Software Mistakes and Tradeoffs, Video Edition

Software Mistakes and Tradeoffs, Video Edition

English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 96 Lessons (13h 57m) | 2.19 GB

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.

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.

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
Table of Contents

1 Introduction
2 Code design patterns and why they do not always work
3 Architecture design patterns and why they do not always work
4 Code duplication is not always bad Code duplication vs. flexibility
5 Libraries and sharing code between codebases
6 Code extraction to a separate microservice
7 Looking at the tradeoffs and disadvantages of a separate service
8 Improving loose coupling by code duplication
9 Looking at inheritance and tight coupling
10 Exceptions vs. other patterns of handling errors in your code
11 Best patterns to handle exceptions in the code that you own
12 Anti-patterns in exception handling
13 Exceptions from third-party libraries
14 Exceptions in multithread environments
15 Functional approach to handling errors with Try
16 Using Try in production code
17 Performance comparison of exception-handling code
18 Balancing flexibility and complexity
19 Allowing clients to provide their own metrics framework
20 Guarding against unpredictable usage of the hooks API
21 Providing extensibility of your APIs via listeners
22 Flexibility analysis of an API vs. the cost of maintenance
23 Premature optimization vs. optimizing the hot path Decisions that impact code performance
24 Optimizing processing based on false assumptions
25 Hot paths in your code
26 A word service with a potential hot path
27 Hot path detection in your code
28 Improvements for hot path performance
29 Optimizing word exists using a cache
30 Simplicity vs. cost of maintenance for your API
31 Directly exposing settings of a dependent library
32 Adding new setting for the cloud client library
33 Deprecatingremoving a setting in the cloud client library
34 Working effectively with date and time data
35 Machine time Instants, epochs, and durations
36 Civil time Calendar systems, dates, times, and periods Part 1
37 Civil time Calendar systems, dates, times, and periods Part 2
38 Time zones, UTC, and offsets from UTC Part 1
39 Time zones, UTC, and offsets from UTC Part 2
40 Date and time concepts that hurt my head
41 Preparing to work with date and time information
42 Clarifying date and time requirements Part 1
43 Clarifying date and time requirements Part 2
44 Using the right libraries or packages
45 Improving testability by avoiding defaults Part 1
46 Improving testability by avoiding defaults Part 2
47 Representing date and time values in text Part 1
48 Representing date and time values in text Part 2
49 Explaining code with comments
50 Handling ambiguous or skipped times
51 Working with evolving time zone data
52 Leveraging data locality and memory of your machines
53 Data partitioning and splitting data
54 Partitioning vs. sharding
55 Join big data sets from multiple partitions
56 Data processing Memory vs. disk
57 Calculating access times
58 Implement joins using Apache Spark
59 Third-party libraries Libraries you use become your code
60 Concurrency models and scalability
61 Testability
62 Testing with fakes (test double) and mocks
63 Dependencies of third-party libraries
64 Choosing and maintaining third-party dependencies
65 Security and updates
66 Consistency and atomicity in distributed systems
67 Producing data and idempotency
68 A naive implementation of a deduplication library
69 Common mistakes when implementing deduplication in distributed systems
70 Making your logic atomic to prevent race conditions
71 Delivery semantics in distributed systems
72 Producer and consumer applications based on Apache Kafka
73 The producer logic
74 Consumer code and different delivery semantics
75 Restarting from the earliest or latest offsets
76 Leveraging delivery guarantees to provide fault tolerance
77 Managing versioning and compatibility
78 Semantic versioning
79 Versioning for libraries
80 Source, binary, and semantic compatibility Part 1
81 Source, binary, and semantic compatibility Part 2
82 Techniques for handling breaking changes
83 Managing internal-only libraries
84 Common versioning strategies Part 1
85 Common versioning strategies Part 2
86 Further versioning considerations
87 Versioning for data storage
88 Migrating data within a storage system
89 Expecting the unexpected
90 Separating API and storage representations
91 Keeping up to date with trends vs. cost of maintenance of your code
92 Do-it-yourself (DIY) dependency injection
93 When to use reactive programming
94 Using CompletableFuture
95 When to use functional programming
96 Using lazy vs. eager evaluation