Introduction to Software 59

c
h
a
p
t

Introduction to Software e
r 4

LEARNING
OBJECTIVES
After studying this chapter, the readers will be able to

∑ identify system programs and application programs ∑ briefly discuss compiler, interpreter, linker, and loader
∑ discuss basic concepts of high- and low-level languages functions
∑ explain the software development steps

4.1 INTRODUCTION are program files to be used in conjunction with the main

executable file and additional data files and configuration
The basic concepts of software have already been introduced
files. Consequently, the installation of software is not just
in Chapter 1. As discussed earlier, there are different catego-
copying the files in the hard disk. It is typically dependent on
ries of software. Among them, system software controls the
the operating system on which it would execute and whether
activities of computer resources (such as input/output devic-
the software is a local, Web, or portable application. For local
es, memory, processor), schedule the execution of multiple
application software, its files are placed in the appropriate
tasks, whereas application software is designed and devel-
locations on the computer’s hard disk and may require
oped for a specific or generic type of use which is sold in the
additional configurations with the underlying operating
market or for a user or an organization. The term ‘application’
system so that it can be run as and when required. Portable
refers to the specific usage such as creating documents, draw-
software is basically designed to run from removable storage,
ing images, playing video games, etc., which is accomplished
such as a CD or USB flash drive without installing its program
by a computer system.
files or configuration data on the hard disk. Most interesting
Nowadays, software is typically composed of several files
fact is that no trace is found when the removable storage
among which at least one must be an executable file intended
media containing the portable software is removed from
to be executed by users or automatically launched by the
the computer. On the other hand, web application software
operating system. Apart from this main executable file, there
is accessed through a Web browser and most of its program
 60 Computer Fundamentals and Programming in C
code runs on a remote computer connected to the Internet or
other computer network.
4.2  PROGRAMMING LANGUAGES
A programming language can be defined formally as an
artificial formalism in which algorithms can be expressed. It is
composed of a set of instructions in a language understandable
to the programmer and recognizable by a computer. Computer
languages have been continuing to grow and evolve since the
1940’s. Assembly language was the normal choice for writing
system software like operating systems, etc. But, C has
been used to develop system software since its emergence.
The UNIX operating system and its descendants are mostly
written in C. Application programs are designed for specific
computer applications. Most programming languages are
designed to be good for one category of applications but not
necessarily for the other. For an instance, COBOL is more
suitable for business applications whereas FORTRAN is
more suitable for scientific applications.
The development of programming languages has been
governed by a number of factors such as type and performance
of available hardware, applications of computers in different
fields, the development of new programming methodologies
and its implementation etc.
4.2.1 Generation of Programming Languages
Just as hardware is classified into generations based on tech-
nology, computer languages also have a generation classifi-
cation based on the level of interaction with the machine.
First generation language (1GL)—machine
language
The instructions in machine language are written in the
form of binary codes that can immediately be executed by
the processor. A machine language instruction generally has
three parts as shown in Fig. 4.1. The first part is the operation
code that conveys to the computer what function has to be
performed by the instruction. All computers have operation
codes for functions such as adding, subtracting and moving.
The second part “Mode” specifies the type of addressing
used by the instruction to obtain the operand referred by the
instruction. The third part of the instruction either specifies
that the operand contains data on which the operation has to be
performed or it specifies that the operand contains a location,
the contents of which have to be subjected to the operation.
n-bits
p-bits q-bits r-bits
Operation code Mode Operand
n=p+q+r
Fig. 4.1 General format of machine language instruction
Machine language is considered to be the first generation
language (1GL). As it is the native language of the computer,
CPU can directly start executing machine language
instructions. But the limitations of using machine language
in writing programs include the following.
Difficult to use and error prone  It is difficult to understand
and develop a program using machine language. Because it is
hard to understand and remember the various combinations of
1’s and 0’s representing data and instructions. The programmer
has to remember machine characteristics while preparing a
program. Checking machine instructions to locate errors are
about as tedious as writing the instructions. For anybody
checking such a program, it would be difficult to forecast the
output when it is executed. Nevertheless, computer hardware
recognizes only this type of instruction code. Further,
modifying such a program is highly problematic.
Machine independent  As the internal design of the
computer is different across types, which in turn is determined
by the actual design or construction of the ALU, CU, and
size of the word of the memory unit, the machine language
also varies from one type of computer to another. Hence,
it is important to note that after becoming proficient in the
machine code of a particular computer, the programmer may
be required to learn a new machine code and would have to
write all the existing programs again in case the computer
system is changed.
Second generation language (2GL)—assembly
language
Assembly language is considered to be a second generation
language (2GL). In this language, an instruction is expressed
using mnemonic codes instead of binary codes. Normally an
assembly language statement consists of a label, an operation
code, and one or more operands. Labels are used to identify
and reference instructions in the program. The operation code
is a symbolic notation that specifies the particular operation to
be performed, such as MOV, ADD, SUB, or CMP etc. The operand
represents the register or the location in main memory where
the data to be processed is located. For example, a typical
statement in assembler to command the processor to move
the hexadecimal number 0x80 into processor register R2
might be:
MOV R2, 080H
The following is an example of an assembly language
program for adding two numbers A and B and storing the
result in some memory location.
Load register A with content of
LDA, 2000h;
memory address 2000h
MOV B, 10h; Load register B with 10th.
ADD A, B Add contents of A with contents of
B and store result in register A

