CEN 4065 - Lecture 2: Software Design Vocabulary

Vocabulary flashcards covering key software design concepts from the lecture slides.

Software design

The process of defining a system's architecture, components, interfaces, and other characteristics, and the result of that process.

Design fundamentals

Concepts, context, and processes that underlie software design.

Key design issues

Structure and architecture, user interface design, design quality analysis and evaluation, notations, strategies, and design tools.

SOLID Principles

Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion. A set of object-oriented design guidelines aimed at creating software systems that are more maintainable, flexible, scalable, and understandable over time.

Single Responsibility Principle

A class should have one and only one reason to change.

Open/Closed Principle

Objects or entities should be open for extension but closed for modification.

Liskov Substitution Principle

Objects in a program should be replaceable with instances of their subtypes without altering correctness.

Interface Segregation Principle

Many client-specific interfaces are better than one general-purpose interface.

Dependency Inversion Principle

Entities should depend on abstractions, not on concretions.

DRY (Don’t repeat yourself)

Every small piece of knowledge should occur exactly once in the system.

KISS (Keep it simple, stupid)

Keep software simple and avoid unnecessary complexity.

YAGNI (You ain’t gonna need it)

Implement things when you actually need them, not before.

Abstraction

Data and procedural abstraction; separating what is important from how it is implemented.

Architecture

Overall structure of software, how components interact, and data organization.

Design patterns

Reusable solutions to common design problems; patterns describe structure and interactions.

Design Pattern Template

A structured description of a pattern including name, intent, applicability, structure, participants, collaborations, consequences, and related patterns.

Creational Design Patterns

Patterns that provide object creation mechanisms to increase flexibility and reuse (e.g., Factory Method, Builder).

Structural Design Patterns

Patterns that organize classes and objects into larger structures (e.g., Adapter, Facade, Decorator, Proxy).

Behavioral Design Patterns

Patterns that define how objects interact and assign responsibilities (e.g., Observer, Strategy, Command, State).

Observer Pattern

Separates the display of object state from the object and updates observers when state changes.

Model-View-Controller (MVC)

A design pattern that separates data (Model), presentation (View), and input control (Controller) to organize code.

Repository Architecture

Subsystems share a central data repository; data exchange through the central data structure.

Client-Server Architecture

Distributed system model where clients request services from servers over a network.

Pattern (Architectural pattern)

A stylized description of a good design practice that can be reused across contexts and environments.

Class diagrams

A UML diagram showing classes, their attributes, operations, and relationships.

CRC models

Class-Responsibility-Collaborator models used to design class responsibilities and collaborations.

Use cases

Narratives describing system behavior from the user perspective to capture requirements.

Sequence diagrams

Diagrams that show object interactions in time order.

State diagrams

Model the states and transitions of a system or object.

Activity diagrams

Model the workflow of steps or activities in a process.

Interface design elements

Interfaces include UI, external interfaces to other systems, and internal interfaces between design components.

Golden Rule: Place User in Control

Design interaction so the user is in control, with flexible, interruptible, and understandable workflows.

Golden Rule: Reduce User's Memory Load

Minimize memory requirements by using defaults and intuitive shortcuts.

Golden Rule: Make Interface Consistent

Maintain consistency to help users predict behavior and learn quickly.

User Interface Design

Focus on the interface between product and user; plan how information is presented and interacted with.

Usability Guidelines

Principles guiding interface usability, including anticipation, communication, consistency, efficiency, and learnability.

Accessibility Guidelines

Guidelines to ensure interfaces are usable by people with disabilities, addressing response time, help facilities, and error handling.

CBSE (Component-Based Software Engineering)

Building software from pre-existing or reusable components to reduce development effort.

CBSE Benefits

Faster development, ROI improvements, reuse of components, higher quality, easier maintenance.

CBSE Risks

Risks include component selection, integration, quality, security, and evolution.

Refactoring

Reorganizing code to improve quality without changing functionality; reduces technical debt.

Stepwise Refinement

Incremental elaboration of detail for abstractions.

Information Hiding

Hiding implementation details behind controlled interfaces to reduce dependencies and side effects.

Cohesion

The single-mindedness of a module; high cohesion groups related functionality.

Coupling

Degree of interdependence between components; aim for low coupling.

High cohesion, Low coupling

Design goal where components are highly cohesive and loosely coupled to others.