7 Deadly Sins of Design

Reproduced from a paper on object oriented principles by Arnon Rotem-Gal-Oz.

7 deadly design sins to avoid:

  1. Rigidity. Make it hard to change, especially if changes might result in ripple effects or when you don’t know what will happen when you make changes.
  2. Fragility. Make it easy to break. Whenever you change something, something breaks.
  3. Immobility. Make it hard to reuse. When something is coupled to everything it uses. When you try to take a piece of code (class etc.) it takes all of its dependencies with it.
  4. Viscosity. Make it hard to do the right thing. There are usually several ways to work with a design. Viscosity happens when it is hard to work with the design the way the designer intended to. The results are tricks and workarounds that, many times, have unexpected outcomes (esp. if the design is also fragile).
  5. Needless Complexity. Over design. When you overdo it; e.g. the “Swiss-Army knife” antipattern. A class that tries to anticipate every possible need. Another example is applying too many patterns to a simple problem etc.
  6. Needless Repetition. The same code is scattered about which makes it error prone.
  7. Not doing any design.

Coding The Architecture

I stumbled upon Coding the Architecture and found it to be a very refreshing and pragmatic view to software architecture and to the role of a software architect. I generally find that sites, blogs and articles on software architecture tend to focus on presenting a specific architectural process, modeling tool or on the latest trend in software architecture. Trying to find down to earth, practical advice on how to set oneself up for success as a software architect has proven difficult – until now. 

After browsing through some of the blog entries on the site and from one of its user groups, I am reminded of the resonant style of the Pragmatic Programmer book. It has the same practical and pragmatic feel. 

Some entries / articles that I found interesting: