UNIT-4

Chapter -1
The Software Problem

1.1 Software Problem :

An industrial-strength software system is built to solve some
problem of a client and is used by the client’s organization for operating some part of business,
and a malfunction of such a system can have huge impact in terms of financial or business loss,
inconvenience to users, or loss of property and life.
Consequently, the software system needs to be of high quality with respect to properties like
reliability, usability, portability, etc.
1.2 Cost, Schedule and Quality:
The three main forces that drive a (industrial-strength) software project are as follows,
1. Cost
2. Schedule
3. Quality
1.2.1 Cost :
The cost of software can be defined as the cost of some resources like manpower
employed, hardware and software, the cost for developing a project can be measured in
terms of person-months.
The productivity is measured in terms of Lines of code (LOC) or thousands of lines of code
(KLOC) per person-month.
1.2.2 Schedule :
Schedule is another important factor in many projects. Business trends are dictating that
the time to market of a product should be reduced; that is, the cycle time from concept to
delivery should be small.
1.2.3 Quality :
The software quality can be defined as the required attributes of software. It is
considered as a major aspect in business strategies .
Software Quality Attributes

Functionality :
It refers to the capacity of providing the requirements of the user as stated
Reliability :
It refers to the capacity of providing failure –free service
Usability :
It refers to the capacity of being used by the users in real-time
Efficiency :
It refers to the capacity of providing efficient performance respected the
1
 quality of resources used.

Maintainability :
It refers to the ease using which one can modify, develop and understand
the code.
Portability :
It refers to the capacity to be adopted by various platforms without introducing
any external actions to the product that is in use.
1.3 Scale and Change :
Industrial –strength software tends to be very large. Thus, its
development involves thousands of lines of code. Some of the famous software products
and their lines of codes are as shown in the below table,

Any software project involves the use of engineering and project management.
In small projects, informal methods for development and management can be used.

The problems in this domain often tend to be very large and where the needs of the
customers change fast. Hence the techniques used for developing industrial-strength software
capable of building large software systems, and have the capability to handle changes.

2
 Chapter - 2
Software Process
Software processes are the methods and techniques used to develop software products or the
systems used to make computers function usefully.

2.1 Process and Project :

A process is a sequence of steps performed in order to produce the
required output. A software process involves various issues related to technical and management
aspects of software development. Software satisfies user needs.

A Project can be defined as an instance of a process. The main goal of a software project
is to produce a good software with low-cost and high quality.

2.2 Component Software Processes:

Component Software Processes is a process is the
sequence of steps executed to achieve a goal. The processes that deal with the technical and
management issues of software development are collectively called the software process.

Software Processes are clearly two major components in a software process

1. Product Engineering process
2.Process management process.

3
2.2.1 Product Engineering Process
The product engineering process is divided into three different processes .
They are as follows.
Development process:-
The development process specifies all the engineering activities that need to be
performed.
Project management process:-
The management process specifies how to plan and control these activities so that cost,
schedule, quality, and other objectives are met.
Software Configuration Management Process
The software configuration management process is to manage the change and rework of
components that are not handled by a development process.

2.2.2 Process Management Process

The process management process is used to improve and
enhance the quality of software process . These improvements results in a good quality and low-
cost productivity. The activities of a process management process are executed by a software
community called Software Engineering Process Group (SEPG).

2.3 Software Development Process Models

A software process model is an abstraction of the software development process.
The models specify the stages and order of a process. So, think of this as a representation of
the order of activities of the process and the sequence in which they are performed.
A model will define the following:
 The tasks to be performed
 The input and output of each task
 The pre and post conditions for each task
 The flow and sequence of each task
In software development life cycle, various models are designed and defined. These
models are called as Software Development Process Models.
On the basis of project motive, the software development process model is selected for
development.

The Software Development Process Models are of 7 types.

1. Waterfall Model
2. Prototyping Model
3. Iterative Model
4. Rational Unified Process Model
5. Timeboxing Model
6. Agile model.
7. Incremental model.

4
2.4.1 Waterfall Model :
 The waterfall model is the classic model or oldest model and is known as mother of all
the model. It is widely used in government projects and many vital projects in company.
 The waterfall model is also called as 'Linear sequential model' or 'Classic life cycle
model'.
 In this model, each phase is executed completely before the beginning of the next phase.
Hence the phases do not overlap in waterfall model.
 This model is used for small projects.
 In this model, feedback is taken after each phase to ensure that the project is on the right
path.
 Testing part starts only after the development is completed.

Following are the phases in waterfall model:

i) Communication :
The software development starts with the communication between customer
and developer.
ii) Planning :
It consists of complete estimation, scheduling for project development.
iii) Modeling :
 Modeling consists of complete requirement analysis and the design of the
project i.e algorithm, flowchart etc.
 The algorithm is the step-by-step solution of the problem and the flow chart
