I'm trying to create a video game, but it really frustrates me to spend 5 hours learning how to use the engine—especially its interface—and on top of that, I don't find object-oriented programming fun. However, I don't mind at all learning other skills (coding, pixel art, game design, etc.). That’s why I need an answer to my ultimate question: How do I create a video game without a game engine? I’m looking for an easy and accessible solution. I have absolutely no idea where to start, so please explain it to me as if I were 10 years old.

I'm a bit confused about something and wanted to hear honest opinions from people who have experience in software development.

I've been thinking about building projects using AI. My approach is to go through every step, understand what each line of code does, learn the basic concepts behind the technologies being used, and try to understand the overall working of the project.

However, I'm not necessarily writing all the code myself from scratch. AI is doing a lot of the actual coding, while I'm learning from the generated code.

My plan is to put these projects on my resume, but I'm worried about whether this is actually a good way to learn and whether it will be enough for interviews. I know I'll still need to practice DSA and coding fundamentals separately.

For those of you who have gone through interviews or work as developers, what do you think?

- Is understanding the code line by line and being able to explain the project properly enough to put it on a resume?

- Would you consider this a valid way for me to learn, or am I missing something important?

I'm not trying to take shortcuts. I just want to use AI effectively without fooling myself into thinking I know more than I actually do.

I'd appreciate honest advice.

I’m now building a simple to-do app in Flutter. The problem: when I tap (Add), the task gets added to the list (I checked in the console), but the screen doesn’t update until I hot restart.

Code :

void addTask() {

tasks.add(controller.text);

controller.clear();

}

What am I missing? Any help would be appreciated

Im curious because i know about web coding on a computer but never really figured it out what smart phones use.

So I am working on making my own Personal AI for an sci-fi generation ship themed bedroom but it looks jagged and smudged, how do I fix this?

Photo of my ai

My code is bellow:

import tkinter as tk

import math

# ==========================

# ASUS_v1

# ==========================

root = tk.Tk()

root.title("ASUS_v1")

root.geometry("1000x700")

root.configure(bg="black")

canvas = tk.Canvas(

root,

width=1000,

height=700,

bg="black",

highlightthickness=0

)

canvas.pack(fill="both", expand=True)

angle = 0

def draw():

global angle

cyan = "#00FFFF"

canvas.delete("all")

# ==========================

# TITLE

# ==========================

canvas.create_text(

500,

50,

text="ASUS ONLINE",

fill=cyan,

font=("Consolas", 24, "bold")

)

cx = 500

cy = 400

# ==========================

# OUTER RING

# ==========================

canvas.create_oval(

250,

150,

750,

650,

outline=cyan,

width=3

)

# Rotating markers

for i in range(12):

a = math.radians(

angle + i * 30

)

x1 = cx + math.cos(a) * 220

y1 = cy + math.sin(a) * 220

x2 = cx + math.cos(a) * 250

y2 = cy + math.sin(a) * 250

canvas.create_line(

x1,

y1,

x2,

y2,

fill=cyan,

width=2

)

# ==========================

# INNER RING

# ==========================

canvas.create_oval(

325,

225,

675,

575,

outline=cyan,

width=2

)

# ==========================

# CENTER CORE

# ==========================

canvas.create_oval(

450,

350,

550,

450,

fill=cyan,

outline=cyan

)

canvas.create_text(

500,

400,

text="ASUS",

fill="black",

font=("Consolas", 10, "bold")

)

# ==========================

# SYSTEM PANEL

# ==========================

canvas.create_rectangle(

20,

120,

180,

360,

outline=cyan,

width=2

)

canvas.create_text(

100,

150,

text="SYSTEM",

fill=cyan,

font=("Consolas", 12, "bold")

)

# ==========================

# PROJECTS PANEL

# ==========================

canvas.create_rectangle(

820,

120,

980,

360,

outline=cyan,

width=2

)

canvas.create_text(

900,

150,

text="PROJECTS",

fill=cyan,

font=("Consolas", 12, "bold")

)

# ==========================

# ANIMATION SPEED

# ==========================

angle += 0.5

root.after(25, draw)

draw()

root.mainloop()

