Software Design Concepts:
• Information Hiding:
This principle dictates that modules should be designed to conceal internal
details (data structures, algorithms) from other modules. Only necessary
information is exposed through well-defined interfaces, minimizing the
impact of changes within a module on other parts of the system.
• Functional Independence:
Achieved when modules perform a single, well-defined task and have
minimal interaction with other modules. This promotes high cohesion
(elements within a module are functionally related) and low coupling
(minimal dependencies between modules), leading to more maintainable
and reusable code.
• Refinement:
A top-down design approach where a high-level design is progressively
elaborated by adding increasing levels of detail. This iterative process helps
in breaking down complex problems into manageable sub-problems.
• Aspects:
In aspect-oriented programming, aspects address cross-cutting concerns
(e.g., logging, security, transaction management) that are not easily
localized within a single module. Aspects encapsulate these concerns and
can be woven into multiple modules without modifying their core logic.
• Refactoring:
The process of restructuring existing code without changing its external
behavior. This is done to improve code quality, readability, maintainability,
and reduce technical debt, often by applying design patterns or addressing
code smells.
Object-Oriented Design (OOD) Concepts:
OOD is a paradigm centered around "objects" that encapsulate data and
behavior. Key concepts include:
• Encapsulation:
Bundling data and methods that operate on the data within a single unit
(class), controlling access to the internal state.
• Inheritance:
A mechanism where a new class (subclass) derives properties and
behaviors from an existing class (superclass), promoting code reuse and
establishing a hierarchical relationship.
• Polymorphism:
The ability of objects of different classes to respond to the same message or
method call in different ways, enabling flexible and extensible systems.
Design Classes:
Design classes are the building blocks of an object-oriented design
model. They represent the core entities and their relationships within the
software system, often derived from the analysis model.
Design Model Levels:
The design model typically encompasses multiple levels of abstraction:
• Data Design:
Focuses on defining the data structures, relationships, and persistence
mechanisms within the system.
• Architectural Design:
Defines the overall structure of the software system, including its major
components, their interactions, and the architectural style (e.g., client-server,
layered).
• Interface Design:
Specifies the user interfaces and the interfaces between different software
components, defining how users and components interact with the system.
• Component-Level Design:
Details the internal design of individual software components, including their
classes, methods, and data structures.
• Deployment-Level Design:
Describes how the software components are mapped to physical hardware
and network configurations for deployment and execution.