MOV (100), A Save the result in the main memory
location 100 from register A.
HALT Halt process
An assembly language program cannot be executed by a
machine directly as it is not in a binary machine language
form. An assembler is a translator that produces machine
language code from an assembly language code. It produces
a single machine language instruction from a single assembly
language statement. Therefore, the coding to solve a problem
in assembly language has to be exercised at individual
instruction level. That’s why, along with machine language,
assembly language is also referred to as a low level language.
Writing a program in assembly language is more convenient
than writing in machine language. Instead of binary sequence,
as in machine language, a program in assembly language is
written in the form of symbolic instructions. This gives the
assembly language program improved readability. It also
offers several disadvantages.
• The most eminent disadvantage of assembly language
is that it is machine dependent. Assembly language is
specific to the internal architecture of a particular model of
a processor and the programmer should know all about the
internal architecture of the processor. A program written
in assembly language for one processor will not work on a
different processor if it is architecturally different.
• Though mnemonic codes are easier to be remembered than
binary codes, programming with assembly language is still
difficult and time-consuming.
Third generation language (3GL)—high-level
language
High-level languages are called third generation languages
(3GLs). High-level programming languages were developed
to make programming easier and less error-prone. Languages
like C, C++, COBOL, FORTRAN, BASIC, PASCAL etc.,
have instructions that are similar to English language that
makes it easy for a programmer to write programs and
identify and correct errors in them. The program shown
below is written in BASIC to obtain the sum of two numbers.
10 LET X = 7
20 LET Y = 10
30 SUM = X + Y
40 PRINT SUM
50 END
Most third generation languages are procedural in nature.
That is, the programmer must specify the sequential logically
related steps to be followed by the computer in a program.
As computer only understands machine language, a program
written in a high level language must be translated into
the basic machine language instruction set before it can be
Introduction to Software 61
executed. This can be performed either by a compiler, or
by interpreter. One statement in a high-level programming
language will be translated into several machine language
instructions.
Advantages of high-level programming languages are
many fold which are as follows.
Readability Programs written in these languages are
more readable than those written in assembly and machine
languages.
Portability High-level programming languages can be run
on different machines with little or no change. It is, therefore,
possible to exchange software, leading to creation of program
libraries.
Easy debugging Errors can be easily detected and removed.
Ease in the development of software  Since the instructions
or statements of these programming languages are closer to
the English language, software can be developed with ease.
The time and cost of creating machine and assembly language
programs were quite high. This motivated the development
of high-level languages.
Fourth generation languages (4GL)
The Fourth Generation Language (4GL) is a non-procedural
language that allows the user to simply specify what is
wanted without describing the steps that the computer has to
follow to produce the result. This class of languages requires
significantly fewer instructions to accomplish a particular task
than does a third generation language. Thus, a programmer
should be able to write a program faster in 4GL than in a third
generation language.
The main areas and purviews of 4GLs are: database
queries, report generators, data manipulation, analysis and
reporting, screen painters, etc. An example of a 4GL is the
query language that allows a user to request information from
a database with precisely worded English-like sentences.
A query language is used as a database user interface and
hides the specific details of the database from the user.
The following example shows a query in a common query
language, SQL.
SELECT address FROM EMP WHERE empname = ‘PRADIP DEY’
With a report generator, the programmer specifies the
headings, detailed data, and other details to produce the
required report using data from a file. 4GLs offer several
advantages which include the following.
• Like third generation languages, fourth generation lan-
guages are mostly machine independent. They are primar-
ily used mainly for developing business applications.
• Most of the fourth generation languages can be easily
learnt and employed by end-users.
 62 Computer Fundamentals and Programming in C
