Part 10: Program Maintenance of Computer Programming Techniques

by Jesmin Akther | Jan 5, 2022 | Computer Programming Techniques

Program Maintenance

Program maintenance is the process of modifying a software or program after delivery to achieve any of these outcomes:

• Correct errors
• Improve performance
• Add functionalities
• Remove obsolete portions

Despite the common perception that maintenance is required to fix errors that come up after the software goes live, in reality most of the maintenance work involves adding minor or major capabilities to existing modules. For example, some new data is added to a report, a new field added to entry forms, code to be modified to incorporate changed government laws, etc.

Types of Maintenance

Maintenance activities can be categorized under four headings −

• Corrective maintenance − Here errors that come up after on-site implementation are fixed. The errors may be pointed out by the users themselves.
• Preventive maintenance − Modifications done to avoid errors in future are called preventive maintenance.
• Adaptive maintenance − Changes in the working environment sometimes require modifications in the software. This is called adaptive maintenance. For example, if government education policy changes, corresponding changes have to be made in student result processing module of school management software.
• Perfective maintenance − Changes done in the existing software to incorporate new requirements from the client is called perfective maintenance. Aim here is to be always be up-to-date with the latest technology.

Maintenance Tools

Software developers and programmers use many tools to assist them in software maintenance. Here are some of the most widely used −

• • Program slicer − selects a part of the program that would be affected by the change
  • Data flow analyzer − tracks all possible flows of data in the software
  • Dynamic analyzer − traces program execution path
  • Static analyzer − allows general viewing and summarizing of the program
  • Dependency analyzer − assists in understanding and analyzing interdependence of different parts of the program

Software maintenance

Definition: Software maintenance is a part of Software Development Life Cycle. Its main purpose is to modify and update software application after delivery to correct faults and to improve performance. Software is a model of the real world. When the real world changes, the software requires alteration wherever possible.

Software Maintenance Description: 

Software maintenance is a vast activity which includes optimization, error correction, deletion of discarded features and enhancement of existing features. Since these changes are necessary, a mechanism must be created for estimation, controlling and making modifications. The essential part of software maintenance requires preparation of an accurate plan during the development cycle. Typically, maintenance takes up about 40-80% of the project cost, usually closer to the higher pole. Hence, a focus on maintenance definitely helps keep costs down.

Software Maintenance Processes are:

• The SM process includes a maintenance plan which contains software preparation, problem identification and find out about product configuration management.

• The problem analysis process includes checking validity, examining it and coming up with a solution and finally getting all the required support to apply for modification.

• The process acceptance by confirming the changes with the individual who raised the request.

• The platform migration process, which is used if software is needed to be ported to another platform without any change in functionality.

Some software points that affect maintenance cost include:

• Structure of Software Program

• Programming Language

• Dependence on external environment

• Staff reliability and availability

Part 9: Program Documentation of Computer Programming Techniques

by Jesmin Akther | Jan 5, 2022 | Computer Programming Techniques

Program Documentation

Any written text, illustrations or video that describe a software or program to its users is called program or software document. User can be anyone from a programmer, system analyst and administrator to end user. At various stages of development multiple documents may be created for different users. In fact, software documentation is a critical process in the overall software development process.

In modular programming documentation becomes even more important because different modules of the software are developed by different teams. If anyone other than the development team wants to or needs to understand a module, good and detailed documentation will make the task easier.

These are some guidelines for creating the documents −

• Documentation should be from the point of view of the reader
• Document should be unambiguous
• There should be no repetition
• Industry standards should be used
• Documents should always be updated
• Any outdated document should be phased out after due recording of the phase out

Advantages of Documentation

These are some of the advantages of providing program documentation −

• Keeps track of all parts of a software or program
• Maintenance is easier
• Programmers other than the developer can understand all aspects of software
• Improves overall quality of the software
• Assists in user training
• Ensures knowledge de-centralization, cutting costs and effort if people leave the system abruptly

Example Documents

A software can have many types of documents associated with it. Some of the important ones include −

• User manual − It describes instructions and procedures for end users to use the different features of the software.
• Operational manual − It lists and describes all the operations being carried out and their inter-dependencies.
• Design Document − It gives an overview of the software and describes design elements in detail. It documents details like data flow diagrams, entity relationship diagrams, etc.
• Requirements Document − It has a list of all the requirements of the system as well as an analysis of viability of the requirements. It can have user cases, reallife scenarios, etc.
• Technical Documentation − It is a documentation of actual programming components like algorithms, flowcharts, program codes, functional modules, etc.
• Testing Document − It records test plan, test cases, validation plan, verification plan, test results, etc. Testing is one phase of software development that needs intensive documentation.
• List of Known Bugs − Every software has bugs or errors that cannot be removed because either they were discovered very late or are harmless or will take more effort and time than necessary to rectify. These bugs are listed with program documentation so that they may be removed at a later date. Also they help the users, implementers and maintenance people if the bug is activated.

Programming and Documentation Style Requirements

Here is a list of four categories of documentation to be considered:

