System Design


System Design is the process of designing the architecture, components, and
interfaces for a system so that it meets the end-user requirements. This specifically
designed System Design tutorial will help you to learn and master System Design
concepts in the most efficient way from basics to advanced level.
Importance of System Design in Software Development
Building a successful application goes beyond just having functional features. It
is also about ensuring the system can withstand real-world conditions. A well-
designed system is not only reliable and scalable but also easy to maintain and
evolve as the requirements change. As applications grow in complexity,
designing them with scalability, performance, and availability in mind becomes
important.
What is Systems Design – Learn System Design

Systems Design is the process of defining the architecture, components, modules,
interfaces, and data for a system to satisfy specified requirements. It involves
translating user requirements into a detailed blueprint that guides the
implementation phase. The goal is to create a well-organized and efficient
structure that meets the intended purpose while considering factors like scalability,
maintainability, and performance.

Mastering Systems Design is crucial for anyone looking to build robust and
scalable systems. Our comprehensive Systems Design course provides you with
the knowledge and skills to excel in this area. Through practical examples and

J.KALPANA., MCA, ASSISTANT PROFESSOR, DEPARTMENT OF CA., Page 1

expert insights, you’ll learn how to effectively translate user requirements into
detailed designs that can be successfully implemented.

Objectives of Systems Design

Below are the main objectives of Systems Design:
 Practicality: We need a system that should be targetting the set of
audiences(users) corresponding to which they are designing.
 Accuracy: Above system design should be designed in such a way it fulfills
nearly all requirements around which it is designed be it functional o non-
functional requirements.
 Completeness: System design should meet all user requirements
 Efficient: The system design should be such that it should not overuse
surpassing the cost of resources nor under use as it will by now we know will
result in low thorough put (output) and less response time(latency).
 Reliability: The system designed should be in proximity to a failure-free
environment for a certain period of time.
 Optimization: Time and space are just likely what we do for code chunks for
individual components to work in a system.
 Scalable(flexibility): System design should be adaptable with time as per
different user needs of customers which we know will keep on changing on
time. The best example here out is the well-known firm: Nokia. It is the most
important aspect while designing systems and is the result of why 1 of 100
startups succeed over the long run, the best example here out is GeeksforGeeks.

Objectives of System Design

J.KALPANA., MCA, ASSISTANT PROFESSOR, DEPARTMENT OF CA., Page 2

Advantages of System Design
Upon detailed discussion of the introduction to system design, it is a must now to
discuss the advantages of System Design:

The greatest advantage of system design is inculcating awareness and creativity in

full-stack developers’ via synergic bonding of API protocols gateways, networking
and databases.
Some of the major advantages of System Design include:
 Reduces the Design Cost of a Product: By using established design patterns
and reusable components, teams can lower the effort and expense associated
with creating new software designs.
 Speedy Software Development Process: Using frameworks and libraries
accelerates development by providing pre-built functionalities, allowing
developers to focus on unique features.
 Saves Overall Time in SDLC: Streamlined processes and automation in the
Software Development Life Cycle (SDLC) lead to quicker iterations and faster
time-to-market.
 Increases Efficiency and Consistency of a Programmer: Familiar tools and
methodologies enable programmers to work more effectively and produce
uniform code, reducing the likelihood of errors.
 Saves Resources: Optimized workflows and shared resources minimize the
need for redundant efforts, thereby conserving both human and material
resources.
Components of Systems Design
Below are some of the major components of the System Design. discussed in brief.
The detailed version of this will be discussed in different posts:
 Load Balancers: Distribute incoming traffic across multiple servers to
optimize performance and ensure reliability.
 Key-Value Stores: Storage systems that manage data as pairs of keys and
values, often implemented using distributed hash tables.
 Blob Storage: A service for storing large amounts of unstructured data, such as
media files (e.g., YouTube, Netflix).
 Databases: Organized collections of data that facilitate easy access,
management, and modification.
 Rate Limiters: Control the maximum number of requests a service can handle
in a given timeframe to prevent overload.

J.KALPANA., MCA, ASSISTANT PROFESSOR, DEPARTMENT OF CA., Page 3

 Monitoring Systems: Tools that enable administrators to track and analyze
infrastructure performance, including bandwidth and CPU usage.
 Distributed Messaging Queues: Mediums that facilitate communication
