waashk/dblp huggingface dataset:
spyware: a change-aware development toolset. our research is driven by the motivation that change must be put in the center, if one wants to understand the complex processes of software evolution. we built a toolset named spyware which, using a monitoring plug-in for integrated development environments (ides), tracks the changes that a developer performs on a program as they happen. spyware stores these first-class changes in a change repository and offers a plethora of productivity-enhancing ide extensions to exploit the recorded information.
systematically refactoring inheritance to delegation in java. because of the strong coupling of classes and the proliferation of unneeded class members induced by inheritance, the suggestion to use composition and delegation instead has become commonplace. the presentation of a corresponding refactoring in the literature may lead one to believe that such a transformation is a straightforward undertaking. however, closer analysis reveals that this refactoring is neither always possible, nor does it necessarily achieve its desired effect. we have therefore identified the necessary preconditions and realizable postconditions of the refactoring, and built a tool that can perform it completely automatically. by applying this tool to all subclasses of several open-source projects, we have collected evidence of the applicability of the refactoring and of its capability to deliver on its promises. the refactoring builds on constraint graphs originally developed for type inference to check the preconditions and to compute the necessary delegation as well as the subtype relationships that must be maintained.
plural: checking protocol compliance under aliasing. enforcing compliance to api usage protocols is notoriously hard due to possible aliasing of objects through multiple references. in previous work we proposed a sound, modular approach to checking protocol compliance based on typestates that offers a great deal of flexibility in aliasing. in our approach, api protocols are defined based on typestates. every reference is associated with a permission, and reasoning about permissions is appropriately conservative for the "degree" of possible aliasing admitted by a permission. this paper describes plural, a tool to automatically enforce typestate-based protocols using permissions in java. api developers can specify protocols with simple annotations on methods and method parameters. a static flow analysis tracks permissions in code that uses specified apis and issues warnings for possible protocol violations.
third international workshop on sharing and reusing architectural knowledge (shark 2008). the shift of the software architecture community towards architectural knowledge has brought along some promising research directions. in this workshop we discuss the issues that lead to the application of architectural knowledge in research and industrial practice; ongoing research and new ideas to advance the field. in its previous editions we examined the state of the art and practice, future challenges and trends. this third edition will discuss, among others, architectural knowledge as perceived by different research communities, including requirements engineering, service-oriented computing and international standardization.
the design navigator: charting java programs. the design navigator is a semi-automated design mining tool which reverse engineers lepus3 design charts from java™ 1.4 programs at any level of abstraction in reasonable time. we demonstrate the design navigator's step-wise charting process of java foundation classes, generating decreasingly abstract charts of java.awt and discovering building-blocks in its design.
celadon: a change impact analysis tool for aspect-oriented programs. to reduce the manual effort of assessing potential affected program parts during software evolution, we develop a tool, called celadon, which automates the change impact analysis for aspectj programs. celadon is implemented in the context of the eclipse environment and designed as a plugin. it analyzes the source code of two aspectj software versions, and decomposes their differences into a set of atomic changes together with their dependence relationships. the analysis result is reported in terms of impacted program parts and affected tests. for each affected test, celadon also identifies a subset of affecting changes that are responsible for the test's behavior change. in particular, as one of its applications, celadon helps facilitate fault localization by isolating failure-inducing changes for one specific affected test from other irrelevant changes.
the international workshop on software architectures and mobility (sam 2008). e-businesses are increasingly facing the need of porting the provision of their e-services to mobile customers. evolving requirements, such as reliability, security, scalability, performance and privacy, from fixed to mobile settings, has revealed new and important challenges. this is due to the behavioral constraints that mobility poses, and that were not faced in traditional distributed settings. examples include: dynamic network topology, changes in location, constrained resource availability, communication protocols heterogeneity, unstable connectivity, and so forth. industrial practice is demonstrating that such transition is not straightforward and tends to be costly. in particular, the evolution may "break" the software system architecture, thus calling for substantial and expensive changes. even when the system is (re)built from scratch, it is unclear if and how the state-of-the-art in software architectures relate to the requirements and concerns brought forward by mobile software systems. likewise, there is still a lack of systematic software engineering methods and techniques which can assist in developing and evolving mobile software systems. the goal of this workshop is to address these gaps by strengthening the cross fertilization of advances from requirements and domain engineering, software architectures, and middleware to systematically develop and evolve architectures supporting mobility.
: a tool for generating binary adapters for evolving java libraries. although in theory the apis of software libraries and frameworks should be stable, they change in practice. this forces clients of the library api to change as well, making software maintenance expensive. changing a client might not even be an option if its source code is missing or certain policies forbid its change. by giving a library both the old and the new api, clients can be shielded from api changes and can run with the new version of the library. this demo presents our tool, reba, that automatically generates compatibility layers between new library apis and old clients. in the first stage, reba generates another version of the library, called adapted-library, that supports both the old and the new apis. in the second stage, reba shrinks the adapted-library into a minimal, client-specific compatibility layer containing only classes truly required by the client. evaluation on controlled experiments and case studies using eclipse core libraries shows that our approach effectively adapts clients to new library versions, and is efficient.
third international workshop on graph and model transformations. model transformation is an emerging paradigm used in model-driven software development. graph transformations deal with rewriting operations on graphs, and as such can serve as a foundation for constructing model transformation language, tools, and systems. this workshop, the 3rd in a series, investigates the connection between graph and model transformations and intends to bring together interested researchers and practitioners from the two fields.
jigsaw: a tool for the small-scale reuse of source code. developers perform small-scale reuse tasks to save time and to increase the quality of their code. due to the small scale of such tasks, the overhead in reusing source code can quickly outweigh the benefits. existing approaches focus on locating source code for reuse but do not support the integration of the located code within the developer's system, thereby leaving the developer with the burden of performing these steps manually. this paper presents a tool, called jigsaw, that uses the developer's context to help integrate the reused source code into the developer's own source code.
business impact of process improvements. the topic of the workshop "business impact of process improvements" is achieving tangible and sustainable business impact from process improvements. focus is on approaches that are both practical and quantifiable. the kinds of process improvements addressed include, but are not limited to, the introduction of iterative, agile or "lean" approaches, improved requirements engineering, risk management, usage of process improvement reference frameworks, and improved quality control and assurance. busi-ness impact should be illustrated through either increasing the value of what is delivered to the customer or reducing the cost (for example by reduction of rework effort). the audience will share experiences how to reliably set-up, measure and achieve business-oriented process improvements in order to increase return on investment in software engineering.
composing knowledge fragments: a next generation ide. when building a software system, software developers each contribute a flow of information that together forms the system. as they work, programmers continuously consult various facts (knowledge) about this information to answer their questions about the system. the knowledge most easily accessed today in a programming environment involves facts about the structure of the program. however, the knowledge required by a programmer is broader than just structure; it also includes knowledge about design, requirements, and the development process, to name just a few other sources. to enable developers to access this knowledge more efficiently, our goal is to develop a model for programming environments that allows various fragments of different kinds of knowledge to be configured flexibly. this model would enable new presentations to show these knowledge fragments in ways that more directly answer programmers' questions.
formal concept analysis applied to fault localization. one time-consuming task in the development of software is debugging. recent work in fault localization crosschecks traces of correct and failing execution traces, it implicitly searches for association rules which indicate that executing a line will most probably cause the whole execution to fail. this technique has some limitations: it assumes that an error has a single faulty statement origin, and that lines are independent. our research hypothesis is that using association rules with more expressive premises, some limitations can be alleviated. the solution that we propose combines association rules and formal concept analysis. our technique is already usable when the size of the execution traces is not too large. we conjecture that the technique can be used to analyze large executions, thanks to the information contained in the abstract syntax tree.
abctool: a tool for architecture centric engineering of component based systems. in this paper, we present the abctool, a visual tool for modeling software architecture in the whole lifecycle of the target system so that the development, deployment, online maintenance and evolution of a component-based system can be done as a series of refinements and transformations of architectural models in a systematic and automated manner.
sdsoa 2008: second international workshop on systems development in soa environments. the key objective of this workshop is to provide researchers and practitioners an opportunity to discuss open soa research challenges. an soa research agenda that has been developed by sei and a group of collaborators over the past year will be presented as a framework for obtaining feedback and new ideas from researchers and practitioners who do work and research in this area.
summary for leadership and management in software architecture (lmsa 2008). software architecture, in education and practice, is primarily concerned with technical issues associated with the quality of software architecture and design. however, as project size increases, leadership, management skills, and the organizational context of the architect become more important, to the point where the non-technical duties of the project architect can "make or break" a project. this workshop is focused on understanding these non-technical duties.
comeback!: a refactoring-based tool for binary-compatible framework upgrade. maintenance of a software framework often requires restructuring its api (refactoring). upon framework upgrade structural api changes may invalidate existing plugins - modules that used one of its previous versions. to preserve plugins, we use refactoring trace to automatically create an adaptation layer that translates between plugins and the framework. for each encountered refactoring we formally define a comeback - a refactoring to construct adapters. given an ordered set of refactorings occured between two framework versions our tool comeback! executes the corresponding comebacks and yields the adaptation layer.
answering common questions about code. difficulties understanding update paths while un-derstanding code cause developers to waste time and insert bugs. a detailed investigation of these difficulties suggests that a wide variety of problems could be addressed by more easily answering questions about update paths that existing tools do not answer. we are designing a feasible update path static analysis to compute these paths and a visualization for asking questions and displaying results. in addition to grounding the questions we answer and tailoring the program analysis in data, we will also evaluate the usefulness of our tool using lab and field studies.
featuremapper: mapping features to models. variability modelling with feature models is one key technique for specifying the problem space of software product lines (spls). to allow for the automatic derivation of a concrete product based on a given variant configuration, a mapping between features in the problem space and their realisations in the solution space is required. it is crucial to support the developer in the complex task of defining such mappings. these mappings can also be used to provide visualisations of the variant space that allow to reason over variability in spls. in this paper we present featuremapper, a tool that allows for defining mappings of features to model elements specifying feature realisations. these feature realisations can be defined in arbitrary ecore-based languages. furthermore, the tool supports different visualisation techniques that can help developers understand the complex designs of spls.
se-cse 2008: the first international workshop on software engineering for computational science and engineering. computational science and engineering (cs&e) software supports a wide variety of domains including nuclear physics, crash simulation, satellite data processing, fluid dynamics, climate modeling, bioinformatics, and financial modeling. the recent increase in the importance of this type of software motivates the need to better understand how it is developed. this movement creates an opportunity for the software engineering community to apply our techniques and knowledge to a new and important application domain. furthermore, the design, implementation, and maintenance used in cs&e software systems can be significantly different from that used in systems more typically studied by the software engineering community. this workshop brings together researchers from the software engineering community with researchers and practitioners from the cs&e community. the workshop allows participants to share perspectives and present findings from research and practice that are relevant to the cs&e application development. a significant portion of the workshop is devoted to discussion of the position papers with the goal of generating a research agenda to improve tools, techniques, and experimental methods for cs&e software engineering in the future.
developing natural language-based program analyses and tools to expedite software maintenance. with as much as 60-90% of software life cycle resources spent on program maintenance, there is a critical need for automated software tools to help explore and understand today's large and complex software. one important source of information software maintenance tools can draw from is lexical information in comments and identifiers. identifier names often communicate a programmer's intent when writing code, and help developers map real-world concepts to code during comprehension. my dissertation will develop specialized information retrieval techniques and natural language analyses for software so that software maintenance tools can take full advantage of the wealth of information in program identifiers, and integrate these techniques into software tools to expedite the maintenance activities of program exploration, concern location, and fault localization.
runtime software adaptation: framework, approaches, and styles. our icse 1998 paper showed how an application can be adapted at runtime by manipulating its architectural model. in particular, our paper demonstrated the beneficial role of (1) software connectors in aiding runtime change, (2) an explicit architectural model fielded with the system and used as the basis for runtime change, and (3) architectural style in providing both structural and behavioral constraints over runtime change. this paper examines runtime evolution in the decade hence. a broad framework for studying and describing evolution is introduced that serves to unify the wide range of work now found in the field of dynamic software adaptation. this paper also looks to the future, identifying what we believe to be highly promising directions.
software development governance (sdg). governance in a specific organization is an iterative process that starts with the assignment of roles and decision rights as per goals that are set, continues with the establishment of a set of mechanisms to be activated on a specific scope within the organization, and ends with the assessment that leads to the refinement of the goals accordingly. this one-day workshop focuses on software development governance and deals with the issues that are special to software organizations.
summary for scrutinizing agile practices or shoot-out at process corral! agile methods and practices are gaining momentum in industry, and are also slowly making their way in academia bringing fresh air and funny new jargon. some practitioners consider them as the ultimate advance in software engineering. but what do we know about this? where is the evidence? do they scale? do they solve real issues or just substitute new issues to old ones? are the benefits tangible, or just acts of faith? aren't we all agile? are they no agile failures? isn't the "waterfall process" - that piñata of agilistas--the real holy grail of software engineering, and agile processes only a band-aid to compensate for our deficiencies? this workshop aims at challenging the ready-made ideas, the fluff, the hype, putting things into context, and examining these with fresh and open eyes.
monticore: a framework for the development of textual domain specific languages. in this paper we demonstrate a framework for the efficient development of textual domain specific languages and supporting tools. we use a redundance-free and compact definition of a readable concrete syntax and a comprehensible abstract syntax as both representations significantly overlap in their structure. to further improve the usability of the abstract syntax, this definition format integrates additional concepts like associations and inheritance into the well-understood grammar-based approach. modularity concepts like language inheritance and embedding are used to simplify the development of languages based on already existing ones. in addition, the generation of editors and a template approach for code generation is explained.
amida: a sequence diagram extraction toolkit supporting automatic phase detection. amida is a toolkit to record an execution trace of a java program and visualize the trace as a sequence diagram. amida supports our novel approach to efficiently detecting phases; the algorithm precisely divides a long execution trace into a series of smaller diagrams corresponding to features (or tasks to achieve a feature) without deep knowledge on a target system.
a model transformation tool for performance simulation of complex uml models. we present a tool that automatically translates uml2 models of service-oriented systems to models for performance evaluation by a commercial simulator. the strength of our tool lies in its support for complex behaviors, which is made possible by a rich intermediate metamodel with clear operational semantics.
international workshop on multicore software engineering (iwmse 2008). we have reached a major turning point: microprocessor performance can no longer be improved by increasing clock frequencies; instead, higher performance will have to come from parallelism. as multi/manycore processors with multiple cpus on a chip become standard and affordable for everyone, software engineers face the challenge of parallelizing applications of all sorts. however, compared to sequential applications, our repertoire of tools and methods for cost-effectively developing reliable, parallel applications is spotty. the mission of this workshop is to bring together researchers and practitioners with diverse backgrounds in order to advance the state of the art in software engineering for multi/manycore parallel applications. this is the first workshop specifically focusing on software engineering challenges of multi/manycore.
constructing difference tools for models using the sidiff framework. model-driven development requires a full set of development tools. while technologies for constructing graphical editors, compilers etc. are readily available, there is a lack of approaches for constructing version management tools which compare models and show their difference. the general problem is aggravated by the fact that such tools must consider the semantics of each particular model (or diagram) type, i.e. a whole family of tools needs to be constructed. this research demonstration shows how such families of difference tools can be constructed using the sidiff framework.
pacc starter kit: developing software with predictable behavior. the pacc starter kit is an eclipse-based development environment that combines a model-driven development approach with reasoning frameworks that apply performance, safety, and security analyses. these analyses predict runtime behavior based on specifications of component behavior and are accompanied by some measure of confidence.
modelscope: inspecting executable models during run-time. this paper presents a software tool called modelscope which is a co-debugging platform that, during run-time, allows insight into a model running on various different target systems with different views and diagrams for different aspects of the run-time state.