In the realm of industrial software development, DevOps has emerged as the preferred approach for handling the highly iterative software production process. DevOps refers to the tight integration of development and operations activities, with Continuous Integration, Continuous Delivery, and Continuous Deployment (CI/CD) being pivotal methodologies for ensuring the iterative delivery of high-quality software. To achieve CI/CD, pipelines of activities are deployed using commercial tools. Due to the dynamic nature of these tools, CI/CD pipelines are often migrated to new versions or even new tools. Since this is mostly a manual process, it is a cumbersome and error-prone activity. To assist software engineers during this process, we propose a novel approach that leverages model-driven engineering (MDE) to support the migration of CI/CD pipelines. Our approach is inspired by the traditional reengineering horseshoe model, which abstracts existing pipeline artifacts into a comprehensive model as an intermediate representation. From these models, we can then generate semantic-equivalent pipelines for any novel CI/CD tool. Thus, our main contribution comprises a metamodel designed to represent the structure of existing CI/CD pipelines and build the foundation for MDE-based migration of CI/CD pipelines. We validated our metamodel by successfully modeling 400 existing pipelines. This evaluation demonstrated a 100% applicability rate when applied to configuration files from technologies that collectively account for over 92% of CI/CD scripts in use. Furthermore, we conducted a detailed case study demonstrating the practical applicability of our approach in real-world migration scenarios. Finally, we demonstrate that our metamodel promotes equivalence between an original pipeline and a new one generated from it in a different technology by showing through test cases that the execution traces of both pipelines are identical.

In the realm of conceptual and system design, mod-eling stands out as a pivotal activity, emphasizing the significance of mastering modeling languages such as the Unified Modeling Language (UML). Despite the existence of numerous interactive UML learning applications and the emergence of gamification-based alternatives designed to enhance learner engagement, a gap persists in providing an immersive learning environment ca-pable of significantly increasing interactivity during the learning process. Current approaches fall short in creating a sense of presence that could positively impact learning outcomes, and the full potential of gamification remains underexplored. To address this gap, this paper introduces an innovative so-lution-a gamification-based UML learning environment within Virtual Reality (VR), named GaMo Vr.This immersive platform is specifically tailored for practicing the creation of class diagrams in an interactive manner, incorporating mini games to support the learning process. The study conducted to evaluate GaMo Vrinvolved 16 participants and utilized the MEEGA360 question-naire. In comparison to a similar desktop application, the results of the evaluation revealed that GaMo Vrsignificantly enhanced learners' motivation, enjoyment, and engagement, along with a perceivable improvement in the overall learning outcome. This groundbreaking approach not only bridges the existing gap in UML learning applications but also harnesses the potential of VR and gamification to revolutionize the way modeling is taught and learned.

Abstract The development of new business models is essential for startups to become successful, as well as for established companies to explore new business opportunities. However, developing such business models is a continuous challenging activity where different tasks need to be performed, and business decisions need to be made. Both have to fit the constantly changeable situation in which the business model is developed to reduce the risk of developing ineffective business models with low market penetration. Therefore, a method for developing situation-specific business models is needed. As a solution, we refine the concept of situational method engineering (SME) to business model development. SME, in turn, provides means to construct situation-specific development methods out of fragments from a method repository. We develop a concept for the continuous situation-specific development of business models based on design science. The approach uses the roles of a domain expert, a method engineer, and a business developer together with a repository with method fragments for developing business models and a repository with modeling artifacts for supporting the development. Both repositories are filled by utilizing the experience of domain experts. Out of these repositories, situation-specific development methods for developing business models can be continuously composed based on the changeable situation by the method engineer and enacted by the business developer. We implement it as an open-source tool and evaluate its applicability in an industrial case study of developing a business model for a local event platform. Our results show that situation awareness supports the continuous development of business models.

Modeling is a key activity in conceptual design and system design. Through collaborative modeling, end-users, stakeholders, experts, and entrepreneurs are able to create a shared understanding of a system representation. While the Unified Modeling Language (UML) is one of the major conceptual modeling languages in object-oriented software engineering, more and more concerns arise from the modeling quality of UML and its tool-support. Among them, the limitation of the two-dimensional presentation of its notations and lack of natural collaborative modeling tools are reported to be significant. In this paper, we explore the potential of using virtual reality (VR) technology for collaborative UML software design by comparing it with classical collaborative software design using conventional devices (desktop PC/laptop). For this purpose, we have developed a VR modeling environment that offers a natural collaborative modeling experience for UML Class Diagrams. Based on a user study with 24 participants, we have compared collaborative VR modeling with conventional modeling with regard to efficiency, effectiveness, and user satisfaction. Results show that the use of VR has some disadvantages concerning efficiency and effectiveness, but the user's fun, the feeling of being in the same room with a remote collaborator, and the naturalness of collaboration were increased.

