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.
127 – Review: The Pragmatic Programmer, It’s All Writing
#begin The next big topic of this chapter is called It’s all writing. This section will dive into the many kinds of documentation we will have to write as pragmatic programmers. Andrew and David mention that we should treat english, or which ever language you or your...
126 – Review: The Pragmatic Programmer, Ruthless Testing
#begin Ok; so next up is yet another section on testing. David and Andrew say that most developers hate testing. And I agree, as Uncle Bob would say, testing after the fact is really, really boring. You already know the code works because you just wrote it and tested...
125 – Review: The Pragmatic Programmer, Ubiquitous Automation
#begin The next section of the chapter is all about automation. Well, we talked about that before but let’s see what else Andrew and David have to say about it. They mention that automation is a way to ensure guaranteed repeatability. Well that sounds pretty...
124 – Review: The Pragmatic Programmer, Pragmatic Teams
#begin Andrew and David kick this chapter off with the idea of no broken windows. Do you remember what this was about? You don’t leave broken windows in a building because if there’s one broken window and nobody fixes it, people expect its fine and no one will...
123 – Review: The Pragmatic Programmer, Circles and Arrows
#begin The last section of the chapter is about circles and arrow, which effectively just means CASE tools, UML or diagramming. I think its funny since even though UML is a standard its still not widely used. I remember an interview with Simon Brown, the...
122 – Review: The Pragmatic Programmer, The Specification Trap
#begin Earlier we mentioned we would take another look at over analyzing the requirements. The following section of the chapter is all about the specification trap. But first, what exactly is a specification. Well, David and Andrew say that a specification is a...
120 – Review: The Pragmatic Programmer, Not Until You’re Ready
#begin The next section of the chapter we will discuss is about knowing when to start, and stop or maybe pause for a bit. David and Andrew say you should listen to your nagging doubts. As a developer you are constantly doing things that work, or don’t. All of this...
119 – Review: The Pragmatic Programmer, Solving Impossible Puzzles
#begin The next section of the chapter is about solving seemingly impossible requirements. I think we’ve all faced such requirements before. What do we do when we’re asked to implement a requirement that’s impossible to implement due to current software...
118 – Review: The Pragmatic Programmer, The Requirements Pit
#begin Lets discuss the first section called “The Requirements Pit”. If you have attended some formal computer science education, or maybe more specialized in regard to gamedev you might know that courses describe requirements engineering or elicitation as a...
116 – Review: The Pragmatic Programmer, Before the Project
#begin David and Andrew start this chapter off smashing us right in the face with reality. They ask the question and I quote: “Do you ever get the feeling that your project is doomed, even before it starts? Haha. I suspect we have all been in that situation before....
115 – Review: The Pragmatic Programmer, Evil Wizards
#begin Evil Wizards The next section starts of with a really great insight. David and Andrew say that:”There's no denying it—applications are getting harder and harder to write. User interfaces in particular are becoming increasingly sophisticated.” Hahaha this...
114 – Review: The Pragmatic Programmer, Code That’s Easy to Test
#begin Code That’s Easy to Test David and Andrew start this new section of with a description of people comparing software to an integrated circuit. Software components should be combined just as such circuit and such components must be known to be...
113 – Review: The Pragmatic Programmer, Refactoring
#begin Refactoring Refactoring, one of my favorite subjects since it always feels good to clean up the code. As your game evolves it will be necessary to clean up some junk you left behind. This is not necessarily about tech debt but simply has to do with the...
112 – Review: The Pragmatic Programmer, Algorithm Speed
#begin Algorithm Speed Now, as we talked about in the introduction we will also discuss the topic of algorithm speed. This mostly boils down to being able to estimate with some level of precision your algorithm’s resources. Pragmatic programmers should be able...
111 – Review: The Pragmatic Programmer, While you are coding
#begin While You Are Coding David and Andrew start new this chapter (6) off with a very shitty and outdated way of thinking and I’ll quote: “Conventional wisdom says that once a project is in the coding phase, the work is mostly mechanical, transcribing the...
110 – Review: The Pragmatic Programmer, Blackboards
#begin Blackboards So for the last section of this chapter we are going to dive into Blackboard architecture. Oh boy, who has nightmares about the Learning Management System in highschool!? All of these shitty tools were implemented with the blackboard architecture....
109 – Review: The Pragmatic Programmer, It’s just a view
#begin It’s just a view Next we will dive into a section called “It’s just a view”. In this section they mainly focus on creating architectural boundaries between presentation and business code. One, if not, the most well known pattern to achieve this is the...
107 – Review: The Pragmatic Programmer, Temporal Coupling
#begin Temporal Coupling The next major section of this chapter is about temporal coupling. I think we have all heard this term before but what is it exactly. It’s about time being a design element of the software itself. Time is an often ignored aspect of software...
106 – Review: The Pragmatic Programmer, Meta-programming
#begin Meta-Programming When I hear this term I think about static analysis. I’ve done some meta-programming in University to do static analysis on a Java project. It was SQLite if I remember correctly. But in The Pragmatic Programmer Andrew and David have a different...
105 – Review: The Pragmatic Programmer, The Law of Demeter
#begin Bend, or Break In this chapter we will cover lots of interesting topics that have stood the test of time. Many of these topics will already be known to you as they are ingrained in our industry over the past 30 years. Remember, this book was written in 1999!...
104 – Review: The Pragmatic Programmer, How to Balance Resources
#begin How to Balance Resources The next section of the book is about how you should or can balance resources. I think this concept is far more important in languages without garbage collection like c or c++ but David and Thomas will also talk about how to do...