Showing papers in "Software and Systems Modeling in 2014"

Multi-perspective enterprise modeling: foundational concepts, prospects and future research challenges

Abstract: The paper presents a method for multi- perspective enterprise modeling (MEMO) and a corresponding (meta-) modeling environment. An extensive analysis of requirements for enterprise modeling serves to motivate and assess the method. The method is based on an elaborate conception of multi-perspective enterprise models and on an extensible language architecture. The language architecture is comprised of a meta modeling language and an extensible set of integrated domain-specific modeling languages (DSML). The DSML are supplemented with process models and with guidelines for their reflective use. The corresponding modeling environment integrates editors for various DSML into multi-language model editors. It includes a meta model editor which enables the convenient use, development and extension of the set of supported DSML and supports the generation of respective graphical model editors. Thus, it also serves as a foundation for method engineering. MEMO covers both software engineering as well as social, managerial and economic aspects of the firm. The presentation of MEMO is supplemented with a comparative overview of other approaches to enterprise modeling. The paper concludes bys summarizing fundamental technical, epistemological and political challenges for enterprise modeling research and discusses potential paths for future research.

Strategic business modeling: representation and reasoning

Abstract: Business intelligence (BI) offers tremendous potential for business organizations to gain insights into their day-to-day operations, as well as longer term opportunities and threats. However, most of today's BI tools are based on models that are too much data-oriented from the point of view of business decision makers. We propose an enterprise modeling approach to bridge the business-level understanding of the enterprise with its representations in databases and data warehouses. The business intelligence model (BIM) offers concepts familiar to business decision making--such as goals, strategies, processes, situations, influences, and indicators. Unlike many enterprise models which are meant to be used to derive, manage, or align with IT system implementations, BIM aims to help business users organize and make sense of the vast amounts of data about the enterprise and its external environment. In this paper, we present core BIM concepts, focusing especially on reasoning about situations, influences, and indicators. Such reasoning supports strategic analysis of business objectives in light of current enterprise data, allowing analysts to explore scenarios and find alternative strategies. We describe how goal reasoning techniques from conceptual modeling and requirements engineering have been applied to BIM. Techniques are also provided to support reasoning with indicators linked to business metrics, including cases where specifications of indicators are incomplete. Evaluation of the proposed modeling and reasoning framework includes an on-going prototype implementation, as well as case studies.

From enterprise architecture to business models and back

Abstract: In this study, we argue that important IT change processes affecting an organization's enterprise architecture are also mirrored by a change in the organization's business model. An analysis of the business model may establish whether the architecture change has value for the business. Therefore, in order to facilitate such analyses, we propose an approach to relate enterprise models specified in ArchiMate to business models, modeled using Osterwalder's Business Model Canvas. Our approach is accompanied by a method that supports business model-driven migration from a baseline architecture to a target architecture and is demonstrated by means of a case study.

An approach for modeling and detecting software performance antipatterns based on first-order logics

Abstract: The problem of interpreting the results of performance analysis is quite critical in the software performance domain. Mean values, variances and probability distributions are hard to interpret for providing feedback to software architects. Instead, what architects expect are solutions to performance problems, possibly in the form of architectural alternatives (e.g. split a software component in two components and re-deploy one of them). In a software performance engineering process, the path from analysis results to software design or implementation alternatives is still based on the skills and experience of analysts. In this paper, we propose an approach for the generation of feedback based on performance antipatterns. In particular, we focus on the representation and detection of antipatterns. To this goal, we model performance antipatterns as logical predicates and we build an engine, based on such predicates, aimed at detecting performance antipatterns in an XML representation of the software system. Finally, we show the approach at work on a case study.

Automatic data collection for enterprise architecture models

Abstract: Enterprise Architecture (EA) is an approach used to provide decision support based on organization-wide models. The creation of such models is, however, cumbersome as multiple aspects of an organization need to be considered, making manual efforts time-consuming, and error prone. Thus, the EA approach would be significantly more promising if the data used when creating the models could be collected automatically--a topic not yet properly addressed by either academia or industry. This paper proposes network scanning for automatic data collection and uses an existing software tool for generating EA models (ArchiMate is employed as an example) based on the IT infrastructure of enterprises. While some manual effort is required to make the models fully useful to many practical scenarios (e.g., to detail the actual services provided by IT components), empirical results show that the methodology is accurate and (in its default state) require little effort to carry out.

