25-Comp-B11 Advanced Software Design
Worked solutions to 7 past sittings (2014–2019), 190 questions. Pick a sitting, or start from a topic below.
Topics across the sittings
Topics that come up in more than one sitting, taken from the headings of our worked solutions. A topic counts once per sitting.
- Dynamic Binding (7 sittings): December 2019 Q24 · December 2018 Q24 · May 2016 Q24 · May 2015 Q24 · December 2014 Q7 · May 2014 Q7 · Undated paper Q24
- Functional (7 sittings): December 2019 Q2 · December 2018 Q2 · May 2016 Q2 · May 2015 Q2 · December 2014 Q2 · May 2014 Q2 · Undated paper Q2
- Overloading (7 sittings): December 2019 Q24 · December 2018 Q24 · May 2016 Q24 · May 2015 Q24 · December 2014 Q7 · May 2014 Q7 · Undated paper Q24
- Overriding (7 sittings): December 2019 Q24 · December 2018 Q24 · May 2016 Q24 · May 2015 Q24 · December 2014 Q7 · May 2014 Q7 · Undated paper Q24
- Liskov Substitution Principle (6 sittings): December 2019 Q12 · May 2016 Q11 · May 2015 Q11 · December 2014 Q11 · May 2014 Q11 · Undated paper Q12
- Non-Functional Requirements (6 sittings): December 2019 Q2 · May 2016 Q2 · May 2015 Q2 · December 2014 Q2 · May 2014 Q2 · Undated paper Q2
- Polymorphism (6 sittings): December 2019 Q24 · December 2018 Q24 · May 2016 Q24 · May 2015 Q24 · December 2014 Q7 · May 2014 Q7
- Software Reuse (6 sittings): December 2019 Q7 · May 2016 Q7 · May 2015 Q7 · December 2014 Q8 · May 2014 Q8 · Undated paper Q7
- Structural (6 sittings): December 2019 Q14 · December 2018 Q14 · May 2016 Q15 · May 2015 Q15 · December 2014 Q15 · May 2014 Q15
- Behavioural Patterns (5 sittings): December 2018 Q14 · May 2016 Q15 · May 2015 Q15 · December 2014 Q15 · May 2014 Q15
- Credit-Card Validation (5 sittings): December 2018 Q17 · May 2016 Q17 · May 2015 Q17 · December 2014 Q17 · May 2014 Q17
- Postcondition (5 sittings): December 2019 Q10 · December 2018 Q10 · May 2016 Q10 · May 2015 Q10 · Undated paper Q10
- Precondition (5 sittings): December 2019 Q10 · December 2018 Q10 · May 2016 Q10 · May 2015 Q10 · Undated paper Q10
- Benefits (4 sittings): December 2018 Q7 · May 2016 Q9 · May 2015 Q9 · December 2014 Q8
- Boundary/Entity Classes (4 sittings): May 2016 Q16 · May 2015 Q16 · December 2014 Q16 · May 2014 Q16
Questions by sitting
December 2019
- Question 1: Agile Methodologies vs. Conventional Document-Driven Process Models
- Question 2: Functional vs. Non-Functional Requirements
- Question 3: Software Metrics and the Meaning of "Quantifiable"
- Question 4: Use Case and Class Diagrams for a Personal Financial Management Application
- Question 5: Quality Concerns Driving Different Design Decisions
- Question 6: When White-Box, Black-Box, and Grey-Box Test Cases Can Be Created
- Question 7: Software Reuse — Importance, Activities, and the Two Directions of Reuse
- Question 8: Design-by-Contract — Definition, Example, Pros and Cons
- Question 9: Assertions and How They Implement Design-by-Contract
- Question 10: Preconditions, Postconditions, and Their Relationship to Assertions
- Question 11: Class Invariant — Definition, Example, and Role in Design-by-Contract
- Question 12: Liskov Substitution Principle — A Design That Follows It and One That Violates It
- Question 13: What a Design Pattern Is, and Why Design Patterns Matter
- Question 14: Creational, Structural, and Behavioural Pattern Classification
- Question 15: Factory Method vs. Abstract Factory
- Question 16: Decorator vs. Strategy
- Question 17: The Façade Pattern for a Personal Financial Management Application
- Question 18: MVC Architecture for a Personal Financial Management Application
- Question 19: Boundary, Control, and Entity Classes
- Question 20: Command and Memento for High-Quality GUI Design
- Question 21: Design Strategy for the Three Usability Goals
- Question 22: Favoring Object Composition Over Class Inheritance
- Question 23: Visibility of Classes, Variables, and Methods
- Question 24: Polymorphism, Dynamic Binding, Overloading, and Overriding
- Question 25: friend Access in C++ — Advantages, Disadvantages, and Why Java Disallows It
- Question 26: Programming to an Interface, Not an Implementation
- Question 27: Interface vs. Class, and Simulating a Java Interface in C++
- Question 28: Modular Programming in C++ and Java
December 2018
- Question 1: Waterfall, Iterative & Incremental, and RUP Lifecycle Models
- Question 2: Functional, Quality, Process, Implementation, and Business Requirements
- Question 3: Why Quality Requirements Should Be Quantifiable
- Question 4: Deriving OOD Classes from a Use Case Diagram
- Question 5: Design Decisions, Design Alternatives, and Documented Rationale
- Question 6: Test Cases Developable Before vs. After Implementation
- Question 7: Two Major Tasks, Benefits, and Challenges of Software Reuse
- Question 8: Pros and Cons of Design by Contract vs. Defensive Programming
- Question 9: Verifying Contract Fulfillment — Assertions vs. Defensive Checks
- Question 10: Precondition, Postcondition, and the Importance of a Class Invariant
- Question 11: Implementing the Liskov Substitution Principle Without Knowing Subclasses
- Question 12: A Class Design Example With Class Invariants
- Question 13: Describing the Observer Pattern in Standard Pattern-Language Form
- Question 14: Creational, Structural, and Behavioural Patterns
- Question 15: Decorator vs. Proxy Design Patterns
- Question 16: Observer vs. Mediator Design Patterns
- Question 17: Credit-Card Validation — Template Method Pattern
- Question 18: MVC Class Design for a Stock Monitoring Application
- Question 19: Why Separate Entity, Control, and Boundary Classes
- Question 20: Command and Decorator Patterns for High-Quality GUI Design
- Question 21: Usability Goals for a Hospital Patient Registration System
- Question 22: Programming to an Interface, Not to an Implementation
- Question 23: Encapsulation, Information Hiding, and Message Passing
- Question 24: Polymorphism, Dynamic Binding, Overloading, and Overriding
- Question 25: Pros and Cons of Friend Functions and Friend Classes in C++
- Question 26: Favoring Object Composition Over Class Inheritance, via the Adapter Pattern
- Question 27: Multiple Class Inheritance via Single Inheritance and Interfaces in Java
- Question 28: Boundary Value Analysis for a Price Input
May 2016
- Question 1: Waterfall vs. Spiral Model
- Question 2: Functional and Non-Functional Requirements
- Question 3: Quantifiable Non-Functional Requirements
- Question 4: Use-Case Actors vs. Design Classes (Library Domain)
- Question 5: Design Goals in System Design
- Question 6: Fault, Error, and Failure
- Question 7: Software Reuse
- Question 8: Design by Contract vs. Defensive Programming
- Question 9: Benefits and Challenges of Design by Contract
- Question 10: Precondition, Postcondition, and Class Invariant
- Question 11: The Liskov Substitution Principle
- Question 12: Invariant Strengthening Under Inheritance
- Question 13: Framework, Library, and Design Pattern
- Question 14: The Three Types of the Proxy Design Pattern
- Question 15: Creational, Structural, and Behavioural Patterns
- Question 16: Observer Roles vs. Boundary/Entity Classes
- Question 17: Credit-Card Validation — Pattern Selection
- Question 18: The Model-View-Controller Architecture
- Question 19: Separating Boundary from Entity/Control Classes
- Question 20: Design Patterns Paramount to GUI Design
- Question 21: Non-Functional Requirements for Human-Machine Interfaces
- Question 22: The Open–Closed Principle
- Question 23: Encapsulation, Information Hiding, and Message Passing
- Question 24: Polymorphism, Dynamic Binding, Overloading, Overriding
- Question 25: Friend Functions and Modular Programming
- Question 26: Inheritance vs. Delegation
- Question 27: Multiple Inheritance in Java
- Question 28: Boundary Value Analysis for a Price Input
May 2015
- Question 1: Waterfall vs. Spiral Model
- Question 2: Functional and Non-Functional Requirements
- Question 3: Quantifiable Non-Functional Requirements
- Question 4: Use-Case Actors vs. Design Classes (Library Domain)
- Question 5: Design Goals in System Design
- Question 6: Fault, Error, and Failure
- Question 7: Software Reuse
- Question 8: Design by Contract vs. Defensive Programming
- Question 9: Benefits and Challenges of Design by Contract
- Question 10: Precondition, Postcondition, and Class Invariant
- Question 11: The Liskov Substitution Principle
- Question 12: Invariant Strengthening Under Inheritance
- Question 13: Framework, Library, and Design Pattern
- Question 14: Two Variants of the Adapter Design Pattern
- Question 15: Structural vs. Behavioural Patterns
- Question 16: Observer Roles vs. Boundary/Entity Classes
- Question 17: Credit-Card Validation — Pattern Selection
- Question 18: The Model-View-Controller Architecture
- Question 19: Separating Boundary from Entity/Control Classes
- Question 20: Design Patterns Paramount to GUI Design
- Question 21: Non-Functional Requirements for Human-Machine Interfaces
- Question 22: The Open–Closed Principle
- Question 23: Encapsulation, Information Hiding, and Message Passing
- Question 24: Polymorphism, Dynamic Binding, Overloading, Overriding
- Question 25: Friend Functions and Modular Programming
- Question 26: Inheritance vs. Delegation
- Question 27: Multiple Inheritance in Java
December 2014
- Question 1: Incremental vs. Iterative Development
- Question 2: Functional and Non-Functional Requirements
- Question 3: Extracting Requirements from a Scenario
- Question 4: Quantifiable Non-Functional Requirements
- Question 5: Agile Methods — Interest and Dangers
- Question 6: The Open–Closed Principle
- Question 7: Polymorphism, Dynamic Binding, Overloading, Overriding
- Question 8: Software Reuse — Benefits and Challenges
- Question 9: Use-Case Actors vs. Design Classes
- Question 10: Design by Contract
- Question 11: The Liskov Substitution Principle
- Question 12: Design Goals in System Design
- Question 13: Framework, Library, and Design Pattern
- Question 14: Uses of the Proxy Design Pattern
- Question 15: Structural vs. Behavioural Patterns
- Question 16: Observer Roles vs. Boundary/Entity Classes
- Question 17: Credit-Card Validation — Pattern Selection
- Question 18: Anti-Patterns
- Question 19: The Model-View-Controller Architecture
- Question 20: Separating Boundary from Entity/Control Classes
- Question 21: Design Patterns Paramount to GUI Design
- Question 22: Non-Functional Requirements for Human-Machine Interfaces
- Question 23: Friend Functions and Modular Programming
- Question 24: Inheritance vs. Delegation
- Question 25: Java equals/hashCode and HashSet
- Question 26: Multiple Inheritance in Java
May 2014
- Question 1: Incremental vs. Iterative Development
- Question 2: Functional and Non-Functional Requirements
- Question 3: Extracting Requirements from a Scenario
- Question 4: Quantifiable Non-Functional Requirements
- Question 5: Agile Methods — Interest and Dangers
- Question 6: The Open–Closed Principle
- Question 7: Polymorphism, Dynamic Binding, Overloading, Overriding
- Question 8: Software Reuse
- Question 9: Use-Case Actors vs. Design Classes
- Question 10: Design by Contract
- Question 11: The Liskov Substitution Principle
- Question 12: Design Goals in System Design
- Question 13: Framework, Library, and Design Pattern
- Question 14: Uses of the Proxy Design Pattern
- Question 15: Structural vs. Behavioural Patterns
- Question 16: Observer Roles vs. Boundary/Entity Classes
- Question 17: Credit-Card Validation — Pattern Selection
- Question 18: The Model-View-Controller Architecture
- Question 19: Separating Boundary from Entity/Control Classes
- Question 20: Design Patterns Paramount to GUI Design
- Question 21: Non-Functional Requirements for Human-Machine Interfaces
- Question 22: Friend Functions and Modular Programming
- Question 23: Inheritance vs. Delegation
- Question 24: Java equals/hashCode and HashSet
- Question 25: Multiple Inheritance in Java
Undated paper
- Question 1: Design-Activity Differences Between Waterfall and Agile
- Question 2: Functional vs. Non-Functional Requirements and Their Role in Design
- Question 3: Software Metrics, Their Importance, and Their Relationship to Quality
- Question 4: Use Case and Class Diagrams for a Personal Address Book Application
- Question 5: Why Multiple Design Alternatives Are Produced, and the Basis for Selecting One
- Question 6: Test Cases Derivable From the Design Phase
- Question 7: Software Reuse — Definition, Importance, and Major Activities
- Question 8: Design-by-Contract — Definition, Example, Pros and Cons
- Question 9: Assertions and How They Implement Design-by-Contract
- Question 10: Preconditions, Postconditions, and Their Relationship to Assertions
- Question 11: Class Invariant — Definition, Example, and Role in Design-by-Contract
- Question 12: Liskov Substitution Principle — A Design That Follows It and One That Violates It
- Question 13: The Structured Contents of a Pattern Language
- Question 14: Class-Inheritance-Based vs. Object-Composition-Based GoF Patterns
- Question 15: Factory Method vs. Template Method
- Question 16: State vs. Strategy
- Question 17: The Façade Pattern for a Personal Address Book Application
- Question 18: MVC Architecture for a Personal Address Book Application
- Question 19: Boundary, Control, and Entity Classes
- Question 20: Command and Memento for High-Quality GUI Design
- Question 21: Design Strategy for the Three Usability Goals
- Question 22: Favor Object Composition Over Class Inheritance
- Question 23: Private, Protected, and Public — Meaning and Role in Encapsulation and Modularity
- Question 24: Sample Code for Polymorphism, Dynamic Binding, Overloading, and Overriding
- Question 25: C++ Private-Member Access for Other Classes, and Why Java Disallows It
- Question 26: Programming to an Interface, Not to an Implementation
- Question 27: Java Interface vs. C++ Class, and Simulating Interfaces in C++
- Question 28: Implementing Public/Private Module Relationships in C++ and Java