between producers and consumers, ensuring reliable message delivery.
 Distributed Unique ID Generators: Systems that generate unique identifiers
for events or tasks in a distributed environment.


 Distributed Search: Mechanisms that allow users to search across multiple
data sources or websites for relevant information.
 Distributed Logging Services: Systems that collect and trace logs across
services to monitor and troubleshoot applications.
 Distributed Task Schedulers: Tools that manage and allocate computational
resources for executing tasks across a distributed system.

Components of System Design

Elements of a System
1. Architecture: This is the conceptual model that defines the structure, behavior,
and views of a system. We can use flowcharts to represent and illustrate the
architecture.
2. Modules: These are components that handle one specific task in a system. A
combination of the modules makes up the system.
3. Components: This provides a particular function or group of related functions.
They are made up of modules.

J.KALPANA., MCA, ASSISTANT PROFESSOR, DEPARTMENT OF CA., Page 4

4. Interfaces: This is the shared boundary across which the components of a
system exchange information and relate.
5. Data: This is the management of the information and data flow.

Software Design Process

Software Design Process

The design phase of software development deals with transforming the customer
requirements as described in the SRS documents into a form implementable using
a programming language. The software design process can be divided into the
following three levels or phases of design:
1. Interface Design
2. Architectural Design
3. Detailed Design
Interface Design
Interface design is the specification of the interaction between a system and its
environment. This phase proceeds at a high level of abstraction with respect to the
inner workings of the system i.e, during interface design, the internal of the
systems are completely ignored, and the system is treated as a black box. Attention
is focused on the dialogue between the target system and the users, devices, and
other systems with which it interacts. The design problem statement produced
during the problem analysis step should identify the people, other systems, and
devices which are collectively called agents.
Interface design should include the following details:
1. Precise description of events in the environment, or messages from agents to
which the system must respond.
2. Precise description of the events or messages that the system must produce.

J.KALPANA., MCA, ASSISTANT PROFESSOR, DEPARTMENT OF CA., Page 5

 3. Specification of the data, and the formats of the data coming into and going out
of the system.
4. Specification of the ordering and timing relationships between incoming events
or messages, and outgoing events or outputs.
Architectural Design
Architectural design is the specification of the major components of a system, their
responsibilities, properties, interfaces, and the relationships and interactions
between them. In architectural design, the overall structure of the system is chosen,
but the internal details of major components are ignored. Issues in architectural
design includes:
1. Gross decomposition of the systems into major components.
2. Allocation of functional responsibilities to components.
3. Component Interfaces.
4. Component scaling and performance properties, resource consumption
properties, reliability properties, and so forth.
5. Communication and interaction between components.
The architectural design adds important details ignored during the interface design.
Design of the internals of the major components is ignored until the last phase of
the design.

Detailed Design
Detailed design is the specification of the internal elements of all major system
components, their properties, relationships, processing, and often their algorithms
and the data structures. The detailed design may include:
1. Decomposition of major system components into program units.
2. Allocation of functional responsibilities to units.
3. User interfaces.
4. Unit states and state changes.
5. Data and control interaction between units.
6. Data packaging and implementation, including issues of scope and visibility of
program elements.
7. Algorithms and data structures.

Introduction to Software Engineering



J.KALPANA., MCA, ASSISTANT PROFESSOR, DEPARTMENT OF CA., Page 6

Software is a program or set of programs containing instructions that provide the
desired functionality. Engineering is the process of designing and building
something that serves a particular purpose and finds a cost-effective solution to
problems.

What is Software Engineering?

Software Engineering is the process of designing, developing, testing, and
maintaining software. It is a systematic and disciplined approach to software
development that aims to create high-quality, reliable, and maintainable software.
1. Software engineering includes a variety of techniques, tools, and
methodologies, including requirements analysis, design, testing, and
maintenance.
2. It is a rapidly evolving field, and new tools and technologies are constantly
being developed to improve the software development process.
3. By following the principles of software engineering and using the appropriate
tools and methodologies, software developers can create high-quality, reliable,
and maintainable software that meets the needs of its users.
4. Software Engineering is mainly used for large projects based on software
systems rather than single programs or applications.
5. The main goal of Software Engineering is to develop software applications for
improving quality, budget, and time efficiency.
6. Software Engineering ensures that the software that has to be built should be
consistent, correct, also on budget, on time, and within the required
requirements.
Key Principles of Software Engineering
1. Modularity: Breaking the software into smaller, reusable components that can
be developed and tested independently.
2. Abstraction: Hiding the implementation details of a component and exposing
only the necessary functionality to other parts of the software.
3. Encapsulation: Wrapping up the data and functions of an object into a single
unit, and protecting the internal state of an object from external modifications.
4. Reusability: Creating components that can be used in multiple projects, which
can save time and resources.
5. Maintenance: Regularly updating and improving the software to fix bugs, add
new features, and address security vulnerabilities.