memory for the AI: {
    "user_title": "Sir",
    "voice_enabled": true,
    "hardware_thresholds": {
        "cpu_percent": 85.0,
        "ram_percent": 90.0
    },
    "protocols": {
        "house party": {
            "description": "Launch primary workstation suite",
            "paths": [
                "C:\\Windows\\System32\\calc.exe",
                "C:\\Windows\\notepad.exe"
            ]
        }
    },
    "dynamic_rules": {
        "run diagnostic": "audit_logs",
        "system status": "check_telemetry"
    }
}

Long story short I graduated college with a 3.8/4.0 gpa but I never did any learning outside of class subjects or did any projects on my own which I regret deeply and wish I could do it all over again because I quickly realized what is taught in college is very limited and elementary and you have to do a lot of self learning to become an actual developer.

What is the fastest way to gain the knowledge and experience I should have gained in college? Any books I could read, guides I could follow, videos I could watch? Anything?

I'm a junior undergrad CS student. I've learned a bit of everything but specialize in nothing. I want to specialize and work in cyber security in the future. Can you recommend free resources I can use to specialize in cyber security? I prefer something structured like a course or textbook. Also, recommend any resource for projects where I could apply what I learn.

So I'm modding games and I am making a mod for Balatro, which uses LUA. I tried to look for books at the library but all I could find was modding bocks for Roblox (NO TO THAT).

Can anyone point me in the right direction, please?

Hey everyone!

I'm a developer with some professional experience, mostly working with Java and Spring Boot. I can build APIs and work on real projects, but I still have plenty to learn about software architecture, system design, and more advanced backend concepts.

I studied HTML, CSS, and JavaScript in the past, but after focusing on backend for a while, I got rusty. I also never got particularly comfortable with CSS or JavaScript.

For the past couple of months (on and off), I've been trying to refresh my HTML/CSS knowledge. I enjoy building interfaces, but I'm starting to feel stuck in an endless cycle of reviewing fundamentals.

I want to learn JavaScript and React, but I'm also really interested in exploring things like Docker, Kubernetes, cloud, and more complex software engineering topics. Sometimes I feel like I'm spending too much time reviewing things instead of actually building something interesting.

I've been thinking about picking a full-stack project, starting with a small MVP, and gradually making it more complex as I learn.

But I'm unsure how to approach it. Should I spend time planning the architecture and modeling everything myself, or just start building and figure things out along the way? How much should I rely on AI for guidance without becoming dependent on it?

For those who've been in a similar situation, how did you balance learning fundamentals, exploring new technologies, and building actual projects?

I don't want to rush through topics just to say I know them. I want to actually understand what I'm doing and become a better developer.

I'd appreciate any advice or experiences you could share!

I'm in my second year of a BCA (AI/ML) in India. Our college curriculum covers programming theory but barely any practical Python, so I've been self-learning on a 12-week plan: Python basics → NumPy → Pandas → Matplotlib/Seaborn → statistics → portfolio projects.

I'm about a week in and already torn. One camp says depth wins: get genuinely good at Python + data analysis and build a few real projects (I've built a couple of small Telegram bots, which taught me more than any lecture). The other camp says Indian internships screen for breadth: some web dev, some SQL, some ML basics, otherwise you don't get shortlisted.

For those of you who actually got internships or junior roles from a background like this: did depth in one lane help more than a bit of everything? What did your first portfolio project look like, and what would you skip if you started over?

I have very little knowledge about programming but I want to make a program that can take values from an excel sheet and copy them to a website, what I want to know Is which programming language can I use to make It?

I'm looking for architectural advice rather than help debugging a specific function. This is a private project, so I can't share the complete source code, but I've included detailed specifications, measured performance results, memory usage, and the engineering changes we've already tried. I'm happy to provide small, anonymized code examples if someone needs them to investigate a specific issue.

TL;DR: I'm building a private, local Python application that processes large amounts of time-series data, maintains historical analytical State, produces reports, and independently verifies that nothing has been corrupted or lost.

The application works on small datasets, and many of its correctness and performance tests pass. However, I'm trying to prove that the entire system can operate within a 1 GiB aggregate memory limit, preserve complete historical information, and recover from crashes within 60 seconds.

I've spent weeks working through this with AI coding assistants. We've made substantial improvements, but I feel like we're chasing architectural issues one at a time instead of solving the underlying problem.

