An advocation of design focused development (and software entropy)
Image Credit: John Shier
Web application development is an arena that is fairly easy to get into if you are equipped with the right sort of mind and mentality. In most cases it requires no formal education on the subject at all and the majority are self-taught. In fact, my thoughts are that the industry is so fast-moving, that by the time schools can create a ‘relevant’ syllabus, it’s probably, well; irrelevant.
Online learning resources such as code-school, treehouse and YouTube are great for equipping up-and-coming developers with great syntactical knowledge of their choice software and many developers take this route, (+/- a few books), into a web development career.
However, I believe there is at least one area which should be studied more by web application developers and employers should put more emphasis on when recruiting. This area is application design.
Never have I met a software developer coming from web who has UML diagrams coving his desk and TOGAF certificates hanging on his wall. I’m not saying certificates and complete architectural expertise are necessary, but I will say that a good knowledge of software design is one of the key differentiators of a great developer over a good one.
With popular development frameworks firmly ensconced at the heart of many a project, the modern web app developer has even less reason to study the ins-and-outs of software design. With application frameworks, most of the design has already been done by someone else, and given that most popular choices adopt inversion of control principles, the design elements the modern web developer is expected to address are minimal.
(Heck I made it nearly eight years into my development career myself without ever doing any architectural training or research, which shows how little emphasis employers put on the area. I’m 100% sure I could have done a better job on all of my projects up until that point if I had learnt some solid design skills, and have paid the price in the past when projects got big and complicated and turned into code spaghetti due to lacking design.)
As you may have guessed from my above monologue, I think we should advocate stronger knowledge of software architecture on in the web development community. My first discussion towards this end, is what some like to call ‘software entropy’. The second law of thermodynamics applies all over the universe, and if we aren’t careful, it’s virtual brother will proliferate our software and ensure our code less ordered (messier) over time.
Software entropy starts at the design and architecture level. It’s a product of a project in which the programmers a working from poor designs or no designs. To avoid software entropy, you need to set and enforce clear design rules. I’m not talking about business logic rules, or what your developers need to wear when coding, I mean design rules which your developers must adhere to in their implementations. Patterns, principles, standards, and limitations.
Hopefully, the following questions and points should help build a solid framework for rules and patterns to help avoid code entropy. I’ve intentionally left this list high-level and short but if you have others to contribute, please comment.
- What is the hierarchical list of development principles which must be used?
- What are the designs for application, subsystem, class and routine levels?
- Are they consistent?
- Can a developer stay on one level while working or do they have to dip in-and-out of different levels?
General Design Rules and heuristics
- Which modules in your system are allowed to communicate with each other?
- How many other modules is one module allowed to communicate with? (should be a very low number or none)
- Which modules or classes are allowed to communicate with the database? File system? Client?
- Where are the entry points to your application? Can there be others?
- Portability – how will your developers consistently ensure the code works on all platforms require?
- Reusability – what’s the consistent approach to ensuring developers make their code re-usable?
- Performance – what’s the principles for ensuring performance?
- Extensibility, maintainability, redundancy, and so on – how have you factored in these elements?
- What are your coding standards and guidelines?
- Aceptable technologies?
- Acceptable modules and 3rd party code vendors?
I’d love to hear you thoughts on design practises within the web application community.