QUALITIES OF A GOOD SOFTWARE

The goal of software engineering is, of course, to design and develop better software. However,
what exactly does "better software" mean? In order to answer this question, this lesson
introduces some common software quality characteristics. Six of the most important quality
characteristics are maintainability, correctness, reusability, reliability, portability, and efficiency.

Maintainability is "the ease with which changes can be made to satisfy new requirements
or to correct deficiencies". Well-designed software should be flexible enough to accommodate
future changes that will be needed as new requirements come to light. Since maintenance
accounts for nearly 70% of the cost of the software life cycle, the importance of this quality
characteristic cannot be overemphasized. Quite often the programmer responsible for writing a
section of code is not the one who must maintain it. For this reason, the quality of the software
documentation significantly affects the maintainability of the software product.

Correctness is "the degree with which software adheres to its specified requirements". At the
start of the software life cycle, the requirements for the software are determined and formalized
in the requirements specification document. Well-designed software should meet all the stated
requirements. While it might seem obvious that software should be correct, the reality is that this
characteristic is one of the hardest to assess. Because of the tremendous complexity of software
products, it is impossible to perform exhaustive execution-based testing to ensure that no errors
will occur when the software is run. Also, it is important to remember that some products of the
software life cycle such as the design specification cannot be "executed" for testing. Instead,
these products must be tested with various other techniques such as formal proofs, inspections,
and walkthroughs.

Reusability is "the ease with which software can be reused in developing other software". By
reusing existing software, developers can create more complex software in a shorter amount of
time. Reuse is already a common technique employed in other engineering disciplines. For
example, when a house is constructed, the trusses which support the roof are typically purchased
preassembled. Unless a special design is needed, the architect will not bother to design a new
truss for the house. Instead, he or she will simply reuse an existing design that has proven itself
to be reliable. In much the same way, software can be designed to accommodate reuse in many
situations. A simple example of software reuse could be the development of an efficient sorting
routine that can be incorporated in many future applications.

Reliability is "the frequency and criticality of software failure, where failure is an

unacceptable effect or behavior occurring under permissible operating conditions". The
frequency of software failure is measured by the average time between failures. The criticality of
software failure is measured by the average time required for repair. Ideally, software engineers
want their products to fail as little as possible (i.e., demonstrate high correctness) and be as easy
as possible to fix (i.e., demonstrate good maintainability). For some real-time systems such as air
traffic control or heart monitors, reliability becomes the most important software quality
characteristic. However, it would be difficult to imagine a highly reliable system that did not also
demonstrate high correctness and good maintainability.

Portability is "the ease with which software can be used on computer configurations other
than its current one". Porting software to other computer configurations is important for several
reasons. First, "good software products can have a life of 15 years or more, whereas hardware is
frequently changed at least every 4 or 5 years. Thus, good software can be implemented, over its
lifetime, on three or more different hardware configurations". Second, porting software to a new
computer configuration may be less expensive than developing analogous software from scratch.
Third, the sales of "shrink-wrapped software" can be increased because a greater market for the
software is available.

Efficiency is "the degree with which software fulfills its purpose without waste of resources".
Efficiency is really a multifaceted quality characteristic and must be assessed with respect to a
particular resource such as execution time or storage space. One measure of efficiency is the
speed of a program's execution. Another measure is the amount of storage space the program
requires for execution. Often these two measures are inversely related, that is, increasing the
execution efficiency causes a decrease in the space efficiency. This relationship is known as the
space-time tradeoff. When it is not possible to design a software product with efficiency in every
aspect, the most important resources of the software are given priority.
 QUALITIES OF A GOOD DEVELOPER
1. POSITIVE ATTITUDE
A great programmer cares about your product. They are positive, willing to go the distance to get
the job done and bring their best everyday. Although it’s important not to exhaust a developer
with frequent urgent deadlines, sometimes this is unavoidable. When you need to bring a product
to market or need to ship a certain feature out by the deadline, the great programmer will step up
and get the product released whenever possible. Because they care. A great developer doesn’t let
their ego get in the way of taking feedback. A good way to instil a positive attitude is to give
them interesting projects to work on, give them a sense of ownership and praise them for good
work. Start-ups can give out stock options, pay employees for working overtime, provide
compensated paid leave or find other perks that ensure great programmers are retained.

2. SUPREME COMMUNICATION SKILLS

Good communication skills directly correlate with good development skills. A great developer is
able to understand problems clearly, break them down into hypotheses and propose solutions in a
coherent manner. They understand concepts quickly, or ask the right questions to understand,
and don’t need to have everything written down in a specifications document. Great offshore
developers usually speak multiple languages coherently and are very comfortable with
documentation in English. In the world of technology, English is the defector language of most
documentation and developer interactions. If they don’t speak it well enough, they’ll require
interpreters and translators, making their knowledge second hand, and quickly outdated.

3. GREAT AT TIME AND TASK MANAGEMENT

Great developers are highly reliable. They have a strong work ethic and show up at meetings on
time. An important skill is the ability to estimate the amount of time needed to complete a task,
communicating this and delivering on it. Exceptional developers are great at managing their
clients or leaders instead of you managing them.

4. QUICK LEARNING ABILITY

Great developers are usually amazing self-learners. They have the ability to learn new
technologies on their own and aren’t intimidated by new technologies. They have the ability to
pull disparate bits of information and process information on the fly. Every programmer will
experience a situation where he or she doesn’t know the answer. Great programmers will find
different resources, talk to the right people and find the solution no matter what. The best skill
anyone can have is knowing how to learn, and great developers have mastered the skill of self-
learning.

5. DEEP AND BROAD TECHNICAL EXPERIENCE

Great developers have worked with a handful of technologies long enough to become experts
and are competent with many. Of course, finding a programmer who has worked on a product
similar to yours or that uses the same technologies important. The right programmer for your
project will be able to hit the ground running because they already know the right technologies.
They will follow coding standards and will write code that is understandable and commented
where necessary and can be passed on to someone else easily. By combining their cognitive
abilities and diverse industry experience, they’re able to arrive at optimal solutions quickly. An
experienced developer is well versed in best practices like agile development, task management
software (Jira, Trello, etc.), version control (If they know Git, it’s a sign they’ve moved on past
older systems like SVN), and working in different environments (local development
environment, and working knowledge of deploying applications) so ask them about these things.

6. A GOOD TEAM PLAYER

Another superb quality of premium developers is their ability to help other developers get better.
They offer teammates help when they are stuck, teach new skills to others and write
documentation that would help teammates not only in their organization but the developer
community in general.

7. HIGH-END USER FOCUS

A good programmer does what is asked of them while a great programmer thinks of the end user
of the software and works to solve problems for them within the abilities of the organization. A
great programmer wants to know the feature they’re building is of high value and pushes back
when a feature creates no value for anyone.