Software Engineering: It 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.Software
Engineering combines two concepts, Software and Engineering.
Software
Software is set of executed programs related to specific functionality. Set of executable
instructions is called a program.
Software is more than just a program code; it also includes data structures which allow
programs to manipulate information, and documentation related to software products which
defines the functionality and guidance for the user to use this software. Software engineers
design and build the software product.
Software Components
What is Software
Program: A step by step instructions to perform a specific task on a computer in a programming
language is called program, i.e. set of instructions.
Software: Is a program along with proper documentation (requirement analysis, design, coding,
testing) and user manuals which mainly includes installation guide and other manuals,
Software Program + documentation
Engineering
-Engineering is an application of knowledge and well defined principles to develop products.
Software Engineering
Definition 1
Software Engineering is the method of applying scientific and technological knowledge,
procedures, and rules to design, develop, and maintain the software product.
OR
Definition 2
Applying technological, scientific, and administrative approach to designing, developing,
testing, and maintaining the software product in order to meet customers' requirements
with best quality of product referred as software Engineering.
Software Engineering processes are composed of many activities, notably the following:
Requirements Analysis
Specification
Software architecture
Implementation
Testing
Documentation
Training and Support
Maintenance
Software Characteristics
Correctness: The ability of the software to perform its intended tasks effectively and meet user
requirements.
Usability: The ease with which users can learn, operate, and navigate the software.
Reliability: The software's consistency in producing accurate results and maintaining
performance over time.
Efficiency: The optimal use of system resources, such as memory and processing power, to
achieve desired outcomes.
Maintainability: The ease of updating, modifying, and fixing the software to accommodate
changing requirements or fix issues.
Portability: The ability of the software to operate on different platforms or environments without
significant modifications.
Scalability: The software's capacity to handle increased workloads or user demands without
compromising performance.
Security: The software's ability to protect against unauthorized access, data breaches, and
other potential threats.
Modularity: The degree to which the software's components are organized into separate,
manageable units that can be independently developed or updated.
Reusability: The potential for the software's components to be used in other applications or
contexts, reducing development time and costs.
Testability: The ease with which the software can be tested to ensure it meets its requirements
and performs as expected
The characteristics of software decide whether the software is good or bad.
Understandability
Software should be easy to understand
It should be efficient to use.
Cost
Software should be cost effective as per its usage.
Maintainability
Software should be easily maintainable and modifiable in future.
Modularity
Software should have modular approach so it can be handled easily for testing.
Functionality
Software should be functionally capable to meet user requirements.
Reliability
It should have the capability to provide failure-free service.
Portability
Software should have the capability to be adapted for different environments.
Correctness
Software should be correct as per its requirements.
Documentation
Software should be properly documented so that we can re-refer it in future.
Reusability
It should be reusable, or its code or logic should be reusable in future.
Interoperability
Software should be able to communicate with various devices using standard bus structure
and protocol.
Programmes v/s Software product
Programmes: A computer program is a sequence of instructions, written to perform a specified
task with a computer.
Software program: A collection of computer programs and related data is referred to as
software.
There are three basic entities which are generally used while defining the principles of software
engineering are –
1. Software process
2. Software projects
3. Software products
Difference between programmes and software product
Program Software product
Programmes are developed by Software products are developed by
individuals. multiple users.
Programmes are smaller in size. Software products are extremely
large in size.
Programmes are set of instructions In software products, most users are
for computer to perform a specified not involved with development.
task. Software products must be well
documented.
In case of programmes, programmer
himself is the sole user.
In programmes, very little
documentation is required.
Software product is merchandise
consisting of a computer program
that is offered to sale.
Programs Vs Software Products:
Program: Program is a set of instructions or commands that a computer follow in order to
perform a specific task or functions. It is written in a certain Programming Language. For
example: Microsoft Exel, Word, Web browsers, Video games etc. as t example of program
Software Product: It contains different programs on a computer. It is set of
instructions and its documentations to perform a specific task. Softwares products are big in size
, such as applications and operating systems. They are used to perform an End to End
application. For example Microsoft Office is a software product. It consists of different programs.
Program Software products
They are usually small in size: They are large in size.
Can be developed by a single developer. Team of developers required.
Do not have a proper user interface. Have a user interface.
A program cannot be a software. A software can be a program.
Size varies from kilobytes (Kb) to Mega Size varies from megabytes (Mb) to
bytes (Mb) gigabytes (Gb).
It takes less time to develop.
It takes more time to develop.
Functionality of a program depends on the Functionality of software depends on the
compiler. operating system.
There are less no. of code line in a program.
There are a very large number of code lines
There is no proper documentation for a in software products.
programme.
For software program there is proper
Functionality of a programme is up to a very documentation and also user manual
limited extent. provided
It provides a large scale functionality
Need of Software Engineering
1. Handling Big Projects: Corporations must use SE to handle large projects without any
issues.
2. To manage the cost: Software engineering programmers plan everything and reduce all
those things that are not required.
3. To decrease time: It will save a lot of time if you are developing software using a software
engineering technique.
4. Reliable software: It is the company's responsibility to deliver software products on schedule
and to address any defects that may exist.
5. Effectiveness: Effectiveness results from things being created in accordance with the
software standards.
SDLC stands for Software Development Life Cycle. A Software Development Life Cycle is
essentially a series of steps, or phases, that provide a model for the development and lifecycle
management of an application or piece of software.
PHASES OF SDLC
Software life cycle models describe phases of the software cycle and the order in which those
phases are
executed. Each phase produces deliverables required by the next phase in the life cycle.
Requirements are
translated into design. Code is produced according to the design which is called the
development phase. After
coding and development the testing verifies the deliverable of the implementation phase against
requirements.
The basic activities or phases to be performed for developing software system are-
Determination of System’s Requirements
Design of system
Development (coding) of software
System Testing
Waterfall Model is the primitive model in software engineering that evolved with time, putting
together all the phases in natural sequence.
Phases of Waterfall Model:
The phases of the waterfall model are as follows:
Requirement Phase: It consists of extensive user participation and ends with an approved set of
requirements documented called SRS.
Design Phase: It works as a bridge between user wants and code that will be created to satisfy
the requirement.
Construction Phase: According to design and requirement coding is implemented. This phase
consists of a large team.
Testing Phase: After the construction testing phase is started. It involves the lowest component
testing, then the testing of a group of components & then the whole system is tested and finally,
acceptance testing is done to validate that the system fulfills user requirements or not.
Deployment Phase: After the testing on this phase the user training, installation of the system
are done.
Operation & Maintenance Phase: This Phase helps to make the system more updated and also
helps to reduce the defects if generated in the system.
Advantages of Model :
The model has well-defined phases with well-defined output.
It recognizes the sequence of software engineering activities in a software product.
It is simple and easy to execute.
This model is intuitive and logical.
Disadvantages of Waterfall Model:
The Cycle time of this model is very long.
In this model, there is no user feedback.
The approach is very simple.
The model assumes that requirements as clearly specified at a beginning of the project the
model have no mechanism to handle changes to the phases once implemented.
Types of projects in which model is used:
Short duration projects are taken to implement this model.
Projects which require automation of adjusting manual systems are implemented by this model.
The projects which have well understood problems are implemented using this model.
Spiral Model is developed by Barry Boehm. Its emphasis is on a continuous reassessment of
the risks and combining iterative and sequential approaches. Due to continuous emphasis on
risk analysis this model is relevant to the realities of software development
A risk is an unexpected consequence that could endanger the successful execution of a
software project. This risk can be reduced by establishing an access subsystem prototype and
experimenting with the exact access rate. This model provides direct help dealing with risks by
enabling the establishment of a prototype at every stage of the software development.
Phases of Model:
This model is divided into four phases or quadrants which are as:
Quadrant 1:
Features of the product are identified on the difficulty of the risk.
Identified features are implemented and form the objective of the phase.
Objectives are investigated, elaborated, and analyzed.
Possible alternative solutions are proposed.
Quadrant 2:
By developing an appropriate prototype best possible alternative solutions are evaluated.
Quadrant 3:
Developing and verifying the next level of the product.
Identified features are implemented and the next version of the product is available.
Quadrant 4:
Reviewing the result of stages traversed far with the customer and planning the next iteration
along the spiral
Different Features of the product can be developed simultaneously to make the model more
efficient,
Advantages of Model:
For Variety of Situations model is very flexible such as reuse, component-based development,
and prototyping.
For every spiral risk analysis is performed as it is an integral part of the life cycle which leads to
an increase in confidence in the project.
Disadvantages of Spiral Model:
Knowledgeable and experienced staff is required.
For developers, it is a more complicated and risk-driven model.
When to Use Spiral Model:
The spiral model is well suited to the development of technically complex projects.
It’s useful when risks are harder to know at the beginning of a project but are probably to arise
as the work proceeds.
The iterative enhancement model in software engineering combines elements of the linear
sequential model with the iterative philosophy of prototyping. In this model, the software is
broken down into several modules which are incrementally developed and delivered. Firstly, the
development team develops the core module of the system. After that, it is refined into
increasing levels of capacity of adding new functionalities in successive versions.
When it is used the first increment is often a core product i.e basic requirements are addressed
but many supplementary features are undelivered. The core product is used by the customers.
As a result of use or evaluation, a plan is developed for the next increment. The plan addresses
the modification of the core product to meet the needs of customers, and the delivery of
additional features and functionality. This process is repeated following each
delivery of increment until the complete product is produced.
Advantages of Iterative Enhancement Model:
The feedback from early increments improves the later stages.
The possibility of changes in requirement is reduced due to the shorter time span between the
design component and its delivery.
Users get benefits earlier than the conventional approach.
Smaller sub-projects are easier to control and manage.
File priority features are incorporated in early deliverables.
Disadvantage of Model:
Programmers may be more productive working on one large system than on the series.
The development cost of the total product is higher.
The time period for the delivery o jif the entire functionality is higher.
Planning of delivery increments is critical to success.
Wrong planning results to diaster.
When to Use Iterative Model:
Model is used where risk of long project can not be taken.
This model is for businesses where time is of essence.
The agile model was proposed in the mid-1990s to overcome the existing faults in the waterfall
development methodology. The agile model was established to support a project with rapidly
responds to changing needs. It places a higher emphasis on face-to-face contact than on
written documentation. The development team should be intentionally kept small (5–9 persons)
to allow team members to effectively engage in face-to-face contact and work in a cooperative
way. As a result, it should come as no surprise that the agile methodology is well suited to the
development of small projects. However, if a big project must be developed applying the agile
model, the collaborating teams are likely to be located in different places. In this instance, the
various teams must keep as much daily touch as possible by videoconferencing, telephone,
e-mail, and other means.
Principles of Agile Model Manifesto :
Working software prioritizes official documentation.
Frequent distribution to the customer of incremental versions of the software at intervals of a
few weeks.
Customer requests for requirement changes are welcomed and immediately executed.
Effective contract negotiation is regarded as far less important than continuous interaction with
the client.
Face-to-face communication, rather than the exchange of formal documentation, is suggested
as a means of improving communication among development team members.
Advantage of Model:
The agility of agile methodologies is derived in part from the team members’ tacit understanding
of the development project.
Rather to spending considerable amounts of time preparing formal documents and analyzing
them, informal communications are utilized to assess situations.
Disadvantage of Model:
Because there are no formal papers, there is a chance of crucial decisions made during different
phases will be misread by various team members at a later time.
It’s difficult to get important project decisions, such as design decisions, reviewed and controlled
by external professionals when there are no formal papers.
Maintenance might become a challenge once the project is completed and the developers have
moved.
Prototyping Model
The goal of a prototyping-based development process is to
counter the first limitation of the waterfall model.
In this, instead of freezing the requirements before design
or coding, a throwaway prototype is built to help understand
the requirements.
This prototype is developed based on the currently known
requirements.
Development of the prototype undergoes design, coding,
and testing phases.
By using this prototype, the client can better understand the
requirements of the desired system.
This results in more stable requirements that change less
frequently.
The development of the prototype starts when the
preliminary version of the requirements specification
document has been developed.
After the prototype has been developed, the end users and
clients are given an opportunity to use the prototype.
They provide feedback to the developers regarding the
prototype: what is correct, what needs to be modified, what is
missing, what is not needed, etc.
Based on the feedback, the prototype is modified, and the
users and the clients are again allowed to use the system.
This cycle repeats.
Prototype is a working physical system or subsystem.
Prototype is nothing but a tip implementation of a system.
In this model, before starting actual development, a working prototype of the system should be
built first.
A prototype is actually a partially developed product.
Compared to the actual software, a prototype usually have,
Limited functional capabilities
Low reliability
Inefficient performance
Prototype usually built using several shortcuts, and these shortcuts might be inefficient,
inaccurate or dummy functions.
Prototype model is very useful in developing the GUI part of the system.
In working of the prototype model, product development starts with initial requirements
gathering phase.
Then, a quick design is carried out and a prototype is built.
The developed prototype is then submitted to the customer for his evaluation.
Based on customer feedback, the requirements are refined and prototype is modified.
This cycle of obtaining customer feedback and modifying the prototype continues till the
customers approve the prototype.
The actual system is developed using different phases of iterative waterfall model.
Prototype Model – Advantages
A partial product is built at initial stage, so customers can get a chance to have a look of the
product.
New requirements can be accommodated easily.
Quicker user feedback is available for better solutions.
As the partial product is evaluated by the end users, more chance of user satisfaction.
Prototype Model – Disadvantages
The code for the prototype model is usually thrown way. So wasting time is there.
The construction cost of developing the prototype is very high.
If the end user is not satisfied with the initial prototype, then he/she may loose interest in the
final product.
Prototype Model – When to Use?
This model is used when the desired system needs to have a lot of interactions with end
users.
This type of model generally used in GUI type of development.
Software Components
Program
A program is a subset of software and it becomes software only if documentation and an
operating procedure manual are prepared.
Documents
Software documentation consist all the description, programs, graphics and instructions
pertaining to design, coding, testing and preparation of software.
Operating Procedure(User Manual & Operational Manual)
Provides information about what software is how to work with it how to install it on your system
and how to control all the activities of the software.