1. “External” Documentation: In programming classes, the comprehensive set of documents that detail the design, development, and structure of a program are usually condensed into a comparatively brief ‘block comment’ at the top of the source code. This “external” documentation will minimally include:
   1. Your name, the course name/number, assignment name/number, instructor’s name, and due date.
   2. Detailed description of the problem the program was written to solve, including the techniques (e.g., algorithms) used to solve the problem.
   3. The program’s operational requirements: Which language system you used, special compilation information, where the input can be located on disk, etc.
   4. Required features of the assignment that you were not able to include, and/or information about bugs that are still known to exist.

1. Class Documentation: When writing a class in an object–oriented programming language, it should be preceded by a block comment minimally containing the following:
   1. The name of the class, your name, the names of any external packages upon which your class depends, the name of the package of classes containing this class (if any), and inheritance information.
   2. An explanation of purpose of the class.
   3. Names and very brief descriptions of the class and instance constants and variables.
   4. Names and very brief descriptions of constructors as well as the implemented class and instance methods.

• Internal Documentation: The details of the program are explained by comments placed within the code. The internal documentation should minimally include the following:
  1. A ‘block comment’ should be placed at the head of every method (a.k.a., function or subprogram). This will include the method name; the purpose of the method; the method’s pre– and post–conditions; the method’s return value (if any); and a list of all parameters, including direction of information transfer (into this method, out from the method back to the calling method, or both), and their purposes.
  2. Meaningful identifier names. In a nod to tradition, simple loop variables may have single letter variable names, but all others should be meaningful. Never use nonstandard abbreviations. If your language has accepted naming conventions, learn and follow them.
  3. Each variable and constant must have a brief comment next to its declaration that explains its purpose. This applies to all variables, as well as to fields of structure declarations.
  4. Complex sections of code and any other parts of the program that need some explanation should have comments just ahead of them or embedded in them.

1. Miscellaneous Requirements:
   1. Write programs with appropriate modularity; that is, create classes when appropriate, write methods that accomplish limited, well-defined tasks, etc.
   2. Global/public variables should never be used in your programs for my classes unless I have approved their use for your particular situation.
   3. Be generous with your use of “white space” (blank lines) to set off logically related sections of code.
   4. Indent bodies of methods, loops and IF statements, and do so with a single, consistent style.
   5. Like global variables, unconditional branching (e.g., goto) may not be used in your programs unless I have approved its use for your particular situation.

Part 8: Computer Programming Techniques and Methods

by Jesmin Akther | Jan 5, 2022 | Computer Programming Techniques

Programming Techniques

In this chapter, we will cover how to write a good program. But before we do that, let us see what the characteristics of a good program are:

• Portable− The program or software should run on all computers of same type. By same type we mean a software developed for personal computers should run on all PCs. Or a software for written for tablets should run on all tablets having the right specifications.
• Efficient− A software that does the assigned tasks quickly is said to be efficient. Code optimization and memory optimization are some of the ways of raising program efficiency.
• Effective− The software should assist in solving the problem at hand. A software that does that is said to be effective.
• Reliable− The program should give the same output every time the same set of inputs is given.
• User friendly− Program interface, clickable links and icons, etc. should be user friendly.
• Self-documenting− Any program or software whose identifier names, module names, etc. can describe itself due to use of explicit names.

Here are some ways in which good programs can be written.

Proper Identifier Names

A name that identifies any variable, object, function, class or method is called an identifier. Giving proper identifier names makes a program self-documenting. This means that name of the object will tell what it does or what information it stores. Let’s take an example of this SQL instruction:

Look at line 10. It tells anyone reading the program that a student’s ID, name and roll number are to be selected. The names of the variables make this self-explanatory. These are some tips to create proper identifier names −

• Use language guidelines
• Don’t shy from giving long names to maintain clarity
• Use uppercase and lowercase letters
• Don’t give same name to two identifiers even if the language allows it
• Don’t give same names to more than one identifier even if they have mutually exclusive scope

Comments

In the image above, look at line 8. It tells the reader that the next few lines of code will retrieve list of students whose report card is to be generated. This line is not part of the code but given only to make the program more user friendly.

Such an expression that is not compiled but written as a note or explanation for the programmer is called a comment. Look at the comments in the following program segment. Comments start with // and /* */.

Comments can be inserted as −

• Prologue to the program to explain its objective
• At the beginning and/or end of logical or functional blocks
• Make note about special scenarios or exceptions

You should avoid adding superfluous comments as that may prove counterproductive by breaking the flow of code while reading. Compiler may ignore comments and indentations but the reader tends to read each one of them.

Indentation

Distance of text from left or right margin is called indent. In programs, indentation is used to separate logically separated blocks of code. Here’s an example of indented program segment:

As you can see, indented program is more understandable. Flow of control from for loop to if and back to for is very clear. Indentation is especially useful in case of control structures.

With Indentation

Without Indentation

Inserting blank spaces or lines is also part of indentation. Here are some situations where you can and should use indentation −

• Blank lines between logical or functional blocks of code within the program
• Blank spaces around operators
• Tabs at the beginning of new control structures

Programming Methodologies

Identifying and removing errors from a program or software is called debugging. Debugging is ideally part of testing process but in reality it is done at every step of programming. Coders should debug the smallest of their modules before moving on. This decreases the number of errors thrown up during the testing phase and reduces testing time and effort significantly. Let us look at the types of errors that can crop up in a program.