I'm looking for experienced human developers who can suggest a more efficient approach.

I'm on a budget, so I would particularly appreciate practical solutions that don't involve buying expensive hardware or moving everything to cloud infrastructure.

1. My computer and environment

Here are the hardware and software specifications I have confirmed from the diagnostic reports:

The computer has considerably more than 1 GiB of physical RAM. The 1 GiB limit is an application-level resource requirement, not the total RAM installed in the computer.

The requirement includes the main application and the workers needed for verification and recovery. Moving processing into another process doesn't exempt its memory.

There's also a separate 32 MiB discretionary-cache limit.

I'm open to hearing whether these resource targets are realistic, but I'm especially interested in architectures that could meet them without sacrificing correctness.

2. What the application does

Without getting into the proprietary purpose, the application:

• Processes incoming data across three time intervals: 1 minute, 5 minutes, and 15 minutes.
• Maintains a complete, causally ordered historical record.
• Performs incremental calculations using current and historical data.
• Tracks evolving analytical State across thousands of updates.
• Produces evidence, reports, snapshots, and durable journal entries.
• Uses immutable, content-addressed references to historical information.
• Independently checks the integrity of data and calculations.
• Must recover the latest valid committed State after a crash, without losing acknowledged durable events.

It is currently a read-only analytical system. It doesn't need a transaction-execution engine or cloud deployment to accomplish its purpose.

The challenge is retaining and verifying complete historical information without repeatedly loading or reconstructing all of it.

3. How much data are we talking about?

The main historical workload represents 60 sessions.

The system must preserve the analytical State, evidence, and reports associated with those processing attempts.

An earlier test retained all 29,184 data records but grouped them into 992 processing captures rather than executing every scheduled assessment individually.

That test produced approximately:

• 938,669 independently audited storage nodes.
• 166,307 evidence derivations.
• 2,979 State records.
• 992 capture reports.
• Zero failures in its independent storage-integrity audit.

However, we subsequently determined that 992 batched assessments do not prove the same workload as approximately 29,196 individual scheduled attempts.

That larger per-assessment qualification is still outstanding.

4. The performance requirements

These are the principal limits we're trying to satisfy:

The application also processes bounded current input views while retaining full historical continuity separately.

I realize some of these are demanding constraints. They're intentional, but I'd welcome informed criticism of their design.

5. What we've already changed

This was originally much less efficient. We've made several major architectural changes.

Historical storage and data structures

We moved away from repeatedly constructing and serializing massive historical structures on every update.

The current design uses immutable content-addressed nodes, authenticated references, persistent collections, incremental updates, and shared historical prefixes.

We replaced repeated historical-list expansion with reference-based representations. Analytical modules preserve their required history through authenticated continuation structures instead of passing enormous expanded objects between components.

Database and storage

We use SQLite-backed content storage and append-only journal structures.

We've added immutable sealed baseline segments and private copy-on-write overlays for separate verification branches.

Instead of copying an entire historical database for every test branch, the branches share verified read-only segments and maintain private writable metadata.

Crash recovery

We've implemented per-commit recoverable generations, durable expected-tip tracking, pending and acknowledged commit handling, and independently controlled generation pins.

The verification system maintains hash-chained evidence and independently held rollback protection.

It checks for missing, substituted, rolled-back, and inconsistent information.

Recovery reconstructs the appropriate State and checks that it matches the committed history.

Independent verification

We have a separate verification process that checks data integrity and committed calculations.

There's also a replay certifier that reconstructs the processing history to confirm the committed results are correct.

This is where the biggest memory concern has appeared: the producer and replay certifier may need substantial analytical working State at the same time.

Replay-certifier memory improvements

We recently implemented a bounded verification-only replay path.

Instead of keeping every historical record decoded, it streams authenticated references, retains a limited working window, and retrieves older information when required.

On small inputs, the historical per-bar representation decreased from approximately 1.42 KB to 0.33 KB of resident data, excluding the bounded window.

However, this does not necessarily eliminate the memory needed for the actual analytical State.

Other improvements

We also implemented incremental calculations for a separate relationship-analysis path, repaired correction/reset handling, improved event ordering, eliminated repeated full-history validation, and added reference-based report construction.