A fundamental approach to model versioning based on graph modifications: from theory to implementation

Abstract: In model-driven engineering, models are primary artifacts that can evolve heavily during their life cycle. Therefore, versioning of models is a key technique to be offered by integrated development environments for model-driven engineering. In contrast to text-based versioning systems, we present an approach that takes model structures and their changes over time into account. Considering model structures as graphs, we define a fundamental approach where model revisions are considered as graph modifications consisting of delete and insert actions. Two different kinds of conflict detection are presented: (1) the check for operation-based conflicts between different graph modifications, and (2) the check for state-based conflicts on merged graph modifications. For the merging of graph modifications, a two-phase approach is proposed: First, operational conflicts are temporarily resolved by always giving insertion priority over deletion to keep as much information as possible. Thereafter, this tentative merge result is the basis for manual conflict resolution as well as for the application of repair actions that resolve state-based conflicts. If preferred by the user, giving deletion priority over insertion might be one solution. The fundamental concepts are illustrated by versioning scenarios for simplified statecharts. Furthermore, we show an implementation of this fundamental approach to model versioning based on the Eclipse Modeling Framework as technical space.

Bridging value modelling to ArchiMate via transaction modelling

Abstract: The ArchiMate modelling language provides a coherent and a holistic view of an enterprise in terms of its products, services, business processes, actors, business units, software applications and more Yet, ArchiMate currently lacks (1) expressivity in modelling an enterprise from a value exchange perspective, and (2) rigour and guidelines in modelling business processes that realize the transactions relevant from a value perspective To address these issues, we show how to connect e $$^{3}$$ value, a technique for value modelling, to ArchiMate via transaction patterns from the DEMO methodology Using ontology alignment techniques, we show a transformation between the meta models underlying e $$^{3}$$ value, DEMO and ArchiMate Furthermore, we present a step-wise approach that shows how this model transformation is achieved and, in doing so, we also show the of such a transformation We exemplify the transformation of DEMO and e $$^{3}$$ value into ArchiMate by means of a case study in the insurance industry As a proof of concept, we present a software tool supporting our transformation approach Finally, we discuss the functionalities and limitations of our approach; thereby, we analyze its and practical applicability

Graph and model transformation tools for model migration

Abstract: We describe the results of the Transformation Tool Contest 2010 workshop, in which nine graph and model transformation tools were compared for specifying model migration The model migration problem--migration of UML activity diagrams from version 14 to version 22--is non-trivial and practically relevant The solutions have been compared with respect to several criteria: correctness, conciseness, understandability, appropriateness, maturity and support for extensions to the core migration task We describe in detail the comparison method, and discuss the strengths and weaknesses of the solutions with a special focus on the differences between graph and model transformation for model migration The comparison results demonstrate tool and language features that strongly impact the efficacy of solutions, such as support for retyping of model elements The results are used to motivate an agenda for future model migration research (including suggestions for areas in which the tools need to be further improved)

Extraction and evolution of architectural variability models in plugin-based systems

Abstract: Variability management is a key issue when building and evolving software-intensive systems, making it possible to extend, configure, customize and adapt such systems to customers' needs and specific deployment contexts. A wide form of variability can be found in extensible software systems, typically built on top of plugin-based architectures that offer a (large) number of configuration options through plugins. In an ideal world, a software architect should be able to generate a system variant on-demand, corresponding to a particular assembly of plugins. To this end, the variation points and constraints between architectural elements should be properly modeled and maintained over time (i.e., for each version of an architecture). A crucial, yet error-prone and time-consuming, task for a software architect is to build an accurate representation of the variability of an architecture, in order to prevent unsafe architectural variants and reach the highest possible level of flexibility. In this article, we propose a reverse engineering process for producing a variability model (i.e., a feature model) of a plugin-based architecture. We develop automated techniques to extract and combine different variability descriptions, including a hierarchical software architecture model, a plugin dependency model and the software architect knowledge. By computing and reasoning about differences between versions of architectural feature models, software architect can control both the variability extraction and evolution processes. The proposed approach has been applied to a representative, large-scale plugin-based system (FraSCAti), considering different versions of its architecture. We report on our experience in this context.