shows a complete flow diagram of a program.
iv) Construction
 Construction consists of code generation and the testing part.
 Coding part implements the design details using an appropriate programming
language. Testing is to check whether the flow of coding is correct or not.
 Testing also checks that the program provides desired output.
v) Deployment
 Deployment step consists of delivering the product to the customer and taking
feedback from them.
 If the customer wants some corrections or demands for the additional
capabilities, then the change is required for improvement in the quality of the
software.
5
Advantages of Waterfall model
 The waterfall model is simple and easy to understand, to implement, and use.
 All the requirements are known at the beginning of the project, hence it is easy to manage.
 It avoids overlapping of phases because each phase is completed at once.
 This model works for small projects where the requirements are easily understood.

Disadvantages of the Waterfall model

 This model is not good for complex and object oriented projects.
 In this model, the changes are not permitted so it is not fit for moderate to high risk
changes in project.
 It is a poor model for long duration projects.
 The amount of risk is high.

2.4.2 Prototype Model :

 Prototype is defined as first or preliminary form using which other forms are copied or
derived.
 Prototype model is a set of general objectives for software.
 It does not identify the requirements like detailed input, output.
 It is software working model of limited functionality.
 In this model, working programs are quickly produced.

The different phases of Prototyping model are:

1) Communication
2) Quick design
3) Modeling and quick design
4) Construction of prototype
5) Deployment, delivery, feedback

1. Communication
In this phase, developer and customer meet and discuss the overall objectives of the
software.

6
2. Quick design
 Quick design is implemented when requirements are known.
 It includes only the important aspects i.e input and output format of the software.
 It focuses on those aspects which are visible to the user rather than the detailed plan.
 It helps to construct a prototype.
3. Modeling quick design
 This phase gives the clear idea about the development of software as the software is now
constructed.
 It allows the developer to better understand the exact requirements.
4. Construction of prototype
The prototype is evaluated by the customer itself.
5. Deployment, delivery, feedback
 If the user is not satisfied with current prototype then it is refined according to the
requirements of the user.
 The process of refining the prototype is repeated till all the requirements of users are met.
 When the users are satisfied with the developed prototype then the system is developed
on the basis of final prototype.

Advantages of Prototyping Model

 In the development process of this model users are actively involved.
 The development process is the best platform to understand the system by the user.
 Earlier error detection takes place in this model.
Disadvantages of Prototyping Model
 The client involvement is more and it is not always considered by the developer.
 It is a slow process because it takes more time for development.
 Many changes can disturb the rhythm of the development team.

2.4.3 Iterative Model :

 In Iterative model, the large application of software development is divided into smaller
parts of software which can be reviewed to recognize further requirements are
implemented. This process is repeated to generate a new version of the software in each
cycle of a model.
 With every iteration, development module goes through the phases i.e requirement,
design, implementation and testing. These phases are repeated in iterative model in a
sequence.

7
1) Requirement Phase
In this phase, the requirements for the software are assembled and analyzed. Generates
a complete and final specification of requirements.
2) Design Phase
In this phase, a software solution meets the designed requirements which can be a new
design or an extension of an earlier design.

3) Implementation and test phase

In this phase, coding for the software and test the code.

4) Evaluation
In this phase, software is evaluated, the current requirements are reviewed and
the changes and additions in the requirements are suggested.

Advantages of an Iterative Model

 Produces working software rapidly and early in the software life cycle.
 This model is easy to test and debug in a smaller iteration.
 It is less costly to change scope and requirements.

Disadvantages of an Iterative Model

 The system architecture is costly.
 This model is not suitable for smaller projects.

2.4.4 Rational Unified Process (RUP):

Rational Unified Process (RUP) is a software development process for object-oriented

models. It is also known as the Unified Process Model. It is created by Rational corporation and is
designed and documented using UML (Unified Modeling Language). This process is included in
IBM Rational Method Composer (RMC) product. IBM (International Business Machine
Corporation) allows us to customize, design, and personalize the unified process. RUP reduces
unexpected development costs and prevents wastage of resources.
Phases of RUP :
There are total five phases of life cycle of RUP

8
Inception –
 Communication and planning are main.
 Identifies Scope of the project using use-case model allowing managers to estimate costs
and time required.
 Customers requirements are identified and then it becomes easy to make a plan of the
project.
 Project plan, Project goal, risks, use-case model, Project description, are made.
 Project is checked against the milestone criteria and if it couldn’t pass these criteria then
project can be either cancelled or redesigned.
Elaboration –
 Planning and modeling are main.
 Detailed evaluation, development plan is carried out and diminish the risks.
 Revise or redefine use-case model (approx. 80%), business case, risks.
 Again, checked against milestone criteria and if it couldn’t pass these criteria then again
project can be cancelled or redesigned.
 Executable architecture baseline.