Most of these changes have passed focused correctness tests.

6. Tests we've already passed

We've run a substantial number of tests. I don't want to throw away this work or rerun everything unnecessarily.

Historical processing performance

An earlier integrated test completed:

• 21 timed captures.
• All captures between approximately 1.07 and 2.33 seconds.
• The slowest tested group finished approximately 22.1 seconds after its interval closed.
• Three cold restorations completed in approximately 2.2, 6.1 and 24.4 seconds.
• A recorded peak private commit of approximately 786 MiB.

Those timings passed the limits for that particular test and source version.

But that test used a batched historical workload and an earlier implementation. It is not proof that the final full scheduled workload passes.

Correctness and integrity

We have passing focused tests covering:

• Legacy-versus-new analytical calculations.
• State and historical evidence equivalence.
• Crash recovery and exact continuation.
• Correction/reset behavior.
• Developing and confirmed analytical results.
• Five-layer offline processing/replay equivalence.
• Independently authenticated generation pins.
• Missing, substituted, forged and rolled-back data rejection.
• Durable acknowledgment and recovery after interrupted commits.

A correction-depth test covered 1,164 bars without analytical differences. Developing-result tests included more than 15,000 comparisons.

Replay-certifier comparison

We compared the original full replay certifier against the new bounded-memory version over four different small history batches.

Their committed results, recovered State, identity roots, and generation checks were equal.

The new bounded version also passed its focused integrity tests.

7. The memory results that have us stuck

This is the main reason I'm posting.

Historical large-workload measurement

One earlier test reported approximately 786 MiB peak private commit.

But the testing process also contained the full 60-session input fixture, processing code, restored historical State, and other supporting objects.

We therefore cannot treat 786 MiB as the main application's own operating memory.

Fixture-only measurement

We ran a separate fresh process that loaded only the existing 60-session input fixture.

It loaded 29,184 records.

Results:

• Before application-related imports: 8.6 MiB.
• After imports: 14.1 MiB.
• After fixture construction: 78.6 MiB.
• Increase during fixture setup: 64.5 MiB, including lazy imports and allocator overhead.

This was one measurement in a separate process.

We cannot simply subtract 64.5 MiB from the earlier 786 MiB measurement, because their memory lifetimes, allocations, and workloads were different.

Small multi-process recovery test

We also tested the producer, replay certifier, independent verification authority, and byte-provider workers under a kernel-enforced aggregate memory cap.

The earlier full replay arrangement reached approximately 343 MiB aggregate high-water.

After the bounded replay-certifier change, a comparable small test reached approximately 353 MiB.

Both stayed below the 1 GiB cap and recovered the exact expected State.

However, the small test started certification from an initial empty history, so it didn't exercise the deep historical restoration that the memory improvement targets.

The new design is correct on the tested inputs, but its maximum-history memory savings are not measured.

The concern

At maximum historical depth, the producer and replay certifier may each retain substantial working State.

If both have to remain resident simultaneously, they could exceed the aggregate 1 GiB limit.

We don't have a measured maximum-depth aggregate number yet. I don't want to spend hours rebuilding historical test data just to discover another predictable problem.

8. Storage concerns

The complete future historical qualification has been estimated at approximately 133 GB of peak storage, including:

• Historical processing data and committed generations.
• Private test overlays and sealed baseline snapshots.
• An independently readable complete export.
• Verification indexes and evidence.
• SQLite temporary/scratch storage.

This is only a projection. Actual peak disk use has not been measured for the full workload.

With roughly 155–160 GiB free, the storage margin is uncomfortably small.

I considered purchasing a 5 TB external hard drive for approximately $220, but I'm reluctant to spend money until I know whether it will solve anything.

I understand an external HDD would increase storage capacity, not available RAM, and may make database-intensive workloads slower.

I would rather improve the software first if possible.

9. Another challenge: complete historical relationships

A separate, more demanding analytical mode creates relationships between historical evidence objects.

Its relationship set can grow quadratically with the number of eligible objects.

One worst-case projection reached multiple terabytes of relationship data, but that assumes all historical evidence is simultaneously eligible. That assumption has not been established and isn't the configuration of the normal observational workload we're currently qualifying.

