Skip to main content
CBE Nexus · Undergraduate Computer Science

Chapter 9: Software Engineering and Systems Analysis

Software engineering study notes on requirements, feasibility, UML, architecture, design patterns, agile development, version control, testing, quality assurance, deployment and maintenance.

Back to Computer Science course guide

Chapter overview and learning outcomes

This chapter develops the conceptual and practical foundations of software engineering and systems analysis. It connects theory with real systems, technical decision-making and responsible computing practice.

1. Software engineering principles and lifecycle

Software engineering applies systematic, measurable and disciplined methods to the development, operation and maintenance of software. A lifecycle organises work from problem discovery through requirements, design, implementation, verification, deployment and evolution. Software projects face uncertainty, changing needs, technical constraints and coordination costs. Engineering practices aim to deliver useful, dependable systems while managing time, budget, quality, security and risk. The lifecycle may be sequential, iterative, incremental or continuous.

Applied example: Consider a realistic university, business or public-service information system. Identify the users, inputs, outputs, constraints and failure conditions. Trace the relevant operation from beginning to end, record what the system should guarantee, and explain how the design can be tested. Compare a reasonable alternative and discuss trade-offs in performance, reliability, security, cost and maintainability.

Learning activity: Create a labelled diagram or small worked example, explain the terminology in your own words, and prepare one test question that checks application rather than simple recall.

2. Systems analysis and feasibility

Systems analysis examines an organisation's problem, current processes, stakeholders, data and constraints before proposing a solution. Feasibility considers technical capability, economic value, operational fit, legal requirements, schedule and organisational readiness. A business case explains expected benefits, costs, risks and alternatives. Process models, interviews, observation and document analysis reveal current workflows. Analysts should validate findings with users rather than assuming that the first request describes the underlying need.

Applied example: Consider a realistic university, business or public-service information system. Identify the users, inputs, outputs, constraints and failure conditions. Trace the relevant operation from beginning to end, record what the system should guarantee, and explain how the design can be tested. Compare a reasonable alternative and discuss trade-offs in performance, reliability, security, cost and maintainability.

Learning activity: Create a labelled diagram or small worked example, explain the terminology in your own words, and prepare one test question that checks application rather than simple recall.

3. Requirements elicitation and specification

Functional requirements describe services and behaviours the system must provide. Non-functional requirements describe quality attributes such as performance, availability, usability, accessibility, security, scalability and maintainability. Elicitation methods include interviews, workshops, surveys, observation, prototyping and analysis of existing systems. Requirements should be clear, testable, prioritised, traceable and agreed with stakeholders. Ambiguous words such as fast, easy or secure should be translated into measurable acceptance criteria.

Applied example: Consider a realistic university, business or public-service information system. Identify the users, inputs, outputs, constraints and failure conditions. Trace the relevant operation from beginning to end, record what the system should guarantee, and explain how the design can be tested. Compare a reasonable alternative and discuss trade-offs in performance, reliability, security, cost and maintainability.

Learning activity: Create a labelled diagram or small worked example, explain the terminology in your own words, and prepare one test question that checks application rather than simple recall.

4. Use cases, user stories and modelling

Use cases describe interactions between actors and a system to achieve a goal. User stories express a need from a user's perspective and are often accompanied by acceptance criteria. UML provides standard diagrams: use-case, class, sequence, activity, state and component diagrams, among others. Models help stakeholders discuss structure and behaviour before implementation. They should be detailed enough to resolve important design questions without becoming documentation that is expensive to maintain.

Applied example: Consider a realistic university, business or public-service information system. Identify the users, inputs, outputs, constraints and failure conditions. Trace the relevant operation from beginning to end, record what the system should guarantee, and explain how the design can be tested. Compare a reasonable alternative and discuss trade-offs in performance, reliability, security, cost and maintainability.

Learning activity: Create a labelled diagram or small worked example, explain the terminology in your own words, and prepare one test question that checks application rather than simple recall.

5. Software architecture and design principles

Architecture defines major components, their responsibilities, interfaces, deployment and quality trade-offs. Common styles include layered, client-server, event-driven, microservices and service-oriented architectures. Good design aims for high cohesion within modules and low coupling between them. Separation of concerns, encapsulation, dependency management and clear interfaces reduce change impact. Architecture decisions should be recorded with context, alternatives and consequences, particularly for security, availability and operational complexity.

Applied example: Consider a realistic university, business or public-service information system. Identify the users, inputs, outputs, constraints and failure conditions. Trace the relevant operation from beginning to end, record what the system should guarantee, and explain how the design can be tested. Compare a reasonable alternative and discuss trade-offs in performance, reliability, security, cost and maintainability.

