Intro to Software Development — from punch cards to your own solo stack

A guided path from "what even is software?" to shipping your own program. Start with the story of how computing got here — the hardware, the languages, and the people — then build a working model of how modern languages differ and what they're good (and bad) at. Learn the principles and patterns that separate code that lasts from code that rots, the systems teams use to ship, how to choose the right language for a job, and finally how to assemble your own solo development stack, workflow, and distribution strategy. Examples lean on real-time and radio software — the kind of streaming, signal-crunching code behind GopherTrunk.

Start lesson 1 →Jump to glossary

“Software development” sounds like a single skill, but it’s really a stack of them — a bit of history, a working model of how languages differ, a handful of durable principles and patterns, the systems teams use to ship, and the judgement to pick the right tool for a job. This path builds that stack one short lesson at a time, starting from absolute zero and ending with you shipping your own program.

Who this is for. Complete newcomers are welcome — no prior coding required. If you already write code, use the module list to jump to the parts you’re missing: language internals, design patterns, choosing a language, or going solo. Every lesson is self-contained and cross-linked, so you can read straight through or hop around.

How the path works. Seven modules move from story to practice. We open with how computing got here — the hardware, the languages, and the people. Then we dig into what actually separates modern languages, the principles and patterns that keep code alive, and the systems teams use to ship. Module 6 is a complete toolkit for choosing the right language for a project, and Module 7 walks you through assembling your own solo development stack, workflow, and distribution strategy. Examples lean gently on real-time and radio software — the streaming, signal-crunching kind of code behind GopherTrunk — so abstract ideas stay concrete. Mark lessons complete as you go; your progress is saved in your browser. New here? Start with lesson 1: What is software?

Module 1 — A Brief History of Software

Where software came from: the hardware, the first languages, the pioneers, and the cheap compute that put a radio receiver inside a program.

  1. What is software? Hardware vs. software, the stored-program idea, and what "code" really is — the one idea everything else builds on. beginner 8 min
  2. From looms to microprocessors The hardware story — Babbage and Lovelace, ENIAC, the transistor, and the microchip that put a computer on every desk. beginner 9 min
  3. From machine code to high-level languages Why we stopped writing 1s and 0s — assembly, FORTRAN, COBOL, LISP, and C, and what each one made possible. beginner 10 min
  4. The people who built programming Lovelace, Turing, Hopper, Ritchie, Kay, and the engineers whose ideas you still use every day. beginner 9 min
  5. PCs, the internet & the age of cheap compute From mainframes to the cloud and the edge — and how falling compute costs made software-defined radio possible. beginner 9 min

Module 2 — Modern Programming Languages

The families languages fall into, how they run, and the capabilities, trade-offs, and security properties that set them apart.

  1. Paradigms & language families Imperative, object-oriented, functional, and declarative — the big families and how a language can belong to several. beginner 9 min
  2. Compiled, interpreted & JIT How source code becomes something a computer runs — and why the answer shapes speed, portability, and tooling. beginner 9 min
  3. Type systems & safety Static vs. dynamic, strong vs. weak — what types catch, what they cost, and why it matters for reliable code. intermediate 9 min
  4. Memory — manual, GC & ownership Stacks, heaps, garbage collection, and Rust-style ownership — and why memory model is the deepest language difference. intermediate 10 min
  5. Concurrency & parallelism Threads, async, goroutines, and actors — doing many things at once, the way streaming radio data demands. intermediate 10 min
  6. Language-level security Memory safety, undefined behaviour, and the software supply chain — how your language choice changes your attack surface. intermediate 9 min

Module 3 — Software Development Principles

The timeless, language-agnostic ideas that make code readable, changeable, and robust instead of a tangle nobody dares touch.

  1. Writing readable code Naming, small functions, and comments that earn their place — code is read far more often than it's written. beginner 8 min
  2. DRY, KISS, YAGNI & separation of concerns The four maxims that fight complexity — repeat yourself less, keep it simple, and don't build what you don't need yet. beginner 8 min
  3. SOLID & object-oriented design The five principles that keep object-oriented code flexible — explained with plain examples, not jargon. intermediate 10 min
  4. Abstraction, coupling & cohesion Good fences make good modules — hiding detail behind interfaces so parts of a program can change independently. intermediate 9 min
  5. Errors, edge cases & defensive programming Handling failure on purpose — because real-world inputs, like a noisy radio channel, never behave. intermediate 9 min