J.KALPANA., MCA, ASSISTANT PROFESSOR, DEPARTMENT OF CA., Page 7

6. Testing: Verifying that the software meets its requirements and is free of bugs.
7. Design Patterns: Solving recurring problems in software design by providing
templates for solving them.
8. Agile methodologies: Using iterative and incremental development processes
that focus on customer satisfaction, rapid delivery, and flexibility.
9. Continuous Integration & Deployment: Continuously integrating the code
changes and deploying them into the production environment.

Main Attributes of Software Engineering

Software Engineering is a systematic, disciplined, quantifiable study and approach
to the design, development, operation, and maintenance of a software system.
There are four main Attributes of Software Engineering.
1. Efficiency: It provides a measure of the resource requirement of a software
product efficiently.
2. Reliability: It assures that the product will deliver the same results when used
in similar working environment.
3. Reusability: This attribute makes sure that the module can be used in multiple
applications.
4. Maintainability: It is the ability of the software to be modified, repaired, or
enhanced easily with changing requirements.
Objectives of Software Engineering
1. Maintainability: It should be feasible for the software to evolve to meet
changing requirements.
2. Efficiency: The software should not make wasteful use of computing devices
such as memory, processor cycles, etc.
3. Correctness: A software product is correct if the different requirements
specified in the SRS Document have been correctly implemented.
4. Reusability: A software product has good reusability if the different modules
of the product can easily be reused to develop new products.
5. Testability: Here software facilitates both the establishment of test criteria and
the evaluation of the software concerning those criteria.
6. Reliability: It is an attribute of software quality. The extent to which a program
can be expected to perform its desired function, over an arbitrary time period.
7. Portability: In this case, the software can be transferred from one computer
system or environment to another.
8. Adaptability: In this case, the software allows differing system constraints and
the user needs to be satisfied by making changes to the software.

J.KALPANA., MCA, ASSISTANT PROFESSOR, DEPARTMENT OF CA., Page 8

9. Interoperability: Capability of 2 or more functional units to process data
cooperatively.

Advantages of Software Engineering

There are several advantages to using a systematic and disciplined approach to
software development, such as:

1. Improved Quality: By following established software engineering principles

and techniques, the software can be developed with fewer bugs and higher
reliability.
2. Increased Productivity: Using modern tools and methodologies can
streamline the development process, allowing developers to be more productive
and complete projects faster.
3. Better Maintainability: Software that is designed and developed using sound
software engineering practices is easier to maintain and update over time.
4. Reduced Costs: By identifying and addressing potential problems early in the
development process, software engineering can help to reduce the cost of fixing
bugs and adding new features later on.
5. Increased Customer Satisfaction: By involving customers in the development
process and developing software that meets their needs, software engineering
can help to increase customer satisfaction.
6. Better Team Collaboration: By using Agile methodologies and continuous
integration, software engineering allows for better collaboration among
development teams.
7. Better Scalability: By designing software with scalability in mind, software
engineering can help to ensure that software can handle an increasing number
of users and transactions.
8. Better Security: By following the Software Development Life Cycle
(SDLC) and performing security testing, software engineering can help to
prevent security breaches and protect sensitive data.
In summary, software engineering offers a structured and efficient approach to
software development, which can lead to higher-quality software that is easier to
maintain and adapt to changing requirements. This can help to improve customer
satisfaction and reduce costs, while also promoting better collaboration among
development teams.

J.KALPANA., MCA, ASSISTANT PROFESSOR, DEPARTMENT OF CA., Page 9

Disadvantages of Software Engineering
While Software Engineering offers many advantages, there are also some potential
disadvantages to consider:
1. High upfront costs: Implementing a systematic and disciplined approach
to software development can be resource-intensive and require a significant
investment in tools and training.
2. Limited flexibility: Following established software engineering principles and
methodologies can be rigid and may limit the ability to quickly adapt to
changing requirements.

