Source: CS101 Lecture Notes, University of Central Florida
Tags: software engineering, SDLC, software development life cycle, waterfall, agile, iterative, requirements engineering, software design, software testing, unit testing, integration testing, system testing, software maintenance, software quality, reliability, maintainability, usability
Difficulty: Introductory Prerequisites: None. This is foundational material for computer science and software engineering courses.
Software engineering is the discipline that brings structure, predictability, and quality control to the process of building software. Rather than writing code and hoping for the best, software engineers follow defined processes, from gathering what users need, through designing and building a system, to testing and maintaining it after release. This topic sits at the very start of most CS programmes because every other course you take (algorithms, databases, operating systems) eventually feeds into the question: how do we build real software that works and lasts? If you have done any programming at all, you have the background you need.
Software engineering applies engineering principles to every stage of building software: figuring out what to build, designing it, coding it, testing it, and keeping it running. The software development life cycle (SDLC) is the framework that organises these stages, and it comes in several flavours (waterfall, agile, iterative). Quality is measured not just by whether the software works, but by how reliable, maintainable, and usable it is.
Software engineering
The systematic application of engineering principles to the design, development, testing, and maintenance of software. In simple terms, it is the practice of building software the way engineers build bridges: with planning, standards, and quality checks.
Software development life cycle (SDLC)
A structured process for developing software, consisting of defined stages: requirements gathering, design, implementation, testing, and maintenance. Think of it as the recipe that tells a team which step comes next and what each step should produce.
Waterfall model
An SDLC model where each phase (requirements, design, implementation, testing, maintenance) is completed fully before the next one begins. In simple terms, you finish one stage, sign it off, and move on with no going back.
Agile model
An SDLC approach that breaks development into short, repeated cycles (often called sprints), delivering working software incrementally and adapting to changing requirements along the way. Think of it as building the product in small, testable slices rather than all at once.
Iterative model
An SDLC approach where the system is developed through repeated cycles (iterations), with each iteration refining and expanding the product. In simple terms, you build a rough version first, then improve it in loops.
Requirements engineering
The process of gathering, analysing, and specifying the needs and constraints a software system must satisfy. Think of it as writing the brief before anyone touches a keyboard: what does the user need, and what limits exist?
Software design
The process of creating a plan or blueprint for the software, identifying components, their interactions, and their relationships. In simple terms, this is the architecture stage, where you decide what the parts are and how they fit together.
Software testing
The process of evaluating a software system or component to confirm that it meets its specified requirements and behaves as expected. Think of it as the quality inspection before the product ships.
Unit testing
Testing individual components or functions in isolation to verify each one works correctly on its own.
Integration testing
Testing how multiple components work together, checking that the connections between parts behave as expected.
System testing
Testing the complete, integrated system as a whole to verify it meets the specified requirements end to end.
Software maintenance
The process of modifying and updating software after deployment, including bug fixing, performance optimisation, and adding new features. In simple terms, the work does not stop at launch; most of a system's lifetime cost is in maintenance.
Software quality
The degree to which a software system meets its specified requirements and satisfies its intended purpose, measured through attributes such as reliability, maintainability, and usability.
Reliability
The ability of software to perform its required functions under stated conditions for a specified period without failure.
Maintainability
How easily software can be modified to fix defects, improve performance, or adapt to a changed environment.
Usability
The ease with which users can learn and operate the software to achieve their goals.
The SDLC provides the overall framework. Every model (waterfall, agile, iterative) organises the same core activities; the difference is in sequencing and feedback loops.
The five core stages are:
Requirements gathering – what the system must do and under what constraints
Design – how the system will be structured to meet those requirements
Implementation – writing the actual code
Testing – verifying the system works as intended
Maintenance – updating the system after release
Waterfall: linear and sequential. Each phase completes before the next starts. Works well when requirements are stable and well understood from the outset. Risky when requirements are uncertain, because changes late in the process are expensive.
Agile: iterative and incremental. Work is broken into short cycles (sprints), typically one to four weeks. Requirements can evolve. Emphasises working software, customer collaboration, and responding to change.
Iterative: the system is built in repeated cycles, each producing a more complete version. Similar to agile in spirit, but the term is broader and predates the Agile Manifesto.
Determines what the system should do (functional requirements) and under what conditions (non-functional requirements such as performance, security, scalability).
Poor requirements are the single most common cause of project failure. Getting this stage wrong means building the wrong thing.
Involves stakeholder interviews, document analysis, prototyping, and use-case modelling.
Translates requirements into a structural plan: which components exist, what each one does, and how they communicate.
High-level design defines the overall architecture (e.g. client-server, microservices).
Low-level design defines the internals of each component (data structures, algorithms, interfaces).
Unit testing: tests the smallest testable parts (functions, methods) in isolation. Fast, cheap, catches bugs early.
Integration testing: tests interactions between combined components. Catches interface mismatches and data-flow errors.
System testing: tests the fully assembled system against the original requirements. Validates the product end to end.
Testing can be manual (a person executes test cases) or automated (scripts run and verify results).
Typically consumes 60–80% of total software cost over its lifetime.
Types of maintenance:
Corrective – fixing bugs discovered after release
Adaptive – adjusting the software to a changed environment (new OS, new regulations)
Perfective – improving performance or adding features users request
Preventive – refactoring or updating code to prevent future problems
Quality is not a single number. It is a set of attributes, the most commonly cited being reliability, maintainability, and usability.
Quality assurance (QA) is the set of planned activities that ensure the development process itself produces a quality product.
Quality control (QC) is the set of activities that evaluate the finished product against standards.
The SDLC is used in every professional software team, from a two-person startup shipping a mobile app to a defence contractor building mission-critical avionics. The model chosen (waterfall vs agile) depends on how uncertain the requirements are and how quickly the market demands releases.
Requirements engineering failures are behind some of the most expensive software disasters in history. The Denver International Airport baggage system (1990s) went massively over budget largely because requirements were incomplete and changed repeatedly.
"Waterfall is outdated and bad." Waterfall is not inherently bad. It works well for projects with stable, well-defined requirements (e.g. embedded systems, regulated industries). The problem arises when it is applied to projects where requirements are uncertain or likely to change.
"Agile means no documentation." Agile values working software over comprehensive documentation, but that does not mean zero documentation. It means producing just enough documentation to be useful without slowing the team down.
"Testing happens at the end." In modern practice, testing is integrated throughout development. Unit tests are written alongside (or before) the code. Waiting until the end to test is a hallmark of poorly run projects, not a best practice.
"Maintenance is just bug fixing." Maintenance also includes adapting to new environments, adding features, and refactoring. Bug fixing is only one of four recognised types.
⚠️ Be able to list and describe the five SDLC phases in order. This is a near-certainty on introductory exams.
⚠️ Know the differences between waterfall, agile, and iterative models. Expect a question asking you to compare two of them or recommend one for a given scenario.
⚠️ Understand the three levels of testing (unit, integration, system) and what each one catches. A common exam format is matching the testing level to a described scenario.
⚠️ Be able to define software quality and name at least three measurable attributes (reliability, maintainability, usability).
⚠️ Requirements engineering is frequently tested via a scenario question: "A client says they want X. What questions would you ask?" Practise thinking through what is missing from vague requirements.
True or False: The waterfall model allows you to return to a previous phase easily once it is complete. A: False. Waterfall is linear and sequential; going back is difficult and costly.
True or False: Integration testing checks whether individual functions work correctly in isolation. A: False. That describes unit testing. Integration testing checks how components work together.
Fill in the blank: The process of gathering and analysing user needs before development begins is called ________. A: Requirements engineering.
True or False: Software maintenance typically accounts for less than 20% of a software product's total lifetime cost. A: False. Maintenance typically accounts for 60–80% of total lifetime cost.
Fill in the blank: The three software quality attributes most commonly cited in introductory courses are ________, ________, and ________. A: Reliability, maintainability, and usability.
Q: What is the software development life cycle (SDLC), and what are its main stages?
A: The SDLC is a structured process for developing software. Its main stages are requirements gathering, design, implementation, testing, and maintenance.
Q: Compare the waterfall and agile SDLC models. When would you choose one over the other?
A: Waterfall is linear and sequential, with each phase completed before the next begins. It suits projects with stable, well-understood requirements. Agile is iterative and incremental, delivering working software in short cycles and adapting to changing requirements. It suits projects where requirements are uncertain or evolving.
Q: What is requirements engineering, and why is it considered critical?
A: Requirements engineering is the process of gathering, analysing, and specifying what a system must do and under what constraints. It is critical because errors at this stage propagate through design, implementation, and testing, making them the most expensive to fix later.
Q: Describe the three main levels of software testing and what each one verifies.
A: Unit testing verifies individual components in isolation. Integration testing verifies that combined components interact correctly. System testing verifies the complete system against the original requirements.
Q: What is software maintenance, and what are its main types?
A: Software maintenance is the process of modifying software after deployment. Its main types are corrective (fixing bugs), adaptive (adjusting to environmental changes), perfective (improving performance or features), and preventive (refactoring to avoid future problems).
Q: Define software quality and name three attributes used to measure it.
A: Software quality is the degree to which software meets its specified requirements and satisfies its intended purpose. Three measurable attributes are reliability (consistent performance without failure), maintainability (ease of modification), and usability (ease of use).
This material connects directly to project management topics you will encounter later in the course, since choosing an SDLC model shapes how teams plan sprints, allocate resources, and track progress.
Object-oriented programming (OOP) and design patterns build on the software design phase discussed here. When you study OOP, you are learning one approach to the "how do we structure the components" question.
Quality assurance and formal methods courses go deeper into the testing and quality concepts introduced here, including topics like test coverage, static analysis, and formal verification.
software engineering, software development life cycle, SDLC, SDLC phases, SDLC models, waterfall model, waterfall vs agile, agile methodology, agile model, iterative development, iterative model, requirements engineering, requirements gathering, requirements analysis, functional requirements, non-functional requirements, software design, software architecture, software blueprint, software testing, unit testing, integration testing, system testing, manual testing, automated testing, software maintenance, corrective maintenance, adaptive maintenance, perfective maintenance, preventive maintenance, software quality, software quality assurance, QA, QC, reliability, maintainability, usability, CS101, introduction to software engineering, software engineering concepts, UCF computer science