What is Software Engineering?

Software Engineering is the process of designing, developing, testing, and maintaining software. It is a
systematic and disciplined approach to software development that aims to create high-quality, reliable,
and maintainable software.

1. Software engineering includes a variety of techniques, tools, and methodologies, including

requirements analysis, design, testing, and maintenance.

2. It is a rapidly evolving field, and new tools and technologies are constantly being developed to
improve the software development process.

3. By following the principles of software engineering and using the appropriate tools and
methodologies, software developers can create high-quality, reliable, and maintainable software
that meets the needs of its users.

4. Software Engineering is mainly used for large projects based on software systems rather than
single programs or applications.

5. The main goal of Software Engineering is to develop software applications for improving
quality, budget, and time efficiency.

6. Software Engineering ensures that the software that has to be built should be consistent, correct,
also on budget, on time, and within the required requirements.

Key Principles of Software Engineering

1. Modularity: Breaking the software into smaller, reusable components that can be developed and
tested independently.

2. Abstraction: Hiding the implementation details of a component and exposing only the necessary
functionality to other parts of the software.

3. Encapsulation: Wrapping up the data and functions of an object into a single unit, and protecting
the internal state of an object from external modifications.

4. Reusability: Creating components that can be used in multiple projects, which can save time and
resources.

5. Maintenance: Regularly updating and improving the software to fix bugs, add new features, and
address security vulnerabilities.

6. Testing: Verifying that the software meets its requirements and is free of bugs.

7. Design Patterns: Solving recurring problems in software design by providing templates for solving
them.

8. Agile methodologies: Using iterative and incremental development processes that focus on
customer satisfaction, rapid delivery, and flexibility.

9. Continuous Integration & Deployment: Continuously integrating the code changes and deploying
them into the production environment.
Main Attributes of Software Engineering

Software Engineering is a systematic, disciplined, quantifiable study and approach to the design,
development, operation, and maintenance of a software system. There are four main Attributes of
Software Engineering.

1. Efficiency: It provides a measure of the resource requirement of a software product in an efficient

way.

2. Reliability: It provides the assurance that the product will deliver the same results when used in
similar working environment.

3. Reusability: This attribute makes sure that the module can be used in multiple applications.

4. Maintainability: It is the ability of the software to be modified, repaired, or enhanced easily with
changing requirements.

Software Processes

The term software specifies to the set of computer programs, procedures and associated documents
(Flowcharts, manuals, etc.) that describe the program and how they are to be used.

A software process is the set of activities and associated outcome that produce a software product.
Software engineers mostly carry out these activities. These are four key process activities, which are
common to all software processes. These activities are:

1. Software specifications: The functionality of the software and constraints on its operation must
be defined.

2. Software development: The software to meet the requirement must be produced.

3. Software validation: The software must be validated to ensure that it does what the customer
wants.

4. Software evolution: The software must evolve to meet changing client needs.

The Software Process Model

A software process model is a specified definition of a software process, which is presented from a
particular perspective. Models, by their nature, are a simplification, so a software process model is an
abstraction of the actual process, which is being described. Process models may contain activities, which
are part of the software process, software product, and the roles of people involved in software
engineering. Some examples of the types of software process models that may be produced are:

1. A workflow model: This shows the series of activities in the process along with their inputs,
outputs and dependencies. The activities in this model perform human actions.

2. 2. A dataflow or activity model: This represents the process as a set of activities, each of which
carries out some data transformations. It shows how the input to the process, such as a
specification is converted to an output such as a design. The activities here may be at a lower level
 than activities in a workflow model. They may perform transformations carried out by people or
by computers.

3. 3. A role/action model: This means the roles of the people involved in the software process and
the activities for which they are responsible.

There are several various general models or paradigms of software development:

1. The waterfall approach: This takes the above activities and produces them as separate process
phases such as requirements specification, software design, implementation, testing, and so on.
After each stage is defined, it is "signed off" and development goes onto the following stage.

2. Evolutionary development: This method interleaves the activities of specification, development,

and validation. An initial system is rapidly developed from a very abstract specification.

3. Formal transformation: This method is based on producing a formal mathematical system

