40 research outputs found
The evolution of the laws of software evolution. A discussion based on a systematic literature review
After more than 40 years of life, software evolution should be considered as a mature field. However, despite
such a long history, many research questions still remain open, and controversial studies about the validity
of the laws of software evolution are common. During the first part of these 40 years the laws themselves
evolved to adapt to changes in both the research and the software industry environments. This process
of adaption to new paradigms, standards, and practices stopped about 15 years ago, when the laws were
revised for the last time. However, most controversial studies have been raised during this latter period.
Based on a systematic and comprehensive literature review, in this paper we describe how and when the
laws, and the software evolution field, evolved. We also address the current state of affairs about the validity
of the laws, how they are perceived by the research community, and the developments and challenges that
are likely to occur in the coming years
Context-Adaptive Coordination of Pervasive Services by Interpreting Models during Runtime
[EN] One of the most important goals of pervasive systems is to help users in their daily life by automating their behaviour patterns. To achieve this, pervasive services must be dynamically coordinated, executed and adapted to context according to user behaviour patterns. In this work, we propose a model-driven solution to meet this challenge. We propose a task model and a context ontology to design context-adaptive coordination of services at a high level of abstraction. This design facilitates the coordination analysis at design time and is also reused at runtime. We propose a software architecture that interprets the models at runtime in order to coordinate the service execution that is required to support user behaviour patterns. This coordination is done in a context-adaptive way and decoupled from service implementation. This approach makes the models the only representation of service coordination, which facilitates the maintenance and evolution of the executed service coordination after deployment.This work has been developed with the support of (a) MICINN under the project EVERYWARE TIN2010-18011 and (b) MITYC under the project LIFEWEAR TSI-020400-2010-100 co-funded with ERDF.Serral Asensio, E.; Valderas Aranda, PJ.; Pelechano Ferragud, V. (2013). Context-Adaptive Coordination of Pervasive Services by Interpreting Models during Runtime. Computer Journal. 56(1):87-114. https://doi.org/10.1093/comjnl/bxs019S8711456
On porting software visualization tools to the web
Software systems are hard to understand due to the complexity and the sheer size of the data to be analyzed. Software visualization tools are a great help as they can sum up large quantities of data in dense, meaningful pictures. Traditionally, such tools come in the form of desktop applications. Modern web frameworks are about to change this status quo, as building software visualization tools as web applications can help in making them available to a larger audience in a collaborative setting. Such a migration comes with a number of promises, perils, and technical implications that must be considered before starting any migration process. In this paper, we share our experiences in porting two such tools to the web and provide guidelines about the porting. In particular, we discuss promises and perils that go hand in hand with such an endeavor and present a number of technological alternatives that are available to implement web-based visualization
Recommended from our members
Requirements-Driven Adaptation of Choreographed Interactions
Electronic services are emerging as the de-facto enabler of interaction interoperability across organization boundaries. Cross-organizational interactions are often “choreographed”, i.e. specified by a messaging protocol from a global point of view independent of the local view of each interacting organization. Local requirements motivating an interaction as well as the global contextual requirements governing the interaction inevitably evolve over time, requiring adaptation of the corresponding interaction protocol. Adaptation of an interaction protocol must ensure the satisfaction of both sets of interaction requirements while maintaining consistency between the global view and the local views of an interaction specification. Such adaptation is not possible with the current state-of-the-art representations of choreographed interactions, as they capture only operational messaging specifications detached from both local organizational requirements as well as global contextual requirements.
This thesis presents three novel contributions that tackle adaptation of choreographed interaction protocols: an automated technique for deriving an interaction protocol from requirements, a formalization of consistency between local and global views, and a framework for guiding the adaptation of a choreographed interaction. A choreographed interaction is specified using models of organizational requirements motivating the interaction. We employ the formal semantics embedded in requirements models to automatically derive an interaction protocol. We propose a framework for relating the global and local views of interaction specification and maintaining consistency between them. We develop a metamodel for interaction specification, from which we enumerate adaptation operations. We build a catalogue that provides guidance on performing each operation and propagating changes between the global and local views. These contributions are evaluated using examples from the literature as well as a real-world case study
Efficient and Effective Event Pattern Management
The goal of this thesis is to reduce the barriers stopping more enterprises from accessing CEP technology by providing additional support in managing relevant business situations. Therefore we outline the role of event pattern management and present a methodology, methods and tools aiming at an efficient and effective event pattern management. We provide a meta model for event patterns, an event pattern life cycle methodology, methods for guidance, refinement and evolution
Open Source Software Evolution and Its Dynamics
This thesis undertakes an empirical study of software evolution by analyzing open source software (OSS) systems. The main purpose is to aid in understanding OSS evolution. The work centers on collecting large quantities of structural data cost-effectively and analyzing such data to understand software evolution dynamics (the mechanisms and causes of change or growth). We propose a multipurpose systematic approach to extracting program facts (e. g. , function calls). This approach is supported by a suite of C and C++ program extractors, which cover different steps in the program build process and handle both source and binary code. We present several heuristics to link facts extracted from individual files into a combined system model of reasonable accuracy. We extract historical sequences of system models to aid software evolution analysis. We propose that software evolution can be viewed as Punctuated Equilibrium (i. e. , long periods of small changes interrupted occasionally by large avalanche changes). We develop two approaches to study such dynamical behavior. One approach uses the evolution spectrograph to visualize file level changes to the implemented system structure. The other approach relies on automated software clustering techniques to recover system design changes. We discuss lessons learned from using these approaches. We present a new perspective on software evolution dynamics. From this perspective, an evolving software system responds to external events (e. g. , new functional requirements) according to Self-Organized Criticality (SOC). The SOC dynamics is characterized by the following: (1) the probability distribution of change sizes is a power law; and (2) the time series of change exhibits long range correlations with power law behavior. We present empirical evidence that SOC occurs in open source software systems
Recommended from our members
Data cleaning techniques for software engineering data sets
This thesis was submitted for the degree of Doctor of Philosophy and awarded by Brunel University.Data quality is an important issue which has been addressed and recognised in research communities such as data warehousing, data mining and information systems. It has been agreed that poor data quality will impact the quality of results of analyses and that it will therefore impact on decisions made on the basis of these results. Empirical software engineering has neglected the issue of data quality to some extent. This fact poses the question of how researchers in empirical software engineering can trust their results without addressing the quality of the analysed data. One widely accepted definition for data quality describes it as `fitness for purpose', and the issue of poor data quality can be addressed by either introducing preventative measures or by applying means to cope with data quality issues. The research presented in this thesis addresses the latter with the special focus on noise handling.
Three noise handling techniques, which utilise decision trees, are proposed for application to software engineering data sets. Each technique represents a noise handling approach: robust filtering, where training and test sets are the same; predictive filtering, where training and test sets are different; and filtering and polish, where noisy instances are corrected. The techniques were first evaluated in two different investigations by applying them to a large real world software engineering data set. In the first investigation the techniques' ability to improve predictive accuracy in differing noise levels was tested. All three techniques improved predictive accuracy in comparison to the do-nothing approach. The filtering and polish was the most successful technique in improving predictive accuracy. The second investigation utilising the large real world software engineering data set tested the techniques' ability to identify instances with implausible values. These instances were flagged for the purpose of evaluation before applying the three techniques. Robust filtering and predictive filtering decreased the number of instances with implausible values, but substantially decreased the size of the data set too. The filtering and polish technique actually increased the number of implausible values, but it did not reduce the size of the data set.
Since the data set contained historical software project data, it was not possible to know the real extent of noise detected. This led to the production of simulated software engineering data sets, which were modelled on the real data set used in the previous evaluations to ensure domain specific characteristics. These simulated versions of the data set were then injected with noise, such that the real extent of the noise was known. After the noise injection the three noise handling techniques were applied to allow evaluation. This procedure of simulating software engineering data sets combined the incorporation of domain specific characteristics of the real world with the control over the simulated data. This is seen as a special strength of this evaluation approach.
The results of the evaluation of the simulation showed that none of the techniques performed well. Robust filtering and filtering and polish performed very poorly, and based on the results of this evaluation they would not be recommended for the task of noise reduction. The predictive filtering technique was the best performing technique in this evaluation, but it did not perform significantly well either.
An exhaustive systematic literature review has been carried out investigating to what extent the empirical software engineering community has considered data quality. The findings showed that the issue of data quality has been largely neglected by the empirical software engineering community.
The work in this thesis highlights an important gap in empirical software engineering. It provided clarification and distinctions of the terms noise and outliers. Noise and outliers are overlapping, but they are fundamentally different. Since noise and outliers are often treated the same in noise handling techniques, a clarification of the two terms was necessary.
To investigate the capabilities of noise handling techniques a single investigation was deemed as insufficient. The reasons for this are that the distinction between noise and outliers is not trivial, and that the investigated noise cleaning techniques are derived from traditional noise handling techniques where noise and outliers are combined. Therefore three investigations were undertaken to assess the effectiveness of the three presented noise handling techniques. Each investigation should be seen as a part of a multi-pronged approach.
This thesis also highlights possible shortcomings of current automated noise handling techniques. The poor performance of the three techniques led to the conclusion that noise handling should be integrated into a data cleaning process where the input of domain knowledge and the replicability of the data cleaning process are ensured
Governance and organizational sponsorship as success factors in free/libre and open source software development: An empirical investigation using structural equation modeling
Recent advances in information technologies and subsequent explosive growth of computer software use in practically all aspects of everyday life provide tremendous opportunities and benefits for improving people\u27s lives. However, significant proportion of software projects represents cancelled, abandoned or otherwise failed projects. This situation exists not only in commercial software products or government information systems, but also in an increasingly popular and important domain of free/libre and open source software (FLOSS).
The problem of failures in software development projects requires identification and understanding of the factors of success and their interrelationships. Practice and previous research suggest that governance of software development projects plays crucial role in their success. Increasing adoption and sponsorship of FLOSS by commercial firms and government organizations present additional challenges; such sponsorship may also interact with governance in FLOSS projects and play a role in determining their success.
This dissertation focused on analyzing the role and significance of governance and organizational sponsorship in the success of FLOSS development. This study used both conceptual analysis and empirical methods. The conceptual analysis phase, a preliminary study based on the review of existing literature, produced a partial model of success in FLOSS development. This model was verified in an empirical phase, which statistically analyzed data from multiple FLOSS repositories and other public sources. The statistical analysis was based on structural equation modeling (SEM) approach.
Results of this study did not confirm hypothesized effects of the main two factors (governance and organizational sponsorship) on FLOSS success, but confirmed a positive effect of project maturity on the success. The likely reason of the lack of support for the main factors is unavailability of sufficient and correct data for proper operationalization. This and other uncovered issues are planned to be addressed in the future research on the topic, for which this dissertation formed a solid conceptual and data analysis framework
Semantic discovery and reuse of business process patterns
Patterns currently play an important role in modern information systems (IS) development and their use has mainly been restricted to the design and implementation phases of the development lifecycle. Given the increasing significance of business modelling in IS development, patterns have the potential of providing a viable solution for promoting reusability of recurrent generalized models in the very early stages of development. As a statement of research-in-progress this paper focuses on business process patterns and proposes an initial methodological framework for the discovery and reuse of business process patterns within the IS development lifecycle. The framework borrows ideas from the domain engineering literature and proposes the use of semantics to drive both the discovery of patterns as well as their reuse