Software Engineering - Software Development Books

Code Complete: A Practical Handbook of Software Construction

This book made me realize, among other things, that assuring quality in software is not something that takes place towards the end of the development life cycle, but is rather a continuous effort which starts from the very beginning, at the stage of defining the problem and gathering requirements.

Concepts within the book are described using colorful metaphors so that they’re easier to comprehend and simpler to explain to a non-technical audience, such as business analysts and project managers. And despite having been released for a few years now, its value is timeless.

Reading Code Complete 2 is one of the best investments you can make if you really care about your craft.

The Pragmatic Programmer: 20th Anniversary Edition

This was the first technical book I ever read, back in the early 2000’s. I wasn’t quite ready for it then, but some of its concepts stuck in my head and helped me become who I am today.

Instead on focusing on code, the authors present a number of practical approaches they have found to work in real world scenarios, accompanied with solid advice and outstanding analogies.

As Ward Cunningham, the father of wiki, said:

If I’m putting together a project, it’s the authors of this book that I want… And failing that I’d settle for people who’ve read their book.”

Clean Code: A Handbook of Agile Software Craftsmanship

As programmers we tend to optimize for writing code fast, which is unfortunate as we typically spend up to 80% of our time reading and changing existing code. We should instead optimize for reading code fast, and be able to make changes easier without causing regressions. You could say that we need to be producing software that is actually soft!

What is the difference between good and bad code? How bad code can be transformed to good code? What are the best practices for formatting, naming things, writing tests, or implementing error handling without clouding the business logic?

This book is another must-read by Robert C. Martin (aka Uncle Bob). It is highly recommended for programmers, technical architects and team leaders who are interested in producing better, high-quality and highly-effective code.

Agile Principles, Patterns, and Practices in C# (Robert C. Martin)

This is the bible of agile software development. Robert C. Martin (aka Uncle Bob) presents a variety of case studies explaining the fundamentals of agile development and extreme programming. Every single technique is proven in real-world scenarios, and it is accompanied by numerous code examples.

Apart from agile fundamentals, the book also discusses various other topics, such as planning iterations & releases, TDD, refactoring, unit testing, acceptance testing, pair programming, and design smells.

Agile Principles, Patterns, and Practices in C# is highly recommended for every software developer and technical architect, regardless of whether they work in C# or some other language.

Refactoring: Improving the Design of Existing Code (Object Technology Series)

Martin Fowler introduces a series of refactoring techniques that focus on improving the internal design of existing code without changing its external behavior. Each refactoring type is given a name and it’s described in small, easy to comprehend steps.

My favorite quote from the book is:

Any fool can write code that a computer can understand. Good programmers write code that humans can understand.

The book’s code examples are presented in Java, but the concepts illustrated are 100% applicable to any object-oriented language.

The Art of Unit Testing: with examples in C#

What is legacy code? According to Michael Feathers, it’s code without tests. Even if it was written yesterday! If you write legacy code for a living, this book is for you.

The Art of Unit Testing will get you started from zero, and teach you enough to be dangerous. You will learn about a number of different testing approaches, their pros and cons, and how to choose which one you need on a case by case basis. The examples might be in C#, but writing good tests goes beyond the programming language.

xUnit Test Patterns: Refactoring Test Code

Automated tests are right at the center of agile software development and the DevOps culture. Tests have your back, and given they are done right, they can help you move faster and more effectively by taking huge risks out of the equation.

This book by Gerard Meszaros is the bible of software automated testing, and can greatly help you step-up your engineering game. It describes a total of 68 well-defined patterns for writing better, more readable, and much more maintainable tests. It also depicts a number of common code smells of automated tests, and provides detailed guidance on how to refactor and end up with a good solution.

There are code samples in several programming languages, and although the book is focused on the xUnit family of testing frameworks, the patterns and practices it contains apply to several other modern testing frameworks, such as NUnit, RSpec, JBehave, Fit and Fitnesse.

Head First Design Patterns

Design patterns is one of the most essential concepts of software engineering. Essentially, some of our every-day problems in software design have already been solved by others. Instead of reinventing the wheel, we can tap into the experience tank of those people and find solutions that we probably wouldn’t think by ourselves.

For people who work in large corporations, their boss or client may not want to see this book on their desk, mostly because it’s playful and funny, it uses an informal style of communication, and overall it doesn’t look very professional, but it is! I strongly believe that it’s the best choice one has to get introduced to the mindset of designing software based on well-defined patterns.

The book’s examples are written in Java, but the designs are applicable to every OOP language, especially to the strongly-typed ones.

Design patterns: elements of reusable object-oriented software

For the more experienced engineers, I recommend the all-time-classic Design patterns : elements of reusable object-oriented software, written by Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides, a group of authors also known as The Gang of Four.

I made several attempts to read this book over the last few years, just to find out that I wasn’t ready yet. Only after reading Head First Design Patterns and getting some more experience in the field I was finally able to read and understand the GoF book. I believe that no one should get discouraged if their initial attempts fail.

