Design is a meaningful activity needed to develop a quality product. Software Design is the only way by which we can accurately translate the customer’s requirements into a finished software product or system. Thus design serves as the basis for all the software engineering steps. In this chapter we will get introduced with the systematic approach to design process. We will discuss architectural design, user interface design and real time software design.
Importance of Software Design
Design allows a software engineer to create a model of the system or product that is to be built. This model is useful to access quality improvements. The accessment of quality can be done before code generation. A large number of users can be involved in development process if design model is prepared. In short, design is a place where software quality can be assured.
Analysis and Design Model
- After analyzing and specifying all the requirements the process of software design begins. Each of the elements of analysis model is used to create the design model.
- The elements of analysis model are
- Data dictionary
- Entity relationship diagram
- Data flow diagram
- State transition diagram
- Control specification
- Process specification
- The elements of design model are
- Data design
- Architectural design
- Interface design
- Component-level design.
- The data design is used to transform the information domain model of analysis phase into the data structures. These data structures play an important role in software implementation. The entity relationship diagram and data dictionary are used to create the data design model. In entity relationship diagram the relationships among the data objects is defined and in data dictionary detailed data contents are given, Hence ERD and data dictionary are used to implement the data design.
- The architectural design is used to represent the relationship between major structural elements with the help of some “design patterns.” Hence data flow diagrams from analysis model serve as the basis for architectural design.
- The ‘interface design’ describes how software interacts within itself. An interface means flow of information and specific type of behavior. Hence by using the data flow and control flow diagrams the interface design can be modeled.
- In the ‘component-level design’ the structural elements of software architecture into procedural description of software components. Hence the ‘component-lever design’ can be obtained using State Transition Diagrams (STD), Control Specification(CSPEC) and Process Specification (PSPEC).
A Design Process and Design Quality
- Design process is a sequence of steps carried through which the requirements are translated into a system or software model.
- Any design may be modeled as a directed graph. The graphs are collection of entities with attributes which participate in relationships.
- The system should be described at several different levels of abstraction.
- Design takes place in overlapping stages.
- Various phases of design process are as shown in following image
- In architectural design the subsystem components can be identified.
- The abstract specification is used to specify the subsystems.
- The interfaces between the subsystems are designed, which is called interface design.
- In component design of subsystems components is done.
- The data structure is designed to hold the data.
- For performing the required functionality, the appropriate algorithm is designed.
Davis suggested a set of principles for software design as :
- The design process should not suffer from “tunnel vision”.
- The design should be traceable to the analysis model.
- The design should not reinvent the wheel.
- The design should “minimize the intellectual distance” between the
- software and the problem in in the real world.
- The design should exhibit uniformity and integration.
- The design should be structured to accommodate change.
- The design should be structured to degrade gently.
- Design is not coding and coding is not design.
- The design should be assessed for quality.
- The design should be reviewed to minimize conceptual errors.
Characteristics of Good Design
- The good design should implement all the requirements that are mentioned in the explicitly analysis model. It should accommodate all the implicit requirements demanded by the customer.
- The design should be simple enough so that the code developer, code tester as well as those who are supporting the software will find it readable and understandable.
- The design should be comprehensive. That means it should provide a complete picture of software, addressing the data, functional and behavioural domains from an implementation perspective.
The goal of any software design is to produce high quality software. In order to evaluate quality of software there should be some predefined rules or criteria that need to be used to assess the software product. Such criteria serve as characteristics for good design. The quality guidelines are as follows-
- The design architecture should be created using following issues –
- The design should be created using architectural styles and patterns.
- Each component of design should posses good design characteristics
- The implementation of design should be evolutionary, so that testing can be performed at each phase of implementation.
- In the design the data, architecture, interfaces and components should be clearly represented.
- The design should be modular. That means the subsystems in the design should be logically partitioned.
- The data structure should be appropriately chosen for the design of specific problem.
- The components should be used in the design so that functional independency can be achieved in the design.
- Using the information obtained in software requirement analysis the design should be created.
- The interfaces in the design should be such that the complexity between connected components of the system gets reduced. Similarly interface of the system with external interface should be simplified one.
- Every design of the software system should convey its meaning appropriately a effectively.
The abstraction, means an ability to cope up with the (complexity. Software design occurs at different levels of abstraction. At each stage of software design process level abstractions should be applied to refine the software solution. (At the higher level abstraction, the solution should bé stated in broad terms and in the lower level more detailed description of the solution is given.
While moving through different levels of abstraction the procedural abstraction and data abstraction are created. The procedural abstraction gives the named sequence of instructions in the specific function. That means the functionality of procedure is mentioned by its implementation details are hidden. For example : Search the record is a procedural abstraction in which implementation details are hidden (i.e. Enter the name, compare each name of the record against the entered one, if a match is found then declare success!! Other wise declare ‘name not found’)
In data abstraction the collection of data objects is represented. For example, for the procedure search the data abstraction will be Record. The record consists of various attributes such as Record ID, name, address and designation.
- The software is divided into separately named and addressable components that called as modules.
- Monolithic software is hard to grasp for the software engineer, hence it has now become a trend to divide the software into number of products. But there is a co-relation between the number of modules and overall cost of the software product. Following argument supports this idea – “Suppose there are two problems A and B with varying complexity. If the complexity of problem A is greater than the complexity of the problem B then obviously the efforts required for solving the problem A is greater than that of problem B. That also means the time required by the problem A to get solved is more than that of problem B.”
The overall complexity of two problems when they are combined is greater than the sum of complexity of the problems when considered individually. This leads to divide and conquer strategy (according to divide and conquer strategy the problem is divided into smaller subproblems and then the solution to these subproblems is obtained) . Thus dividing the software problem into manageable number of pieces leads to the concept o modularity. It is possible to conclude that if we subdivide the software indefinitely the effort required to develop each software component will become very small. But a conclusion is invalid because the total number of modules get increased the effort required for developing each module also gets increased. That means the cost associated with each effort gets increased. The effort (cost) required for integration these modules
The above image provides useful guideline for the modularity and that is –
over modularity or the under modularity while developing the software product must be avoided) We should modularize the software but the modularity must remain near the region denoted by M
- Modularization should be such that the development can be planned easily, software increments can be defined and delivered, changes can be more easily accommodated and long term maintenance can be carried out effectively.
- Meyer defines five criteria that enable us to evaluate a design method with respect to its ability to define an effective modular system :
- Modular decomposability : A design method provides a systematic mechanism for decomposing the problem into sub-problems. This reduces the complexity of the problem and the modularity can be achieved.
- Modular composability : A design method enables existing design components to be assembled into a new system.
- Modular understandability : A module can be understood as a standalone unit. It will be easier to build and easier to change.
- Modular continuity: Small changes to the system requirements result in changes to individual modules, rather than system-wide changes.
- Modular protection: An aberrant condition occurs ‘within a module and its effects are constrained within the module.
Information hiding is one of the important property of effective modular design( The term information hiding means the modules are designed in such a way that information contained in one module cannot be accessible to the other module (the module which does not require this information). Due to information hiding only limited amount of information can be passed to other module or to any local data structure used by other module.
The advantage of information hiding is basically in testing and maintenance. Due to information hiding some data and procedures of one module can be hidden from another module. This ultimately avoids introduction of errors module from one module to another. Similarly one can make changes in the desired module without affecting the other module.
Modular design reduces complexity and helps in easier implementation The parallel development of different parts of the system is possible due to modular design.
What is the benefits of modular design?
Changes made during testing and maintenance becomes manageable and they do not affect other modules.
Various quality parameters for effective modular design are
1) Functional independence 2) Cohesion 3) Coupling.
The functional independence can be achieved by developing the functional modules with single-minded approach.
- By using functional independence functions may be compartmentalized and interfaces are simplified.
- Independent modules are easier to maintain with reduced error propagation.
- Functional independence is a key to good design and design is the key to software quality.
- The major benefit of functional independence is in achieving effective modularity.
- With the help of cohesion the information hiding can be done.
- A cohesive module performs only “one task” in software procedure with little interaction with other modules. In other words cohesive module performs only one thing.
Different types of cohesion are :
- Coincidentally cohesive – The modules in which the set of tasks a related with each other loosely then such modules are called coincidentally cohesive.
- Logically cohesive – A module that performs the tasks that are logically related with each other is called logically cohesive.
- Temporal cohesion The module in which the tasks need to be executed in some specific time span is called temporal cohesive.
- Procedural cohesion – When processing elements of a module are related with one another and must be executed in some specific order then such module is called procedural cohesive.
- Communicational cohesion – When the processing elements of a module share the data then such module is communicational cohesive. The goal is to achieve high cohesion for modules in the system.
- Coupling effectively represents how the modules can be “connected” with other module or with the outside world.
- Coupling is a measure of interconnection among modules in a program structure.
- Coupling depends on the interface complexity between modules.
- The goal is to strive for lowest possible coupling among modules in software design.
- The property of good coupling is that it should reduce or avoid change impact and ripple effects. It should also reduce the cost in program changes, testing and maintenance.
Various types of coupling are :
- Data coupling – The data coupling is possible by parameter passing or data interaction.
- ii) Control coupling – The modules share related control data in control coupling.
iii) Common coupling – In common coupling common data or a global data is shared among the modules.
- iv) Content coupling – Content coupling occurs when one module makes use of data or control information maintained in another module.
- The architectural design is the design process for identifying the subsystems making up the system and framework for subsystem control and communication.
- The goal of architectural design is to establish the overall structure of software system.
- Architectural design represents the link between design specification and actual design process.
In architectural design logical system components and communication between them are identified.
The common activities in design process are
The system is subdivided into principle subsystems
- System structuring – components and communications between these subsystems are identified.
- Control modelling – A model of control relationships between different parts of the system is established.
- Modular decomposition– The identified subsystems are decomposed into modules.
The software architecture gives the hierarchical structure of software components and their interactions. In software architecture the software model is designed and structure of that model is partitioned horizontally or vertically.
Each model represents different perspective on the architecture for instance :
1. Structural model-Represents architecture as an organized collection of components.
- Framework model- Identifies the repeatable architectural design frameworks and event thereby increases the level of abstraction.
- Dynamic model – Represents the behavior aspects of the program architecture.
Behavior means change in functioning of the system on occurrence of external
- Process model – Focuses on the design of the business or technical process.
- Functional model – It can be used to represent functional hierarchy of the system.
- The architectural model or style is a pattern for creating the system architecture, for given problem. However, most of the large systems are heterogeneous and do not follow single architectural style.
- System categories define the architectural style.
- Components : They perform a function.
For example : Database, simple computational modules, clients, servers and filters.
- Connectors : Enable communications. They define how the components communicate, co-ordinate and co-operate. For example, Call, event broadcasting, pipes.
- Constraints : Define how the system can be integrated.
4.Semantic models : Specify how to determine a system’s overall properties from the properties of its parts.
The commonly used architectural styles are
- Data centered architectures
- Data flow architectures
- Call and return architectures
- Object oriented architectures
- Layered architectures.
Data Centered Architectures
In this architecture the data store lies at the center of the architecture and other components frequently access it by performing add, delete, and modify operations. The client software requests for the data to central repository. Sometime. the client software accesses the data from the central repository without any change in data or without any change in actions of software actions.
Data centered architecture posses the property of interchangeability. Interchangeability means any component from the architecture can be replaced by a new component without affecting the working of other components. In data centered architecture the data can be passed among the components.
User Interface Design Principles
While designing the user interface the capability, need and experience of system or should be considered. The designer should take into account the people’s physical and mental limitations. For instance a short memory or in game playing software a child can recognize pictures rather than text. He should also be aware of the fact that people make mistakes and the interface should tolerate these mistakes in a friendly manner. Following design principles are used.
- User familiarity – Instead of using computer terminology make use of user oriented terminologies. For example, in ‘Microsoft Office’ software, the terms such as document, spreadsheet, letter, folder are used and use of the terms directory, file and identities are avoided.
- Consistency The appropriate level of consistency should be maintained in the user interface. or example, the commands or menus should be of same format.
- Minimal surprise – The commands should operate in a known way. This makes user to easily predict the interface. For example, the in word processing document under the tool menu there should be a facility of spelling and grammar checking.
- 4. Recoverability – The system should provide recovering facility to user from his errors so that user can correct those error. For example, an undo command should be given so that user can correct his errors, or while deleting something the confirmation action must be provided, that user can think again while deleting something.
- User guidance – The user interface can be effectively used by a novice user if some user guidance such as help systems, online manuals etc. are supplied.
Thao Mandel has proposed three golden rules for user interface design –
- Place the user in control
- Reduce the user’s memory load
- Make the interface consistent.
Let us discuss each rule in detail –
Place the User in Control
While analyzing any requirement during requirement analysis the user often demands for the system which will satisfy user requirements and help him to get the things done. That means the user always wants to control the computerized system.
Mandel has suggested following principles for consistent interface design.
- Allow user to direct the current task into meaningful manner
This principle suggests that create a user interface with proper indicators on it so that user can understand his current task and how to proceed for new task
- Maintain consistency across family of product
If an application come in a packaged manner then every product of that application family should possess the consistent user interface. For example
Microsoft Office family has several application products such as MS WORD, MS Power Point, MS Access and so on. The interface of each of these product is consistent (of course with necessary changes according to its working!). That means there is a title bar, menu bar having menus such as File, Edit, View. Insert, Format, Tools, Table, Window, Help on every interface. Then tool bars and then design layouts are placed on the interface.
- If certain standards are maintained in previous model of application do not change it until and unless it is necessary Certain sequence of operation becomes a standard for the user, then do not change these standards because user becomes habitual with such practices. For instance, control + s is for saving the file then it has become a standard rule now, if you assign different short cut keys for saving then it becomes annoying to the user.
User Interface Analysis and Design
User interface analysis and design can be done with the help of following steps.
- Create different models for system functions.
- The order to perform these functions identify the human-computer interface tasks.
- Prepare all interface designs by solving various design issues.
- Apply modern tools and techniques to prototype the design.
- Implement design model.
- Evaluate the design from end user to bring quality in it.
These steps can be broadly categorized in two classes.
- Interface analysis and design models
- The process Let us discuss each of them in detail –
After creation of first prototype it is evaluated by the user. The evaluation made by the user is then submitted to the designer who then makes necessary changes in the interface and builds the next prototype. This process is repeatedly performed until the user gets satisfied completely and no further modifications are necessary in the interface. Thus prototype approach proves to be effective for design evaluation.
Real Time Systems
- Behavior of real time systems is based on timing constraints. Real time systems are those systems which monitor and control their environment.
- These systems are usually associated with some hardware devices.
- There are two important elements of the real time system.
Sensors – They are responsible for collecting the data from the system.
Actuators These are responsible to change the environment of the system.
- Real time systems must respond within specified time.
Real time system is a software system in which the correct functionalities of the system are dependant upon results produced by the system and the time at which these results are produced.
There are two types of real time systems soft real time and hard real time systems.
A soft real time systems are those systems in which the operations are degraded if results are not produced in specified timing requirements.
A hard real time systems are those systems in which operations are incorrect if the results are not generated in specified timing requirements.
Real Time Software Design
- Stimulus response system – In real time systems, there is one class of the system in which on giving the stimulus the system produces the response. The stimuli can be of two types
- i) Periodic stimuli – These are the stimuli that occur at periodic time interval. For example – pressure sensor may be activated after every 20 seconds.
- ii) Aperiodic stimuli – These are stimuli that occur at unpredictable time interval.
For example – Power failure in the system.
- Different stimuli require different time intervals. Hence the real time system architecture should be such that there fast switching between the stimuli handler should be allowed.
- Real time systems are designed with the help of many co-operating processes.
JAVA is the most effective language for real time programming. JAVA supports thread and synchronized methods. Java is used in soft real time programming. JAVA 2.0 is not supporting hard real time programming.
Real Time System Design Consideration
In real time system design process events or stimuli are focused instead of considering objects and functions. The interleaved stages in real time system design process are –
- A Identify the important stimuli and associated responses.
- For the identified stimuli-responses, find out the timing constraints that are applicable to corresponding stimuli and responses.
- Choose an execution platform for the system by considering some factors such as timing constraints on the system, limitations on power available, experience of software developers and price target.
- Identify some concurrent processes., These concurrent processes can be created by aggregating stimuli-responses. Software Design algorithms for each stimulus and response.
- Design a schedule which will indicate starting and ending time of each process.
Real Time Executives
Real time executives are specialized operating systems which are used in process management. The real time executives also perform process management and resource allocation. The real time executive kernel can be modified or unmodified for particular application. The real time executive does not support file management. The executive components are
- Real time clock – It is used while scheduling the processes.
- Interrupt handler – It manages the aperiodic requests.
- Scheduler – Schedules various processes.
- Resource manager – It allocates processor resources and memory.
- Dispatcher – It is responsible for start of process execution.
Non stop system components are –
Configuration manager – The configuration manager reconfigures the system dynamically. In dynamic reconfiguration the hardware can be completely replaced and software can be upgraded without stopping the systems.
|Read More Topics|
|Supervisory Control and Data Acquisition|
|Software cost estimation|
|Risk analysis management|