LECTURE NOTES

ON
Software Engineering
(24ALMC00102T)
I MCA I Semester (R24)
Prepared by
T.Syamala
Assistant Professor

MASTER OF COMPUTER APPLICATIONS

Anantha Lakshmi Institute of Technology & Sciences

(Autonomous)
(Itikalapalli (V), Near S.K. University-Ananthapuramu-515721)
 Course Code SOFTWARE ENGINEERING L T P C
24ALMC00102T 4 0 0 4
Semester I
Course Objectives:
 To learn the basic concepts of software engineering and life cycle models
 To explore the issues in software requirements specification and enable to write
SRSdocuments for software development problems
 To elucidate the basic concepts of software design and enable to carry out proceduraland
object oriented design of software development problems
 To understand the basic concepts of black box and white box software testing andenable
to designtest cases for unit, integration, and system testing
 To reveal the basic concepts in software project management
Course Outcomes (CO): Student will be able to
 Ability to apply software engineering principles and techniques.
 Ability to develop, maintain and evaluate large-scale software systems.
 To produce efficient, reliable, robust and cost-effective software solutions.
 Ability to work as an effective member or leader of software engineering teams.
 Ability to understand and meet ethical standards and legal responsibilities.
UNIT – I Lecture Hrs:
Basic concepts: abstraction versus decomposition, evolution of software engineering techniques,
Software development life cycle (SDLC) models: Iterative waterfall model, Prototype model,
Evolutionary model, Spiral model, RAD model, Agile models, software project management:
project planning, project estimation, COCOMO, Halstead’s Software Science, project scheduling,
staffing, Organization and team
structure, risk management, configuration management.
UNIT – II Lecture Hrs:
The nature of software, The Unique nature of Webapps, Software Myths, Requirements gathering
and analysis, software requirements specification, Traceability, Characteristics of a Good SRS
Document, IEEE 830 guidelines, representing complex requirements using decision tables and
decision trees,
overview of formal system development techniques. Axiomatic specification, algebraic
specification.
UNIT - III Lecture Hrs:
Good Software Design, Cohesion and coupling, Control Hierarchy: Layering, Control Abstraction,
Depth and width, Fan-out, Fan-in, Software design approaches, object oriented vs. function
oriented design. Overview of SA/SD methodology, structured analysis, Data flow diagram,
Extending DFD technique to real life systems, Basic Object oriented concepts, UML Diagrams,
Structured design, Detailed design, Design review, Characteristics of a good user interface, User
Guidance and Online Help, Mode-based Vs. Mode-less Interface, Types of user interfaces,
Component-based GUI development, User interface design
methodology: GUI design methodology.
UNIT – IV Lecture Hrs:
Coding standards and guidelines, code review, software documentation, Testing, Black Box
Testing,
White Box Testing, debugging, integration testing, Program Analysis Tools, system testing,
performance testing, regression testing, Testing Object Oriented Programs.
UNIT – V
Software reliability, Statistical testing, Software quality and management, ISO 9000, SEI
capability maturity model (CMM), Personal software process (PSP), Six sigma, Software quality
metrics, CASE and its scope, CASE environment, CASE support in software life cycle,
Characteristics of software maintenance, Software reverse engineering, Software maintenance
processes model, Estimation
maintenance cost. Basic issues in any reuse program, Reuse approach, Reuse at organization level.
Text Books:

1. RajibMall, “Fundamentals of Software Engineering”, 5th Edition, PHI, 2018.

2.Pressman R, “Software Engineering- Practioner Approach”, McGraw Hill.
 SOFTWARE ENGINEERING

UNIT-I

INTRODUCTION

Computers were very slow in the initial years and lacked sophistication. If similar improvements could
have occurred to aircrafts, now personal mini-airplanes should have become available, costing as much as a
bicycle, and flying at over 1000 times the speed of the supersonic jets. The more powerful a computer is, the
more sophisticated programs can it run. Therefore, with every increase in the raw computing capabilities of
computers, software engineers have been called upon to solve increasingly larger and complex problems, and
that too in cost-effective and efficient ways. Software engineers have coped up with this challenge by innovating
and building upon their past programming experiences.

