- Programming Methodologies
- Understanding the Problem
- Identifying the Solution
- Applying Modular Techniques
- Writing the Algorithm
- Flowchart Elements
- Using Clear Instructions
- Correct Programming Techniques
- Program Documentation
- Program Maintenance
Applying Modular Techniques
A real-life problem is complex and big. If a monolithic solution is developed it poses these problems −
Difficult to write, test and implement one big program
Modifications after the final product is delivered is close to impossible
Maintenance of program very difficult
One error can bring the whole system to a halt
To overcome these problems, the solution should be divided into smaller parts called modules. The technique of breaking down one big solution into smaller modules for ease of development, implementation, modification and maintenance is called modular technique of programming or software development.
Advantages of Modular Programming
Modular programming offers these advantages −
Enables faster development as each module can be developed in parallel
Modules can be re-used
As each module is to be tested independently, testing is faster and more robust
Debugging and maintenance of the whole program easier
Modules are smaller and have lower level of complexity so they are easy to understand
Identifying the Modules
Identifying modules in a software is a mind boggling task because there cannot be one correct way of doing so. Here are some pointers to identifying modules −
If data is the most important element of the system, create modules that handle related data.
If service provided by the system is diverse, break down the system into functional modules.
If all else fails, break down the system into logical modules as per your understanding of the system during requirement gathering phase.
For coding, each module has to be again broken down into smaller modules for ease of programming. This can again be done using the three tips shared above, combined with specific programming rules. For example, for an object oriented programming language like C++ and Java, each class with its data and methods could form a single module.
To implement the modules, process flow of each module must be described in step by step fashion. The step by step solution can be developed using algorithms or pseudocodes. Providing step by step solution offers these advantages −
Anyone reading the solution can understand both problem and solution.
It is equally understandable by programmers and non-programmers.
During coding each statement simply needs to be converted to a program statement.
It can be part of documentation and assist in program maintenance.
Micro-level details like identifier names, operations required, etc. get worked out automatically
Let’s look at an example.
As you can see in the above example, it is not necessary that a program logic runs sequentially. In programming language, control structures take decisions about program flow based on given parameters. They are very important elements of any software and must be identified before any coding begins.
Algorithms and pseudocodes help analysts and programmers in identifying where control structures are required.
Control structures are of these three types −
Decision Control Structures
Decision control structures are used when the next step to be executed depends upon a criteria. This criteria is usually one or more Boolean expressions that must be evaluated. A Boolean expression always evaluates to “true” or “false”. One set of statements is executed if the criteria is “true” and another set executed if the criteria evaluates to “false”. For example, if statement
Selection Control Structures
Selection control structures are used when program sequence depends upon the answer to a specific question. For example, a program has many options for the user. The statement to be executed next will depend on the option chosen. For example, switch statement, case statement.
Repetition / Loop Control Structures
Repetition control structure is used when a set of statements in to be repeated many times. The number of repetitions might be known before it starts or may depend on the value of an expression. For example, for statement, while statement, do while statement, etc.
As you can see in the image above, both selection and decision structures are implemented similarly in a flowchart. Selection control is nothing but a series of decision statements taken sequentially.
Here are some examples from programs to show how these statements work −