Syntax Errors

Syntax errors are the grammatical errors in a program. Every language has its own set of rules, like creating identifiers, writing expressions, etc. for writing programs. When these rules are violated, the errors are called syntax errors. Many modern integrated development environments can identify the syntax errors as you type your program. Else, it will be shown when you compile the program. Let us take an example −

In this program, the variable a has not been declared, which is thrown up by the compiler.

Semantic Errors

Semantic errors are also called logical errors. The statement has no syntax errors, so it will compile and run correctly. However, it will not give the desired output as the logic is not correct. Let us take an example.

Look at line 8. Here programmer wants to check if the divisor is 0, to avoid division by 0. However, instead of using the comparing operator ==, assignment operator = has been used. Now every time the “if expression” will evaluate to true and program will give output as “You cannot divide by 0”. Definitely not what was intended!!

Logical errors cannot be detected by any program; they have to be identified by the programmer herself when the desired output is not achieved.

Runtime Errors

Runtime errors are errors that occur while executing the program. This implies that the program has no syntax errors. Some of the most common run time errors your program may encounter are −

• Infinite loop
• Division by ‘0’
• Wrong value entered by user (say, string instead of integer)

Code Optimization

Any method by which code is modified to improve its quality and efficiency is called code optimization. Code quality determines life span of code. If the code can be used and maintained for a long period of time, carried over from product to product, its quality is deemed to be high and it has a longer life. On the contrary, if a piece of code can be used and maintained only for short durations, say till a version is valid, it is deemed to be of low quality and has a short life.

Reliability and speed of a code determines code efficiency. Code efficiency is an important factor in ensuring high performance of a software.

There are two approaches to code optimization −

• Intuition based optimization (IBO)− Here the programmer tries to optimize the program based on her own skill and experience. This might work for small programs but fails miserably as complexity of the program grows.
• Evidence based optimization (EBO)− Here automated tools are used to find out performance bottlenecks and then relevant portions optimize accordingly. Every programming language has its own set of code optimization tools. For example, PMD, FindBug and Clover are used to optimize Java code.

Code is optimized for execution time and memory consumption because time is scarce and memory expensive. There has to be a balance between the two. If time optimization increases load on memory or memory optimization makes the code slower, purpose of optimization will be lost.

Execution Time Optimization

Optimizing code for execution time is necessary to provide fast service to the users. Here are some tips for execution time optimization −

• Use commands that have built-in execution time optimization
• Use switch instead of if condition
• Minimize function calls within loop structures
• Optimize the data structures used in the program

Memory Optimization

As you know, data and instructions consume memory. When we say data, it also refers to interim data that is the result of expressions. We also need to keep a track of how many instructions are making up the program or the module we are trying to optimize. Here are some tips for memory optimization −

• Use commands that have built-in memory optimization
• Keep the use of variables that need to be stored in registers minimum
• Avoid declaring global variables inside loops that are executed many times
• Avoid using CPU intensive functions like sqrt()

Part 7: Using Clear Instructions of Computer Programming Techniques

by Jesmin Akther | Jan 5, 2022 | Computer Programming Techniques

Using Clear Instructions

As you know, computer does not have intelligence of its own; it simply follows the instructions given by the user. Instructions are the building blocks of a computer program, and hence a software. Giving clear instructions is crucial to building a successful program. As a programmer or software developer, you should get into the habit of writing clear instructions. Here are two ways to do that.

Clarity of Expressions

Expression in a program is a sequence of operators and operands to do an arithmetic or logical computation. Here are some examples of valid expressions −

• Comparing two values
• Defining a variable, object or class
• Arithmetic calculations using one or more variables
• Retrieving data from database
• Updating values in database

Writing unambiguous expressions is a skill that must be developed by every programmer. Here are some points to be kept in mind while writing such expressions −

Unambiguous Result

Evaluation of the expression must give one clear cut result. For example, unary operators should be used with caution.

Avoid Complex Expressions

Do not try to achieve many things in a single expression. Break into two or more expressions the moment things start getting complicated.

Simplicity of Instructions

It’s not just for computers that you need to write clear instructions. Any one reading the program later (even you yourself!!) should be able to understand what the instruction is trying to achieve. It is very common for programmers not to get a hang of their own programs when they revisit it after some time has passed. This indicates that maintenance and modification of such programs would be quite difficult.

Writing simple instructions helps in avoiding this problem. Here are some tips to write simple instructions −

• Avoid clever instructions− Clever instructions might not look that clever later if no one is able to understand it properly.
• One instruction per task− Trying to do more than one thing at a time complicates instructions.
• Use standards− Every language has its standards, follow them. Remember you are not working alone on the project; follow project standards and guidelines for coding.

Part 6: Flowchart Elements of Computer Programming Techniques

by Jesmin Akther | Jan 5, 2022 | Computer Programming Techniques

Flowchart

Flowchart is a diagrammatic representation of sequence of logical steps of a program. Flowcharts use simple geometric shapes to depict processes and arrows to show relationships and process/data flow.

Flowchart Symbols

Here is a chart for some of the common symbols used in drawing flowcharts.

