23.01
item · Curriculum / Bridge

Intro to Programming

10 days · instructor-led

Every developer you hire out of university arrives able to write correct code. That’s what a computer science degree certifies, and the certification is real. What none of them arrive with — because there’s no way to get it at school — is any experience of code that has to survive being inherited.

At school, code is written to a standard of correctness that is known before you start. It gets graded, and then it gets thrown away. On a team, nothing a developer writes is ever over. Someone reads it in eighteen months. Someone changes it while they’re on vacation. Someone is trying to work out what they meant at four o’clock on a Thursday with an incident open — and that someone is frequently the original author, having completely forgotten.

Almost everything that separates professional software development from schoolwork follows from that one difference. Why we care about coupling. Why anyone writes tests. Why teams argue about where a thing belongs instead of putting it wherever works. None of that makes sense for code that gets graded and deleted. All of it is obvious for code that gets inherited.

This course is ten days of closing that gap. It is not abstract: every idea in it is discovered inside code we write together, in C# and TypeScript — which also does the level-setting work for developers arriving from Java, C++, or Python. Developers leave knowing more of both languages than they came in with.

But the reason to teach the details is not recall. It’s that you cannot evaluate code you can’t read — and evaluating code is now most of the job. Your own, a teammate’s, a fifteen-year-old service nobody has touched since the last reorg, or a draft that arrived faster than you could have typed it. The developer who can look at working code and say what is this actually for, and what breaks if it isn’t here is the one every team needs. That judgment is what this course is built to start.

Who this is for

Developers in their first year on the job, typically arriving directly from university. No prerequisites beyond having written code somewhere.

Developers headed for teams that don’t work primarily in C# or Angular still get most of the value. The concepts — contracts, coupling, testing, delivery, observability — show up in every stack, and the emphasis flexes with the cohort. A room full of people going to Angular teams gets more Angular; a room with two of them gets enough to know where it fits and who to talk to.

What developers can do afterward

  • Read an unfamiliar codebase and make a small, safe change to it — which is the actual shape of their first several months of work, and nothing like what they were asked to do at school.
  • Look at a piece of code and say what it is for — what would break if it weren’t there, and where it’s tangled up with something it shouldn’t know about.
  • Write tests that describe agreed-upon behavior, and recognize when a test is hard to write because the design is wrong rather than because testing is annoying.
  • Explain how their code gets from their machine to production, and what each stage of that path is protecting against — so that pipelines, containers, and reviews read as leverage rather than as process imposed on them.
  • Tell which layer a rule comes from — whether a thing is a property of the language, a choice their framework made, a convention of their company, or a constraint from outside software entirely. This is the difference between memorizing everything with equal weight and knowing what’s worth memorizing at all.
  • Get useful in an unfamiliar language or framework, and close their own gaps deliberately instead of waiting to be trained.
  • Talk about code with other developers — walk a group through what they built, what they’d do differently, and why they made the call they made. Ask a question in front of peers without it feeling like a confession.
  • Say “I don’t know that” out loud — and treat a gap as information rather than as something to hide until the exam. This one is small to write down and is the single largest change most of them make in two weeks.

What we work on

Organized by topic, not by day. The order flexes with the room.

Telling the layers apart. A frame we return to all two weeks. Any piece of code sits inside several overlapping worlds at once — the language, the framework, the platform underneath both, the conventions of their company, and the rules that come from outside software entirely. New developers receive all of that as one undifferentiated wall of things to be memorized, which is exhausting and hides the useful distinctions. Learning to ask where did this rule come from tells a developer what will transfer to their next project, what to simply look up rather than reason about, and — the part that matters most at work — which rules are decisions that can be discussed and which are not.

The language and the platform. C# and .NET — the type system, records and classes, nullability, collections and generics, delegates and LINQ. TypeScript on the front end. Dense and hands-on, and aimed at fluency rather than coverage.

Code that gets inherited. Coupling and cohesion as the working lens for the whole course. Finding the concepts hiding inside code that’s grown too large. Dependency injection, composition, designing to what you need rather than to what’s available. Writing software before you have all the requirements — and improving it as understanding arrives. Principles show up when the code calls for them, not as a catalog to memorize.

