Jayeeta Chanda

UML-compiler: a framework for syntactic and semantic verification of UML diagrams

UML being semi formal in nature, it lacks formal syntax and hence automated verification of design specifications cannot be done. To address this we propose a UML Compiler that takes context free grammars for UML diagrams and verifies the syntactic correctness of the individual diagrams and semantic correctness in terms of consistency verification with other diagrams. This UML-Compiler is a part of a framework, which consists of two modules. First module converts XMI format of UML diagrams, as generated by any standard tool into string format and second module (UML-Compiler) is for verification of the diagrams. This paper focuses on the second module and proposes a formal context free grammar for the two of the commonly used UML diagrams - Class diagram (depicting the static design) and sequence diagram (depicting behavioral design) and validated by using Lex and YACC.

Traceability between service component and class: a model based approach

Service components are the key to the development of a serviceoriented solution as they provide the implementation of the services. The implementation of Service components provides the actual function of the component and can be defined with one or more Java classes. We propose a model named Service Component to Class (SC2C) that maps the service components of an application with that of the classes that implement the service components. We also propose a visual model as a part of SC2C that represents the classes and relationship among classes. This model helps to establish traceability among service components and classes. We also introduce some traceability metrics to measure traceability between the artifacts of Service Oriented Architecture (SOA) and Object Oriented (OO) paradigms. This work, along with our earlier work, help in Software Configuration Management of a SOA application. We provide an insurance system case study to illustrate our approach.

SCAG: a graphical approach to measure the complexity of the SOA application

Service Oriented Architecture (SOA) provides a foundation to achieve software reuse that enables business professionals, who are not necessarily programmers, to exploit the intrinsic properties of software. A component-based programming model is the key factor in the rapid adoption of SOA. SOA exploits the properties of Component Based Software Engineering (CBSE) in the form of services. SOA components help to provide the business users with some flexibility to play around with the components and rewire them to create new business solutions. The complexity of SOA application plays an important role in project planning and determination of timeline and cost estimation and allocation of resources. This paper proposes a metric-based approach for the determination of relative complexity and coupling of Component based SOA application. We have proposed a Service Component Architecture Graph (SCAG) which can be used for graphical representation of the different service module, the service components in the service module and interaction among them. This metrics may be used by developers to assess the complexity of SOA application and if required redesign to create highly cohesive components with minimal coupling. It will also promote a culture of asset (reusable components) based development by considering the factor like usability, complexity, coupling etc. A case study is presented and graph based analysis is done for deriving the complexity, along with the other aspects of the architecture.

Formalization of the design phase of software lifecycle: a grammar based approach

In Object Oriented systems, the design phase can be modeled using the three diagrams: Sequence diagram (which depicts responses of all objects that are involved in a single use case), Class Diagram (which is used to depict the structural aspect of design) and State chart diagram (which is used to depicts the states and state dependent behavior for objects). In this paper, we have proposed a framework for verification of these diagrams, which includes syntactic correctness and inter-diagram consistency. This is done by proposing Context Free Grammar for the three diagrams. The proposed grammar is validated by using Lex and Yacc and parse tree is generated which is an alternate form of the grammar. This framework, being built based on a formal approach, would enable us to automate the process of correctness and consistency verification among the diagrams used in design phase. This would also help us in ensuring requirement traceability on the long run.

Requirements to Services: A Model to Automate Service Discovery and Dynamic Choreography from Service Version Database

As the software industry is gradually moving toward the cloud computing in a fast pace, Service oriented architecture (SOA) is increasingly becoming more and more important, as far as the Software As a Service (SAAS) is concerned. As SOA applications are maturing, it becomes imperative to maintain the various versions of services published in the Enterprise Service Bus (ESB). However, for implementing a particular requirement, it may not always be cost-efficient, to use the latest version of the services. If a previous version matches the requirement, then that might be a cost-effective solution and enabling “reuse” to a larger extent can be a very useful method in cloud computing domain where pay per use is the accepted norm. In this chapter, we devise a comprehensive framework that models requirements in a formal manner and automatically extracts verbs to generate an activity model, which is then translated into BPMN notation based on a set of transformation rules. The BPMN nodes are mapped to services and an algorithm for dynamic discovery of appropriate service version is conceived. Thereafter we also verify the entire transformation process and ensure correctness by developing a traceability model and generate trace table to trace from requirements till services and apply it for a case study for substantiation of our approach.

Transformation Framework for Consistent Evolution of UML Behavioral Elements into BPMN Design Element

There are many software products that have been developed in the object-oriented paradigm. To incorporate the positive aspects of service-oriented paradigm (SOA) and address the issues related to increasing size and complexity of software products, they need to be evolved to service-oriented domain. There are some proven Object Oriented (OO) Design Tools that can be used for Service Oriented Application design incorporating both the behavioral and structural aspects in a seamless, consistent evolution that can be made from object oriented to service oriented domain. In this chapter, we concentrate on the evolution process of behavioral aspect of design from OO to SOA. Business Process Modeling Notation (BPMN) has become the de-facto standard for modeling business process on a conceptual level. Business processes are an integral part of service-oriented architecture. In service-oriented applications Use cases needs to be ordered along business processes. Business Processes visualize global control-flow across Use cases. Therefore, use of a business process language to visualize the dependencies among different use cases is of high importance. Use case diagram along with activity diagrams represents the behavioral aspect of a system in the analysis phase of an object-oriented system. To enable modeling the relationship among different behavioral aspects and evolve from object oriented domain to service oriented domain, a formal approach would help in establishing the foundation. In order to do that, in this work, we propose a formal framework, FAM (Formalized analysis model), which is a set of grammar based formalized Use case and Activity diagram elements of UML and a framework for verification of the diagrams, which includes syntactic correctness and requirement traceability. Along with that, we also propose FAM2BP (Formalized Analysis Model to Business Process) for transformation of Formalized Analysis Model (FAM) of object-oriented systems into BPMN process for SOA application using a set of rules that will help in generating business processes for SOA application directly from object oriented analysis models. This model would help in a consistent evolution of software development paradigms from Object Oriented to Service Oriented systems.