软件错误与权衡：如何做出良好的编程决策

通过探索专家开发人员的常见错误和有意权衡，优化定义代码的决策。
在软件错误和权衡中，你将学会如何
让您的系统做出直观、更好的设计决策
了解后果以及如何平衡权衡
为你的问题选择合适的库
彻底分析服务的所有依赖关系
理解交付语义以及它们如何影响分布式体系结构
设计并执行性能测试，以检测代码热路径并验证系统的SLA
检测并优化代码中的热路径，将优化工作集中在根本原因上
为日期/时间处理选择合适的数据模型，以避免常见（但微妙）错误
关于兼容性和版本控制以防止API客户端出现意外问题的原因
了解紧/松耦合以及它如何影响团队之间的工作协调
明确需求，直到它们精确、易于实施、易于测试
优化API以获得友好的用户体验
代码性能与简单性。与复制相比，交付速度更快。灵活性与可维护性在软件工程中，你所做的每一个决定都涉及到权衡。在软件错误和权衡中，你会从托马斯兹·莱莱莱克和乔恩·斯凯特在他们令人印象深刻的职业生涯中所遇到的代价高昂的错误中学到教训。你将探索现实世界中的场景，在这些场景中，对权衡的理解不足会导致未来的重大问题，因此你可以通过更深思熟虑的决策方法来预防自己的错误。
了解代码复制如何影响系统的耦合和演化速度，以及简单的需求如何隐藏日期和时间信息的细微差别。了解如何根据80/20帕累托原则有效地缩小优化范围，并确保分布式系统的一致性。你很快就会建立起那种只有多年经验才能积累的知识库。
购买纸质书包括曼宁出版社提供的PDF、Kindle和ePub格式的免费电子书。
关于技术
软件项目的每一步都需要权衡。在平衡速度、安全性、成本、交付时间、功能等因素时，合理的设计选择可能会在生产中产生问题。本书中的专家见解和相关战争故事将帮助您在设计和构建应用程序时做出正确的选择。
关于这本书
软件错误和权衡探索了做出错误权衡决定的现实世界场景，并阐明了本可以采取不同做法的地方。在这本书中，作者Tomasz Lelek和Jon Skeet分享了基于数十年软件工程经验的智慧，包括一些令人愉快的指导性错误。您将欣赏每个示例附带的具体提示和实用技巧，以及将改变您处理下一个项目方式的常青模式。
里面是什么
如何系统地推理你的软件
如何选择工具、库和框架
紧密耦合和松散耦合如何影响团队协调
精确、易于实施、易于测试的需求
关于读者
面向对软件设计和实现做出决策的中高级开发人员和架构师。
关于作者
Tomasz Lelek每天都使用各种生产服务、体系结构和JVM语言。Jon Skeet是一名谷歌工程师，也是《C#in Depth》一书的作者，他以对堆栈溢出的许多实际贡献而闻名。
目录
1导言
2代码复制并不总是坏事：代码复制与灵活性
3异常与代码中处理错误的其他模式
4平衡灵活性和复杂性
5过早优化与优化热路径：影响代码性能的决策
6 API的简单性与维护成本
7有效处理日期和时间数据
8利用计算机的数据位置和内存
9第三方库：您使用的库将成为您的代码
10分布式系统中的一致性和原子性
11分布式系统中的交付语义
12管理版本控制和兼容性
13跟上趋势与代码维护成本
Software Mistakes and Tradeoffs: How to make good programming decisions
Optimize the decisions that define your code by exploring the common mistakes and intentional tradeoffs made by expert developers.
In Software Mistakes and Tradeoffs you will learn how to
Reason about your systems to make intuitive and better design decisions
Understand consequences and how to balance tradeoffs
Pick the right library for your problem
Thoroughly analyze all of your service’s dependencies
Understand delivery semantics and how they influence distributed architecture
Design and execute performance tests to detect code hot paths and validate a system’s SLA
Detect and optimize hot paths in your code to focus optimization efforts on root causes
Decide on a suitable data model for date/time handling to avoid common (but subtle) mistakes
Reason about compatibility and versioning to prevent unexpected problems for API clients
Understand tight/loose coupling and how it influences coordination of work between teams
Clarify requirements until they are precise, easily implemented, and easily tested
Optimize your APIs for friendly user experience
Code performance versus simplicity. Delivery speed versus duplication. Flexibility versus maintainability—every decision you make in software engineering involves balancing tradeoffs. In Software Mistakes and Tradeoffs you’ll learn from costly mistakes that Tomasz Lelek and Jon Skeet have encountered over their impressive careers. You’ll explore real-world scenarios where poor understanding of tradeoffs lead to major problems down the road, so you can pre-empt your own mistakes with a more thoughtful approach to decision making.
Learn how code duplication impacts the coupling and evolution speed of your systems, and how simple-sounding requirements can have hidden nuances with respect to date and time information. Discover how to efficiently narrow your optimization scope according to 80/20 Pareto principles, and ensure consistency in your distributed systems. You’ll soon have built up the kind of knowledge base that only comes from years of experience.
Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.
About the technology
Every step in a software project involves making tradeoffs. When you’re balancing speed, security, cost, delivery time, features, and more, reasonable design choices may prove problematic in production. The expert insights and relatable war stories in this book will help you make good choices as you design and build applications.
About the book
Software Mistakes and Tradeoffs explores real-world scenarios where the wrong tradeoff decisions were made and illuminates what could have been done differently. In it, authors Tomasz Lelek and Jon Skeet share wisdom based on decades of software engineering experience, including some delightfully instructive mistakes. You’ll appreciate the specific tips and practical techniques that accompany each example, along with evergreen patterns that will change the way you approach your next projects.
What’s inside
How to reason about your software systematically
How to pick tools, libraries, and frameworks
How tight and loose coupling affect team coordination
Requirements that are precise, easy to implement, and easy to test
About the reader
For mid- and senior-level developers and architects who make decisions about software design and implementation.
About the author
Tomasz Lelek works daily with a wide range of production services, architectures, and JVM languages. A Google engineer and author of C# in Depth, Jon Skeet is famous for his many practical contributions to Stack Overflow.
Table of Contents
1 Introduction
2 Code duplication is not always bad: Code duplication vs. flexibility
3 Exceptions vs. other patterns of handling errors in your code
4 Balancing flexibility and complexity
5 Premature optimization vs. optimizing the hot path: Decisions that impact code performance
6 Simplicity vs. cost of maintenance for your API
7 Working effectively with date and time data
8 Leveraging data locality and memory of your machines
9 Third-party libraries: Libraries you use become your code
10 Consistency and atomicity in distributed systems
11 Delivery semantics in distributed systems
12 Managing versioning and compatibility
13 Keeping up to date with trends vs. cost of maintenance of your code

OR