The paper describes the need for and goals of tool-integration within software development processes. In particular we focus on agile software development but are not limited to. The integration of tools and data between the different domains of the process is essential for an efficient, effective and customized software development. We describe what the next steps in the pursuit of integration are and how major goals can be achieved. Beyond theoretical and architectural considerations we describe the prototypical implementation of an open platform approach. The paper introduces platform apps and a functionality store as general concepts to make apps and their functionalities available to the community. We describe the implementation of the approach and how it can be practically utilized. The description is based on one major use case and further steps are motivated by various other examples.
Meanwhile, Frantz and Corchuelo @cite_7 refer to integration in the business (EAI) context. But, they state important facts that also apply to integration of the software development process. They see need for integration in order to be able to reuse software components (or tools) and for adapting or optimizing IT to the needs of (business) processes, while we emphasize workflows within the software development process. Further, they introduce their own EAI framework to compare it to other existing ones like Spring Integration or Camel. With regard to the goal to provide simple tool integration and development mechanisms, we consider the approach to be not sufficient to serve as an integration environment for software development processes. In particular the use of message pattern to detach data from integrated applications can be problematic. This means, messages have to be routed through the integration environment and translated into the application specific data model format. Using message buses to decouple systems is a general EAI pattern, which we explicitly avoid by mapping directly on a generic meta model understood by all applications using our platform.
@cite_7
1983841261 2054506507 2171262729 1991292921
Abstract The need for integrating business and technical information systems, allowing partners to collaborate effectively in creating innovative products, has motivated the design and deployment of a novel integration framework for product lifecycle management. The time is ripe for such an integration framework because of the convergence of three important developments, almost in a perfect storm: (1) maturity of standardized product data and meta-data models, and standardized engineering and business processes; (2) emergence of service-oriented architecture for information sharing; and (3) availability of robust middleware to implement them. These developments allow engineering and business objects and processes to be built or composed as modular pieces of software in the form of services that can communicate with each other and be used across different parts of a business. These modular software pieces can be reused and reconfigured in new ways as business conditions change, thereby saving time and money for companies. This paper describes the business and technical aspects of an integration framework for product lifecycle management using open standards and service-oriented architecture. Automated tools for understanding application behavior and its changes during the application lifecycle are essential for many performance analysis and debugging tasks. Application performance issues have an immediate impact on customer experience and satisfaction. A sudden slowdown of enterprise-wide application can effect a large population of customers, lead to delayed projects, and ultimately can result in company financial loss. Significantly shortened time between new software releases further exacerbates the problem of thoroughly evaluating the performance of an updated application. Our thesis is that online performance modeling should be a part of routine application monitoring. Early, informative warnings on significant changes in application performance should help service providers to timely identify and prevent performance problems and their negative impact on the service. We propose a novel framework for automated anomaly detection and application change analysis. It is based on integration of two complementary techniques: (i) a regression-based transaction model that reflects a resource consumption model of the application, and (ii) an application performance signature that provides a compact model of runtime behavior of the application. The proposed integrated framework provides a simple and powerful solution for anomaly detection and analysis of essential performance changes in application behavior. An additional benefit of the proposed approach is its simplicity: It is not intrusive and is based on monitoring data that is typically available in enterprise production environments. The introduced solution further enables the automation of capacity planning and resource provisioning tasks of multitier applications in rapidly evolving IT environments. Data integration systems offer a uniform interface to a set of data sources. Despite recent progress, setting up and maintaining a data integration application still requires significant upfront effort of creating a mediated schema and semantic mappings from the data sources to the mediated schema. Many application contexts involving multiple data sources (e.g., the web, personal information management, enterprise intranets) do not require full integration in order to provide useful services, motivating a pay-as-you-go approach to integration. With that approach, a system starts with very few (or inaccurate) semantic mappings and these mappings are improved over time as deemed necessary. This paper describes the first completely self-configuring data integration system. The goal of our work is to investigate how advanced of a starting point we can provide a pay-as-you-go system. Our system is based on the new concept of a probabilistic mediated schema that is automatically created from the data sources. We automatically create probabilistic schema mappings between the sources and the mediated schema. We describe experiments in multiple domains, including 50-800 data sources, and show that our system is able to produce high-quality answers with no human intervention. In continuous integration development environments, software engineers frequently integrate new or changed code with the mainline codebase. This can reduce the amount of code rework that is needed as systems evolve and speed up development time. While continuous integration processes traditionally require that extensive testing be performed following the actual submission of code to the codebase, it is also important to ensure that enough testing is performed prior to code submission to avoid breaking builds and delaying the fast feedback that makes continuous integration desirable. In this work, we present algorithms that make continuous integration processes more cost-effective. In an initial pre-submit phase of testing, developers specify modules to be tested, and we use regression test selection techniques to select a subset of the test suites for those modules that render that phase more cost-effective. In a subsequent post-submit phase of testing, where dependent modules as well as changed modules are tested, we use test case prioritization techniques to ensure that failures are reported more quickly. In both cases, the techniques we utilize are novel, involving algorithms that are relatively inexpensive and do not rely on code coverage information -- two requirements for conducting testing cost-effectively in this context. To evaluate our approach, we conducted an empirical study on a large data set from Google that we make publicly available. The results of our study show that our selection and prioritization techniques can each lead to cost-effectiveness improvements in the continuous integration process.