Software engineering is a systematic and cost-effective technique for software development. These
techniques help develop software using an engineering approach. The innovations and past experiences
towards writing good quality programs cost- effectively, have contributed to the emergence of the software
engineering discipline.
For example: If someone wants to travel from Punjab to Delhi. There are two approaches one can
follow to achieve the same result:
1. The normal approach is just to go out and catch the bus/train that is available.
2. A systematic approach is constructed as Firstly check on Google Maps about distance and after
analyzing the timing of trains and buses online and after that, match user’s preference suppose user have
some work till 4:00 PM and trains slot are: 1:00 PM, 6:00 PM then the user will choose 6:00 PM time
slot and reach Delhi.
From the above situation, one can easily analyze that Creating a systematic Approach is more optimal
and time and cost-effective as compared to a normal approach. This will same occur while designing Software.
So in Software Engineering working on an Engineering or a Systematic approach is more beneficial.
What is software engineering?
 Software engineering an engineering branch Associated with development of software product using well
defined Scientific principles,,methods and procedures. The outcome of software engineering is an efficient
and effective software product.

Abstraction Versus Decomposition

Two important principles that are deployed by software engineering to overcome the problems arising
due to human cognitive limitations are—abstraction and decomposition

Abstraction:

In software engineering and computer science, abstraction is a technique for arranging complexity of
computer systems. Abstraction means displaying only essential information and hiding the details. It works by
establishing a level of simplicity on which a person interacts with the system, suppressing the more complex
details below the current level. Data abstraction refers to providing only essential information about the data to
the outside world, hiding the background details or implementation. Consider a real life example of a man
driving a car.

Decomposition:

It is another important principle that is available in the repertoire of a software engineer to handle
problem complexity. This principle is profusely made use by several software engineering techniques to contain
the exponential growth of the perceived problem complexity. The decomposition principle is popularly known
as the divide and conquer principle.The decomposition principle advocates decomposing the problem into many
small independent parts. The small parts are then taken up one by one and solved separately. The idea is that
each small part would be easy to grasp and understand and can be easily solved. The full problem is solved when
all the parts are solved.

Evolution of software design techniques

1. Early Computer Programming: Early commercial computers were very slow and too elementary as
compared to today’s standards. Even simple processing tasks took considerable computation time on those
computers. No wonder that programs at that time were very small in size and lacked sophistication. Those
programs were usually written in assembly languages.

Program lengths were typically limited to about a few hundreds of lines of monolithic assembly code.
Every programmer developed his own individualistic style of writing programs according to his intuition and
used this style ad hoc while writing different programs.

2. High-level Language Programming: Computers became faster with the introduction of semiconductor
technology in the early 1960s. Faster semiconductor transistors replaced the prevalent vacuum tube-based
circuits in a computer. With the availability of more powerful computers, it became possible to solve larger
and more complex problems.

At this time, high-level languages such as FORTRAN, ALGOL, and COBOL were introduced. This
considerably reduced the effort required to develop software and helped programmers to write larger
programs.Writing each high-level programming construct in effect enables the programmer to write several
machine instructions. However, the programmers were still using the exploratory style of software
development.

3. Control Flow-based Design: A program’s control flow structure indicates the sequence in which the
program’s instructions are executed. In order to help develop programs having good control flow structures,
the flowcharting technique was developed. Even today, the flowcharting technique is being used to represent
and design algorithms.

4. Data Structure-oriented Design: Computers became even more powerful with the advent of
Integrated Circuits (ICs) in the early 1970s. These could now be used to solve more complex problems.
Software developers were tasked to develop larger and more complicated software. which often required
writing in excess of several tens of thousands of lines of source code.

It is much more important to pay attention to the design of the important data structures of the
program than to the design of its control structure. Design techniques based on this principle are called Data
Structure-oriented Design.

Example: Jackson’s Structured Programming (JSP) technique developed by Michael Jackson (1975). In JSP
methodology, a program’s data structure is first designed using the notations for sequence, selection, and
iteration. The JSP methodology provides an interesting technique to derive the program structure from its data
structure representation.

5. Data Flow-oriented Design: As computers became still faster and more powerful with the introduction
of very large scale integrated (VLSI) Circuits and some new architectural concepts, more complex and
sophisticated software were needed to solve further challenging problems. Therefore, software developers
looked out for more effective techniques for designing software and Data Flow-Oriented Design techniques
were proposed.

