QUALITIES OF A GOOD PROGRAM

A good program is not necessarily a powerful application but at the very least, it must pass
certain criteria so that it can stand out among other programs in the market. If you are a
programmer by profession, your main goal in creating programs is and should always be to
satisfy the requirements of your clients. Aside from attaining this goal, you should also take the
following qualities into consideration when you create your program:

) It should be free from bugs.

Program errors normally occur no matter how careful the programmer is in constructing the
program. Even commercially released applications are not spared from this buggy predicament.
The best thing a programmer can do is to constantly find bugs in the program or for large-scale
applications, enlist the aid of beta testers. This will not necessarily eliminate every program error
but at least it would minimize the occurrence of such bugs.

2) It must run in an accurate and efficient manner.

During quality control, a program must be tested for its accuracy and efficiency. Not all
programs are created equal. Some programs are not sophisticated enough to successfully
complete multiple tasks. Others have a slew of powerful features but they take too long to load.
As a programmer, it should be your priority to satisfy your client's needs without neglecting
accuracy and efficiency. You must not compromise one for the other, instead, you should set
some kind of equilibrium point which balances the two qualities.

3) The program's interface must be accessible and user-friendly.

No matter how good a program's features are, a cluttered user interface will most likely drag it
down. Don't risk it. Potential users will steer clear from your program unless you have a
comprehensive help file to go along with the messy UI.

4) It should be easy to maintain and doesn't hog system resources.

What good is a program if it bogs down the entire computer system? Sometimes, you must
carefully consider an average user's system specifications. If you're creating a program in a high-
end computer and you notice that it runs really smoothly, you should also make the effort to test
it in a system with only the barest necessities. Remember that there are still people out there who
use relatively low-end computers, so if you don't want to alienate them, try to put yourself in
their shoes. Of course, you should not sacrifice a program's quality in the process. You must
strike a balance in this criterion as well.

5) The source code is well-organized and optimized for the best performance.

If your main goal is to share bits and pieces of your code to the community to showcase your
skills as a programmer, then you should clean it up and trim down excess code. It is advisable to
organize your code in such a manner that they will understand your program's flow.
Program Development Life Cycle

The process of developing a software, according to the desired needs of a user, by following a
basic set of interrelated procedures is known as Program Development Life Cycle.

PDLC includes various set of procedures and activities that are isolated and sequenced for
learning purposes but in real life they overlap and are highly interrelated.

Tasks of Program Development

The basic set of procedures that are followed by various organisations in their program
development methods are as follows:

1.Problem Definition
2.Program Design
3.Coding
4.Debugging
5.Testing
6.Documentation
7.Maintenance
8.Extension and Redesign

1.PROBLEM DEFINITION

This stage is the formal definition of the task. It includes the specification of inputs and outputs
processing requirements, system constraints, and error handling methods.

This step is very critical for the completion of a satisfactory program. It is impossible to solve a
problem by using a computer, without a clear understanding and identification of the problem.
Inadequate identification of problem leads to poor performance of the system. The programmer
should invest a significant portion of his time in problem identification. If he does not spend
enough time at %%%%%%%%

This step is the process of becoming familiar with the problem. It starts when the programmer is
assigned a task. This step includes the reviewing of the design document that was prepared for
the program, as well as any system wide information that would be helpful.

The process ends when all the programmer’s questions have been resolved and the requirements
of the program are understood.

2.PROGRAM DESIGN
Once the problem has been identified, the next stage is the program design. A computer is both
fast and versatile, but it requires the meticulous specification of what actions it should take. For
the user, there is seldom an opportunity to allow the computer to make an undirected decision.
Therefore the programmer must decide, prior to writing his program, exactly which steps the
computer should take to solve an identified problem. Such a functional description of the task is
either called an algorithm or results in a diagram called flowchart.

The techniques that are useful in program design include:

i. MODULAR PROGRAMMING

A method in which long programs are divided into smaller programs or modulates that can be

designed, coded and debugged separately with a minimum amount of interaction.

ii. TOP-DOWN DESIGN

A method in which the overall task is first defined in terms of generalised sub-tasks that, in
turn, are subsequently further defined. The process continues downward until the sub-tasks
are defined in a form suitable for execution by the computer.

iii.STRUCTURED PROGRAMMING
A method in which programs are written according to specifically defined forms; that is
only certain kinds of program logic are allowed, although the forms allowed may be nested
within one another to handle complex situations.

