Software Engineering and DevOps

I’ve read more books and articles / seen more videos than this, but these are what I feel to be important and seminal content that I refer to often. Presented in roughly the order I’ve read them:

  • Design Patterns - This is a pretty foundational read, and though there are aspects at times that seem dated, a number of these patterns really stand the test of time. Moreso, this book engages the mind to start thinking about software in a different way.

  • Scalable and Modular Architecture for CSS - I searched high and low for patterns for CSS. There’s pretty good prescriptive guidance when it comes to most programming languages, but when it came to a logical organization pattern for stylesheets I wandered in the desert for a long time. Until I found this book. I have yet to find a better approach.

  • Smashing Books: 1, 2, 3 + 3 1/3, 4, 5, and more - These books have come out at certain intervals over the years, and although I don’t claim to be a Designer of any sort, what I do know about web design has come from these series of books. Smashing Magazine has also produced other non-numbered books on more specific subjects which are also great.

  • Learning JavaScript Design Patterns - Frontend development has changed a lot but this book first introduced me to some fundamental concepts including the important AMD pattern.

  • Microsoft Visual C# Step by Step, 9th Edition - I read an earlier edition of this book, but you’ll want to get the latest available. It’s not exactly an earth-shattering book, but I decided to retroactively add it to the list, as in hindsight it is a very good book to give to as an introductory book to the C# language for someone who has not used it before.

  • C# Coding Conventions (C# Programming Guide) - I’m a big proponent of “When in Rome, code like the Romans do,” i.e. stick to the conventions of the communities surrounding a given language. These are those conventions for C#.

  • Framework Design Guidelines - Dovetailing off of C# conventions is overall conventions for library design in conjunction with the .NET Framework.

  • Adaptive Code: Agile coding with design patterns and SOLID principles (2nd Edition) (Developer Best Practices) - This is one of those unassuming books that winds up being totally earth-shattering. The SOLID principles are so well laid out this book, and it goes into good depth on a concept that is pretty essential these days: Dependency Injection. And much, much more. I cannot recommend this book highly enough.

  • Microsoft .NET - Architecting Applications for the Enterprise (2nd Edition) (Developer Reference) - After reading Adaptive Code, I recommend people read this book. It builds on those core concepts but takes them up a level into application architectural patterns including DDD and the Domain Model, CQRS, Event Sourcing and more.

  • Building Microservices - After reading the previous two books I highly recommend folks read this one, as it builds on those concepts more. This is another earth-shattering book that will entirely change how you look at software and deployment and a number of practices.

  • Pattern: Backends for Frontends - BFF is a key architectural pattern called out in Building Microservices and one that I reference often in designing applications, especially ones with multiple clients.

  • PowerShell Practice and Style - I looked around for a long time on good conventions for writing PowerShell and came across this from the community. I follow these rules about 95-98% of the time, though Microsoft themselves will have slightly different practices – what I wind up doing is following convention based on the project, so that at least within a given project things are consistent. Common things that vary per project are, brackets opening on the same line and the use of backticks.

  • Getting Started with PowerShell Desired State Configuration (DSC) - A great course for PowerShell DSC and PowerShell in general – lots of great tidbits shared throughout by Jeffrey Snover, the inventor of PowerShell.

  • Advanced PowerShell Desired State Configuration (DSC) and Custom Resources - Another great course to get deeper on PowerShell DSC and PowerShell in general.

  • The DSC Book by Don Jones et al. - A good evergreen book on PowerShell Desired State Configuration that continues to be updated. This book helps to fill in a lot of gaps an answer a lot of the niche questions about PowerShell DSC.

  • The Imposter’s Handbook - A great read for someone like myself who did not get a computer science major in undergrad.

  • The Phoenix Project: A Novel about IT, DevOps, and Helping Your Business Win - Another earth-shattering book. A necessary read for any DevOps practitioner.

  • Scaling Git (and some back story) - I refer to this seminal blog post by Brian Harry quite often, as it goes into great depth on how a large company like Microsoft standardized around common engineering standards with Git and VSTS.

  • Pro Git - aka the Git Book. You only need to know a handful of commands to get going as a normal Git user, but if you really want to understand the full breadth of the tool you need to read this book.

  • Mastering Regular Expressions - No, I have not mastered them, they are still hard. But, I at least have a better idea around DFA’s and NFA’s and how the different engines work having read this book.

  • Zero Trust Networks - This book takes your traditional concepts of network security and flips them on their head, and presents a model of what modern identity and trust-based security looks like - an earth-shattering book.

  • Learn SQL Server in a Month of Lunches - I began to get into a series of “Month of Lunches book” around certain tools and products I used every day but wanted to round out my knowledge base on. This was one of them, gives a good, no-nonsense introduction to managing SQL Server.

  • Learn Active Directory in a Month of Lunches - Similarly I wanted to round out my knowledge in Active Directory and this book was great for that.

  • Learn Windows IIS in a Month of Lunches - Similarly I wanted to rout out my knowledge of IIS and this book was great for that.

  • Learn Windows PowerShell in a Month of Lunches (Third Edition, 2017 or newer) - I was fairly deep on PowerShell by the time I started to pick up the PowerShell series of “Lunches” books, but I wanted to start with the first introductory one to round out any aspects I may have missed, and understand if it was a good intro book to recommend to others (and it is).

  • Learn PowerShell Scripting in a Month of Lunches (First Edition, 2017 or newer) - The next logical book in the PowerShell “Lunches” books was a good insight into creating maintainable PowerShell scripts. I frame these scripts as useful pieces of long-lived business logic that could be packaged up and distributed as single Script modules (e.g. Install-Script).

  • Learn PowerShell Toolmaking in a Month of Lunches (First Edition, 2013 or newer) - The next logical book in the PowerShell “Lunches” books was a good insight into creating PowerShell modules, including facets of cmdlet design. I frame these modules as useful collections of related and cohesive commands taht could be packaged up and distributed as cmdlet modules (e.g. Install-Module). (Not to be confused with compiled, C# binary cmdlet modules).

  • The PowerShell Scripting & Toolmaking Book (Leanpub evergreen book, limited print runs) - This is an evergreen, logical continuation of the PowerShell “Lunches” books with additional advanced content.

  • The Release Pipeline Model - This is a seminal whitepaper that outlines a Release Pipeline Model that’s especially oriented around Infrastructure / Configuration as Code, using tools like PowerShell DSC and Chef.

  • The DevOps Handbook - The logical successor to The Phoenix Project, but more of a straight-forward handbook instead of a novel. We read this book as a team, and I can say confidently that it goes into the “earth-shattering” category and thus is very worthy of this list.

  • Learning the bash Shell: Unix Shell Programming - I’m not going to lie, bash is arcane, especially coming from PowerShell where everything is beautiful and nothing hurts. And I would probably reach for Python if I had to do some serious scripting / programing on the *nix side, but alas you do run across the need to interpret and make bash shell scripts from time to time (if only to wrap / invoke other things) and this book finally got me a semi-competent understanding of the bash shell (and its siblings ksh, zsh, fish etc.). I’m using zsh most of the time interactively now with the “oh my zsh” extensions, but writing scripts targeting bash.

  • Applied Cryptography: Protocols, Algorithms, and Source Code in C - This book is a great primer on wrapping your head around the underpinnings of how cryptography works. Reading the entirety is not necessary, as many of the described algorithms in the book have gone by the wayside over the years since it was written in the 90’s, but there are a number there that help to establish a good footing for future cryptographic study and application.

  • It Doesn’t Have to Be Crazy at Work - This is a very thought-provoking work that will have you questioning many of the modern-day practices in companies. Overdrawn hours and unrealistic expectations fly in the face of a lot of the sensible approaches outlined in this book. Highly recommend it.

  • Effective Monitoring and Alerting: For Web Operations - This book starts out with slightly run-of-the-mill content on Monitoring and Alerting, and then you get to Chapter 4… and it rocks your socks off. This book is not just filled with knowledge on monitoring and alerting at scale, it is filled with wisdom. Real world experience with these scenarios can be hard to come by. Systems that start small at some point suddenly find themselves in need of scale, and montioring and alerting has to scale with it. This book demystifies how to do this with tons of rules of thumb that are born out of tried and tested patterns. I highly recommend this book.

  • Scrum: The Art of Doing Twice the Work in Half the Time - I’m very much into going to the source for the best information, and when I found out from a colleague that there was a book by the creator of Scrum about Scrum, I knew I had to read it. Many organizations will take Scrum and transmogrify it according to their interpretations (which is fine), but IMHO it’s best to build up one’s own understanding of Scrum from the source, and I think this is the closest you’ll get to that source.

  • The Pester Book - I had this in my queue for a while and finally got around to reading it when we started using Pester for various scenarios at work. It’s really the best dive into how to use it short of perhaps watching Pluralsight videos by the author. (I prefer the written word whenever possible.)

  • Effective C#: 50 Specific Ways to Improve Your C# - There are some real gems in this book to pick up. Not all of these 50 will be mind-blowing but there’s enough here that it goes on the recommended list.

  • More Effective C#: 50 Specific Ways to Improve your C# - Similar to the first Effective C# book, there are some items in here that are very helpful.

  • Just for Fun: The Story of an Accidental Revolutionary - This book won’t change the way you program or add large hidden facet of technical understanding to your repertoire, but it is still very interesting nonetheless. The autobiography of Linus Torvalds provides some very interesting insights into the history of the various operating systems of the time. One interesting concept I appreciated was his description of how the basic sys calls serve as the basic building blocks upon which you can do everything else in the OS, and how this idea of composability of simple things to make complex things is very important.

  • DNS and BIND - I’m not going to lie, this book is a long slog. But if you can power through it, you will come out the other end with a much better understanding of the underpinnings of DNS, and have a new appreciation of just how much hidden complexity exists beneath a system that has the seemingly simplistic job of mapping domain names to IP addresses.

  • Semantic Versioning - I debated adding this to the list but decided that I should, as I feel that the concepts expressed here are extremely important and should be understood broadly by developers, especially in the context of separating “marketing versions” of software and packages from their actual package versions.


Over the course of 2016 and now into 2017 and beyond I started taking health seriously. In particular I lost 40 pounds eating a well formulated ketogenic diet, which I consider a lifestyle and something I will do forever now. in 2017 I’ve also started incorporating the gym into my diet after understanding the strong correlations between overall muscle mass and longevity.

  • 2 Keto Dudes - This is the podcast that got me started on my keto journey and pursuit of overall better health. I had listened to Carl Franklin for years on podcast .NET Rocks, and when he mentioned he was starting a new podcast with his friend Richard Morris to document his journey through Ketosis to fix his Type II Diabetes, I was intrigued, and knew I could do it, too. And I did. And I’m in the best shape of my life because of it.

  • The Ketogenic Forums - The dudes, being the software developer types, put their skills and energy to work to set up these Ketogenic Forums, which is a great source of information for anyone who is in the ketogenic lifestyle or thinking about starting the ketogenic diet.

  • The 4-Hour Body - This book can be a little crazy at times, but I have to admit this was the first place I heard about the concept of low carb and ketosis, and though I didn’t understand it years ago when I first read it, and I don’t necessarily follow the “Slow Carb” diet Tim lays out (I stay pretty much low carb most of the time), it has a lot of concepts that were ahead of its time. Still worth a read.


These are books of any other category that don’t fit above.