To succeed with the development of modern software, organizations must have the agility to adapt faster to constantly evolving environments to deliver more reliable and optimized solutions that can be adapted to the needs and environments of their stakeholders including users, customers, business, development, and IT. However, stakeholders do not have sufficient automated support for global decision making, considering the increasing variability of the solution space, the frequent lack of explicit representation of its associated variability and decision points, and the uncertainty of the impact of decisions on stakeholders and the solution space. This leads to an ad-hoc decision making process that is slow, error-prone, and often favors local knowledge over global, organization-wide objectives. The Multi-Plane Models and Data (MP-MODA) framework explicitly represents and manages variability, impacts, and decision points. It enables automation and tool support in aid of a multi-criteria decision making process involving different stakeholders within a feedback-driven software development process where feedback cycles aim to reduce uncertainty. We present the conceptual structure of the framework, discuss its potential benefits, and enumerate key challenges related to tool supported automation and analysis within MP-MODA.

Concurrent model synchronisation, i.e. the (bidirectional) propagation of updates between two models, is an important problem in the area of model-driven engineering (MDE). Compared to other consistency management tasks, synchronising concurrent updates is especially challenging as they can be conflicting, such that restoring a consistent state is not possible when all updates must be considered. Recent approaches create a search space of possible solutions and determine the optimum solution via exact methods, such as integer linear programming (ILP), via a configurable, scalarised objective function that takes conflicting goals into account. However, the determination of suitable configuration parameters and runtime efficiency improvements are still an open issue, which is commonly addressed by using heuristics instead of exact methods. We investigate on whether it is beneficial to apply heuristics to solve concurrent model synchronisation problems. First, a multiobjective evolutionary algorithm is used for small instances for which all pareto-optimal solutions can be presented to a user to select the best one. Second, for larger models, we propose a method to determine suitable weightings for aggregating all objectives into a single function. Finally, these insights are used to recommend a strategy for determining solutions of satisfying quality within an acceptable amount of time.

Modeling is a key activity in conceptual design and system design. Through collaborative modeling, end-users, stakeholders, experts, and entrepreneurs are able to create a shared understanding of a system representation. While the Unified Modeling Language (UML) is one of the major conceptual modeling languages in object-oriented software engineering, more and more concerns arise from the modeling quality of UML and its tool-support. Among them, the limitation of the two-dimensional presentation of its notations and lack of natural collaborative modeling tools are reported to be significant. In this paper, we explore the potential of using Virtual Reality (VR) technology for collaborative UML software design by comparing it with classical collaborative software design using conventional devices (Desktop PC / Laptop). For this purpose, we have developed a VR modeling environment that offers a natural collaborative modeling experience for UML Class Diagrams. Based on a user study with 24 participants, we have compared collaborative VR modeling with conventional modeling with regard to efficiency, effectiveness, and user satisfaction. Results show that the use of VR has some disadvantages concerning efficiency and effectiveness, but the user's fun, the feeling of being in the same room with a remote collaborator, and the naturalness of collaboration were increased.

Recent advances in Virtual Reality (VR) technology and the increased availability of VR-equipped devices enable a wide range of consumer-oriented applications. For novice developers, however, creating interactive scenes for VR applications is a complex and cumbersome task that requires high technical knowledge which is often missing. This hinders the potential of enabling novices to create, modify, and execute their own interactive VR scenes. Although recent authoring tools for interactive VR scenes are promising, most of them focus on expert professionals as the target group and neglect the novices with low programming knowledge. To lower the entry barrier, we provide an open-source web-based End-User Development (EUD) tool, called VREUD, that supports the rapid construction and execution of interactive VR scenes. Concerning construction, VREUD enables the specification of the VR scene including interactions and tasks. Furthermore, VREUD supports the execution and immersive experience of the created interactive VR scenes on VR head-mounted displays. Based on a user study, we have analyzed the effectiveness, efficiency, and user satisfaction of VREUD which shows promising results to empower novices in creating their interactive VR scenes.

In recent years, Additive Manufacturing (AM) has evolved from a niche technology for prototyping to a well-known industrial production process. In this work, we focus on Selective Laser Sintering (SLS)-one of the leading AM techniques. While SLS has many advantages, the simultaneous manufacturing of multiple components requires the subsequent recognition of components which must be done manually in today's production processes. While approaches for automatic, sensor-based object recognition have been proposed, e.g., based on Convolutional Neural Networks (CNNs), they assume the availability of real-world photos which is not given in the setting of Additive Manufacturing. Hence, we develop an approach to render realistic virtual images and demonstrate their suitability to recognize real-world objects. Although often done in the machine learning community, orienting the objects randomly generates many orientations that are physically impossible and cause distracting noise in the training process. Hence, we pay particular attention to generate physically sound training data and we demonstrate that our approach significantly improves the recognition rate compared to traditional approaches.

