Great software comes from great designers. Learn the essential software architecture fundamentals every programmer needs to know. With hands-on examples in every chapter, tips and advice from respected architects, practical scenarios, and dozens of architectural design activities, Design It! shows you how to lead your team as a software architect to create excellent software.
Uncover the big ideas behind software architecture and learn practical methods for designing software systems big and small. Gain a framework for thinking about design, enabling you to plan, lead, design, implement, and evaluate software architectures. Collaborate with your team, stakeholders, and other architects. Dig for architecturally significant requirements and write detailed quality attribute scenarios. Explore design alternatives, balance trade-offs, manage risks, and choose technologies based on their architectural impact. Make the architecture real for everyone with powerful sketches, engaging stories, and lean documentation people love to read. Evaluate your designs using lightweight methods and harness the power of your team to improve the architecture over time. Host collaborative workshops that create buy-in and get the whole team excited and involved in designing the software architecture.
Hands-on exercises, real-world scenarios, and practical team-based decision-making tools will give you the experience you need to become a confident software architect.

Design and build scalable web applications quickly
This is an invaluable roadmap for meeting the rapid demand to deliver scalable applications in a startup environment. With a focus on core concepts and best practices rather than on individual languages, platforms, or technologies, Web Scalability for Startup Engineers describes how infrastructure and software architecture work together to support a scalable environment.
You’ll learn, step by step, how scalable systems work and how to solve common challenges. Helpful diagrams are included throughout, and real-world examples illustrate the concepts presented. Even if you have limited time and resources, you can successfully develop and deliver robust, scalable web applications with help from this practical guide.
Learn the key principles of good software design required for scalable systems Build the front-end layer to sustain the highest levels of concurrency and request rates Design and develop web services, including REST-ful APIs Enable a horizontally scalable data layer Implement caching best practices Leverage asynchronous processing, messaging, and event-driven architecture Structure, index, and store data for optimized search Explore other aspects of scalability, such as automation, project management, and agile teams

"Eric Evans has written a fantastic book on how you can make the design of your software match your mental model of the problem domain you are addressing. "His book is very compatible with XP. It is not about drawing pictures of a domain; it is about how you think of it, the language you use to talk about it, and how you organize your software to reflect your improving understanding of it. Eric thinks that learning about your problem domain is as likely to happen at the end of your project as at the beginning, and so refactoring is a big part of his technique. "The book is a fun read. Eric has lots of interesting stories, and he has a way with words. I see this book as essential reading for software developers-it is a future classic." -Ralph Johnson, author of Design Patterns "If you don't think you are getting value from your investment in object-oriented programming, this book will tell you what you've forgotten to do. "Eric Evans convincingly argues for the importance of domain modeling as the central focus of development and provides a solid framework and set of techniques for accomplishing it. This is timeless wisdom, and will hold up long after the methodologies du jour have gone out of fashion." -Dave Collins, author of Designing Object-Oriented User Interfaces "Eric weaves real-world experience modeling-and building-business applications into a practical, useful book. Written from the perspective of a trusted practitioner, Eric's descriptions of ubiquitous language, the benefits of sharing models with users, object life-cycle management, logical and physical application structuring, and the process and results of deep refactoring are major contributions to our field." -Luke Hohmann, author of Beyond Software Architecture "This book belongs on the shelf of every thoughtful software developer." -Kent Beck "What Eric has managed to capture is a part of the design process that experienced object designers have always used, but that we have been singularly unsuccessful as a group in conveying to the rest of the industry. We've given away bits and pieces of this knowledge...but we've never organized and systematized the principles of building domain logic. This book is important." -Kyle Brown, author of Enterprise Java(TM) Programming with IBM(r) WebSphere(r) The software development community widely acknowledges that domain modeling is central to software design. Through domain models, software developers are able to express rich functionality and translate it into a software implementation that truly serves the needs of its users. But despite its obvious importance, there are few practical resources that explain how to incorporate effective domain modeling into the software development process. Domain-Driven Design fills that need. This is not a book about specific technologies. It offers readers a systematic approach to domain-driven design, presenting an extensive set of design best practices, experience-based techniques, and fundamental principles that facilitate the development of software projects facing complex domains. Intertwining design and development practice, this book incorporates numerous examples based on actual projects to illustrate the application of domain-driven design to real-world software development. Readers learn how to use a domain model to make a complex development effort more focused and dynamic. A core of best practices and standard patterns provides a common language for the development team. A shift in emphasis-refactoring not just the code but the model underlying the code-in combination with the frequent iterations of Agile development leads to deeper insight into domains and enhanced communication between domain expert and programmer. Domain-Driven Design then builds on this foundation, and addresses modeling and design for complex systems and larger organizations.Specific topics covered include: * Getting all team members to speak the same language * Connecting model and implementation more deeply * Sharpening key distinctions in a model * Managing the lifecycle of a domain object * Writing domain code that is safe to combine in elaborate ways * Making complex code obvious and predictable * Formulating a domain vision statement * Distilling the core of a complex domain * Digging out implicit concepts needed in the model * Applying analysis patterns * Relating design patterns to the model * Maintaining model integrity in a large system * Dealing with coexisting models on the same project * Organizing systems with large-scale structures * Recognizing and responding to modeling breakthroughs With this book in hand, object-oriented developers, system analysts, and designers will have the guidance they need to organize and focus their work, create rich and useful domain models, and leverage those models into quality, long-lasting software implementations.

