I’ve attended a couple of seminars by the authors of Leading Lean Software Development. Mary and Tom Poppendieck did not shy away from the tough questions at the seminars which is a good sign. This book attempts to tackle some of those really tough questions and more and it does a good job at it.

There are many references to real corporations and situations which helps back up the claims the book is making regarding lean software and human behaviour in general. This is always a welcome addition for me because it is sometimes difficult to believe some of the claims because they are rather unintuitive and often against traditional western thinking.

The subtitle of this book is “Results Are Not the Point” which is prime example of going against traditional western thinking. The idea in this case is to focus on improving your software delivery system and stop focusing so much on the products. This will in turn help you produce better software more reliably because you won’t be just burning people out with overtime each time to get results. At least that is my interpretation.

Overall, I did find the book was a bit dry and perhaps a little too detailed at times. There is just so much information in there I suppose it was difficult for the authors to distill their knowledge down. The book is well organized but I think it also requires quite an investment to soak up all the information in there.

I like this book. It is obviously targeted directly to software professionals like myself. It also talks about that mushy brain thing. How could I not like it?

I never really meant to buy this book. I was actually trying to buy a copy of the Agricola board game. Since the store was out of stock when their computer claimed otherwise I received a nice discount on anything in the store. I walked by the computer book shelf and spied the wonderful title Pragmatic Thinking & Learning: Refactor Your Wetware. I knew the author Andy Hunt from Pragmatic Programmer fame. I also just have to buy anything with wetware in the title.

This is one of those books that is actually two books in one. On the one hand, it talks a lot about how the brain works and the latest theories. There are plenty of cool facts to chew on. On the other hand, the book tries to help you become a better software professional by fully utilizing your current brain. No expensive and inconvenient brain transplant surgery required.

There are plenty of other texts out there about how the brain works, why people behave as they do, how to change your learning habits, etc. What this book does is bring it all together and present it to the software professional in language we understand. There is even a handy reference card listing all 48 tips and references to where they are in the book.

You need the reference card because this book is only a starting point. You don’t magically become a better learner after reading it. You have to work at it and the reference card helps you remember the most important points.

What a nice surprise this book turned out to be. It is compact, very readable, Andy Hunt is hilarious, the book is inexpensive and it is loaded with great tips 100% relevant to what I’m doing right now. Can’t get much better than that.

The latest AmigaOS Software Development Kit (SDK) was recently released. The SDK corresponds to the AmigaOS 4.1 Update 1 system release. The SDK is available for download now and doesn’t require any sort of mandatory registration.

I had prepared the SDK before but this would be the first time new includes and autodocs were included. The includes are a collection of C source code header files. The autodocs are generated directly from the source code similar to JavaDocs, etc. However, the autodoc format has not really changed much in a couple of decades now and consists entirely of plain ASCII.

Many developers helped contribute to the SDK and I’d like to thank all of them. Once again, this truly was a team effort.

Lua Programming Gems is a collection of articles on Lua in the spirit of all the other “gems” books that came before it. This is simply a must have for all Lua programmers and touches on pretty much every aspect of Lua in some way.

I’m still relatively new to Lua myself so some of the samples are beyond my Lua skill level. Even so, I think the book will be a valuable reference later on when my skills have advanced.

The one important lesson I took away from this book is that Lua really is a language for building languages. Luas only data structure is the table from which you can build all your traditional structures like queues and lists but that doesn’t mean that you should. Instead, try to use Lua as it is and adapt to the way Lua does things instead of forcing Lua to be something else.

Clean Code: A Handbook of Agile Software Craftsmanship focuses on the importance of the source code itself. I’m already familiar with Robert C. Martin’s Agile Software Development: Principles, Patterns, and Practices so I expected something similar but focused on the code instead of on design. I was not at all disappointed.

Please don’t let “Uncle Bob”’s book titles scare you away. There is some focus on the agile methodologies but nothing is really being pushed on you. Agile enables more of a focus on the code and testing which is the main point.

Martin begins with an argument for writing clean code and caring about the readability of code. I did not require convincing myself but I’m pretty sure there are still a lot of people out there that still believe getting code working and walking away is still acceptable practice. What follows is the real meat of the book.

The book covers horizontal and vertical spacing, code comments, choosing meaningful names, handling third-party code, unit testing and everything else you would expect a book about coding would cover. Martin goes so far as to pick sides as well and does not hold back on expressing his opinions. I think we all respect an author that is willing to take sides.

