The first and most
important step of software construction is the identification of the qualities
that the software must possess. It is a step that can sometimes be overlooked
or missed in the requirements process because we are often too eager to get into
the details so that we can start building. We tell ourselves that
"correctness," which is the quality that dictates software must
correctly do what it is designed to do, is the end-all be-all upon which
everything else hangs. And while this probably the most important quality to
strive for in software construction, it is only one of many qualities that may
be important to your client or customer.
As an architect, I
have to understand the qualities that are most important to my client so that I
know what my solution constraints are. There are a million ways to design a
solution to any given software problem. It is my job as an architect to pick from
that universe of solutions the one solution that most appropriately produces
the qualities that matter the most. This task is a lot easier to accomplish
when I know what those qualities are from the onset of a project.
Here are the top
ten qualities that my clients generally desire when building solutions:
Adaptability
|
How easy should it be to change the software in the
future? If you work in an environment where change is a normal part of
the business process, then adaptability is probably important to you. Having
worked on a software-as-a-service eCommerce platform before, I know a thing
or two about how essential adaptable software can be for a clothing
manufacturer trying to keep an edge on the competition. However, I've also
worked in many enterprises where adaptability isn't very important at all
because of time or budgetary constraints. Whether an application should be
adaptable or not may drive whether you use the Adapter or Dependency
Injection (DI) design patterns to build your system.
|
Availability
|
For how long does your application need to be
available for your users? Knowing
the answer to this question will determine whether you will need to built in
additional redundancy to ensure that the systems doesn't fail. You will also
need to think about how to perform patching and feature upgrades without
taking the system down for extended periods of time.
|
Correctness
|
Does the software do what it is designed to do?
This is one of the more obvious qualities that most people would identify as
being a very important. Hard to argue with the fact that, if software is
being built for a specific set of jobs, it should do those jobs correctly.
|
Maintainability
|
Can other engineers easily support the system and
perform debugging to resolve production issues? This quality makes it
pretty high on the list for most engineers. With many shops being
understaffed and strained for resources, it can be very important to
customers to keep any learning curve associated with supporting the system at
a very low level.
|
Robustness
|
How does the system respond to bad input or
unexpected errors? An application designed to be used as a quick and
dirty tool for an internal engineering team might not need to be very robust.
However, an educational game designed to be used by hundreds of thousands of
elementary school children might need to be very, very robust. Building
robust software is not easy and will require very rigorous testing and
software construction standards to ensure that a system can hold up when
things take a turn for the worst.
|
Portability
|
Will the system need to execute across multiple
platforms and devices? With the increase of phones, tablets, and other
mobile devices, we live in a world where applications must often support
multiple platforms simultaneously. Making a system portable requires a great
deal of planning and consideration in order to determine what versions of
each platform should be supported. There are a number of tools and frameworks
that can assist with making applications more portable such as Java, Mono,
and Silverlight.
|
Reusability
|
Will components implemented or used by the system
need to be reused in other systems? When building a suite of
applications that share the same features, reusability is an extremely
valuable quality since it can save both time and money. Highly reusable
components also ensure that your users will have a consistent experience from
one application to another.
|
Scalability
|
Can the system perform well under increased load? Some
systems do not experience the same load consistently from day to day or week
to week. Systems and applications supported by a professional sports league
will experience peak utilization while in season, demonstrating loads that
are dramatically higher than they would be during the offseason.
|
Security
|
Is the system susceptible to attacks and
intrusions? System security can be very challenging to design
correctly. You have to think like a potential attacker, assess threats, and
design the appropriate solution. There may be standards and regulations that
must be adhered to in order to maintain certification. Whatever the case,
security constraints should be examined up front since doing so too late will
almost always be significantly more costly.
|
Usability
|
How well can users execute the various functions of
the system? Users won't care what or how well your application works
if they don't like using it. Applications that suffer from poorly designed
user interfaces can double or triple the amount of work users have to do in
order to use the system correctly, leading to big headaches for them and
higher support costs for you.
|