3. Bureaucratic: Software Engineering can create an environment that is

bureaucratic, with a lot of processes and paperwork, which may slow down the
development process.
4. Complexity: With the increase in the number of tools and methodologies,
software engineering can be complex and difficult to navigate.
5. Limited creativity: The focus on structure and process can stifle creativity and
innovation among developers.
6. High learning curve: The development process can be complex, and it
requires a lot of learning and training, which can be challenging for new
developers.
7. High dependence on tools: Software engineering heavily depends on the
tools, and if the tools are not properly configured or are not compatible with the
software, it can cause issues.
8. High maintenance: The software engineering process requires regular
maintenance to ensure that the software is running efficiently, which can be
costly and time-consuming.
Principles of Software Design
Software Design is also a process to plan or convert the software requirements
into a step that are needed to be carried out to develop a software system. There
are several principles that are used to organize and arrange the structural
components of Software design. Software Designs in which these principles are
applied affect the content and the working process of the software from the
beginning.
These principles are stated below :

J.KALPANA., MCA, ASSISTANT PROFESSOR, DEPARTMENT OF CA., Page 10

Principles Of Software Design :
1. Should not suffer from “Tunnel Vision” –
While designing the process, it should not suffer from “tunnel vision” which
means that is should not only focus on completing or achieving the aim but on
other effects also.
2. Traceable to analysis model –
The design process should be traceable to the analysis model which means it
should satisfy all the requirements that software requires to develop a high-
quality product.
3. Should not “Reinvent The Wheel” –
The design process should not reinvent the wheel that means it should not
waste time or effort in creating things that already exist. Due to this, the overall
development will get increased.
4. Minimize Intellectual distance –
The design process should reduce the gap between real-world problems and
software solutions for that problem meaning it should simply minimize
intellectual distance.
5. Exhibit uniformity and integration –
The design should display uniformity which means it should be uniform
throughout the process without any change. Integration means it should mix or
combine all parts of software i.e. subsystems into one system.
6. Accommodate change –
The software should be designed in such a way that it accommodates the
J.KALPANA., MCA, ASSISTANT PROFESSOR, DEPARTMENT OF CA., Page 11
 change implying that the software should adjust to the change that is required
to be done as per the user’s need.
7. Degrade gently –
The software should be designed in such a way that it degrades gracefully
which means it should work properly even if an error occurs during the
execution.
8. Assessed or quality –
The design should be assessed or evaluated for the quality meaning that during
the evaluation, the quality of the design needs to be checked and focused on.
9. Review to discover errors –
The design should be reviewed which means that the overall evaluation should
be done to check if there is any error present or if it can be minimized.
10. Design is not coding and coding is not design –
Design means describing the logic of the program to solve any problem and
coding is a type of language that is used for the implementation of a design.

Software Design Concepts

The software design concept simply means the idea or principle behind the
design. It describes how you plan to solve the problem of designing software,
and the logic, or thinking behind how you will design software. It allows the
software engineer to create the model of the system software or product that is to
be developed or built. The software design concept provides a supporting and
essential structure or model for developing the right software. There are many
concepts of software design and some of them are given below:

Software Design Concepts

J.KALPANA., MCA, ASSISTANT PROFESSOR, DEPARTMENT OF CA., Page 12

1. Abstraction (Hide Irrelevant data): Abstraction simply means to hide the
details to reduce complexity and increase efficiency or quality. Different
levels of Abstraction are necessary and must be applied at each stage of the
design process so that any error that is present can be removed to increase the
efficiency of the software solution and to refine the software solution. The
solution should be described in broad ways that cover a wide range of
different things at a higher level of abstraction and a more detailed
description of a solution of software should be given at the lower level of
abstraction.
2. Modularity (subdivide the system): Modularity simply means dividing the
system or project into smaller parts to reduce the complexity of the system or
project. In the same way, modularity in design means subdividing a system
into smaller parts so that these parts can be created independently and then
use these parts in different systems to perform different functions. It is
necessary to divide the software into components known as modules because
nowadays, there are different software available like Monolithic software that
is hard to grasp for software engineers. So, modularity in design has now
become a trend and is also important. If the system contains fewer
components then it would mean the system is complex which requires a lot of
effort (cost) but if we can divide the system into components then the cost
would be small.
3. Architecture (design a structure of something): Architecture simply means
a technique to design a structure of something. Architecture in designing
software is a concept that focuses on various elements and the data of the
structure. These components interact with each other and use the data of the
structure in architecture.
4. Refinement (removes impurities): Refinement simply means to refine
something to remove any impurities if present and increase the quality. The
refinement concept of software design is a process of developing or
presenting the software or system in a detailed manner which means
elaborating a system or software. Refinement is very necessary to find out
any error if present and then to reduce it.
5. Pattern (a Repeated form): A pattern simply means a repeated form or
design in which the same shape is repeated several times to form a pattern.
The pattern in the design process means the repetition of a solution to a
common recurring problem within a certain context.
6. Information Hiding (Hide the Information): Information hiding simply
means to hide the information so that it cannot be accessed by an unwanted

