In LCDC: Fundamental Knowledge, I explained how hard it is to specify a minimum level of knowledge or experience for all programmers. This minimum level would be needed to determine what is allowable for Lowest Common Denominator Code (LCDC). Anyone who has been programming for any time is probably shouting at the screen, calling me… Read More »
In The Myth of Code Anyone Can Read, I introduced the idea that least common denominator code (LCDC) is not a good approach to writing software. One reason for this problem is caused by the knowledge base of your average programmer. Different Programmers Have Different Backgrounds Programming is still a relatively new field. It’s also… Read More »
I got into a conversation recently coming out of the Houston.pm user group meeting. As usual, we wandered over numerous technical topics, but one stuck out in my mind: whether or not to use more advanced or more complicated language idioms. I’ve written about programming idioms and advanced code many times in the past (see… Read More »
I recently heard an interview with Martin Fowler on the Ruby Rogues podcast. He pointed out a few things about the process of refactoring that I haven’t thought of in a while. Based on that interview and what I’ve read and learned elsewhere about refactoring in the past few years, I decided there are a… Read More »
The first skill a new programmer must learn is not what most people expect. It is not learning a programming language. It has nothing to do with algorithms or data structures. The first thing a new programmer must learn is how to identify a small piece of a problem. Solving the Big Problems Most problems… Read More »
Between my earlier career in electronics and my current career in software, I have found a number of questions that have been helpful in troubleshooting problems reported by others. None of these questions are original to me. My wife described troubleshooting a hardware problem over the phone and mentions some of her troubleshooting questions. I… Read More »
I’ve recently been reminded of something I used to tell entry level programmers repeatedly: Review the basics. And really I mean all of the basics: data structures basic algorithms basics of algorithm analysis language syntax core CS concepts testing strategies In many programming positions, you can get away with coasting on these things for a… Read More »
Back in February, I ran across the post robkinyon on Perl: How useful is a debugger, really? and was again reminded of the great debugging debate. I thought about commenting on it at the time, but I got distracted. Well, Matt Trout reminded me of it again today with his post Simple Debugging. So, I… 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 »
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 »