Making Good Software

A blog by Alberto G (Alberto Gutierrez)

Written by Alberto Gutierrez

March 31st, 2010 at 3:47 am

Are you using too many technologies in your projects? The 7 anti-patterns for technologies, frameworks and other technicalities in software development.

with 6 comments

One of the most recurrent and common mistakes in software development is to focus too much on technologies, frameworks, middleware and other technicalities. It is like forgetting that our mission is to produce killer applications, not to make sure we use the most powerful tools available.

The following are in my opinion the main 7 anti-patterns related with them.

Anti-pattern 1: Hiring people based on the amount of technologies they know.

Hiring people is one of the most clear and common situations where we let the technicalities drive our decisions, and it is also one of the most delicate. It is as if we only care about how many technologies the candidate knows, rather than looking for good coding or design skills, which are much more important.

Anti-pattern 2: Picking up technologies without knowing if they are necessary.

We have all probably been there. The project is about to start, and the first thing we do is list the technologies and frameworks we think may be suitable for the project. It is like creating a shopping list with all the products we fancy from the supermarket. In my opinion it is better to start as simple as possible, and add technologies and frameworks only when they are required or when they will make the developers life easier.

Anti-pattern 3: Overusing a technology.

“When you have a hammer, everything looks like a nail”. Imagine that it’s been decided that Spring is going to be used for dependency injection. Next think you know, Spring is used to create all the objects in the application, and the configuration file has thousands of lines of code.

Anti-pattern 4: Cover design flaws with technologies.

Performance comes to mind immediately when discussing this anti pattern. It is very common when performance is poor to blame and focus on the technologies involved, but in my experience, performance problems usually have their root cause on how the implementation was designed.

Anti-pattern 5: ALWAYS Prefer new technologies and frameworks to a plain approach.

There are some developers that if they find something that can be done with a new technology they automatically discard a plain approach, and that is not always good. It is worthwhile to remember that technologies, frameworks, middleware… come at a price to the project. They require maintenance, learning, support, configuration…

Anti-pattern 6: Prioritize extensibility when it is not necessary.

One of the most common reasons I have heard for using new fancy technologies is that they deliver an extreme degree of flexibility and configuration not achievable otherwise with a plain approach. While this may sound wonderful, it is also true that most of the time they were not necessary for the project, so using them will only increase the risk of over engineering the application.

Anti-pattern 7: MDT – Management driven technology.

This anti-pattern usually goes like this: Your manager reads a magazine/article which talks about a new super-duper technology, he gets all excited, the next day in the office he makes the announcement: “I’ve found the solution to all of our problems, from now on we are going to use ________ !!” (fill in the gap, with the fancy technology of your choice)