Yaknyam Press A Philosophy of Software Design, 2nd Edition

Great book! Very clear and pragmatic explanation of what matters in Software Design. Also recommend the The Pragmatic Engineer podcast episode with John Ousterhout (author) for a great overview of some ideas in the book.

Mi pareja compró este libro para leerlo, tal y como ha hecho con otros libros. Sin embargo acaban decorando una estantería.

It's an amazing book where you get insights about how to build and maintain a software design. It's technical, but not a heavy reading, which makes it even more enjoyable.

The book's examples are mostly from programs running on an OS, with significant iron underneath. I mostly work with embedded systems, which are severely resource contained, often running on bare metal with a limited thread scheduler. Still, I found the book being generic enough to be applicable for that niche as well. I completely agree with Prof Ousterhout regarding shallow methods, variable duplication and the like being red flags. He repeatedly re-iterates the importance of hiding implementation details, which is actually one of the stated goals of OOP, The book tries to drive a point through: your system's long-term manageability depends on its abstractions, how you partition the task at hand into self-contained chunks with minimum, or preferably no interdependence between them. Yes, it cost a a lot of design time without cranking out any code, but this investment will be paid back during the actual implementation, and, more importantly, during the lifetime of the project (which with embedded systems is often decades). I especially like his talking about commenting the code and how comments provide meta-information that the code does not convey. The code should be obvious, sure. You read it and should know what it does. But will you know why it does it the way it does? Often the code is written on a particular way to accommodate peculiarities of the underlying hardware, and it incorporates a lot of knowledge/mathematics of a completely different field that the device services. You might have it all in your head when working on the project, but expecting the next guy (or even yourself a few years later) to know it all is not realistic. Comments can point out all those externalities and provide a rational for particular, possibly counter-intuitive, design choices employed in the code. Overall, I think the book is an eye-opener, at least it should make you think about abstractions, interactions, separation, generalisation, and, the most important message of the book, minimising complexity.

Very well written, it manages to frame many software design principles in a refreshing new, and above all, actionable way. The author presents many valuable lessons without getting bogged down by programming language minutiae that are irrelevant to the principles being presented. I highly recommend this to all software developers, regardless of their level of experience.