An ontology-based framework for domain-specific modeling

Abstract: Domain-specific languages (DSLs) provide abstractions and notations for better understanding and easier modeling of applications in a special domain. Current shortcomings of DSLs include learning curve and formal semantics. This paper reports on a framework that allows the use of ontology technologies to describe and reason on DSLs. The formal semantics of OWL together with reasoning services allows for addressing constraint definition, progressive evaluation, suggestions, and debugging. The approach integrates existing metamodels and concrete syntaxes in a new technical space. A scenario in which domain models for network devices are created illustrates the framework.

Evolution styles: foundations and models for software architecture evolution

Abstract: As new market opportunities, technologies, platforms, and frameworks become available, systems require large-scale and systematic architectural restructuring to accommodate them. Today's architects have few techniques to help them plan this architecture evolution. In particular, they have little assistance in planning alternative evolution paths, trading off various aspects of the different paths, or knowing best practices for particular domains. In this paper, we describe an approach for planning and reasoning about architecture evolution. Our approach focuses on providing architects with the means to model prospective evolution paths and supporting analysis to select among these candidate paths. To demonstrate the usefulness of our approach, we show how it can be applied to an actual architecture evolution. In addition, we present some theoretical results about our evolution path constraint specification language.

Transformation challenges: from software models to performance models

Abstract: A software model can be analysed for non-functional requirements by extending it with suitable annotations and transforming it into analysis models for the corresponding non-functional properties. For quantitative performance evaluation, suitable annotations are standardized in the "UML Profile for Modeling and Analysis of Real-Time Embedded systems" (MARTE) and its predecessor, the "UML Profile for Schedulability, Performance and Time". A range of different performance model types (such as queueing networks, Petri nets, stochastic process algebra) may be used for analysis. In this work, an intermediate "Core Scenario Model" (CSM) is used in the transformation from the source software model to the target performance model. CSM focuses on how the system behaviour uses the system resources. The semantic gap between the software model and the performance model must be bridged by (1) information supplied in the performance annotations, (2) in interpretation of the global behaviour expressed in the CSM and (3) in the process of constructing the performance model. Flexibility is required for specifying sets of alternative cases, for choosing where this bridging information is supplied, and for overriding values. It is also essential to be able to trace the source of values used in a particular performance estimate. The performance model in turn can be used to verify responsiveness and scalability of a software system, to discover architectural limitations at an early stage of development, and to develop efficient performance tests. This paper describes how the semantic gap between software models in UML+MARTE and performance models (based on queueing or Petri nets) can be bridged using transformations based on CSMs, and how the transformation challenges are addressed.

Modeling and enforcing secure object flows in process-driven SOAs: an integrated model-driven approach

Abstract: In this paper, we present an integrated model-driven approach for the specification and the enforcement of secure object flows in process-driven service-oriented architectures (SOA). In this context, a secure object flow ensures the confidentiality and the integrity of important objects (such as business contracts or electronic patient records) that are passed between different participants in SOA-based business processes. We specify a formal and generic metamodel for secure object flows that can be used to extend arbitrary process modeling languages. To demonstrate our approach, we present a UML extension for secure object flows. Moreover, we describe how platform-independent models are mapped to platform-specific software artifacts via automated model transformations. In addition, we give a detailed description of how we integrated our approach with the Eclipse modeling tools.

An enterprise architecture framework for multi-attribute information systems analysis

Abstract: Enterprise architecture is a model-based IT and business management discipline. Enterprise architecture analysis concerns using enterprise architecture models for analysis of selected properties to provide decision support. This paper presents a framework based on the ArchiMate metamodel for the assessment of four properties, viz., application usage, system availability, service response time and data accuracy. The framework integrates four existing metamodels into one and implements these in a tool for enterprise architecture analysis. The paper presents the overall metamodel and four viewpoints, one for each property. The underlying theory and formalization of the four viewpoints is presented. In addition to the tool implementation, a running example as well as guidelines for usage makes the viewpoints easily applicable.

Bridging the gap between formal semantics and implementation of triple graph grammars