Symbol	Symbol Name	Purpose
	Start/Stop	Used at the beginning and end of the algorithm to show start and end of the program. The oval, or terminator, is used to represent the start and end of a process. Use the Gliffy flowchart tool to drag and drop one of these bad boys and you’ve got yourself the beginning of a flowchart. Remember to use the same symbol again to show that your flowchart is complete.
	Process	Indicates processes like mathematical operations. The rectangle is your go-to symbol once you’ve started flowcharting. It represents any step in the process you’re diagramming and is the workhorse of the flowchart diagram. Use rectangles to capture process steps like basic tasks or actions in your process.
	Input/ Output	Used for denoting program inputs and outputs.
	Decision	Stands for decision statements in a program, where answer is usually Yes or No. The diamond symbolizes that a decision is required to move forward. This could be a binary, this-or-that choice or a more complex decision with multiple choices. Make sure that you capture each possible choice within your diagram.
	Arrow	Shows relationships between different shapes. Indicate Directional Flow The arrow is used to guide the viewer along their flowcharting path. And while there are many different types of arrow tips to choose from, we recommend sticking with one or two for your entire flowchart. This keeps your diagram looking clean, but also allows you to emphasize certain steps in your process.
	On-page Connector	Connects two or more parts of a flowchart, which are on the same page.
	Off-page Connector	Connects two parts of a flowchart which are spread over different pages.

Guidelines for Developing Flowcharts

These are some points to keep in mind while developing a flowchart −

• Flowchart can have only one start and one stop symbol
• On-page connectors are referenced using numbers
• Off-page connectors are referenced using alphabets
• General flow of processes is top to bottom or left to right
• Arrows should not cross each other

Example Flowcharts

Here is the flowchart for going to the market to purchase a pen.

Here is a flowchart to calculate the average of two numbers.

Intermediate & Advanced Flowchart Symbols

As you know, flowcharts are made up of a sequence of actions, data, services, and/or materials. They illustrate where data is being input and output, where information is being stored, what decisions need to be made, and which people need to be involved. In addition the basic flowchart conventions, rules, and symbols, these intermediate flowchart symbols will help you describe your process with even more detail.

Document Symbols

Single and multiple document icons show that there are additional points of reference involved in your flowchart. You might use these to indicate items like “create an invoice” or “review testing paperwork.”

Data Symbols

Data symbols clarify where the data your flowchart references is being stored. (You probably won’t use the paper tape symbol, but it definitely came in handy back in the day.)

Input & Output Symbols

Input and output symbols show where and how data is coming in and out throughout your process.

Merging & Connecting Symbols

Agreed-upon merging and connector symbols make it easier to connect flowcharts that span multiple pages.

Additional Useful Flowchart Symbols

The above are a few additional symbols that prove your flowcharting prowess when put to good use.

Part 5: Writing the Algorithm of Computer Programming Techniques

by Jesmin Akther | Jan 5, 2022 | Computer Programming Techniques

Writing an Algorithm

A finite set of steps that must be followed to solve any problem is called an algorithm. Algorithm is generally developed before the actual coding is done. It is written using English like language so that it is easily understandable even by non-programmers.

Sometimes algorithms are written using pseudocodes, i.e. a language similar to the programming language to be used. Writing algorithm for solving a problem offers these advantages −

• Promotes effective communication between team members
• Enables analysis of problem at hand
• Acts as blueprint for coding
• Assists in debugging
• Becomes part of software documentation for future reference during maintenance phase

These are the characteristics of a good and correct algorithm −

• Has a set of inputs
• Steps are uniquely defined
• Has finite number of steps
• Produces desired output

Example Algorithms

Let us first take an example of a real-life situation for creating algorithm. Here is the algorithm for going to the market to purchase a pen.

Step 4 in this algorithm is in itself a complete task and separate algorithm can be written for it. Let us now create an algorithm to check whether a number is positive or negative.

Key Method for creating Algorithm

The educator guides   through expressing procedures as algorithms and then testing, comparing, and debugging algorithmic approaches.

Method Components

Decomposing problems

Before creating an algorithm,   need to first break down the problem or task want to express. Breaking down a problem or task into smaller parts or steps that are easier to understand is also known as decomposition. Think about a daily task or routine that you perform, such as cooking a meal. What smaller steps make up this task?

Decomposition is an important skill that cuts across grade levels and across content areas. For example, when working on a project or paper, it is helpful for   to decompose, or break down, the task down into smaller, more manageable chunks. Think about your classroom. What problems or tasks might behelpful for your   to decompose? At the elementary level, for instance,   could break down a daily routine, like getting ready for school, into smaller tasks or parts. Or in a middle school art class,   may decompose a painting or an image to analyze its component parts.

Expressing procedures as algorithms

We need to give it step-by-step instructions, or an algorithm, that clearly explain exactly how we want it to solve a problem. Think about an algorithm for cooking a meal, instance. What are the steps in this process? In what order do these steps need to be carried out? How might you communicate these steps to another human so that they could perform them? Algorithms can be expressed in a variety of ways including non-computer languages such as prose, flowcharts, pseudocode, or oral language.

There are several educational reasons for thinking about procedures as algorithms. For example, programming a computer to find the average of a list of numbers is an excellent way for   to develop an understanding of how to calculate averages.

Testing, comparing, and debugging algorithms

