Название: Principles of Software Architecture Modernization: Delivering engineering excellence with the art of fixing microservices
Автор: Diego Pacheco, Sam Sgro
Издательство: BPB Publications
Год: 2024
Страниц: 474
Язык: английский
Формат: epub (true)
Размер: 19.7 MB

Long path to better systems that last longer and make engineers and customers happier.

Key Features:

- Guidance, trade-offs analysis, principles, and insights on understanding complex microservices and monoliths problems and solutions at scale.
- In-depth coverage of anti-patterns, allowing the reader to avoid pitfalls and understand how to handle architecture at scale better.
- Concepts and lessons learned through experience in performing code and data migration at scale with complex architectures. Best usage of new technology using the right architecture principles.

Description:

This book is a comprehensive guide to designing scalable and maintainable software written by an expert. It covers the principles, patterns, anti-patterns, trade-offs, and concepts that software developers and architects need to understand to design software that is both scalable and maintainable.

The book begins by introducing the concept of monoliths and discussing the challenges associated with scaling and maintaining them. It then covers several anti-patterns that can lead to these challenges, such as lack of isolation and internal shared libraries.

The next section of the book focuses on the principles of good software design, such as loose coupling and encapsulation. It also covers several software architecture patterns that can be used to design scalable and maintainable monoliths, such as the layered architecture pattern and the microservices pattern.

The final section of the book guides how to migrate monoliths to distributed systems. It also covers how to test and deploy distributed systems effectively.

Our goal with this book is to make sure you can fully understand the problems around monoliths and how you can approach them correctly and effectively. We will help you stop the bleeding, make sense of your reality, and have a path forward to better days and better systems using solid architectural principles and a bit of creativity.

We will be very technical in this book and will connect many different subjects, but don't worry. We will explain things in depth and with lots of practical scenarios and examples. The topics we will cover are wide-ranging, and sometimes we will review the same points from different angles to uncover different perspectives. We hope you like it, and thank you in advance for your readership.

Monoliths are a style of software architecture where a large amount of code is deployed using a small number of deployment units like exes, JARs, WARs, etc. In short, a big codebase with a few deployed artifacts. It is the natural state of most application development when it just gets started, having all the code in the same code repository and deployment unit simplifies your life in the early days where finding product-market fit trumps premature optimization. Monoliths typically have a lot of code. It could be in one source code repository or multiple repos for some types of monoliths which we will discuss later. But, there is ALWAYS a lot of code involved. Of course, what is big is relative. Big codebases are not a problem per se; it is more like a smell, but it happens often enough that it is a key characteristic of a monolith.

What you will learn:

- Understand the challenges of monoliths and the common anti-patterns that lead to them.
- Learn the principles of good software design, such as loose coupling and encapsulation.
- Discover software architecture patterns that can be used to design scalable and maintainable monoliths.
- Get guidance on how to migrate monoliths to distributed systems.
- Learn how to test and deploy distributed systems effectively.

Who this book is for:
This book is for software developers, architects, system architects, DevOps engineers, site reliability engineers, and anyone who wants to learn about the principles and practices of modernizing software architectures. The book is especially relevant for those who are working with legacy systems or want to design new systems that are scalable, resilient, and maintainable.

Contents: