MODELING - SYSTEM DESIGN, DESIGN PROCESS, DESIGN CONCEPTS AND DESIGN MODEL Flashcards
How does one transalate the requirements model into the design model?
- This process involves converting the high-level specifications and functional requirements outlined in the requirements model into a detailed design that can be implemented.
- The translation process may vary depending on the development methodology and the specific characteristics of the project.
- Additionally, using modeling tools and notations (such as UML) can aid in the visualization and communication of the design model.
What are the Software Design Objectives?
- Correctness,
- Completeness,
- Efficiency,
- Flexibility,
- Consistency,
- Maintainability.
Exaplain the Design Process.
1.Involves the systematic and creative application of design principles and techniques to transform requirements into a solution that meets the specified objectives,
2. Crucial phase that bridges the gap between the conceptualization of a system and its actual implementation.
Talk about the Desing Concept - Abstraction.
Definition: Abstraction involves simplifying complex systems by modeling classes based on essential characteristics and ignoring unnecessary details. It allows developers to focus on relevant aspects without being overwhelmed by the intricacies of the entire system.
Application: Abstraction is applied through the use of abstract classes, interfaces, and high-level design models that provide a simplified view of the system’s functionality.
Talk about the Desing Concept - Architecture.
Definition: Architecture refers to the overall structure and organization of a software system. It involves high-level decisions on how components will interact, the system’s behavior, and the distribution of responsibilities.
Application: Designing a system with a well-defined architecture ensures scalability, maintainability, and the alignment of the software with business goals.
Talk about the Desing Concept - Patterns.
Definition: Design patterns are reusable solutions to common problems in software design. They represent best practices that have evolved over time and provide templates for solving recurring design challenges.
Application: Patterns, help create maintainable and modular systems by providing tested and proven solutions to specific design issues.
Talk about the Desing Concept - Separation of Concerns.
Definition: This principle advocates dividing a system into distinct modules or layers, each responsible for a specific concern. It helps manage complexity by isolating different aspects of the software.
Application: In practice, this could mean separating the user interface from business logic and data storage, allowing each component to be developed, tested, and maintained independently.
Talk about the Desing Concept - Modularity.
Definition: Modularity involves breaking down a system into smaller, independent, and interchangeable components. Each module should have a specific and well-defined set of responsibilities.
Application: Modularity enhances reusability and maintainability. It allows developers to work on different modules simultaneously, and changes to one module have minimal impact on others.
Talk about the Desing Concept -Sizing Modules
Definition: This concept involves determining the size and scope of modules within a system. The two views refer to the perspective of the end-users and the perspective of developers, each influencing module size.
Application: Balancing user needs and developer considerations helps in creating modules that are both functional for end-users and manageable for development teams.
Talk about the Desing Concept - Information Hiding
Definition: Information hiding involves restricting access to certain details of a module or object and exposing only what is necessary for external interactions.
Application: This concept enhances security, reduces complexity, and allows for changes in the internal implementation without affecting the external interfaces.
Talk about the Desing Concept -Functional Independence (Encapsulation)
Definition: Encapsulation involves bundling data and methods that operate on the data into a single unit, promoting information hiding and enhancing security.
Application: By encapsulating functionalities, developers can control access to data, limit unintended side effects, and create more modular and maintainable code.
Explaing what is Cohesion and Coupling and how high cohesion and low coupling are essential design concepts as well.
Cohesion: Cohesion refers to the degree to which elements within a module or component belong together. It measures how closely the responsibilities of a module are related to each other.
Coupling: Coupling is the degree of dependence between different modules or components in a system. It measures how much one module relies on another.
Relationship: High cohesion ensures that each module has a well-defined purpose, making it more understandable and maintainable. Low coupling ensures that modules are independent and can be modified with minimal impact on other parts of the system, promoting flexibility and ease of change.
Talk about the Desing Concept -Stepwise Refinement.
Definition: Stepwise refinement is an iterative approach to system design where a high-level design is successively refined into more detailed and specific designs.
Application: Starting with a broad view of the system and gradually refining it helps manage complexity and ensures that each level of design is well thought out before moving on to the next.
Talk about the Desing Concept - Design Classes
Definition: Design classes involve creating class structuresthat represent the key components and entities in a system, considering attributes, methods, and relationships.
Application: Well-designed classes form the building blocks of a system, promoting modularity, reusability, and maintainability.
Talk about the Desing Concept -Refactoring
Definition: Refactoring is the process of restructuring existing code without changing its external behavior. It aims to improve code quality, maintainability, and readability.
Application: Regularly refactoring code helps address technical debt, improves design, and ensures that the codebase remains flexible and adaptable to changing requirements.