specification and transforming this specification, using mathematical methods to a program.
These transformations are 'correctness preserving.' This means that you can be sure that the
developed programs meet its specification.

4. System assembly from reusable components: This method assumes the parts of the system
already exist. The system development process target on integrating these parts rather than
developing them from scratch.

What is The Waterfall Model?

Waterfall Model is a sequential model that divides software development into pre-defined phases. Each
phase must be completed before the next phase can begin with no overlap between the phases. Each
phase is designed for performing specific activity during the SDLC phase. It was introduced in 1970 by
Winston Royce.
Different Phases of Waterfall Model in Software
Engineering
Following are the different Waterfall Model phases:

Different phases Activities performed in each stage

• During this phase, detailed requirements of the software system to be
Requirement
developed are gathered from client
Gathering stage
• Plan the programming language, for Example Java, PHP, .net
• or database like Oracle, MySQL, etc.
Design Stage
• Or other high-level technical details of the project

Built Stage After design stage, it is built stage, that is nothing but coding the software
In this phase, you test the software to verify that it is built as per the
Test Stage
specifications given by the client.
Deployment stage Deploy the application in the respective environment
Once your system is ready to use, you may later require change the code as per
Maintenance stage
customer request
 When to use SDLC Waterfall Model?

Waterfall Methodology can be used when:

• Requirements are not changing frequently

• Application is not complicated and big

• Project is short

• Requirement is clear

• Environment is stable

• Technology and tools used are not dynamic and is stable

• Resources are available and trained

tested, and refined as per customer
feedback repeatedly till a final
Advantages and Disadvantages of Waterfall Model
acceptable
Here are the popular advantages prototype
of Waterfall model in Software is disadvantages:
Engineering with some achieved
Advantages which forms Dis-Advantages the basis for developing
completed
the final product.
Before the next phase of development, each phase must be
Error can be fixed only during the phase

Suited for smaller projects where requirements are well It is not desirable for complex project where
defined requirement changes frequently

They should perform quality assurance test (Verification and Testing period comes quite late in the developmental
Validation) before completing each stage process

Elaborate documentation is done at every phase of the Documentation occupies a lot of time of developers
software’s development cycle and testers

Project is completely dependent on project team with Clients valuable feedback cannot be included with
minimum client intervention ongoing development phase

Any changes in software is made during the process of the Small changes or errors that arise in the completed
development software may cause a lot of problems

Prototype Model
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,

tested, and refined as per customer feedback

repeatedly till a final acceptable prototype is achieved
which forms the basis for developing the final product.
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.

Steps of Prototype Model

1. Requirement Gathering and Analyst

2. Quick Decision

3. Build a Prototype

4. Assessment or User Evaluation

5. Prototype Refinement

6. Engineer Product

Advantage of Prototype Model

1. Reduce the risk of incorrect user requirement

2. Good where requirement are changing/uncommitted

3. Regular visible process aids management

4. Support early product marketing

 5. Reduce Maintenance cost.

6. Errors can be detected much earlier as the system is made side by side.

Disadvantage of Prototype Model

1. An unstable/badly implemented prototype often becomes the final product.

2. Require extensive customer collaboration

o Costs customer money

o Needs committed customer

o Difficult to finish if customer withdraw

o May be too customer specific, no broad market

3. Difficult to know how long the project will last.

4. Easy to fall back into the code and fix without proper requirement analysis, design, customer
evaluation, and feedback.

5. Prototyping tools are expensive.

6. Special tools & techniques are required to build a prototype.

7. It is a time-consuming process.

Evolutionary Model
The evolutionary model is a combination of the Iterative and Incremental models of the software
development life cycle. Delivering your system in a big bang release, delivering it in incremental process
over time is the action done in this model. Some initial requirements and architecture envisioning need to
be done. It is better for software products that have their feature sets redefined during development
because of user feedback and other factors.

What is the Evolutionary Model?

The Evolutionary development model divides the development cycle into smaller, incremental waterfall
models in which users can get access to the product at the end of each cycle.

1. Feedback is provided by the users on the product for the planning stage of the next cycle and the
development team responds, often by changing the product, plan, or process.

2. Therefore, the software product evolves with time.