Crowdsourcing is used in academia and industry to solve tasks that are easy for humans but hard for computers, in natural language processing mostly to annotate data. The quality of annotations is affected by problems in the task design, task operation, and task evaluation that workers face with requesters in crowdsourcing processes. To learn about the major problems, we provide a short but comprehensive survey based on two complementary studies: (1) a literature review where we collect and organize problems known from interviews with workers, and (2) an empirical data analysis where we use topic modeling to mine workers' complaints from a new English corpus of workers' forum discussions. While literature covers all process phases, problems in the task evaluation are prevalent, including unfair rejections, late payments, and unjustified blockings of workers. According to the data, however, poor task design in terms of malfunctioning environments, bad workload estimation, and privacy violations seems to bother the workers most. Our findings form the basis for future research on how to improve crowdsourcing processes.

Virtual reality (VR) has evolved into a trending technology that has proven its worth in various application domains. VR is especially helpful for the training of complex tasks in special environments. In the area of logistics, warehouse management involves a complex workflow that consists of different order picking activities. Due to this complex workflow, stock discrepancies and misplaced wares are typical problems that often occur. To overcome this problem, we have developed a VR training application that integrates an existing warehouse management system and trains typical order picking processes. In our VR training demo, we simulate a real warehouse that is supplied with real stocks and real orders.

Abstract Modern user interfaces (UIs) are increasingly expected to be plastic, in the sense that they retain a constant level of usability, even when subjected to context changes at runtime. Self-adaptive user interfaces (SAUIs) have been promoted as a solution for context variability due to their ability to automatically adapt to the context-of-use at runtime. The development of SAUIs is a challenging and complex task as additional aspects like context management and UI adaptation have to be covered. In classical model-driven UI development approaches, these aspects are not fully integrated and hence introduce additional complexity as they represent crosscutting concerns. In this paper, we present an integrated model-driven development approach where a classical model-driven development of UIs is coupled with a model-driven development of context-of-use and UI adaptation rules. We base our approach on the core UI modeling language IFML and introduce new modeling languages for context-of-use (ContextML) and UI adaptation rules (AdaptML). The generated UI code, based on the IFML model, is coupled with the context and adaptation services, generated from the ContextML and AdaptML model, respectively. The integration of the generated artifacts, namely UI code, context, and adaptation services in an overall rule-based execution environment, enables runtime UI adaptation. The benefit of our approach is demonstrated by two case studies, showing the development of SAUIs for different application scenarios and a usability study which has been conducted to analyze end-user satisfaction of SAUIs.

Migration of test cases has a twofold benefit in software migration projects: reuse of valuable knowledge as well as time and cost savings. The diversity of software migration project contexts require a flexible and modular construction method to address several aspects like different system and test environments or the impact of the system changes on the test cases. When an inappropriate migration method is used, it may increase the effort and the costs and also decrease the overall software quality. Therefore, a critical task in test case migration is to provide a transformation method which fits the context. To address this problem, in this paper, we present a framework that enables a modular construction of context-specific migration methods for test cases by assembling predefined building blocks. Our approach builds upon an existing framework for modular construction of software transformation methods and consists of a method base and a method engineering process. Method fragments are the atomic building blocks of a migration method, whereas method patterns encode specific migration strategies. The guidance on development and enactment of migration methods is provided by the method engineering process. We evaluate our approach in an industrial case study where a part of the Eclipse Modeling Framework was migrated from Java to C#.

Crowdsourced knowledge bases like Wikidata suffer from low-quality edits and vandalism, employing machine learning-based approaches to detect both kinds of damage. We reveal that state-of-the-art detection approaches discriminate anonymous and new users: benign edits from these users receive much higher vandalism scores than benign edits from older ones, causing newcomers to abandon the project prematurely. We address this problem for the first time by analyzing and measuring the sources of bias, and by developing a new vandalism detection model that avoids them. Our model FAIR-S reduces the bias ratio of the state-of-the-art vandalism detector WDVD from 310.7 to only 11.9 while maintaining high predictive performance at 0.963 ROC and 0.316 PR.

Modern User Interfaces (UIs) are increasingly expected to be plastic, in the sense that they retain a constant level of usability, even when subjected to context (platform, user, and environment) changes at runtime. Adaptive UIs have been promoted as a solution for context variability due to their ability to automatically adapt to the context-of-use at runtime. However, evaluating end-user satisfaction of adaptive UIs is a challenging task, because the UI and the context-of-use are both constantly changing. Thus, an acceptance analysis of UI adaptation features should consider the context-of-use when adaptations are triggered. Classical usability evaluation methods like usability tests mostly focus on a posteriori analysis techniques and do not fully exploit the potential of collecting implicit and explicit user feedback at runtime. To address this challenge, we present an on-the-fly usability testing solution that combines continuous context monitoring together with collection of instant user feedback to assess end-user satisfaction of UI adaptation features. The solution was applied to a mobile Android mail application, which served as basis for a usability study with 23 participants. A data-driven end-user satisfaction analysis based on the collected context information and user feedback was conducted. The main results show that most of the triggered UI adaptation features were positively rated.