Kubernetes in Action teaches you to use Kubernetes to deploy container-based distributed applications. You'll start with an overview of Docker and Kubernetes before building your first Kubernetes cluster. You'll gradually expand your initial application, adding features and deepening your knowledge of Kubernetes architecture and operation. As you navigate this comprehensive guide, you'll explore high-value topics like monitoring, tuning, and scaling.
Kubernetes is Greek for "helmsman," your guide through unknown waters. The Kubernetes container orchestration system safely manages the structure and flow of a distributed application, organizing containers and services for maximum efficiency. Kubernetes serves as an operating system for your clusters, eliminating the need to factor the underlying network and server infrastructure into your designs.

我们总是喜欢借鉴别人的架构实践，参考别人的架构图，但体会过的人都知道，由于各家公司的行业背景、发展情况、人力资源都不同，所以真正意义上的架构借鉴难度很大。 《聊聊架构》希望揭开事物的外在“表皮”，再现架构深层之理，向读者揭示最本质的架构之道。
架构是如何运作并影响人们的日常生活的，在软件行业中架构是如何运作的？架构又是如何指导代码编写的，如何把架构应用在软件工程实践上？带着这些疑问，《聊聊架构》通过大量的实例一步一步揭示出架构背后的原理，以及架构在软件行业的发展，并通过企业实例来展示软件架构的实际应用。《聊聊架构》没有高深的词汇，不仅适合IT 从业人员阅读，也适合其他行业的人士阅读。尤其对于想从事架构工作的人而言，是一本不可多得的参考材料。

Developing reliable, scalable distributed systems today is often more black art than science. Building these systems is complicated and, because few formally established patterns are available for designing them, most of these systems end up looking very unique. This practical guide shows you how to use existing software design patterns for designing and building reliable distributed applications.Although patterns such as those developed more than 20 years ago by the Gang of Four were largely restricted to running on single machines, author Brendan Burns—a Partner Architect in Microsoft Azure—demonstrates how you can reuse several of them in modern distributed applications.Systems engineers and application developers will learn how these patterns provide a common language and framework for dramatically increasing the quality of your system.

Architects look at thousands of buildings during their training, and study critiques of those buildings written by masters. In contrast, most software developers only ever get to know a handful of large programs well—usually programs they wrote themselves—and never study the great programs of history. As a result, they repeat one another's mistakes rather than building on one another's successes.
This book's goal is to change that. In it, the authors of twenty-five open source applications explain how their software is structured, and why. What are each program's major components? How do they interact? And what did their builders learn during their development? In answering these questions, the contributors to this book provide unique insights into how they think.
If you are a junior developer, and want to learn how your more experienced colleagues think, this book is the place to start. If you are an intermediate or senior developer, and want to see how your peers have solved hard design problems, this book can help you too.