The software designer can offcourse use a combination of techniques. Flowcharting, top
down design, structured programming and modular programming are not mutually

exclusive.

3.CODING

The third step is the process of transforming the program logic design documents into a
computer language format. This stage translates the program design into computer instructions.
These instructions are the actual program or the software product.
During this step the programmer eliminates all the syntax and formal errors from the program
and all logic errors are detected and resolved during this process. This step is walk through
has been held.

4.DEBUGGING

This stage is the discovery and correction of programming errors. Few programs run correctly
the first time, so debugging is an important and time consuming stage of software development.
Programming theorists often refer to program debugging and testing as verification and
validation, respectively. Verification ensures that the program does what the programmer intends
to do. Validation ensures that the program gives the correct results for a set of test data.
The tools that can be used to debug programs are given below:

•Simulators.
•Logic Analysers.
•Breakpoints.
•Trace routines.
•Memory Dumps.
•Software Interrupts.

5.TESTING
This stage is the validation of the program. Testing ensures that the program performs correctly
the required tasks. Program testing and program debugging are closely related. Testing is
essentially a later stage of debugging in which the program is validated by trying it on a suitable
set of cases.

Program testing is, however, more than a simple matter of exercising the program a few
times. Exhaustive testing of all possible cases is the best alternative, but this processes is usually
impractical. Formal validation methods exist, but are only applicable to very simple programs.
Thus, program testing requires a choice of test cases.
Among the rules that can aid in program testing are the following:

• Make the test plan part of the program design.

• Check all trivial and special cases.

• Select test data on a random basis.

• Plan and document software testing just like hardware testing.

• Use the maximum and minimum values of all variables as test data.
• Use statistical methods in planning and evaluating complex tasks.

There are two goals in preparing a test plan. Firstly, a properly detailed test plan demonstrates
that the program specifications are understood completely. Second, the test plan is used during
the program testing to prove the correctness of the program. During this step a general approach
to the testing of the program is prepared and documented, indicating the number of tests needed
and the purpose of each test.
6.DOCUMENTATION

This stage is the documentation of the program so that those who use and maintain it, can
understand it, and program can be extended to further applications. Documentation is a stage of
software development that is often overlooked. This stage is the documentation of the program
so that those who use and maintain it, can understand it, so that the program can be extended to
further applications.
Documentation is a stage of software development that is often overlooked. Yet proper
documentation is not only useful in the testing and debugging stages, it is also essential in the
maintenance and redesign stages. A properly documented program can be easily reused when
needed; an undocumented program usually requires so much extra work that the programmer
might as well start from scratch.
Among the techniques commonly used in documentation are flowcharts, comments, memory
maps, parameter and definition lists, and program library forms.
Proper documentation combines all or most of the methods mentioned. Documentation is a time
consuming task that the programmer performs simultaneously with the design, coding,
debugging and testing stages of software development. Good documentation simplifies
maintenance and redesign, and makes subsequent tasks simpler.
7.MAINTENANCE

This stage is the updating and correcting of the program to account for changing conditions or
field experience. Proper testing and documentation should significantly reduce the frequency and
extent of required maintenance. Unlike student programs that used for a long time. Changes may
occur due to:

• Newly discovered bugs.

• Specification changes.

• Specification expansion.

• New equipment.
The costs involved in program maintenance are usually grossly underestimated by most
programmers. It has been studied that in a typical programming environment, over 50% of the
time is spent on maintaining the existing programs.
So, it becomes really necessary to reduce the costs and the time spent on maintenance. This can
be done by the use of the following steps:
• Clarity and readability of code.

• Portability and generality.

• Structured code.

• Modularity.

• Debugging and testing.

• Documentation.

8.EXTENTION AND REDESIGN

This stage is the extension of the program to solve problems beyond those described in initial
problem definition. Obviously designers want to take advantage of programs developed for
previous tasks.

Designers should not consider any task in complete isolation from those that occur
subsequently.
Redesign may involve adding new features or meeting new requirements. Such redesign should
proceed through the previously mentioned stages of software development. The process may also
involve making a program meet critical time or memory requirements.

When relatively small increase in speed or reduction in memory usage is needed, a program can
often be reorganised to meet the requirement. Program structure may have to be sacrificed. The
new program must be carefully documented, since its working will seldom be obvious. Such a
reorganisation may require a large amount of programmer’s time and should be avoided when
possible.
Enormous gains cannot be expected from program optimisation. Unless the program is very
poorly written, speed increase or memory reduction larger than 25% is rare.