Learning activity: Create a labelled diagram or small worked example, explain the terminology in your own words, and prepare one test question that checks application rather than simple recall.

6. Design patterns and reusable components

A design pattern is a reusable description of a solution to a recurring design problem in a context. Patterns such as Strategy, Observer, Factory and Adapter address different forms of variability, communication or object creation. Patterns are not code templates that must always be used. Applying one without a real need can add complexity. Reusable libraries and components also require evaluation of licensing, maintenance, compatibility, security and provenance.

Applied example: Consider a realistic university, business or public-service information system. Identify the users, inputs, outputs, constraints and failure conditions. Trace the relevant operation from beginning to end, record what the system should guarantee, and explain how the design can be tested. Compare a reasonable alternative and discuss trade-offs in performance, reliability, security, cost and maintainability.

Learning activity: Create a labelled diagram or small worked example, explain the terminology in your own words, and prepare one test question that checks application rather than simple recall.

7. Agile development and project management

Agile approaches emphasise collaboration, feedback, working increments and adaptation to change. Scrum organises work into time-boxed sprints with defined accountabilities, events and artefacts. Kanban visualises workflow and limits work in progress. Agile does not mean abandoning planning, documentation or quality; it changes how they are produced and updated. Teams should select practices that suit their regulatory, technical and organisational context.

Applied example: Consider a realistic university, business or public-service information system. Identify the users, inputs, outputs, constraints and failure conditions. Trace the relevant operation from beginning to end, record what the system should guarantee, and explain how the design can be tested. Compare a reasonable alternative and discuss trade-offs in performance, reliability, security, cost and maintainability.

Learning activity: Create a labelled diagram or small worked example, explain the terminology in your own words, and prepare one test question that checks application rather than simple recall.

8. Version control and collaborative development

Version control records changes to files over time and supports collaboration, review and recovery. Git stores snapshots and supports branching, merging and distributed workflows. Commits should be focused and descriptive. Pull requests enable peer review and automated checks before integration. Teams need policies for branch protection, secret handling, conflict resolution and release tagging. Never commit passwords, API keys or private user data into source repositories.

Applied example: Consider a realistic university, business or public-service information system. Identify the users, inputs, outputs, constraints and failure conditions. Trace the relevant operation from beginning to end, record what the system should guarantee, and explain how the design can be tested. Compare a reasonable alternative and discuss trade-offs in performance, reliability, security, cost and maintainability.

Learning activity: Create a labelled diagram or small worked example, explain the terminology in your own words, and prepare one test question that checks application rather than simple recall.

9. Software testing and verification

Testing provides evidence about software behaviour but cannot prove the absence of every defect. Unit tests target small components; integration tests examine interactions; system tests evaluate the complete system; acceptance tests assess whether user needs are met. Regression tests check that changes do not break existing behaviour. Static analysis examines code without executing it; dynamic testing runs software under selected conditions. Test design should include normal, boundary, invalid and failure cases.

Applied example: Consider a realistic university, business or public-service information system. Identify the users, inputs, outputs, constraints and failure conditions. Trace the relevant operation from beginning to end, record what the system should guarantee, and explain how the design can be tested. Compare a reasonable alternative and discuss trade-offs in performance, reliability, security, cost and maintainability.

Learning activity: Create a labelled diagram or small worked example, explain the terminology in your own words, and prepare one test question that checks application rather than simple recall.

10. Quality assurance, security and reliability

Quality assurance includes processes that prevent defects and improve consistency, while quality control evaluates delivered outputs. Quality attributes include correctness, reliability, usability, efficiency, maintainability, portability and accessibility. Secure development includes threat modelling, code review, dependency scanning, input validation, least privilege and secure defaults. Risk-based testing focuses effort on high-impact failures. Metrics should inform improvement rather than encourage teams to optimise misleading numbers.

Applied example: Consider a realistic university, business or public-service information system. Identify the users, inputs, outputs, constraints and failure conditions. Trace the relevant operation from beginning to end, record what the system should guarantee, and explain how the design can be tested. Compare a reasonable alternative and discuss trade-offs in performance, reliability, security, cost and maintainability.

Learning activity: Create a labelled diagram or small worked example, explain the terminology in your own words, and prepare one test question that checks application rather than simple recall.

11. Deployment, operations and software maintenance

