Understanding Software: Max Kanat-Alexander on simplicity, coding, and how to suck less as a programmer

by Max Kanat-Alexander

Key FeaturesRead and enjoy the superlative writing and insights of the legendary Max Kanat-AlexanderLearn and reflect with Max on how to bring simplicity to your software design principlesDiscover the secrets of rockstar programmers and how to also just suck less as a programmerBook DescriptionIn Understanding Software, Max Kanat-Alexander, Technical Lead for Code Health at Google, shows you how to bring simplicity back to computer programming. Max explains to you why programmers suck, and how to suck less as a programmer. There's just too much complex stuff in the world. Complex stuff can't be used, and it breaks too easily. Complexity is stupid. Simplicity is smart.

Understanding Software covers many areas of programming, from how to write simple code to profound insights into programming, and then how to suck less at what you do! You'll discover the problems with software complexity, the root of its causes, and how to use simplicity to create great software. You'll examine debugging like you've never done before, and how to get a handle on being happy while working in teams.

Max brings a selection of carefully crafted essays, thoughts, and advice about working and succeeding in the software industry, from his legendary blog Code Simplicity. Max has crafted forty-three essays which have the power to help you avoid complexity and embrace simplicity, so you can be a happier and more successful developer.

Max's technical knowledge, insight, and kindness, has earned him code guru status, and his ideas will inspire you and help refresh your approach to the challenges of being a developer.

What you will learnSee how to bring simplicity and success to your programming worldClues to complexity - and how to build excellent softwareSimplicity and software designPrinciples for programmersThe secrets of rockstar programmersMax's views and interpretation of the Software industryWhy Programmers suck and how to suck less as a programmerSoftware design in two sentencesWhat is a bug? Go deep into debuggingAbout the AuthorMax Kanat-Alexander is the Technical Lead for Code Health at Google, where he does various work that helps other software engineers be more productive, including writing developer tools, creating educational programs, guiding refactoring efforts, and more.

His roles at Google have included Tech Lead for YouTube on the Xbox, work on the Java JDK, JVM, and other aspects of Java for Google, and Technical Lead for Engineering Practices for YouTube, where he's supported developers across all of YouTube in best practices and engineering productivity. Max is a former Chief Architect of the Bugzilla Project, where he was one of the two main developers of the well-known Bugzilla Bug-Tracking System, used by thousands of organizations worldwide. Max also writes the legendary programming industry blog, Code Simplicity, where he challenges Complexity and embraces Simplicity for the programming industry.

Max has been involved for several years at Google with enabling developers to work more effectively and helping shape engineering practice, and in this highly readable collection of essays you can share the best of his experience.

Table of ContentsPart Principles for Programmers Part Software Complexity and its Causes Part Simplicity and Software Design Part Debugging Part

Genres: Programming, Technology, Software, Nonfiction, Audiobook, Coding

280 pages, Kindle Edition

Published September 29, 2017

About the author

Max is a Senior Software Engineer at Google and former Chief Architect of the Bugzilla Project. He has been fixing computers since he was eight years old and writing software since he was fourteen. He is the author of http://www.codesimplicity.com/ and http://www.fedorafaq.org/, and is currently living in Northern California.

Reviews

[Tony · Rating 1 out of 5]

There are a few useful nuggets sprinkled throughout, but in general this was a painful read, partially for the shallowness of the content, and partially for the shoddy job of hastily throwing a bunch of blogposts together and pretending it's a book.

[Rootul · Rating 2 out of 5]

I would not recommend this book. The author was the maintainer of an outdated issue tracking software and shares some not so insightful advice.

Insightful takeaways:
- Make developers feel appreciated. Be kind.
- Make it easy for developers to get started. Include getting started documentation and label issues that are good beginner tasks.

Sections I disliked:
- Software = knowledge
- His take on privacy
- Make every release of your software "suck less"

[Sloan · Rating 5 out of 5]

Very easy and short read with some geberal good info about the practice of writing software. Don't expect anything too in depth here as it seems primarily a collection of the author's blog posts.

[Carlos Ramos · Rating 5 out of 5]

Some very nice and clearly explained concepts of software design, explained in a conversational tone.

I finally put my hands in a book about software design principles that does not put me to sleep, and that I actually did finish.

Definitely, worth a read for any software developer out there!

[Chris Esposo · Rating 4 out of 5]

A very good book on the practice of software development, written to focus not only on good code hygiene, both from a design standpoint (though this is not a design book) and a refactoring process standpoint, but also from a communication standpoint, since authoring software is, more often than not, is a team-intensive exercise. The topics of the text start off focused on individual level topics on planning and designing software. How do you start to write code for a problem you do not yet know how to solve (write out the elements you do know how to handle, even if they are trivial etc.), how you should think about what should and should not be admissible for your functions and methods, and how being too admissible in your design can come back to haunt you (e.g. HTML).

Then the text moves on to how a well-run engineering organization is setup, specifically, the flow/cadence of prioritizing feature-development, bug issues, and the all-encompassing refactor/simplification activity that minimizes technical debt. What are proper metrics/KPIs for a software team, and how members of the team ought to communicate with each other. Other topics covered are an introduction to several program frameworks for code organization, specifically ISAR (Input, Structure, Action and Results), as well as several sections on testing, a topic I am in greater need of study on with respect to my smaller domain of machine learning development.