Module 4 — Software Design Patterns

Named, reusable solutions to problems that come up again and again — including the streaming and plugin shapes signal software lives on.

  1. What is a design pattern? Where patterns came from, how to read one, and the anti-patterns that signal trouble. beginner 8 min
  2. Creational patterns: factory, builder, singleton Patterns for making objects — flexibly, step by step, or exactly once. intermediate 9 min
  3. Structural patterns: adapter, facade, decorator Patterns for composing objects — wrapping, simplifying, and extending without rewriting. intermediate 9 min
  4. Behavioral patterns: observer, strategy, state Patterns for how objects talk and decide — swapping algorithms and reacting to change. intermediate 9 min
  5. Concurrency & streaming patterns Pipelines, producer/consumer, and pub-sub — the patterns a real-time DSP chain is built from. advanced 10 min
  6. Architecture patterns: layered, event-driven & plugins The big-picture shapes — including the plugin architecture that lets a scanner add a new decoder without a rewrite. advanced 10 min

Module 5 — Development Systems & Strategies

How software actually gets built and kept alive: life cycles, version control, testing, automation, and fighting technical debt.

  1. The software life cycle — Waterfall to Agile The stages every project moves through, and the methodologies — Waterfall, Agile, Scrum, Kanban — teams use to manage them. beginner 9 min
  2. Version control & collaboration Why every project lives in version control, how teams work together without stepping on each other, and where to go deeper. beginner 8 min
  3. Testing — unit, integration & beyond The kinds of tests, what each is for, and why signal-processing code needs them most of all. intermediate 10 min
  4. Build systems, CI/CD & automation Turning source into a shippable artifact automatically — and catching problems the moment they're introduced. intermediate 9 min
  5. Documentation, tech debt & maintenance The unglamorous work that decides whether software survives — writing it down and paying down debt. intermediate 8 min

Module 6 — Choosing the Right Language

A full toolkit for the question every project starts with: which language? Driven by requirements, trade-offs, and the domain you're in.

  1. Why language choice matters (and when it doesn't) What the language decision actually buys you, what it locks in, and the cases where it barely matters. beginner 8 min
  2. Start with requirements Turning needs — performance, safety, ecosystem, team, timeline — into the criteria that pick a language for you. intermediate 9 min
  3. The performance ↔ productivity trade-off Fast to run vs. fast to write — the central tension, and how to find the right point on the curve for your project. intermediate 9 min
  4. A tour of today's major languages C, C++, Rust, Go, Python, JavaScript/TypeScript, Java, and friends — strengths, drawbacks, and sweet spots. intermediate 12 min
  5. Matching language to domain Web, systems, data, mobile, embedded, and DSP/RF — the languages each field reaches for, and why. intermediate 10 min
  6. A practical decision framework A repeatable way to choose, worked through real cases — including why a pure-Go engine fits a software-defined-radio scanner. advanced 10 min

Module 7 — Build Your Solo Developer Stack

Putting it all together as a team of one: pick your stack, set up your workflow, and ship and distribute software you build alone.

  1. The solo developer — wearing every hat What changes when you're designer, coder, tester, and release manager at once, and how to use your speed without drowning. beginner 8 min
  2. Choosing your stack Picking a language, frameworks, and tools you can be productive and happy in for the long haul — solo edition. intermediate 9 min
  3. Your environment & daily workflow Editor, terminal, version control, and the loop you'll run a hundred times a day — set up once, benefit forever. intermediate 9 min
  4. From idea to project Scoping a v1 you can actually finish, structuring the repo, and resisting the urge to build everything at once. intermediate 9 min
  5. Keeping quality high alone Tests, linters, and CI as the teammate you don't have — guardrails that review your work when no one else can. intermediate 9 min
  6. Packaging & distributing your software Cross-platform binaries, releases, and versioning — how a solo project like GopherTrunk reaches users on every OS. advanced 10 min
  7. Shipping v1 & maintaining solo Cutting the first release, gathering feedback, and sustaining a project — and yourself — over the long run. intermediate 9 min
  1. Glossary of software development terms Plain-language definitions for every term in the learning path, cross-linked to the lessons.