Deployment moves tested software into an environment where users can access it. Strategies include rolling, blue-green and canary releases. Continuous integration and delivery automate build, test and release steps when appropriate safeguards exist. Monitoring tracks logs, metrics and traces to identify failures and performance problems. Maintenance includes corrective, adaptive, perfective and preventive work. Plan migrations, backups, rollback procedures, documentation and user support before a release.

Applied example: Consider a realistic university, business or public-service information system. Identify the users, inputs, outputs, constraints and failure conditions. Trace the relevant operation from beginning to end, record what the system should guarantee, and explain how the design can be tested. Compare a reasonable alternative and discuss trade-offs in performance, reliability, security, cost and maintainability.

Learning activity: Create a labelled diagram or small worked example, explain the terminology in your own words, and prepare one test question that checks application rather than simple recall.

Figure 1. Software lifecycle
Discover and analyse needs→Specify requirements→Design and implement→Verify and release→Maintain and improve

Conceptual learning diagram. Interpret each stage in the context of the chapter topic.

Figure 2. Requirements traceability
Stakeholder need→Requirement statement→Design and implementation item→Test and acceptance evidence

Conceptual learning diagram. Interpret each stage in the context of the chapter topic.

Figure 3. Continuous integration
Developer commits change→Automated build→Automated tests and checks→Review and controlled release

Conceptual learning diagram. Interpret each stage in the context of the chapter topic.

Practical laboratory activity

  1. Choose a small scenario related to the chapter and write a clear problem statement.
  2. Identify assumptions, inputs, outputs, constraints and expected behaviour.
  3. Draw a model, flow diagram, schema or sequence of operations.
  4. Use an appropriate programming language, database, simulator or network tool where relevant.
  5. Test normal, boundary and failure cases; record observations and explain discrepancies.
  6. Submit a concise report with methods, results, limitations and recommendations.

Use authorised software, sample data and test environments. Do not access systems or information without permission.

Worked reasoning and self-assessment

Begin by defining the problem and its constraints. Work through a small example manually before relying on a tool. State the expected result, show intermediate steps and verify the outcome independently. For system-design questions, justify the selected approach and discuss at least one alternative. For performance questions, identify the workload and metric being measured. For security questions, describe the threat, the control and the residual risk.

Examination and revision questions

Answer each question with precise definitions, diagrams, calculations or technical examples where appropriate.

  1. Define software engineering.

    Show answer guidance

    A systematic and disciplined approach to developing, operating and maintaining software.

  2. What is systems analysis?

    Show answer guidance

    Investigating stakeholder needs, processes, data and constraints to define an appropriate system solution.

  3. Differentiate functional and non-functional requirements.

    Show answer guidance

    Functional requirements specify system behaviour; non-functional requirements specify quality attributes and constraints.

  4. What is a use case?

    Show answer guidance

    A description of interactions between an actor and a system to achieve a goal.

  5. Name four UML diagrams.

    Show answer guidance

    Use-case, class, sequence, activity, state or component diagrams.

  6. What is cohesion?

    Show answer guidance

    The degree to which elements within a module belong together around a focused responsibility.

  7. What is coupling?

    Show answer guidance

    The degree of dependency between modules or components.

  8. What is an agile iteration?

    Show answer guidance

    A short development cycle that produces an increment and incorporates feedback.

  9. Why use version control?

    Show answer guidance

    To track changes, support collaboration and recover or compare earlier versions.

  10. Differentiate unit and integration testing.

    Show answer guidance

    Unit tests examine components individually; integration tests examine interactions between components.

  11. What is regression testing?

    Show answer guidance

    Retesting to detect whether changes have broken previously working behaviour.

  12. What is continuous integration?

    Show answer guidance

    A practice of frequently integrating changes with automated builds and tests.

  13. What is technical debt?

    Show answer guidance

    Future cost created by shortcuts or design decisions that make later change or maintenance harder.

  14. Name four software maintenance categories.

    Show answer guidance

    Corrective, adaptive, perfective and preventive.

  15. Why should secrets not be committed to source control?

    Show answer guidance

    Repository history and copies can expose credentials even after a file is removed.

Revision checklist

Further study and references

Use current university textbooks, peer-reviewed research, official standards and vendor or project documentation. Verify software versions, protocol specifications and security guidance against authoritative sources because technical systems change. Cite the edition and publication details of materials used in assignments, and distinguish established facts from assumptions or illustrative examples.

Academic and responsible-use note: These notes support undergraduate learning and do not replace your university's course outline or laboratory rules. Respect privacy, intellectual property, software licences and institutional policies. Conduct experiments only on systems and datasets for which you have permission.

Return to the full Computer Science course guide

Official Education References

Use these official organisations for curriculum guidance, examinations and further learning information.