The functions are also called as processes and the data items that are exchanged between the different functions
are represented in a diagram is known as a Data Flow Diagram (DFD).
6. Object-oriented Design: Object-oriented design technique is an intuitively appealing approach, where
the natural objects (such as employees, etc.) relevant to a problem are first identified and then the relationships
among the objects such as composition, reference, and inheritance are determined. Each object essentially acts
as a data hiding is also known as data abstraction.

Object-oriented techniques have gained wide spread acceptance because of their simplicity, the scope for
code and design reuse, promise of lower development time, lower development cost, more robust code, and
easier maintenance.

Software life cycle: It is well known that all living organisms undergo a life cycle. For example when a seed
is planted,It germinates, grows into a full tree,and finally dies.Based on this concept of a biological life
cycle,the term software life cycle has been defined to imply the different stages (or phases)over which a
software evolves from an initial customer request for it,to a fully developed software,and finally to a stage
where it is no longer useful to any user, and then it is discarded.

Software Development life cycle

software life cycle model (also termed process model) is a pictorial and diagrammatic
representation of the software life cycle. A life cycle model represents all the methods required to make a
software product transit through its life cycle stages. SDLC stands for Software Development Life Cycle and
is also referred to as the Application Development life-cycle.
• Phase 1: Requirement analysis & planning

• Phase 2: Design

• Phase 3: Implementation/Coding

• Phase 4: Testing

• Phase 5 : Deployement

• Phase 6: Maintenace

Phase 1: Requirement collection and analysis:

 The requirement is the first stage in the SDLC process.

 It is conducted by the senior team members with inputs from all the stakeholders and domain
experts in the industry.
 This stage gives a clearer picture of the scope of the entire project and the anticipated issues,
opportunities, and directives which triggered the project.
 After gathering all requirements from customer.They maintain SRS (Software Requirement
Specification) document is created.

Phase 2: Design:

 In this phase, the system and software design documents are prepared as per the requirement
specification document.
  There are two kinds of design documents developed in this phase:

High-Level Design (HLD)

• Brief description and name of each module

• An outline about the functionality of every module

• Interface relationship and dependencies between modules

• Database tables identified along with their key elements

• Complete architecture diagrams along with technology details

Low-Level Design(LLD)

• Functional logic of the modules

• Database tables, which include type and size

• Complete detail of the interface

• Addresses all types of dependency issues

• Listing of error messages

• Complete input and outputs for every module

Phase 4: Implementation/Coding:

 Once the system design phase is over, the next phase is coding.
 It is conducted by programmers and software developers
 In this phase, developers start build the entire system by writing code using the chosen
programming language ( php,c,c++,html,python,Java)
 In the coding phase, tasks are divided into units or modules and assigned to the various developers.
It is the longest phase of the Software Development Life Cycle process.
 They also need to use programming tools like compiler, interpreters, debugger to generate and
implement the code.

Phase 5: Testing:

 Once the software is complete, and it is deployed in the testing environment.

 It is conducted by Testors and Question & Answers.
 The testing team starts testing the functionality of the entire system. This is done to verify that the
entire application works according to the customer requirement.
 During this phase, QA and testing team may find some bugs/defects which they communicate to
developers.
 The development team fixes the bug and send back to QA for a re-test.
  It performs Integration testing,white box testing, black box testing performance testing and
accepting testing.

Phase 6: Deployment:

 Once the software testing phase is over and no bugs or errors left in the system then the final
deployment process starts.
 Based on the feedback given by the project manager, the final software is released and checked for
deployment issues if any changing ,modifying & updating software to keep it up with customer
needs.

Phase 7: Maintenance:

Once the system is deployed, and customers start using the developed system, following 3 activities occur

• Bug fixing - bugs are reported because of some scenarios which are not tested at all

• Upgrade - Upgrading the application to the newer versions of the Software

• Enhancement - Adding some new features into the existing software

SDLC MODELS:

There are 8 types of sdlc models they are

1) waterfall model
2) Prototype model
3) Iterative model
4) Spiral model
5) Incremental model
6) RAD (Rapid application development) model
7) Agile Model
8) Evolutionary Model

1.waterfall model:

 This Model is a linear sequential model

 It demands systematic sequential approach
 It is a oldest model
 It is no reverse direction but only the forward direction each face must be complete a before the
next phase can begin output of the one face will be input of next phase
The sequential phases in Waterfall model are −

• Requirement Gathering and analysis − All possible requirements of the system to be developed are
captured in this phase and documented in a requirement specification document.

