SE Software Engineering UNIT-1
SE Software Engineering UNIT-1
1 Software Engineering
The term software engineering is the product of two words, software, and engineering. The software is
a collection of integrated programs. Software consists of carefully-organized instructions and code
written by developers on any of various particular computer languages. Computer programs and
related documentation such as requirements, design models and user manuals. Engineering is the
application of scientific and practical knowledge to invent, design, build, maintain, and improve
frameworks, processes, etc.
Software Engineering is an engineering branch related to the evolution of software product using well-
defined scientific principles, techniques, and procedures. The result of software engineering is an
effective and reliable software product.
The necessity of software engineering appears because of a higher rate of progress in user
requirements and the environment on which the program is working.
o Huge Programming: It is simpler to manufacture a wall than to a house or building, similarly,
as the measure of programming become extensive engineering has to step to give it a scientific
process.
o Adaptability: If the software procedure were not based on scientific and engineering ideas, it
would be simpler to re-create new software than to scale an existing one.
o Cost: As the hardware industry has demonstrated its skills and huge manufacturing has let
down the cost of computer and electronic hardware. But the cost of programming remains high
if the proper process is not adapted.
o Dynamic Nature: The continually growing and adapting nature of programming hugely
depends upon the environment in which the client works. If the quality of the software is
continually changing, new upgrades need to be done in the existing one.
o Quality Management: Better procedure of software development provides a better and quality
software product.
There are three components of the software: These are: Program, Documentation, and Operating
Procedures.
Program –A computer program is a list of instructions that tell a computer what to do.
Documentation – Source information about the product contained in design documents,
detailed code comments, etc.
Operating Procedures –Set of step-by-step instructions compiled by an organization to help
workers carry out complex routine operations.
Code: the instructions that a computer executes in order to perform a specific task or set of
tasks.
Data: the information that the software uses or manipulates.
User interface: the means by which the user interacts with the software, such as buttons,
menus, and text fields.
Libraries: pre-written code that can be reused by the software to perform common tasks.
Documentation: information that explains how to use and maintain the software, such as user
manuals and technical guides.
Test cases: a set of inputs, execution conditions, and expected outputs that are used to test the
software for correctness and reliability.
Configuration files: files that contain settings and parameters that are used to configure the
software to run in a specific environment.
Build and deployment scripts: scripts or tools that are used to build, package, and deploy the
software to different environments.
Metadata: information about the software, such as version numbers, authors, and copyright
information.
An engineer’s first consideration when creating any kind of software product is, “What are the
characteristics of a good software product?” Well before we talk about Software characteristics, let’s
look at what one can reasonably expect from any software. First and foremost, a software product
must satisfy the needs of the end-user as well as the business. Additionally, software development and
maintenance should be affordable. Software development should be completed within the specified
time frame.
1. Operational: In operational categories, the factors that decide the software performance in
operations. It can be measured on:
Budget
Usability
Efficiency
Correctness
Functionality
Dependability
Security
Safety
2. Transitional: When the software is moved from one platform to another, the factors deciding the
software quality:
Portability
Interoperability
Reusability
Adaptability
3. Maintenance: In this categories all factors are included that describes about how well a software has
the capabilities to maintain itself in the ever changing environment:
Modularity
Maintainability
Flexibility
Scalability
a. Functionality: The software meets the requirements and specifications that it was designed for,
and it behaves as expected when it is used in its intended environment.
b. Usability: The software is easy to use and understand, and it provides a positive user
experience.
c. Reliability: The software is free of defects and it performs consistently and accurately under
different conditions and scenarios.
d. Performance: The software runs efficiently and quickly, and it can handle large amounts of
data or traffic.
e. Security: The software is protected against unauthorized access and it keeps the data and
functions safe from malicious attacks.
f. Maintainability: The software is easy to change and update, and it is well-documented, so that
it can be understood and modified by other developers.
g. Reusability: The software can be reused in other projects or applications, and it is designed in a
way that promotes code reuse.
h. Scalability: The software can handle an increasing workload and it can be easily extended to
meet the changing requirements.
i. Testability: The software is designed in a way that makes it easy to test and validate, and it has
a comprehensive test coverage.
OR
o Functionality: The functionality of software refers to its ability to perform and function
according to design specifications. In simple terms, software systems should function correctly,
i.e. perform all the functions for which they are designed. The functions refer to the features
that the end user, as well as the business, expect as basic facilities from the system. All these
functions must be integrated into the system. Many software applications out there are
designed for simplicity, but ultimately, the purpose of the software is to provide its users with
the desired functionality. In order to look like the best software product, it must have a clear
appearance, components, and functions. However, there are also those products out there that
can provide a great deal of value for your money.
o Efficiency: Essentially, it refers to the software’s ability to utilize human and system resources
such as time, effort, CPU, memory, computation power, network bandwidth, files, databases,
etc., as effectively and efficiently as possible. For a software project to succeed, efficiency is
crucial. In addition to meeting the needs for which the software was made, it must also provide
excellent features designed to assist users in completing their tasks faster. Software should
make efficient use of storage space and execute commands according to timing requirements.
In order to be efficient, software must offer users proper value in terms of their time and cash.
The market is filled with products that cater to various industries, but only a handful of
products are efficient enough to benefit individuals and businesses. The medical billing
software that Open Practice Solutions provides, for instance, makes billing processes much
more efficient for clients than those offered by other companies.
o Flexibility: Software Flexibility refers to the ability of the software solution to adapt to
potential or future changes in its requirements. When evaluating the flexibility of software,
look at how simple it is to add, modify, or remove features without interfering with the current
operation. It is essential to keep up with rapidly changing markets, technologies, and customer
needs. In software development, change is inevitable; it can arise during the development
process itself or as the result of future requirements. Flexibility is therefore highly valued.
Consequently, any software product must be scalable, flexible, and easily adaptable to future
technology. When designing or building a software product, be sure to plan for these changes
that are inevitably going to occur. Loose coupling of components is the key to creating highly
flexible systems.
o Reliability: The reliability of a software product describes the likelihood it will operate without
failure over a specified period of time under certain conditions. It determines the ability of
software to maintain its level of performance (provide desired functionality) under specified
conditions for a specified period of time. Generally speaking, software reliability is measured
as the availability of the software. The value should not be less than 99%. In reliability testing,
the goal is not perfection, but achieving a level of reliability that is acceptable before a software
product is released to customers. MTTF, MTTR, MTBR, etc., are some reliability metrics that
can be used to quantify the reliability of a software product. It is regarded as one of the most
important quality aspects of software quality, along with functionality, efficiency,
maintainability, etc. Since software tends to be complex, it is hard to achieve software
reliability.
o Maintainability: Maintainability refers to how easily you can repair, improve and comprehend
software code. In some ways, maintaining is similar to being flexible. Maintainability deals
with the modification of errors and minor alterations to software code, while flexibility focuses
on major functional extensions. It also involves maintaining the services and functionality of
the software. Most of the time, developers are not the ones who maintain the software.
Therefore, good documentation is crucial, which includes code documentation, interface
definitions, etc. The maintainability of software products is affected by the quality of the
documentation. Typically, more than half of development budgets are spent on software
maintenance. Maintenance should therefore be integrated into the development lifecycle for
effective software maintenance.
o Portability: Software portability is a critical factor that cannot be ignored. Portability refers to
the ability to use software in different environments. This is the ease with which software can
be ported from one platform to another without (or with minimal) changes, while obtaining
similar results. As simple as it may sound, it refers to the ability of software to work on
different hardware platforms without any (or little) modifications needed. Furthermore, you
should be aware that porting software to a new environment is comparatively cheaper than
developing an equivalent application from scratch. There can be no doubt that portability is a
crucial aspect of reducing development costs.
o Integrity: There are multiple interpretations of software integrity. Some people tend to
associate integrity with security, believing it is resistant to hacks and privacy violations. To
others, high integrity means that the software cannot be modified without authorization.
Integrity is key for demonstrating the safety, security, and maintainability of your software. In
addition, software that needs to be compliant with industry regulations and coding standards
requires high code integrity. Achieving software integrity can be difficult. Yet, with the right
practices to improve safety, security, and maintainability, the challenge can be easily
overcome. In these days of increased security threats, all software must include this factor.
2 Software Crisis
Software Crisis is a term used in computer science for the difficulty of writing useful and efficient
computer programs in the required time. The software crisis was due to using the same workforce,
same methods, same tools even though rapidly increasing in software demand, the complexity of
software, and software challenges. With the increase in the complexity of software, many software
problems arise because existing methods were insufficient. If we will use the same workforce, same
methods, and same tools after the fast increase in software demand, software complexity, and
software challenges, then there arise some problems like software budget problems, software
efficiency problems, software quality problems, software managing and delivering problem, etc.
This condition is called a software crisis.
Causes of Software Crisis:
The cost of owning and maintaining software was as expensive as developing the software
At that time Projects were running over-time
At that time Software was very inefficient
The quality of the software was low quality
Software often did not meet user requirements
The average software project overshoots its schedule by half
At that time Software was never delivered
Non-optimal resource utilization.
Difficult to alter, debug, and enhance.
The software complexity is harder to change.
Poor project management.
Lack of adequate training in software engineering.
Less skilled project members.
Low productivity improvements.
Solution of Software Crisis: There is no single solution to the crisis. One possible solution to a
software crisis is Software Engineering because software engineering is a systematic, disciplined,
and quantifiable approach. For preventing software crises, there are some guidelines:
Reduction in software over budget.
The quality of software must be high.
Less time is needed for a software project.
Experienced and skilled people working over the software project.
Software must be delivered.
Software must meet user requirements.
3 Software Processes
Software is the set of instructions in the form of programs to govern the computer system and to
process the hardware components. To produce a software product the set of activities is used. This
set is called a software process.
A software process model is an abstraction of the actual process, which is being described. It can
also be defined as a simplified representation of a software process. Each model represents a process
from a specific perspective. Basic software process models on which different type of software
process models can be implemented:
A workflow Model – It is the sequential series of tasks and decisions that make up a
business process.
The Waterfall Model – It is a sequential design process in which progress is seen as flowing
steadily downwards. Phases in waterfall model:
i. Requirements Specification
ii. Software Design
iii. Implementation
iv. Testing
Dataflow Model – It is diagrammatic representation of the flow and exchange of information
within a system.
Evolutionary Development Model – Following activities are considered in this method:
i. Specification
ii. Development
iii. Validation
Role / Action Model – Roles of the people involved in the software process and the activities.
Software Process Framework details the steps and chronological order of a process. Since it serves as a
foundation for them, it is utilized in most applications. Task sets, umbrella activities, and process
framework activities all define the characteristics of the software development process. Software
Process includes:
1. Tasks: They focus on a small, specific objective.
2. Action: It is a set of tasks that produce a major work product.
3. Activities: Activities are groups of related tasks and actions for a major objective.
The process framework is required for representing common process activities. Five framework
activities are described in a process framework for software engineering. Communication, planning,
modeling, construction, and deployment are all examples of framework activities. Each engineering
action defined by a framework activity comprises a list of needed work outputs, project milestones,
and software quality assurance (SQA) points.
o Communication: By communication, customer requirement gathering is done. Communication
with consumers and stakeholders to determine the system’s objectives and the software’s
requirements.
o Planning: Establish engineering work plan, describes technical risk, lists resources requirements,
work produced and defines work schedule.
o Modeling: Architectural models and design to better understand the problem and to work towards
the best solution. The software model is prepared by:
o Construction: Creating code, testing the system, fixing bugs, and confirming that all criteria are
met. The software design is mapped into a code by:
o Umbrella Activities: Umbrella Activities are that take place during a software development
process for improved project management and tracking.
o Software project tracking and control: This is an activity in which the team can assess
progress and take corrective action to maintain the schedule. Take action to keep the
project on time by comparing the project’s progress against the plan.
o Risk management: The risks that may affect project outcomes or quality can be
analyzed. Analyze potential risks that may have an impact on the software product’s
quality and outcome.
o Software quality assurance: These are activities required to maintain software quality.
Perform actions to ensure the product’s quality.
o Formal technical reviews: It is required to assess engineering work products to uncover
and remove errors before they propagate to the next activity. At each level of the
process, errors are evaluated and fixed.
o Software configuration management: Managing of configuration process when any
change in the software occurs.
o Work product preparation and production: The activities to create models, documents,
logs, forms, and lists are carried out.
o Reusability management: It defines criteria for work product reuse. Reusable work
items should be backed up, and reusable software components should be achieved.
o Measurement: In this activity, the process can be defined and collected. Also, project
and product measures are used to assist the software team in delivering the required
software.
Software Engineering Process: Software Engineering Process is an engineering process that is mainly
related to computers and programming and developing different kinds of applications through the use
of information technology.
Another example is also that of a product that will have everything that the users need but has an
associate degree virtually incomprehensible and not maintainable code. Therefore, the normal
construct of quality as “fitness of purpose” for code merchandise isn’t satisfactory.
Factors of Software Quality: The modern read of high-quality associates with software many quality
factors like the following:
A 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. It also captures the structure in which these methods are to
be undertaken.
In other words, a life cycle model maps the various activities performed on a software product from its
inception to retirement. Different life cycle models may plan the necessary development activities to
phases in different ways. Thus, no element which life cycle model is followed, the essential activities
are contained in all life cycle models though the action may be carried out in distinct orders in
different life cycle models. During any life cycle stage, more than one activity may also be carried out.
SDLC Cycle represents the process of developing software. SDLC framework includes the following
steps:
Requirement Analysis is the most important and necessary stage in SDLC. The senior members of the
team perform it with inputs from all the stakeholders and domain experts or SMEs in the industry.
Planning for the quality assurance requirements and identifications of the risks associated with the
projects is also done at this stage. Business analyst and Project organizer set up a meeting with the
client to gather all the data like what the customer wants to build, who will be the end user, what is the
objective of the product. Before creating a product, a core understanding or knowledge of the product
is very necessary.
For Example, A client wants to have an application which concerns money transactions. In this
method, the requirement has to be precise like what kind of operations will be done, how it will be
done, in which currency it will be done, etc.
Once the required function is done, an analysis is complete with auditing the feasibility of the growth
of a product. In case of any ambiguity, a signal is set up for further discussion. Once the requirement is
understood, the SRS (Software Requirement Specification) document is created. The developers
should thoroughly follow this document and also should be reviewed by the customer for future
reference.
Once the requirement analysis is done, the next stage is to certainly represent and document the
software requirements and get them accepted from the project stakeholders. This is accomplished
through "SRS"- Software Requirement Specification document which contains all the product
requirements to be constructed and developed during the project life cycle.
The next phase is about to bring down all the knowledge of requirements, analysis, and design of the
software project. This phase is the product of the last two, like inputs from the customer and
requirement gathering.
In this phase of SDLC, the actual development begins, and the programming is built. The
implementation of design begins concerning writing code. Developers have to follow the coding
guidelines described by their management and programming tools like compilers, interpreters,
debuggers, etc. are used to develop and implement the code.
Stage5: Testing
After the code is generated, it is tested against the requirements to make sure that the products are
solving the needs addressed and gathered during the requirements stage. During this stage, unit testing,
integration testing, system testing, acceptance testing are done.
Stage6: Deployment
Once the software is certified, and no bugs or errors are stated, then it is deployed. Then based on the
assessment, the software may be released as it is or with suggested enhancement in the object segment.
After the software is deployed, then its maintenance begins.
Stage7: Maintenance
Once when the client starts using the developed systems, then the real issues come up and
requirements to be solved from time to time. This procedure where the care is taken for the developed
product is known as maintenance.
Winston Royce introduced the Waterfall Model in 1970.This model has five phases: Requirements
analysis and specification, design, implementation, and unit testing, integration and system testing, and
operation and maintenance. The steps always follow in this order and do not overlap. The developer
must complete every phase before the next phase begins. This model is named "Waterfall Model",
because its diagrammatic representation resembles a cascade of waterfalls.
Step 1. Requirements analysis and specification phase: The aim of this phase is to understand the
exact requirements of the customer and to document them properly. Both the customer and the
software developer work together so as to document all the functions, performance, and interfacing
requirement of the software. It describes the "what" of the system to be produced and not "how”. In
this phase, a large document called Software Requirement Specification (SRS) document is created
which contained a detailed description of what the system will do in the common language.
Step 2. Design Phase: This phase aims to transform the requirements gathered in the SRS into a
suitable form which permits further coding in a programming language. It defines the overall software
architecture together with high level and detailed design. All this work is documented as a Software
Design Document (SDD).
Step 3. Implementation and unit testing: During this phase, design is implemented. If the SDD is
complete, the implementation or coding phase proceeds smoothly, because all the information needed
by software developers is contained in the SDD.4 Pro is FINALLY Getting This Killer Feature!
During testing, the code is thoroughly examined and modified. Small modules are tested in isolation
initially. After that these modules are tested by writing some overhead code to check the interaction
between these modules and the flow of intermediate output.
Step 4. Integration and System Testing: This phase is highly crucial as the quality of the end
product is determined by the effectiveness of the testing carried out. The better output will lead to
satisfied customers, lower maintenance costs, and accurate results. Unit testing determines the
efficiency of individual modules. However, in this phase, the modules are tested for their interactions
with each other and with the system.
Step 5. Operation and maintenance phase: Maintenance is the task performed by every user once
the software has been delivered to the customer, installed, and operational.
Some Circumstances where the use of the Waterfall model is most suited are:
o When the requirements are constant and not changed regularly.
o A project is short
o The situation is calm
o Where the tools and technology used is consistent and is not changing
o When resources are well prepared and are available to use.
The prototype model requires that before carrying out the development of actual software, a working
prototype of the system should be built. A prototype is a toy implementation of the system. A
prototype usually turns out to be a very crude version of the actual system, possible exhibiting limited
functional capabilities, low reliability, and inefficient performance as compared to actual software. In
many instances, the client only has a general view of what is expected from the software product. In
such a scenario where there is an absence of detailed information regarding the input to the system, the
processing needs, and the output requirement, the prototyping model may be employed.
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 their expectation from the system is.
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: Refine requirement incorporation customer suggestion- 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: Customer evaluation of 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: Acceptance by customer- Once the user is satisfied with the re-developed prototype, only
then the final system is start developing based on the approved final prototype.
Advantages:
In evolutionary model, a user gets a chance to experiment partially developed system.
It reduces the error because the core modules get tested thoroughly.
Disadvantages:
Sometimes it is hard to divide the problem into several versions that would be acceptable to the
customer which can be incrementally implemented and delivered.
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. It implements the potential for rapid development of new versions of the software. Using the
spiral model, the software is developed in a series of incremental releases. During the early iterations,
the additional release may be a paper model or prototype. During later iterations, more and more
complete versions of the engineered system are produced.
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.
The risk-driven feature of the spiral model allows it to accommodate any mixture of a specification-
oriented, prototype-oriented, simulation-oriented, or another type of approach. An essential element of
the model is that each period of the spiral is completed by a review that includes all the products
developed during that cycle, including plans for the next cycle. The spiral model works for
development as well as enhancement projects.
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.
Software development uses a dynamic and adaptable method called the iterative enhancement Model.
The iterative enhancement model encourages a software product’s ongoing evolution and
improvement. This methodology is noticeable due to its concentration on adaptability, flexibility and
change responsiveness. It makes it easier for a product to evolve because it gives developers the
freedom to progressively enhance the software, making sure that it complies with evolving
specifications, user demands, and market demands. This helps products evolve more easily.
The Iterative Enhancement Model creates an environment where development teams can more
effectively adjust to changing requirements by segmenting the software development process into
smaller, more manageable parts. Every iteration improves on the one before it, adding new features
and fixing problems found in earlier stages. Members of the team, stakeholders and end users are
encouraged to collaborate and communicate continuously to make sure the software meets changing
needs and expectations. Until the software is finished being built, the iteration process is carried out,
which involves giving the user the increments.
Mobile app developement: Updates and improvements are often needed for mobile apps to stay
current with new devices, operating system versions and user preferences. By using an iterative
process developers can release the beta versions of their apps, get user feedback and then
improve functionality of those iterations in future release.
Web Application Development: The requirements for developing web applications frequently
change as a result of shifting user demand and advancements in technology. The Iterative
Enhancement Model makes it possible to developed features incrementally and guaranteeing
that the application can be modified to satisfy changing user and market demands. In later
iterations it also makes it easier to incorporate new features based on input from users.
E-commerce Platforms: Developement in e-commerece field often involves constant updates.
Implementing an iterative approach enables the introduction of new functionality.
GOOD LUCK….