Today, modern IT-systems are often an interplay of third-party web services. Developers in their role as requesters integrate existing services of different providers into new IT-systems. Providers use frameworks like Open API to create syntactic service specifications from which requesters generate code to integrate services. Proper service discovery is crucial to identify usable services in the growing plethora of third-party services. Most advanced service discovery approaches rely on semantic specifications, e.g., OWL-S. While semantic specifications are crucial for a precise discovery, syntactical specification are needed for service invocation. To close the gap between semantic and syntactic specifications, service grounding establishes links between the semantic and syntactic specifications. However, for a large number of web services still no semantic specification or grounding exists. In this paper, we present an approach that semi-automates the semantic specification of web services for service providers and additionally helps service requesters to leverage semantic web services. Our approach enables a higher degree of automation than other approaches. This includes the creation of semantic specifications and service groundings for service providers as well as the integration of services for requesters by using our code generator. As proof-of-concept, we provide a case study, where we derive a sophisticated semantic OWL-S specification from a syntactic Open API specification.

Websites increasingly embed semantic data for search engine optimization. The most common ontology for semantic data, schema.org, is supported by all major search engines and describes over 500 data types, including calendar events, recipes, products, and TV shows. As of today, users wishing to pass this data to their favorite applications, e.g., their calendars, cookbooks, price comparison applications or even smart devices such as TV receivers, rely on cumbersome and error-prone workarounds such as reentering the data or a series of copy and paste operations. In this paper, we present Semantic Data Mediator (SDM), an approach that allows the easy transfer of semantic data to a multitude of services, ranging from web services to applications installed on different devices. SDM extracts semantic data from the currently displayed web page on the client-side, offers suitable services to the user, and by the press of a button, forwards this data to the desired service while doing all the necessary data conversion and service interface adaptation in between. To realize this, we built a reusable repository of service descriptions, data converters, and service adapters, which can be extended by the crowd. Our approach for linking services to websites relies solely on semantic data and does not require any additional support by either website or service developers. We have fully implemented our approach and present a real-world case study demonstrating its feasibility and usefulness.

Spreadsheets are used in professional business contexts to make decisions based on collected data. Usually, these spreadsheets are developed by end users in an ad-hoc way. Thus, the business logic of a concrete spreadsheet is not explicit to end users, making its correctness hard to assess and users have to trust. We present an approach where structure and computational behavior of a spreadsheet are specified by a model with a process-like notation based on pre-defined functional spreadsheet services with typed interfaces. This enables a consistent construction process of a spreadsheet that comprises defining its structure and computational behavior as well as filling it with data and executing the defined computational behavior. Thus, concrete spreadsheets are equipped with a specification of their construction process. This supports their understanding and correct usage, even in case of legacy spreadsheets. The approach has been developed in cooperation with an industrial partner.

Wikidata is the new, large-scale knowledge base of the Wikimedia Foundation. Its knowledge is increasingly used within Wikipedia itself and various other kinds of information systems, imposing high demands on its integrity. Wikidata can be edited by anyone and, unfortunately, it frequently gets vandalized, exposing all information systems using it to the risk of spreading vandalized and falsified information. In this paper, we present a new machine learning-based approach to detect vandalism in Wikidata. We propose a set of 47 features that exploit both content and context information, and we report on 4 classifiers of increasing effectiveness tailored to this learning task. Our approach is evaluated on the recently published Wikidata Vandalism Corpus WDVC-2015 and it achieves an area under curve value of the receiver operating characteristic, ROC-AUC, of 0.991. It significantly outperforms the state of the art represented by the rule-based Wikidata Abuse Filter (0.865 ROC-AUC) and a prototypical vandalism detector recently introduced by Wikimedia within the Objective Revision Evaluation Service (0.859 ROC-AUC).

No abstract available.

General theories explain the fundamental phenomena that constitute a research domain. They apply across a domain and often integrate many theories and concepts into a single cohesive view. While general theories are extremely important for education and research coordination, and common in many disciplines (e.g. sociology, criminology, electrical engineering, biology, physics), software engineering lacks a well-accepted general theory. The General Theory of Software Engineering workshop seeks to rectify this situation by promoting theory development in software engineering. The fourth workshop in this series, held in conjunction with the International Conference on Software Engineering, displayed a promising trend toward more theory development papers.

