Software Mistakes and Tradeoffs: How to Make Good Programming Decisions
$0.99
Price: $0.99
(as of Oct 31, 2024 23:02:35 UTC – Details)
In Software Mistakes and Tradeoffs, you will learn how to:
Reason about your systems to make intuitive and better design decisionsUnderstand consequences and how to balance tradeoffs Pick the right library for your problemThoroughly analyze all of your service’s dependenciesUnderstand delivery semantics and how they influence distributed architectureDesign and execute performance tests to detect code hot paths and validate a system’s SLADetect and optimize hot paths in your code to focus optimization efforts on root causesDecide on a suitable data model for date/time handling to avoid common (but subtle) mistakesReason about compatibility and versioning to prevent unexpected problems for API clientsUnderstand tight/loose coupling and how it influences coordination of work between teamsClarify requirements until they are precise, easily implemented, and easily testedOptimize 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 leads to major problems down the road, so you can preempt 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.
PLEASE NOTE: When you purchase this title, the accompanying PDF will be available in your Audible Library along with the audio.
5 reviews for Software Mistakes and Tradeoffs: How to Make Good Programming Decisions
Add a review
You must be logged in to post a review.
$0.99
Chu Chen –
Know the tradeoffs in the real world
(I read the PDF version of this book)This is a very good book for the senior engineers to broaden the scope and vision. It tells in honesty when and why to break some rules at times, e.g. code duplication is not always bad. The book has very common and practical examples, such as code duplications, lib v.s. service, etc.Some great points really beneficial to software engineers at all levels, cherry-picked from my memory:1. need to understand the alternatives and tradeoff before hand, to avoid common pitfalls too late to fix later2. understand best practice, such that the direction is not too far from being optimal3. thinking process on why choosing one over another due to tradeoffs4. textbook theory couples with practice: singleton pattern, multithreading context, etc5. speaking of the truth instead of blindly advocate one technology, e.g. design patternsLast but no least, the book also covers the traditional OOP way vs functional ways (Monads!)
FingolfinTEK –
A mixed bag, probably worth a read for junior devs
The book opens with three chapters of fairly Java-specific topics too trivial for anyone but absolute beginners; I get the idea of demonstrating the approach to be taken in the rest of the book but spending almost 20% of the book on it seems excessive.The writing quality fluctuates, so even some of the chapters that follow aren’t much better – they all start with a statement along the lines of “When doing X, making a choice of Y has the consequence of Z” and then proceed to demonstrate the statement with some examples. A fairly typical approach but my issue here is the realisation of the idea – examples are mainly too simple or contrived to do anything useful except prove the initial point – I’d have expected to see advice on how to detect, document and balance the tradeoffs in a real world scenario, not just a “be aware of the tradeoffs for they are there” mantra repeated over and over in different incarnations.Overall, the writing in poor chapters is filled with useless text explaining the obvious, e.g. “component shared with other teams and users” had to have an accompanying sentence explaining the above meant it will be used by other people. While most of the waffle wasn’t as drastic, it does start to chafe fairly quickly.There are also very few references – many chapters touch upon topics on which books can and have been written so would have been nice to throw in a section with further reading materials.But, as you could guess from the title, the book isn’t all bad – except when using async and nonblocking interchangeably, the tradeoffs it lists are all there and it’s useful for beginner devs know about them and to know how to spot tradeoffs in their projects, and that’s what I think this book still manages to do quite well.
Harinath Mallepally –
A realistic book on software tradeoffs
(Disclaimer: I am writing this review reading this text on manning livebook. This book is a truely a book with long shelf life. Addresses issues that are familiar to most developers and not everything need to be fixed, if designed correctly. While providing details of various scenarios applicable for most in the industry, it also confirms some of the practices that we follow.Not everything need to follow some best practice, code duplication may be ok at times, and letting application or API crash at times is ok if that is outside of the designed context etc and advice on starting public APIs with limited but robust functionalities and extending from there..Its a worth read for every engineer and architect and one of the few titles from manning that will truly have long shelf life!
Sam –
How to make better design decisions
The perfect solution doesnât exist but acknowledging that you are making trade-offs will help you make better decisions.The book clearly shows a detailed look at how to make design decisions â I wish I had it earlier in my career
ar –
One of the most informative books on tradeoffs ever written
This book doesnât shy away from the consequences – the decisions we gave in software engineering are difficult, and by carefully examining tradeoffs in modern software cases we can make better decisions over time. Highly recommended