Books for Great Software Architects - Fundamentals Path

As we have seen in the Overview, the reading roadmap starts by the fundamentals path which will be explained in this story:

Fundamentals Path

The fundamentals path is actually composed of two sub-paths; Design Path and Architecture Fundamentals Path.

Design Path

Before starting your journey to the software architecture you must be equipped with the basic skills, techniques and tools required through out the journey and this is exactly the purpose of the design path.

In this path, you will gain a lot of skills (such as development methodologies, design approaches, modeling techniques, design principles and patterns) that will support you through the subsequent paths.

By the end of this path, you will gain deep knowledge in the following topics:

• Responsibility-driven design (RDD) which is the base for Domain-Driven Design
• Object-Oriented (OO) Analysis and Design
• SOLID principles
• Modeling using UML
• GRASP principles
• Basic Agile Development concepts
• Object-Oriented (OO) Design Patterns
• Domain-Driven Design (DDD)

Book 1: Applying UML and Patterns, by Larman

This is a must read book and it must be your first book, because it will provide you with all you need to comprehend the subsequent books correctly. In this book you will learn:

• Object-Oriented Analysis and Design
• Modeling using UML (which is required while reading all the upcoming books)
• SOLID principles (I found it useful to learn about SOLID principles before reading any of the OO Design Patterns)
• Responsibility-Driven Design (RDD) and GRASP principles which are considered the base for Domain-Driven Design (I found it important to understand RDD before reading DDD)
• Development using Agile methodology
• Few design patterns

Book 2: Head First Design Patterns, by Freeman

This book must be your second book to learn about OO Design Patterns. In this book, you will learn, in a very simple, yet comprehensive, way, the context of each , the problem it addresses and the solution it proposes.

The thing I liked most in this book is the focus on explaining the relationship between the design patterns and SOLID principles (SOLID principles covered in Book 1) and how the design patterns' solutions are implemented to enforce the different SOLID principles.

Book 3:Object Design: Roles, Responsibilities and Collaboration, by Ivar

This book is taking the RDD (RDD basics are covered in Book 1) to the next level and taking it into more details.

The thing I liked most in this book is the differentiation between role and responsibility, roles stereotypes and CRC cards that can be used to capture early design ideas.

Book 4: Domain-Driven Design Tackling Complexity in the Heart of Software, by Eric

This book is the last in the design path and it is also must to read. This book is following RDD principles (RDD covered in Book 1 and Book 3) to build domain model using techniques that aligns with the business domain and business stakeholders.

Architecture Fundamentals Path

While the design path was the preparation stage, Architecture Fundamentals is actually your first steps into the software architecture where you will learn about the main architectural concepts, principles, best practices and patterns and you will also learn about architecture documentation.

Book 5: Fundamentals of Software Architecture, by Mark Richards

In this book, you will learn the basic architectural concepts, elements, characteristics, rules, principles, measures and styles. It also shows the most important skills that an architect must have.

Book 6: Clean Architecture, by Robert Martin

This book is building on the previous book by focusing more on the architecture structure and the relationships between the different parts to come up with clean, maintainable and extendible solution.

I found Component Principles (Reuse/Release Equivalence, Common Closure, Common Reuse, Acyclic Dependencies, Stable Dependencies, Stable Abstractions principles) very useful.

Book 7: Documenting Software Architecture, by Paul Clements

By now, you should be able to build an architecture based on Books 5 and 6 and you need now to document them. This book explains how an architecture must be described and documented, although I didn't like the proposed template, but the book gives you all the techniques you need to build your own template and eventually your architecture documents.

Bonus Reading

If you are involved in projects delivery and you are a part of a DevOps process, I would recommend for you to read a book called "Continuous Architecture in Practice, by Murat Erder"

Summary

In this part, we started the reading journey by learning about the fundamentals path. Now we are ready to move on into; Application, Integration and/or Data Architecture paths.