The Collaborative Research Centre "On-The-Fly Computing" works on foundations and principles for the vision of the Future Internet. It proposes the paradigm of On-The-Fly Computing, which tackles emerging worldwide service markets. In these markets, service providers trade software, platform, and infrastructure as a service. Service requesters state requirements on services. To satisfy these requirements, the new role of brokers, who are (human) actors building service compositions on the fly, is introduced. Brokers have to specify service compositions formally and comprehensively using a domain-specific language (DSL), and to use service matching for the discovery of the constituent services available in the market. The broker's choice of the DSL and matching approaches influences her success of building compositions as distinctive properties of different service markets play a significant role. In this paper, we propose a new approach of engineering a situation-specific DSL by customizing a comprehensive, modular DSL and its matching for given service market properties. This enables the broker to create market-specific composition specifications and to perform market-specific service matching. As a result, the broker builds service compositions satisfying the requester's requirements more accurately. We evaluated the presented concepts using case studies in service markets for tourism and university management.

We report on the construction of the Wikidata Vandalism Corpus WDVC-2015, the first corpus for vandalism in knowledge bases. Our corpus is based on the entire revision history of Wikidata, the knowledge base underlying Wikipedia. Among Wikidata's 24 million manual revisions, we have identified more than 100,000 cases of vandalism. An in-depth corpus analysis lays the groundwork for research and development on automatic vandalism detection in public knowledge bases. Our analysis shows that 58% of the vandalism revisions can be found in the textual portions of Wikidata, and the remainder in structural content, e.g., subject-predicate-object triples. Moreover, we find that some vandals also target Wikidata content whose manipulation may impact content displayed on Wikipedia, revealing potential vulnerabilities. Given today's importance of knowledge bases for information systems, this shows that public knowledge bases must be used with caution.

Companies expect higher productivity of their software teams when introducing new software development methods. Productivity is commonly understood as the ratio of output created and resources consumed. Whereas the measurement of the resources consumed is rather straightforward, there are several definitions for counting the output of a software development. Source code-based metrics create a set of valuable figures direct from the heart of the software - the code. However, depending on the chosen process model software developers and testers produce also a fair amount of documentation. Up to now this output remains uncounted leading to an incomplete view on the development output. This article addresses this open point by proposing a novel automated way on software quantity measurement. It extends source code-based metrics, namely the size of code changes which is called churn, by the counting of work items representing the design and test documentation belonging to that churn. We demonstrate the validity of this approach on the sliced V-model process which is an agility extension of the traditional V-model.

SUMMARY In performance‐driven software engineering, the performance of a system is evaluated through models before the system is assembled. After assembly, the performance is then validated using performance tests. When a component‐based system fails certain performance requirements during the tests, it is important to find out whether individual components yield performance errors or whether the composition of components is faulty. This task is called performance blame analysis. Existing performance blame analysis approaches and also alternative error analysis approaches are restricted, because they either do not employ expected values, use expected values from regression testing, or use static developer‐set limits. In contrast, this paper describes the new performance blame analysis approach PBlaman that builds upon our previous work and that employs the context‐portable performance contracts of Palladio. PBlaman decides what components to blame by comparing the observed response time data series of each single component operation in a failed test case to the operation's expected response time data series derived from the contracts. System architects are then assisted by a visual presentation of the obtained analysis results. We exemplify the benefits of PBlaman in two case studies, each of which representing applications that follow a particular architectural style. Copyright © 2014 John Wiley & Sons, Ltd.

Information extraction is usually approached as an annotation task: Input texts run through several analysis steps of an extraction process in which different semantic concepts are annotated and matched against the slots of templates. We argue that such an approach lacks an efficient control of the input of the analysis steps. In this paper, we hence propose and evaluate a model and a formal approach that consistently put the filtering view in the focus: Before spending annotation effort, filter those portions of the input texts that may contain relevant information for filling a template and discard the others. We model all dependencies between the semantic concepts sought for with a truth maintenance system, which then efficiently infers the portions of text to be annotated in each analysis step. The filtering view enables an information extraction system (1) to annotate only relevant portions of input texts and (2) to easily trade its run-time efficiency for its recall. We provide our approach as an open-source extension of Apache UIMA and we show the potential of our approach in a number of experiments.

The paradigm of service-oriented architectures has emerged as an architectural style for designing enterprise applications. Requirements engineering for such applications comprises the specification of business goal models representing stakeholder objectives and the operationalization to business process models that specify the required composition of services. Inconsistencies between business goals and derived business processes can lead to service compositions that are not in line with the actual stakeholder objectives. For preserving consistency it is required to consider logical and temporal dependencies among goals (e.g. the order in which they need to be achieved) in the derivation of business processes. In previous work, we provided a technique for the elicitation and specification of dependencies between business goals. Extending this approach, we aim at validating the consistency between business goal models and business process models regarding these dependencies. In this paper, we present a pattern-based approach for the automated generation of verifiable business process quality constraints from business goal models. We describe how these constraints can be used to check the consistency between business goals and business processes and demonstrate the applicability of our approach in a case study by using the implemented tool support.

