The practice of developing software depends on a large body of arcane knowledge and skills. Almost all of this knowledge is based on logical principles and built up to the point that we can do amazing work. Because programming has it’s roots in applied mathematics, there is an impression that programming is also a logical,… Read More »
Jeff Atwood had an interesting post on regular expressions a few days ago. Most of the article talks passionately about the usefulness of regular expressions, strategies for writing readable regular expressions, and tools to help write and debug regular expressions. Along the way, Jeff points out a comment that usually pops up when the topic… Read More »
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 »
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 »
Over the last few years, I have spent a lot of time talking to lots of different people about object-oriented programming (OOP). I have spent a fair portion of the last three years interviewing and screening people over the phone for development positions. This activity has caused me to spend some time re-evaluating what I… Read More »
Ever since O’Reilly published the new book Beautiful Code, there seem to be references everywhere to what makes code beautiful. While a few people have suggested that beauty should not influence code (see the comments section for the suggestion that there is no beautiful code), I believe that most people have seen code that they… Read More »