• All 4GLs are designed to reduce programming effort, the
time it takes to develop software, and the cost of software
development. Programming productivity is increased when
4GL is used in coding.
Fifth generation language (5GL)
Natural languages represent the next step in the development
of programming languages belonging to Fifth Generation
Language (5GL). Natural language is similar to query
language, with one difference: it eliminates the need for the
user or programmer to learn a specific vocabulary, grammar,
or syntax.
Actually, 5GL is a programming language based around
solving problems using constraints given to the program,
rather than using an algorithm written by a programmer. Fifth
generation languages are used mainly in artificial intelligence
research. OPSS and Mercury are examples of fifth generation
languages.
note
∑ A low-level computer programming language is one
that is closer to the native language of the computer.
Machine and assembly languages are referred to as low-
level languages since the coding for a problem is at the
individual instruction level.
∑ Program written in languages other than machine lan-
guage is required to be translated into machine code.
4.2.2 Classification of Programming Languages
Programming languages can be classified in various ways.
According to the extent of translation that is required to gen-
erate the machine instructions from a program, programming
languages can be classified into low-level or high-level lan-
Programming language
High-level language
Procedural Non-procedural
Algorithmic Functional
(COBOL, (LISP, ML)
FORTRAN, C)
Object Logic based
oriented (PROLOG)
(C++, JAVA,
SMALLTALK)
Scripting
(VB, PERL)
Fig. 4.2  Programming language classification
guages. Both assembly language and machine language are
considered as low-level languages. Low-level languages are
closer to the native language of the computer as program
written in machine language does not require translation for
a processor to execute them. Assembly language is also con-
sidered as a low-level language since each assembly language
instruction accomplishes only a single operation and the cod-
ing for a problem is at the individual instruction level. On
the other hand, high-level programming languages provide a
high level of abstraction from the actual machine hardware.
High-level languages can further be characterized is by
programming paradigm (Fig. 4.2). A programming paradigm
refers to the way of problem solving that includes a set of
methodologies, theories, practices and standards. The high-
level programming languages may also be categorized into
three groups—procedural, non-procedural, and problem
oriented.
Procedural programming languages
In procedural programming, a program is conceived as
a set of logically related instructions to be executed in
order. In procedural programming, each program can be
divided into small self-contained program segment, each
of which performs a particular task and be re-used in the
program as and when required without repeated explicit
coding corresponding to the segment. These sections of
code are known as procedures or subroutines or functions.
It also makes it easier for programmers to understand and
maintain program structure. There are mainly three classes of
procedural programming languages.
Algorithmic  Using this type of programming languages,
the programmer must specify the steps the computer has
to follow while executing a program. In these languages,
a complex problem is solved using top-down approach
Low-level language
Problem- Machine Assembly
oriented language language
Numerical
(MATLAB)
Symbolic
(MATHEMATICA)
Publishing
(LATEX)