• System Design − The requirement specifications from first phase are studied in this phase and the
system design is prepared. This system design helps in specifying hardware and system requirements
and helps in defining the overall system architecture.

• Implementation − With inputs from the system design, the system is first developed in small
programs called units, which are integrated in the next phase. Each unit is developed and tested for its
functionality, which is referred to as Unit Testing.

• Integration and Testing − All the units developed in the implementation phase are integrated into a
system after testing of each unit. Post integration the entire system is tested for any faults and failures.

• Deployment of system − Once the functional and non-functional testing is done; the product is
deployed in the customer environment or released into the market.

• Maintenance − There are some issues which come up in the client environment. To fix those issues,
patches are released. Also to enhance the product some better versions are released. Maintenance is
done to deliver these changes in the customer environment.

Advantages and Disadvantages of Waterfall-Model

Advantages Dis-Advantages

Before the next phase of development, each Error can be fixed only during the phase
phase must be completed
 Suited for smaller projects where It is not desirable for complex project where
requirements are well defined requirement changes frequently

Elaborate documentation is done at every Documentation occupies a lot of time of

phase of the software's development cycle developers and testers

Project is completely dependent on project Clients valuable feedback cannot be included

team with minimum client intervention with ongoing development phase

2.Prototyping Model:

 Prototyping Model is a software development model in which prototype is built, tested, and reworked
until an acceptable prototype is achieved.
 Prototype model type is not a complete product it is just functional a replica of any idea

Advantages:

 Communicate effectively
 This is useful when requirement are changing rapidly

Disadvantages:

 It is impossible to know how long it will take prototype tools are expensive
 Costly with respect to time and money
 There is a lot of Client or customer feedback
Step 1: Requirements gathering and analysis
A prototyping model starts with requirement analysis. In this phase, the requirements of the system are defined
in detail. During the process, the users of the system are interviewed to know what is their expectation from
the system.

Step 2: Quick design

The second phase is a preliminary design or a quick design. In this stage, a simple design of the system is
created. However, it is not a complete design. It gives a brief idea of the system to the user. The quick design
helps in developing the prototype.

Step 3: Build a Prototype

In this phase, an actual prototype is designed based on the information gathered from quick design. It is a small
working model of the required system.

Step 4: Initial user evaluation

In this stage, the proposed system is presented to the client for an initial evaluation. It helps to find out the
strength and weakness of the working model. Comment and suggestion are collected from the customer and
provided to the developer.

Step 5: Refining prototype

If the user is not happy with the current prototype, you need to refine the prototype according to the user's
feedback and suggestions.

Step 6: Implement Product and Maintain

Once the final system is developed based on the final prototype, it is thoroughly tested and deployed to
production. The system undergoes routine maintenance for minimizing downtime and prevent large-scale
failures.
3.Iterative Model:
The iterative model is a methodology where the development process is broken into smaller, manageable
cycles called iterations. Each iteration involves planning, designing, coding, testing, and evaluating a subset of
the software. This process is repeated until the software is complete.
Advantages:
 Testing and debugging smaller iteration is easy a parallel development can plan
 Risks are identify or resolved during iteration
Dis Advantages :
 It is not suitable for small projects and it is suitable for large project
 More resources may be required
 Design can be again and again because of imperfect requirements

4.Incremental Model:
It 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.
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.
Advertisement
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
Advantage of Incremental Model
o Errors are easy to be recognized.
o Easier to test and debug
o More flexible.
o Simple to manage risk because it handled during its iteration.
o The Client gets important functionality early.
Disadvantage of Incremental Model
o Need for good planning
o Total Cost is high.
o Well defined module interfaces are needed.
5.Spiral Model :
The spiral model, initially proposed by Boehm, is an evolutionary software process model that couples
the iterative feature of prototyping with the controlled and systematic aspects of the linear sequential
model.

Each cycle in the spiral is divided into four parts:

Objective setting: Each cycle in the spiral starts with the identification of purpose for that cycle, the
various alternatives that are possible for achieving the targets, and the constraints that exists.
Advertisement
Risk Assessment and reduction: The next phase in the cycle is to calculate these various alternatives
based on the goals and constraints. The focus of evaluation in this stage is located on the risk perception
for the project.
Development and validation: The next phase is to develop strategies that resolve uncertainties and
risks. This process may include activities such as benchmarking, simulation, and prototyping.
Planning: Finally, the next step is planned. The project is reviewed, and a choice made whether to
continue with a further period of the spiral. If it is determined to keep, plans are drawn up for the next
step of the project.
The development phase depends on the remaining risks.
 For example, if performance or user-interface risks are treated more essential than the program
