New book: Code That Fits in Your Head by Mark Seemann

The expanded universe.

It gives me great pleasure to announce that my new book Code That Fits in Your Head will be out in September 2021. The subtitle is Heuristics for Software Engineering.

Many regular readers have been expecting me to write a book about functional programming, and while that may also some day happen, this book is neither about object-oriented nor functional programming per se. Rather, it takes a step back and looks at various software development techniques and practices that I've found myself teaching for years. It covers both coding, troubleshooting, software design, team work, refactoring, and architecture.

The target audience is all the hard-working enterprise developers in our industry. I estimate that there's great overlap with the general readership of this blog. In other words, if you find this blog useful, I hope that you'll also find the book useful.

As the title suggests, the theme is working effectively with code in a way that acknowledges the limitations of the human brain. This is a theme I've already explored in my Humane Code video, but in the book I expand the scope.

Expanded universe #

I've structured the book around a realistic sample application. You'll see how to bootstrap a code base, but also how to work effectively with existing code. Along with the book, you'll get access to a complete Git repository with more than 500 commits and more than 6,000 lines of lovingly crafted code.

While I was developing the sample code, I solved many interesting problems. The best and most universal examples I used in the book, but many didn't make the cut. The book aims broadly at programmers comfortable with a C-based programming language: Java, C#, JavaScript, C++, and so on. Some of the problems I solved along the way were specific to .NET, so I found them a poor fit for the book. I didn't want these great lessons to go to waste, so instead I've been blogging about them.

These are the articles based on the code base from the book:

• Closing database connections during test teardown
• Using the nameof C# keyword with ASP.NET 3 IUrlHelper
• An ASP.NET Core URL Builder
• Adding REST links as a cross-cutting concern
• EnsureSuccessStatusCode as an assertion
• Fortunately, I don't squash my commits
• Monomorphic functors
• Signing URLs with ASP.NET
• Checking signed URLs with ASP.NET
• Redirect legacy URLs
• Name by role
• Branching tests
• Waiting to happen
• Parametrised test primitive obsession code smell
• Self-hosted integration tests in ASP.NET
• ASP.NET POCO Controllers: an experience report
• When properties are easier than examples
• Pendulum swing: internal by default
• Pendulum swing: sealed by default
• Consider including identity in URLs
• Leaky abstraction by omission
• Structural equality for better tests
• Simplifying code with Decorated Commands
• Unit testing private helper methods
• Keep IDs internal with REST
• The Equivalence contravariant functor
• Waiting to never happen
• Test Double clocks
• An applicative reservation validation example in C#
• ASP.NET validation revisited
• Coalescing DTOs
• Stubs and mocks break encapsulation
• An initial proof of concept of applicative assertions in C#
• Warnings-as-errors friction
• A restaurant example of refactoring from example-based to property-based testing
• Decomposing CTFiYH's sample code base
• Do ORMs reduce the need for mapping?
• The case of the mysterious comparison
• A restaurant sandwich

Some of these articles also use code examples from other sources, or code written specifically for that post, but whenever you see a code example from the restaurant reservation domain, it's from the book's code base.

That the above list represents the outtakes from the book's example code base should give you an idea of the richness of it.

I may add to the list in the future if I write more articles that use the book's example code base.

Conclusion #

A decade after my first book, I've finally written a completely new book. Over the years, I had a few false starts. This book wasn't the book I thought that I'd be writing if you'd asked me five years ago, but when it finally dawned on me that the topic ought to be Code That Fits in Your Head: Heuristics for Software Engineering, the book almost wrote itself.

This one is for all the software developers out there who aspire to improve their practical skills.

---

Comments

• ← Previous
• Archive
• Next →