System Analysis and Design / Case Study – DevScope
1. System Analysis
1.1 Problem Identification
Developers face difficulty in quickly identifying performance bottlenecks, execution
inefficiencies, and code-level exceptions. Existing profiling tools are either too complex or
require manual log inspection, slowing down the development process.
1.2 Proposed Solution
DevScope automates runtime monitoring of Java applications by:
Using AspectJ bytecode weaving to insert monitoring code without changing the
source.
Collecting execution metrics (function calls, paths, execution time, exceptions).
Storing metrics in Firebase for centralized, secure access.
Presenting analytics visually on a ReactJS dashboard.
1.3 Feasibility Study
Technical Feasibility: Uses widely available technologies (Java, AspectJ, [Link],
ReactJS, Firebase) with stable community support.
Operational Feasibility: Developers can easily integrate their existing Java
applications by uploading JAR files for weaving.
Economic Feasibility: Low cost — relies on open-source tools and cloud-based
storage.
2. System Design
2.1 Architecture Overview
DevScope follows a 3-tier architecture:
1. Presentation Layer – ReactJS dashboard for data visualization.
2. Application Layer – [Link] + Express backend for API handling and AspectJ
integration.
3. Data Layer – Firebase NoSQL database for runtime metric storage.
2.2 Data Flow Diagram (DFD)
Level 0 (Context Diagram):
User uploads Java application JAR → DevScope Server weaves with AspectJ →
Execution metrics sent to Firebase → Data retrieved by dashboard for visualization.
Level 1:
1. JAR Upload → AspectJ Weaving Module → Instrumented JAR created.
2. Application execution → Data Collection Module → Firebase Storage.
3. Dashboard requests metrics from backend → API fetches data → Visualization on
dashboard.
2.3 UML Diagrams
Use Case Diagram
o Actors: Developer (user), System (DevScope).
o Use Cases: Upload JAR, View Analytics, Monitor Exceptions, Track
Execution Paths, Download Reports.
Sequence Diagram (simplified)
1. Developer uploads JAR.
2. Backend runs AspectJ weaving.
3. Instrumented JAR executes and sends metrics to Firebase.
4. Dashboard requests metrics → Backend fetches from Firebase → Dashboard
displays results.
3. Case Study Example
Scenario:
A Java developer notices their web application is running slowly under certain conditions.
1. They package their application into a JAR and upload it to DevScope.
2. DevScope weaves monitoring aspects and returns the instrumented JAR.
3. The developer runs the instrumented application in a test environment.
4. Execution metrics (function call counts, execution times, exceptions) are
automatically sent to Firebase.
5. The developer opens the DevScope dashboard, sees that a specific
function calculateOrderTotal() is consuming excessive time, and optimizes the
function logic.
6. Application performance improves significantly after changes.