development risks, the next phase may be an evolutionary development that includes developing a more
detailed prototype for solving the risks.
Advantages
o High amount of risk analysis
o Useful for large and mission-critical projects.

Disadvantages
o Can be a costly model to use.
o Risk analysis needed highly particular expertise
o Doesn't work well for smaller projects.

6.RAD (Rapid Application Development) Model:

RAD is a linear sequential software development process model that emphasizes a concise development cycle
using an element based construction approach. It is also an incremental model and fastest.RAD model is we
can complete project with in 2 or 3 months.

It can be contain 5 stages:

1. Communication
2. Planning
3. Modeling
4. Implementation
5. Development /Maintain
The various phases of RAD are as follows:
1.Business Modelling: The information flow among business functions is defined by answering questions like
what data drives the business process, what data is generated, who generates it, where does the information
go, who process it and so on.
2. Data Modelling: The data collected from business modeling is refined into a set of data objects (entities)
that are needed to support the business. The attributes (character of each entity) are identified, and the
relation between these data objects (entities) is defined.
Advertisement
3. Process Modelling: The information object defined in the data modeling phase are transformed to achieve
the data flow necessary to implement a business function. Processing descriptions are created for adding,
modifying, deleting, or retrieving a data object.
4. Application Generation: Automated tools are used to facilitate construction of the software; even they use
the 4th GL techniques.
5. Testing & Turnover: Many of the programming components have already been tested since RAD emphasis
reuse. This reduces the overall testing time. But the new part must be tested, and all interfaces must be fully
exercised.

Advantage :
 o This model is flexible for change.
o In this model, changes are adoptable.

o Each phase in RAD brings highest priority functionality to the customer.

o It reduced development time.
o It increases the reusability of features.

Disadvantage
o It required highly skilled designers.

o All application is not compatible with RAD.

o For smaller projects, we cannot use the RAD model.
o On the high technical risk, it's not suitable.
o Required user involvement.

7.Agile model:
The meaning of Agile is swift or versatile."Agile process model" refers to a software development approach
based on iterative development. Agile methods break tasks into smaller iterations, or parts do not directly
involve long term planning. It is combination of an incremental and Iterative process of software development
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(Pros) :
1. Frequent Delivery
2. Face-to-Face Communication with clients.
3. Efficient design and fulfils the business requirement.
4. Anytime changes are acceptable.

5. It reduces total development time.

Disadvantages(Cons):
1. 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.
 2. 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.

8.Evolutionary Model:
The evolutionary model is also known as successive versions or incremental models. The main aim of
this evolutionary model is to deliver the products in total processes over time. It also combines the
iterative and collective model of the software development life cycle (SDLC).
It is also called successive versions model or incremental model. At first, a simple working model is
built. Subsequently it undergoes functional improvements & we keep on adding new functions till the
desired system is built.

Advantages: 1.User gets a chance to experiment partially developed system

2.Reduce the error because the core modules get tested thoroughly.
Dis Advantages: It is difficult to divide the problem into several versions that would be acceptable to the
customer which can be incrementally implemented & delivered.
Software project management :
What is Project?
A project is a group of tasks that need to complete to reach a clear result. A project also defines as a set of
inputs and outputs which are required to achieve a goal. Projects can vary from simple to difficult and can be
operated by one person or a hundred.
What is software project management?
Software project management is an art and discipline of planning and supervising software projects. It is a
sub-discipline of software project management in which software projects planned, implemented, monitored
and controlled.
It is a procedure of managing, allocating and timing resources to develop computer software that fulfills
requirements.
In software Project Management, the client and the developers need to know the length, period and cost of
the project.
Prerequisite of software project management?
There are three needs for software project management. These are:

1. Time
2. Cost
3. Quality
There are many activities of software project management : They are
1) Project Planning
2) Project Scheduling
3) Project Cost Estimation
4) COCOMO
5) Project Risk Management
6) Project Configuration Management
7) Project Communication Management
8) Staffing

Project planning:
Once a project is found to be feasible, software project managers undertake project planning. Project
planning is undertaken and completed even before any development activity starts. Project planning consists
of the following essential activities:
Project size: What will be problem complexity in terms of the effort and time required to develop the product?
Cost: How much is it going to cost to develop the project?
 Duration: How long is it going to take to complete development?

