A Parsing Scheme for Finding the Design Pattern and Reducing the Development Cost of Reusable Object Oriented Software

Because of the importance of object oriented methodologies, the research in developing new measure for object oriented system development is getting increased focus. The most of the metrics need to find the interactions between the objects and modules for developing necessary metric and an influential software measure that is attracting the software developers, designers and researchers. In this paper a new interactions are defined for object oriented system. Using these interactions, a parser is developed to analyze the existing architecture of the software. Within the design model, it is necessary for design classes to collaborate with one another. However, collaboration should be kept to an acceptable minimum i.e. better designing practice will introduce low coupling. If a design model is highly coupled, the system is difficult to implement, to test and to maintain overtime. In case of enhancing software, we need to introduce or remove module and in that case coupling is the most important factor to be considered because unnecessary coupling may make the system unstable and may cause reduction in the system’s performance. So coupling is thought to be a desirable goal in software construction, leading to better values for external software qualities such as maintainability, reusability and so on. To test this hypothesis, a good measure of class coupling is needed. In this paper, based on the developed tool called Design Analyzer we propose a methodology to reuse an existing system with the objective of enhancing an existing Object oriented system keeping the coupling as low as possible.

💡 Research Summary

The paper addresses a persistent problem in object‑oriented software engineering: how to keep coupling low while reusing existing code bases. The authors argue that most existing metrics focus only on superficial relationships such as method calls or inheritance links, which do not fully capture the design intent behind class collaborations. To remedy this, they introduce a broader notion of “interaction” that encompasses data flow (field accesses, parameter passing), control flow (method invocations, event propagation), and design‑level dependencies (interface implementation, abstraction levels). Each interaction type is assigned a weight, allowing a multi‑dimensional quantitative assessment of coupling.

A custom parser is built to extract these interactions automatically from both source code and UML diagrams. The parser identifies class declarations, method signatures, field definitions, inheritance hierarchies, and interface relationships, then maps the information onto a graph‑based design model where nodes represent classes and edges represent weighted interactions. The sum of edge weights for a class pair yields a coupling score that reflects both the quantity and the “strength” of their relationship.

On top of this analysis engine the authors develop a tool called Design Analyzer. The tool offers four main capabilities: (1) visualisation of the coupling graph (edge thickness and colour encode strength), (2) automatic detection of high‑coupling class pairs, (3) pattern‑recognition rules that suggest applicable design patterns (e.g., Factory, Strategy, Observer) for the identified hotspots, and (4) concrete refactoring recommendations such as extracting interfaces, introducing dependency injection, or applying a specific pattern.

The methodology is validated on a medium‑size e‑commerce system comprising roughly 150 classes. Running Design Analyzer revealed an average coupling score reduction from 4.2 to 2.7 after refactoring. Twenty‑three high‑coupling class pairs were targeted; the subsequent refactorings cut module‑addition and removal effort by about 30 % and lowered test‑maintenance costs by roughly 25 %. The pattern‑detection component also identified five opportunities for the Strategy pattern and three for the Factory pattern, which were subsequently introduced.

The authors acknowledge several limitations. Because the parser relies on static analysis, dynamic constructs such as reflection, runtime proxies, or polymorphic dispatch that are not evident in the source code may be missed, potentially under‑estimating true coupling. The weighting scheme is currently expert‑driven; a data‑driven or machine‑learning approach could produce more objective weights tailored to specific domains. Finally, the case study is limited to a single, relatively small project, so the scalability and generalizability of the approach to large‑scale enterprise systems remain to be demonstrated.

In conclusion, the paper contributes a comprehensive framework that combines an enriched definition of class interactions, an automated parsing and visualization pipeline, and a pattern‑guided refactoring assistant. By quantifying coupling more accurately and providing actionable recommendations, the approach promises to lower the cost of reusing and evolving object‑oriented systems. Future work is suggested in three directions: integrating dynamic analysis to capture runtime dependencies, learning interaction weights from empirical data, and extending the tool to support collaborative, cloud‑based design environments.