Programming & Developer Tooling Foundations
The bedrock every developer needs before any language: the command line, Git and version control, editors and environments, debugging, and how programmes are built and run.
Why foundations come first
It is tempting to jump straight into a language, but the developers who progress fastest are the ones who first become fluent with their tools. Knowing how to move around a filesystem from the command line, track changes with Git, set up a reproducible environment, and debug when things break are the skills you use every single day, in every language, for your whole career. Learning them first means every language that follows is easier.
This programme treats those foundations as a subject worth teaching properly rather than assuming you will pick them up by osmosis. By the end you work the way a professional developer works: in version control, from the command line, with a debugger rather than guesswork, which is exactly the fluency that makes the rest of the journey feel natural instead of overwhelming.
The payoff compounds: every hour spent getting comfortable with the command line and Git early saves many hours of confusion later, across every project and every language you will ever touch. That is why this programme exists as a deliberate first step rather than being left to chance.
The full syllabus
Four modules of five chapters each, sequenced so the material builds cumulatively. The brochure carries a note on what each chapter teaches.
M1 The command line and the machine Ch 1-5 · 5 chapters
- How a computer runs a programme
- The shell, files, and the filesystem
- Navigating and manipulating files from the CLI
- Environment variables and the PATH
- Package managers and installing tools
M2 Version control with Git Ch 6-10 · 5 chapters
- Why version control exists
- Commits, branches, and the working tree
- Merging, rebasing, and resolving conflicts
- Remotes, pull requests, and collaboration
- A sane Git workflow for teams
M3 Editors, environments, and builds Ch 11-15 · 5 chapters
- Choosing and configuring an editor or IDE
- Project structure and reproducible environments
- How source becomes a running programme
- Dependencies and lockfiles
- Formatting, linting, and editor tooling
M4 Debugging and working like a pro Ch 16-20 · 5 chapters
- Reading errors and stack traces
- Using a debugger and breakpoints
- Print, log, and inspect effectively
- Reading documentation and asking good questions
- A first well-structured project
Three ways to take Programming and Developer Tooling Foundations
| Feature | Self-paced | Cohort | Enterprise |
|---|---|---|---|
| Format | Written chapters, video explainers and podcasts | Everything in self-paced, plus scheduled live sessions | Everything in cohort, delivered privately to your team |
| Live sessions | None | Scheduled, instructor-led | Scheduled, instructor-led, private |
| Mentorship | Not offered | Not offered | Not offered |
| Access | Lifetime | Lifetime | Lifetime for every enrolled seat |
| Pace | Entirely your own | Guided schedule with a peer group | Agreed with your desk |
| Tailoring | Fixed curriculum | Fixed curriculum | Sequenced to your markets, systems and governance |
| Best for | Individuals learning around a job | Individuals who want structure and deadlines | Desks building the same capability together |
Get the programme guide
The full chapter list, what each module covers, and how the tiers compare - sent to your inbox as a PDF.
Run this for my desk
Private delivery for your desk, sequenced to your markets and systems. Tell us the team and we will scope it.
Run this for my deskBring this to your desk
Download the full curriculum, or talk to us about running it for a team.