PROGRAMMING IN C

1. INTRODUCTION TO
PROGRAMING & PROBLEM
SOLVING – SPS2101
Lecture 2
Program Development Cycle - Modularity

2. Lecture Overview
• Program development life cycle
• Characteristics of a good program
• Types of errors
• Modularity

3. Program
development
life cycle

4. Program development life
cycle
• The program development is part of the software
development life cy le, characterized by the following
steps;
1. Requirement analysis
2. Design
3. Coding
4. Testing
5. Implementation support
6. Documentation

5. Requirement Analysis
• An accurate and complete set of
client and user requirements is
produced to determine the
characteristics of the desirable
solution.

6. Requirement analysis components
• The requirement analysis is made up of;
1. The proposed solution agreed upon by the client and developer
2. List of existing tools, new tools, required facilities and development team
3. A schedule for implementation stages consisting of deliverables at each phase

7. Design stage
• Use of proper design techniques to illustrate the program
specifications in a systematic way
• Representing the tasks required in the program
specification showing al input, processing and output
requirements
Example
• Flowchart
• Pseudocode
• JSP

8. Coding stage
Produce the programs that will
make up the system
Translation of design into
programming language e.g c,
c++, pascal
AKA implementation Complete when all code is
written, compiled and
documented without any errors

9. Testing
stage
Debugging: Done by development team – the task
involves tracing and removing errors/bugs
Testing: done by testing team – the task of locating
and identifying bugs/errors included in the program
Any tracable error is corrected and the testing
phase repeated again.
Types of tests
Alpha test: test of the finished application
completed internally
Beta test: tested externally

10. Implementation and support
• When all the previous stages have been completed
satisfactorily, the system is ready for implementation
• Program is transferred o the user’s machine and made to
work
• 3 strategies are incorporated
• The new program run concurrently with the old one
• It may completely replace the old one
• It may be phased out gradually

11. Implementation and support
ONCE THE PROGRAM IS INSTALLED AND
OPERATED, IT WILL BE MONITORED FOR SOME
TIME TO ENSURE THAT PROGRAM IS ERROR-FREE
MAINTENANCE INCLUDES ERROR FIXING,
UPDATES AND MODIFICATION

12. Documentation stage
All processes in all stages during the system
development must be documented/written
down
This documentation is vital for future
reference/for future maintenance of the
program

13. Characteristics of a good program
CORRECTNESS: FULFILLING
USER REQUIREMENTS
RELIABILITY: IT PRODUCES
CORRECT OUTPUT AND
VALIDATES INPUT DATA TO
AVOID PROGRAM CRASH
PORTABILITY: EASILY
INSTALLED FROM ONE
MACHINE TO ANOTHER
WITH MINIMAL
MODIFICATION
MAINTAINABILITY: EASILY
FOLLOWED AND MODIFIED,
NOT ONLY TO THE
PROGRAMMER WHO
WROTE IT
READABILITY: CLEARLY
DOCUMENTED
USE OF RESOURCES: FAST IN
PROCESSING, USES
MINIMUM STORAGE SPACE
AND ABLE TO RUN ON
EXISTING HARDWARE

14. Types of
errors
Syntax: error relating to the
programming language used
Logical: error in programming logic
Run-time/execution: error that
appears after you compile and run
your code

15. Modularity

16. Modularity
Software is divided into
separately named
components often called
modules that are used to
detect problems at ease.
This follows the “divide and
conquer’ strategy.
It is easier to solve a
complex problem when you
break it into manageable
pieces

17. Why modularize a
system?
Management: partition the
overall development effort
Evolution: Decouple parts of
a system so that changes to
one part are isolated from
changes to other parts
Principle of
discontinuity
(delete a part)
Principle of
continuity
(addition to the
part)
Understanding: Permit
system to be understood
As composition
of mind-sized
chunks
With one issue at
a time

18. Advantages of modularization
Smaller
components are
easier to maintain
Program can be
divided based on
functional aspects
Desired level of
abstraction can be
brought in the
program
Components with
high usage can be
re-used
Concurrent
execution can be
made possible

19. Modular design
Easier to change Easier to build Easier to maintain

20. Functional Independence
Cohesion: The degree
to which a module
performs one and
only one function
Coupling: The degree
to which a module is
‘connected’ to other
module in the system.

21. Modularity “Modules”
cost Vs size
• The effort(cost) to develop an individual software
module does decrease as the total number of modules
increases.
• Given the same of requirements more modules means
smaller individual size.
• However, as the number of modules grows the effort
(cost)associated with integrating the modules grows.
• These characteristics lead to a total cost or effort
as shown in these figure.
• There is a number “M” of modules that would result in
Minimum cost development.

22. Self-contained:
“Agile &
Autonomous”
A module is a self-contained component of a
larger software system.
This doesn’t mean that it is atomic component
In fact, a module consists of several smaller
pieces which are collectively contributed o the
functionality/ performance of the module.
A module can be installed, un-installed or
moved as a whole and it won’t affect the
functionality of the other modules