What is software design?
Software design is the process of analyzing software requirements in order to produce a description of the software’s internal structure that will serve as the basis for its construction.
A software design (the result) describes the architecture—how software is decomposed
and organized into components—and the interfaces between those components. It should also describe the components at a level of detail that enables their construction.
What is architectural design?
Architectural design (aka highlevel design aka top-level design) describes how software is organized into components
What is detailed design?
Detailed design describes the desired behavior of components within an architectural design.
What is a software design priciple?
Software design principles are key notions that provide the basis for many different software design approaches and concepts.
Examples:
- abstraction
- coupling and cohesion
- decomposition and modularization
- encapsulation/information hiding
- separation of interface and implementation
- sufficiency, completeness, and primitiveness
- separation of concerns
What is abstraction?
A software design principle where “a view of an object that focuses on the information relevant to a particular purpose and ignores the remainder of the information”
What is coupling? What is cohesion?
Coupling is defined as “a measure of the interdependence among modules in a computer program.”
Cohesion is defined as “a measure of the
strength of association of the elements within
a module”.
What is decomposition and modularization?
Large software is divided into a number of smaller named components having well-defined
interfaces that describe component interactions. Usually the goal is to place different functionalities and responsibilities in different components.
What is encapsulation?
Encapsulation and information hiding means
grouping and packaging the internal details
of an abstraction and making those details
inaccessible to external entities.
What is separation of interface and implementation?
Separating interface and implementation
involves defining a component by specifying a public interface (known to the clients)
that is separate from the details of how the
component is realized (see encapsulation and
information hiding).
What is sufficiency, completeness, and primitiveness?
Achieving sufficiency and completeness
means ensuring that a software component
captures all the important characteristics of
an abstraction and nothing more.
Primitiveness means the design should be based on patterns that are easy to implement.
What is separation of concerns?
Separation of concerns. A concern is an
“area of interest with respect to a software
design” [8]. A design concern is an area of
design that is relevant to one or more of its
stakeholders. Each architecture view frames
one or more concerns. Separating concerns
by views allows interested stakeholders to
focus on a few things at a time and offers a
means of managing complexity [9].
What are architectural viewpoints? Give some examples.
“A view represents a partial aspect of a software architecture that shows specific properties of a software system” [14*].
Examples:
- logical view (satisfying the functional requirements)
- process view (concurrency issues)
- physical view (distribution issues)
- development view (how the design is broken down into implementation units with explicit representation of the dependencies among the units).
What is an architectural style? Give some examples.
An architectural style is “a specialization of element and relation types, together with a set of constraints on how they can be used” [14*].
An architectural style provides the software’s high-level organization.
Major architectural styles:
* General structures (for example, layers, pipes
and filters, blackboard)
* Distributed systems (for example, clientserver, three-tiers, broker)
* Interactive systems (for example, Model-ViewController, Presentation-Abstraction-Control)
* Adaptable systems (for example, microkernel, reflection)
* Others (for example, batch, interpreters, process control, rule-based).
What are some general user interface design principles?
- Learnability. The software should be easy to
learn so that the user can rapidly start working with the software. - User familiarity. The interface should use
terms and concepts drawn from the experiences of the people who will use the software. - Consistency. The interface should be consistent so that comparable operations are activated in the same way.
- Minimal surprise. The behavior of software
should not surprise users. - Recoverability. The interface should provide
mechanisms allowing users to recover from
errors. - User guidance. The interface should give
meaningful feedback when errors occur and
provide context-related help to users. - User diversity. The interface should provide appropriate interaction mechanisms
for diverse types of users and for users with
different capabilities (blind, poor eyesight,
deaf, colorblind, etc.).
What are some user interaction styles?
- Question-answer. The interaction is essentially restricted to a single question-answer
exchange between the user and the software.
The user issues a question to the software,
and the software returns the answer to the
question. - Direct manipulation. Users interact with
objects on the computer screen. Direct
manipulation often includes a pointing
device (such as a mouse, trackball, or a finger on touch screens) that manipulates an
object and invokes actions that specify what
is to be done with that object. - Menu selection. The user selects a command
from a menu list of commands. - Form fill-in. The user fills in the fields of a
form. Sometimes fields include menus, in
which case the form has action buttons for
the user to initiate action. - Command language. The user issues a command and provides related parameters to
direct the software what to do. - Natural language. The user issues a command in natural language. That is, the natural
language is a front end to a command language and is parsed and translated into software commands.