Construction –
 Project is developed and completed.
 System or source code is created and then testing is done.
 Coding takes place.
Transition –
 Final project is released to public.
 Transit the project from development into production.
 Update project documentation.
 Beta testing is conducted.
 Defects are removed from project based on feedback from public.
Production –
 Final phase of the model.
 Project is maintained and updated accordingly.

2.4.5 Time Boxing Model

 In time boxing model, development is done iteratively as in the iterative enhancement
model. However, in time boxing model, each iteration is done in a timebox of fixed
duration.
 The functionality to be developed is adjusted to fit the duration of the timebox.
Moreover, each timebox is divided into a sequence of fixed stages where each stage
performs a clearly defined task (analysis, implementation, and deploy) that can be done
independently.
 This model also requires that the time duration of each stage is approximately equal so
that pipelining concept is employed to have the reduction in development time and
product releases.

9
Advantages:
 Speeds up the development process and shortens the delivery time
 Well suited to develop projects with a number of features in short time period.
Disadvantages:
 Project management becomes more complex.
 Not suited to projects in which entire development work cannot be divided into multiple
iterations of almost, equal duration.

2.4.6 Agile model

The Agile software development methodology is one of the simplest and effective processes to
turn a vision for a business need into software solutions. Agile is a term used to describe software
development approaches that employ continual planning, learning, improvement, team
collaboration, evolutionary development, and early delivery. It encourages flexible responses to
change.

Phases of Agile Model:

Following are the phases in the Agile model are as follows:

1. Requirements gathering
2. Design the requirements
3. Construction/ iteration
4. Testing/ Quality assurance
5. Deployment
6. Feedback

10
1. Requirements gathering:
In this phase, you must define the requirements. You should explain
business opportunities and plan the time and effort needed to build the project. Based on
this information, you can evaluate technical and economic feasibility.
2. Design the requirements:
When you have identified the project, work with stakeholders to
define requirements. You can use the user flow diagram or the high-level UML diagram to
show the work of new features and show how it will apply to your existing system.
3. Construction/ iteration:
When the team defines the requirements, the work begins.
Designers and developers start working on their project, which aims to deploy a working
product. The product will undergo various stages of improvement, so it includes simple,
minimal functionality.
4. Testing:
In this phase, the Quality Assurance team examines the product's performance and
looks for the bug.
5. Deployment:
In this phase, the team issues a product for the user's work environment.
6. Feedback:
After releasing the product, the last step is feedback. In this, the team receives
feedback about the product and works through the feedback.

Advantages:
 Frequent Delivery
 Face-to-Face Communication with clients.
 Efficient design and fulfils the business requirement.
 Anytime changes are acceptable.
 It reduces total development time.
Disadvantages:
 Due to the shortage of formal documents, it creates confusion and crucial decisions taken
throughout various phases can be misinterpreted at any time by different team
members.
 Due to the lack of proper documentation, once the project completes and the developers
allotted to another project, maintenance of the finished project can become a difficulty.

2.4.6 Incremental Model

Incremental Model is a process of software development where requirements divided into

multiple standalone modules of the software development cycle.

In this model, each module goes through the requirements, design, implementation and testing
phases. Every subsequent release of the module adds function to the previous release. The
process continues until the complete system achieved.
11
The various phases of incremental model are as follows:

1. Requirement analysis:
In the first phase of the incremental model, the product analysis
expertise identifies the requirements. And the system functional requirements are understood by
the requirement analysis team. To develop the software under the incremental model, this phase
performs a crucial role.

2. Design & Development:

In this phase of the Incremental model of SDLC, the design of the
system functionality and the development method are finished with success. When software
develops new practicality, the incremental model uses style and development phase.

3. Testing:
In the incremental model, the testing phase checks the performance of each existing
function as well as additional functionality. In the testing phase, the various methods are used to
test the behavior of each task.
History of Java
4. Implementation:
Implementation phase enables the coding phase of the development system.
It involves the final coding that design in the designing and development phase and tests the
functionality in the testing phase. After completion of this phase, the number of the product
working is enhanced and upgraded up to the final system product

Advantages
 Errors are easy to be recognized.
 Easier to test and debug
 More flexible.
 Simple to manage risk because it handled during its iteration.
Disadvantages
 Need for good planning
 Total Cost is high.
 Well defined module interfaces are needed

12
2.5 Programming Principles and Guidelines

The main task before a programmer is to write readable code with few bugs in it. An
additional goal is to write code quickly. Writing solid code is a skill that can only be
acquired by practice. However, based on experience, some general rules and
guidelines can be given for the programmer. They are

1.Structured programming
2.Information hiding

1.Structured Programming

The structured programming movement started in the 1970s, and much has been
said and written about it. Structured programming is often regarded as “goto-less”
programming. Although extensive use of gotos is certainly not desirable, structured
programs can be written with the use of gotos.

