All posts¶
135 posts, by category. Each post is listed under its first category.
Architecture¶
- A Pragmatic Architecture Process for Embedded, Application, and Cloud Systems
- Architectural Governance: Stitching Together ADRs, RFCs, ARBs, and Architecture Vision for Effective Decision-Making
- Architecture Flashcards
- Building an Effective Architecture Guild: Lessons from the Trenches
- Clever Architecture is Not Good Architecture
- Communicating as an Architect: Telling the Story and Bringing Everyone on the Journey
- Embedded Architecture Process Mindmap
- Leveraging a Technology Radar for Strategic Decision-Making in Business
- The Evolution of Software Architecture: Moving Towards Lightweight, Agile, and Collaborative Approaches
- The Importance of Architectural Principles: Guardrails for Consistency and Success
- Using RFCs to Improve Software Design and Architecture
- What is an Architecture Vision and Why Does It Matter?
Architecture as Code¶
- Architecture Anti-Patterns: Common Pitfalls in C4 and Structurizr
- Architecture as Code (AAC): Building Better Systems Through Code-Driven Architecture
- Architecture as Code: Bridging the Gap Between Design and Development
- Structurizr: Bringing the C4 Model to Life in Code
- The C4 Model Visualising Software Architecture
Book reviews¶
- Adrenaline Junkies and Template Zombies: The Good, the Bad, and the Ugly of Software Development Culture
- Dan Pink’s Drive: Why Motivation is About More Than Just Money
- Happy to Work Here: Creating a Workplace People Actually Enjoy
- Managing Humans: The No-Nonsense Guide to Engineering Leadership
- Maximizing Software ROI: Lessons from Return on Software
- Peopleware: Why Tech Success is More About People Than Code
- Reviewing Software Engineering (8th Edition) by Ian Sommerville
- Slack: Why Overworked Teams Are Less Productive
- Start with Why, Leaders Eat Last, and The Infinite Game: A Practical Perspective
- Team Geek: How to Build a High-Performing Engineering Team
- The First 90 Days: How to Nail Your Transition into a New Role
- The Infinite Game: Why Playing to Win is a Losing Strategy
- The Mythical Man-Month: Why Throwing More People at a Late Project Makes It Later
- The Practical Wisdom of Leaders Eat Last
- Waltzing with Bears: Embracing Risk Instead of Ignoring It
- Why Does Software Cost So Much? (And Why It’s Not Just About Code)
- Why ‘Start with Why’ is Just Common Sense
- Writing Better Software: Lessons from Code Complete
Computing history¶
- Beyond Unix and C: The Lasting Legacy of Kernighan, Ritchie, and Thompson
- C: The Language That Built the Modern World
- More Than Just Unix and C: The Unsung Heroes of Bell Labs
- The Origins of TCP/IP: How the Internet Found Its Voice
- The Origins of Unix: A Legacy of Simplicity and Power
Docs as Code¶
- Architecture Evaluation and Trade-Off Analysis
- Building a Documentation Culture That Lasts
- Canvas Tools for Strategy, Communication, and Clarity
- Case Study: Multi-Layer Docs-as-Code in Practice
- Deep Dive into Architecture Decision Records (ADRs)
- Deep Dive into RFCs: Capturing Collaborative Design in Docs-as-Code
- Docs as Code: What It Is, Who It’s For, and When It Works Best
- Docs-as-Code Smells and Anti-Patterns
- Frameworks That Bring Order to Documentation
- Going Beyond Markdown: Rich, Interactive, and Cross-linked Docs
- Key Artefacts Across the Stack: What to Write and Why
- Living Architecture: Keeping Documentation Relevant Over Time
- Making Docs Part of Your Agile Workflow
- Structuring Docs for Complex Systems: Layered, Flexible, and Discoverable
- Templates, Starter Kits and Metadata Playbooks
- Tools of the Trade: Building a Docs-as-Code Stack That Works
- Writing a Software Design Specification Using Docs-as-Code
- Writing for Systems, Products, and Projects – Scoping Documentation the Right Way
Documentation¶
- "Good Code Documents Itself!"—No, It Really Doesn’t
- arc42: A Pragmatic Approach to Software Architecture Documentation
- Making Sense of Documentation: A Pragmatic Look at the Diátaxis Framework
- Supercharging Documentation with MkDocs and Plugins
- The Ultimate Markdown Guide: Formatting, Diagrams, Code Blocks, and More
- What You Should Document and Why
- Why Your Software Documentation Shouldn’t Live in Work Tracking Tools
Embedded¶
- Fixing MISRA C Errors: More Than Just Cleaning Up the Report
- How to Write Maintainable Embedded Code: Principles That Outlast Your Compiler
Engineering practice¶
- A Pragmatic Approach to Semantic Versioning
- Feature Flags: A Pragmatic Approach to Software Development
- How Long Should It Take for a Developer to Be Productive?
- The Cone of Uncertainty: Why Your Estimates Are Always Wrong (And That’s Okay)
- The Impact of Interruptions on Developer Productivity: Evidence and Real-World Data
- Why Companies Keep Failing at Software (And Never Learn)
- Why Companies Will Never Learn (And Why They Think They’re Different)
- Why Some Companies Struggle with Software Development (When They Really Shouldn’t)
- Why Standardising Tools and Processes Across Software Teams is a Bad Idea
Git¶
- 10 Git Tricks You Wish You Knew Earlier
- Mastering Git – A 10-Part Journey from Basics to Best Practices
- Mastering Git – Part 10: Git in CI/CD and Large-Scale Development
- Mastering Git – Part 1: Git Fundamentals – The Absolute Basics
- Mastering Git – Part 2: Understanding Branching and Merging
- Mastering Git – Part 3: Rebasing vs Merging – When and Why?
- Mastering Git – Part 4: Git Reset, Revert, and Amend – Fixing Mistakes
- Mastering Git – Part 5: Remote Repositories and Working with Teams
- Mastering Git – Part 6: Git Best Practices – Writing Clean History
- Mastering Git – Part 7: Git Hooks and Automation
- Mastering Git – Part 8: Advanced Git – Stashing, Cherry-Picking, and Submodules
- Mastering Git – Part 9: Debugging and Resolving Git Issues
- Understanding Git: How It Works Under the Hood
Home lab¶
- ARP Spoofing, MAC Filtering and Network Fingerprinting
- Development and Documentation Tools in Containers
- Essential Dashboards for Home Labs: Heimdall, Homarr, Flame
- Expanding My NAS: Future Containers to Run
- Home Network Design: Tips from a Real Setup
- IoT Networking: Smart Devices and Their Challenges
- Keeping Docker in Check with Watchtower
- Monitoring Raspberry Pis with PiStats & A Unified Dashboard for All Devices
- NAS: What It Is and Why You Might Want One
- Network Tools and Automation in Docker
- Observability and Monitoring in a Home Network
- Powering a Home Lab with Docker and Synology NAS
- Running a Local DNS and DHCP Server for Your Home Lab
- Self-Hosting My Smart Home & Network: Current Setup and Future Plans
- Setting Up an Nginx Reverse Proxy with SSL and Local DNS for a Synology NAS and Other Services (home.example)
- Using VLANs and Subnets for Smart Home Security
Networking¶
- A Deep Dive into IP: The Backbone of Internet Communication
- A Deep Dive into TCP: How It Powers Reliable Communication
- Authentication, Authorisation, Accounting (AAA)
- Common Application Protocols: HTTP, HTTPS, FTP, SMTP, IMAP
- DNS: The Internet's Directory Service
- Encryption Basics: Protecting Data in Transit and at Rest
- Firewalls: What They Are and Why You Need One
- How Devices Join the Network: DHCP Explained
- How the Internet Actually Works (ISPs, IXPs, Routing)
- IP Addresses and Subnetting Demystified
- MAC Addresses and ARP: Finding Devices on a Network
- NAT and Port Forwarding: Talking to the Outside World
- Network Topologies: Star, Bus, Mesh and More
- Networking and Home Lab: the Series
- QoS: Prioritising Traffic for Smooth Performance
- Switches and Routers: What’s the Difference and Why It Matters
- TCP vs UDP: Choosing the Right Transport Protocol
- Virtual LANs (VLANs): Network Segmentation 101
- VPNs: Secure Tunnels for Remote Access and Privacy
- What Is a Network? (LAN, WAN, PAN Explained Simply)
- Wired vs Wireless: Ethernet and Wi-Fi Compared
Standards¶
- AsyncAPI: Bringing Order to Event-Driven Chaos
- OpenADR: Enabling Scalable, Automated Demand Response
Team¶
- An Approach to Engineering Leadership and Delivery
- Autonomy, Mastery, and Purpose in Software Engineering and Architecture
- Building a High-Impact Software Guild: A Collaborative Approach for Architects, Product Managers, Developers, and Project Managers
- Building a High-Performing Engineering Team – Managing People for Success
- Navigating Organizational Complexity – Leading in Cross-Functional Teams
- Scaling Leadership – Evolving from Manager to Strategic Visionary
- The Role of a Technical Leader – Driving Innovation While Empowering Teams