waashk/dblp huggingface dataset:
from programming to modeling: our experience with a distributed software engineering course. distributed software engineering (dse) concepts in computer science (or engineering) degrees are commonly introduced using a hands-on approach mainly consisting of teaching a particular distributed and component-based technology platform (such as java enterprise edition or microsoft .net) and proposing the students to develop a small distributed software application with it. though this approach provides the students with some relevant practical knowledge, we believe that it is not the most appropriate way of teaching all the concepts and particularities of dse. thus, in this paper we report on our experience of redesigning an initial dse course following a model-based approach. by raising the level of abstraction we gained modularity, separation of concerns and technology independence, while making the course evolve according to the latest trends in software development methods.
mining framework usage changes from instantiation code. framework evolution may break existing users, which need to be migrated to the new framework version. this is a tedious and error-prone process that benefits from automation. existing approaches compare two versions of the framework code in order to find changes caused by refactorings. however, other kinds of changes exist, which are relevant for the migration. in this paper, we propose to mine framework usage change rules from already ported instantiations, the latter being applications build on top of the framework, or test cases maintained by the framework developers. our evaluation shows that our approach finds usage changes not only caused by refactorings, but also by conceptual changes within the framework. further, it copes well with some issues that plague tools focusing on finding refactorings such as deprecated program elements or multiple changes applied to a single program element.
symbolic mining of temporal specifications. program specifications are important in many phases of the software development process, but they are often omitted or incomplete. an important class of specifications takes the form of temporal properties that prescribe proper usage of components of a software system. recent work has focused on the automated inference of temporal specifications from the static or runtime behavior of programs. many techniques match a specification pattern (represented by a finite state automaton) to all possible combinations of program components and enumerate the possible matches. such approaches suffer from high space complexity and have not scaled beyond simple, two-letter alternating patterns (e.g. (ab)*). in this paper, we precisely define this form of specification mining and show that its general form is np-complete. we observe a great deal of regularity in the representation and tracking of all possible combinations of system components. this motivates us to introduce a symbolic algorithm, based on binary decision diagrams (bdds), that exploits this regularity. our results show that this symbolic approach expands the tractability of this problem by orders of magnitude in both time and space. it enables us to mine more complex specifications, such as the common three-letter resource acquisition, usage, and release pattern ((ab+c)*). we have implemented our algorithm in a practical tool and used it to find significant specifications in real systems, including apache ant and hibernate. we then used these specifications to find previously unknown bugs.
data flow testing of service-oriented workflow applications. ws-bpel applications are a kind of service-oriented application. they use xpath extensively to integrate loosely-coupled workflow steps. however, xpath may extract wrong data from the xml messages received, resulting in erroneous results in the integrated process. surprisingly, although xpath plays a key role in workflow integration, inadequate researches have been conducted to address the important issues in software testing. this paper tackles the problem. it also demonstrates a novel transformation strategy to construct artifacts. we use the mathematical definitions of xpath constructs as rewriting rules, and propose a data structure called xpath rewriting graph (xrg), which not only models how an xpath is conceptually rewritten but also tracks individual rewritings progressively. we treat the mathematical variables in the applied rewriting rules as if they were program variables, and use them to analyze how information may be rewritten in an xpath conceptually. we thus develop an algorithm to construct xrgs and a novel family of data flow testing criteria to test ws-bpel applications. experiment results show that our testing approach is promising.
time-bounded adaptation for automotive system software. software is increasingly deployed in vehicles as demand for new functionality increases and cheaper and more powerful hardware becomes available. likewise, emerging wireless communication protocols allow the integration of new software into vehicles, thereby enabling time-bounded adaptive response to changes that occur in mobile environments. examples of time-bounded adaptation include adaptive cruise control and the dynamic integration of location-aware services within fixed time bounds. this paper provides three contributions to the study of time-bounded adaptation for automotive system software. first, we categorise automotive systems with respect to requirements for dynamic software adaptation. second, we define a taxonomy that captures various dimensions of dynamic adaptation in emerging automotive system software. third, we use this taxonomy to analyse existing research projects in the automotive domain. our analysis shows that although time-bounded synchronisation of applications and data is a key requirement for next-generation automotive systems, it is not adequately covered by existing work.
seurat: integrated rationale management. a completed software product is the end result of many decisions that must be made throughout the development lifecycle. unfortunately, the rationale for these decisions is usually not captured and is therefore lost. the software using rationale (seurat) system integrates with the eclipse interactive development environment to support rationale capture and use. in addition to presenting the rationale to the developer/maintainer as needed, seurat also supports requirements traceability and impact assessment.
answering conceptual queries with ferret. programmers seek to answer questions as they investigate the functioning of a software system, such as "which execution path is being taken in this case?" programmers attempt to answer these questions, which we call conceptual queries, using a variety of tools. each type of tool typically highlights one kind of information about the system, such as static structural information or control-flow information. unfortunately for the programmer, the tools seldom directly answer the programmer's conceptual queries. instead, the programmer must piece together results from different tools to determine an answer to the initial query. at best, this process is time consuming and at worst, this process can lead to data overload and disorientation. in this paper, we present a model that supports the integration of different sources of information about a program. this model enables the results of concrete queries in separate tools to be brought together to directly answer many of a programmer's conceptual queries. in addition to presenting this model, we present a tool that implements the model, demonstrate the range of conceptual queries supported by this tool, and present the results of use of the conceptual queries in a small field study.
power through brokering: open source community participation in software engineering student projects. many software engineering projects use open source software tools or components. the project team's active participation in the open source community may be necessary for the team to use the technology. based on an in-depth field study of industry software engineering project students interacting with an open source community, we find that participation in the community may affect the team's work and learning by strengthening the power of the broker between the team and the community. we outline pitfalls and benefits of having student teams acquire development-related knowledge from open source communities. the findings are relevant to the organization and supervision of software engineering student projects interacting with open source communities.
applying model-based testing to healthcare products: preliminary experiences. healthcare software systems are becoming more and more complex since they will be highly integrated to support a wide variety of healthcare workflows (e.g., financial, administration, diagnosis, and treatment). in addition, healthcare software systems will be more safety-critical as they will provide medical decision support for doctors. all of those require systematic and thorough testing of the systems before they are put into use or upgraded. model-based testing (mbt) is an approach to apply formal, explicit system use-models to generate the test cases for testing the system behaviors under different input data sets. this paper describes our experiences in applying this approach to testing some siemens healthcare software systems. we will report the benefits and challenges in using mbt for testing healthcare software systems.
are fit tables really talking?: a series of experiments to understand whether fit tables are useful during evolution tasks. test-driven software development tackles the problem of operationally defining the features to be implemented by means of test cases. this approach was recently ported to the early development phase, when requirements are gathered and clarified. among the existing proposals, fit (framework for integrated testing) supports the precise specification of requirements by means of so called fit tables, which express relevant usage scenarios in a tabular format, easily understood also by the customer. fit tables can be turned into executable test cases through the creation of pieces of glue code, called fixtures. in this paper, we test the claimed benefits of fit through a series of three controlled experiments in which fit tables and related fixtures are used to clarify a set of change requirements, in a software evolution scenario. results indicate improved correctness achieved with no significant impact on time, however benefits of fit vary in a substantial way depending on the developers' experience. preliminary results on the usage of fit in combination with pair programming revealed another relevant source of variation.
using components for architecture-based management: the self-repair case. components are widely used for managing distributed applications because they not only capture the software architecture of managed applications as an assembly of components but also permit to dynamically adapt these applications to changing environments. following this approach, our practical experience in the jade environment about developing an autonomic repair management service with a self-healing behavior shows novel requirements on reflective component models for architecture-based management systems. first, we have identified five essential runtime abstractions that a component model must include in order to efficiently support an autonomic repair service. second, our experience suggests that traditional reflective component models should be extended to allow specializing meta-operations. third, our experience also shows that a meta-data checkpointing capability is best-suited for meta-data recovery after failures. we demonstrate the soundness of these findings in several ways. we applied the difficult problem of autonomic repair to both j2ee and jms middleware. we further stressed our algorithms and mechanisms by applying them recursively towards gaining a self-healing property for the repair service itself. although our experience was done in the jade context, using the fractal component model, we believe our findings to be general to architecture-based management systems using reflective component
open source software peer review practices: a case study of the apache server. peer review is seen as an important quality assurance mechanism in both industrial development and the open source software (oss) community. the techniques for performing inspections have been well studied in industry; in oss development, peer reviews are less well understood. we examine the two peer review techniques used by the successful, mature apache server project: review-then-commit and commit-then-review. using archival records of email discussion and version control repositories, we construct a series of metrics that produces measures similar to those used in traditional inspection experiments. specifically, we measure the frequency of review, the level of participation in reviews, the size of the artifact under review, the calendar time to perform a review, and the number of reviews that find defects. we provide a comparison of the two apache review techniques as well as a comparison of apache review to inspection in an industrial project. we conclude that apache reviews can be described as (1) early, frequent reviews (2) of small, independent, complete contributions (3) conducted asynchronously by a potentially large, but actually small, group of self-selected experts (4) leading to an efficient and effective peer review technique.
global consistency checking of distributed models with tremer+. we present tremer+, a tool for consistency checking of distributed models (i.e., models developed by distributed teams). tremer+ works by first constructing a merged model before checking consistency. this enables a flexible way of verifying global consistency properties that is not possible with other existing tools.
rational quality requirements for medical software. in this paper we discuss the challenges of software quality for medical software and present some ideas for improving medical software quality requirements through software engineering methods. we apply the quality requirements engineering method moqare to elicit specific quality requirements for an imaginary drug advisory system and report our lessons learned.
impact analysis of database schema changes. we propose static program analysis techniques for identifying the impact of relational database schema changes upon object-oriented applications. we use dataflow analysis to extract all possible database interactions that an application may make. we then use this information to predict the effects of schema change. we evaluate our approach with a case-study of a commercially available content management system, where we investigated 62 versions of between 70k-127k loc and a schema size of up to 101 tables and 568 stored procedures. we demonstrate that the program analysis must be more precise, in terms of context-sensitivity than related work. however, increasing the precision of this analysis increases the computational cost. we use program slicing to reduce the size of the program that needs to be analyzed. using this approach, we are able to analyse the case study in under 2 minutes on a standard desktop machine, with no false negatives and a low level of false positives.
detecting model inconsistency through operation-based model construction. nowadays, large-scale industrial software systems may involve hundreds of developers working on hundreds of different but related models representing parts of the same system specification. detecting and resolving structural inconsistencies between these models is then critical. in this article we propose to represent models by sequences of elementary construction operations, rather than by the set of model elements they contain. structural and methodological consistency rules can then be expressed uniformly as logical constraints on such sequences. our approach is meta-model independent, allowing us to deal with consistency between different models whatever their kind. we have validated our approach by building a prolog engine that detects violations of structural and methodological constraints specified on uml 2.1 models and requirement models. this engine has been integrated into two contemporary uml-based modelling environments, eclipse emf and rational software architect (rsa).
recommending adaptive changes for framework evolution. in the course of a framework's evolution, changes ranging from a simple refactoring to a complete rearchitecture can break client programs. finding suitable replacements for framework elements that were accessed by a client program and deleted as part of the framework's evolution can be a challenging task. we present a recommendation system, semdiff, that suggests adaptations to client programs by analyzing how a framework adapts to its own changes. in a study of the evolution of the eclipse jdt framework and three client programs, our approach recommended relevant adaptive changes with a high level of precision, and detected non-trivial changes typically undiscovered by current refactoring detection techniques.
tool support for data validation by end-user programmers. end-user programming tools for creating spreadsheets and webforms offer no data types except "string" for storing many kinds of data, such as person names and street addresses. consequently, these tools cannot automatically validate these data. to address this problem, we have developed a new userextensible model for string-like data. each "tope" in this model is a user-defined abstraction that guides the interpretation of strings as a particular kind of data, such as a mailing address. specifically, each tope implementation contains software functions for recognizing and reformatting that tope's kind of data. with our tools, end-user programmers define new topes and associate them with fields in spreadsheets, webforms, and other programs. this makes it possible at runtime to distinguish between invalid data, valid data, and questionable data that could be valid or invalid. once identified, questionable and/or invalid data can be double-checked and possibly corrected, thereby increasing the overall reliability of the data.
best practices in extreme programming course design. teaching (and therefore learning) extreme programming (xp) in a university setting is difficult because of course time limitations and the soft nature of xp that requires first-hand experience in order to see and really learn the methods. for example, iterations are either shorter or fewer than appropriate. in this paper we present the properties to tune when designing an extreme programming course. these are the properties we gathered by conducting three xp labs as part of our software engineering teaching. within this paper we describe our set-up as well as the important properties. lecturers and teachers can use this property system and combine it with their own constraints in order to derive a better xp lab for their curriculum.
clone detection in automotive model-based development. model-based development is becoming an increasingly common development methodology. in important domains like embedded systems already major parts of the code are generated from models specified with domain-specific modelling languages. hence, such models are nowadays an integral part of the software development and maintenance process and therefore have a major economic and strategic value for the software-developing organisations. nevertheless almost no work has been done on a quality defect that is known to seriously hamper maintenance productivity in classic code-based development: cloning. this paper presents an approach for the automatic detection of clones in large models as they are used in model-based development of control systems. the approach is based on graph theory and hence can be applied to most graphical data-flow languages. an industrial case study demonstrates the applicability of our approach for the detection of clones in matlab/simulink models that are widely used in model-based development of embedded systems in the automotive domain.
specification patterns for probabilistic quality properties. probabilistic verification techniques are a powerful means to ensure that a software-intensive system fulfills its quality requirements. to apply these techniques an accurate specification of the required properties in a probabilistic temporal logic is necessary. to help practitioners formulate these properties correctly, this paper presents a specification pattern system of common probabilistic properties called proprost. this pattern system has been a developed based on a survey of 152 properties from academic examples and 48 properties of real-word quality requirements from avionic, defence and automotive systems. furthermore, a structured english grammar that can guide in the specification of probabilistic properties is given. similar to previous specification patterns for traditional and real-time properties, the presented specification pattern system and the structured english grammar captures expert knowledge and helps practitioners to correctly apply formal verification techniques.
sufficient mutation operators for measuring test effectiveness. mutants are automatically-generated, possibly faulty variants of programs. the mutation adequacy ratio of a test suite is the ratio of non-equivalent mutants it is able to identify to the total number of non-equivalent mutants. this ratio can be used as a measure of test effectiveness. however, it can be expensive to calculate, due to the large number of different mutation operators that have been proposed for generating the mutants. in this paper, we address the problem of finding a small set of mutation operators which is still sufficient for measuring test effectiveness. we do this by defining a statistical analysis procedure that allows us to identify such a set, together with an associated linear model that predicts mutation adequacy with high accuracy. we confirm the validity of our procedure through cross-validation and the application of other, alternative statistical analyses.
experience applying the spin model checker to an industrial telecommunications system. model checking has for years been advertised as a way of ensuring the correctness of complex software systems. however, there exist surprisingly few critical studies of the application of model checking to industrial-scale software systems by people other than the model checker's own authors. in this paper we report our experience in applying the spin model checker to the validation of the failover protocols of a commercial telecommunications system. while we conclude that model checking is not yet ready for such applications, we find that current research in the model checking community is working to address the difficulties we encountered.
model-based security analysis for mobile communications. mobile communication systems are increasingly used in companies. in order to make these applications secure, the security analysis has to be an integral part of the system design and it management process for such mobile communication systems. this work presents the experiences and results from the security analysis of a mobile system architecture at a large german telecommunications company, by making use of an approach to model-based security engineering that is based on the uml extension umlsec. the focus lies on the security mechanisms and security policies of the mobile applications which were analyzed using the umlsec method and tools. main results of the paper include a field report on the employment of the umlsec method in an industrial telecommunications context as well as indications of its benefits and limitations.