J.KALPANA., MCA, ASSISTANT PROFESSOR, DEPARTMENT OF CA., Page 13

 party. In software design, information hiding is achieved by designing the
modules in a manner that the information gathered or contained in one
module is hidden and can’t be accessed by any other modules.
7. Refactoring (Reconstruct something): Refactoring simply means
reconstructing something in such a way that it does not affect the behavior of
any other features. Refactoring in software design means reconstructing the
design to reduce complexity and simplify it without impacting the behavior
or its functions. Fowler has defined refactoring as “the process of changing a
software system in a way that it won’t impact the behavior of the design and
improves the internal structure”.
Effective Modular Design

The role of effective modular design in software engineering:
Any software comprises of many systems which contains several sub-systems
and those sub-systems further contains their sub-systems. So, designing a
complete system in one go comprising of each and every required functionality
is a hectic work and the process can have many errors because of its vast size.

Thus in order to solve this problem the developing team breakdown the complete
software into various modules. A module is defined as the unique and
addressable components of the software which can be solved and modified
independently without disturbing ( or affecting in very small amount ) other
modules of the software. Thus every software design should follow modularity.
The process of breaking down a software into multiple independent modules
where each module is developed separately is called Modularization.
Effective modular design can be achieved if the partitioned modules are
separately solvable, modifiable as well as compilable. Here separate compilable
modules means that after making changes in a module there is no need of
recompiling the whole software system.
In order to build a software with effective modular design there is a
factor “Functional Independence” which comes into play. The meaning of
Functional Independence is that a function is atomic in nature so that it performs
only a single task of the software without or with least interaction with other
modules. Functional Independence is considered as a sign of growth in

J.KALPANA., MCA, ASSISTANT PROFESSOR, DEPARTMENT OF CA., Page 14

modularity i.e., presence of larger functional independence results in a software
system of good design and design further affects the quality of the software.
Benefits of Independent modules/functions in a software design:
Since the functionality of the software have been broken down into atomic
levels, thus developers get a clear requirement of each and every functions and
hence designing of the software becomes easy and error free.
As the modules are independent they have limited or almost no dependency on
other modules. So, making changes in a module without affecting the whole
system is possible in this approach.
Independence of modules of a software system can be measured using 2 criteria
: Cohesion, and Coupling. These are explained as following below.

Cohesion:
Cohesion is a measure of strength in relationship between various functions
within a module. It is of 7 types which are listed below in the order of high to
low cohesion:
1. Functional cohesion
2. Sequential cohesion
3. Communicational cohesion
4. Procedural cohesion
5. Temporal cohesion
6. Logical cohesion
7. Co-incidental cohesion
Coupling:
Coupling is a measure of strength in relationship between various modules
within a software. It is of 6 types which are listed below in the order of low to
high coupling:
1. Data Coupling
J.KALPANA., MCA, ASSISTANT PROFESSOR, DEPARTMENT OF CA., Page 15
2. Stamp Coupling
3. Control Coupling
4. External Coupling
5. Common Coupling
6. Content Coupling
A good software design requires high cohesion and low coupling.

Understanding Design Heuristics in Software Engineering

Design heuristics in software engineering are fundamental principles or rules
that software 0engineers follow when designing systems and applications.
These principles guide the design process, ensuring that the software is robust,
efficient, and user-friendly.
We dive into the intricacies of design heuristics in software engineering, their
importance, and how they are applied in the real world.

What are design heuristics in software