Once an algorithm has been designed, it is important to test the algorithm. Does the algorithm solve every aspect of the problem? Is it efficient? Is it easily understood by a peer or a computer? Testing and comparing algorithms will allows   to find and fix any errors, also known as debugging.

Suggested implementation

1. Before teaching the lesson, carefully read the submission instructions and consider what evidence you will need to gather for your submission.
2. Choose an open-ended problem which is important to your subject area and relevant to your .
3. Find a computational tool or a non-computational environment in which  can implement various solutions to the problem. For example,   can test their algorithms in a computational environment like Scratch or via an unplugged simulation in the classroom setting.
4. Plan a lesson in which  test, compare, and debug algorithms to solve the problem. Suggested outline:
   • Facilitate a brief discussion of possible approaches to decomposing the problem.
   • Introduce the tool the  will be using to test their algorithms and model the process they will be using.
   • Allow  to work in small groups to build and test algorithms on their own. As they work on this task, have   express their algorithms in a less formal medium, such as a list of verbal commands or a flowchart.
   • If appropriate, allow  to test and compare the performance of their algorithms against each other. If time allows, ask   to debug and iterate on their algorithms.
   • Ask  to share their algorithms, explain how they work, and evaluate their performance.

Part 4: Applying Modular Techniques of Computer Programming Techniques

by Jesmin Akther | Jan 5, 2022 | Computer Programming Techniques

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.

Step-by-Step Solution

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

Control Structures

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 −

if statement

An if statement consists of a Boolean expression followed by one or more statements.

Syntax

The syntax of an ‘if’ statement in C programming language is −

if(boolean_expression) {

/* statement(s) will execute if the boolean expression is true */

}

If the Boolean expression evaluates to true, then the block of code inside the ‘if’ statement will be executed. If the Boolean expression evaluates to false, then the first set of code after the end of the ‘if’ statement (after the closing curly brace) will be executed.

An if statement can be followed by an optional else statement, which executes when the Boolean expression is false.

Syntax

The syntax of an if…else statement in C programming language is −

if(boolean_expression) {

/* statement(s) will execute if the boolean expression is true */

} else {

/* statement(s) will execute if the boolean expression is false */

}

If the Boolean expression evaluates to true, then the if block will be executed, otherwise, the else block will be executed.

#include <stdio.h>
int main()
{
int age;
printf("Enter your age:");
scanf("%d",&age);
if(age >=18)
{
printf("You are eligible for voting");
}
else
{
printf("You are not eligible for voting");
}
return 0;
}

Output:

Enter your age:14

You are not eligible for voting

switch statement

A switch statement allows a variable to be tested for equality against a list of values. Each value is called a case, and the variable being switched on is checked for each switch case.

Syntax

The syntax for a switch statement in C programming language is as follows −

switch(expression) {

case constant-expression  :

statement(s);

break; /* optional */

case constant-expression  :

statement(s);

break; /* optional */

/* you can have any number of case statements */

default : /* Optional */

statement(s);

}

The following rules apply to a switch statement −

• The expressionused in a switch statement must have an integral or enumerated type, or be of a class type in which the class has a single conversion function to an integral or enumerated type.
• You can have any number of case statements within a switch. Each case is followed by the value to be compared to and a colon.
• The constant-expressionfor a case must be the same data type as the variable in the switch, and it must be a constant or a literal.
• When the variable being switched on is equal to a case, the statements following that case will execute until a breakstatement is reached.
• When a breakstatement is reached, the switch terminates, and the flow of control jumps to the next line following the switch statement.
• Not every case needs to contain a break. If no breakappears, the flow of control will fall through to subsequent cases until a break is reached.
• A switchstatement can have an optional default case, which must appear at the end of the switch. The default case can be used for performing a task when none of the cases is true. No break is needed in the default case.

#include <stdio.h>

int main() {

int num = 8;

switch (num) {

case 7:

printf("Num variable Value is 7");

break;

case 8:

printf("Num variable Value is 8");

break;

case 9:

printf("Num variable Value is 9");

break;

default:

printf("Out of range");

break;

}

return 0;

}

Output:

Num variable Value is 8

Another switch statement example using char datatype.

#include <stdio.h>

int main()

{

char ch='b';

switch (ch)

{

case 'd':

printf("Case is d ");

break;

case 'b':

printf("Case is b ");

break;

case 'c':

printf("Case is c ");

break;

default:

printf("Default ecase");

}

return 0;

}

Output:

Case is b

When the above code is compiled and executed, it produces the following result −

Well done

Your grade is B

It is possible to have a switch as a part of the statement sequence of an outer switch. Even if the case constants of the inner and outer switch contain common values, no conflicts will arise.

Part 3: Identifying the Solution of Computer Programming Techniques

by Jesmin Akther | Jan 5, 2022 | Computer Programming Techniques

Identifying the Solution

Often, coding is supposed to be the most essential part of any software development process. However, coding is just a part of the process and may actually take the minimum amount of time if the system is designed correctly. Before the system can be designed, a solution must be identified for the problem at hand.

The first thing to be noted about designing a system is that initially the system analyst may come up with more than one solutions. But the final solution or the product can be only one. In-depth analysis of data gathered during the requirement gathering phase can help in coming to a unique solution. Correctly defining the problem is also crucial for getting to the solution.

