Software Engineering notes UNIT III

                                            UNIT III

1. Refining the Software Specification 

The software design process begins with a well-defined software specification. It involves the following tasks:

• Clarity of Requirements
  Understanding user requirements well and resolving their ambiguities.

• Resolving potential conflicts:
  Sometimes there may be conflicts between different requirements, which need to be resolved before design.

• Prioritization:
  Prioritizing requirements so that important features are designed first.

• Feasibility Check:
  To see how and how easily the given requirements can be met technically.

Example:

If we have to design a banking application, we first have to decide which features are mandatory like user login, balance check, money transfer, statement generation etc.

2. Application of Fundamental Procedural Designs using Software Design Paradigms

Various design patterns and procedural design are used in the software design process.

(A) Procedural Design 

In procedural design a software is divided into small modules where each module performs a particular task. It uses top-down and bottom-up approach.

1. Top-Down Approach 

   • Firstly the main problem is divided into larger blocks.

   • Each block is then broken down into smaller modules.

   • Finally, these modules are combined together to form the complete software.

2. Bottom-Up Approach 

   • First, small modules are created that accomplish a particular task.

   • These modules are then linked together to form a larger software system.

(B) Software Design Paradigms 

Design patterns are methods used to create software architecture. Some important design patterns are:

1. Structured Design 

   • Data and functions are clearly defined.

   • Flowcharts, Data Flow Diagrams (DFD) and Pseudocode are used

2. Object-Oriented Design 

   • Data and its associated functions are put together as objects.

   • Encapsulation, Inheritance, and Polymorphism are used.

   • Example: This approach is common in languages ​​like Java, Python, and C++.

3. Component-Based Design 

   • Software is broken down into separate, reusable components.

   • Example: Various modules in a web application like login system, database management, and UI design.

Example:

If we are to design an online shopping website then:

• Procedural Design: Modules like Checkout, Cart Management, Payment Processing can be created.

• Object-Oriented Design: Classes like Users, Products, Orders can be created.

• Component-Based Design: A separate login module, a product display module, and a payment gateway module can be created.

---

3. Creating a Design Concept for Data, Architectural, and Procedural Design

The main purpose of software design is to create a framework that allows software to be developed effectively and efficiently. There are three major design concepts for this:

(A) Data Design 

This process focuses on the proper organization and storage of data so that the data can be easily accessed and managed.

Important Points:

• Data is organized as Entities, Attributes, and Relationships.

• Data is represented through ER (Entity-Relationship) diagrams, Data Flow Diagrams (DFD) or Data Models.

• The redundancy of data is reduced using Normalization.

• Technologies like SQL, NoSQL are used in database design.

Example: 

If we are designing a banking system, the key entities could be:

• Customer  → Attributes: Name, Address, Contact

• Account  → Attributes: Account Number, Balance

• Transaction  → Attributes: Amount, Date, Type (Credit/Debit)

---

(B) Architectural Design 

It defines the overall structure of the software and decides how different components will interact with each other.

Major Architectural Styles::

1. Layered Architecture 

   • The software is divided into different layers.

   • Example: MVC (Model-View-Controller) design

   • Uses: Web applications, enterprise software

2. Client-Server Architecture 

   • The client requests data and the server processes it and responds.

   • Example: Websites, online banking systems

3. Microservices Architecture 

   • The software is divided into smaller, independent services.

   • Usage: In companies like Netflix, Amazon

Example:

If we are building an online shopping website, its architecture could be like this:

• Presentation Layer: User Interface (UI)

• Business Logic Layer: Order Processing, Payment Validation

• Database Layer: MySQL, MongoDB

---

(C) Procedural Design 

Procedural design is the way in which the functionality of a program is divided into individual functions or modules.

Important Points:

• Modularity : Splitting the code into smaller modules.

• Cohesion : The functions of a module are interrelated.

• Coupling : There should be minimal dependencies between modules.

Example:

A hotel management system may contain the following processes:

• Room Booking System 

• Customer Check-in & Check-out 

• Payment Processing 

4. Software Blueprint Methodology and Object-Oriented Design Paradigms

When we design a software, we have to prepare a blueprint for its correct and systematic development. This blueprint tells us how the various components of the software will interact with each other and what their data flow will be like.

(A) Software Blueprint Methodology 

A software design blueprint is a detailed plan that contains the following key elements:

1. System Architecture :

• It determines what the internal structure of the software will be like.

• Example: Monolithic (single unit), Microservices (small independent components), Layered Architecture (layered structure).

2. Design Patterns :

• Design patterns are principles used to make software repeatable, efficient, and flexible.

• Some popular design patterns:

• • Singleton Pattern: There should only be one object of a class.

  • Factory Pattern: To make object creation easier.

  • Observer Pattern: Updating other related objects when one object changes.

3. Modeling Techniques :

• Different types of diagrams are used:

  • Use Case Diagram 

  • Class Diagram 

  • Sequence Diagram 

  • Data Flow Diagram (DFD) 

Example:

If we are designing an online banking system then:

• System Architecture: Microservices based

• Design Patterns: Singleton (just one Database Connection Object), Factory (to create different types of Accounts)

• Modeling: Use Case Diagram can show the user's activities.

---

(B) Object-Oriented Design Paradigms 

Object-oriented design (OOD) encapsulates data and its associated functions, providing better code reusability and flexibility.

Main principles:

1. Encapsulation : Keeping data and functions together in a class.

2. Abstraction : Giving the user only the necessary information and hiding the complexity.

3. Inheritance : Using the features of one class in another class.

4. Polymorphism : The same function or method can work differently.

Example:

If we are designing a car management system, then:

• Encapsulation: The Car class will have attributes such as Speed, Model, and Color.

• Abstraction: The user will only see the Start() and Stop() functions, but what is happening inside the engine will be hidden.

• Inheritance: The ElectricCar and PetrolCar classes will inherit from the Car class.

• Polymorphism: The Drive() function will work differently for ElectricCar and PetrolCar.

---

5. Creating Software Design Documents

A Software Design Document (SDD) is a technical document that describes how a system is designed – its internal structure, modules, data structures, algorithms, etc.

The main points included in the SDD are:

1. Introduction :

   • Purpose and Scope of the System

   • User needs

2. Overall Description :

   • System Architecture

   • External Interfaces (User, Hardware, Software)

3. Design Considerations :

   • Focus on factors like performance, security, portability

4. Architectural Design :

   • The main modules of the system and their interrelationships

5. Component Design :

   • Detailed description of each module/class

   • Input/Output, Interfaces, Algorithms

6. User Interface Design :

   • Layout of screens, user interactions

7. Database Design:

   • Tables, Relationships, Indexes, Query Examples

Example:

If you are designing a Library Management System, your SDD will contain:

• Users: Student, Librarian

• Modules: Book Issue, Return, Search

• UI Sketches: Search Box, Book List Table

• Database Tables: Users, Books, Transactions

---

6. Review of Conformance to Software Requirements and Quality Assessment

After design it is important to check whether what has been designed actually complies with the initial requirements or not.

1. Conformance Review :

   • Comparison of design with SRS (Software Requirements Specification)

   • Does every requirement have a solution in the design?

   • What essential tasks have been missed?

2. Design Validation :

   • Is the design practical and implementable?

   • Is it scalable, modular, and secure?

3. Quality Assessment :

   • Does the design have low coupling and high cohesion?

   • Maintainability, Efficiency, Flexibility are measured

   • Methods like Peer Reviews, Walkthroughs and Design Audits are adopted

Example:

If the SRS states that "users can reset their password," but the design does not provide that option, this would be considered a conformance deficiency.