Complete Progression
Follow the full journey from single classes to multi-package architecture and continuous delivery.
The curriculum in numbers
Designed for SE506 MSc in Artificial Intelligence at UKH.
15Chaptersfrom foundations to architecture, refactoring, and delivery
12+Checkpointscumulative, fully-verified Java/Maven codebases
6Learning outcomesLO1 to LO6 covering design, TDD, agile flow, and reflection
100%Executable & testedzero mock hand-waving; fully verifiable with JUnit & Mockito
The change-driven teaching method
- Understand the change
Read the scenario and distinguish existing guarantees from new business requirements.
- Choose the OO design
Justify structural choices using SOLID principles, encapsulation, and composition over inheritance.
- Test as design practice
Drive implementation with characterisation and unit tests using Arrange-Act-Assert.
- Inspect, refactor & evolve
Apply safe refactorings, monitor lead/cycle time, and integrate feedback continuously.
Learning paths through the curriculum
Explore this section
OO Principles & SOLID
Master responsibilities, extension, substitutability, and dependency inversion.
TDD & Design Patterns
Drive design with test doubles, factory/builder creation, and behavioral patterns.
Architecture & Refactoring
Layered architecture, package stability, legacy code seams, and empirical flow metrics.
The arc of the textbook
Foundations, OO Principles & Iterations
Developing software that can change, OO beyond syntax, Agile user stories, and SOLID principles.
Testing, Object Creation & Changing Behaviour
Interfaces, TDD with JUnit/Mockito, Creational patterns, and GoF Behavioral patterns.
Architecture, Packages & Refactoring
Layered packages, component stability, characterisation tests, and legacy seams.
Flow Metrics, Continuous Delivery & AI Assistance
Cycle time, contract tests, feature flags, retrospective handover, and responsible AI assistance.
Core competencies
OO Responsibilities & Invariants
SOLID Design Principles
Agile Planning & User Stories
Test-Driven Development (TDD)
Test Doubles & Mocks
Creational & DI Containers
Behavioral Design Patterns
Package Cohesion & Coupling
Safe Legacy Refactoring
Lead & Cycle Time Metrics
Contract Testing & Feature Flags
AI as an Engineering Assistant
Tools and technologies applied
Java 17+ Baseline
Strong typing, immutable records, explicit contracts, and modern syntax
Apache Maven
Deterministic builds, dependency graphs, and offline surefire verification
JUnit 5 & Mockito
Parametrized suites, assertions, strict stubs, and isolation spies
PMD Static Analysis
Automated code smell detection, design rules, and complexity gates
Git & Agile Workboards
Traceable commits, pull request peer reviews, and milestone delivery
LLMs & AI Coding Agents
Critical evaluation of AI suggestions, boundary testing, and prompts
Frequently Asked Questions
Who is this textbook intended for?
It is written for postgraduate students in Artificial Intelligence (SE506 at UKH) and software engineers looking to master production-quality object-oriented design, automated testing, and agile collaboration.
Why focus on software engineering for AI students?
The course descriptor prepares students to build reliable, maintainable software around AI and data components, handling real-world fallbacks, timeouts, test doubles, and evolving domain rules.
What is the Campus Equipment Lending System?
A realistic running domain used across chapters. Starting from a single reservation rule, it grows iteratively into a layered, decoupled system with persistence and policy models.
How are code companions structured?
Each chapter is paired with a companion containing complete or delta Java listings, line-by-line walkthroughs, lab solutions, and verified test outputs.
Can I read and build the materials offline?
Yes. Every chapter companion includes self-contained code listings, and all dependencies are pinned for reproducible offline testing.
Foundational engineering principles
Design for change
Invert dependencies, protect invariants, and isolate components that change for different reasons.
Test as a design practice
Write automated tests to discover cohesive interfaces, define contracts, and prevent regressions.
Iterate with empirical feedback
Make small, reversible commits, measure flow with lead and cycle times, and adapt plans continuously.
Ready to explore the textbook?Read online, explore verified code companions, or download the complete 341-page PDF monograph.