One of the main ideas of Service-Oriented Computing (SOC) is the delivery of flexibly composable services provided on world-wide markets. For a successful service discovery, service requests have to be matched with the available service offers. However, in a situation in which no service that completely matches the request can be discovered, the customer may tolerate slight discrepancies between request and offer. Some existing fuzzy matching approaches are able to detect such service variants, but they do not allow to explicitly specify which parts of a request are not mandatory. In this paper, we improve an existing service matching approach based on Visual Contracts leveraging our preliminary work of design pattern detection. Thereby, we support explicit specifications of service variants and realize gradual matching results that can be ranked in order to discover the service offer that matches a customer's request best.

When developing component-based systems, we incorporate third-party black-box components. For each component, performance contracts have been specified by their developers. If errors occur when testing the system built from these components, it is very important to find out whether components violate their performance contracts or whether the composition itself is faulty. This task is called performance blame analysis. In our previous work we presented a performance blame analysis approach that blames components based on a comparison of response time values from the failed test case to expected values derived from the performance contract. In that approach, the system architect needs to manually assess if the test data series shows faster or slower response times than the data derived from the contract. This is laborious as the system architect has to do this for each component operation. In this paper we present an automated comparison of each pair of data series as decision support. In contrast to our work, other approaches do not achieve fully automated decision support, because they do not incorporate sophisticated contracts. We exemplify our performance blame analysis including the automated decision support using the "Common Component Modeling Example" (CoCoME) benchmark.

Information Extraction (IE) pipelines analyze text through several stages. The pipeline's algorithms determine both its effectiveness and its run-time efficiency. In real-world tasks, however, IE pipelines often fail acceptable run-times because they analyze too much task-irrelevant text. This raises two interesting questions: 1) How much "efficiency potential" depends on the scheduling of a pipeline's algorithms? 2) Is it possible to devise a reliable method to construct efficient IE pipelines? Both questions are addressed in this paper. In particular, we show how to optimize the run-time efficiency of IE pipelines under a given set of algorithms. We evaluate pipelines for three algorithm sets on an industrially relevant task: the extraction of market forecasts from news articles. Using a system-independent measure, we demonstrate that efficiency gains of up to one order of magnitude are possible without compromising a pipeline's original effectiveness.

To be successful with global software development (GSD), development knowledge needs to be shared among the developers and stakeholders, and the quality of the exchanged information must be assured. Therefore, mature processes, methods and tools have to be in place. If a unified and integrated solution does not exist, this impedes the exchange of knowledge (and the migration of people between projects). In GSD, such a diversity can lead to new problems: offshore development teams have to repeatedly re-adjust to method variants used by the respective business units. This can lead to misinterpretation of information and risks for project success. We report on re-aligning the varying software engineering methods and unifying the methodology throughout Capgemini sd&m. We also standardized quality assurance procedures and tightly integrated them with the engineering methodology. By this, we arrived at a comprehensive company-wide Enterprise Software Engineering Model that effectively supports knowledge transfer from clients to the onshore and offshore team.

Effective knowledge transfer (KT) is always important in software development projects, but crucial in global software development (GSD). Two challenges arise: First, reviews of the software requirements specification (SRS) are indispensable, but not always effective. Second, using knowledge representations that support KT from customers to developers is paramount. However, 'classical' SRS often don't support SRS comprehension of all stakeholders. We address these two challenges with a new approach that exploits the multi-fold power of a acceptance test case specifications (ATC-Specs): 1) A specific two-stage test-based review technique is used. We argue that these two-stage reviews of ATC-Specs increase the quality of the ATC-Specs and the SRS. 2) Additionally to the SRS, ATC-Specs are delivered to the offshore team, bridging the mental models of different stakeholders, and thus effectively transferring knowledge. We provide preliminary evidence of the validity of our approach based on a commercial GSD project at Capgemini sd&m.

Assessments are an effective technique for software quality assurance. As global software development (GSD) becomes the standard, an assessment framework must be flexible to support different sourcing and shoring models. Although much work exists on inspections and reviews, an assessment framework which addresses these challenges is missing. We present a systematic yet flexible assessment framework. The paper contributes: i) The description of our assessment framework which addresses four challenges: Appropriateness of a software requirements specification (SRS), viability of software architectures and SRS, wholeness of work packages, and compliance of results with predefined quality objectives. ii) A detailed explanation how the assessment framework can be tailored to support offshore and outsourcing scenarios. This paper describes the result of a two years research initiative at Capgemini sd&m and serves the practitioner to implement assessment frameworks according to his needs. We also discuss open research questions of high relevance for the software industry.

