Why do I need to learn about advanced software design?

Your task now is not just to build a house, it is to build a city. Soon, you will be creating very complex software. You are responsible for designing a system containing around 10,000 classes or functions for 5,000 users to use over the next 15 years. The maximum allowable system downtime must be less than five minutes per year.

Imagine you have to create a system that serves millions of users simultaneously, like Facebook, YouTube, Amazon, Office 365, or Gmail. Are you confident in building one?

Now imagine you are tasked with creating a web framework for developers to extend, such as ASP.NET, Yii, or React. Are you confident you could create one?

If you are unsure how to accomplish these tasks, it is probably wise to study how others have built similar systems and adapt their approaches to your situation. Advanced software design equips you with the knowledge and tools needed to begin building your own complex software.

What can I do after finishing learning advanced software design?

You will learn how to design a complex software system that satisfies not only functional requirements but also security, modifiability, scalability, reusability, extensibility, and reliability requirements..

That sounds interesting! What should I do now?

Nowadays, software can be applied to many fields, each requiring specific advanced software design knowledge. In this topic, we focus only on enterprise software due to its popularity.

Before designing a complex system, you must thoroughly understand its sophisticated requirements. This is a critical step in building any large system.

First, please read this book to learn how to elicit, analyze and document requirements for an enterprise system: David C. Hay (2002). Requirements Analysis: From Business Views to Architecture. Prentice Hall PTR.

After that, please read this book to learn about transactional processing principles and techniques: Philip A. Bernstein and Eric Newcomer (2009). Principles of Transaction Processing. Second Edition. Morgan Kaufmann.

After that, please read the books below to learn how to leverage domain-driven design approach to reduce software complexity.

• Eric Evans (2003). Domain-Driven Design: Tackling Complexity in the Heart of Software. Addison Wesley
• Jimmy Nilsson (2006). Applying Domain-Driven Design and Patterns: With Examples in C# and .NET. Addison-Wesley Professional
• Dino Esposito and Andrea Saltarello (2014). Microsoft .NET: Architecting Applications for the Enterprise. Microsoft Press
• Vaughn Vernon (2013). Implementing Domain-Driven Design. Addison-Wesley Professional

After that, please read the books below to learn how to design microservices:

• Mark Endrei et al. (2004). Patterns: Service-Oriented Architecture and Web Services. IBM Corp
• Sam Newman (2021). Building Microservices: Designing Fine-Grained Systems. O’Reilly
• Sam Newman (2019). Monolith to Microservices – Evolutionary Patterns to Transform Your Monolith. O’Reilly Media
• Cloves Carneiro and Tim Schmelmer (2016). Microservices From Day One. Apress

After that, please read the books below to learn how to leverage event sourcing and stream processing to design scalable big data software systems:

• Martin Kleppmann (2016). Making Sense of Stream Processing. O’Reilly Media
• Nathan Marz and James Warren (2015). Big Data: Principles and Best Practices of Scalable Realtime Data Systems. Manning Publications
• Ian Gorton (2022). Foundations of Scalable Systems – Designing Distributed Architectures. O’Reilly Media

Terminology Review:

• Enterprise Applications
• Enterprise Systems
• Transaction Processing
• Microservices
• Domain-Driven Design
• Entities
• Value Objects
• Aggregates
• Domain Events
• Factories
• Repository Interfaces
• Repository Implementations
• Bound Contexts
• Event Sourcing
• Command Query Responsibility Segregation (CRQS)
• Stream Processing
• Lambda Architecture
• Kappa Architecture
• Event-Driven Architecture
• Serverless

After finishing advanced software design, please click on Topic 17 – Calculus to continue.