3. All the models have the disadvantage that the duration of time from the start of the project to the
delivery time of a solution is very high.

4. The evolutionary model solves this problem with a different approach.

 5. The evolutionary model suggests breaking down work into smaller chunks, prioritizing them, and
then delivering those chunks to the customer one by one.

6. The number of chunks is huge and is the number of deliveries made to the customer.

7. The main advantage is that the customer’s confidence increases as he constantly gets quantifiable
goods or services from the beginning of the project to verify and validate his requirements.

8. The model allows for changing requirements as well as all work is broken down into maintainable
work chunks.

Evolutionary Model

Application of Evolutionary Model

1. It is used in large projects where you can easily find modules for incremental implementation.
Evolutionary model is commonly used when the customer wants to start using the core features
instead of waiting for the full software.

2. Evolutionary model is also used in object oriented software development because the system can
be easily portioned into units in terms of objects.

Necessary Conditions for Implementing this Model

1. Customer needs are clear and been explained in deep to the developer team.

2. There might be small changes required in separate parts but not a major change.
 3. As it requires time, so there must be some time left for the market constraints.

4. Risk is high and continuous targets to achieve and report to customer repeatedly.

5. It is used when working on a technology is new and requires time to learn.

Advantages Evolutionary Model

1. In evolutionary model, a user gets a chance to experiment partially developed system.

2. It reduces the error because the core modules get tested thoroughly.

Disadvantages Evolutionary Model

1. 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.

What is RAD Model?

RAD Model or Rapid Application Development model is a software development process based on
prototyping without any specific planning. In RAD model, there is less attention paid to the planning and
more priority is given to the development tasks. It targets at developing software in a short span of time.

SDLC RAD modeling has following phases

• Business Modeling

• Data Modeling

• Process Modeling

• Application Generation

• Testing and Turnover

Different Phases of RAD Model

There are following five major phases of Rapid Application Development Model

RAD Model
Activities performed in RAD Modeling
Phases

Business On basis of the flow of information and distribution between various business channels,
Modeling the product is designed

The information collected from business modeling is refined into a set of data objects that
Data Modeling
are significant for the business

The data object that is declared in the data modeling phase is transformed to achieve the
Process Modeling
information flow necessary to implement a business function

Application Automated tools are used for the construction of the software, to convert process and data
Generation models into prototypes

Testing and As prototypes are individually tested during every iteration, the overall testing time is
Turnover reduced in RAD.

When to use RAD Methodology?

• When a system needs to be produced in a short span of time (2-3 months)

 • When the requirements are known

• When the user will be involved all through the life cycle

• When technical risk is less

• When there is a necessity to create a system that can be modularized in 2-3 months of time

• When a budget is high enough to afford designers for modeling along with the cost of automated
tools for code generation

Rapid Application Development Advantages and Disadvantages

Advantages of RAD Model Disadvantages of RAD Model

Flexible and adaptable to changes It can’t be used for smaller projects

It is useful when you have to reduce the overall

Not all application is compatible with RAD
project risk

It is adaptable and flexible to changes When technical risk is high, it is not suitable

It is easier to transfer deliverables as scripts, high-

If developers are not committed to delivering software on
level abstractions and intermediate codes are
time, RAD projects can fail
used

Due to code generators and code reuse, there is a Reduced features due to time boxing, where features are
reduction of manual coding pushed to a later version to finish a release in short period

Reduced scalability occurs because a RAD developed

Due to prototyping in nature, there is a possibility
application begins as a prototype and evolves into a finished
of lesser defects
application

Progress and problems accustomed are hard to track as such

Each phase in RAD delivers highest priority
there is no documentation to demonstrate what has been
functionality to client
done

With less people, productivity can be increased in

Requires highly skilled designers or developers
short time

Incremental Model
Incremental Model is a process of software development where requirements divided into multiple
standalone modules of the software development cycle. In this model, each module goes through the
requirements, design, implementation and testing phases. Every subsequent release of the module adds
function to the previous release. The process continues until the complete system achieved.
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.

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

When we use the Incremental Model?

o When the requirements are superior.

o A project has a lengthy development schedule.

o When Software team are not very well skilled or trained.

o When the customer demands a quick release of the product.