In acceptance testing, customer requirements as specified in system specifications have to be tested for their successful implementation. This is a time-consuming task due to inherent system complexity and thus a large number of requirements. In order to reduce efforts in acceptance testing, we introduce a novel approach that exploits redundancies and implicit relations in requirements specifications, which are based on multi-viewpoint techniques, in our case the reference model for open distributed processing (RM-ODP). It deploys requirements clustering and linguistic analysis techniques for reducing the total number of test cases. We report on concrete experiences with this approach within joint R&D work of the Software Quality Lab (s-lab) of the University of Paderborn and HJP Consulting, an international consulting company, specialized in planning, procurement and acceptance testing of national electronic identification (e-ID) systems. The paper is concluded with an overview on the current tool support especially for automated detection of the redundancies and implicit relations in requirements. Also the future work on the tool support for the overall test specification process is discussed.

Dynamic meta modeling (DMM) is a visual semantics specification technique targeted at languages equipped with a metamodel. In DMM, the metamodel of a language is mapped into a runtime metamodel able to express runtime states of instances of that language. In addition, graph transformation rules are defined which describe how these runtime states change in time. Given an instance of the runtime metamodel and a set of rules typed over that metamodel, a transition system can be computed which represents the semantics of the model instance under investigation. To be easily understandable by language engineers, DMM resembles a couple of well-known object-oriented concepts. Part of this is the fact that a DMM rule has many similarities to a method in an object-oriented language. In this paper, we enhance DMM such that DMM rules can "override" other DMM rules, similar to a method being overridden in a subclass. We argue that this does not only have positive impact on reusability of DMM specifications, but also improves the intuitive understandability of DMM rules.

This paper depicts the evolution of enterprise architectures to their today often used service-oriented form and presents a state-of-the-art development process for this kind of architecture. The development process covers both the development of business architecture as well as the appropriate software architecture. While showing up a possible form of further evolution of enterprise architectures, we identify the major challenges for future development methods of enterprise architectures.

Software cities alias application landscapes of large enterprises comprise tens or even hundreds of IT applications. Structuring software cities into domains is an important task of enterprise architects. The quality of the resulting domain model is crucial for the success of enterprise architecture management and an important tool for the governance of the development of an enterprise's application landscape. This paper presents a novel method for constructing domain models based on business services, business objects, and business dimensions. The method has been validated in numerous industrial projects.

Business processes usually have to consider certain constraints like domain specific and quality requirements. The automated formal verification of these constraints is desirable, but requires the user to provide an unambiguous formal specification. In particular since the notations for business process modeling are usually visual flow-oriented languages, the notational gap to the languages usually employed for the formal specification of constraints, e.g., temporal logic, is significant and hard to bridge. Thus, our approach relies on UML Activities as a single language for the specification of both business processes and the corresponding constraints. For the expression of such constraints, we have provided a process pattern definition language based on specialized Activities. In this paper, we describe how model checking can be employed for formal verification of business processes against such patterns. For this, we present an automated transformation of the business process and the corresponding patterns into a transition system and temporal logic, respectively.

The Visual Contract Workbench is a tool that supports model-driven development of software systems by lifting the Design by Contract idea, which is usually used at the code level, to the model level. It uses visual contracts for graphically specifying the pre- and post-conditions of an operation. Java classes with JML (Java modeling language) assertions are generated from visual contracts to facilitate automatic monitoring of the correctness of the programmers' implementation

Quality management is a hot issue in most organisations and must be considered in the business processes of the organisation. Existing approaches on business process modelling provide neither explicit strategy to model quality requirements on business processes nor do they provide explicit support for the construction of business processes satisfying such quality requirements. In this paper, we present a pattern-driven development process for modelling business processes with respect to given quality constraints. We introduce a visual pattern specification language based on UML Activity Diagrams that enables the expression of quality constraints as patterns. These patterns can be used in a forward-engineering development process which supports the business process designer in constructing business processes by applying patterns. Thereby, quality constraints can be integrated into the design of business processes seamlessly

The design and development of complex software systems is a difficult task, and it is not easy to ensure the quality of a developed software. The paper presents an architectural style-based approach to specifying and analyzing complex software systems. The approach developed is based on UML-like meta models and graph transformation techniques to support sound methodological principals, formal analysis and refinement. The approach is illustrated through the specification and simulation of architectural styles of mobile computing middleware, where three abstract levels of architectural styles are defined in order to decrease the complexity brought by mobility.

Spreadsheets are widely used in all kinds of business applications. Numerous studies have shown that they contain many errors that sometimes have dramatic impacts. One reason for this situation is the low-level, cell-oriented development process of spreadsheets.We improve this process by introducing and formalizing a higher-level object-oriented model termed ClassSheet. While still following the tabular look-and feel of spreadsheets, ClassSheets allow the developer to express explicitly business object structures within a spreadsheet, which is achieved by integrating concepts from the UML (Unified Modeling Language). A stepwise automatic transformation process generates a spreadsheet application that is consistent with the ClassSheet model. Thus, by deploying the formal underpinning of ClassSheets, a large variety of errors can be prevented that occur in many existing spreadsheet applications today.The presented ClassSheet approach links spreadsheet applications to the object-oriented modeling world and advocates an automatic model-driven development process for spreadsheet applications of high quality.

