Software Design Principles PDF

Software design is the process of creating a specification for a software artifact to meet specific goals, utilizing primitive components under various constraints. **1. Conceptual Design (Left Side)**: This part focuses on high-level, abstract aspects of the software design. **Customers**: Repre...

Software design is the process of creating a specification for a software artifact to meet specific goals, utilizing primitive components under various constraints. **1. Conceptual Design (Left Side)**: This part focuses on high-level, abstract aspects of the software design. **Customers**: Represented as actors, they provide input for the conceptual design. Their needs and requirements are gathered here. **Designers**: They translate customer requirements into conceptual designs, which is a more abstract version of what the final system should look like. This involves the detailed, technical aspect of software design, focusing on how the system will be implemented. **System Designers**: Another set of actors who work with technical specifications to produce a detailed design that can be implemented by developers. **Designers**: These individuals (or teams) also collaborate in creating the technical design. **3.Flow**:-The flow between **Conceptual Design** and **Technical Design** is mediated by the **Designers**, who bridge the gap between the customer\'s abstract requirements and the technical implementation. In summary, the diagram emphasizes that software design involves collaboration between designers, customers, and system designers, starting from abstract ideas (conceptual design) to detailed technical specifications (technical design). Key components requiring design include User Interface design, Database design, Application design, Network design and System Interface design. Software design involves two main activities: software architectural design, which outlines the software\'s top-level structure and identifying various components,and software detailed design, which specifies each component for coding. S/W Architectural design describes how software is decomposed and organized into components. S/W Design Process -Design is the process of deciding how software will meet requirements, and usually excludes detailed coding levels. -Design can be viewed as a series of decision making in light of the s/w development context. As you progress through the design, you encounter multiple design issues or sub-problems. For each of these issues, there are usually several alternative solutions, also known as design options. The combination of all these possible choices creates the design space. -Each issue normally has several alternative solutions also known as design *options*. -To make each design decision,the designer requires knowledge of functional and non-functional requirements, available technology, design created so far,software design principles and best practices and what has worked well in the past. The design space refers to the range of possible designs that can be created by making different choices during the design process. It emerges from the various design decisions a designer must make. For example: Overall *goals* of good design include : 1.Increasing profit by reducing cost and increasing revenue 2.Ensuring that we actually conform with the requirements 3.Accelerating development 4.Increasing qualities such as Usability,Efficiency,Reliability,Maintainability,Reusability Where do we start design? Start at the highest level (architectural, general or conceptual), and refine to the detailed level ( low level such as design of specific programs) **TOP DOWN DESIGN** In this design: You begin by designing the very high level structure of the system. Then, you progressively decompose this high-level into more detailed decisions. This process of breaking down continues until you reach a level of detail that can be directly implemented such as the format of particular items,the individual algorithms that will be used. **Bottom-up Design** This design involves: 1.Making decisions about reusable low-level utilities or components first. 2.Then deciding how these low-level components will be combined to create higher-level constructs. **Hybrid Design** A mix of top-down and bottom-up approaches are normally used: **Top-down design** is almost always needed to give the system a good structure. **Bottom-up design** is normally useful so that reusable components can be created. Techniques for making good design decisions Using priorities and objectives to decide among alternatives Step 1: List and describe the alternatives for the design decision. Step 2: List the advantages and disadvantages of each alternative with respect to your objectives and priorities. Step 3: Determine whether any of the alternatives prevents you from meeting one or more of the objectives. Step 4: Choose the alternative that helps you to best meet your objectives. Step 5: Adjust priorities for subsequent decision making Primary Design Principles **Separation of concerns**. Divide your application into distinct features with as little overlap in functionality as possible.This is to minimize interaction points and achieve high cohesion and low coupling among modules. However, separating functionality at the wrong boundaries can result in high coupling and complexity between features even though the contained functionality within a feature does not significantly overlap. **Abstraction** It focuses on identifying essential aspects while ignoring irrelevant details, thereby reducing complexity through information hiding. **Restricted Visibility:** **Locality of Information**: This principle refers to keeping related information and functionality together in the same place. It ensures that only the necessary parts of a program are visible or accessible to other components. **Simplicity:** Emphasis on Clear, Simple Software: This principle focuses on making the design of software easy to understand, check, and modify. **General Design Concepts** General design concepts include decomposition,information hiding and modularity. **1.Decomposition** **-**Handles complexity by splitting large problems into smaller manageable problems. -Parts can be replaced without having to replace other parts. These are the steps to follow for decomposition: 1\. Select a piece of the problem (initially, the whole problem) 2\. Determine the components in this piece using a design paradigm, e.g., functional, structured, object-oriented, generic. 3\. Describe the components interactions -Each design unit hides internal details of processing activities. They communicate only through well-defined interfaces. They are also specified by as little information as possible. -If internal details change, client units should need no change. **Modularity** Modularity is important for both design and implementation phases and is also crucial for creating independent abstractions. Module prescriptions: -- Modules should possess well-specified abstract interfaces. -- Modules should have high cohesion and low coupling. Modularity also facilitates extensibility, reusability, compatibility, and portability. Modularity is an important characteristic of good designs because it: i)allows for separation of concerns. ii\) enables developers to reduce overall system complexity via decentralized software architectures. iii) enhances scalability by supporting independent and concurrent development by multiple personnel **Cohesion and Coupling** They are vital for evaluating design quality. A module that performs a single task has a high degree of cohesion,which is desirable. What about coding of highly cohesive modules? 1.Much easier to code and reuse. 2.Easier to maintain. Modules that are independent are loosely coupled, which is desirable. Easier to maintain and modify loosely coupled modules since logic in one module does not interfere with other modules. Tightly coupled modules, one module is linked to internal logic contained in another module. **S/W Design Approaches** Software design encompasses various approaches including Function-Oriented (Structured) Design, Object-Oriented Design, and Component-Based Design (CBD). Function-Oriented Design involves: 1. reviewing fundamental system models essentially level 0 DFD, the outcome of the review and key system process. 2\. Reviewing and refining data flow diagrams for the S/W e.g.level 2,3 until the DFDs do not require further refinement 3.Mapping the DFD into a program structure amenable to transaction processing. 4.Identifying modules and relationships. Each DFD level presents a processing level You can divide processes into smaller modules to handle single tasks 5.Reviewing data flows, data dictionary to identify data elements that pass from one module to another 6.Ensuring high cohesion and loose coupling, and developing processing narratives for each module