engineering?
Design heuristics in software engineering are essentially guidelines that
help engineers make decisions during the design process.
They are not strict rules, but rather, they provide a framework that
engineers can use to navigate the complex landscape of software design.
These heuristics are derived from years of experience and research in the
field of software engineering.

Examples of design heuristics in software

engineering
There are numerous design heuristics in software engineering, each
serving a specific purpose in the design process.
Here are a few examples:
J.KALPANA., MCA, ASSISTANT PROFESSOR, DEPARTMENT OF CA., Page 16
 1. Modularity:
This heuristic encourages the division of a system into distinct,
independent modules. This approach enhances readability,
facilitates testing, and simplifies maintenance.
2. Abstraction:
This principle involves hiding the complexities of a system,
revealing only what is necessary. It helps in managing complexity
and promoting understandability.
3. Information Hiding:
This heuristic involves concealing the details of a module from
other modules. It promotes independence among modules, making
the system more robust and easier to modify.
Why are design heuristics in software engineering
important?
Design Heuristics
1. Find real-world objects (classes)
2. Form consistent abstraction (good and understandable view of object)

3. Encapsulate implementation details

4. Aim for strong cohesion for classes/routines
5. Keep louse coupling among classes/routines
6. Draw diagrams (e.g. using the UML)
7. Inherit when it is possible

Design heuristics in software engineering play a crucial role in the

successful development of software systems.
They guide engineers through the design process, helping them make
informed decisions that result in efficient, reliable, and user-friendly
software.
Without these heuristics, the design process can become chaotic and
unmanageable.
Engineers may overlook important aspects of the design, leading to
software that is difficult to maintain, inefficient, or fails to meet user
needs.

J.KALPANA., MCA, ASSISTANT PROFESSOR, DEPARTMENT OF CA., Page 17

The impact of design heuristics on software quality
Design heuristics in software engineering have a significant impact on
the quality of the resulting software.
By following these principles, engineers can create software that is
robust, efficient, and easy to use.
For instance, the heuristic of modularity helps improve the
maintainability of the software.
If a bug is found in a module, it can be fixed without affecting other
modules.
Similarly, the heuristic of abstraction enhances the usability of the
software by hiding unnecessary complexities from the user.
Applying design heuristics in software
engineering
Applying design heuristics in software engineering involves integrating
these principles into the design process.
This can be done at various stages of the software development lifecycle,
from requirements analysis to implementation and testing.
For instance, during the design phase, engineers can use the heuristic of
modularity to divide the system into distinct modules.
During implementation, the heuristic of information hiding can be used
to ensure that each module operates independently of others.

Challenges in applying design heuristics

While design heuristics in software engineering provide a valuable
guide, applying them in practice can be challenging.
One common challenge is the trade-off between different heuristics.
For instance, achieving high modularity may conflict with performance
requirements, as inter-module communication can be costly.
Another challenge is the subjective nature of some heuristics.

J.KALPANA., MCA, ASSISTANT PROFESSOR, DEPARTMENT OF CA., Page 18

 What constitutes ‘good’ modularity or ‘appropriate’ abstraction can vary
depending on the context and the judgement of the engineer.
Therefore, engineers need to have a deep understanding of the heuristics
and the ability to apply them judiciously.

User Interface Design


The user interface is the front-end application view to which the user
interacts to use the software. The software becomes more popular if its user
interface is:
1. Attractive
2. Simple to use
3. Responsive in a short time
4. Clear to understand
5. Consistent on all interface screens

Types of User Interface

1. Command Line Interface: The Command Line Interface provides a command
prompt, where the user types the command and feeds it to the system. The user
needs to remember the syntax of the command and its use.
2. Graphical User Interface: Graphical User Interface provides a simple
interactive interface to interact with the system. GUI can be a combination of
both hardware and software. Using GUI, the user interprets the software.
User Interface Design Process
The analysis and design process of a user interface is iterative and can be
represented by a spiral model. The analysis and design process of user interface
consists of four framework activities.

J.KALPANA., MCA, ASSISTANT PROFESSOR, DEPARTMENT OF CA., Page 19

 UI Design Stages

1. User, Task, Environmental Analysis, and Modeling