Design by contract (DbC) is widely acknowledged to be a powerful technique for creating reliable software. DbC allows developers to specify the behavior of an operation precisely by pre- and post-conditions. Existing DbC approaches predominantly use textual representations of contracts to annotate the actual program code with assertions. In the unified modeling language (UML), the textual object constraint language (OCL) supports the specification of preand post-conditions by constraining the model elements that occur in UML diagrams. However, textual specifications in OCL can become complex and cumbersome, especially for software developers who are typically not used to OCL. In this paper, we propose to specify the pre-and post-conditions of an operation visually by a pair of UML object diagrams (visual contract). We define a mapping of visual contracts into Java classes that are annotated with behavioral interface specifications in the Java modeling language (JML). The mapping supports testing the correctness of the implementation against the specification using JML tools, which include a runtime assertion checker. Thus we make the visual contracts executable.

The integration of software components becomes a more and more important issue in software engineering. Process-oriented approaches should provide automated information processes. Therefore, the software components have to be integrated in a consistent way, i.e., their export interfaces have to be respected by the importing components. Furthermore, the type system of component interfaces has to support a tunable degree of freedom. This allows the insertion of components with interfaces of restricted but sufficient degree of compatibility. In this paper, we develop a concept for consistent and flexible integration of components. We present a process modeling language that combines UML and XML in order to support consistent, flexible, and executable processes. Finally, we provide a formalization of the proposed component type system.

Abstract In the early stages of most software processes, functional and non‐functional (such as architectural, performance, or security) requirements are expressed separately in different sub‐models. Later these requirements have to be integrated into one overall system design. The integration raises consistency issues between different sub‐models, which have to be resolved in the process. If requirements evolve over time, this leads to changes to the sub‐models concerned. Thus, new consistency issues arise between changed and unchanged sub‐models. In this case, a clear separation of concerns between different sub‐models is required to keep the effect of changes as local as possible. In this paper, we use a relational approach to couple functional and architectural models while keeping them separated in order to simplify change. The approach uses meta modeling to support the static integration and concepts from the theory of graph transformation to formalize the semantic consistency of the dynamic aspects. Copyright © 2002 John Wiley & Sons, Ltd.

Object-oriented modeling favors the modeling of object behavior from different viewpoints and the successive refinement of behavioral models in the development process. This gives rise to consistency problems of behavioral models. The absence of a formal semantics for UML models and the numerous possibilities of employing behavioral models within the development process lead to the rise of a number of different consistency notions. In this paper, we discuss the issue of consistency of behavioral models in the UML and present a general methodology how consistency problems can be dealt with. According to the methodology, those aspects of the models relevant to the consistency are mapped to a semantic domain in which precise consistency tests can be formulated. The choice of the semantic domain and the definition of consistency conditions can be used to construct different consistency notions. We show the applicability of our methodology by giving an example of a concrete consistency problem of concurrent object-oriented models.

The idea of a combined reference model- and view-based specification approach has been proposed recently in the software engineering community. In this paper we present a specification technique based on graph transformations which supports such a development approach. The use of graphs and graph transformations supports an intuitive understanding and an integration of static and dynamic aspects on a well-defined semantical base. On this background, formal notions of view and view relation are developed and the behaviour of views is described by a loose semantics. The integration of two views derived from a common reference model is done in two steps. First, dependencies between the views which are not given by the reference model are determined, and the reference model is extended appropriately. This is the task of a model manager. If the two views and the reference model are consistent, the actual view integration can be performed automatically. For the case of more than two views more general scenarios are developed and discussed. All concepts and results are illustrated at the well-known example of a banking system.

The conceptual modeling approach of the IPSEN (Integrated Project Support Environment) project for building highly integrated environments is based on using attributed graphs to model and implement arbitrary object structures, in particular all kinds of software documents and their relationships. A language based on graph grammars, called PROGRESS (PROgrammed Graph REwriting SyStems), and a suitable method for the application of this language, called graph grammar engineering, have been developed over the last ten years. This language and method are being extensively used for specifying the complex graph structures of internal document representations as well as for specifying the functionality of all tools (editors, browsers, analyzers, debuggers) working on these internal rpresentations. This paper explains the language and the method for applying the language based on a pragmatic nontrivial example of a software production process and its corresponding documents. In particular, it is shown why and how a graph grammar-based strongly typed language is perfectly suitable to formally specify highly integrated software tools. In addition, it is shown that the implementation of these tools (i.e., an environment composed of these tools) is systematically being derived from the formal specifications.