8 Flashcards
is a mechanism to transform user requirements into some suitable
form, which helps the programmer in software coding and implementation.
Software Design
It deals with representing the client’s requirement, as described in SRS (Software
Requirement Specification) document, into a form, i.e., easily implementable using
programming language.
Software Design
6 Objectives of Software Design
Correctness
Completeness
Efficiency
Flexibility
Consistency
Maintainability
are concerned with providing means to handle the
complexity of the design process effectively. Effectively managing the complexity will
not only reduce the effort needed for design but can also reduce the scope of
introducing errors during design.
Software Design Principles
These are recommendations that help you write code that is clear, manageable, and
scalable. These principles give a foundation for developing software systems that are
both robust and responsive to change.
Software Design Principles
4 Software Design Principles
Problem Partitioning
Abstraction
Modularity
Top Down & Bottom up Strategy
For small problem, we can handle the entire problem at once but for the significant
problem, divide the problems and conquer the problem it means to divide the
problem into smaller pieces so that each piece can be captured separately.
Problem Partitioning
- For software design, the goal is to divide the problem into manageable pieces.
Problem Partitioning
6 Benefits of Problem Partitioning
- Software is easy to understand
- Software becomes simple
- Software is easy to test
- Software is easy to modify
- Software is easy to maintain
- Software is easy to expand
A module is specified by the method it performs.
Functional Abstraction
is a tool that enables a designer to consider a component at an
abstract level without bothering about the internal details of the implementation.
Abstraction can be used for existing element as well as the component being
designed.
Abstraction
two common abstraction mechanisms:
Functional Abstraction
Data Abstraction
The details of the algorithm to accomplish the functions are not visible to the
user of the function.
Functional Abstraction
forms the basis for Function oriented design approaches.
Functional Abstraction
Details of the data elements are not visible to the users of data.
Data Abstraction
forms the basis for Object Oriented design approaches.
Data Abstraction
specifies to the division of software into separate modules which are
differently named and addressed and are integrated later on in to obtain the
completely functional software.
Modularity
It is the only property that allows a program to be intellectually manageable. Single
large programs are difficult to understand and read due to a large number of
reference variables, control paths, global variables, etc.
Modularity
Advantages of Modularity
- It allows large programs to be written by several or different people
- It encourages the creation of commonly used routines to be placed in the library and
used by other programs. - It simplifies the overlay procedure of loading a large program into main storage.
- It provides more checkpoints to measure progress.
- It provides a framework for complete testing, more accessible to test
- It produced the well designed and more readable program.
Disadvantages of Modularity
- Execution time maybe, but not certainly, longer
- Storage size perhaps, but is not certainly, increased
- Compilation and loading time may be longer
- Inter-module communication problems may be increased
- More linkage required, run-time may be longer, more source lines must be written,
and more documentation has to be done
is achieved by developing
functions that perform only one kind of task and do not excessively interact with other
modules. Independence is important because it makes implementation more accessible
and faster. The independent modules are easier to maintain, test, and reduce error
propagation and can be reused in other programs as well. Thus, functional
independence is a good design feature which ensures software quality.
Functional Independence:
It measures the relative function strength of a module.
Cohesion
It is measured using two criteria:
Cohesion:
Coupling:
It measures the relative interdependence among modules.
Coupling:
The fundamental of Information hiding suggests that modules
can be characterized by the design decisions that protect from the others, i.e., In other
words, modules should be specified that data include within a module is inaccessible to
other modules that do not need for such information.
Information hiding
To design a system, there are two possible approaches:
Top-down Approach
Bottom-up Approach
A good system design strategy is to organize the program modules in such a method
that are easy to develop and latter too, change. Structured design methods help
developers to deal with the size and complexity of programs. Analysts generate
instructions for the developers about how code should be composed and how pieces of
code should fit together to form a program.
Strategy of Design
SOLID Principles
(Single Responsibility, Open-Closed, Liskov Substitution, Interface
Segregation, Dependency Inversion)
Additional Software Design Principles
- SOLID Principles (Single Responsibility, Open-Closed, Liskov Substitution, Interface
Segregation, Dependency Inversion) - DRY (Don’t Repeat Yourself)
- Encapsulation Principle
- Principle of Least Astonishment (PoLA)
- You Aren’t Gonna Need It (YAGNI)
- Keep It Simple, Stupid (KISS)
DRY
(Don’t Repeat Yourself)
(PoLA)
Principle of Least Astonishment (
(YAGNI)
You Aren’t Gonna Need It
Different Designs in Software
Architectural Pattern
Design Pattern
KISS
Keep It Simple, Stupid
explains a system’s core ideas and characteristics with
respect to its relationships, environment, and other design principles. It includes a
software system’s organizational structure, behavioral components, and composition
of those components into more complex subsystems.
Software architecture
defines the high-level structure and organization
of a software system. It outlines the fundamental components, their interactions,
and the overall layout of the system. It guide decisions about the system’s scalability,
performance, and maintainability. They focus on the system’s macro-level aspects
and establish a framework for the design and implementation of the entire
application.
software architecture pattern
6 Different Architectural Patterns
- Layered Pattern
Client-server architecture
event-driven architecture
Microservices
Monolithic
MV Pattern
Separates application into clients (user interfaces) and servers (data processing) to manage
data sharing and user interactions. Ideal for distributed systems like web-based services.
Client-server architecture
It is one of the most common types of architecture in software engineering. Organizes
software into horizontal layers, each responsible for distinct functionalities like presentation,
business logic, and data storage. Enables modular development and maintenance, commonly used in web applications.
Layered Pattern
Emphasizes communication between components through asynchronous events, triggered by
user actions or data changes. Used in real-time systems and graphical user interfaces.
event-driven architecture
Structures applications as a collection of small, independently deployable services, enabling scalability and rapid development. Common in cloud-based systems.
Microservices
An older approach where all components of an application are tightly integrated into a single codebase and are deployed together. While less common now, it’s still seen in some legacy systems.
Monolithic
It is an umbrella term that encompasses variants of this architecture pattern, and they differ in terms of the type and level of coupling between the components.
MV* Pattern
are an important concept in software development. They provide
tested answers to common design issues, helping developers reduce code structure and
improve maintainability. Design patterns allow you to construct resilient and scalable
systems while also supporting excellent software architectural practices.
Design Pattern
is a general, recurring solution to a commonly encountered problem in
software design that is utilized in software engineering.
Design Pattern
It is not a comprehensive design that can be implemented in code straight immediately.
Design Pattern
It is a description or model for issue solving that may be used in a variety of settings.
Design Pattern
are similar to cooking recipes in that they provide a tried-and-true
approach to producing consistent results without having to start from scratch each time.
Design Pattern
Attempt to generate things in a manner appropriate to the situation.
Creational Design Patterns
Types of Design Pattern
- Creational Design Patterns
- Structural Patterns
- Behavioral Design Patterns
Are concerned with the generation of objects, ensuring that they are formed in a
situationally appropriate manner and providing flexibility in how objects are instantiated.
Creational Design Patterns
Concerned with object composition, specifying how to combine items to achieve
additional functionality
Structural Patterns
It is a formula for combining many objects and classes to create a larger structure.
Structural Patterns
It’s similar to building a house based on a blueprint.
Structural Patterns
These patterns tell us how to incorporate the distinct components of a system in a way
that is simple to update or grow without affecting the overall system.
Structural Patterns
These patterns help resolve typical issues with how parts of codeshare work, disguise
what they do, and stay organized.
Behavioral Design Patterns
When developers adopt these patterns, it’s like putting together a jigsaw, with the
pieces fitting together effortlessly.
Behavioral Design Patterns
This makes the software more organized, easy to alter, and less likely to break when we
add or change things.
Behavioral Design Patterns
is an essential phase of the Software Development Life Cycle. The list of
requirements that you develop in the definition phase is used to make design choices. In
the design phase, one or more designs are created to achieve the project result.
Depending on the project subject, the design phase products include dioramas, flow
charts, sketches, site trees, HTML screen designs, photo impressions, prototypes, and
UML schemas.
Design Phase in SDLC
All the details about the system design phase are mentioned in the software requirement
specification document. It helps development teams in the implementation phase for
error-free system development.
true
A thorough analysis and requirement helps to prepare better designs at once. Many
companies follow agile methodology for software development.
Design Phase in SDLC
Many types of designs are created in this phase of the software development process.
Depending on the business requirements and the client’s needs, the design is improved
many times. Moreover, developers build a minimum viable product and get feedback from
real customers.
Design Phase in SDLC
A software developer checks all required documents for a better production environment.
Since designing defines the entire system architecture, no development team moves
forward without it.
true
The design of a software system falls into two categories.
1) High-Level Design (HLD):
2) Low-Level Design (LLD):
It includes the functional logic of the modules. You have to collect the details of the
interface, database tables, and type and size. Furthermore, a listing of error messages,
and addresses dependency issues.
2) Low-Level Design (LLD):
It includes a brief description and the name of each module. So, you have to analyze the
functionality of each module. Moreover, key elements are used to identify the database
tables.
1) High-Level Design (HLD):
At this stage, developers define the technical details of the product. They are as follows.
- Screen design
- Sketches
- System interfaces
- UI/UX designs
- Databases
- Prototypes
Roles in design phaseq
Client.
* UX designer.
* Project manager.
* Business analyst.
* Software developer.
* Quality assurance (QA) specialist.
Provides business-related information, reviews materials prepared by the team,
and approves project milestones.
Client
Ensures that the user’s interaction with the product is logical by creating
user-centered product interface designs
UX designer.
Leads the project and makes decisions to ensure a successful
outcome (project organization, task allocation, budget planning, progress monitoring,
and others).
Project manager.
Helps clients translate their requirements into product features,
create an original code for the product
- Software developer.
Creates product requirements for UX designers and reviews the
designs they make
Business Analyst
Involved in analyzing requirements and testing
product designs to ensure a lack of performance issues.
- Quality assurance (QA) specialist.
Requirements Visualization in Design Phase
Rapid Prototyping
Wireframes
Starting with a clean, spare wireframe design also gives UI/UX designers room to iterate. They can
collect early feedback from user testing on core UX/UI elements, without distracting users with
visual design details. Design teams try out different concepts, user flows, and templates as they
work toward the ultimate user experience.
true
basic blueprints that help teams align on requirements, keeping UX design
conversations focused and constructive.
wireframe
Your wireframe shows the design team and stakeholders the bare- bones outlines of essential webpages, components, and features, including:
* Screen layouts
* Navigation bars
* Components of UX and UI design
* Interactive elements
true
prioritizes speed, so it’s limited in scope—but even a quick mockup
can stress-test and improve a product design.
rapid prototyping
Test your prototype with target users and key stakeholders to learn whether it
meets expectations.
- Review.
The three-step rapid prototyping process
is basically a loop that repeats until you’ve got a prototype that resonates with your
users.
The main steps are:
Build.
* Review.
* Refine.
Create mock-ups of a design concept or flow, keeping your users’ needs and
company’s goals in mind.
Build
Adjust the prototype based on the feedback you receive.
- Refine.
