UNIT – IV

DESIGNS
Software Design Process – Software Engineering

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

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.
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.

Conceptual and Technical Designs

 Conceptual Design: This is the high-level design phase where the system’s
architecture and major components are identified and specified. The main goal is to
define the what and why of the system — what functionalities will be included, and
why the chosen approach or architecture is suitable for the requirements. It focuses on
understanding the problem space and solving it from a conceptual standpoint, without
worrying about technical implementation details.
  Technical Design: This phase follows conceptual design and focuses on the how. It
involves determining how the system will be implemented, addressing the technical
details, choosing technologies, tools, databases, and platforms, and deciding on
software components and their interactions. It also includes defining interfaces, data
structures, and specific algorithms.

Objectives of Design

The objectives of design in software engineering are to ensure that the software is:

1. Correct: The system should perform as expected and meet the requirements.
2. Efficient: It should perform well in terms of resource usage (e.g., memory, CPU
time).
3. Maintainable: The software should be easy to update and modify, allowing for easy
debugging, enhancements, and fixes.
4. Scalable: It should be able to handle increased load or expand over time without
requiring a complete redesign.
5. Reliable: The software should consistently perform its intended functions without
failures.
6. Usable: It should provide a user-friendly interface, ensuring a positive experience for
the end-user.

Modularity

 Modularity refers to dividing a software system into smaller, manageable units or

modules. Each module encapsulates a specific functionality and can be developed,
tested, and maintained independently. Modularity promotes:

o Reusability: Modules can be reused across different projects.

o Maintainability: It is easier to modify one module without affecting the entire
system.
o Scalability: The system can be easily extended by adding new modules
without disrupting existing functionality.
o Separation of Concerns: Each module focuses on a specific concern or
functionality, simplifying the design process.

Function-Oriented Design

 Function-Oriented Design focuses on defining the functions or operations that the

system will perform and organizing the system around those functions. It is a
 traditional approach that typically follows a top-down process where the system is
decomposed into functions or procedures, each handling specific tasks.

 Key Characteristics:
o Decomposition: The system is broken down into a hierarchy of functions.
o Data Flow: Emphasizes the flow of data between functions.
o Modularity: Functions are modular, allowing for independent testing and
maintenance.

 Example: In function-oriented design, software systems might be designed as a series

of functions (e.g., calculate_salary, process_payment, generate_report).

Software Reliability: Basic Concepts

 Software Reliability refers to the probability that a software system will perform its
intended functions without failure under specified conditions for a specified period of
time.

 Key Concepts:
o Failure: When the software does not perform as expected.
o Fault: A defect or bug in the software that can potentially lead to a failure.
o Error: A discrepancy between the software’s behavior and its specification or
requirements.
o Reliability Metrics: Metrics such as Mean Time Between Failures (MTBF)
and failure rate are used to quantify software reliability.

Software Reliability Maturity Levels

Software reliability often evolves through various maturity levels, commonly outlined in
models such as the Capability Maturity Model (CMM) or Software Reliability
Engineering:

1. Initial (Level 1): At this stage, software is unpredictable and unreliable. Development
is typically ad-hoc.
2. Managed (Level 2): Some processes are defined, and basic reliability testing is
performed.
3. Defined (Level 3): Software reliability is systematically measured, and testing
methods are formalized.
4. Quantitatively Managed (Level 4): The software reliability is continuously
monitored, and statistical methods are used for improvement.
 5. Optimizing (Level 5): Continuous improvement processes are in place, focusing on
optimization and predictive reliability.

IMPORTANT QUESTIONS

5 Marks Questions

1. What is the difference between conceptual design and technical design in

software engineering?
2. Explain the importance of modularity in software design.
3. List the key objectives of the software design process.
4. What is the significance of function-oriented design in the development of
software?
5. Define software reliability and why is it important in software development?
6. What are the basic concepts of software reliability?
7. Describe the concept of "modularity" with an example.
8. What does "function-oriented design" emphasize in software development?
9. Explain the basic concept of "software reliability maturity levels."
10. Identify and explain the primary goals of software design.

10 Marks Questions

1. Compare and contrast conceptual design and technical design. Explain the role
each plays in the overall software development process.
2. Discuss the objectives of design in software engineering and how these objectives
impact the final product.
 3. Describe the function-oriented design approach and provide examples where this
approach is suitable.
4. Explain the concept of software reliability and how it impacts the lifecycle of a
software project.
5. Discuss the importance of modularity in software design. How does modularity
contribute to maintenance and scalability of software systems?
6. Explain the maturity levels of software reliability. How do these levels help in
improving the reliability of software over time?
7. What is function-oriented design, and how does it differ from object-oriented
design?
8. Discuss the relationship between conceptual design and software requirements.
How does conceptual design help in identifying key functionalities of the system?
9. Explain the importance of software reliability in real-world applications and
how it can be measured and improved.
10. How do modular designs improve the reliability and scalability of software
systems? Provide an example.

15 Marks Questions

1. Critically analyze the role of conceptual and technical design in software

engineering. How do they influence the success of a software project?
2. Discuss in detail the objectives of software design. How do modularity, function-
oriented design, and reliability contribute to achieving these objectives?
3. Explain function-oriented design in the context of software engineering. Discuss
its strengths, weaknesses, and situations where it is particularly useful.
4. Examine the concept of software reliability. Discuss its importance, key concepts,
and strategies for improving software reliability in different phases of the
software lifecycle.
5. Evaluate the role of software reliability maturity levels in improving the quality
and performance of software systems. Provide examples of real-world software
that has evolved through these levels.
6. Discuss how modularity in design can lead to better software maintenance and
easier debugging. Explain with an example of a modular software system.
7. Describe the differences between software reliability and software quality. How
does software reliability impact the system's operational performance?
8. Analyze the different software reliability maturity levels and their impact on the
software development process. Provide examples of how these levels can be
applied in practice.
9. Explain how conceptual and technical design affect the overall system
architecture. Provide a detailed example of how poor design decisions at the
conceptual or technical level can lead to project failure.
10. Discuss the relationship between function-oriented design and modularity in
software development. How can the two complement each other to improve
system design and maintainability?