I think software design is like a logical pipeline for a piece of
software. This can include a description of the logical organization of
data structures, independent of their actual implementation. It should
show the input and output of the software along with how information
is stored and processed in between. Basically, software design is
an overview of the information and it's processing as performed
by the software.
To the best of my knowledge, software design is the process by which an
idea goes from being merely a thought to being a functional computer
program that is usable by people other than the designers. Many programs
are only meant to be tools for the coder, but if a piece of software is
going to be widely used, it needs to be properly designed. A good software
design should include a hierarchical plan for the implementation of the
starting with the big picture and getting progressively more specific.
This can look like breaking the problem down into modules and
then breaking each module down into individual classes. Different programming
problems require different design paradigms that specify how the program's
subparts are going to interact.
Another property that well designed
software should have is that the parts should be modular so that if one
breaks or need updating, the rest don't need to be adjusted.
The term "software design" describes a process for the creation of a
computer program. The design process involves the idea or motive for
the software and
should consider any constraints of the system or platform
for which it is being built. Software design is an aspect of software
engineering, and it is sometimes integrated with other software engineering
aspects like implementation or production.
Software design is the phase in the software development process where
functional specifications are translated into coherent architectural
structures which can be mapped to an implementation environment.
Contemporary software design utilizes UML and design patterns to
produce artifacts which are then interpreted by software implementers
to produce concrete software products. Designs specify, among other
things, modularization, component interfaces, human factors, security,
extensibility and maintainability.
Software is a set of instructions that is given to the computer (programs),
that on execution performs desired function, along with the data structures
to manipulate information and the related documentation. In general, design
is the process of representing the system that is to be built, by breaking
down the system into several parts and assigning attributes to each of
Software design is an iterative process to translate the requirements of
the software to a "blueprint" for constructing the software. It involves
identifying modules in the system, their function and their relationship
with other modules.
During the design process, the requirements of the
software are translated to a detailed design of data, architecture,
components and interfaces. The design process could either be recursive
decomposition of modules or recursive grouping of several modules or a
combination of both. The output of the design phase is a "software design",
which ultimately results in software that would meet functional, behavioral
and quality goals. Software design aids primarily in providing quality
along with providing stability/robustness, reducing the cost of rework,
re usability, modularity etc. In short, it is the first technical step
and the most crucial one in the software development process.
Software design is the process of conceiving (not implementing) a
software system that
solves a problem through the use of computers.
It decomposes a problem into a hierarchy of subproblems.
hierarchy, there are notions of low-level and high-level design.
Low-level design is devising algorithms that accomplish a specific
task, while high-level design dictates how the lower level pieces interact.
Software design is the process of planning a software system.
Software requirements must be in place before a system can be designed.
These requirements are a contract between the client and the developer
that define the features of the system. Requirements can be changed
depending on the development method. For example, in the waterfall method,
requirements are created before the system is designed and are solidified,
but in an iterative method, requirements can be changed at each step
in the development cycle. After requirements are defined, developers
can start planning how a system will be designed. This process takes
the requirements from a document to an implemented system which proves
that the design of a software system is important. If a system has a
flaw in its design, it is plausible that the complete system may have
to be redesigned.
Software design is a difficult problem;
tools have been created to aid designers. Tools such as Unified Modeling
Language (UML), allow designers to graphically visualize a software system.
Design patterns are another tool that solves recurring problems in
software design. These tools do not completely solve all of the problems;
thus, it is important to explore other possible solutions.
Software design is the process by which abstract ideas are transformed
into concrete programs. Along the way, various levels of abstraction
(such as use cases, design patterns, iterations) are used to further
refine the idea in the space of computer programming.
Software design is the half art, half science of developing 'good' software.
It involves the careful consideration of feature requirements, user
expectations, and tools available to craft the right solution: on time,
feature rich, and defect free. Common paradigms of component interaction
have become standard over time, the use of which aids the design process
and makes for more re-usable software.
Software design is the process of mapping user requirements to a
functional tool. It involves multiple iterations of gathering user
requirements combined with programming language selection, data object
creation, prototyping of the tool, and testing the prototype.
The design of software should be based on these user requirements,
and most software can be built on fundamental design patterns
and can be proved correct using a functional logic.
To my mind, software design is a set of patterns/practices that are
employed in developing software. Particularly with larger software
systems, where a number of people might be involved in various stages of
the development, having a set of 'blueprints' is necessary in order to
maintain consistency and overall efficiency. The design concepts are
applied at all stages of development: the higher-level design, breaking
the problem into various modules,
the lower-level design where specific
algorithms are chosen,
implemented and tested, documentation, and even
testing and maintenance. In some sense, it's a combination of art and
theory: where the art comes from experience and a set of 'good' practices
and the formal theory aspect comes from quantifying software design
patterns (the syllabus mentions temporal logic and algebraic specification
of ADTs - I'm not yet sure of the details). While not yet familiar with
many software design concepts (apart from what I've picked up in
practice), one of the themes that I've come across, is the 'adding
manpower to a late software project makes it later' adage from The
Software design is a critical step in the software development process
that results in software products. A typical software development process
may be carried out through the following stages: Requirement analysis,
Software design, Implementation (coding), Testing (QA), Maintenance
(Bug fixing). Although there are several different approaches to software
development, most of them share some combination of these stages among
which software design always plays an important role and occurs before
implementation stage. Software design usually takes the output of
requirement analysis as input and generates a set of documented
specifications or prototypes, based on which software developers
can write the source code. Sometimes requirement analysis is also
considered part of software design process, making software design
a more general concept in software development cycle. After requirement
analysis, the target functions desired from the software are obtained
and further specified as features of software products.
The task of
software design then involves developing a plan for a solution to
produce software that have desired features.
It includes specifications
on all levels of the software structure, ranging from low-level
data structures and algorithms to abstract architectural view.
Depending on the characteristics of software, software design may
involve different design activities. For software with user interaction
user experience design is involved to determine how the software
is supposed to interface with user and satisfy the requirements,
while for other kinds of software this might not be necessary. In most
cases efforts are made to determine the plan to construct the software
from the technical viewpoints during software design process.
A part of the plan is the software architecture, i.e. the components
and their organization into a complete software product. Another part is
the decision on techniques to use or create for realizing desired features.
The plan also includes elaboration on how to implement each components.
During software design process modeling languages are used to help
expressing the information or knowledge on various aspects of software,
defining the structure and mechanism inside a complex system as well as
all the other modeling problems encountered. The specification on how
the software should be developed is documented and provided as the
product of software design. Occasionally prototypes are provided
to testify the design feasibility which can be developed rapidly.
Design pattern is known as a template or pattern describing a solution
to a common problem. It can be reused when a software designer identifies
a design problem that can be solved by an existing design pattern.
Software design is the process of constructing a software system to
solve a given real-world problem/task.
This typically involves formally
specifying problem requirements, developing a high-level model, and
finally implementing, debugging, and maintaining the code.
Various traits of software, such as correctness, reliability, readability,
and maintainability, are also heavily taken into consideration
during the development process.
Software design is the process of
analyzing the purpose of the target software product and
then planing out (i.e. design) how to achieve that purpose
with computers. In my point of view, software design can be as
high-level as just designing the framework/blue print of the software
solution with a diagram. It also can be as low-level as having the
class/function hierarchy and details all planned out. A good software
design practice is supposed to make the software implementation easier,
faster, more straightforward, and less bug-prone.
I think that software design is a
planning methodology of problem-solving.
Because computational power is so powerful in these days, software is able
to and needs to solve enormous problems. Therefore, software became huge
system of problem-solving modules, not just a single algorithm. Unlike
blue-prints in architecture, the
software specifications are change rapidly and frequently
in the middle of design process to reflect current technology
and situation. I believe that software development allows the smallest time
for the planning of system among various engineering fields. With increasing
complexity of problems, software design became more complex and error prone
process, so there should be well-defined way to make an error-proof
Software design is a process of problem-solving and planning for a
software solution. After the purpose and specifications of software are
determined, software developers will design or employ designers to develop
a plan for a solution. It includes low-level component and algorithm
implementation issues as well as the architectural view.
So, any science of software design would have to consist of:
1. An explanation of the purpose of software.
2. An explanation of the goals of the science.
3. A series of fundamental truths on which to base decisions.
And this would allow us to achieve:
1. The ability to make decisions that achieve the stated purpose of software.
2. Some way of understanding what causes errors (decisions that do not
achieve the purpose) in software design.
3. A method (or methods) of preventing future errors.
4. A method (or methods) of fixing errors that already exist.
Software design provides complete support for the design process, from
the initial customer data gathering through the transition to object
oriented design. The process brings together the techniques needed to
design a system that meets its customers’ needs, while addressing the
challenges of making a design process work in real-world situations.
-Contextual Design BY Hugh Beyer