Ismaïl Khriss

Automated Prototyping of User Interfaces Based on UML Scenarios

User interface (UI) prototyping and scenario engineering have become popular techniques. Yet, the transition from scenario to formal specifications and the generation of UI code is still ill-defined and essentially a manual task, and the two techniques lack integration in the overall requirements engineering process. In this paper, we suggest an approach for requirements engineering that generates a user interface prototype from scenarios and yields a formal specification of the application. Scenarios are acquired in the form of collaboration diagrams as defined by the Unified Modeling Language (UML), and are enriched with user interface (UI) information. These diagrams are automatically transformed into UML Statechart specifications of the UI objects involved. From the set of obtained specifications, a UI prototype is generated that is embedded in a UI builder environment for further refinement. Based on end user feedback, the collaboration diagrams and the UI prototype may be iteratively refined, and the result of the overall process is a specification consisting of the Statechart diagrams of all the objects involved, together with the generated and refined prototype of the UI. The algorithms underlying this process have been implemented and exercised on a number of examples.

Generating user interface prototypes from scenarios

Requirements capture by scenarios and user interface prototyping have become popular techniques. Yet, the transition from scenarios to formal specifications is still ill-defined, and prototyping remains weak in linking the application domain with the user interface. Most importantly, the prototyping and the scenario approaches lack integration in the overall requirements engineering process. We suggest a process that generates a user interface prototype from scenarios and yields a formal specification of the application. The approach is based on the Unified Modeling Language (UML), and the generated prototypes are embedded in a user interface builder environment for further refinement. The algorithms underlying the approach have been implemented and applied on a number of examples.

Algorithmic support for model transformation in object-oriented software development

Current methods for object‐oriented software development provide notation for the specification of models, yet do not sufficiently relate the different model types to each other, nor do they provide support for transformations from one model type to another. This makes transformations a manual activity, which increases the risk of inconsistencies among models and may lead to a loss of information. We have developed and implemented an algorithm supporting one of the transitions from analysis to design, the transformation of scenario models into behavior models. This algorithm supports the Unified Modelling Language (UML), mapping the UMLs collaboration diagrams into state transition diagrams. We believe that CASE tools implementing such algorithms will be highly beneficial in object‐oriented software development. In this paper, we provide an overview of our algorithm and discuss all its major steps. The algorithm is detailed in semi‐formal English and illustrated with a number of examples. Furthermore, the algorithm is assessed from different perspectives, such as scope and role in the overall development process, issues in the design of the algorithm, complexity, implementation and experimentation, and related work. Copyright

Towards Adaptability Support in Collaborative Business Processes

Service-oriented architecture (SOA) brings new perspectives not only to software architecture but also to enterprise business processes. SOA promotes the use of loosely coupled services to automate business processes. The automation of business processes raises several challenges for enterprises. One of those challenges relates to the maintenance of business processes, more precisely how to facilitate changes within existing business processes, possibly even at run-time. Furthermore, changing a collaborative business process can have an impact on the contract specified between the parties involved. Thus, a business process may need to adapt to meet a new contract. Some approaches propose solutions to support business process adaptability; however, they do not handle adaptability in the context of multi-partner collaborative business processes. In this paper, we propose a new approach to support adaptability for such collaborative processes. This approach uses a protocol, called Change Protocol for Collaboration (CPC), for managing the changes that can have incidence on the contract.

Pattern-based refinement schemas for design knowledge transfer

The transition from high-level to low-level design is a labour-intensive and time-consuming activity since it involves many iterations over design models to obtain a well-designed system. Moreover, it requires the knowledge and expertise of experienced developers. Design patterns provide proven design knowledge by capturing successful solutions to recurring problems which arise when building software systems. To transfer this design knowledge into detailed design, methodological support is needed. We provide such support with pattern-based refinement schemas. In this paper, we present a pattern-based approach to the correct stepwise refinement of UML static and dynamic design models by application of refinement schemas. A refinement schema is composed of two compartments. The first compartment describes the abstract model of the design, whereas the second compartment shows its corresponding detailed model after transformation and instantiation of one design pattern. We also propose a number of smaller transformations called micro-refinements whose correctness is proven. These micro-refinements can be composed into sequences to produce correct refinement schemas. Our approach will allow for the construction of intelligent CASE tools that provide automatic support for the selection, management, and application of design patterns for the refinement of design models. Such tool support will enable effective design knowledge transfer.

Automating the Synthesis of UML StateChart Diagrams from Multiple Collaboration Diagrams

The use of scenarios has become a popular technique for requirements elicitation and specification building. Since scenarios capture only partial descriptions of system behavior, an approach for scenario composition and integration is needed to produce more complete specifications. The Unified Modeling Language (UML), which is emerging as a unified notation for object- oriented modeling, provides a suitable framework for scenario acquisition using Use Case diagrams and Collaboration diagrams and for behavioral specification using StateChart diagrams; yet it does not propose any specific modeling process, let alone a process for transforming scenarios into behavioral specifications. In this paper, we suggest a four-step process for synthesizing behavioral specifications from scenarios. It generates from a given set of Collaboration diagrams the StateChart diagrams of all the objects involved. Our approach is incremental and is fully compliant with the UML. Furthermore, it provides an elegant solution to the problem of scenario interleaving. The underlying algorithm has been implemented and validated with several examples, and is fit for integration into CASE tools supporting the UML.

Towards the automatic discovery of platform transformation templates of legacy object-oriented systems

Software modernization is needed to perform the evolution of a system when conventional practices can no longer achieve the desired evolution goal. In their initiative called architecture-driven modernization (ADM), the Object Management Group proposes to use MDA to perform this modernization. However, ADM needs new tools and techniques to migrate systems developed on a non-model-driven environment to a model-driven environment. One challenge to enable this migration is the discovery of a platform description model (PDM) from the implementation of a system. In this paper, we propose an approach to discover a view of the PDM from an object-oriented system source code. This view is given as a set of transformation templates parameterizing the source code of the systems implementation platform and expressed in the QVT language. The approach uses different analysis techniques and was validated on several systems written in Java and gives good results for a number of them.

An MDA-Based Approach for WS Composition Using UML Scenarios

Web services are an interesting emerging technology for the development of distributed applications with respect to SOA (Service Oriented Architecture) paradigm due to the many features provided by the technology. One of these features is service composition, which consists of combining existing services to provide a richer new composite service to meet some user requirements. This paper proposes a new method for composing web services by using UML scenarios expressed as sequence diagrams, and an MDA (Model Driven Architecture) approach to generate the code of the composite service in BPEL (Business Process Execution Language). Our approach consists of three main steps. In the first step, existing simple web services are discovered and located in the web service registry. The developer imports the WSDL files of the candidate services and translates them into UML diagrams (class diagram, use case diagram and sequence diagrams). In the second step, the sequence diagrams, referred to as scenarios, are integrated into a single sequence diagram that describes the behaviour of the composite web service, by using the interaction operators of UML 2.0. In the third step, the MDA approach is adopted to transform the resulting sequence diagram into a BPEL process. As such, our method has the advantages of being independent of the web service composition language and the UML modelling tool, the user can choose any UML design tool, any language of composition and any execution engine to compose services.