A program has a static structure as well as a dynamic structure. The static structure
is the structure of the text of the program, which is just a linear organization of
statements of the program.

The key property of a structured statement is that it has a single-entry and a single-exit.
That is, during execution, the execution of the (structured) statement starts from one
defined point and the execution terminates at one defined point.

The most commonly used single-entry and single-exit statements are

Selection: if B then S1 else S2

if B then S1
Iteration: While B do S
Repeat S until B
Sequencing : S1; S2; S3;…

It can be shown that these three basic constructs are sufficient to program any conceivable
algorithm.
2. Information hiding
Information hiding can reduce the coupling between modules and make the system more
maintainable. Information hiding is also an effective tool for managing the complexity of
developing software—by using information hiding we have separated the concern of
managing the data from the concern of using the data to produce some desired results.

13
 Many of the older languages, like Pascal, C, and FORTRAN, do not pro- vide mechanisms to
support data abstraction. With such languages, information hiding can be supported only by
a disciplined use of the language. That is, the access restrictions will have to be imposed by
the programmers; the language does not provide them

2.6 Some Programming Practices:

Some of the programming practices or rules that helps in developing a code that easy to read and
understand are as follows

Control Constructs:
It is desirable that as much as possible single-entry, single-exit constructs
be used. It is also desirable to use a few standard control constructs rather than using a wide
variety of constructs, just because they are available in the language.

Gotos:
Gotos should be used in a disciplined manner. Only when the alternative to using gotos
is more complex should the gotos be used. In any case, alternatives must be thought of before
finally using a goto. If a goto must be used, forward transfers (or a jump to a later statement)
is more acceptable than a backward jump.

Information Hiding:
Information hiding should be supported where possible. Only the access
functions for the data structures should be made visible while hiding the data structure behind
these functions

User-defined Types :
Most of the latest programming languages allow the users to define the
types such as enumerated types.But they should be introduced only whne it is necessary.

Nesting :
The usage of multiple nested if-then-else statements make the code complex so
that, it cannot be easily understood by the user. Thus, nesting statements should be used
only when it is necessary.

if C1 then S1
else if C2 then S2
else if C3 then S3
else if C4 then S4;

14
 Switch Case with Default:
In programming concept Switch case is useful to select one statement
from multiple statements. It is a good practice to always include a default case.

switch (i)
{
case 0 : { s= malloc ( size )
}
s [0] = y; /* NULL dereference if default occurs */
Empty Catch Block:
An empty catch block indicates that ,some of the operations to be performed are not
operated. Thus , a catch block should not be left empty in any case.
Return statement from Finally Block
The usage of return statement is finally block may lead to errors.

2.7 Coding Standards:

coding standards provide guidelines for programmers regarding naming, file organization,
statements and declarations, and layout and comments. To give an idea of coding standards
(often called conventions or style guidelines), we discuss some guidelines for Java, based on
publicly available standards.

2.7.1 Naming Conventions

Some of the standard naming conventions that are followed often are:
 Package names should be in lowercase.
 Type names should be nouns and should start with uppercase (e.g., Day, DateOfBirth,
EventHandler).
 Variable names should be nouns starting with lowercase (e.g., name, amount).
 Constant names should be all uppercase (e.g., PI, MAX ITERATIONS).
 Method names should be verbs starting with lowercase (e.g., getValue())

2.7.2 .Files :
There are conventions on how files should be named, and what files should contain, such that
a reader can get some idea about what the file contains.

Some examples of these conventions are:

 Java source files should have the extension .java.

 Each file should contain one outer class and the class name should be the same as the file
name.
15
  Line length should be limited to less than 80 columns and special characters should be
avoided.
2.7.3 .Statements :
 Variables should be initialized where declared, and they should be declared in the smallest
possible scope.
 Declare related variables together in a common statement.
 Unrelated variables should not be declared in the same statement.
 Class variables should never be declared public.
 Use only loop control statements in a for loop.
 Loop variables should be initialized immediately before the loop.
 Avoid the use of break and continue in a loop.
 Avoid the use of do ... while construct.
2.7.4 . Comments and Layout :

Comments are textual statements that are meant for the program reader to aid the
understanding of code. The purpose of com- men ts is not to explain in English the logic of
the program—if the logic is complex that it requires comments to explain it, it is better to
rewrite and simplify the code instead.

Unit 4 Questions

1. What are the three main forces that drive a (industrial-strength ) software project ( Cost,
Schedule and quality of a software project)
2. Explain in detail about scale and change parameters of a software project
3. What is Software Process? Write in short about process and project
4. Explain the various component processes in the software process
5. What is SDLC? Explain stages in SDLC
6. What are the different types of software process models and explain it.
7. Write a short note on information hiding and structured programming
8. What are the different coding statements used to write a program
9. Write in detail about some programming practices

16