of problem solving in which the problem is divided into
a collection of small problems and each small problem
is realized in terms of subprogram. Each subprogram is
implemented using procedure or function. Languages like C,
COBOL, PASCAL and FORTRAN fall into this category.
Object-oriented language  The basic philosophy of ob-
ject-oriented programming is to deal with objects rather than
functions or subroutines as in strictly algorithmic languages.
Instead of procedures, object-oriented programming relies on
software objects as the units of modularity. Data and associ-
ated operations are unified grouping objects with common
properties, operations and semantics. The use of an object
oriented programming language, advocates the reuse of not
only code but also of entire design leading to creation of ap-
plication framework. A program thus becomes a collection
of cooperating objects, rather than a list of instructions. Ob-
jects are self-contained modules that contain data as well as
the functions needed to manipulate the data within the same
module. The most important object-oriented programming
features are
Abstraction  Abstraction is a technique of focussing on the
essential and relevant details from a complex problem which
are of interest to the application. It helps to simplify the un-
derstanding and using of any system. With data abstraction,
data structures can be used without having to be concerned
about the exact details of implementation. Object-oriented
programming languages use classes and objects for repre-
senting abstractions. A class defines the specific structure of
a given abstraction. It has a unique name that conveys the
meaning of the abstraction. Class definition provides a soft-
ware design which describes the general properties of some-
thing that the software is modeling. Object is an instance of
class. An object’s properties are exactly those described by
its class.
Encapsulation and data hiding  The process, or mecha-
nism, by which the data and functions or methods for ma-
nipulating data into a single unit, is commonly referred to as
encapsulation.
Inheritance  Inheritance allows the extension and reuse of
existing code, without having to repeat or rewrite the code
from scratch. Inheritance involves the creation of new class-
es, also called derived classes, from existing classes (base
classes). Object oriented languages are usually accompanied
by a large and comprehensive library of classes. Members of
these classes can either be used directly or reused by employ-
ing inheritance in designing new classes.
Polymorphism  The purpose of polymorphism is to let one
name be used to specify a general class of action. An op-
eration may exhibit different behaviors in different instances.
Introduction to Software 63
The behaviour depends upon the types of data used in the
operation. Polymorphism is a term that describes a situation
where one name may refer to different methods. This means
that a general kind of operations may be accessed in the same
manner even though specific actions associated with each op-
eration may differ.
Reusable code  Object oriented programming languages
enable programmer to make parts of program reusable and
extensible by breaking down a program into reusable objects.
These objects can then be grouped together in different ways
to form new programs. By reusing code it is much easier to
write new programs by assembling existing pieces.
Using the above features, object-oriented programming
languages facilitate to produce reliable and reusable software
in reduced cost and time. C++, JAVA, SMALLTALK, etc. are
examples of object-oriented languages.
Scripting languages  Few years back, the scripting languag-
es were not considered as the languages, but rather thought of
as auxiliary tool. A scripting language may be thought of as a
glue language, which sticks a variety of components written
in other languages together. These languages are usually in-
terpreted. One of the earliest scripting languages is the UNIX
shell. Now there are several scripting languages such as VB-
script, Python, Tcl and Perl etc. Javascript language also be-
longs to this category and defacto standard for the implemen-
tation of client-side Web application.
Non-procedural languages
These functional languages solve a problem by applying a
set of functions to the initial variables in specific ways to
get the result. A program written in a functional language
consists of a series of built-in function evaluation together
with arguments to those functions. LISP, ML, Scheme, etc.
are examples of functional languages.
Another non-procedural class of languages is called rule
based languages or logic programming languages. A logic
program is expressed as a set of atomic sentences, known
as facts, and horn clauses, such as if-then rules. A query is
then posed. Then the execution of the program begins and
the system tries to find out if the answer to the query is true
or false for the given facts and rules. Such languages include
PROLOG.
Problem-oriented languages
These languages provide readymade procedures or functions
which are pre-programmed. The user has to write the
statements in terms of those pre-written functions. MATLAB
is a very popular language among scientists and engineers to
solve a wide class of problems in digital signal processing,
control systems, modelling of systems described by
differential equations, matrix computations, etc.
 64 Computer Fundamentals and Programming in C
Another class of problem oriented languages is for
symbolic language manipulation. For example, simplifying
a complex algebraic expression or getting the indefinite
integral of a complex expression. MATHEMATICA is a
popular language of this type.
In the Internet era, a new category of languages has
emerged, the markup languages. Mark-up languages are
not programming languages. For instance, HTML, the
most widely used mark-up language, is used to specify the
layout of information in Web documents. However, some
programming capability has crept into some extensions to
HTML and XML. Among these are the Java Server Pages,
Standard Tag Library (JSTL), and eXtensible Stylesheet
Language Transformations (XSLT).
4.3 COMPILING, LINKING, AND LOADING
A PROGRAM
A program, written in source language, is translated by the
compiler to produce a program in a target language. The
source language is usually a high-level language. The target
language may or not necessarily be machine language. In most
cases, the target language is assembly language, and in which
case, the target program must be translated by an assembler
into an object program. Then the object program is linked with
other object programs to build an executable program, which
is normally saved in a specified location of the secondary
memory. When it is needed to be executed, the executable
file is loaded into main memory before its execution. The
whole process is managed, coordinated and controlled by the
underlying operating system. Sometimes the target language
may be a language other than machine or assembly language,
in which case a translator for that language must be used to
obtain an executable object program.
Conceptually, the compilation process can be divided into
a number of phases, each of which is handled by different
modules of a compiler, as shown in Fig. 4.3.
Lexical analysis  In this phase, the source program is
scanned for lexical units (known as tokens) namely, identifier,
operator delimiter, etc. and classify them according to their
types. A table, called symbol table, is constructed to record
the type and attributes information of each user-defined name
used in the program. This table is accessed in the other phases
of compilation.
Syntax analysis  In this phase, tokens are conflated into
syntactic units such as expressions, statements, etc. that must
conform to the syntax rules of the programming language.
This process is known as parsing. Syntax is similar to the
grammar of a language. Syntax rules specify the way in which
valid syntactic elements are combined to form the statements
of the language. Syntax rules are often described using a
notation known as BNF (Backus Naur Form) grammar.
Source Lexical Syntactic Semantic
program analysis analysis analysis
Library code
Intermediate
object code
from other code
compilations generation
Executable
program Linker
Object
program
Code
generation
Fig. 4.3  The process of compilation
As a result of parsing, a data structure, known as parse
tree, is produced.
Semantic analysis The semantics of a statement in a
programming language define what will happen when that
statement is executed. Semantic rules assign meanings to
valid statements of the language. In the semantic analysis
phase, the parsed statements are analysed further to make
sure that the operators and operands do not violate source
language specification.
Intermediate code generation and optimization To
make the target program a bit smaller or faster or both,
many compilers produce an intermediate form of code
for optimization. In most cases, the intermediate code is
generated in assembly language or in a different language at
a level between assembly language and machine language.
Code generation  This is the final phase of a standard
compilation which converts every statement of the optimized
intermediate code into target code using predefined target
language template. The target language template depends on
the machine instructions of the processor, addressing modes
and number of registers, etc.
If a system library containing pre-written subroutines
or functions and/or separately compiled user-defined
subroutines are used in a program a final linking and loading
step is needed to produce the complete machine language
program in an executable form.

