Software development is a pursuit characterized by complexity. This can take many forms, for example,
accommodating complex requirements, technology or team dynamics. Being able to elevate the level of abstraction helps
us manage this complexity and make tractible progress in the face of an inherently difficult task.
There are a number of strategies available to help abstract away complexity. Here are some suggestions.
Leverage Patterns
Patterns help us take advantage of proven techniques for solving common problems. We can benefit from the experience of
seasoned practioners and avoid "re-inventing the wheel." The use of patterns is a crucial aspect of an
architecture-centric approach to development, helping to reduce the novelty and diversity of a solution and thereby
improving quality.
See Patterns for more information.
Architect with Components and Services
This strategy helps manage software complexity through partioning a system into a set of loosely-coupled and
highly-cohesive subsystem. This approach has a number of benefits, including the ability to organise the team around a
set of smaller, more manageable objectives; and the ability to subsitute parts of the system without disturbing the
overall cohesion of the system. Exposing services encourages re-use thorough making the functionality of the system
easier to comprehend. Focusing on services makes it possible to understand what the system does from a technical
perspective without having to necessarily understand the details of how the system works.
See Component for more information.
Actively Promote Reuse
Incorporating existing software into an overall architecture helps to reduce cost and improve quality by reusing proven
working software rather than developing from scratch. It also helps to reduce the burden of maintenance by
eliminating duplication in the software estate. Although often difficult to manage, a well-executed re-use strategy can
reap signifcant benefits for a project and/or enterprise.
Model Key Perspectives
Modeling helps to raise the level of abstraction by simplifying complex ideas into pictures. Good models are able to
convey information that helps the team visualize, specify, construct and document software. The Unified Modeling
Language provides an industry standard approach to software modeling that is widely used across the industry.
When applying this strategy, a number of techniques can be employed.
-
Identify the key perspectives - Focus on modeling the things that count. Few (if any) projects
benefit from modeling the entire design to an excrutiating level of detail. Make sure that you understand why you
are modeling something and who will benefit from it.
-
Sketch the design - Not all models need to be detailed, complete and presented in a software
modeling tool. It is often perfectly acceptable (if not desirable) to produce hand-drawn sketches on paper or
around a whiteboard when exploring and communicating the architecture and design with your team. You can use a
digital camera or electronic whiteboard to capture these diagrams and share them. For many small projects, this is
often all you need. See www.agilemodeling.com for more
information.
-
Agree on a standard notation - In a team environment it is naturally important that others can
understand your diagrams without too much explanation. Choosing a standard notation will enable others to quickly
comprehend your diagrams without ambiguity. The Unified Modeling Language is an example of a widely understood
notation.
-
Visualize the code - Many software development tools allow you to view the code as models, making
it easier to comprehend static and dynamic aspects of a complex code base.
-
Document key architectural perspectives - Even if you choose to model very little your
design, it is often advantageous to produce diagrams communicating the key architectural aspects of the system.
Conveying the "big picture" to the rest of the team will help them understand the overall approach and develop
cohesive software.
-
Use a Model-Driven Development approach - This approach takes formal and complete models and
applies a series of defined transformations, ultimately resulting in the generation of working software. This
technique offers a number of benefits, with reported success stories. See www.omg.org/mda for more information.
|