Abstract: The correctness of model transformations is a crucial element for model-driven engineering of high-quality software. A prerequisite to verify model transformations at the level of the model transformation specification is that an unambiguous formal semantics exists and that the implementation of the model transformation language adheres to this semantics. However, for existing relational model transformation approaches, it is usually not really clear under which constraints particular implementations really conform to the formal semantics. In this paper, we will bridge this gap for the formal semantics of triple graph grammars (TGG) and an existing efficient implementation. While the formal semantics assumes backtracking and ignores non-determinism, practical implementations do not support backtracking, require rule sets that ensure determinism, and include further optimizations. Therefore, we capture how the considered TGG implementation realizes the transformation by means of operational rules, define required criteria, and show conformance to the formal semantics if these criteria are fulfilled. We further outline how static and runtime checks can be employed to guarantee these criteria.

Merging of EMF models

Abstract: Inadequate version control for models significantly impedes the application of model-driven software development. In particular, sophisticated support for merging model versions is urgently needed. In this paper, we present a formal approach to both two- and three-way merging of models in the EMF framework. The approach may be applied to instances of arbitrary Ecore models. We specify context-free as well as context-sensitive rules for model merging which both detect and resolve merge conflicts. Based on these rules, a merge algorithm is developed which produces a consistent model from consistent input models. The merge algorithm does neither assume unique object identifiers, nor does it require change logs. In contrast, it relies on matchings among the input models which identify common elements (state-based approach). The requirements imposed on these matchings are reduced to a minimum, e.g., there are no restrictions on the relative positions of matched elements. Altogether, the merge algorithm is widely applicable, preserves consistency, and offers advanced features, such as merging of ordered collections in the presence of arbitrary moves and handling of context-sensitive conflicts which are hard to detect and to resolve.

Assessing event correlation in non-process-aware information systems

Abstract: Many present-day companies carry out a huge amount of daily operations through the use of their information systems without ever having done their own enterprise modeling. Business process mining is a well-proven solution which is used to discover the underlying business process models that are supported by existing information systems. Business process discovery techniques employ event logs as input, which are recorded by process-aware information systems. However, a wide variety of traditional information systems do not have any in-built mechanisms with which to collect events (representing the execution of business activities). Various mechanisms with which to collect events from non-process-aware information systems have been proposed in order to enable the application of process mining techniques to traditional information systems. Unfortunately, since business processes supported by traditional information systems are implicitly defined, correlating events into the appropriate process instance is not trivial. This challenge is known as the event correlation problem. This paper presents an adaptation of an existing event correlation algorithm and incorporates it into a technique in order to collect event logs from the execution of traditional information systems. The technique first instruments the source code to collect events together with some candidate correlation attributes. Based on several well-known design patterns, the technique provides a set of guidelines to support experts when instrumenting the source code. The event correlation algorithm is subsequently applied to the data set of events to discover the best correlation conditions, which are then used to create event logs. The technique has been semi-automated to facilitate its validation through an industrial case study involving a writer management system and a healthcare evaluation system. The study demonstrates that the technique is able to discover an appropriate correlation set and obtain well-formed event logs, thus enabling business process mining techniques to be applied to traditional information systems.

An architecture framework for enterprise IT service availability analysis

Abstract: This paper presents an integrated enterprise architecture framework for qualitative and quantitative modeling and assessment of enterprise IT service availability. While most previous work has either focused on formal availability methods such as fault trees or qualitative methods such as maturity models, this framework offers a combination. First, a modeling and assessment framework is described. In addition to metamodel classes, relationships and attributes suitable for availability modeling, the framework also features a formal computational model written in a probabilistic version of the object constraint language. The model is based on 14 systemic factors impacting service availability and also accounts for the structural features of the service architecture. Second, the framework is empirically tested in nine enterprise information system case studies. Based on an initial availability baseline and the annual evolution of the 14 factors of the model, annual availability predictions are made and compared with the actual outcomes as reported in SLA reports and system logs. The practical usefulness of the method is discussed based on the outcomes of a workshop conducted with the participating enterprises, and some directions for future research are offered.

On the modeling and generation of service-oriented tool chains

