Ananya Kanjilal

Measuring complexity of component based architecture: a graph based approach

Component based software development (CBSD) is an evolving paradigm where emphasis is laid on reuse of existing components and effective designing of components. As complexity of software systems increases, the challenge of CBSD lies in designing highly cohesive, testable components. Researcher community is striving hard to identify the attributes characterizing component-based development and proposing metrics that may help in controlling the complexity of the component-based systems. This paper proposes a metric-based approach for the determination of complexity along with a set of architectural aspects of componentbased architectures. The Component Architecture Complexity Measurement Metrics (CACMM) has been proposed based on Component Architecture Graph (CAG), a graphical model used for representing UML component diagram. Analysis of the graph is done to measure complexity at different levels -- individual component level, component-to-component level and the complexity for the overall architecture. This metrics may be used by developers to assess the component based architecture and if required re-design to create highly cohesive components with minimal coupling. A case study is presented for deriving the complexity along with the other aspects of the architecture.

Analysis of complexity of requirements: a metrics based approach

In this paper we have developed a metrics based model that will help in quantitatively estimating complexity of requirements for object oriented development methodology. Use Case point is a well-known metrics used for estimation based on use cases. Our model goes a step forward and provides a measurement methodology based on other design models like sequence and class diagrams. This metrics model is based on a formal model using Z notation and implemented using a XML based approach. Measuring complexity of a requirement in terms of design elements will help in validating estimates in the design phase and project management in the long run.

Code based analysis for object-oriented systems

The basic features of object-oriented software makes it difficult to apply traditional testing methods in object-oriented systems. Control Flow Graph (CFG) is a well-known model used for identification of independent paths in procedural software. This paper highlights the problem of constructing CFG in object-oriented systems and proposes a new model named Extended Control Flow Graph (ECFG) for code based analysis of Object-Oriented (OO) software. ECFG is a layered CFG where nodes refer to methods rather than statements. A new metrics— Extended Cyclomatic Complexity (E-CC) is developed which is analogous to McCabe’s Cyclomatic Complexity (CC) and refers to the number of independent execution paths within the OO software. The different ways in which CFG’s of individual methods are connected in an ECFG are presented and formulas for E-CC for these different cases are proposed. Finally we have considered an example in Java and based on its ECFG, applied these cases to arrive at the E-CC of the total system as well as proposed a methodology for calculating the basis set, i.e., the set of independent paths for the OO system that will help in creation of test cases for code testing.

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.

Adv-EARS: A Formal Requirements Syntax for Derivation of Use Case Models

The development of complex systems frequently involves extensive work to elicit, document and review functional requirements that are usually written in unconstrained natural language, which is inherently imprecise. Use of Formal techniques in Requirement Engineering would be of immense importance as it would provide automated support in deriving use case models from the functional requirements. In this paper we propose a formal syntax for requirements called Adv-EARS. We define a grammar for this syntax such that a requirements document in this format can be grammatically parsed and the prospective actors and use cases are automatically derived from the parse tree. The use case diagram is then automatically generated based on the actors and use cases and their relationships. We have used requirements of an Insurance system as a 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.

A mathematical reusability model for quantifying the reduction in development effort

Software Effort and Cost Estimation is a very important activity that includes very uncertain elements. In the context of object-oriented software, traditional methods and metrics were extended to help managing this activity. Use Case Points (UCP) is a very well known metrics used for estimation of object-oriented systems. Use case models are used in Object-Oriented Analysis for capturing and describing the Functional-Requirements of a system. Several methods for estimating software development effort are based on attributes of a use case model. In this paper, we propose a mathematical model based on vectors to measure reusability of software design in terms of reusability of the use cases. Increasing reusability of the use case model would lead to decrease in development effort. Using the vector model, we propose an approach to measure Complexity Reduction Factor (CRF) which measures percentage decrease in effort and hence in cost with increasing reusability. This quantitative analysis of effort reduction with increased reusability would enable us in designing reusable and cost effective software much earlier in software development life cycle, right at the requirement engineering phase. We have used requirements of an Insurance system as a case study to illustrate our approach.

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.

Separation of scattered concerns: a graph based approach for aspect mining

Aspect Mining is a dynamic area of research in the field of Software Engineering. Aspects are concerns that are intermingled with other concerns thereby reducing the understandability, maintainability and scalability of the code. The concept of Separation of Concerns (SoC) is often achieved untill the Design Phase, but gets difficult in the later phases of the software development life cycle (SDLC). During program maintenance the maintenance team is left with an aggregation of procedures and variables, both of which may be generically called user-defined tokens. This paper proposes a graph-based approach to address the problem of SoC during program maintenance. This is done by the removal of some source code elements (e.g., user-defined-tokens), which can be responsible for tangled concerns and complex code. These user-definedtokens can be treated separately under the Aspect Oriented Programming paradigm. The paper proposes a graphical-model, which represents a procedural program and defines a mathematical- model to identify and remove the tangled and interleaving code-fragments. Thereafter these code fragments are traced back to the requirements engineering level through a formal traceability model. This process yields the corresponding user requirements that are associated with these scattered code fragments. These identified user requirements are put forward as Aspects, to be handled or re-engineered under the Aspect Oriented Programming paradigm.