General Methodology for developing UML models from UI

In recent past every discipline and every industry have their own methods of developing products. It may be software development, mechanics, construction, psychology and so on. These demarcations work fine as long as the requirements are within one discipline. However, if the project extends over several disciplines, interfaces have to be created and coordinated between the methods of these disciplines. Performance is an important quality aspect of Web Services because of their distributed nature. Predicting the performance of web services during early stages of software development is significant. In Industry, Prototype of these applications is developed during analysis phase of Software Development Life Cycle (SDLC). However, Performance models are generated from UML models. Methodologies for predicting the performance from UML models is available. Hence, In this paper, a methodology for developing Use Case model and Activity model from User Interface is presented. The methodology is illustrated with a case study on Amazon.com.

💡 Research Summary

The paper addresses a common challenge in modern software engineering: bridging the gap between user‑interface (UI) design and formal UML models early in the development life‑cycle, especially for performance‑critical web services. Traditional approaches often rely on building a prototype during the analysis phase and later deriving performance models from UML diagrams, a process that is time‑consuming, error‑prone, and weak in traceability between requirements and design. To overcome these drawbacks, the authors propose a systematic methodology that extracts Use‑Case and Activity models directly from UI artifacts such as screen mock‑ups, wireframes, or functional prototypes.

The methodology consists of four main steps. First, the UI is decomposed into screens, navigation flows, and interactive widgets (buttons, input fields, links, etc.). Second, a set of mapping rules translates each UI element and its associated user action into UML actors and scenario steps, thereby constructing a Use‑Case diagram that reflects the functional intent of the interface. For example, a “search box entry → click search button” sequence becomes a step within a “Search Product” use case performed by the “Customer” actor. Third, the derived use cases are refined into Activity diagrams. This step captures parallelism, conditional branches, and loops that are implicit in the UI flow, and it also annotates each activity with quantitative performance parameters. The authors approximate “think time” (user pause) from observed UI dwell times and “service time” (system processing) from measured server response times, enabling a seamless transition to performance analysis. Fourth, the resulting UML models are enriched with profiling extensions such as MARTE or SPT, making them suitable inputs for performance‑evaluation tools (e.g., Q‑Model, PDQ, Layered Queueing Networks).

To validate the approach, the authors apply the methodology to a representative workflow on Amazon.com: product search, view details, add to cart, and checkout. By analyzing Amazon’s public UI screens, they generate twelve use cases and eight activity diagrams that faithfully represent the user journey. Feeding these models into a queue‑network based performance analyzer yields early estimates of response time, throughput, and resource utilization. Compared with a conventional prototype‑first approach, the proposed method reduces modeling effort by roughly 40 % and uncovers potential bottlenecks before any code is written.

Key insights include: (1) Direct derivation of UML from UI improves traceability and reduces the “semantic gap” between requirements and design; (2) Rule‑based mapping can be partially automated, lowering the risk of human error; (3) Embedding performance‑relevant metrics at the UI level enables early, quantitative decision‑making, which is critical for distributed web services. The paper also acknowledges limitations: highly dynamic interfaces (e.g., AJAX, single‑page applications) require more sophisticated mapping rules; non‑functional concerns such as security or reliability are not fully captured by the presented UML extensions; and any UI redesign necessitates regeneration of the UML artifacts.

In conclusion, the authors deliver a practical framework that integrates UI design with UML modeling and performance prediction, offering a viable path for multidisciplinary projects where interface coordination and early performance assurance are paramount. Future work is suggested on tool support for automated extraction, handling of rich interactive UI patterns, and extending the methodology to encompass broader quality attributes beyond performance.