o You can develop prioritized requirements first.

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.

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.
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.

The Spiral Model is shown in fig:

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.

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.

When to use Spiral Model?

o When deliverance is required to be frequent.

o When the project is large

o When requirements are unclear and complex

o When changes may require at any time

o Large and high budget 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 project planning

Software project planning is a crucial phase in the development life cycle that involves defining the scope,
schedule, budget, and resources needed to successfully complete a software project. Effective planning
sets the foundation for a project's success by providing a roadmap for the development team and
stakeholders. Here are key aspects of software project planning:

1. Project Scope Definition:

• Clearly define the project's objectives, features, and deliverables. This involves
understanding the client's requirements and expectations.

• Create a detailed scope statement that outlines what the software will and will not
include.

2. Requirement Analysis:

• Identify and document detailed requirements. This involves understanding user needs,
system functionality, and any constraints.

• Engage stakeholders to gather input and validate requirements.

3. Resource Identification:
 • Determine the human, financial, and technological resources required for the project.

• Allocate roles and responsibilities to team members based on their skills and expertise.

4. Time Estimation:

• Break down the project into tasks and estimate the time required for each task.

• Create a realistic project timeline considering dependencies and potential risks.

5. Risk Assessment and Management:

• Identify potential risks and uncertainties that may impact the project.

• Develop mitigation strategies and contingency plans to address these risks.

6. Budgeting:

• Estimate the costs associated with the project, including labor, materials, and any external
services.

• Establish a budget and monitor expenses throughout the project.

7. Communication Plan:

• Define a communication plan that outlines how project information will be shared with
stakeholders.

• Establish regular communication channels to keep team members and stakeholders

informed.

8. Quality Assurance and Testing Strategy:

• Define the testing strategy and quality assurance processes to ensure that the software
meets the required standards.

• Plan for regular testing cycles and bug-fixing activities.

9. Change Management:

• Establish a process for handling changes to the project scope or requirements.

• Ensure that changes are documented, evaluated for impact, and approved before
implementation.

10. Monitoring and Control:

• Implement monitoring mechanisms to track project progress against the plan.

• Regularly review and update the project plan as necessary, taking into account any
changes in scope, schedule, or resources.

11. Documentation:
 • Maintain comprehensive documentation throughout the project life cycle, including the
project plan, requirements, design documents, and test plans.

12. Closure and Evaluation:

• Develop a plan for the closure of the project, including final testing, deployment, and
documentation.

• Conduct a project evaluation to identify lessons learned and areas for improvement in
future projects.

Effective software project planning requires a balance between flexibility and structure, adapting to
changes while maintaining control over the project's key elements. Regular reviews and updates to the
plan are essential for successful project execution.

Feasibility analysis

Feasibility analysis is a crucial step in the early stages of software project planning. It involves evaluating
the practicality and viability of a proposed project before investing significant resources. The analysis helps
stakeholders make informed decisions about whether to proceed with the project or not. Here are the key
components of feasibility analysis in software projects:

1. Technical Feasibility:

• Hardware and Software Requirements: Assess whether the existing hardware and
software infrastructure can support the proposed system. Determine if any additional
technology or upgrades are needed.

• Technology Compatibility: Evaluate the compatibility of the chosen technologies with the
existing systems and technologies in the organization.

• Technical Expertise: Analyze if the required technical skills are available within the team
or if additional training or hiring is necessary.

2. Operational Feasibility:

• Impact on Operations: Examine how the new system will affect current business
processes and operations. Consider potential disruptions during the transition period.

• User Acceptance: Assess the willingness of end-users to adopt the new system. Consider
factors such as user training, support, and resistance to change.

3. Economic Feasibility:

• Cost-Benefit Analysis: Calculate the estimated costs of developing and implementing the
software against the expected benefits. Consider both tangible (e.g., hardware, software,
training) and intangible (e.g., increased efficiency, customer satisfaction) costs and
benefits.
 • Return on Investment (ROI): Determine the financial returns expected from the project
and compare them to the initial investment. Ensure that the project aligns with the
organization's financial goals.

4. Schedule Feasibility:

• Project Timeline: Evaluate the proposed project schedule and deadlines. Consider any
dependencies, potential delays, and the overall time required for completion.

• Time-to-Market: Assess the urgency of delivering the software to the market and whether
the proposed timeline is aligned with business objectives.

5. Legal and Regulatory Feasibility:

• Compliance Requirements: Ensure that the project complies with relevant laws,
regulations, and industry standards. Identify any legal or regulatory constraints that may
impact the project.

• Intellectual Property: Evaluate the risk of infringement on existing patents, copyrights, or

trademarks. Address any legal issues related to intellectual property rights.

6. Risk Analysis:

• Identify Risks: Identify potential risks and uncertainties associated with the project. This
includes technical, operational, economic, and legal risks.

• Mitigation Strategies: Develop strategies to mitigate or manage identified risks. This may
involve contingency plans, risk mitigation measures, or alternative approaches.

A comprehensive feasibility analysis provides stakeholders with the information needed to make informed
decisions about whether to proceed with the software project. It also helps in setting realistic expectations
and identifying potential challenges early in the planning process.

Five-Mark Questions:

1. Question: What is Software Engineering, and why is it considered a systematic and disciplined
approach to software development?

2. Question: List and briefly explain three key principles of Software Engineering.

3. Question: Explain the significance of the Modularity principle in Software Engineering.

4. Question: How does the Agile methodology contribute to the principles of Software Engineering?

5. Question: What are the four main attributes of Software Engineering, and why are they essential
for the development of a software system?

6. Question: Briefly describe the activities involved in the software validation phase of the Software
Development Life Cycle (SDLC).
 7. Question: Differentiate between the Waterfall Model and the Incremental Model in software
development.

8. Question: What are the main phases in the Prototype Model, and how does it address the
challenges of software development?

9. Question: Explain the advantages and disadvantages of using the RAD Model in software
development.

10. Question: Why is continuous risk assessment and reduction crucial in the Spiral Model of software
development?

11. Question: In the context of software project planning, what role does change management play,
and why is it important?

12. Question: How does the Incremental Model address the challenges of software development,
especially in terms of flexibility and adaptability?

13. Question: Discuss the significance of the feasibility analysis phase in software project planning.

14. Question: Why is it essential to conduct a technical feasibility analysis before initiating a software
project?

15. Question: How does the operational feasibility analysis consider the impact of a new system on
existing business processes?

16. Question: In economic feasibility, what is the purpose of a cost-benefit analysis, and how is return
on investment (ROI) calculated?

17. Question: Explain the role of project timeline and time-to-market considerations in schedule
feasibility.

18. Question: What legal and regulatory factors should be considered in the legal feasibility analysis
of a software project?

19. Question: How can risks be identified and mitigated during the risk analysis phase of feasibility
analysis?

20. Question: Summarize the key benefits of conducting a comprehensive feasibility analysis before
initiating a software project.

Ten-Mark Questions:

1. Question: Compare and contrast the Waterfall Model and the Spiral Model in terms of their
advantages, disadvantages, and suitability for different types of projects.

2. Question: Explain the principles of modularity, abstraction, and encapsulation in Software

Engineering. Provide examples to illustrate each principle.

3. Question: Describe the key characteristics of the Agile methodology in software development.
How does Agile contribute to the iterative and incremental nature of the software development
process?
4. Question: Discuss the attributes of Software Engineering, namely efficiency, reliability, reusability,
and maintainability. Why are these attributes crucial for successful software development?

5. Question: Compare the Prototype Model and the RAD Model in software development. Highlight
their differences and similarities, and discuss situations where each model is most suitable.

6. Question: Elaborate on the various phases of the Incremental Model in software development.
How does this model address challenges related to project planning and execution?

7. Question: Evaluate the advantages and disadvantages of the Spiral Model in software
development. Discuss its application in large and high-budget projects.

8. Question: Explain the components of a comprehensive software project plan, including project
scope definition, resource identification, and quality assurance strategies.

9. Question: Discuss the role of feasibility analysis in software project planning. How does it help in
making informed decisions about whether to proceed with a project?

10. Question: Compare the economic feasibility analysis and the schedule feasibility analysis in
software project planning. How do these factors impact the overall success of a project?