Defining the given key terms:

Software Engineering:--
Software engineering is the branch of computer science that deals with the design, development, testing,
and maintenance of software applications. Software engineers apply engineering principles and
knowledge of programming languages to build software solutions for end users.
Software Development Life Cycle (SDLC):--
The software development lifecycle is the cost-effective and time-efficient process that development
teams use to design and build high-quality software. The goal of SDLC is to minimize project risks through
forward planning so that software meets customer expectations during production and beyond.
feasibility:
Feasibility study is one of stage among important four stages of Software Project Management Process. As
name suggests feasibility study is the feasibility analysis or it is a measure of the software product in terms
of how much beneficial product development will be for the organization in a practical point of view.
Types of feasibility:
The 5 types of feasibility study are Scheduling Feasibility, Operational Feasibility, Legal Feasibility,
Economic Feasibility, and Technical Feasibility.
Technical Feasibility: In Technical Feasibility current resources both hardware software along with required
technology are analyzed/assessed to develop project.
Operational Feasibility: In Operational Feasibility degree of providing service to requirements is analyzed
along with how much easy product will be to operate and maintenance after deployment.
Economic Feasibility: In Economic Feasibility study cost and benefit of the project is analyzed.
Legal Feasibility: In Legal Feasibility study project is analyzed in legality point of view.
Schedule Feasibility: In Schedule Feasibility Study mainly timelines/deadlines is analyzed for proposed
project which includes how many times teams will take to complete final project which has a great impact
on the organization as purpose of project may fail if it can’t be completed on time.
Cultural and Political Feasibility: This section assesses how the software project will affect the political
environment and organizational culture.
Requirements:
The phase in software development where senior team members collaborate with stakeholders and
domain experts to gather and analyze project requirements. It involves planning for quality assurance and
risk recognition, providing clarity on the project scope, anticipated challenges, opportunities, and
objectives. This stage ensures detailed and precise requirements are gathered, aiding in finalizing project
timelines.
Design:
The phase where system and software design documents align with requirements. It defines system
architecture and serves as input for subsequent stages. It includes two documents:
1. High Level Design (HLD): Outlines module names, functionality, interfaces, database tables, and
architecture diagrams.
2. Low Level Design (LLD): Details module logic, database tables, interfaces, error messages, and
inputs/outputs.

Testing:
The testing team validates the system's functionality against customer requirements, identifying bugs.
Developers rectify these bugs, and QA re-tests until the software is bug-free and aligned with business
needs.
Maintainance:
After system deployment, three key activities occur: bug fixing to address untested scenarios, upgrading to
newer software versions, and enhancing the software by adding new features.

Models:
Agile Model:
Agile methodology emphasizes continuous interaction between development and testing throughout the
Software Development Life Cycle (SDLC). Projects are divided into small incremental builds delivered in
iterations, typically lasting from one to three weeks.
RAD Model Definition:
The RAD Model, or Rapid Application Development model, is a software development process focused on
prototyping without detailed planning. It prioritizes development over planning, aiming to deliver
software quickly. Key phases include Business Modeling, Data Modeling, Process Modeling, Application
Generation, Testing, and Turnover.
Prescriptive Model Definition and Conclusion:
The Prescriptive Model earns its name from its approach of prescribing a defined set of activities, actions,
tasks, quality assurance measures, and change mechanisms for each project. This model offers structured
guidelines and procedures to ensure consistency and efficiency in project execution, enhancing project
management and control.
Incremental Model:
The Incremental Model involves building software akin to assembling LEGO bricks, adding one piece at a
time to create a larger structure. It entails developing and enhancing the software in small, iterative cycles
and phases, refining each part along the way. This approach offers benefits such as early results, flexibility
for changes, and reduced risk by catching issues sooner. However, it also presents challenges such as
coordination between parts, complexity in managing multiple components, and the need for thorough
planning. Examples of projects suited for the Incremental Model include software updates, building
complex systems in manageable chunks, and improving products based on customer feedback.
Evolutionary Development Model:
The Evolutionary Model compares to tending a garden, nurturing software to evolve and enhance
gradually. Prototyping plays a crucial role, offering a glimpse into the final product and facilitating iterative
refinement based on user feedback. Adaptability and flexibility are key features, allowing adjustments to
plans and accommodating new ideas and requirements. The Evolutionary Model finds use in exploring
new technologies, addressing evolving user needs, and tackling projects with uncertain requirements. In
summary, it embodies continuous improvement, user-centricity, and adaptiveness, akin to tending a
garden for optimal growth.
Spiral Model:
The Spiral Model is a risk-driven approach to software development, likened to ascending a spiral
staircase, where each turn represents revisiting and refining strategies to mitigate risks and uncertainties
throughout the project lifecycle.
V Model:
The V Model in software engineering is a visual representation that aligns development and testing
processes as two sides of a "V," progressing in parallel.

Summary:--
Lecture #1:
Software Engineering is the application of well-defined scientific principles and methods to develop
software products efficiently and reliably. It involves creating executable programming code, associated
libraries, and documentation to meet specific requirements, resulting in a software product.

Software Evolution refers to the process of developing a software product using software engineering
principles and methods, including initial development, maintenance, and updates, until the desired
software product meets expected requirements.

The software is divided into three categories:

1. Static-type (S-type): Strictly follows defined specifications and solutions, like a calculator program.
2. Practical-type (P-type): Consists of a collection of procedures, such as gaming software.
3. Embedded-type (E-type): Adapts closely to real-world requirements, experiencing high evolution due to
changes in laws and regulations, like online trading software.
Software Myths are false beliefs and misconceptions that arise during software development, causing
confusion among managers, users, and developers. Common myths include budget constraints, time
constraints, and quality improvements.

Software Quality Attributes are functionality, reliability, usability, efficiency, maintainability, and portability,
ensuring software meets stated and implied needs, provides failure-free service, is easy to understand and
use, performs well, is adaptable for modifications, and can function in various environments.

Principles of Software Engineering include managing using a phased life-cycle plan, continuous validation,
disciplined product control, modern programming practices, clear accountability for results, using better
and fewer people, and a commitment to process improvement.

Software Process involves four activities specification (requirements engineering), design and
implementation, verification and validation, and evolution (maintenance), leading to the production of
software through communication, planning, modeling, construction, and deployment.