note
Conceptually, the compilation process can be divided into a
number of phases
∑ In the first phase of compilation, termed as lexical
analysis, each statement of a program is analyzed and
broken into individual lexical units termed tokens and
constructs a symbol table for each identifier.
∑ The second stage of translation is called syntax analysis;
tokens are combined into syntactic units according to the
syntax or grammar of the source language.
∑ In the third stage of compilation, the parsed statements
are analysed further to make sure that the operators and
operands do not violate source language specifications.
∑ Next, an intermediate representation of the final machine
language code is produced. Optionally, the intermediate
code is optimized to produce an optimized code.
∑ The last phase of translation is code generation whereby
the optimized intermediate code is converted into target
code.
4.4  TRANSLATOR, LOADER, AND LINKER
REVISITED
4.4.1  Translators
There are three types of translators, namely Assembler,
Compiler and Interpreter. Assembler converts one assembly
language statement into a single machine language instruction.
. Depending on its implementation, a high-level language
employs a compiler or an interpreter or both for translation.
One statement in a high-level programming language will
be translated into several machine language instructions.
Both compiler and interpreter translate a program written in
high-level language into machine language but in different
fashion. Compiler translates the entire source program into
object program at once and then the object files are linked
to produce a single executable file. Unlike compiler, an
interpreter translates one line of source code at a time—then
executes it—before translating the next one and it does this
every time the program executes. BASIC is a language that is
usually implemented with an interpreter. Translation using an
interpreter is slower than that using a compiler. The interpreter
translates each line of source code to machine code each
time the program is executed. With respect to debugging, an
interpreted language is better than the compiled language. In
an interpreter, syntax error is brought to the attention of the
programmer immediately so that the programmer can make
necessary corrections during program development. The Java
language uses both a compiler and an interpreter.
Introduction to Software 65
4.4.2  Linker
Most of the high-level languages provide libraries of
subroutines or functions so that certain common operations
may be reused by system-supplied routines without explicit
coding. Hence, the machine language program produced by
the translator must normally be combined with other machine
language programs residing within the library to form a
useful execution unit. This process of program combination
is called linking and the software that performs this operation
is variously known as a linker. The features of a programming
language influence the linking requirements of a program. In
languages like FORTRAN, COBOL, C, all program units
are translated separately. Hence, all subprogram calls and
common variable references require linking. Linking makes
the addresses of programs known to each other so that transfer
of control from one subprogram to another or a main program
takes place during execution.
4.4.3  Loader
Loading is the process of bringing a program from secondary
memory into main memory so it can run. The system soft-
ware responsible for it is known as loader. The simplest type
of loader is absolute loader which places the program into
memory at the location prescribed by the assembler. Boot-
strap loader is an absolute loader which is executed when
computer is switched on or restarted to load the operating
system.
In most of the cases, when a compiler translates a source
code program into object code, it has no idea where the code
will be placed in main memory at the time of its execution.
In fact, each time it is executed, it would likely be assigned
a different area of main memory depending on the avail-
ability of primary storage area at the time of loading. That
is why, compilers create a special type of object code which
can be loaded into any location of the main memory. When
the program is loaded into memory to run, all the addresses
and references are adjusted to reflect the actual location of
the program in memory. This address adjustment is known
as relocation. Relocation is performed before or during the
loading of the program into main memory.
In modern languages, a prewritten subroutine is not loaded
until it is called. All subroutines are kept on disk in a relocat-
able load format. The main program is loaded into memory
and is executed. When a routine needs to call another routine,
the calling routine first checks whether the other routine has
been loaded. If not, the linking loader is called to load the
desired routine into memory and to update the program’s ad-
dress tables to reflect this change. Then, control is passed to
the newly loaded routine.
 66 Computer Fundamentals and Programming in C