When faced with the problem of multiple solutions, analysts go for visual aids like flowcharts, data flow diagrams, entity relationship diagrams, etc. to understand each solution in depth.

Flowcharting

Flowcharting is the process of illustrating workflows and data flows in a system through symbols and diagrams. It is an important tool to assist the system analyst in identifying a solution to the problem. It depicts the components of the system visually.

These are the advantages of flowcharting −

• Visual representation helps in understanding program logic
• They act as blueprints for actual program coding
• Flowcharts are important for program documentation
• Flowcharts are an important aid during program maintenance

These are the disadvantages of flowcharting −

• Complex logic cannot be depicted using flowcharts
• In case of any change in logic or data/work flow, flowchart has to be redrawn completely

Data Flow Diagram

Data flow diagram or DFD is a graphical representation of data flow through a system or sub-system. Each process has its own data flow and there are levels of data flow diagrams. Level 0 shows the input and output data for the whole system. Then the system is broken down into modules and level 1 DFD shows data flow for each module separately. Modules may further be broken down into sub-modules if required and level 2 DFD drawn.

Physical and logical data flow diagrams

To determine whether a physical or logical DFD best suits your needs. Logical data flow diagrams focus on what happens in a particular information flow: what information is being transmitted, what entities are receiving that info, what general processes occur, etc. The processes described in a logical DFD are business activities a logical DFD doesn’t delve into the technical aspects of a process or system. Non-technical employees should be able to understand these diagrams.

Logical Data Flow Diagram

Physical data flow diagrams focus on how things happen in an information flow. These diagrams specify the software, hardware, files, and people involved in an information flow. A detailed physical data flow diagram can facilitate the development of the code needed to implement a data system.

Physical Data Flow Diagram

Both physical and logical data flow diagrams can describe the same information flow. In coordination they provide more detail than either diagram would independently. As you decide which to use, keep in mind that you may need both.

Data flow diagram levels

Data flow diagrams are also categorized by level. Starting with the most basic, level 0, DFDs get increasingly complex as the level increases. As you build your own data flow diagram, you will need to decide which level your diagram will be.

Level 0 DFDs, also known as context diagrams, are the most basic data flow diagrams. They provide a broad view that is easily digestible but offers little detail. Level 0 data flow diagrams show a single process node and its connections to external entities.

Data Flow Diagram Level 0 Template

Level 1 DFDs are still a general overview, but they go into more detail than a context diagram. In a level 1 data flow diagram, the single process node from the context diagram is broken down into sub-processes. As these processes are added, the diagram will need additional data flows and data stores to link them together.

Template of Data Flow Diagram Level 1

Level 2+ DFDs simply break processes down into more detailed subprocesses. In theory, DFDs could go beyond level 3, but they rarely do. Level 3 data flow diagrams are detailed enough that it doesn’t usually make sense to break them down further.

Data Flow Diagram Level 2 Template

Data flow diagram symbols and notation

Depending on the methodology (Gane and Sarson vs. Yourdon and Coad), DFD symbols vary slightly. However, the basic ideas remain the same. There are four basic elements of a data flow diagram: processes, data stores, external entities, and data flows. The picture below shows the standard shapes for both methodologies.

Pseudocode

After the system is designed, it is handed over to the project manager for implementation, i.e. coding. The actual coding of a program is done in a programming language, which can be understood only by programmers who are trained in that language. However, before the actual coding occurs, the basic operating principles, work flows and data flows of the program are written using a notation similar to the programming language to be used. Such a notation is called pseudocode.

Here is an example of a pseudocode in C++. The programmer just needs to translate each statement into C++ syntax to get the program code.

Identifying Mathematical Operations

All instructions to the computer are finally implemented as arithmetic and logical operations at machine level. These operations are important because they −

• Occupy memory space
• Take time in execution
• Determine software efficiency
• Affect overall software performance

System analysts try to identify all major mathematical operations while identifying the unique solution to problem at hand.

Part 2: Understanding the Problem of Computer Programming Techniques

by Jesmin Akther | Jan 5, 2022 | Computer Programming Techniques

Understanding the Problem

It is very obvious that before finding the solution we should understand the problem well. Moreover, if we fail to understand the problem we may end up with a useless solution for it. Hence, a wrong solution will not solve our purpose of problem-solving. Therefore, we need to read the problem carefully and decide the different functions which the solution will contain.

Moreover, we need to understand that what is the required output and how we can generate it. Besides, for proper output, we surely need an input. The input can be single or multiple as per the problem. Hence, it is quite important to maintain the necessary relationship between the input and the output.

Important points in Understanding the Problem

Some of the important points that we should keep in mind while understanding the problem are as follows:

• Read the problem very carefully.
• Identify the functions that the solution (algorithm) should have.
• Identify the required output.
• Find a way to produce the required output.
• Draw a proper relationship between the input and output.
• Take all the necessary number of inputs.
• Avoid unnecessary inputs.
• Identify the correct number of the required input.

Further steps in problem-solving

After understanding the problem, the further steps are as follows:

Designing an algorithm

After understanding the relationship between input and output and the functionalities required we have to design an algorithm. Furthermore, the algorithm should contain all the necessary functions to solve the problem. Moreover, it should produce a proper output for every input.

