waashk/dblp huggingface dataset:
making defect-finding tools work for you. given the high costs of software testing and fixing bugs after release, early detection of bugs using static analysis can result in significant savings. however, despite their many benefits, recent availability of many such tools, and evidence of a positive return-on-investment, static-analysis tools are not used widely because of various usability and usefulness problems. the usability inhibitors include the lack of features, such as capabilities to merge reports from multiple tools and view warning deltas between two builds of a system. the usefulness problems are related primarily to the accuracy of the tools: identification of false positives (or, spurious bugs) and uninteresting bugs among the true positives. in this paper, we present the details of an online portal, developed at ibm research, to address these problems and promote the adoption of static-analysis tools. we report our experience with the deployment of the portal within the ibm developer community. we also highlight the problems that we have learned are important to address, and present our approach toward solving some of those problems.
predicting build outcome with developer interaction in jazz. investigating the human aspect of software development is becoming prominent in current research. studies found that the misalignment between the social and technical dimensions of software work leads to losses in developer productivity and defects. we use the technical and social dependencies among pairs of developers to predict the success of a software build. using the ibm jazz&trade; data we found information about developers and their social and technical relation can build a powerful predictor for the success of a software build. investigating human aspects of software development is becoming prominent in current research. high misalignment between the social and technical dimensions of software work lowers productivity and quality.
mining software engineering data. software engineering data (such as code bases, execution traces, historical code changes, mailing lists, and bug databases) contains a wealth of information about a project's status, progress, and evolution. using well-established data mining techniques, practitioners and researchers have started exploring the potential of this valuable data in order to better manage their projects and to produce higher quality software systems that are delivered on time and within budget. this tutorial presents the latest research in mining software engineering data, discusses challenges associated with mining software engineering data, highlights success stories of mining software engineering data, and outlines future research directions. attendees will acquire the knowledge and skills needed to integrate the mining of software engineering data in their own research or practice. this tutorial builds on several successful offerings at icse since 2007.
towards better support for the evolution of safety requirements via the model monitoring approach. the research is motivated by the challenge from the evolution of safety requirements, which leads to revision of system designs at design-time or post-implementation at a high cost. this paper proposes a complementary methodology, namely the model monitoring approach, to better support the evolution throughout the life-cycle at a lower cost.
choreography of intelligent e-services. electronic services (e-services), referred to as a set of automated enterprise services using ict to achieve a business goal, have significantly contributed to the growth of e-commerce, science, and telecommunications. however, applications that use e-services seldom interoperate effectively, and this restricts the benefits they offer. the main purpose of e-services is to have an anthology of network-resident software services accessed via standardised protocols whose meaning can be regularly discovered and integrated into applications. our study supplements the definition provided for e-service by complementing it with an intelligent capability for the purpose of effective and efficient choreography of processes, hence the term "intelligent e-services". the aim of the study is to propose the composition of intelligent e-services in a manner which encourages the interoperability of a range of services pertaining to various autonomous virtual enterprises (ves). it is expected that a framework that defines and supports the composition of intelligent e-services will be formed. it is also anticipated that the study will play an important role in contributing to the formation of dynamic virtual enterprises (dves) as an application business scenario.
adinda: a knowledgeable, browser-based ide. in practice, many people have to work together to develop and maintain a software system. however, the programmer's key tool, the integrated development environment (ide), is a solo-tool, serving to help individual programmers understand and modify the system. such an ide does not leverage the knowledge other team members may have of the design and implementation of the system. we propose to resolve this problem by exploring, experimentally, new ways of inferring knowledge from past ide-interactions, and of maximizing collaboration among developers. our approach, called adinda, revolves around transforming the ide into a set of integrated services, accessible via a web browser, and enriched with web 2.0 technologies. such services will not only help developers perform traditional ide tasks, but also facilitate the required informal communication and collaboration needs of software development projects. in this paper, we report on our vision, approach and challenges for building adinda, and initial results.
stakesource: harnessing the power of crowdsourcing and social networks in stakeholder analysis. projects often fail because they overlook stakeholders. unfortunately, existing stakeholder analysis tools only capture stakeholders' information, relying on experts to manually identify them. stakesource is a web-based tool that automates stakeholder analysis. it "crowdsources" the stakeholders themselves for recommendations about other stakeholders and aggregates their answers using social network analysis.
syde: a tool for collaborative software development. team collaboration is essential for the success of multi-developer projects. when team members are spread across different locations, individual awareness of the activity of others drops due to communication barriers. we built syde, a tool infrastructure to reestablish team awareness by sharing change and conflict information across developer's workspaces. our main challenge is to balance the tradeoff between offering relevant information about the activity of the team and avoiding information overload. the novelty of our approach is that we model source code changes as first-class entities to record the detailed evolution of a multi-developer project. hence, syde delivers precise change information to interested developers.
formalization and validation of a subset of the european train control system. the european train control system (etcs) is a control system for the interoperability of the railways across europe. in this paper, we report on the activities of the eurailcheck project, promoted by the european railway agency, for the development of a methodology and tools for the formalization and validation of the etcs specifications. within the project, we achieved three main results. first, we developed a methodology for the formalization and validation of the etcs specifications. the methodology is based on a three-phases approach that goes from the informal analysis of the requirements, to their formalization and validation. second, we developed a set of support tools, covering the various phases of the methodology. third, we formalized a realistic subset of the specification in an industrial setting. the results of the project were positively evaluated by domain experts from different manufacturing and railway companies.
multicore software engineering: the next challenge in software engineering. due to stagnating clock rates, future increases in processor performance will have to come from parallelism. inexpensive multicore processors with several cores on a chip have become standard in pcs, laptops, servers, and embedded devices will follow; manycore chips with hundreds of processors on a single chip are predicted. software engineers are now asked to write parallel applications of all sorts, and need to quickly grasp the relevant aspects of general-purpose parallel programming. this tutorial at icse 2010 prepares them for this challenge.
cooperative and human aspects of software engineering (chase 2010). software is created by people---software engineers---working in varied environments, under various conditions. thus understanding cooperative and human aspect of software development is crucial to comprehend how methods and tools are used, and thereby improving the creation and maintenance of software. inspired by the hosting country's concept of co-responsibility -- ubuntu -- we especially invited contributions that address community-based development like open source development and sustainability of ict eco-systems. the goal of this workshop is to provide a forum for discussing high quality research on human and cooperative aspects of software engineering. we aim at providing both a meeting place for the growing community and the possibility for researchers interested in joining the field to present their work in progress and get an overview over the field.
the small project observatory: a tool for reverse engineering software ecosystems. software evolution researchers have focused mostly on analyzing single software systems. however, often projects are developed and co-exist within software ecosystems, i.e., the larger contexts of companies, research groups or open-source communities. we present the small project observatory, a web-based analysis platform for ecosystem reverse engineering through interactive visualization and exploration.
legacy component integration by the fujaba real-time tool suite. we present a tool suite which supports the (re-)construction of a behavioral model of a legacy component based on a learning approach by exploiting knowledge of known models of the existing component environment. this in turn enables to check whether the legacy component can be integrated correctly into its environment.
balancing collaboration and discipline in software development processes. neither traditional, agile or free/open software development models can be effective to all projects contexts. we claim that collaboration and discipline can be the driver to tailor software development processes to meet projects and organizations needs. this work proposes that process tailoring can be conducted through a context management approach.
commit 2.0: enriching commit comments with visualization. software developers use commit comments to document changes and as a mean of communication in their team. however, the support given by ides is restricted with this respect, as they limit the users to use only text to document changes. in this paper we propose and implement an approach to enrich commit comments with software visualization: commit 2.0 generates visualizations of the performed changes at different granularity levels, and let the user enrich them with annotations.
qed: a proof system based on reduction and abstraction for the static verification of concurrent software. we present a proof system and supporting tool, qed, for the static verification of concurrent software. our key idea is to simplify the verification of a program by rewriting it with larger atomic actions. we demonstrated the simplicity and effectiveness of our approach on benchmarks with intricate synchronization.
capturing the long-term impact of changes. developers change source code to add new functionality, fix bugs, or refactor their code. many of these changes have immediate impact on quality or stability. however, some impact of changes may become evident only in the long term. the goal of this thesis is to explore the long-term impact of changes by detecting dependencies between code changes and by measuring their influence on software quality, software maintainability, and development effort. being able to identify the changes with the greatest long-term impact will strengthen our understanding of a project's history and thus shape future code changes and decisions.
automatic enforcement of architectural design rules. current techniques for modeling software architecture lacks support for the modeling of architectural design rules, i.e. rules defined by the architect that have to be followed in the detailed design. this is a problem in the context of model-driven development in which it is assumed that major design artifacts are represented as formal or semi-formal models. the phd project presented in this paper addresses this problem by the definition of a method for modeling architectural design rules in a form that is easily interpreted by developers. a tool for automatic validation of the design model against the architectural rules has also been developed. the method is designed to be easy to learn and use for both architects and developers. as a part of the phd project the method is also currently validated in a case study on an industrial development project.
empirical evaluation of effort on composing design models. the importance of model composition in model-centric software development is recognized by researchers and practitioners. however, the lack of empirical evidence about the impact of model composition techniques on developers' effort is a key impairment for their adoption in real-world design settings. software engineers are left without any guidance on how to properly use certain model techniques in a way that effectively reduces their development effort. this work aims to address this problem by: (1) providing empirical evidence on model composition effort through a family of experimental studies; (2) defining quantitative indicators to objectively assess key attributes of model composition effort; (3) deriving a method to support the systematic application of composition techniques; and (4) conceiving a new model composition technique to overcome the problems identified throughout the experimental evaluations.
risk assessment on distributed software projects. risk assessment is a growing discipline on the context of distributed software projects. the complexity to develop software and the related knowledge require automated support for project managers in order to analyze actions to reduce the project's risks and measure the impact of such actions. my thesis aims to investigate an approach for the assessment of risks in globally distributed software projects. this research proposes to apply stochastic simulation technique to analyze project data and identify factors that are likely to impact team productivity and that could affect the team's ability to meet its schedule objective. we aim this thesis to be applied by project management groups to perform risk assessment early in the software development process and to help decision-making process.
helios: impact analysis for event-based components and systems. the event-based software architectural style [4] is widely used in the domain of user-interface software and wide-area applications (e.g., financial markets, logistics, and sensor networks). a gartner study determined that the market size for message-oriented (a.k.a event-based) middleware licenses was about $1 billion in 2005 [2]. in event-based systems, components do not directly call other components, but rather indirectly using messages or events. however, this high decoupling and use of implicit invocations render an event-based system more difficult to analyze since, in the absence of explicit dependency information, an engineer has to assume that any component in the system may potentially interact with, and thus depend on, any other component.
knowledge transfer in global software development: leveraging acceptance test case specifications. 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.
using dynamic execution traces and program invariants to enhance behavioral model inference. software behavioral models have proven useful for design, validation, verification, and maintenance. however, existing approaches for deriving such models sometimes overgeneralize what behavior is legal. we outline a novel approach that utilizes inferred likely program invariants and method invocation sequences to obtain an object-level model that describes legal execution sequences. the key insight is using program invariants to identify similar states in the sequences. we exemplify how our approach improves upon certain aspects of the state-of-the-art fsa-inference techniques.
zenet: generating and enforcing real-time temporal invariants. generating correct specifications for real-time event-driven software systems is difficult and time-consuming. even when such specifications have been created, they are often used to guide development rather than state properties guaranteed by the actual system. we propose a specification generator that reads execution traces and can generate invariants with real-time constraints. that specification can also offer programmers the ability to repair violated invariants at runtime. creating fault-tolerant systems in this manner would provide software engineers guarantees about the software's high-level operation and its ability to recover from errors.
integrating legacy systems with mde. integrating several legacy software systems together is commonly performed with multiple applications of the adapter design pattern in oo languages such as java. the integration is based on specifying bi-directional translations between pairs of apis from different systems. yet, manual development of wrappers to implement these translations is tedious, expensive and error-prone. in this paper, we explore how models, aspects and generative techniques can be used in conjunction to alleviate the implementation of multiple wrappers. briefly the steps are, (1) the automatic reverse engineering of relevant concepts in apis to high-level models; (2) the manual definition of mapping relationships between concepts in different models of apis using an ad-hoc dsl; (3) the automatic generation of wrappers from these mapping specifications using aop. this approach is weighted against manual development of wrappers using an industrial case study. criteria are the relative code length and the increase of automation.
new horizons in multicore software engineering. this paper provides a summary of the third international workshop on multicore software engineering (iwmse 2010). motivated by multicore and manycore processors that are available on every desktop, software engineers need to exploit parallelism to make applications run faster. at the same time, programmers are facing many challenges due to the complexity of parallel programming. the workshop brought together researchers and practitioners to advance the state-of-the-art in software engineering for multicore and manycore systems. the contributions covered topics ranging from programming models, performance engineering, parallel patterns, fault-tolerance, to testing.
parameterized unit testing: theory and practice. unit testing has been widely recognized as an important and valuable means of improving software reliability, as it exposes bugs early in the software development life cycle. however, manual unit testing is often tedious and insufficient. testing tools can be used to enable economical use of resources by reducing manual effort. recently parameterized unit testing has emerged as a very promising and effective methodology to allow the separation of two testing concerns or tasks: the specification of external, black-box behavior (i.e., assertions or specifications) by developers and the generation and selection of internal, white-box test inputs (i.e., high-code-covering test inputs) by tools. a parameterized unit test (put) is simply a test method that takes parameters, calls the code under test, and states assertions. puts have been supported by various testing frameworks. various open source and industrial testing tools also exist to generate test inputs for puts. this tutorial presents latest research on principles and techniques, as well as practical considerations to apply parameterized unit testing on real-world programs, highlighting success stories, research and education achievements, and future research directions in developer testing. the tutorial will help improve developer skills and knowledge for writing puts and give overview of tool automation in supporting puts. attendees will acquire the skills and knowledge needed to perform research or conduct practice in the field of developer testing and to integrate developer testing techniques in their own research, practice, and education.
informal software design knowledge reuse. in this paper, i describe a novel approach for developing and evaluating an infrastructure for supporting informal knowledge capture, representation, and reuse during software design meetings. it is the goal of this work to address the challenges that exist in reusing knowledge while at the whiteboard. the research centers on the design and evaluation of designminders, a tool that augments electronic whiteboards to support the capture and exploration of knowledge using electronic note cards, which can be used over time to preserve knowledge generated during past sessions. the tool will be analyzed in an evaluation that will compare designs produced by two teams, one using designminders and one not.
2010 icse 2nd international workshop on principles of engineering service-oriented systems (pesos 2010). service-oriented systems have attracted great interest from industry and research communities worldwide. service integrators, developers, and providers are collaborating to address the various challenges in the field. pesos 2010 is a forum for all these communities to present and discuss a wide range of topics related to service-oriented systems. the goal of pesos was to bring together researchers from academia and industry, as well as practitioners working in the areas of software engineering and service-oriented systems to discuss research challenges, recent developments, novel applications, as well as methods, techniques, experiences, and tools to support the engineering and use of service-oriented systems.