There is a technique I have seen used many times in my career called Lazy Initialization. The purpose of this technique is to delay an expensive initialization (or object construction, or calculation) until you actually need it. Just like any technique, Lazy Initialization has both advantages and disadvantages. The advantages are a pretty obvious: If… Read More »
Beautiful Code Edited by Andy Oram & Greg Wilson O’Reilly, 2007 Although I was really looking forward to reading Beautiful Code when I first heard it was coming out, I found myself a bit disappointed by the reality of the book. Each chapter is written by a different master coders, giving their views on what… Read More »
Long ago, I was trying to convince a friend of mine that Object Oriented programming was not all just snake oil when he asked me a fundamental question. What’s the difference between an object and a thingie? In some ways, this question has guided my understanding of objects ever since. Fundamentally, what makes one collection… Read More »
Continuing the line of thought from last time (Sharp Tools vs. Frameworks), another issue I see in quite a few frameworks and some systems is a code anti-pattern I’ll call The Modular Monolith. We all know that modularity is a good thing to have in a system. Modular code, in general, reduces coupling between components,… Read More »
Maybe it’s a reflection of when I started programming, but I’ve always had problems with frameworks. I prefer having a sharp set of tools to having a do everything framework. For me, the framework breaks down if I need to do something that does not match exactly what the framework designers wanted to do. A… Read More »
One of the dimensions in which you can vary a design is in terms of the amount of flexibility it supports. Trade-offs along this dimension show up in many design decisions for various kinds of software. In some cases, software is made less flexible to improve predictability. In other cases, the adaptability of the software… Read More »
I’ve been spending a fair amount of my time the past few years helping hire programmers. I have also spent time training both entry-level and senior programmers. So, Jeff Atwood’s recent blog entry The Years of Experience Myth struck me as particularly interesting. While I agree that the number of years of experience a developer… Read More »
In my last essay, I mentioned the Shuffling essay from Jeff Atwood’s blog. This time, my essay is a little less philosophical and more technical. Several of the comments on the Shuffling essay talked about the importance of knowing the random number generator you are using. Generating random numbers sequences is a particularly interesting subject… Read More »
This week, there was an interesting post on Jeff Atwood’s Coding Horror blog. This essay was on Shuffling. Shuffling is an application of random numbers, which is a particular interest of mine. I will write more on that subject in an upcoming essay. One of the comments caught my eye because it echoed a sentiment… Read More »
Last week, I wrote about a technique for debugging without using a debugger in Debugging Without a Debugger. I talked a bit about the advantages of instrumenting code and how it can be used to supplement the use of a debugger. Those of you who have always used a debugger might consider this vaguely interesting,… Read More »