Initially, the focus is based on the profile of users who will interact with the
system, i.e., understanding, skill and knowledge, type of user, etc., based on the
user’s profile users are made into categories. From each category requirements are
gathered. Based on the requirement’s developer understand how to develop the
interface. Once all the requirements are gathered a detailed analysis is conducted.
In the analysis part, the tasks that the user performs to establish the goals of the
system are identified, described and elaborated. The analysis of the user
environment focuses on the physical work environment. Among the questions to
be asked are:
1. Where will the interface be located physically?
2. Will the user be sitting, standing, or performing other tasks unrelated to the
interface?
3. Does the interface hardware accommodate space, light, or noise constraints?
4. Are there special human factors considerations driven by environmental
factors?
2. Interface Design
The goal of this phase is to define the set of interface objects and actions i.e.,
control mechanisms that enable the user to perform desired tasks. Indicate how
these control mechanisms affect the system. Specify the action sequence of tasks
and subtasks, also called a user scenario. Indicate the state of the system when the
user performs a particular task. Always follow the three golden rules stated by
Theo Mandel. Design issues such as response time, command and action structure,
error handling, and help facilities are considered as the design model is refined.
This phase serves as the foundation for the implementation phase.

J.KALPANA., MCA, ASSISTANT PROFESSOR, DEPARTMENT OF CA., Page 20

3. Interface Construction and Implementation
The implementation activity begins with the creation of a prototype (model) that
enables usage scenarios to be evaluated. As iterative design process continues a
User Interface toolkit that allows the creation of windows, menus, device
interaction, error messages, commands, and many other elements of an interactive
environment can be used for completing the construction of an interface.
4. Interface Validation
This phase focuses on testing the interface. The interface should be in such a way
that it should be able to perform tasks correctly, and it should be able to handle a
variety of tasks. It should achieve all the user’s requirements. It should be easy to
use and easy to learn. Users should accept the interface as a useful one in their
work.
User Interface Design Golden Rules
The following are the golden rules stated by Theo Mandel that must be followed
during the design of the interface. Place the user in control:
1. Define the interaction modes in such a way that does not force the user
into unnecessary or undesired actions: The user should be able to easily
enter and exit the mode with little or no effort.
2. Provide for flexible interaction: Different people will use different interaction
mechanisms, some might use keyboard commands, some might use mouse,
some might use touch screen, etc., Hence all interaction mechanisms should be
provided.
3. Allow user interaction to be interruptible and undoable: When a user is
doing a sequence of actions the user must be able to interrupt the sequence to
do some other work without losing the work that had been done. The user
should also be able to do undo operation.
4. Streamline interaction as skill level advances and allow the interaction to
be customized: Advanced or highly skilled user should be provided a chance
to customize the interface as user wants which allows different interaction
mechanisms so that user doesn’t feel bored while using the same interaction
mechanism.
5. Hide technical internals from casual users: The user should not be aware of
the internal technical details of the system. He should interact with the interface
just to do his work.
6. Design for direct interaction with objects that appear on-screen: The user
should be able to use the objects and manipulate the objects that are present on
the screen to perform a necessary task. By this, the user feels easy to control
over the screen.
J.KALPANA., MCA, ASSISTANT PROFESSOR, DEPARTMENT OF CA., Page 21
Key Principles for Designing User Interfaces
1. User-centered design: User interface design should be focused on the needs
and preferences of the user. This involves understanding the user’s goals, tasks,
and context of use, and designing interfaces that meet their needs and
expectations.
2. Consistency: Consistency is important in user interface design, as it helps
users to understand and learn how to use an application. Consistent design
elements such as icons, color schemes, and navigation menus should be used
throughout the application.
3. Simplicity: User interfaces should be designed to be simple and easy to use,
with clear and concise language and intuitive navigation. Users should be able
to accomplish their tasks without being overwhelmed by unnecessary
complexity.
4. Feedback: Feedback is significant in user interface design, as it helps users to
understand the results of their actions and confirms that they are making
progress towards their goals. Feedback can take the form of visual cues,
messages, or sounds.
5. Accessibility: User interfaces should be designed to be accessible to all users,
regardless of their abilities. This involves considering factors such as color
contrast, font size, and assistive technologies such as screen readers.
6. Flexibility: User interfaces should be designed to be flexible and customizable,
allowing users to tailor the interface to their own preferences and needs.

J.KALPANA., MCA, ASSISTANT PROFESSOR, DEPARTMENT OF CA., Page 22