Effort: How much effort would be required?

The effectiveness of the subsequent planning activities is based on the accuracy of these estimations.

• Scheduling manpower and other resources

• Staff organization and staffing plans
• Risk identification, analysis, and abatement planning
• Miscellaneous plans such as quality assurance plan, configuration management plan, etc.

Fig:Precedence ordering among planning activities

Project schedule:
simply means a mechanism that is used to communicate and know about that tasks are needed and has to be
done or performed and which organizational resources will be given or allocated to these tasks and in what
time duration or time frame work is needed to be performed. Effective project scheduling leads to success of
project, reduced cost, and increased customer satisfaction. Scheduling in project management means to list
out activities, deliverables, and milestones within a project that are delivered. It contains more notes than
your average weekly planner notes. The most common and important form of project schedule is Gantt chart.

Project Cost Estimation:

Number of estimation techniques have been developed having some attributes in common.
Cost estimation models are some mathematical algorithms or parametric equations that are used to estimate
the cost of a product.

 Software tools
 Location
 Duration
 Experts Judgement and cost estimation

COCOMO
COCOMO (Constructive Cost Estimation Model) was proposed by Boehm [1981].
The necessary steps in this model are:
1. Get an initial estimate of the development effort from evaluation of thousands of delivered lines of
source code (KDLOC).
2. Determine a set of 15 multiplying factors from various attributes of the project.
3. Calculate the effort estimate by multiplying the initial estimate with all the multiplying factors i.e.,
multiply the values in step1 and step2.
The initial estimate (also called nominal estimate) is determined by an equation of the form used in the static
single variable models, using KDLOC as the measure of the size. To determine the initial effort E i in person-
months the equation used is of the type is shown below
Ei=a*(KDLOC)b
Or
E=a+b(s)c
E=Effort
S=Software Development Time

a,b,c are values derived from customer

In COCOMO, projects are categorized into three types:

1. Organic
2. Semidetached
3. Embedded
1.Organic: A development project can be treated of the organic type, if the project deals with developing a
well-understood application program, the size of the development team is reasonably small, and the team
members are experienced in developing similar methods of projects.
Examples of this type of projects are simple business systems, simple inventory management systems, and
data processing systems.
2.Semidetached: A development project can be treated with semidetached type if the development consists
of a mixture of experienced and inexperienced staff. Team members may have finite experience in related
systems but may be unfamiliar with some aspects of the order being developed.
Example of Semidetached system includes developing a new operating system (OS), a Database
Management System (DBMS), and complex inventory management system.
3.Embedded: A development project is treated to be of an embedded type, if the software being developed
is strongly coupled to complex hardware, or if the stringent regulations on the operational method exist.
For Example: ATM, Air Traffic control.
The Six phases of detailed COCOMO are:

What is Risk?
A risk is a probable problem; it might happen, or it might not. There are main two characteristics of risk.
 Uncertainty: the risk may or may not happen which means there are no 100% risks.
 Loss: If the risk occurs in reality, undesirable results or losses will occur.

