Recently, Joel Spolsky wrote about Don Norman’s article Simplicity Is Highly Overrated. Joel used this as a springboard to another talk of how simplicity doesn’t matter in Joel on Software: Simplicity. He referenced and expanded on his views from Strategy Letter IV: Bloatware and the 80/20 Myth. As I’ve said before, I often find Joel’s… Read More »
I have recently being seeing references online to the concept of Technical Debt. The concept is an attempt to explain to business and management types some of the downside of overly complicated designs, lack of testing infrastructure, and quick-and-dirty code written to meet a deadline. In the past, I’ve had trouble explaining the difficulties working… Read More »
One of the things Java programmers seem to really like to hate in C++ is the concept of operator overloading. I have heard this from many Java programmers and seen it written by others. According to many, operator overloading makes C++ impossible to understand because you can’t tell what a piece of code is doing… Read More »
In the book Software Exorcism, Bill Blunden described a problem caused by the maintenance programmer not usually being the same person as the programmer who wrote the code. Often the maintenance programmer comes in with a less-than-complete understanding of the original problem or of the design decisions made for this problem. Usually, there are also… Read More »
I’ve been seeing a lot of comments in various forums similar to this comment by Christopher Diggins: XML down a slippery slope. In most of them, there is the implied belief that XML is the solution to all problems and that anything that violates the spirit of XML is to be condemned. I have personally… Read More »
Continuing my exploration of misunderstandings about multi-threading, this essay is about simplicity. If you are interested in the previous essays in this series, they can be found on the series page. This time I plan to start with an assertion that almost everyone will agree with and push it more than most people would. The… Read More »
As I said in Joel on Wrong-Looking Code, I find Joel on Software to be a good source of information on programming. However, I don’t always agree with him. In Joel on Software – Making Wrong Code Look Wrong, Joel states that he does not like exceptions. He also refers to a previous article Joel… Read More »
Back in September, I talked a bit about The One, Right Place and what a useful concept it is. I’m now reading the second edition of Code Complete and ran across this concept once again. More importantly, McConnell references the book where I first read about the concept: Programming on Purpose: Essays on Software Design.… Read More »
Many years ago, I spent a lot of time training entry-level programmers. One of the problems that the more junior programmers had was duplicating code and information in the code. Some of our senior programmers at the time began talking about the concept of the one, right place. Later, I read the book The Programmatic… Read More »
In The Forgotten Engineering Principle, I went on at some length about the concept of Good Enough. I originally began thinking about this idea over a decade ago in the context of Stylus-Based Computers (what are now called Tablet PCs). I hadn’t thought about the concept for quite a long time. However, in doing a… Read More »