That mode has passed small correctness tests, but its maximum-depth capacity remains unqualified.

I'm including this because I want to avoid architectures that solve memory problems merely by creating an equally enormous disk problem.

I'm not asking to redesign that separate mode as part of the immediate memory fix.

10. My questions for experienced developers

1. How would you establish the true memory usage of the application versus its test harness?

I'm using Windows private committed memory and Job Objects, not simply Task Manager's displayed RAM percentage.

What techniques would you use to attribute retained and transient memory to specific Python objects, SQLite caches, imported modules, historical State, and verification workers?

2. How would you design independent replay verification without keeping two complete analytical engines in memory?

The certifier must independently re-derive all required committed results. It cannot simply trust stored output hashes or skip historical dependencies.

Would you recommend streaming, authenticated checkpoints, incremental semantic verification, memory-mapped storage, bounded per-owner State, a different worker topology, or another approach?

3. Is there a better way to handle the verification workers under a strict aggregate memory limit?

The producer must remain resident. The verification process must not lose independent trust.

How would you structure scheduling and memory ownership without creating an unacceptable certification backlog or violating the 60-second recovery requirement?

4. How would you measure maximum-depth working memory without reconstructing the full workload?

Can existing persisted references and snapshots be used to construct a representative depth-point measurement, provided the identities and analytical State remain valid?

How would you avoid a synthetic test that looks small but fails to represent real historical State?

5. Are we using Python and SQLite appropriately for this workload?

Would you keep Python and optimize the data structures, use SQLite differently, move a specific bottleneck into a native extension, or consider something else?

I'm not interested in rewriting the entire application without a clear technical reason.

6. Am I approaching this problem incorrectly?

We've spent weeks replacing inefficient data structures, adding persistent references, tuning recovery, and running tests.

The changes have helped significantly, but the qualification process keeps exposing another problem.

What architectural assumption would you challenge first?

11. Budget and what I'm looking for

I'm building this privately on my own computer, not with a corporate infrastructure budget.

I can't keep purchasing additional hardware, expensive services, or spending days rebuilding the same historical fixtures.

I'd prefer a solution that:

• Preserves complete historical accuracy and causal State.
• Doesn't delete required records merely to pass a test.
• Maintains independently verifiable integrity and crash recovery.
• Avoids enormous in-memory copies and unnecessary database duplication.
• Makes efficient use of the hardware I already own.
• Can be tested incrementally without repeatedly rebuilding everything.

I'm not asking anyone to write the application for me. I'm looking for experienced developers willing to point out what I may be overlooking.

If you were taking over this project tomorrow, what would you inspect first, what would you measure, and what would you change?

I would genuinely appreciate specific technical suggestions, especially from people who have built Python/SQLite event-processing systems, persistent historical databases, or independently verified data pipelines.

apologies if this has been asked before , im trying to learn java from scratch and ive gotten a good bit of progress.
Im coming from a python heavy background and sometimes reading code can get a bit confusing. I'm looking for any tips or mental maps to read any java code and understand it the entry points etc.

For some context, I am a complete beginner programmer who loves programming more than anything. I have always dreamt of building my own social media network, just to understand how it works and to gain experience.

Now, I have found out that there are various open-source projects like Lemmy, Bluesky, Mastodon, etc.

Now my question is, which one should I choose to understand its inner workings? I personally want to build a platform like Reddit (a community-driven network).

Please note: I haven't even explored anything yet. I just know some fundamentals. I am asking out of curiosity, which definitely motivates me and gives me the inspiration to work hard.

Really going through hard times with this shit tho

Can you recommend me some books or resources for learning statistics and applying it to C++

So far I am using Khan Academy and youtube, but do y'all have any other resources?

I want to build a webapp for social media mockups (instagram, twitter, imessage, facebook). What language is best to use? I consider myself very much of an intermediate level when it comes to html and a little bit of a beginner with javascript, also a graphic designer with slight experience in UX design, so I know what kind of assets to utilize. Can anyone help me what workflow to utilize for this? I'm planning to do this over the course of Christmas break.

Other info about my planned project:

• I want users to be fixed per each app (pictures, names, etc.,)
• I want to prioritize easy GUI/UX
• I want users to be able to save and download a screenshot with a floating button of some sort (like assistive touch) and ensure they won't get blurry images
• If possible I want some sort of like a phone interface for the webapp

I don't want to use AI, so here I am asking and I also want to develop skills for my future job. Any suggestion or recommendations will be very much appreciated! Thank you <3

Also, if you're thinking this is for a socmed au for a certain ship, yes, it is very much so. lmao.

So im learning python by watching youtube videos(started watching bro code) but i want to know am i in the wrong direction.Any help please

So I have been learning Python for around 4 hours and I just finished this and I would want to know if it's good or if it's just okay.

again = "yes"

while again == "yes":

print("create your character: ")

# sex

sex = input("sex? ").strip().lower()

while sex not in ['male', 'female']:

sex = input("try again, you misspelled male or female: ").strip().lower()

if sex == "male":

print("hello boyyy")

else:

print("helloooo girl")

# age

age = int(input("what is your age: "))

while age < 18:

age = int(input("try again "))

# name

name = input("what is your name: ").lower().strip()

print("hello " + name)

# height

height = int(input("height in cm "))

if height >= 180:

print("tall person eh?")

else:

print("nice.")

print("next questions")

# build

build = input("what is your build. skinny. fat. muscular. ").lower().strip()

while build not in ['skinny', 'muscular', 'fat']:

build = input("try again. that was not an option ").lower().strip()

if build == "skinny":

print("interesting choice... " + name)

elif build == "muscular":

print("perfect choice especially for a man")

elif build == "fat":

print("HAHAHA FATSO HAHAHA")

# stats

print('____')

print(' ')

print('stats for: ' + name)

print('age:', age)

print('height:', height)

print('sex:', sex)

print('build:', build)

print('____')

again = input("create another character? Yes/No: ").strip().lower()

while again not in ['yes', 'no']:

again = input("answer using Yes or No: ").strip().lower()

print("Goodbye!")

Hey everyone!

I’ve learned some basic Python and Dart, but never really went deep or built any significant projects.
I’m looking for a course or book that takes things slowly and focuses on truly understanding programming concepts rather than just teaching syntax.

A lot of beginner courses explain how to do something, but rarely go into the what and why behind it.

I’ve been considering:
How to Design Programs (HtDP)
Structure and Interpretation of Computer Programs (SICP)
University of Helsinki’s Haskell MOOC
University of Helsinki’s Java Programming MOOC

Which of these would you recommend for someone in my position? I’m also open to other suggestions.

I learned java through a class in my school (AP Computer Science A if you know what that is) and I would say that I'm at a intermediateish level, maybe a low intermediate. what would be the next thing for me to learn and practice if I want to get better at programming and continue practicing? Should I learn a different language or continue going deeper with java?

Hey Guys I entered a college that depends on programming in a university because of my scholarship but I feel like I am stuck in a limbo any advice they teach us c++ and i need to know what is your secret that made you pros in programming

Hello, so I really need some directions because I’m starting to feel really bad about it.
I left High School with really good grades and I’m at University rn, the first year was a complete mess, I felt like everything was too hard for some reason, I couldn’t pay attention to most of the classes and that made me fail 2 classes (C++ and Java) I started to feel really demotivated because even the classes that I passed like JS, it was kinda on the edge so ye.
Right now I’m in the second year, and I’m trying to recover the classes that I failed on the first year and it’s not getting easier, I feel like in C++ I’m a little better, but not as I thought I was, in C# I’m having the same problems as Java and I don’t really know what to do.
I don’t really have a plan B, as a kid I always thought I wanted to be a programmer when I was older (I’m 21 btw) and I choose to take a Programming Course in High School because of it and it went really well, but now I’m having a lot of problems and I don’t know what to do, it feels like I can’t save any information on my brain and use it properly since I changed from the High School to the University, and I feel like I became kinda lazy.

Anyways, give me your opinions and be as harsh as you think you should, I’m taking everything into consideration, but I need to do anything about this.
And don’t get me wrong, I really love programming, every time that I’m into the project or something and I understand, it’s really good, but since I can’t understand anything it’s being a hassle lately.

Thank you for reading till here!

