A summary of all posts that are currently in progress of my review of the book The Pragmatic Programmer by Andrew Hunt and David Thomas.
103 – Review: The Pragmatic Programmer, When to Use Exceptions
#begin When to Use Exceptions Next up we get to the section I hinted at before and it’s about exceptions. We discussed the mindset of failing fast and the fact funny statement that dead programs tell no lies. David an Andrew rightfully admit that if you throw...
102 – Review: The Pragmatic Programmer, Assertive Programming
#begin Assertive Programming Let's check out a section about assertive programming. We also talked about this earlier while discussing Design by Contract. Assertions allow you to use the compiler for certain conditions. Not just during testing, but also at runtime....
101 – Review: The Pragmatic Programmer, Dead Programs Tell No Lies
#begin Dead Programs Tell no Lies The next section of the book is called Dead Programs Tell no Lies, haha. This refers back to something we talked about earlier. We need to fail fast in order to be able to pin down problems in he code properly. That’s what they...
100 – Review: The Pragmatic Programmer, Design by Contract
#begin Design by Contract David and Thomas say that on of the best solutions for ensuring plain dealings is by contract. We have probably signed lots of contracts before like an employment contract, a mortgage or maybe a lease for a car. These contracts specify...
99 – Review: The Pragmatic Programmer, Pragmatic Paranoia
#begin So in today’s blog we are going to start a new chapter in The Pragmatic Programmer with chapter 4 called Pragmatic Paranoia. Pragmatic Paranoia David and Thomas start this chapter straight of the bat with a tip and it’s a very realistic one which says:...
97 – Review: The Pragmatic Programmer, Code Generators
#begin Code Generators The last section of the book is about code generators. This is indeed something we need to know as programmers since it will improve out work. Most likely, you are using code generators but maybe didn’t know. For example, if you are using some...
96 – Review: The Pragmatic Programmer, Text Manipulation
#begin Text Manipulation As plain text is our most common means of building stuff it is really important to know how to manipulate it properly. Luckily there are languages that are really good at manipulating text like python, ruby or perl. David and Thomas...
95 – Review: The Pragmatic Programmer, Debugging
#begin Debugging The next section of the book is all about debugging. We have talked about debugging before in earlier episodes. As Uncle Bob puts it: “Debugging is not a skill to be desired!”. And I totally agree, however, you must be able to do it. And in...
94 – Review: The Pragmatic Programmer, Source Code Control
#begin Source Code Control The next section of the book is all about source code control. The authors start this section of with some hard truth: “One of the important things we look for in a user interface is the UNDO key -- a single button that forgives us...
93 – Review: The Pragmatic Programmer, Power Editing
#begin Power Editing This part of the chapter is all about your most important tool as a game developer; your IDE. Whatever you choose, you must be able to manipulate and navigate text effortlessly. This is the basis for all programming you will ever do....
92 – Review: The Pragmatic Programmer, Shell Games
#begin Shell Games This paragraph is basically Andrew and David emphasizing the fact we as mere mortal programmers must learn how to work with the terminal. They compare the terminal to a woodworker’s most basic tools like a good, solid, reliable workbench....
90 – Review: The Pragmatic Programmer, Plain Text
#begin Andrew and David start this chapter with the following sentence: “Every craftsman starts his or her journey with a basic set of good-quality tools.” I couldn’t agree more. They give the example of a wood worker and his tools. He has saw, chisels, drills and...
89 – Review: The Pragmatic Programmer, Estimation
#begin The last and really interesting topic of this chapter is estimation. I think I’ve said this before but estimation is one of these topics that however much advise you have consumed, when-ever you consume it again, something new, you always gain new...
88 – Review: The Pragmatic Programmer, DSL’s
#begin The next topic in the book is about domain languages. We’ve talked about this is previous blogs as well since I personally think domain languages are very important. I try to create an ubiquitous language whenever I can. Ever since I read Eric Evans’ book about...
87 – Review: The Pragmatic Programmer, Prototypes
#begin The next section of the book dives into prototyping, let’s take a look. They start off by saying that many industries use prototypes to try out specific ideas since prototyping is much cheaper than full-scale production. Think about SpaceX testing these raptor...
86 – Review: The Pragmatic Programmer, Tracer Bullets
#begin The next section an about the concept of tracer bullets. This has become a pretty important analogy in the software architecture space since I keep hearing people mention it in podcasts, blogs or conference talks. I’ve described what this means before but let’s...
84 – Review: The Pragmatic Programmer, Reversibility
#begin The next topic to cover is reversibility. But what is reversibility exactly? Well what David and Andrew mean is that your system must be flexible enough so you can reverse or delay decisions as you write your code. This topic has been one of much debate because...
83 – Review: The Pragmatic Programmer, Orthogonality
#begin But alright, let’s continue with a new section which describes the concept of Orthogonality. So what again does Orthogonality mean again? It’s one of these words that’s always thrown around in computer science lectures and literature. Well orthogonality...
80 – Review: The Pragmatic Programmer, Duplication
#begin In today’s blog we will start with chapter two called, A Pragmatic Approach. We will dive into code duplication, a topic that is very familiar to us since we have discussed in to great length already in previous blogs while discussing Clean Code and A...
79 – Review: The Pragmatic Programmer, Communication
#begin Although we are developers and we like to code, we need to be social in order to do our jobs properly. When you are just a code monkey, closing tickets on your Jira board you will burn out very quickly. Have you been in that situation? You know, day after day,...
78 – Review: The Pragmatic Programmer, Goal setting
#begin You also need to set a couple of realistic goals for yourself and keep them. Think about the new year resolutions you set for yourself. Do you keep them? Are they realistic? It’s really important that if you set some goal you know you can reach them by the end...