Learning path

Software engineering

Practise the habits of building maintainable software: unit tests, safe refactoring, SOLID design, design patterns, version control, and clear contracts.

About this subject

Software engineering is about building programs that stay correct and understandable as they grow and as teams change them. It covers testing, design, maintenance, and the tools and processes teams use to work together.

This path covers unit testing with unittest, refactoring with tests as a safety net, SOLID design and dependency injection, the observer pattern, a model of how version control stores history, and design by contract with exceptions. Each lesson uses a small, complete program that runs on its own. Python has the full sequence. The other languages listed below add lessons that use that language's own idioms and standard library, such as Java threads, C++ smart pointers, C# LINQ, or Node.js streams, and appear only for the topics the language supports. The programs are simplified models chosen to make an idea visible, so they are a foundation for further study rather than a replacement for a full course or for production-grade software.

Before you start: Classes, functions, and exceptions.

1
Python
Readable code for automation, data, and first programs.
Unit testing with unittest
Write small automated tests that check normal behavior, boundaries, and error handling.
Refactoring safely with tests
Restructure code without changing its behavior, and prove that behavior is unchanged.
SOLID design: depend on abstractions
Pass behavior into a class so it can be extended without being edited.
The observer pattern and an event bus
Let a publisher notify many subscribers without knowing who they are.
How version control works: commits, history, and merge bases
Model a commit graph as hashes and parents, and find the common ancestor used to merge branches.
Contracts, invariants, and exceptions
State what a function requires and guarantees, and fail fast with clear errors.
2
C
Learn memory, pointers, and efficient systems programming.
C: unit testing with a small macro
Report which checks pass and fail by printing the text of each expression.
C: the strategy pattern with function pointers
Choose behaviour at run time by passing a function to qsort, without changing the sorting code.
3
C++
Build fast applications with modern types and classes.
C++: a small unit-test harness
Check results and expected exceptions with a macro and a template, and report failures.
C++: the observer pattern with std::function
Notify any number of listeners without the publisher knowing what they do.
4
Java
Understand object oriented programs and the JVM.
Java: testing a method with a tiny test runner
Check normal cases, boundaries, and error cases, and report which ones pass.
Java: strategy and observer with interfaces and lambdas
Swap behavior behind an interface and notify listeners without coupling the sender to them.
5
C#
Build typed applications on .NET.
C#: testing values and exceptions with a small harness
Check results, and verify that bad input throws the expected exception type.
C#: dependency injection makes code testable
Pass a dependency in through the constructor so tests can replace it with a fixed one.
6
Kotlin
Write concise, typed code for JVM applications.
Kotlin unit tests with lambdas and runCatching
Write a minimal test function that reports passes and failures, including expected exceptions.
7
JavaScript
Add behavior to the web and build applications.
JavaScript: unit tests with node:assert
Write small tests with assertions, including checks that bad input throws the right error.
JavaScript: the observer pattern with EventEmitter
Let several listeners react to the same event without the emitter knowing about them.
8
TypeScript
JavaScript with static types for dependable code.
TypeScript: explicit errors with a Result type
Return success or failure as a value, and let the compiler force the caller to handle both.
9
PHP
Learn server-side web programming basics.
PHP unit tests with closures
Write a tiny test runner with named test closures and check normal values and expected errors.

About this subject

Python

Unit testing with unittest

Refactoring safely with tests

SOLID design: depend on abstractions

The observer pattern and an event bus

How version control works: commits, history, and merge bases

Contracts, invariants, and exceptions

C

C: unit testing with a small macro

C: the strategy pattern with function pointers

C++

C++: a small unit-test harness

C++: the observer pattern with std::function

Java

Java: testing a method with a tiny test runner

Java: strategy and observer with interfaces and lambdas

C#

C#: testing values and exceptions with a small harness

C#: dependency injection makes code testable

Kotlin

Kotlin unit tests with lambdas and runCatching

JavaScript

JavaScript: unit tests with node:assert

JavaScript: the observer pattern with EventEmitter

TypeScript

TypeScript: explicit errors with a Result type

PHP

PHP unit tests with closures