Structured Analysis | System Design - Software Development PDF Download

Introduction

When it comes to designing complex systems, having a clear and organized approach is crucial. Structured analysis provides a systematic way to understand and document requirements, processes, and data in a system. In this article, we will explore the basics of structured analysis and how it can be used in system design. We'll cover its key concepts, provide examples, and even include simple code snippets to illustrate the practical implementation.

What is Structured Analysis?

Structured analysis is a technique used in system design to break down complex systems into smaller, manageable modules. It focuses on understanding the system's processes, data flow, and requirements, allowing designers to create clear and concise system specifications.

Key Concepts of Structured Analysis

To grasp structured analysis, it's important to familiarize yourself with a few key concepts:
a) Data Flow Diagrams (DFDs): Data Flow Diagrams visually represent how data flows through a system. They consist of processes, data stores, external entities, and data flows. Let's take an example:
Example: Consider a simple library system where a user can borrow books. We can represent the system using a Data Flow Diagram as follows:

                Borrow Book

User ------->    System    ------>   Book

              (Process)              (Data Store)

Here, the user interacts with the system (process) to borrow a book (data flow) from the book collection (data store).

b) Entity Relationship Diagrams (ERDs): Entity Relationship Diagrams are used to model the relationships between different entities in a system. They help in understanding the data requirements and relationships between various components. Here's an example:
Example: In a school management system, we can represent the relationship between students and courses using an ERD as follows:

      +------------------+              +------------------+

      |     Student      |              |      Course      |

      +------------------+              +------------------+

      |     StudentID    |<>------<>|    CourseID     |

      |     Name         |              |      Name        |

      +------------------+              +------------------+

Here, the "Student" entity is related to the "Course" entity through the "StudentID" and "CourseID" attributes.

Examples of Structured Analysis

Let's explore a couple more examples to understand how structured analysis can be applied in different scenarios:
a) Banking System: A banking system can be modeled using structured analysis. We can use DFDs to illustrate how different processes interact and how data flows within the system. Here's a simplified DFD for a banking system:

     +------------------+             +------------------+

     |   Customer       |             |    Bank          |

     +------------------+             +------------------+

        |              |                 |              |

        | Open Account |                 |              |

        v              |                 v              |

     +------------------+             +------------------+

     |    Account       |             |   Transaction    |

     +------------------+             +------------------+

In this example, the "Customer" interacts with the "Bank" to open an account. The "Bank" performs various processes, and the data flows through "Account" and "Transaction" entities.

b) Online Shopping System: Structured analysis can also be applied to model an online shopping system. Here's a simplified DFD for an online shopping system:

     +------------------+             +------------------+

     |    Customer      |             |     Online       |

     +------------------+             |   Shopping       |

        |              |             |     System       |

        | Place Order  |             +------------------+

        v              |

     +------------------+

     |     Order        |

     +------------------+

In this example, the "Customer" interacts with the "Online Shopping System" to place an order. The data flows through the "Order" entity, capturing the necessary information for order processing.

Practical Implementation with Code Snippets

Now, let's see how structured analysis can be practically implemented using simple code snippets.
a) Data Flow Diagrams (DFDs) with Python: Python provides several libraries to create DFDs. One popular library is matplotlib. Here's an example of how to create a basic DFD using Python:

import matplotlib.pyplot as plt

# Define the elements of the DFD

elements = ['Process', 'Data Store', 'External Entity', 'Data Flow']

# Define the connections between elements

connections = [('Process', 'Data Store'), ('External Entity', 'Process'),

               ('Process', 'Data Flow')]

# Create the plot

plt.figure(figsize=(6, 6))

plt.axis('off')

plt.title('Example DFD')

plt.tight_layout()

# Draw the elements

for element in elements:

    plt.annotate(element, (0.5, 0.5), ha='center', va='center')

# Draw the connections

for connection in connections:

    plt.annotate('', xy=(0.5, 0.5), xytext=(0.5, 0.5), xycoords='data',

                 textcoords='data', arrowprops=dict(arrowstyle='->'))

# Show the plot

plt.show()

Output: The code will generate a basic DFD plot showing the elements and their connections.

b) Entity Relationship Diagrams (ERDs) with SQL: To create ERDs, SQL databases offer the necessary functionality. Here's an example of how to create a simple ERD using SQL:

CREATE TABLE Student (

    StudentID INT PRIMARY KEY,

    Name VARCHAR(50)

);

CREATE TABLE Course (

    CourseID INT PRIMARY KEY,

    Name VARCHAR(50)

);

CREATE TABLE Enrollment (

    StudentID INT,

    CourseID INT,

    FOREIGN KEY (StudentID) REFERENCES Student(StudentID),

    FOREIGN KEY (CourseID) REFERENCES Course(CourseID)

);

Explanation: In this code snippet, we define three tables: "Student," "Course," and "Enrollment." The "Enrollment" table acts as the relationship between "Student" and "Course" tables.

Sample Problems and Solutions

Problem 1: Design a structured analysis for a simple calculator application.

We can represent the calculator application using a DFD. Here's a possible solution:

   +------------------------+

   |        Calculator      |

   +------------------------+

        |          |        

        |  Input   |        

        v          |        

   +------------------------+

   |         Logic          |

   +------------------------+

                |

                v

          +------------------+

          |      Output      |

          +------------------+

Problem 2: Create an ERD for a music streaming application.

We can design an ERD for a music streaming application as follows:

   +-------------------------+

   |        User             |

   +-------------------------+

   |  UserID                 |

   |  Name                   |

   +-------------------------+

   +-------------------------+

   |        Song             |

   +-------------------------+

   |  SongID                 |

   |  Title                  |

   +-------------------------+

   +-------------------------+

   |      UserPlaylist       |

   +-------------------------+

   |  UserID                 |

   |  PlaylistID             |

   +-------------------------+

   +-------------------------+

   |      Playlist           |

   +-------------------------+

   |  PlaylistID             |

   |  Title                  |

   +-------------------------+

   +-------------------------+

   |   SongInPlaylist        |

   +-------------------------+

   |  PlaylistID             |

   |  SongID                 |

   +-------------------------+

Conclusion

Structured analysis provides a systematic approach to system design by breaking down complex systems into manageable components. By utilizing techniques like Data Flow Diagrams (DFDs) and Entity Relationship Diagrams (ERDs), we can better understand system requirements, processes, and data flow. With practical code snippets and examples, this article has aimed to provide a beginner-friendly introduction to structured analysis in system design.