Abstract: Tool chains have grown from ad-hoc solutions to complex software systems, which often have a service-oriented architecture. With service-oriented tool integration, development tools are made available as services, which can be orchestrated to form tool chains. Due to the increasing sophistication and size of tool chains, there is a need for a systematic development approach for service-oriented tool chains. We propose a domain-specific modeling language (DSML) that allows us to describe the tool chain on an appropriate level of abstraction. We present how this language supports three activities when developing service-oriented tool chains: communication, design and realization. A generative approach supports the realization of the tool chain using the service component architecture. We present experiences from an industrial case study, which applies the DSML to support the creation of a service-oriented tool chain. We evaluate the approach both qualitatively and quantitatively by comparing it with a traditional development approach.

Adapting transformations to metamodel changes via external transformation composition

Abstract: Evolution is inherent to software systemsbecause of the rapid improvement of technologies and business logic. As a software development paradigm, model driven engineering (MDE) is also affected by this problem. More concretely, being metamodels the cornerstone of MDE, their evolution impacts the rest of software artefacts involved in a development process, i.e., models and transformations. The influence over models has been tackled and partially solved in previous works. This paper focuses on the impact over transformations. We propose an approach to adapt transformations by means of external transformation composition. That is, we chain impacted transformations to particular adaptation transformations which deal with either refactoring/destruction changes or construction changes. Our approach semi-automatically generates such transformations by using the AtlanMod matching language, a DSL to define model matching strategies. To provide with a proof of concept for our proposal, we adapt transformations written in terms of object-relational database metamodels when such metamodels evolve in time.

A model-driven method for enacting the design-time QoS analysis of business processes

Abstract: Business Process Management (BPM) is a holistic approach for describing, analyzing, executing, managing, and improving large enterprise business processes. A business process can be seen as a flow of tasks that are orchestrated to accomplish well-defined goals such as goods production or services delivery. From an IT perspective, BPM is closely related to a business process automation approach carried out by use of IT standards and technologies, such as service-oriented architectures (SOAs) and Web Services. This paper specifically focuses on fully automated business processes that are defined and executed as orchestrations of software services. In a BPM context, the ability to predict at design time the business process behavior assumes a strategic relevance, both to early assess whether or not the business goals are achieved and to gain a competitive advantage. A business process is typically specified by use of Business Process Modeling Notation (BPMN), the standard language for the high-level description of business processes. Unfortunately, BPMN does not support the characterization of the business process in terms of nonfunctional or QoS properties, such as performance and reliability. To overcome such a limitation, this paper introduces Performability-enabled BPMN (PyBPMN), a lightweight BPMN extension for the specification of performance and reliability properties. PyBPMN enables the design time prediction of the business processes behavior, in terms of performance and reliability properties. Such prediction activity requires the use of models that are to be first built and then evaluated. In this respect, this work introduces a model-driven method that exploits PyBPMN to predict, at design time, the performance and the reliability of a business process, either to select the process configuration that provides the best behavior or to check if a given configuration satisfies the overall requirements. The proposed model-driven method that enacts the automated analysis of a business process behavior embraces the complete business process development cycle, from the specification phase down to the implementation phase. The paper also describes how the proposed model-driven method is implemented. The several model transformations at the core of the method have been implemented by use of QVT, and the standard language for specifying model transformations provided by OMG's MDA. The availability of such automated model transformations allows business analysts to predict the process behavior with no extra effort and without being required to own specific skills of performance or reliability theory, as shown by use of an example application.

Extracting models from source code in software modernization

Abstract: Model-driven software modernization is a discipline in which model-driven development (MDD) techniques are used in the modernization of legacy systems When existing software artifacts are evolved, they must be transformed into models to apply MDD techniques such as model transformations Since most modernization scenarios (eg, application migration) involve dealing with code in general-purpose programming languages (GPL), the extraction of models from GPL code is an essential task in a model-based modernization process This activity could be performed by tools to bridge grammarware and MDD technical spaces, which is normally carried out by dedicated parsers Grammar-to-Model Transformation Language (Gra2MoL) is a domain-specific language (DSL) tailored to the extraction of models from GPL code This DSL is actually a text-to-model transformation language which can be applied to any code conforming to a grammar Gra2MoL aims to reduce the effort needed to implement grammarware-MDD bridges, since building dedicated parsers is a complex and time-consuming task Like ATL and RubyTL languages, Gra2MoL incorporates the binding concept needed to write mappings between grammar elements and metamodel elements in a simple declarative style The language also provides a powerful query language which eases the retrieval of scattered information in syntax trees Moreover, it incorporates extensibility and grammar reuse mechanisms This paper describes Gra2MoL in detail and includes a case study based on the application of the language in the extraction of models from Delphi code