note
∑ A high-level source program must be translated first into
a form the machine can execute. This is done by the
system software called the translator.
∑ The machine language program produced by the transla-
tor must normally be combined with other machine lan-
guage programs residing within the library to form a useful
execution unit. Linking resolves the symbolic references
between object programs. It makes object programs
known to each other. The system software responsible
for this function is known as linker.
∑ Relocation is the process of assigning addresses to the
various parts of the program, adjusting the code and data
in the program to reflect the assigned addresses.
∑ A loader is a system software that places executable pro-
gram’s instructions and data from secondary memory into
primary memory and prepares them for execution and ini-
tiates the execution
4.5  DEVELOPING A PROGRAM
We first discuss the step-by-step listing of the procedure
involved in creating a computer program. Here we explain the
seven important steps towards creating effective programs:
definition, design, coding, testing, documentation, imple-
mentation, and maintenance.
1. The first step in developing a program is to define
the problem. This definition must include the needed
output, the available input, and a brief definition of how
one can transform the available input into the needed
output.
2. The second step is to design the problem solution.
This detailed definition is an algorithm, a step-by-step
procedure for solving a problem.
3. The third step in developing a program is to code
the program; that is, state the program’s steps in the
language being used. The instructions must follow the
language’s syntax, or rules, just as good English must
follow the rules of grammar in English.
4. The fourth step is to test the program to make sure
that it will run correctly, no matter what happens. If the
algorithm is wrong or the program does not match the
algorithm, the errors are considered logic errors. Errors
in a program are called bugs; the process of finding
the bugs and correcting them is called debugging the
program. To test or debug a program, one must create a
sample-input data that represents every possible way to
enter input.
5. The fifth step in developing a program is to complete the
documentation of the program. Documentation should
include: user instructions, an explanation of the logic of
the program, and information about the input and output.
Documentation is developed throughout the program
development process. Documentation is extremely
important, yet it is the area in program development that
is most often overlooked or downplayed.
6. The last step in developing a program is implementation.
Once the program is complete, it needs to be installed on
a computer and made to work properly. If the program
is developed for a specific company, the programming
team may be involved in implementation. If the program
is designed to be sold commercially, the documentation
will have to include directions for the user to install the
program and begin working with it.
7. Even after completion, a program requires attention.
It needs to be maintained and evaluated for possible
changes.
4.6  SOFTWARE DEVELOPMENT
Programming is an individual’s effort and requires no for-
mal systematic approach. Software development is more than
programming. A large number of people are involved in soft-
ware development and it emphasizes on planned aspect of
development process. Programming is one of the activities
in software development. Other activities include require-
ment analysis, design, testing, deployment, maintenance etc.
A software is built according to client’s requirements. It is
driven by cost, schedule and quality. That is, software should
be developed at reasonable cost, handed over in reasonable
time. Below the most basic steps in software development
are explored.
4.6.1 Steps in Software development:
The entire process of software development and
implementation involves a series of steps. Each successive
step is dependent on the outcome of the previous step.
Thus, team of software designers, developers and users are
required to interact with each other at each stage of software
development so as to ensure that the end product is as per the
client’s requirements.
Software development steps are described below.
Feasibility study
The feasibility of developing the software in terms of
resources and cost is ascertained. In order to determine the
feasibility of software developments, the existing system of
the user is analysed properly. The analysis done in this step is
documented in a standard document called feasibility report,
which contains the observations and recommendations related
to the task of software development. Activities involved in
this step include the following.
Determining development alternatives  This activity in-
volves searching for the different alternatives that are avail-
able for the development of software.

