I finally had a chance to finish reading The Pragmatic Programmer: From Journeyman to Master. Any software developer should check out this title. It's full of wisdom and philosophy behind the craft, it is brought in a humorous way full of entertaining anecdotes and interesting examples and analogies.
This book is all about getting into the habit of writing maintainable code. It is full of good practices each software developer should benefit from: prevent software rot, the concept of DRY (don't repeat yourself), writing bullet-proof code. Avoid programming by coincidence, test ruthlessly, define requirements, automate processes and much more .. GUI/MS developers might find it Unix-biased, but I think they make a point about the power of the Command Line :)
Some examples of all this good stuff ..
The quality of your apps stands and falls with putting out each fire consistently, as soon as spotted. "Don't Live with Broken Windows" is a brilliant analogy.
Decouple your software modules, let components be as independent as possible. The authors give a great example of a helicopter as a tremendous complex system where every change impacts all the other inputs. Minimize coupling in software creation.
We prototype "to analyze and expose risk, and to offer chances for correction at a greatly reduced cost". This might free you from potential perfectionism. Making a sketch or programming "disposable code" at the start of a project might be very useful to explore ideas and features.
The authors are very realistic here: "If It Can't Happen, Use Assertions to Ensure That It Won't" - we all have the tendency to think sometimes: "this could never happen". Well unless you know the future, it is very likely it could, so you should use assertions (exceptions) as they will be your friend when debugging your code.
Programming by Coincidence
The importance to know why something works or not. Again this is having the discipline to not reside in "It works now, better leave well enough alone....". What happens if the code is applied in another context? Can you really prove your assumptions?
Stone Soup and Boiled Frogs
The authors give a great metaphor to show the point of systems getting gradually out of hand: ".. they say that if you take a frog and drop it into boiling water, it will jump straight back out again. However, if you place the frog in a pan of cold water, then gradually heat it, the frog won't notice the slow increase in temperature and will stay put until cooked.". The point is to always remember the Big Picture, we can easily get stuck in details if we are not 100% aware what we are doing
I generally see the following books listed as "must-reads" for software development. Learning new languages and crafting in known ones, makes it hard to keep up. Personally I take some time every now and then to go back to the theory. Apart from practice, understanding the concepts helps a lot!
• Design Patterns: Elements of Reusable Object-Oriented Software
• Refactoring: Improving the Design of Existing Code
• Code Complete: A Practical Handbook of Software Construction
• Clean Code: A Handbook of Agile Software Craftsmanship
• Patterns of Enterprise Application Architecture
Companion volume ..
McConnell's "Code Complete" is said to be a great companion to The Pragmatic Programmer. I bought a hard-copy few years back and I agree with this statement. I only read it partly until now but I have to say it is very interesting! It focuses more on the ins and outs of writing code so I wanted to learn some more c++/ java (compiled programming languages) before I dare a complete read. When I have read it, I will definitely dedicate a post to it :)
And what about you?
I assume most readers of my blog are active in software development.
- did you read The Pragmatic Programmer and if so, what is your opinion about it?
- what other books did inspire you to become a better coder?
- best practices (4) ,
- books (16) ,
- code (1) ,
- coding (6) ,
- programming (14) ,
- reading (7) ,
- software engineering (1) ,
- tutorials (1)