Developer testing. The three kinds we name in this course — system integration, system, and unit — sorted by where a test starts rather than by how much it touches, and why the system tests are where most of the effort belongs. Test-driven development, practiced on katas until the rhythm is real. Test doubles, and the tools for standing in for what your team doesn’t ship. Reading a painful test as a signal about the design rather than about the test.

How a system fits together. HTTP and resource-oriented API design. Building a real API against a real database. An Angular front end talking to it. Backing services, configuration and environments, the twelve-factor ideas, and the trade-offs between calling a service, messaging it, and sharing its data. Stable contracts, and what you owe the people on the other end of one.

How software reaches production. Containers and what one actually is. Orchestration and why clusters look the way they do. Continuous integration and delivery, and what a pipeline is buying you. Observability — logs, traces, metrics — and why you instrument code you can’t attach a debugger to. A short closing orientation to cloud and cloud-native.

Learning as a job skill. How to find your own gaps and build a plan against them. Using an AI assistant to build understanding rather than to skip it — to explain something, to challenge a mental model, to review work already written (see Learning with AI). The position we take raises the standard rather than lowering it: there is no longer a good excuse for not understanding something in a codebase. We’re equally direct about the cost of leaning on it too early, since the intuitions needed to evaluate generated code get built by being wrong and finding out. Keeping durable notes. Knowing which questions to bring to a person.

Through all of it runs one application, carried from domain logic and tests through an API, a database, a front end, a container, a pipeline, and a deployment. Not so that anyone memorizes the steps — so that they’ve seen the whole shape once, and everything they learn afterward has somewhere to attach.

Written reference material covering every topic above is published in the course portal, and developers keep access to it. It exists for a specific reason: so that nobody spends the class transcribing syntax off a screen. “Don’t write that down, it’s on the site” is something you’ll hear most days, and it only works if it’s true.

How the course runs

Day one, before anyone has been taught anything, we build something genuinely hard — a concurrent, multi-threaded HTTP service — and it is deliberately more than anyone in the room can account for. The disorientation is the point. It is far cheaper to have that experience on the first morning, with a guide and fifteen people having it simultaneously, than alone at a desk in month three. It is also precisely how you join a team: a small change to something large you don’t understand yet. Then we slow down and take the pieces apart, and the thing nobody could account for on Monday is something they can explain by Friday.

Every day includes hands-on practice, individually and in small groups — and every exercise ends with the group walking everyone else through it. The developers lead those discussions, not the instructor.

Some of that practice is code. Some of it is design work with no code at all: a scenario, a small group, and an argument about what could be built and what each option would cost. What gets reported back from those matters more than what gets decided — what they’d build, which alternatives they rejected and why, and a list of what they’d still need to find out before being confident. That last list is what separates an estimate from a guess, and producing one is a skill nobody arrives with.

Talking about code with other developers is a distinct skill, one that university coursework never asks for, and it turns out to be a substantial fraction of the job. Two weeks of practicing it daily, in a room where nobody is being graded, is the cheapest opportunity they will ever get to become comfortable doing it.

There is no fixed daily schedule, and that’s deliberate. Each day ends with developers naming the things that didn’t land, and each morning starts by deciding what to revisit. If half the room is fuzzy on something, we spend another hour there and something else moves. A course that ran to a fixed timetable regardless of who showed up would be a worse course — just a more legible one.

Nobody is graded, ranked, or assessed. That sounds like relief and is actually the hard part, because it also means nobody will tell them when they’re behind or when they’re fine. Working that out for themselves is the skill we’re really handing over.

What this course is not

  • Not comprehensive language coverage. It’s enough C# and TypeScript to be useful and to keep learning. The dedicated services and Angular tracks go deep.
  • Not a replacement for the Web API or Angular tracks. It’s the on-ramp to them — the reason those courses land with context instead of cold.
  • Not a graded assessment. No exam, no ranking, no pass/fail.
  • Not a fixed curriculum. The topics are the commitment; the sequence is not.