Does aspect-oriented modeling help improve the readability of UML state machines?

Abstract: Aspect-oriented modeling (AOM) is a relatively recent and very active field of research, whose application has, however, been limited in practice. AOM is assumed to yield several potential benefits such as enhanced modularization, easier evolution, increased reusability, and improved readability of models, as well as reduced modeling effort. However, credible, solid empirical evidence of such benefits is lacking. We evaluate the "readability" of state machines when modeling crosscutting behavior using AOM and more specifically AspectSM, a recently published UML profile. This profile extends the UML state machine notation with mechanisms to define aspects using state machines. Readability is indirectly measured through defect identification and fixing rates in state machines, and the scores obtained when answering a comprehension questionnaire about the system behavior. With AspectSM, crosscutting behavior is modeled using so-called "aspect state machines". Their readability is compared with that of system state machines directly modeling crosscutting and standard behavior together. An initial controlled experiment and a much larger replication were conducted with trained graduate students, in two different institutions and countries, to achieve the above objective. We use two baselines of comparisons--standard UML state machines without hierarchical features (flat state machines) and standard state machines with hierarchical/concurrent features (hierarchical state machines). The results showed that defect identification and fixing rates are significantly better with AspectSM than with both flat and hierarchical state machines. However, in terms of comprehension scores and inspection effort, no significant difference was observed between any of the approaches. Results of the experiments suggest that one should use, when possible, aspect state machines along with hierarchical and/or concurrent features of UML state machines to model crosscutting behaviors.

A reference requirements set for public service provision enterprise architectures

Abstract: Electronic Government (eGov) is a political priority worldwide. One of the core objectives of eGov is the online public services provision (PSP). However, many of eGov PSP systems fail in realizing their objectives. Enterprise Architectures (EA) could contribute to overcome some of the relevant obstacles. The objective of this paper is to derive a reference requirements set for eGov PSP that can be used in EA development. Aiming at capitalizing on existing knowledge, we conduct a systematic literature review on eGov PSP systems requirements. This results in identifying a unified requirements set, i.e. 186 requirements, and stakeholders set, i.e. 19 stakeholders, for eGov PSP systems. Based on these findings, we determine 16 overview use cases demonstrating the basic functionality of such systems. Our findings are modeled using ArchiMate 2.0 notation. The identified requirements set can be used by virtually any public organization providing public services for developing its own EA. As a result, it can lead to the reduction of eGov PSP project failures, the decrease of software development costs and the improvement of its effectiveness and quality. Furthermore, it can be used as a basis to develop a complete reference EA for the eGov PSP domain.

A case study on consistency management of business and IT process models in banking

Abstract: Organizations that adopt process modeling often maintain several co-existing models of the same business process. These models target different abstraction levels and stakeholder perspectives. Maintaining consistency among these models has become a major challenge for such organizations. Although several academic works have discussed this challenge, little empirical investigation exists on how people perform process model consistency management in practice. This paper aims to address this lack by presenting an in-depth empirical study of a business-driven engineering process deployed at a large company in the banking sector. We analyzed more than 70 business process models developed by the company, including their change history, with over 1,000 change requests. We also interviewed 9 business and IT practitioners and surveyed 23 such practitioners to understand concrete difficulties in consistency management, the rationales for the specification-to-implementation refinements found in the models, strategies that the practitioners use to detect and fix inconsistencies, and how tools could help with these tasks. Our contribution is a set of eight empirical findings, some of which confirm or contradict previous works on process model consistency management found in the literature. The findings provide empirical evidence of (1) how business process models are created and maintained, including a set of recurrent patterns used to refine business-level process specifications into IT-level models; (2) what types of inconsistencies occur; how they are introduced; and what problems they cause; and (3) what stakeholders expect from tools to support consistency management.

No shit or Oh, shit!: responses to observations on the use of UML in professional practice