The book then takes a turn into more unfamiliar territory. The systems level is discussed with ideas on design aspects, frameworks and even domain-specific languages. Emergent design, refactoring and the wonderful world of concurrency (ex. multi-threading) is also explored in some detail. These chapters were a surprise for me as I did not expect to find such a wealth of information in a single book.

Real examples on open source projects are presented along with all the advice. Martin takes us through how to take a badly written pile of bits and turn it into what he calls “clean code” step by step. There is a lot of great detail on how and why he chooses to do what he does but it does drag on for a while so be prepared to put some work into reading it.

The book concludes with a collection of “Smells and Heuristics” which help bring everything together.

The first section on concurrency was a little scant so it was decided to put a full appendix dedicated to concurrency at the back of the book. This is a valuable appendix with useful information for anybody dealing with concurrency in their code base.

There is a lot of good information in Clean Code but it does have the same flaw as all other books on coding have. The author must choose a programming language to make the book useful. This time it was Java 5 that was chosen so it would be a good idea to brush up on your Java to get the maximum amount of use out of this book.

The long awaited AmigaOS 4.1 Update 1 is finally out for all supported AmigaOS 4.1 platforms: AmigaOne, Sam440ep and Pegasos II. The Sam440ep platforms are still manufactured by ACube Systems out of Italy and still readily available. If you want to get into AmigaOS, I always recommend AmigaKit because they are simply the best dealer out there.

I was personally quite involved with this release of AmigaOS. I contributed many hours of my time (mostly at no cost) to this product and I’m pretty proud of it. The team behind this product is pretty large and very international with members all over the globe. Hyperion Entertainment controls the AmigaOS source code and allows a smaller subset of the entire team to work on the code base of which I am a part of. I enjoyed my time working on this release and I look forward to contributing again in the future.

A big thanks to the entire AmigaOS 4.1 Update 1 team. It was a blast!

Outliers: The Story of Success is a book by Malcolm Gladwell which I received as a Christmas present. I already read Gladwell’s The Tipping Point so I appreciated his writing style and focus on simplicity. The book is very approachable and written for a large adult audience. This helps with defusing the reader. This is important considering he is making the point that it is likely those people we admire that are considered geniuses, elite, etc. are likely incredibly lucky.

Gladwell has a knack for pointing out the obvious and putting a new spin on it. With outliers, the obvious point is that we rely on others for success. One of his many examples included Bill Gates who cofounded Microsoft. Many consider him some kind of genius but I know I’ve always remained skeptical. Gladwell pointed out something new to me in that Gates had access to one of the only time sharing computer systems at a time when very few others had that opportunity. Armed with 10,000 hours (a magic number that pops up repeatably in many contexts) of computing experience when the rest of the programmers in the world had maybe hundreds of hours sure gives you an edge. Add in a couple of other lucky breaks and we have a billionaire with incredible timing versus some kind of genius.

Outliers isn’t poking fun at the successful of the world or those that are smarter than the average bear. What Outliers is doing is pointing out that armed with some smarts, some great timing and a great cultural background and you have the recipe for success. Without all these things, the underdog really doesn’t have a fighting chance and it is very unlikely we will find many that are considered a “success” which have not had a lot of critical help along the way.

I think Gladwell’s point regarding culture being a larger influence on behaviour than most would admit is an interesting one. He asserts that cultural differences linger a lot longer and a lot deeper than might be obvious to many people and we should not dismiss culture so readily. This came as a surprise to me as well. I would never have thought the attitudes or our ancestors who immigrated to Canada would still have a large influence on my behaviour today but on reflection, he just might be on to something.

This book really does make you think which is always a good thing.

Implementations Patterns is a book by Kent Beck of Extreme Programming fame. These are patterns which are applied at the implementation level versus the usual design patterns. It has been described as three books in one and I tend to agree.

The first part of the book includes Chapter 3: A Theory of Programming which delves into the values and principles of programming itself. Professional programmers will nod in agreement with much of what Beck is saying because much of it has been implied for many years. It is really nice to see it written down and explained.

The patterns themselves don’t necessarily follow any particular formal template and they focus solely on the Java programming language. Given these are implementation patterns it does make sense Beck had to focus on a programming language and he chose Java. Being more of a C++ guy, I found a vast majority of the patterns (if not all) can still be applied in C++. Any object-oriented programming language can easily make use these patterns.

The final part of the book delves into frameworks and includes a handful of patterns and some solid advice for those implementing frameworks. Anyone that has designed and implemented a framework will find this advice very familiar. Again, it is really nice to see it written down and explained.

Kent Beck has a knack for articulating the complex world of software development and this book is no exception. I now understand why it is has been so highly recommended.