UPDATE: Stackoverflow #41 is out. I bet it's going to be the most listened episode ever.

This morning I woke up, and suddenly I was flooded by tweets and posts. All of that were about the latest buzz of the moment: “Are Jeff and Joel going crazy or are they just playing going crazy?”.
I just want to think that, at least Jeff, is just playing the devil’s advocate, and giving a voice to the silent crowd that thinks that “getting things done” and “ship the product/project” is more important than crafting a good piece of software that can be maintained for long time. I HOPE it’s just that, and he is exaggeratedly pushing the opposite to try and reach a better balance between the two opposites.

First thing I want to make clear my position on the ALT.NET thing. When ALT.NET came out two years ago or so, I was skeptical at first, because I thought that, while the idea behind it was great (and it proved to be great), it was useless because 90% of the developers don’t care about their job and thus they do the least amount of work in order not to get fired. But then I decided to try and spread the word myself.

What happened?

But going back to the topic of that post. I’ve an opinion about this, so, if you want you can skip directly to it, but if you want to form your own opinion, I’m going to summarize the main episodes of that saga:

  • I think it all started back in October, when Jeff was talking about his experience writing StackOverflow, and said that he didn’t care that much about security and about making the software flexible because he wanted to push the site out as quickly as possible. Scott almost felt off this chair when he heard that, but Jeff assured that the refinements (aka refactoring) would have come later.
  • Then, still on Hanselminutes, Bob Martin talks about the SOLID principles, and how they help writing good, maintainable, testable software with almost no effort. IMHO the best explanations of these principles I’ve ever heard, really recommended
  • In StackOverflow Podcast #38, Joel, commenting on the just mentioned podcast, states :“Quality just doesn’t matter that much” and also that this is leading to “extremely bureaucratic programming”, and many other comments like this.
  • This podcast obviously started to wake up the nest of hornets that is the community, but the first that really noticed and commented about this outing was Mr. Uncle Bob in person, which answered with the post: “Quality Doesn’t Matter That Much” — Jeff and Joel. He also wrote an “An Open Letter to Joel Spolsky and Jeff Atwood” to try and bring is points on. He also suggests to be invited to talk at a future episode of the show, but till now nothing happened yet and it was interviewed in episode Stackoverflow #41.
  • But the proverbial last straw was Jeff’s answer to Bob: The Ferengi Programmer. I think he is correct when he says that you don’t have to stand on giant’s shoulders but that you have to have a critic mind, and adapt to the environment. But he speaks to 124 thousands readers, the vast majority of which don’t read other blogs (Codebetter only has 30K, 1/4th of Jeff’s readers), and I guess they didn’t hear anything SOLID before. What they got (even if Jeff didn’t explicitly said) is that Principles, Pattern and all that stuff is useless and cumbersome, and only slows you down when you have to write code that has to ship.

  • Obviously this post didn’t go unnoticed as the others, and quite a few people wrote their thought about that:

We are like house builders at the time of Egyptians

I think it’s good that Jeff and Joel started this conversation, because it might help our industry grow a bit.
We are (to continue with Rob’s analogy) in the position of the first house builders at the times of the Egyptians: we are still experimenting and trying to find the best way to build software. Some Egyptian builders applied all the principles they had at the time, using good stones, with the correct design. Other used cheap wood, hold together by ropes, and the house was build just putting on piece on top of the other. The pyramids costed more money and took more time than the wooden house, but they still stand after 4.000 years, while the other houses probably went destroyed at the first sand storm. After thousand of years of tries and errors, house builders can now apply the right principles for each kind of house so that the quality of the house is balanced by the time and effort spent building it. Probably we will never have a pyramid that can resist 4.000 years (since we understood that applying all the principles can lead to higher costs and longer times), but also we don’t have houses that goes down at the first blow of wind.

But in Software Industry we are still experimenting: probably we will fall in the error of over-using the principles (as it happened with the building industry centuries ago), and then we will move back to balancing the two things, and using only the principles that matter.

The first paintings of the great masters were all classical paintings

But in order to be able to decide which rule and which pattern not to apply, first we have to master all the rules. Only after we have them in our skillset, we can decide whether to apply or not apply a certain principle because we don’t need it. At school I was always taught:

If you look at the history of painting you’ll notice that all great painters’ first paintings were classical paintings. Later they experimented different techniques, and finally they invented their own style.

Last final words

Probably I went to far on this post, and it also took me 3 rewrites to get it to this point, but what I just want to summarize here is that IMHO SOLID principles are good, and that must be in everybody’s toolbox. It’s no point in reinventing the wheel every time. But also pay attention to no overuse them, and apply them with grain of salt. But first... LEARN THE BASICS

kick it on DotNetKicks.com

Technorati Tags: ,,