Software Engineering and Technology

These are what I believe to be important and seminal works that I refer to often. Presented in roughly the order I’ve read them:

  • Design Patterns - This is a foundational read, and though there are some patterns from this book that are dated, many stand the test of time.

  • 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, much of what I do know about web design started with 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 over the years, 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) - Important 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) - The SOLID principles are well explained this book, and it goes into good depth on the essential concept of Dependency Injection.

  • 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 further builds on those concepts.

  • 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.

  • 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 - 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 (now Azure DevOps).

  • 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.

  • OpenID Connect Specifications - and OAuth 2.0 and JWT and related OpenID Connect specifications. (Yes, I really read all of these.) Few things have influenced my career in a positive way than reading these specs, because no matter what you are working on, two things hold true: you are communicating over a network, and you need to authenticate over that network. Thus, this to me was a very critical read to inform on how I can use and design systems and services in a proper way with proper authentication and authorization. These specs are widespread, but not well understood, so if you want to do yourself a favor and accelerate your career and enhance your systems design approaches, read these specs. (As an aside, when I read these in the ~2016 time frame, there weren’t many great trainings available on the subject, so I had to go to the source.)

  • 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.

  • Fearless Salary Negotiation: A Step-By-step Guide to Getting Paid What You’re Worth - If you ever find yourself in the situation where you’re interviewing for a new job, this is an excellent reference not only for negotiating salary, but for navigating the entire interview process.

  • Mastering Business Email: How to write emails that get read - This is a great read to get you thinking about how to write effective emails.

  • Learn SQL Server in a Month of Lunches - A good, no-nonsense introduction to managing SQL Server.

  • Learn Active Directory in a Month of Lunches - A great book to round out your knowledge of Active Directory.

  • Learn Windows IIS in a Month of Lunches - A great book to round out your knowledge of IIS.

  • 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 that 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.

  • Learning the bash Shell: Unix Shell Programming - I’m not going to lie, bash is arcane at times, but this book finally got me a semi-competent understanding of the bash shell (and its siblings ksh, zsh, fish etc.).

  • 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.

  • 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 picks up. This book is not just filled with knowledge on monitoring and alerting at scale, it is also 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.

  • 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.

  • 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.

  • Instructional Design for Mortals: Creating Better Adult Learning - Was once in print but hard to find now, but if you can get a copy I highly recommend this. It walks through the various levels of learning and how to design instructional material for professional adults in the working world.

  • 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.

  • The Laws of Identity - These laws from Kim Cameron are a foundational and seminal read for anyone doing any type of work in the identity and access management space in technology.

  • The Twelve-Factor App - Regularly referenced work with a number of ideal practices for app development.

  • 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.

  • Learn Docker in a Month of Lunches - I tried one Docker book prior to this and wound up going back for another since it seemed to be missing some key concepts. This was the book that solidified my knowledge base for Docker.

  • Learn Kubernetes in a Month of Lunches - This is a great book to get you thinking about Kubernetes, and by the end of it you learn about a key concept called the Operator Pattern which is the foundation for the service mesh frameworks like Istio and Open Service Mesh, as well as new emergent patterns for running stateful workloads on Kubernetes.

  • API by Design - A fantastic read from a former colleague that will get you thinking about API complexity and entropy and how to manage it to create quality APIs.

  • OpenAPI - The OpenAPI spec has become one of the most important aspects of modern API development.

  • JSONSchema - This has become a very popular approach to validating JSON in many types of systems.

  • Collection+JSON - This is an interesting concept, and while I haven’t run into a use cases for it much, it’s a good concept to keep in mind.

  • RESTful JSON - An approach to including URLs in JSON in an effort to lower the barrier to implement hypermedia approaches in APIs.

  • Shell of an Idea - A great book on the origins and design philosophy behind the PowerShell language and ecosystem.

  • Staff Engineer: Leadership beyond the management track - This is an essential book for those who are looking to go to or are at the level of Staff Engineer at their respective company.

  • An Elegant Puzzle: Systems of Engineering Management - This is another essential book for both aspiring and current Staff Engineers as well as Engineering Managers, as it provides good perspective from your manager’s point of view for the former, as well as lots of helpful tools for both Staff Engineers and Managers for navigating organizational challenges and working with senior leadership at your company.

  • The Art of Leadership: Small Things, Done Well - I really enjoyed going through Michael Lopp’s 30 things in this book, and the way it’s laid out. Leadership can come from anywhere, and because of that, whether you are in management or not, I strongly implore you to read this one.

  • Managing Humans: More Biting and Humorous Tales of a Software Engineering Manager - Another good read from Michael Lopp that has yet more expanded advice on engineering management and leading at organizations.

  • Being Geek: The Software Developer’s Career Handbook - Another good read from Michael Lopp, this one being slightly less engineering management focused and speaking more directly to the individual contributor.

  • Get to the Point!: Sharpen Your Message and Make Your Words Matter - While not strictly a “tech” book, this is still a very good read for people in tech (and all) industries, because no matter where you work, you’re going to have to present at some point, and you want to be able to deliver a clear message to your audience. This is a fun short read with lots of great tips around this.

  • Team Topologies: Organizing Business and Technology Teams for Fast Flow - A very great book for not just managers but anyone who wants to understand how to align teams in ways to help organizations deliver. I personally resonated with a lot of the items around SRE and DevOps and Platform teams, and more.

  • Project Zero Trust: A Story about a Strategy for Aligning Security and the Business - This book is goofy at times and is not on the same story level as Phoenix Project, but nonetheless walks through a number of key concepts when trying to pursue a Zero Trust Architecture at any organization.

  • Working in Public: The Making and Maintenance of Open Source Software - This is a fascinating deep dive into everything that goes into creating and, critically, maintaining open source software, with a special takeaway on the economics of how a finite amount of attention plays into how maintainers approach the care and feeding of their open source projects.

Other

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