Lecture 5: Software Design Concepts

Lecture 5: Design Concepts

• Lecture 5 focuses on design concepts related to software creation.
• The topics covered include: What is design?, Designing Software, and Design Concepts.

What is Design?

• Design is the explanation of an idea/concept, typically using diagrams.
• Design's purpose is to serve as a blueprint that enables construction of a product or system.
• A design provides detailed information needed for implementation.

Designing A House

• A diagram illustrates a house's layout, including rooms (Kitchen, Living Room, Room 1, Room 2) and essential elements (WC).

Design

• Mitch Kapor, the creator of Lotus 1-2-3, presented a software design manifesto in Dr. Dobbs Journal.
• Good software design should show:
  • Firmness: No bugs hindering functionality.
  • Commodity: Suitable for intended purposes.
  • Delight: User-friendly experience.

Software Design

• Encompasses guiding principles, concepts, and practices for high-quality system development.
• Design principles form an overriding philosophy to guide the designer.
• Design concepts should be understood before applying design practices.
• Software design practices continuously evolve through better analysis and new methods.

Designing Software

• Software design starts from understanding the problem.
• The analysis model is translated into a design model.
• Information is mapped from the analysis model to design representations (data design, architectural design, interface design, component-level design).

Software Engineering Design

• Data/class design translates analysis classes into implementation classes and data structures.
• Architectural design defines the relationships among software components.
• Interface design specifies how software components interact.
• Component-level design provides procedural descriptions of software components.

Analysis Model → Design Model

• A diagram showcasing the relationship between analysis model and design model is included.

Design and Quality

• The design must include all explicit and implicit customer requirements.
• Designs should be readable, understandable, and supportive for code generation, testing, and maintenance.
• Design should completely address data, functional, and behavioral domains from an implementation perspective.

Quality Guidelines

• Designs should follow established architectural styles (patterns).
• Designs should be modular, partitioned into elements or subsystems.
• Designs should consist of distinct representations for data, architecture, interfaces and components.
• Designs should create appropriate data structures for the implemented classes.

Design Principles

• Design should not be limited by 'tunnel vision'.
• Designs should relate to analysis models.
• Designs should avoid reproducing existing solutions.
• Designs should minimize the gap between software and real-world problems.
• Designs should maintain uniformity and integration.
• Designs should be adaptable to changes.
• Designs should degrade gracefully facing unusual circumstances.
• Design is distinct and different from coding.
• Design quality should be evaluated and corrected continuously rather than after completion.

Fundamental Concepts

• Core concepts include abstraction (data, procedure, control), architecture (overall system design), patterns (proven design solutions), separation of concerns (divide problem into manageable pieces), modularity (breaking software into manageable modules), refinement (working out details), information hiding (protecting internal details), functional independence (single-minded functions), aspects (handling cross-cutting concerns), refactoring (improving design without changing behavior), and object-oriented (OO) design.
• OO design encompasses design classes (entity, boundary, controller), inheritance (inheriting properties from parent classes), messages (stimulating actions in objects), and polymorphism (adapting to different situations).

Data Abstraction

• Real-world objects (a door) can be implemented as a data structure in software.
• Each attribute (manufacturer, model, type etc.) becomes a field in the data structure.

Procedural Abstraction

• A procedural level abstraction that includes an "opening" algorithm.

Architecture

• Software architecture refers to the overall structure and how the structure provides conceptual integrity.
• Structural aspects define the components (e.g., modules, objects, filters) and interactions.
• Additional aspects include extra-functional properties and families of related systems.

Patterns

• Pattern name, intent, synonyms, motivation, applicability, structure, participants, collaborations, consequences, and related patterns are elements of design patterns.

Separation of Concerns

• Complex problems can be handled more efficiently by dividing them into independent parts.
• Each part should address a single concern.

Divide And Conquer

• Divide and conquer is an approach to problem-solving where a larger problem is broken down into smaller sub-problems.

Modularity

• Modularity is a key attribute of software that allows software to be intellectually manageable.
• The use of modules helps to manage complexity.
• The optimal number of modules balances the cost of development and integration.

Sizing Modules

• The size of modules is a crucial aspect that balances the development cost with the integration cost.

Information Hiding

• A design approach to prevent external modification of internal module structures.

Why Information Hiding

• Reduced side effects and global impact of local decisions.
• Easier communication via controlled interfaces and discouragement of global data.

Functional Independence

• Functional independence is an important concept when designing software modules.
• Modules should have high cohesion (single task) and low coupling with other modules.
• Cohesion and coupling can be used as quality measurement indicators.

Stepwise Refinement

• Building designs incrementally, starting with a broad description progressively adding detail.

Aspects

• Addressing cross-cutting concerns in software design.
• Cross-cutting concerns affect several parts of the system.

Aspects - An Example

• Example usage of cross-cutting concerns applied to an e-commerce system ( SafeHomeAssured).

Refactoring

• Refactoring is improving the internal structure without changing the external behavior.
• It addresses issues such as redundancy, unused elements, inefficient algorithms, and more.

OO Design Concepts

• Design classes, inheritance, messages, polymorphism-characteristics of Object-oriented programming (OOP).

Design Classes

• Classes crucial for creating software interfaces (boundary classes), managing data and interactions (controller classes), and representing data elements (entity classes).
• Design classes can be further categorized by attributes and characteristics like completeness, primitiveness, high cohesion, and low coupling.