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 »
I’ve noticed something about the programmers I have dealt with in the last few years. Many of them seem to equate debugging skill with ability to use a debugger. In fact, in some instances, the concept of being able to troubleshoot a problem outside a debugger is so foreign it would never occur to them.… Read More »
Software Configuration Management Patterns Stephen P. Berczuk and Brad Appleton Addison-Wesley, 2003 The first three chapters define the problem space. We get a solid description of Software Configuration Management (SCM) and an introduction to patterns and pattern languages. This section of the book sets up the context that you will need to understand the rest.… Read More »
A couple of years ago, I wrote in The IP Goose about some effects that too strict an IP policy can have on developers. In the intervening two years, I’ve had some other insights that I believe are important. First of all, I stand by my original essay. Companies should be able to protect the… Read More »