Javarevisited
Published in

Javarevisited

Software Engineering Mistakes and Trade-offs Book by Jon Skeet and Tomasz Lelek

Hello guys, how are you doing? If you looking for an interesting software development book to read this weekend then you have come to the right place.

In this article, I am going to share with you an awesome Software development book that can help you make good programming decisions by avoiding common Software development Mistakes.

Yes, you guessed it right? I am talking about Software Engineering Mistakes and Trade-offs. by Tomasz Lelek and Jon Skeet on Manning publication.

Tomasz Lelek and Jon Skeet wrote a book about the work of everyone involved in delivering software that is full of trade-offs.

Many of us are operating in a limited time, budget, and also limited knowledge. Therefore, today’s decision about the software that we are creating will have consequences in the future.

The consequences can involve maintenance cost, inflexibility of our software when it needs to change, limited performance when we need to scale, and many more.

It is important to note that every decision is made in a specific context. It’s easy to judge past decisions without complete knowledge about the context when they were made.

However, the more knowledge and the more deep analysis we do at the decision time, the more aware we can be about the trade-offs that our decisions carry.

The authors of the book were involved in and observed many software decisions and learned what tradeoffs they impose throughout their professional careers.

Along the way, Tomasz started writing a personal decision log of the circumstances where a specific decision was made. What was the context of it? What were the alternatives? How did we evaluate a particular solution, and finally, how it ends up.

Did we anticipate all possible tradeoffs of a specific solution? Or were we surprised by something? It turns out that this personal list of lesson-learned is quite generic because those problems and decisions need to be tackled by many engineers out there.

At this point, Tomasz decided that this is an excellent time to share that knowledge with the world. This is how the idea for this book was born.

Authors want to share their lessons learned from the experience with various software systems: monoliths, microservices, big data processing, libraries, and many more.

This book will go through decisions, tradeoffs, and mistakes from real-life production systems and will try to analyze them deeply. By presenting those patterns, mistakes, and lessons, authors hope to widen your context and equip you with better tools This knowledge will help you when you need to make those decisions in your day-to-day job.

Seeing potential problems and limitations of a design upfront can save you a lot of time and money in the future. The book won’t try to give you definite answers.

When the problem is complex, it can often be solved by more than one approach. The authors will present some of those challenging problems and ask questions without definite answers.

Each solution will have its pros and cons, and they will analyze those. Every solution will result in its tradeoffs, and it will be up to you to decide which one suits your context the best.

The book contains 13 chapters — each chapter focuses on real-world problems you may encounter in your production systems. It tries to analyze every situation in a variety of contexts and consider all its tradeoffs. It also presents some non-obvious mistakes that may significantly impact your systems from various perspectives (not only correctness).

  • Some of the topics covered in this book are:
  • Why is code duplication not always bad? Code-duplication vs. flexibility.
  • Java Exceptions vs. other patterns of handling errors in your code
  • How to optimize your code in the chapter: Premature optimization vs. optimizing hot-path — decisions that impact the performance of your code
  • Working effectively with date/time data
  • How to pick a proper 3rd party library for your project?
  • Learn how to design your big data processing leveraging data-locality
  • How to deal with delivery semantics in distributed systems?
  • Versioning your APIs and Data and making your system keep the compatibility

and many more. For a list of all covered topics, please take a look at the table of contents.

Overall a great course to learn your software development skill by learning about mistakes and tradeoffs. If you have any input or feedback for authors, feel free to share it here. It would be highly appreciated! if you decide to buy, you can use the 35% discount code: jrlelek35

--

--

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store
javinpaul

javinpaul

23K Followers

I am Java programmer, blogger, working on Java, J2EE, UNIX, FIX Protocol. I share Java tips on http://javarevisited.blogspot.com and http://java67.com