Home › Software Engineering › Chapter 15
Learning outcomes
By the end of this chapter, learners should be able to explain the principal concepts, analyse a realistic engineering problem, select and justify suitable methods, communicate decisions clearly, identify risks and evaluate results against explicit criteria.
Study approach: Read each topic, create your own examples, reproduce the diagrams from memory, complete the applied project and attempt the questions before consulting the answer guidance.
Feedback from evaluation and operation informs the next iteration.
1. Evolution of software systems and technology trends
Evolution of software systems and technology trends is important because software engineering decisions affect users, organisations and the long-term behaviour of systems. Start by defining the problem and the system boundary. Identify stakeholders, assets, information flows, dependencies and constraints. Distinguish facts from assumptions, and make the quality attributes explicit. A decision should be traceable to a need and supported by evidence rather than selected solely because a tool or method is popular.
In a practical project, translate the concept into observable requirements and clear responsibilities. Document inputs, outputs, interfaces, exceptional conditions and expected behaviour. Consider the effects of change, failure and misuse. Choose methods that fit the context, then review them with peers and relevant stakeholders. Where uncertainty is high, build a small prototype, conduct a focused test or consult authoritative technical documentation before committing to a larger design.
Consider a university learning platform used by students, lecturers and administrators. Follow a realistic user task through the relevant interface, application services, data stores and operational processes. Ask what happens when information is missing, a user has insufficient permission, a network connection fails or usage increases. Record the expected outcome, the evidence required to verify it and the recovery path if the operation cannot complete. This turns abstract ideas into decisions that can be implemented and assessed.
Worked engineering reflection: State the problem, list at least two alternatives, compare their consequences, choose one with a reasoned justification and define how the choice will be reviewed after implementation. Include a limitation so that the decision is not presented as universally correct.
2. Microservices and service-oriented systems
Microservices and service-oriented systems is important because software engineering decisions affect users, organisations and the long-term behaviour of systems. Start by defining the problem and the system boundary. Identify stakeholders, assets, information flows, dependencies and constraints. Distinguish facts from assumptions, and make the quality attributes explicit. A decision should be traceable to a need and supported by evidence rather than selected solely because a tool or method is popular.
In a practical project, translate the concept into observable requirements and clear responsibilities. Document inputs, outputs, interfaces, exceptional conditions and expected behaviour. Consider the effects of change, failure and misuse. Choose methods that fit the context, then review them with peers and relevant stakeholders. Where uncertainty is high, build a small prototype, conduct a focused test or consult authoritative technical documentation before committing to a larger design.
Consider a university learning platform used by students, lecturers and administrators. Follow a realistic user task through the relevant interface, application services, data stores and operational processes. Ask what happens when information is missing, a user has insufficient permission, a network connection fails or usage increases. Record the expected outcome, the evidence required to verify it and the recovery path if the operation cannot complete. This turns abstract ideas into decisions that can be implemented and assessed.
Worked engineering reflection: State the problem, list at least two alternatives, compare their consequences, choose one with a reasoned justification and define how the choice will be reviewed after implementation. Include a limitation so that the decision is not presented as universally correct.
3. Event-driven architecture and stream processing
Event-driven architecture and stream processing is important because software engineering decisions affect users, organisations and the long-term behaviour of systems. Start by defining the problem and the system boundary. Identify stakeholders, assets, information flows, dependencies and constraints. Distinguish facts from assumptions, and make the quality attributes explicit. A decision should be traceable to a need and supported by evidence rather than selected solely because a tool or method is popular.
In a practical project, translate the concept into observable requirements and clear responsibilities. Document inputs, outputs, interfaces, exceptional conditions and expected behaviour. Consider the effects of change, failure and misuse. Choose methods that fit the context, then review them with peers and relevant stakeholders. Where uncertainty is high, build a small prototype, conduct a focused test or consult authoritative technical documentation before committing to a larger design.
Consider a university learning platform used by students, lecturers and administrators. Follow a realistic user task through the relevant interface, application services, data stores and operational processes. Ask what happens when information is missing, a user has insufficient permission, a network connection fails or usage increases. Record the expected outcome, the evidence required to verify it and the recovery path if the operation cannot complete. This turns abstract ideas into decisions that can be implemented and assessed.
Worked engineering reflection: State the problem, list at least two alternatives, compare their consequences, choose one with a reasoned justification and define how the choice will be reviewed after implementation. Include a limitation so that the decision is not presented as universally correct.
4. Serverless computing and managed platforms
Serverless computing and managed platforms is important because software engineering decisions affect users, organisations and the long-term behaviour of systems. Start by defining the problem and the system boundary. Identify stakeholders, assets, information flows, dependencies and constraints. Distinguish facts from assumptions, and make the quality attributes explicit. A decision should be traceable to a need and supported by evidence rather than selected solely because a tool or method is popular.
In a practical project, translate the concept into observable requirements and clear responsibilities. Document inputs, outputs, interfaces, exceptional conditions and expected behaviour. Consider the effects of change, failure and misuse. Choose methods that fit the context, then review them with peers and relevant stakeholders. Where uncertainty is high, build a small prototype, conduct a focused test or consult authoritative technical documentation before committing to a larger design.
Consider a university learning platform used by students, lecturers and administrators. Follow a realistic user task through the relevant interface, application services, data stores and operational processes. Ask what happens when information is missing, a user has insufficient permission, a network connection fails or usage increases. Record the expected outcome, the evidence required to verify it and the recovery path if the operation cannot complete. This turns abstract ideas into decisions that can be implemented and assessed.
Worked engineering reflection: State the problem, list at least two alternatives, compare their consequences, choose one with a reasoned justification and define how the choice will be reviewed after implementation. Include a limitation so that the decision is not presented as universally correct.
5. Distributed systems and consistency models
Distributed systems and consistency models is important because software engineering decisions affect users, organisations and the long-term behaviour of systems. Start by defining the problem and the system boundary. Identify stakeholders, assets, information flows, dependencies and constraints. Distinguish facts from assumptions, and make the quality attributes explicit. A decision should be traceable to a need and supported by evidence rather than selected solely because a tool or method is popular.
In a practical project, translate the concept into observable requirements and clear responsibilities. Document inputs, outputs, interfaces, exceptional conditions and expected behaviour. Consider the effects of change, failure and misuse. Choose methods that fit the context, then review them with peers and relevant stakeholders. Where uncertainty is high, build a small prototype, conduct a focused test or consult authoritative technical documentation before committing to a larger design.
Consider a university learning platform used by students, lecturers and administrators. Follow a realistic user task through the relevant interface, application services, data stores and operational processes. Ask what happens when information is missing, a user has insufficient permission, a network connection fails or usage increases. Record the expected outcome, the evidence required to verify it and the recovery path if the operation cannot complete. This turns abstract ideas into decisions that can be implemented and assessed.
Worked engineering reflection: State the problem, list at least two alternatives, compare their consequences, choose one with a reasoned justification and define how the choice will be reviewed after implementation. Include a limitation so that the decision is not presented as universally correct.
6. Scalable data-intensive application design
Scalable data-intensive application design is important because software engineering decisions affect users, organisations and the long-term behaviour of systems. Start by defining the problem and the system boundary. Identify stakeholders, assets, information flows, dependencies and constraints. Distinguish facts from assumptions, and make the quality attributes explicit. A decision should be traceable to a need and supported by evidence rather than selected solely because a tool or method is popular.
In a practical project, translate the concept into observable requirements and clear responsibilities. Document inputs, outputs, interfaces, exceptional conditions and expected behaviour. Consider the effects of change, failure and misuse. Choose methods that fit the context, then review them with peers and relevant stakeholders. Where uncertainty is high, build a small prototype, conduct a focused test or consult authoritative technical documentation before committing to a larger design.
Consider a university learning platform used by students, lecturers and administrators. Follow a realistic user task through the relevant interface, application services, data stores and operational processes. Ask what happens when information is missing, a user has insufficient permission, a network connection fails or usage increases. Record the expected outcome, the evidence required to verify it and the recovery path if the operation cannot complete. This turns abstract ideas into decisions that can be implemented and assessed.
Worked engineering reflection: State the problem, list at least two alternatives, compare their consequences, choose one with a reasoned justification and define how the choice will be reviewed after implementation. Include a limitation so that the decision is not presented as universally correct.
7. Artificial intelligence in software engineering
Artificial intelligence in software engineering is important because software engineering decisions affect users, organisations and the long-term behaviour of systems. Start by defining the problem and the system boundary. Identify stakeholders, assets, information flows, dependencies and constraints. Distinguish facts from assumptions, and make the quality attributes explicit. A decision should be traceable to a need and supported by evidence rather than selected solely because a tool or method is popular.
In a practical project, translate the concept into observable requirements and clear responsibilities. Document inputs, outputs, interfaces, exceptional conditions and expected behaviour. Consider the effects of change, failure and misuse. Choose methods that fit the context, then review them with peers and relevant stakeholders. Where uncertainty is high, build a small prototype, conduct a focused test or consult authoritative technical documentation before committing to a larger design.
Consider a university learning platform used by students, lecturers and administrators. Follow a realistic user task through the relevant interface, application services, data stores and operational processes. Ask what happens when information is missing, a user has insufficient permission, a network connection fails or usage increases. Record the expected outcome, the evidence required to verify it and the recovery path if the operation cannot complete. This turns abstract ideas into decisions that can be implemented and assessed.
Worked engineering reflection: State the problem, list at least two alternatives, compare their consequences, choose one with a reasoned justification and define how the choice will be reviewed after implementation. Include a limitation so that the decision is not presented as universally correct.
8. AI-assisted coding, review and testing
AI-assisted coding, review and testing is important because software engineering decisions affect users, organisations and the long-term behaviour of systems. Start by defining the problem and the system boundary. Identify stakeholders, assets, information flows, dependencies and constraints. Distinguish facts from assumptions, and make the quality attributes explicit. A decision should be traceable to a need and supported by evidence rather than selected solely because a tool or method is popular.
In a practical project, translate the concept into observable requirements and clear responsibilities. Document inputs, outputs, interfaces, exceptional conditions and expected behaviour. Consider the effects of change, failure and misuse. Choose methods that fit the context, then review them with peers and relevant stakeholders. Where uncertainty is high, build a small prototype, conduct a focused test or consult authoritative technical documentation before committing to a larger design.
Consider a university learning platform used by students, lecturers and administrators. Follow a realistic user task through the relevant interface, application services, data stores and operational processes. Ask what happens when information is missing, a user has insufficient permission, a network connection fails or usage increases. Record the expected outcome, the evidence required to verify it and the recovery path if the operation cannot complete. This turns abstract ideas into decisions that can be implemented and assessed.
Worked engineering reflection: State the problem, list at least two alternatives, compare their consequences, choose one with a reasoned justification and define how the choice will be reviewed after implementation. Include a limitation so that the decision is not presented as universally correct.
9. Responsible AI, evaluation and human oversight
Responsible AI, evaluation and human oversight is important because software engineering decisions affect users, organisations and the long-term behaviour of systems. Start by defining the problem and the system boundary. Identify stakeholders, assets, information flows, dependencies and constraints. Distinguish facts from assumptions, and make the quality attributes explicit. A decision should be traceable to a need and supported by evidence rather than selected solely because a tool or method is popular.
In a practical project, translate the concept into observable requirements and clear responsibilities. Document inputs, outputs, interfaces, exceptional conditions and expected behaviour. Consider the effects of change, failure and misuse. Choose methods that fit the context, then review them with peers and relevant stakeholders. Where uncertainty is high, build a small prototype, conduct a focused test or consult authoritative technical documentation before committing to a larger design.
Consider a university learning platform used by students, lecturers and administrators. Follow a realistic user task through the relevant interface, application services, data stores and operational processes. Ask what happens when information is missing, a user has insufficient permission, a network connection fails or usage increases. Record the expected outcome, the evidence required to verify it and the recovery path if the operation cannot complete. This turns abstract ideas into decisions that can be implemented and assessed.
Worked engineering reflection: State the problem, list at least two alternatives, compare their consequences, choose one with a reasoned justification and define how the choice will be reviewed after implementation. Include a limitation so that the decision is not presented as universally correct.
10. Platform engineering and developer experience
Platform engineering and developer experience is important because software engineering decisions affect users, organisations and the long-term behaviour of systems. Start by defining the problem and the system boundary. Identify stakeholders, assets, information flows, dependencies and constraints. Distinguish facts from assumptions, and make the quality attributes explicit. A decision should be traceable to a need and supported by evidence rather than selected solely because a tool or method is popular.
In a practical project, translate the concept into observable requirements and clear responsibilities. Document inputs, outputs, interfaces, exceptional conditions and expected behaviour. Consider the effects of change, failure and misuse. Choose methods that fit the context, then review them with peers and relevant stakeholders. Where uncertainty is high, build a small prototype, conduct a focused test or consult authoritative technical documentation before committing to a larger design.
Consider a university learning platform used by students, lecturers and administrators. Follow a realistic user task through the relevant interface, application services, data stores and operational processes. Ask what happens when information is missing, a user has insufficient permission, a network connection fails or usage increases. Record the expected outcome, the evidence required to verify it and the recovery path if the operation cannot complete. This turns abstract ideas into decisions that can be implemented and assessed.
Worked engineering reflection: State the problem, list at least two alternatives, compare their consequences, choose one with a reasoned justification and define how the choice will be reviewed after implementation. Include a limitation so that the decision is not presented as universally correct.
11. Legacy modernization and technical debt
Legacy modernization and technical debt is important because software engineering decisions affect users, organisations and the long-term behaviour of systems. Start by defining the problem and the system boundary. Identify stakeholders, assets, information flows, dependencies and constraints. Distinguish facts from assumptions, and make the quality attributes explicit. A decision should be traceable to a need and supported by evidence rather than selected solely because a tool or method is popular.
In a practical project, translate the concept into observable requirements and clear responsibilities. Document inputs, outputs, interfaces, exceptional conditions and expected behaviour. Consider the effects of change, failure and misuse. Choose methods that fit the context, then review them with peers and relevant stakeholders. Where uncertainty is high, build a small prototype, conduct a focused test or consult authoritative technical documentation before committing to a larger design.
Consider a university learning platform used by students, lecturers and administrators. Follow a realistic user task through the relevant interface, application services, data stores and operational processes. Ask what happens when information is missing, a user has insufficient permission, a network connection fails or usage increases. Record the expected outcome, the evidence required to verify it and the recovery path if the operation cannot complete. This turns abstract ideas into decisions that can be implemented and assessed.
Worked engineering reflection: State the problem, list at least two alternatives, compare their consequences, choose one with a reasoned justification and define how the choice will be reviewed after implementation. Include a limitation so that the decision is not presented as universally correct.
12. Emerging paradigms and technology assessment
Emerging paradigms and technology assessment is important because software engineering decisions affect users, organisations and the long-term behaviour of systems. Start by defining the problem and the system boundary. Identify stakeholders, assets, information flows, dependencies and constraints. Distinguish facts from assumptions, and make the quality attributes explicit. A decision should be traceable to a need and supported by evidence rather than selected solely because a tool or method is popular.
In a practical project, translate the concept into observable requirements and clear responsibilities. Document inputs, outputs, interfaces, exceptional conditions and expected behaviour. Consider the effects of change, failure and misuse. Choose methods that fit the context, then review them with peers and relevant stakeholders. Where uncertainty is high, build a small prototype, conduct a focused test or consult authoritative technical documentation before committing to a larger design.
Consider a university learning platform used by students, lecturers and administrators. Follow a realistic user task through the relevant interface, application services, data stores and operational processes. Ask what happens when information is missing, a user has insufficient permission, a network connection fails or usage increases. Record the expected outcome, the evidence required to verify it and the recovery path if the operation cannot complete. This turns abstract ideas into decisions that can be implemented and assessed.
Worked engineering reflection: State the problem, list at least two alternatives, compare their consequences, choose one with a reasoned justification and define how the choice will be reviewed after implementation. Include a limitation so that the decision is not presented as universally correct.
Traceability makes it easier to demonstrate that important needs have been addressed.
Practical laboratory / applied project
In a small team, select a feature for a campus learning platform. Define the problem, identify stakeholders and constraints, create a context diagram, write concise requirements, compare at least two solution approaches and prepare a test or evaluation plan. Build a small prototype or demonstrator where appropriate. Use version control, record meaningful decisions and request peer review.
Submission evidence: problem statement; assumptions; diagram; decision log; prototype, model or investigation; test cases and results; and an individual reflection explaining limitations.
Assessment rubric (100 marks): problem analysis 15; technical accuracy 20; design or method quality 20; implementation or investigation 15; evaluation and evidence 15; communication and reflection 10; collaboration and reproducibility 5.
Revision questions and answer guidance
1. Define the central concepts and explain why they matter in professional software engineering.
Answer guidance: Define the relevant terms, apply them to a specific example, explain your reasoning and acknowledge important limitations.
2. Distinguish the main terms and approaches introduced in this chapter.
Answer guidance: Define the relevant terms, apply them to a specific example, explain your reasoning and acknowledge important limitations.
3. Apply the concepts to a realistic software product or organisational scenario.
Answer guidance: Define the relevant terms, apply them to a specific example, explain your reasoning and acknowledge important limitations.
4. Draw a labelled diagram that communicates the process, architecture or relationship.
Answer guidance: Define the relevant terms, apply them to a specific example, explain your reasoning and acknowledge important limitations.
5. Compare two possible approaches and justify when each is suitable.
Answer guidance: Define the relevant terms, apply them to a specific example, explain your reasoning and acknowledge important limitations.
6. Identify key assumptions, constraints and stakeholder needs.
Answer guidance: Define the relevant terms, apply them to a specific example, explain your reasoning and acknowledge important limitations.
7. Explain a likely failure mode and propose ways to prevent or detect it.
Answer guidance: Define the relevant terms, apply them to a specific example, explain your reasoning and acknowledge important limitations.
8. Discuss relevant security, privacy, accessibility or ethical responsibilities.
Answer guidance: Define the relevant terms, apply them to a specific example, explain your reasoning and acknowledge important limitations.
9. Describe how the proposed approach can be tested or evaluated.
Answer guidance: Define the relevant terms, apply them to a specific example, explain your reasoning and acknowledge important limitations.
10. Interpret evidence that could support or challenge an engineering decision.
Answer guidance: Define the relevant terms, apply them to a specific example, explain your reasoning and acknowledge important limitations.
11. Explain how the solution should evolve as requirements or scale change.
Answer guidance: Define the relevant terms, apply them to a specific example, explain your reasoning and acknowledge important limitations.
12. Identify documentation and collaboration practices needed by a team.
Answer guidance: Define the relevant terms, apply them to a specific example, explain your reasoning and acknowledge important limitations.
13. Develop a short implementation or investigation plan with acceptance criteria.
Answer guidance: Define the relevant terms, apply them to a specific example, explain your reasoning and acknowledge important limitations.
14. Evaluate trade-offs involving quality, cost, performance, risk and maintainability.
Answer guidance: Define the relevant terms, apply them to a specific example, explain your reasoning and acknowledge important limitations.
15. State limitations and identify further work needed to strengthen the solution.
Answer guidance: Define the relevant terms, apply them to a specific example, explain your reasoning and acknowledge important limitations.
Revision checklist
- I can define the chapter vocabulary accurately.
- I can explain the concepts with relevant examples.
- I can draw and interpret the diagrams.
- I can apply the methods to a realistic software project.
- I can justify trade-offs and identify limitations.
- I can present evidence for my engineering decisions.
Further study and academic integrity
Deepen this introductory framework with current university textbooks, peer-reviewed research, applicable standards and primary technical documentation. Check publication dates and version numbers because tools and recommended practices change. Cite sources using the style required by your institution. Verify generated text, code and diagrams independently; do not present them as experimental evidence without testing.