The evolution of software means that, over time, systems grow to be more and more complex, and require more and more developers working on them in a coordinated fashion. As the size increases, a general structure arises from there. This structure, if not well planned, can become really chaotic and difficult to work with.
The challenge of software architecture is to plan and design this structure. A well-designed architecture makes different teams able to interact with each other while at the same time having a clear understanding of their own responsibilities and their goals.
The architecture of a system should be designed in a way that day-to-day software development is possible with minimal resistance, allowing for adding features and expanding the system. The architecture in a live system is also always in flux, and can be adjusted and expanded as well, reshaping the different software elements in a deliberate and smooth fashion.
In this book we will see the different aspects of software architecture, from the top level to some of the lower-level details that support the higher view. The book is structured in four sections, covering all the different aspects in the life cycle:
- Design before writing any code
- Architectural patterns to use proven approaches
- Implementation of the design in actual code
- Ongoing operation to cover changes, and verification that it’s all working as expected
During the book we will cover different techniques across all these aspects.
Who this book is for
This book is for software developers that want to expand their knowledge of software architecture, whether experienced developers that want to expand and solidify their intuitions about complex systems, or less experienced developers who want to learn and grow their abilities, facing bigger systems with a broader view.
We will use code written in Python for the examples. Though you’re not required to be an expert, some basic knowledge of Python is advisable.
What this book covers
Chapter 1, Introduction to Software Architecture, presents the topic of what software architecture is and why it is useful, as well as presenting a design example.
The first section of the book covers the Design phase, before the software is written: Chapter 2, API Design, shows the basics of designing useful APIs that abstract the operations conveniently.
Chapter 3, Data Modeling, talks about the particularities of storage systems and how to design the proper data representation for the application.
Chapter 4, The Data Layer, goes over the code handling of the stored data, and how to make it fit for purpose.
Next, we will present a section that covers the different Architectural patterns available, which reuse proven structures:
Chapter 5, The Twelve-Factor App Methodology, shows how this methodology includes good practices that can be useful when operating with web services and can be applied in a variety of situations.
Chapter 6, Web Server Structures, explains web services and the different elements to take into consideration when settling on both the operative and the software design.
Chapter 7, Event-Driven Structures, describes another kind of system that works asynchronously, receiving information without returning an immediate response.
Chapter 8, Advanced Event-Driven Structures, explains more advanced usages for asynchronous systems, and some different patterns that can be created.
Chapter 9, Microservices vs Monolith, presents these two architectures for complex systems, and goes over their differences.
The Implementation section of the book covers how the code is written:
Chapter 10, Testing and TDD, talks about the fundaments of testing and how Test Driven Development can be used in the coding process.
Chapter 11, Package Management, follows the process of creating reusable parts of code and how to distribute them.
Finally, the last section deals about Ongoing operations, where the system is in operation and requires monitoring at the same time that is adjusted and changed:
Chapter 12, Logging, describes how to record what working systems are doing.
Chapter 13, Metrics, discusses aggregating different values to see how the whole system is behaving.
Chapter 14, Profiling, explains how to understand how code is executed to improve its performance.
Chapter 15, Debugging, covers the process of digging deep into the execution of code to find and fix errors.
Chapter 16, Ongoing Architecture, describes how to successfully operate architectural changes on running systems.
- 关于本书的内容介绍、目录、详情等请在 Amazon、Goolge Books 等售书网站搜索查看，本站仅展示封面作为参考。
- 如无特殊说明，本站提供的所有pdf均为文字版（aka True PDF or Digitally Created PDF）。
扫描下方二维码添加微信号 bookyage 回复本书编号 995555 即可，我们会尽快（一般24小时之内）将本书PDF文件以百度网盘链接的形式发送给您。