Programming & Web Development

Programming looks like one skill from the outside and behaves like five from the inside. What separates them is not difficulty but speed of decay. The knowledge at the bottom was true when today's senior engineers were students and will still be true when they retire. The knowledge at the top has a useful life measured in release notes. Both are real, both are worth having, and what costs practitioners most dearly is mistaking one for the other: pouring months into a framework as though it were a foundation, or refusing to touch any framework at all and ending up technically literate and unhirable. Almost every wasted year in the field is one of those two errors wearing different clothes. The sections below are about the craft rather than the catalogue: which layers deserve slow attention, which deserve fast attention renewed every few years, and how to tell which one a learner is standing on. Python is the one language with a glossary entry of its own, because choosing it is a career decision rather than a syntax preference: it has become the default first language of data and AI work.

• How machines and networks behave. Processes, text encodings, the relational model, and what happens when a request leaves the browser: DNS resolution, a TLS handshake, a web server answering with a status code. HTTP/2 and HTTP/3 changed how the bytes travel, not what the verbs and status codes mean, and SQL has outlived every library written to spare people from learning it. Half-life: a career.
• A language and its idioms. Syntax, data structures, the standard library, error handling, the package ecosystem and its traps. It moves, but slowly and with warning: Python 2 reached end of life in January 2020 after years of announced deadlines, and JavaScript's route from callbacks to promises to async/await took most of a decade. Half-life: a decade.
• Engineering practice. Version control, tests that fail when you break something, review that surfaces structural faults instead of spelling, small changes, and reading code you did not write. This layer barely moves; only the tooling beneath it turns over, and even there answers hold for years: Git won version control, containers became the ordinary unit of deployment. Half-life: a career, disguised as a chore.
• Frameworks and libraries. React introduced hooks in 2019 and a generation of class-component tutorials aged overnight. Redux went from near-mandatory to niche once the framework and the data-fetching libraries absorbed what it was for. Webpack configurations people were proud of were deleted without ceremony when Vite made them unnecessary. Half-life: three to five years.
• Products, APIs and versions. A specific SDK, a cloud console, a model endpoint, this quarter's deprecation notice. Necessary, usually what you are paid to operate, and worth exactly one afternoon of reading at a time. Half-life: months.

Slow layers first, fast layers on purpose

Start at the bottom two and learn them together: one language, plus enough of the machine underneath it to explain where your program's data lives and how it got there. A year is not too long. Pick Python if your interest points at data, automation or AI, JavaScript if it points at interfaces. Either works; alternating between them every six weeks works for nobody. What ruins this stage is the illusion of progress: it compiled, it ran, it printed the thing, and none of that tells you whether you understood it. The diagnostic is whether you can change the program without fear. The layer beginners most often treat as optional is the third one, and it is the layer that hiring filters on. Version control past commit and push, a test suite that catches a regression, the habit of small reviewable changes, and the nerve to open an unfamiliar codebase and find the part that matters. None of it is glamorous, and all of it transfers to every job a developer will ever hold. It gets skipped because its value only becomes visible when something goes wrong, which is necessarily after the decision to skip it. Frameworks come late, and deliberately. Late is not never: job descriptions are written in the fast layer, and a developer who refuses to go there is arguing with the market rather than working in it. Learn one framework properly, ship something real with it, and treat the second as a translation exercise rather than a fresh education. The technology and programming course sections route what to study in what order. Where a credential is worth anything to a developer it is operational rather than linguistic, which is why DevOps and Kubernetes exams turn up on developer CVs and language certificates do not.

Generated code moved the bottleneck

Assistants changed exactly one variable: how fast plausible code appears on the screen. They changed nothing about what makes code correct. The program still has to hold under inputs nobody thought about, still has to fail in a way somebody can diagnose at two in the morning, and still has to mean the same thing next quarter when a dependency moves. None of that was ever a function of typing speed, which is why writing less of the code yourself frees less time than the demos suggest. Notice where the help is strongest. An assistant is most reliable on abundant, stable, well-documented material, which is precisely the bottom layers a patient learner could have acquired anyway, and least reliable on the layer that changed most recently, which is exactly where people want to lean on it. It hands over yesterday's idiom, because yesterday's idiom is what most of the written record contains. The failure mode from the inside is undramatic. A developer accepts a function that looks right and passes the obvious case, accepts the next because the first was fine, and somewhere in week three is maintaining a codebase they have never read. Debugging it costs more than writing it would have. The value therefore moves toward a short and specific list: stating requirements precisely enough that correct has a definition, writing the test before the implementation so acceptance is not a vibe, reading diffs quickly and with suspicion, knowing which parts of a system must never be wrong, and being able to operate what was shipped. Every one of those lives in the slow layers. The tooling got faster at the part that was never the hard part.