Analysing economic feasibility  This activity involves de-
termining whether the development of new software will be
financially beneficial or not. This type of feasibility analysis
is performed to determine the overall profit that can be earned
from the development and implementation of the software.
This feasibility analysis activity involves evaluating all the
alternatives available for development and selecting the one
which is most economical.
Accessing technical feasibility  It involves analysing vari-
ous factors such as the performance of the technologies,
ease of installation, ease of expansion or reduction in size,
interoperability with other technologies, etc. The technical
feasibility involves the study of the nature of technology as
to how easily it can be learnt and the level of training required
to understand the technology. This type of feasibility assess-
ment greatly helps in selecting the appropriate technologies
to be used for developing the software. The selection should
be made after evaluating the requirement specification of the
software.
Analysing operational feasibility  It involves studying the
software on operational and maintenance fronts. The opera-
tional feasibility of any software is done on the basis of sev-
eral factors such as the following.
(a) Type of tools needed for operating the software
(b) Skill set required for operating the software
(c) Documentation and other support required for operating
the software
Requirement analysis
In this step, the requirements related to the software, which is
to be developed, are understood. Analysing the requirements
analysis is an important step in the process of developing
software. If the requirements of the user are not properly
understood, then the software is bound to fall short of end
user’s expectations. Thus, requirements analysis is always
the first step towards development of software.
The users may not be able to provide the complete set
of requirements pertaining to the desired software during
the requirement analysis stage. There should be continuous
interaction between the software development team and the
end users. The software development team also needs to take
into account the fact that the requirement of the users may
keep changing during the development process. Thus proper
analysis of user requirements is quite essential for developing
the software within a given time frame.
The customer requirements identified during the
requirements gathering and analysis activity are organized
into a System Requirements Specification Document. The
important components of this document are functional
requirements, the nonfunctional requirements, and the goals
of implementation.
Introduction to Software 67
Design
After the feasibility analysis stage, the next step is creating
the architecture and design of the new software. It involves
developing a logical model or basic structure of the new
software. Design of the software is divided into two stages –
system design and detailed software design.
System design partitions the requirements to hardware or
software systems. It establishes overall system architecture.
The architecture of a software system refers to an abstract
representation of that system. Architecture is concerned with
making sure the software system meets the requirements of
the product, as well as ensuring that future requirements can
be addressed. The architecture step also addresses interfaces
between the software system and other software products, as
well as the underlying hardware or the host operating system.
Detailed design represents the software system functions in
a form that can be transformed into one or more executable
programs. Specification is the task of precisely describing the
software to be written, possibly in a rigorous way.
Implementation
In this step, the code for the different modules of the new
software is developed. The code for the different modules
is developed according to the design specifications of each
module. The programmers in the software development team
use development tools for this purpose. An important, and
often overlooked, task is documenting the internal design
of software for the purpose of future maintenance and
enhancement.
Testing
It is basically performed to detect the prevalence of any
errors in the new software and rectify those errors. One of
the reasons for the occurrence of errors or defects in the
new software is that the requirements of the client were not
properly understood. Another reason for the occurrence of
errors is the common mistakes committed by a programmer
while developing the code. The two important activities that
are performed during testing are verification and validation.
Verification is the process of checking the software based on
some predefined specifications, while validation involves
testing the product to ascertain whether it meets the user
requirements. During validation, the tester inputs different
values to ascertain whether the software is generating the
right output as per the original requirements.
Deployment
The newly developed and fully tested software is installed
in its target environment. Software documentation is handed
over to the users and some initial data are entered in the
software to make it operational. The users are also given
training on the software interface and its other functions.
 68 Computer Fundamentals and Programming in C

Maintenance
In this phase, developed software is made operational. Users
will have lots of questions and software problems which lead to
the next phase of software development. Once the software has
been deployed successfully, a continuous support is provided
to it for ensuring its full time availability. The software may
be required to be modified if the environment undergoes a
change. Maintaining and enhancing software to cope with
newly discovered problems or new requirements can take far
more time than the initial development of the software.