Abstract: This paper follows a paper, "UML in Practice" presented at ICSE 2013. It summarizes and reflects on the discussion and additional investigation that arose from "UML in Practice." The paper provides a condensed recap of "UML in Practice" findings, explains what data were collected from which sources to inform this paper, and describes how the data were analyzed. It reports on the discussion that has arisen, summarizing responses from industry practitioners, academics teaching software engineering, and the UML community, and considers how those responses reflect on the original observations. The responses to "UML in Practice" divide (crudely) between two perspectives: (1) the observations made are familiar and unsurprizing, and match personal experience ("No shit"); or (2) the observations threaten long-held beliefs about UML use, and in particular about the status of UML as the de facto standard of software engineering, implying a need to change personal practice ("Oh, shit!").

Heuristics for composite Web service decentralization

Abstract: A composite service is usually specified by means of a process model that captures control-flow and data-flow relations between activities that are bound to underlying component services. In mainstream service orchestration platforms, this process model is executed by a centralized orchestrator through which all interactions are channeled. This architecture is not optimal in terms of communication overhead and has the usual problems of a single point of failure. In previous work, we proposed a method for executing composite services in a decentralized manner. However, this and similar methods for decentralized composite service execution do not optimize the communication overhead between the services participating in the composition. This paper studies the problem of optimizing the selection of services assigned to activities in a decentralized composite service, both in terms of communication overhead and overall quality of service, and taking into account collocation and separation constraints that may exist between activities in the composite service. This optimization problem is formulated as a quadratic assignment problem. The paper puts forward a greedy algorithm to compute an initial solution as well as a tabu search heuristic to identify improved solutions. An experimental evaluation shows that the tabu search heuristic achieves significant improvements over the initial greedy solution. It is also shown that the greedy algorithm combined with the tabu search heuristic scale up to models of realistic size.

Mapping feature models onto domain models: ensuring consistency of configured domain models

Abstract: We present an approach to model-driven software product line engineering which is based on feature models and domain models. A feature model describes both common and varying properties of the instances of a software product line. The domain model is composed of a structural model (package and class diagrams) and a behavioral model (story diagrams). Features are mapped onto the domain model by annotating elements of the domain model with features. An element of a domain model is specific to the features included in its feature annotation. An instance of the product line is defined by a set of selected features (a feature configuration). A configuration of the domain model is built by excluding all elements whose feature set is not included in the feature configuration. To ensure consistency of the configured domain model, we define constraints on the annotations of inter-dependent domain model elements. These constraints guarantee that a model element may be selected only when the model elements are also included on which it depends. Violations of dependency constraints may be removed automatically with the help of an error repair tool which propagates features to dependent model elements.

Evaluating probabilistic models with uncertain model parameters

Abstract: Probabilistic models are commonly used to evaluate quality attributes, such as reliability, availability, safety and performance of software-intensive systems. The accuracy of the evaluation results depends on a number of system properties which have to be estimated, such as environmental factors or system usage. Researchers have tackled this problem by including uncertainties in the probabilistic models and solving them analytically or with simulations. The input parameters are commonly assumed to be normally distributed. Accordingly, reporting the mean and variances of the resulting attributes is usually considered sufficient. However, many of the uncertain factors do not follow normal distributions, and analytical methods to derive objective uncertainties become impractical with increasing complexity of the probabilistic models. In this work, we introduce a simulation-based approach which uses Discrete Time Markov Chains and probabilistic model checking to accommodate a diverse set of parameter range distributions. The number of simulation runs automatically regulates to the desired significance level and reports the desired percentiles of the values which ultimately characterises a specific quality attribute of the system. We include a case study which illustrates the flexibility of this approach using the evaluation of several probabilistic properties.

Enhancing the OPEN Process Framework with service-oriented method fragments

Abstract: Service orientation is a promising paradigm that enables the engineering of large-scale distributed software systems using rigorous software development processes. The existing problem is that every service-oriented software development project often requires a customized development process that provides specific service-oriented software engineering tasks in support of requirements unique to that project. To resolve this problem and allow situational method engineering, we have defined a set of method fragments in support of the engineering of the project-specific service-oriented software development processes. We have derived the proposed method fragments from the recurring features of 11 prominent service-oriented software development methodologies using a systematic mining approach. We have added these new fragments to the repository of OPEN Process Framework to make them available to software engineers as reusable fragments using this well-known method repository.