Implementing the algorithm

After designing the algorithm we should implement and design a program to solve the problem. We can develop the program using any programming language.

Evaluation

After developing the program we should run and test if it produces the correct output.

A typical software development process follows these steps −

• Requirement gathering
• Problem definition
• System design
• Implementation
• Testing
• Documentation
• Training and support
• Maintenance

The first two steps assist the team in understanding the problem, the most crucial first step towards getting a solution. Person responsible for gathering requirement, defining the problem and designing the system is called system analyst.

Requirement Gathering

Usually, clients or users are not able to clearly define their problems or requirements. They have a vague idea of what they want. So system developers need to gather client requirements to understand the problem that needs to be resolved, or what needs to be delivered. Detailed understanding of the problem is possible only by first understanding the business area for which the solution is being developed. Some key questions that help in understanding a business include −

• What is being done?
• How is it being done?
• What is the frequency of a task?
• What is the volume of decisions or transactions?
• What are the problems being encountered?

Some techniques that help in gathering this information are −

• Interviews
• Questionnaires
• Studying existing system documents
• Analyzing business data

System analysts needs to create clear and concise but thorough requirements document in order to identify SMART – specific, measurable, agreed upon, realistic and time-based – requirements. A failure to do so results in −

• Incomplete problem definition
• Incorrect program goals
• Re-work to deliver required outcome to client
• Increased costs
• Delayed delivery

Due to the depth of information required, requirement gathering is also known as detailed investigation.

Problem Definition

After gathering requirements and analyzing them, problem statement must be stated clearly. Problem definition should unambiguously state what problem or problems need to be solved. Having a clear problem statement is necessary to −

• Define project scope
• Keep the team focused
• Keep the project on track
• Validate that desired outcome was achieved at the end of project

System Design

The design stage is a necessary precursor to the main developer stage. Developers will first outline the details for the overall application, alongside specific aspects, such as its:

• User interfaces
• System interfaces
• Network and network requirements
• Databases

Implementation

The overall design for the software will come together. Different modules or designs will be integrated into the primary source code through developer efforts, usually by leveraging training environments to detect further errors or defects. The information system will be integrated into its environment and eventually installed. After passing this stage, the software is theoretically ready for market and may be provided to any end-users.

Testing

Building software is not the end. Now it must be tested to make sure that there aren’t any bugs and that the end-user experience will not negatively be affected at any point. During the testing stage, developers will go over their software with a fine-tooth comb, noting any bugs or defects that need to be tracked, fixed, and later retested. It’s important that the software overall ends up meeting the quality standards that were previously defined in the SRS document.

Documentation

Software documentation is written text or an illustration that comes with or is integrated in the source code of a computer program. The documentation explains how the software works or how to use it, and it might mean different things to different people depending on their jobs. Software engineering necessitates the use of documentation. The following are examples of several types of documentation:

Statements that specify a system’s properties, capabilities, characteristics, or qualities are referred to as requirements. This is the foundation for what will be implemented, or what has already been implemented.

Software Architecture/Design: A high-level overview of the software. Includes relationships to the environment as well as design principles for software components.

Technical: Code, algorithms, interfaces, and APIs documentation.

End-user: End-user, system administrator, and support staff manuals.

Marketing: How to sell the product and a review of the competition

Training and support

Every software project’s ultimate goal is to deliver a solution that meets the original specifications. The SDLC (Software Development Life Cycle) is a critical method for achieving that goal. Software development and software engineering training  will equip your team with skills that span the whole Software Development Life Cycle, including requirements documentation, testing, and UX design. Your team may learn to manage and deliver software projects on time and within budget with a comprehensive curriculum of courses for those in design, technical, project management, and architectural roles.

Maintenance

The process of upgrading, modifying, and updating software to stay up with client needs is known as software maintenance. After a product has been released, software maintenance is performed for a variety of purposes, including improving the software overall, addressing faults or bugs, increasing performance, and more.
Software developers don’t have the luxury of releasing a product and then leaving it alone; they must constantly correct and enhance their code in order to be competitive and relevant.
The appropriate software maintenance procedures and tactics are essential for keeping any software running for a long time and keeping customers and users satisfied.

The four types of software maintenance are carried out for a variety of causes and purposes. Throughout its lifetime, a piece of software may require one, two, or all sorts of maintenance.
The four types are as follows:

1. Corrective Software Maintenance (CSM) is the most common and traditional type of software maintenance.

Due to bug reports sent in by users, software suppliers are frequently able to address issues that require corrective maintenance. If a company can detect and correct flaws before users notice them, this is an added benefit that will make your organization appear more credible and trustworthy.

2. Preventative Software Maintenance: Preventative program maintenance is planning ahead of time to ensure that your software continues to function as intended for as long as possible.

3.  Adaptive Software Maintenance
Adaptive software maintenance has to do with the changing technologies as well as policies and rules regarding your software. These include operating system changes, cloud storage, hardware, etc.

4. Perfective Software Maintenance
This is when perfective software maintenance comes into play. Perfective software maintenance aims to adjust software by adding new features as necessary and removing features that are irrelevant or not effective in the given software.

Part 1: Introduction to Programming Methodologies