Summary
A programming language is an artificial formalism for expressing the
instructions to be executed in a specified sequence. Programming
languages can be classified into low-level and high level languages. Low-
level programming languages include machine language and assembly
language. In fact, assembly languages were so revolutionary that they
became known as second-generation languages, the first generation being
the machine languages themselves. Assembly languages are symbolic
programming languages that use symbolic notation to represent machine-
language instructions.
Most third generation languages are procedural languages. Compilers
convert the program instructions from human understandable form to the
machine understandable form. Interpreters also convert the source program
to machine language instruction but execute each line as it is entered. The
translation of the source program takes place for every run and is slower
than the compiled code. The system software controls the activities of a
computer, application programs, flow of data in and out of memory and disk
storage. Compilation of a source code into target code follows successive
stages. In lexical analysis phase, lexical units or tokens are produced
from the statements. Also symbol table is constructed to record the type
and attributes information of each user-defined name in the program.
Next, syntax analysis takes place. In this phase, tokens are grouped into
syntactic units such as expressions, and statements. that must conform to
the grammatical rules of the source language to form a data structure called
parse tree. In semantic analysis, the parse trees are analysed further to
make sure that the operators and operands do not violate source language
type specification. Then, to produce a more efficient target program, the
intermediate code is generated which is then optimized. In the last phase,
object code in target language is produced. Linking resolves symbolic
references between object programs. A loader is a system program that
accepts object programs and prepares them for execution and initiates the
execution. Programming is an individual’s effort and requires no formal
systematic approach. Software development is more than programming. It
involves a series of steps–feasibility study, requirement analysis, design,
coding, testing, deployment and maintenance.

Key Terms
Loader  It is a system program that accepts object programs and
prepares these programs for execution by the computer and initialize the
execution.
Linker  It takes one or more object files or libraries as input and combines
them to produce a single (usually executable) file.
Compiler  It is a system software that translates the entire source
program into machine language.
Interpreter  An interpreter is a system software that translates the source
program into machine language line by line.
Syntax  It refers to the rules governing the computer operating system,
the language, and the application.
Assembler  It is a program that translates an assembly language
program into machine code.
Bug  It is a programming error.
Debugging  It is the process of eliminating errors from a program.
Semantic  It is the meaning of those expressions, statements, and
program units.

Frequently asked questions

1.  Distinguish between 3GL and 4GL.
3GL
Meant for use by professional
programmers.
Requires specifications of how to
perform a task.
Requires large number of procedural
instructions.
Code may be difficult to read,
understand, and maintain by the user.
Typically, file oriented.
4GL
May be used by non-professional
programmers as well as by
professional programmers.
Requires specifications of what task
to perform. System determines how to
perform the task.
Requires fewer instructions.
Code is easy to understand and
maintain.
Typically, database oriented.
2.  What are the functions of a loader?
The functions of a loader are as follows:
∑ Assignment of load-time storage area to the program
∑ Loading of program into assigned area
∑ Relocation of program to execute properly from its load time storage
area
∑ Linking of programs with one another
3.  What is a debugger?
The debugger is a program that lets the programmer to trace the flow of
execution or examine the value of variables at various execution points in
the program. For example, GDB, the GNU debugger, is used with GNU
 Introduction to Software 69
C Compiler. Debugger is always integrated in most of the Integrated 6.  Distinguish between a compiler and an interpreter.
Development Environment.
Compiler Interpreter
4. What does syntax and semantics of a programming language
mean? Scans the entire program before Translates and executes the program
translating it into machine code. line by line.
The syntax of a programming language is the form of its expressions,
Converts the entire program to Each time the program is executed,
statements, and program units. Its semantics is the meaning of those
machine code and only when all every line is checked for syntax error
expressions, statements, and program units. the syntax errors are removed does and then converted to the equivalent
5.  What is a symbol table? What is its function? execution take place. machine code.

The symbol table serves as a database for the compilation process. It Not much helpful in debugging. Very helpful in debugging.
records the type and attributes information of each user-defined name in Compilation process is faster. Interpretation process is slower.
the program. This table is used in sytax analysis, semantic analysis as well
Gives a list of all errors in the program. Stops at the first error.
as in code generation phases of compilation.

exercises
1. What do you mean by a program? 9. Briefly explain linker and loader. Is there any difference between
2. Distinguish between system software and application software. them?
3. State the advantages and disadvantages of machine language and 10. Explain linking loader and linkage editor.
assembly language. 11. Classify the programming languages.
4. Compare and contrast assembly language and high-level language. 12. What is a functional language?
5. Differentiate between 3GL and 4GL. 13. What is object-oriented language? Name five object-oriented
6. What is a translator? programming languages.
7. What are the differences between a compiler and an interpreter? 14. What is the difference between linking loader and linkage editor?
8. Briefly explain the compilation and execution of a program written in a 15. What is relocation?
high-level language.