The book’s examples are written in C++, but the designs are applicable to every OOP language, especially to the strongly-typed ones.

Design Patterns in Ruby

Russ Olsen has done a great job at adapting fourteen commonly-used GoF design patterns to the Ruby language. He doesn’t just list the patterns one by one, rather he presents a real-world problem, builds an initial solution for it, outlines its shortcomings, and then refactors it using design patterns.

It is a must-read for anyone who programs either in Ruby or in any other dynamically-typed language, such as Javascript. Also, the first two chapters provide a comprehensive introduction to Ruby, so the reader doesn’t need any prior Ruby experience in order to start reading the book.

You Don't Know JS: Up & Going

Kyle Simpson’s You don’t know JS book series is the most complete guide on the JavaScript language out there, highly recommended for any front-end or Node.js developer. The series includes:

1. You Don’t Know JS: Up & Going
2. You Don’t Know JS: Scope & Closures
3. You Don’t Know JS: this & Object Prototypes
4. You Don’t Know JS: Types & Grammar
5. You Don’t Know JS: Async & Performance
6. You Don’t Know JS: ES6 & Beyond

You can also read all the books online on Kyle’s GitHub for free.

C# in Depth, 4th Edition

This is THE book to read about C#. It describes all of the core features of the language in great detail, from every-day-use to more advanced ones. It also provides some historical information about each of them.

I wouldn’t recommend it as an introductory book on C#, as it is addressed towards more intermediate developers. Beginning C# Object-Oriented Programming by Dan Clark would be a more suitable choice for that cause.

Jon Skeet always makes my brain melt. His deep knowledge about C# is reflected both in this book, as well as in his Stack Overflow profile.

ASP.NET Core in Action

ASP.NET Core is an open-source, cross-platform and high-performance framework, ideal for building cloud-based, internet-connected applications, from REST APIs to full stack applications. It be directly compared to Ruby on Rails, NodeJS and Spring. Having developed solutions on all of these frameworks, I find that I’m much more productive and happy with ASP.NET Core.

I had been following Andrew Lock’s excellent blog on ASP.NET Core for a while when his book got published, and I immediately knew that I had to read it. I finished it in about a week, learned a ton of new things, and managed to directly apply some of that practical knowledge to a real-world enterprise application. Win!

PS: The usual language to develop on ASP.NET Core is C#, but the framework also works nicely with F#.

Real-World Functional Programming: With Examples in F# and C#

A pleasant and eye-opening introduction into the world of functional programming. The authors, both well respected for their numerous community contributions, have done a great job presenting a number of challenges and then tackling them using the functional programming model, both in C# and F#.

The book makes clear that we can work in a functional way no matter which programming language we use, although using a functional-friendly language such as F# enables us to write less verbose, more concise, and in many cases better performing applications.

This book is introductory to functional programming and F#, so you don’t need any prior experience on either. On the other hand, you need to have a good background in C#.

Programming F# 3.0: A Comprehensive Guide for Writing Simple Code to Solve Complex Problems

In 2017 I started working extensively with F# and functional programming, and I can say with confidence that this is by far the best book I’ve read on the language.

Chris Smith gives you the down to earth, pragmatic version of what functional programming is and what isn’t, and gives you the ammo you need to work effectively with F#.

You will learn about F#’s unique characteristics and core syntax, including Object Oriented and Imperative styles. You will see how you can take advantage of advanced features, such as computational expressions and tail recursion. You will become familiar with parallel and asynchronous programming; you will also figure out the difference between the two. And these are just a few of the topics covered in the book.

If you would like to find out more about F#, how it fits into the .NET ecosystem and what really makes it tick, this book is exactly what you are looking for.

Stylish F#: Crafting Elegant Functional Code for .NET and .NET Core

If you already work with F# and you want to write better programs, this book is for you.

In programming there are many different paths you could take to arrive to a given solution. Building top-notch applications is not just a matter of correctness though; along the way you need to make a number of important and educated design choices that impact your program in terms of performance, maintainability, extensibility etc.

Kit Eason has been a valuable contributor to the F# community, with his training videos and publications being a reference point for anyone working with the language. Stylish F# is no exception.

Domain Modeling Made Functional

The Domain-Driven Design methodology has been identified as a valuable approach for modern software development, helping us tackle the complexity of our software systems and empower the collaboration between programmers and domain experts.

DDD has been traditionally associated with the Object-Oriented programming model due to a number of conceptual commonalities, such as encapsulating state within aggregate roots / bounded contexts, but it actually doesn’t have to be restricted to that.

DDD and functional programming is a powerful combination that can help us model and execute upon real-world requirements in a terse and effective way, in many cases producing better results compared to an object-oriented approach.

Scott Wlaschin, the brains behind the F# For Fun and Profit blog, has distilled his process for creating a functional domain model into a pleasant to read, pragmatic guide. Highly recommended.