# 23.01 Intro to Programming

> Ten days for new developers on the difference between code that gets graded and code that gets inherited.

Format: 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](/20.02-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](/21-services/) and [Angular](/22-frontend/) 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.