Throughout the text, the author peppers his overall and technology-specific design philosophy, which amount to ‘not sucking as much as you did before’ as a good way to improve your productivity (It almost sounds like a paraphrase from Bill Bellechick), as well as his opinions on privacy, developer pomposity, and the nature of knowledge and technology. All of these were enjoyable to listen to/read. I suspect this is a book one will have to revisit several times as they continue their growth in the field to refresh, observe alignment (or develop your own theory of why alignment may not make sense with your use-case). Overall, I think this is an appropriate book for newer and maybe some mid-level devs. Recommended.

[Masoud · Rating 5 out of 5]

This book contains a series of short essays on everything related to Software Engineering. Compared to Max's other book, Code Simplicity, this one is bigger, more comprehensive, and hence, covers more topics.

If I had to pick only one thing from the book, it'd be: the difference between an average and a rockstar programmer is understanding. "All you have to do to become an excellent programmer is fully understand what you're doing." It may seem obvious and non-revolutionary at first sight, but speaking from experience, it is as important as it's true. As the author puts it, "The vast majority (90% or more) of programmers have absolutely no idea what they are doing." Therefore, the code they write is hard to read, maintain, and debug. Examples of violating this principle that I've seen include but are certainly not limited to: not using joins when working with relational databases and performing the joins in the code (not understanding relational databases); using asynchronous programming in CPU-intensive applications to boost performance (not understanding async programming and when to use it); and using Python threads to achieve parallel computing (not understanding the Python GIL).

Max loves simplicity not only when it comes to writing software, but also writing books. I've also had the pleasure of talking to him a few times as he's an advisor to our company. He certainly knows what he's talking about.

[Zinedine Sr. · Rating 5 out of 5]

While it's true some of the books are outdated and it should have read before AI era, we have to remember for some reason the basic of the programming stays the same. Programming is easy, what's hard is to decide how and where to get things going by business, and how to suck less by not repeating the same pattern of code over and over, even if you know you can do things less easier in the future if you could just take the time to proper code.

Few things I like from this book:
1. Software Engineering is a skill not job
2. Standardization and simplicity are the key
3. Software engineering is human discipline, we know that it's one of raw representation of thought and intelligence
4. Structure, Action and Results are the general broad theme that is used to some main models we know: MVC
5. Testing validates our beliefs on designing code
6. Instant Gratification = Instant Failure

I admit the book does not go into detail of technical and tingling kind of code dizziness, but I think the book captures well the basic and some thoughts that we as programmer hold: simplicity and discipline

[Cakra · Rating 3 out of 5]

The long version of book Code Simplicity (by the same author). It is kind of a compiled blog posts from the author blog. The idea is still the same, simple is better. It's like Peopleware, but more modern.

This book could've been better if the author maybe make the chapters more coherent by give more proper editing, instead of just compile blog posts into a book. Some chapters were meh, the end chapters were boring.

I like the way it discuss philosophical aspect of software development, but the book could've been written better.

[Samiullah Khan · Rating 4 out of 5]

Most of the people have rated not well because they thought the author bundled up all those articles and formed an Audio book out of it.

Personally, for me this is the first time I have experience his work. So no prior context made the content fresh for me. I am at the level of intermediate and advanced level of programming so I kinda liked the advanced stuff of being a software engineer that included managing team, testing software and thinking about the end user on the other end.

Overall this book has some good information. I listened it mostly while using a treadmill 😀

[Nikolas Totiev · Rating 4 out of 5]

Read for my job. There was a lot of weird flexing throughout this book but ultimately it was a fun read because it was a philosophical approach to software. For me this is a perfect first book for someone who wants to turn from a software developer to a software engineer. But for everyone else? Not the best choice. I am with everyone else in this one. To me, this is a 3/5 book but I can see the value it could provide to others earlier in their careers.

[Monika Venckauskaite · Rating 4 out of 5]

This is a book about software development practices by Max Kanat-Alexander. Enjoyed it greatly.
Recommending this read to anybody who is about to start a bigger software project.
Or simply if you just want to learn valuable insights from teams who have many years of successful practices in development, testing, debugging and managing people.

[Constantine · Rating 4 out of 5]

Well, I expected something bigger. But overall it very well explains basic principles of software development and how to make your code better. Definitely should read this but do not expect it will make you understand software in an instant.

[Hildeberto · Rating 5 out of 5]

Good and easy reading about the craft of software development. It covers the principles, practices and challenges we normally face in our professional life. It remains in the surface of the subjects, not getting into deep discussions.

[Benjamin Torres · Rating 3 out of 5]

Almost all the points made throughout the book are pretty basic and common-sensical, but nonetheless they are important and needed to be made.
I would have liked a deeper analysis and views on the problems of creating software and the methologies, but it is a good starting point.
This kind of book should be tought to all computer science students.

[Shayne · Rating 4 out of 5]

Impactful: I intend to try some of these ways of thinking because I think they will lend some clarity to some of my work.

[Marek · Rating 3 out of 5]

Slightly too much philosophy / personal views, especially in the second half of the book. The first half is good indeed.

[S Eliot R Wong · Rating 4 out of 5]

Gran libro, ya quiero liderar software. Y leer mi siguiente libro :)

[Marek Sirkovský · Rating 3 out of 5]

This book is just a compilation of blog posts of varying qualities. There are excellent thoughts but some others are too personal/vague and IMHO not so useful these days.