Software Engineering¶

Software engineering is everything involved in turning an idea into software that works, keeps working, and can be changed safely by the people who come after you. Writing code is only part of it. The rest is choosing structures that hold up as a system grows, proving the code does what it claims, shipping it without breaking things, and working with other people along the way.

This section is organised around those facets. Each one has its own folder; start wherever your current problem is.

Languages¶

Language-specific guides: idioms, mental models, tooling, and how to structure real projects.

Languages: overview of all language guides.
Go
Python
Rust: ownership and borrowing, fixing common compiler errors, and a complete guide to structuring, architecting, and deploying Rust projects.

Architecture¶

How the pieces of a system fit together, and the trade-offs behind those choices.

Architecture: overview.
Distributed Architecture: designing systems that span multiple processes, machines, or services, and the failure modes that come with them.

Delivery¶

Getting software from a merged change to running in production safely, and knowing exactly what you shipped.

Delivery: overview.
Release Strategies: rolling, blue/green, canary, feature flags, and choosing between them.
Software Bill of Materials (SBOM): inventorying every component that goes into a build.
Software Composition Analysis (SCA): finding known vulnerabilities and licence problems in your dependencies.

Collaboration¶

Software is built by teams. These pages cover communication, estimation, team dynamics, and keeping people healthy.

Collaboration: overview.
Communicating as a Software Developer: writing and speaking clearly to engineers, managers, and non-technical stakeholders.
Story Point Estimation: what story points measure, what they don't, and how to use them without gaming them.
Software Team Behavioral Categories: recognising common working styles and patterns on engineering teams.
Addressing Double Standards: spotting and raising inconsistent expectations within a team.
Churn for the Sake of Churn: when rewrites, re-orgs, and tool swaps cost more than they deliver.
Burnout: recognising it in yourself and others, and what helps.

Planned topics¶

Areas this section will grow into:

Testing: unit, integration, end-to-end, property-based and contract testing; test doubles; what to test and what not to.
Code quality: code review, linting and formatting, refactoring, technical debt, and readable code.
Design patterns: classic and language-idiomatic patterns, and when a pattern is overkill.
APIs: REST, gRPC, and GraphQL design; versioning; backwards compatibility; error contracts.
Debugging: systematic debugging, reading stack traces, bisecting, profiling, and post-incident analysis.
Concurrency: threads, async, message passing, and the bugs each one invites.
Security for developers: secure coding, input validation, secrets handling, and threat modelling.

Platform Engineering: DevOps, GitOps, SRE, and DevSecOps, the operational side of shipping software.
CI/CD: pipelines that build, test, and release code.
Version Control: Git and related tooling.
Security: broader security topics, including supply-chain security.
Databases: data storage, modelling, and administration.
Data Formats: Markdown, YAML, JSON, TOML, and other formats.
Technical Writing: documentation as a craft.