Risk Management
A software project can be concerned with a large variety of risks. In order to be adept to systematically identify
the significant risks which might affect a software project, it is essential to classify risks into different classes.
The project manager can then check which risks from each class are relevant to the project.
There are three main classifications of risks which can affect a software project:
1. Project risks
2. Technical risks
3. Business risks
1. Project risks: Project risks concern differ forms of budgetary, schedule, personnel, resource, and customer-
related problems. A vital project risk is schedule slippage. Since the software is intangible, it is very tough to
monitor and control a software project. It is very tough to control something which cannot be identified. For
any manufacturing program, such as the manufacturing of cars, the plan executive can recognize the product
taking shape.
2. Technical risks: Technical risks concern potential method, implementation, interfacing, testing, and
maintenance issue. It also consists of an ambiguous specification, incomplete specification, changing
specification, technical uncertainty, and technical obsolescence. Most technical risks appear due to the
development team's insufficient knowledge about the project.
Advertisement
3. Business risks: This type of risks contain risks of building an excellent product that no one need, losing
budgetary or personnel commitments, etc.
Other risk categories
1. 1. Known risks: Those risks that can be uncovered after careful assessment of the project program,
the business and technical environment in which the plan is being developed, and more reliable data
sources (e.g., unrealistic delivery date)
2. 2. Predictable risks: Those risks that are hypothesized from previous project experience (e.g., past
turnover)
3. 3. Unpredictable risks: Those risks that can and do occur, but are extremely tough to identify in
advance.
Principle of Risk Management
1. Global Perspective: In this, we review the bigger system description, design, and implementation. We
look at the chance and the impact the risk is going to have.
2. Take a forward-looking view: Consider the threat which may appear in the future and create future
plans for directing the next events.
3. Open Communication: This is to allow the free flow of communications between the client and the
team members so that they have certainty about the risks.
4. Integrated management: In this method risk management is made an integral part of project
management.
5. Continuous process: In this phase, the risks are tracked continuously throughout the risk management
paradigm.
Project Configuration Management:
It is practical in controlling and managing the access to various SCIs e.g., by preventing the two members of a
team for checking out the same component for modification at the same time.
Or
It is about to controll the changes in software like requirements,design and development of a product
Project Communication Management :
Communication is an essential factor in the success of the project.It is a bridge between client and
organization,Team members and hardware suppliers.The communication must be clear and
understood.Miscommunication can create a big problem in the project.
There are 4 types of Communication Methods:
 Formal Verbal Communication
 Informal verbal communication
 Formal Written Communication
 Informal Written Communication
Halstead’s Software Science – An Analytical Technique
Halstead’s software science is an analytical technique to measure size, development effort, and
development cost of software products. Halstead used a few primitive program parameters to develop the
expressions for over all program length, potential minimum value, actual volume, effort, and development time.
For a given program, let:
 η1 be the number of unique operators used in the program,
 η2 be the number of unique operands used in the program, N1 be the total number of
operators used in the program, N2 be the total number of operands used in the program.
Operators and Operands for the ANSI C language
The following is a suggested list of operators for the ANSI C language:

 ( [ . , -> * + - ~ ! ++ -- * / % + - << >> < > <= >= !=

 == & ^ | && || = *= /= %= += -= <<= >>= &= ^= |= : ? { ;
 CASE DEFAULT IF ELSE SWITCH WHILE DO FOR GOTO CONTINUE BREAK
RETURN and a function name in a function call

Operands are those variables and constants which are being used with operators in expressions. Note that
variable names appearing in declarations are not considered as operands.
Example :The function name in a function definition is not counted as an operator.
int func ( int a, int b ) { . .
.
}
For the above example code, the operators are: {}, ( ) We do not consider func, a, and b as
operands, since these are part of the function definition.
ORGANISATION AND TEAM STRUCTURES
Usually every software development organisation handles several projects at any time. Software
organisations assign different teams of developers to handle different software projects. With regard to staff
organisation, there are two important issues—How is the organisation as a whole structured? And, how are the
individual project teams structured? There are a few standard ways in which software organisations and teams
can be structured.
Functional format
In the functional format, the development staff are divided based on the specific functional group to which they
belong to. This format has schematically.
The different projects borrow developers from various functional groups for specific phases of the
project and return them to the functional group upon the completion of the phase. As a result, different teams
of programmers from different functional groups perform different phases of a project. For example, one team
might do the requirements specification, another do the design, and so on. The partially completed product
passes from one team to another as the product evolves

Project format
In the project format, the development staff are divided based on the project for which they work.A set
of developers is assigned to every project at the start of the project, and remain with the project till the
completion of the project. Thus, the same team carries out all the life cycle activities. An advantage of the
project format is that it provides job rotation. That is, every developer undertakes different life cycle activities
in a project. However, it results in poor manpower utilisation, since the full project team is formed
 Figure: Schematic representation of the functional and project organisation.

Matrix format
A matrix organisation is intended to provide the advantages of both functional and project structures.
In a matrix organisation, the pool of functional specialists are assigned to different projects as needed.

Figure: Matrix organisation.

STAFFING
Software project managers usually take the responsibility of choosing their team. Therefore, they need
to identify good software developers for the success of the project. A common misconception held by managers
as evidenced in their staffing, planning and scheduling practices, is the assumption that one software engineer
is as productive as another. H owever, experiments have revealed that there exists a large variability of
productivity between the worst and the best software developers in a scale of 1 to 30. In fact, the worst
developers may sometimes even reduce the overall productivity of the team, and thus in effect exhibit negative
productivity. Therefore, choosing good software developers is crucial to the success of a project.