UNC-CH COMP 723
What is Software Design?
What is Software design? I think literally it can mean two things. First, internal structure of a software. Variables, classes, functions and how they are connected, etc. In this case, good software design means easy to read, easy to extend (its functionality), not too complicated to lower the performance ( example of a low performance with good interface might be STL ).
Second, user interface part. How each functionality is exposed to the users and how easily they can be manipulated. In this case, good software design means intuitive and effective user control of the software.
For me, I have a feeling that there's not just one absolutely good software design, nor a software with a good design become successful. But applying good design strategy on softwares surely help improving the performance and reducing wasted times on debugging and learning new codes.
In my opinion, software design is the process of pursuing a solution to
a particular problem. With a good design, a software can meet the
requirements of customers, as well as perform functions efficiently
Software deign is about both science and arts. First, we need fully
understand what the customers want. With the precise requirement
specification, we then choose the appropriate techniques to implement
the functions. Besides the basic requirements, software designer should
also try to make the software maintainable and extensible.
Software design also cares about something that are difficult to
evaluate with scientific criteria. For example, is it easy for a new
user to start with the software; is there a clear and pretty user interface,
etc. In this aspect, designing software is no different with designing
other products, since aesthetics is always an important design criterion.
Software design is all about communication. Communication between
human/computers, human/human, or even between computers/computers.
Robust and efficient flow of information is always the key in
developing a successful software. Message is generated by user and
passed into a system to be processed. Software design plays a key
role in passing coherent messages to the right place in the right
form. Software design pattern tries to ensure this message passing
to be the most robust and efficient to both human and computers,
which leads into the development of a successful software.
When it comes to software design, I think of it as more of an art of communication rather than engineering. This is because I believe codes are meant to be read rather than to be executed. At the advent of new technologies such as multicore processor, legacy codes must be maintained in order for application to function as developers intended. There maybe a room for automation in this process. However, at some point somebody needs to look at source codes. That is why in industry there are set of guidance for style, and design axioms exist. A professor in my undergraduate even told us that well written codes have stories.
To me software design encompasses the intermediate level of thinking that bridges specification of functionality with the underlying code and algorithms which implements them. In other words it accounts for the overall structure of a piece of software but is not concerned with the particulars of implementation, only taking into account reasonable assumptions about the underlying code.
In practice this means that software design describes the set of issues beyond the lowest level "well defined" problems encountered in the course of building a piece of software to a certain requirement. For example, it could encompass efforts to make code maintainable and extensible or efforts to make the coding process efficient in a large team environment. Definition of API's, file formats, choice of programming languages, and specification of software modules and their mutual interactions are all be part of the software design process.
Software design is the process of planning the coarse and fine components of software following certain design principles. These design principles may include correctness, scalability, reusability, modularity, and efficiency (in terms of space, computation time, power requirement, etc.) to name a few and their inclusion depends on the specific application.
Software design is the creation of a plan for the structure of a software product. It involves the examination and consideration of the requirements of the proposed software, so that designers can make informed decisions when choosing which specific elements to include in the plan. These elements can include things like the implementation language, frameworks, which algorithms to implement, amongst other elements. It also involves solving problems that arise from these choices. In choosing a specific programming language for example, a software designer may find that a particular requirement of the software is difficult to implement given a limitation of that language. Software design would involve either finding established patterns of implementation or creating from scratch a solution which would resolve the requirement conflict.
Software design isn't limited to simply creating an abstract plan consisting of different software elements. A large part is thinking carefully about how those elements should be architected so that they function together. Typically software can be modularized, with different modules implementing discrete functionality and then interacting with other modules. Some modules may replicate functionality common to software and as such can benefit from the experiences of software designers and implementers in the past, while other modules may need to be custom created. Ensuring that these differing types of modules are appropriate to the overall design and that they function well together is a part of software design. If any of these modules are incompatible with each other, then either choosing suitable replacements, or creating a plan for implementing a way for the elements to operate together would be part of the design.
I think software design is, given the requirements of the software, determine its architecture and separate it into different modules. The process involves design in different levels, from high level design to low level design. For the architecture of the software, we need to decide what data structures can be employed, what interfaces are needed, and how to divide it into modules independent to each other. For each module, we need to decide how it could be implemented, and what algorithms can be used. The ultimate goal is providing a detailed design to guide the implementation, and to meet the requirements of the software.
Software design is the process of analyzing the requirements of the software and planning a solution to solve the given real-world problem. The requirements are a contract between the user and the developer that define the functions and features of the system and they are iteratively updated. After the requirements are defined and purpose and specifications of software are determined, the designers will work out the high level Design (Architecture) and low-level component design as well as algorithm implementation. A good design practice will create a software with higher quality Maintainability, Correctness, Reusability, Reliability, Portability and Efficiency.
Software design works as an organizer of software
implementation. It is a hierarchical abstract model
of the target software. The highest level specifies
users' needs: input and output. Each level of
model provides more practical thoughts by dividing
each black box of higher level into several modules.
Thus the bottom level can be easily implemented.
Schematic part of design requires both software and
global data structure to be established.
However, during programming, I found modifying
difficulty arose with growing design details,
since software design is more like a feedback
process. Software designers need to be cautious
and farseeing enough to realize validity and
extensibility to minimize future modification of
I think that software design is an essential procedure for development and maintenance of software. In the development stage for a large group project, implementation can be divided into several components via software design, and each of them is efficiently implemented by respect developers without full knowledge of other's implementation, that is, developers can simply focus on the specification of other components such as their input and output types, ignoring implementation details. In such a strategy, it would be enough that developers pay attention to validation/tests (bug fix, etc.) of their own components, which will further reduce a large amount of cost for development. For the software maintenance, concepts of reusability and readability can be introduced via software design. Specifically, developed software emphasized by reusability will be easily incorporated or even extended to different projects without hard efforts. In addition, code readability will help software developers better understand and expedite software implementation.
Software design is creating a software system which can accomplish its
goals efficiently and effictively while being easy to maintain and
expand.An efficient and effictive design will perform an operation
correctly without consuming more resources than needed. A design must
also be logical and easy to understand so that programmers can fix
bugs and adapt the system after it has been deployed. Finally, a
software system should be created with future expansions in mind, so
that additional features can be added elegantly and in a timely manner.
Software design is a process of designing a software that could solve the problems given. After the design is given, the software is implemented by engineers.
For designing the software, the designer needs to know what the problems are, what the inputs will be, what the desired outputs will be, which environment the software will run in ( personal computer, mobile phone, supercomputer, etc.), and so on. After that, The designer will decide the composition and the archaetecture of the software. In the upper level, the designer breaks the big problem into several parts and solve them individually; in the lower level, the designer choose objects, data structures and algorithms for the software. Different people would come up with different software design results.
Given the specifications for a software it is usually not obvious how to directly build (start programming) the software from the specifications, especially when the specifications are large and complex. Building a software usually requires careful assessment of the specifications and a plan to break the problem into simpler components that will eventually fit together and result in the software as described in the specifications. The process of planning how to build a software can be referred to as software design.
In several occasions software design has to be revisited during the development process of the software. For example, issues may arise during building the software that may have not been foreseen during the software design process. Determining an approach to overcome such issues can also be considered a part of software design.
Software design is basically an implementation plan to ensure that a body of code meets certain requirements. Certain considerations for the code are addressed in this plan, such as whether the code is secure, or extendable, or efficient. The desired structure for the code is planned out as well. It is similar to outlining a paper before writing it. The design will a description of all the necessary parts of the program, as well as how those parts work together and how dependent they are on one another. For a team of programmers, a design can include an outline of how they are going to work together, as well how they will adapt to possible changes in the program specifications.
Software design can be viewed as the set of choices implemented within a software solution.
While there are many possible solutions to a problem, good software design aims to create a solution
that displays several important characteristics. First example, the solution should be flexible; generally,
it is decomposed into several different components such that if one is changed, it does not affect the
others. Likewise, good software design also aims for easy maintainability; the solution should be written
such that it can continue to work effectively even after the solving the initial problem. Several other
important characteristics, such as efficiency, simplicity, reusability, etc. also encompass good software
design. In the effort to minimize the difficulty in implementing such characteristics, solutions to
commonly occurring problems, called design patterns, have been created; knowledge of these
patterns is extremely useful when aiming for good software design.
The purpose of software design is to design and implement
a system to meet a set of goals. Besides meeting the goal,
a good software design also aims at reusability and
1) The reusability requires designer to develop code
that can be easily reused by for similar function in
other projects. The design involves organizing function
and data, and abstract out reusable data structure,
design pattern, or architecture.
2) The maintainability requires designers to be aware
of future extension both in data structure and algorithm.
Software design is taking the requirements that must be met by a program and deciding on the structure of the program that will meet those requirements in an elegant way. It includes every step of this process, from gathering the requirements by talking to the end users to deciding the final structure of the program. It includes choices of tools to include in the program as a baseline, choice of programming language, choice of programmatic structure using the constructs of the chosen language, etc. Software design also includes the choice of how flexible to make the program and how easily adaptable is will be to potential changes requested by the end user.
Software design is the process of planning and organizing software implementation. Design often includes hierarchy, modularization, information abstraction, and data structures to enable a programmer to easily understand a given code's purpose. Intelligently designed code allows a programmer to reuse, refine, or extend code efficiently. Software design becomes even more essential when working in larger teams, as each member must be able to understand and work independently on a given section of code and incorporate it into the larger project.
I believe "software design" is best defined in terms of what we consider a "well-designed" piece of software. I believe well-designed software should fulfill the following objectives:
Objective 1: It fulfills the expectations of all users.
Objective 2: If user expectations change, the software architecture makes implementing these changes as easy as possible.
Firstly, software design encompasses all possible strategies for fulfilling the above two objectives. For instance, one possible sequence of steps for fulfilling the above objectives may be:
1) Suss out users' expectations of the software.
2) Design software architecture in order to fulfill expectations.
3) Implement software architecture.
4) Test software to see whether it fulfills users' expectations. If not, return to step 1.
Furthermore, software design encompasses all of the possible strategies used to carry out each of steps in the above "high-level" strategy.
In summary, I believe software design is the strategy used to build software which 1) fulfill's user expectations and 2) facilitates changes in user expectations.
I think the main objective of software design is to make the code easy to reuse with no or minor modifications. Software is developed in most cases to make users' work easy and improve their working efficiency. Similarly, I think software design is to make the life of programmers easy. In these days, due to various reasons (e.g., user requirement change, extension of old modules), we need to modify the existing codes. A good piece of code with well designed interfaces enables a lot of functions or modules to be reused without any modifications. On the contrary, badly designed code makes it extremely hard to modify and extend. Once upon a time, I heard a joke about software design, it says "the code quality depends on how many "shit"s are said by other programmers when they are working on the further development of your code." Although it is only a joke and not a formal measure, it certainly reflects that the code quality depends on how easy others can understand and reuse it. Compared with other properties of code (e.g., efficiency), if we need to make a compromise, for me I will be inclined to reusability.
Software design is the iterative process of developing a program's structure and communication framework. This framework is built in consideration of a given set of constraints to accomplish specific tasks. Ideally, the framework should be modular, reusable, and extensible. Software design occurs throughput the development cycle as new ideas, requirements, and limitations emerge from the implementation and testing process.