Component design introduction
- A software component is a modular building block for the computer software.
- Component is defined as a modular, deployable and replaceable part of the system which encloses the implementation and exposes a set of interfaces.
Components view
The components has different views as follows:
1. An object-oriented view- An object-oriented view is a set of collaborating classes.
- The class inside a component is completely elaborated and it consists of all the attributes and operations which are applicable to its implementation.
- To achieve object-oriented design it elaborates analysis classes and the infrastructure classes.
2. The traditional view- A traditional component is known as module.
- It resides in the software and serves three important roles which are control component, a problem domain component and an infrastructure component.
- A control component coordinate is an invocation of all other problem domain components.
- A problem domain component implements a complete function which is needed by the customer.
- An infrastructure component is responsible for function which support the processing needed in the problem domain.
3. The Process related view- This view highlights the building system out of existing components.
- The design patterns are selected from a catalog and used to populate the architecture.
Class-based design components
The principles for class-based design component are as follows:
Open Closed Principle (OCP)
Any module in OCP should be available for extension and modification.
The Liskov Substitution Principle (LSP)- The subclass must be substitutable for their base class.
- This principle was suggested by Liskov.
Dependency Inversion Principle (DIP)- It depends on the abstraction and not on concretion.
- Abstraction is the place where the design is extended without difficulty.
The Interface Segregation Principle (ISP)
Many client specific interfaces is better than the general purpose interface.
The Release Reuse Equivalency Principle (REP)- A fragment of reuse is the fragment of release.
- The class components are designed for reuse which is an indirect contract between the developer and the user.
The common closure principle (CCP)
The classes change and belong together i.e the classes are packaged as part of design which should have the same address and functional area.
The Common Reuse Principle (CRP)
The classes that are not reused together should not be grouped together.
User Interface design
- User interface design helps in successing most of the software.
- It is part of the user and computer.
- Good interface design is user friendly.
Types of user interface:
1. Command Interpreter
Commands help the user to communicate with the computer system.
2. Graphical User Interfaces (GUI)- It is another approach to communicate with system.
- It allows a mouse-based, window-menu-based systems as an interface.
The Golden Rules
The golden rules are known as interface design principles.
The golden rule are as follows:
1. Place the user in control- The interaction should be defined in such a way that the user is not forced to implement unnecessary actions.
- The technical internal details must be hidden from the casual user.
- Design for the direct interaction with objects that appear on the screen.
2. Reduce the user's memory load- The user interface must be designed in such a way that it reduces the demands on the user's short term memory.
- Create the meaningful defaults value as an advantage for the average users in the start of application.
- There must be a reset option for obtaining the default values.
- The shortcut should be easily remembered by the users.
- The interface screen should be friendly to users.
3. Make the interface consistent- The system must allow the user to put task into meaningful context.
- Consistency should be maintained for all the interaction.
- Do not change the past system that is created by the user expectation unless there is a good reason to do that.
User interface design issues
The user interface design consist of following four issues:
1. Response time of the system
Length and variability are the two important characteristic of the system response time.
2. User help facilities
The user of each software system needs the help facility or the user manual for the smooth use of the software.
3. Error information handling
Many error messages and warnings are created which irritate the users as they are not meaningful. Only the critical problems should be handled.
Error message guidelines are as follows:- The language of error message should be described in plain language i.e easily understandable for the users.
- For recovering the error,useful advice should be provided.
- The error message must have an audible or visual indications like beep, short flashing or the special error color.
- The error messages must indicate any negative result so that the user verifies it.
- The wordings of message should not be blamed on the user.
4. Command labeling
The commands and menu labeling must be consistent, easy to understand and learn.
WebApp Interface design
The principles for designing the WebApp are as follows:
1. Anticipation
A WebApp should be designed so that it can anticipate the user's next move.
2. Communication
The interface must communicate the status of any activity initiated by the user.
3. Consistency
Throughout the WebApp the use of navigation control, menus, icons, decorative parts should be consistent.
4. Efficiency
The design of WebApp and its interfaces must optimize the user's work efficiency and not the efficiency of developer.
5. Flexibility
The system must be flexible to accommodate the need of user.
6. Focus
The WebApp interface and the content present in it must focus on the users task.
7. Readability
The presented information must be readable to all the users.
8. Learnability- A WebApp interface must be designed to minimize the learning time.
- After learned, It is necessary to minimize the relearning when the WebApp is revisited.
9. Metaphors
An interface uses an interaction metaphor that is easier to learn and use until the metaphor is appropriate for the application and the user.
10. Maintain the integrity of work product
A work product should be saved automatically so it does not lose an error message which has occurred automatically.
