Design for change and extensibility in Software Engineering - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does 'Design for change' mean in software engineering?

It means creating software in a way that makes it easy to modify or update later without major rewrites.

beginner

Why is extensibility important in software design?

Extensibility allows adding new features or capabilities to software without breaking existing parts.

intermediate

Name a common design principle that supports change and extensibility.

The Open/Closed Principle: software entities should be open for extension but closed for modification.

intermediate

How does modular design help with change and extensibility?

Modular design breaks software into independent parts, so changes in one part don’t affect others, making updates easier.

beginner

Give a real-life example of designing for change.

Building a house with removable walls so rooms can be changed later without rebuilding the whole house.

What does 'extensibility' allow in software?

A Adding new features without breaking existing code

B Making software run faster

C Removing old features permanently

D Writing code without comments

Extensibility means you can add new features without affecting existing functionality.

Which principle supports designing software that can change easily?

A Open/Closed Principle

B Don't Repeat Yourself

C KISS (Keep It Simple, Stupid)

D YAGNI (You Aren't Gonna Need It)

The Open/Closed Principle encourages designs open to extension but closed to modification.

Modular design helps with change because it:

A Combines all code into one file

B Breaks software into independent parts

C Removes all comments

D Makes software run slower

Breaking software into modules isolates changes to one part without affecting others.

Designing for change means:

A Writing code only once

B Making software hard to update

C Ignoring future needs

D Planning so software can be easily modified later

Designing for change means planning ahead to make future updates easier.

Which is a good example of extensibility?

A Deleting old files randomly

B Hardcoding all values

C Adding a new button to an app without changing existing code

D Ignoring user feedback

Adding new features without changing existing code shows extensibility.

Explain in your own words why designing for change is important in software development.

Think about how software needs to evolve over time.

Describe how modular design supports extensibility and change.

Consider how breaking a big problem into smaller pieces helps.