by Jesmin Akther | Jan 5, 2022 | Computer Programming Techniques

Programming Methodologies

When programs are developed to solve real-life problems like inventory management, payroll processing, student admissions, examination result processing, etc. they tend to be huge and complex. The approach to analyzing such complex problems, planning for software development and controlling the development process is called programming methodology.

Types of Programming Methodologies

There are many types of programming methodologies prevalent among software developers −

Procedural Programming

Problem is broken down into procedures, or blocks of code that perform one task each. All procedures taken together form the whole program. It is suitable only for small programs that have low level of complexity.

Procedural programming is widely used in large-scale projects, when the following benefits are important:

1. re-usability of pieces code designed as procedures
2.  ease of following the logic of program;
3.  Maintainability of code.
4.  Emphasis is on doing things (algorithms).
5.  Most of the functions share global data.
6.  Data move openly around the system from function to function.
7.  Functions transform data from one form to another.Procedural programming is a sub-paradigm of imperative programming, since each step of computation is described explicitly, even if by the means of defining procedures.

Example − For a calculator program that does addition, subtraction, multiplication, division, square root and comparison, each of these operations can be developed as separate procedures. In the main program each procedure would be invoked on the basis of user’s choice.

Object-oriented Programming

Here the solution revolves around entities or objects that are part of problem. The solution deals with how to store data related to the entities, how the entities behave and how they interact with each other to give a cohesive solution.

Some of the features of object oriented programming are:
• Emphasis is on data rather than procedure.
• Programs are divided into what are known as objects.
• Data structures are designed such that they characterize the objects.
• Functions that operate on the data of an object are ties together in the data
structure.
• Data is hidden and cannot be accessed by external function.
• Objects may communicate with each other through function.
• New data and functions can be easily added whenever necessary.
• Follows bottom up approach in program design.

Example − If we have to develop a payroll management system, we will have entities like employees, salary structure, leave rules, etc. around which the solution must be built.

Functional Programming

Here the problem, or the desired solution, is broken down into functional units. Each unit performs its own task and is self-sufficient. These units are then stitched together to form the complete solution.

Example − A payroll processing can have functional units like employee data maintenance, basic salary calculation, gross salary calculation, leave processing, loan repayment processing, etc.

Logical Programming

Here the problem is broken down into logical units rather than functional units. Example: In a school management system, users have very defined roles like class teacher, subject teacher, lab assistant, coordinator, academic in-charge, etc. So the software can be divided into units depending on user roles. Each user can have different interface, permissions, etc.

Algorithm Approaches

Software developers may choose one or a combination of more than one of these methodologies to develop a software. Note that in each of the methodologies discussed, problem has to be broken down into smaller units. To do this, developers use any of the following two approaches −

• Top-down approach
• Bottom-up approach

Top-down or Modular Approach

The problem is broken down into smaller units, which may be further broken down into even smaller units. Each unit is called a module. Each module is a self-sufficient unit that has everything necessary to perform its task.

The following illustration shows an example of how you can follow modular approach to create different modules while developing a payroll processing program.

Bottom-up Approach

In bottom-up approach, system design starts with the lowest level of components, which are then interconnected to get higher level components. This process continues till a hierarchy of all system components is generated. However, in real-life scenario it is very difficult to know all lowest level components at the outset. So bottoms up approach is used only for very simple problems.

Let us look at the components of a calculator program.

Programming methodology deals with the analysis, design and implementation of programs.

 Algorithm

Algorithm is a step-by-step finite sequence of instruction, to solve a well-defined computational problem. That is, in practice to solve any complex real life problems;

First, we have to define the problems.

Second, step is to design the algorithm to solve that problem.

Writing and executing programs and then optimizing them may be effective for small programs. Optimization of a program is directly concerned with algorithm design. But for a large program, each part of the program must be well organized before writing the program. There are few steps of refinement involved when a problem is converted to program; this method is called stepwise refinement method. There are two approaches for algorithm design; they are top-down and bottom-up algorithm design.

 Stepwise Refinement Techniques

We can write an informal algorithm, if we have an appropriate mathematical model for a problem. The initial version of the algorithm will contain general statements, i.e., informal instructions. Then we convert this informal algorithm to formal algorithm, that is, more definite instructions by applying any programming language syntax and semantics partially. Finally a program can be developed by converting the formal algorithm by a programming language manual. From the above discussion we have understood that there are several steps to reach a program from a mathematical model. In every step there is a refinement (or conversion). That is to convert an informal algorithm to a program, we must go through several stages of formalization until we arrive at a program — whose meaning is formally defined by a programming language manual — is called stepwise refinement techniques.

There are three steps in refinement process, which is illustrated in following Figure

1. In the first stage, modeling, we try to represent the problem using an appropriate mathematical model such as a graph, tree etc. At this stage, the solution to the problem is an algorithm expressed very informally.
2. At the next stage, the algorithm is written in pseudo-language (or formal algorithm) that is, a mixture of any programming language constructs and less formal English statements. The operations to be performed on the various types of data become fixed.
3. In the final stage we choose an implementation for each abstract data type and write the procedures for the various operations on that type. The remaining informal statements in the pseudo-language algorithm are replaced by (or any programming language) C/C++ code.