We often hear the generic "focus on the fundamentals" advice. For some reason I believed that advice even before I understood why it matters; it just sounds like common sense, and fortunately it turned out to be good advice. I realized this after taking multiple free OSSU courses and reading a couple of books. Around 4 years into the field. I also realized it when I started to learn web development and had an internship.

Here is the key idea: Two different people can study the same material from the same video or book, and leave with completely different experiences, because of the existing knowledge they have.

"Previous knowledge" makes learning new things much more fun, because you're not starting from scratch every time! When we haven't internalized the key fundamental "chunks of knowledge", every new problem we face feels completely new to us, so it feels much more painful. But what's worse is that we learn less from the experience. Without a well-organized base of knowledge, new information has no meaningful place to attach to, so, much of it is quickly forgotten.

There are three things with which good fundamentals help you:

1. They allow you to extract SO MUCH from ANYTHING you learn.
2. They guide you to ask the right questions and learn faster.
3. Odd things feel odd to you.

For example, after studying OS and networks, I internalized the idea of a server. It actually took me quite long to fully get it; here is a casual explanation:

a server is a process that has an open socket (at a specific port). But to grasp this, I had to understand what a process is. Luckily I learned from an OS book. (OSTEP). It's an "abstraction" of a running program. When you run a program, the OS wants to keep track of what's going on, so each running program is represented in the OS as a process with an ID and status. it's pretty much like an object with some fields, They're basically in an array. Each time you run a program, a process starts running. i.e., added to the array, when you kill a process, it is stopped and removed from the table, etc...

(the concept of abstraction in itself is part of CS fundamentals and it took me some time to interalize and start to see it everywhere, it's amazing how a single word can capture so much meaning)

but then what's a socket? it's the abstraction of the network stuff, it's an API (= a bunch of functions, provided by the OS) you can call as a developer in your code so the process (running program) can communicate with the network. You don't need to know much about networks and TCP, just input and output of the API. So basically the server must have some sort of socket that clients can connect to and send some bytes to it. The server understands those bytes, usually a string based "protocol", then responds accordingly.

This is just some CS fundamentals, nothing fancy, but now that I've spent around a year studying web development, it was all there (but in different shapes and flavors). Everything is built over the fundamental concepts and It's so much fun.

1. This allowed me to learn way more from the resources I was learning from, I kept digging: "wait, where is the process", "how does this work, what happens when I use docker run". I used ssh for the first time "but wait, how is this happening, there must be an ssh process running on the server or something" or something, "hey, where is the database process?", and you keep digging.
2. It's related to the previous point, but having good fundamentals helps you ask good questions that will help you fix problems faster and also deepen your understanding.
3. sometimes you face something new that makes you question what you've learned before, they challenge the mental model you made. You'd feel surprised, and it broadens your understanding. It's hard to notice such things without having the fundamentals.

And this doesn't mean we need "perfect" fundamentals, I'm aware of some of the gaps I have and I plan to work on them, but we just need to internalize the key concepts. If you haven't mastered the fundamentals yet I highly recommend the following.

• Build a simple shell (it's really simple, a shell is just a program you run, a python script would do it) understand how the shell runs other programs, understand what PATH is. I highly recommend python so you can focus on the OS concepts.
• Build a simple HTTP server. Jim Kurose has recorded lectures explaining the fundamentals of computer networks, the first two chapters are far more than enough for most people, after that you can easily build a simple HTTP server. If you want to spice it up add some multithreading. He has some starter code too.

These two projects had the highest ROI I've had while learning. They even made me fall in love with CS.

Hello everyone! I need some serious advice from experienced coders and developers.

I’ve been trying to learn coding for about a year now, and today, while learning about WebSockets, a thought popped into my mind. I realized that I wasn’t really learning how WebSockets work; I was just following the steps to implement them. I know I’ll probably forget the syntax and most of the details within a few days.

So, my question is: Is this the right way to learn? Should I be investing my time in learning libraries and building projects, or should I focus more on understanding the programming language itself, learning algorithms, and figuring out how to solve problems on my own?

I’m confused about this. What’s the point of learning to use libraries if I’m going to forget most of the syntax and implementation details anyway?

I’d really appreciate some advice from experienced developers who have been through this phase. How did you approach learning to code, and what would you recommend to someone in my position?

Thanks in advance!