Search

Stack Overflow (SO) is the most popular question-and-answer website for software developers, providing a large amount of code snippets and free-form text on a wide variety of topics. Like other software artifacts, questions and answers on SO evolve over time, for example when bugs in code snippets are fixed, code is updated to work with a more recent library version, or text surrounding a code snippet is edited for clarity. To be able to analyze how content on SO evolves, we built SOTorrent, an open dataset based on the official SO data dump. SOTorrent provides access to the version history of SO content at the level of whole posts and individual text or code blocks. It connects SO posts to other platforms by aggregating URLs from text blocks and by collecting references from GitHub files to SO posts. In this paper, we describe how we built SOTorrent, and in particular how we evaluated 134 different string similarity metrics regarding their applicability for reconstructing the version history of text and code blocks. Based on a first analysis using the dataset, we present insights into the evolution of SO posts, e.g., that post edits are usually small, happen soon after the initial creation of the post, and that code is rarely changed without also updating the surrounding text. Further, our analysis revealed a close relationship between post edits and comments. Our vision is that researchers will use SOTorrent to investigate and understand the evolution of SO posts and their relation to other platforms such as GitHub., 12 pages, 9 figures, 15th International Conference on Mining Software Repositories (MSR 2018), ACM, 2018

Background: Reaching out to professional software developers is a crucial part of empirical software engineering research. One important method to investigate the state of practice is survey research. As drawing a random sample of professional software developers for a survey is rarely possible, researchers rely on various sampling strategies. Objective: In this paper, we report on our experience with different sampling strategies we employed, highlight ethical issues, and motivate the need to maintain a collection of key demographics about software developers to ease the assessment of the external validity of studies. Method: Our report is based on data from two studies we conducted in the past. Results: Contacting developers over public media proved to be the most effective and efficient sampling strategy. However, we not only describe the perspective of researchers who are interested in reaching goals like a large number of participants or a high response rate, but we also shed light onto ethical implications of different sampling strategies. We present one specific ethical guideline and point to debates in other research communities to start a discussion in the software engineering research community about which sampling strategies should be considered ethical., Comment: 6 pages, 2 figures, Proceedings of the 2016 ACM/IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM 2016), ACM, 2016

Sketches and diagrams play an important role in the daily work of software developers. In this paper, we investigate the use of sketches and diagrams in software engineering practice. To this end, we used both quantitative and qualitative methods. We present the results of an exploratory study in three companies and an online survey with 394 participants. Our participants included software developers, software architects, project managers, consultants, as well as researchers. They worked in different countries and on projects from a wide range of application areas. Most questions in the survey were related to the last sketch or diagram that the participants had created. Contrary to our expectations and previous work, the majority of sketches and diagrams contained at least some UML elements. However, most of them were informal. The most common purposes for creating sketches and diagrams were designing, explaining, and understanding, but analyzing requirements was also named often. More than half of the sketches and diagrams were created on analog media like paper or whiteboards and have been revised after creation. Most of them were used for more than a week and were archived. We found that the majority of participants related their sketches to methods, classes, or packages, but not to source code artifacts with a lower level of abstraction., Comment: 12 pages, 2 figures, Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering (FSE 2014), ACM, 2014, pp. 530-541

Recent studies have shown that sketches and diagrams play an important role in the daily work of software developers. If these visual artifacts are archived, they are often detached from the source code they document, because there is no adequate tool support to assist developers in capturing, archiving, and retrieving sketches related to certain source code artifacts. This paper presents SketchLink, a tool that aims at increasing the value of sketches and diagrams created during software development by supporting developers in these tasks. Our prototype implementation provides a web application that employs the camera of smartphones and tablets to capture analog sketches, but can also be used on desktop computers to upload, for instance, computer-generated diagrams. We also implemented a plugin for a Java IDE that embeds the links in Javadoc comments and visualizes them in situ in the source code editor as graphical icons., 4 pages, 4 figures, Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering (FSE 2014), ACM, 2014, pp. 743-746

In software engineering the comparison of graph-based models is a well-known problem. Although different comparison metrics have been proposed, there are situations in which automatic or pre-configured approaches do not provide reasonable results. Especially when models contain semantic similarities or differences, additional human knowledge is often required. However, only few approaches tackle the problem of how to support humans when comparing models.In this paper, we propose a tool for interactive model comparison. Its design was informed by a set of guidelines that we identified in previous work. In particular, our prototype leverages visual dataflow programming to allow users to implement custom comparison strategies. To this end, they can combine metrics and graph operations to compute similarities and differences, and use color coding to visualize the gained results. Additionally, a qualitative user study allowed to assess whether and how our tool facilitates iterative exploration of similarities and differences between models.

Touch gestures are not only often very intuitive, but their direct manipulation characteristics also help to reduce the cognitive load. Since software development poses complex cognitive demands, our goal is to exploit the advantages of direct manipulation to support professional software engineering processes. In this paper, we demonstrate how touch gestures can be used within a professional integrated development environment. As for that, we have enriched the Eclipse IDE with common and invertible multi-touch gestures which can be used for both controlling the graphical user interface and triggering built-in refactoring tools. The design of our extensions was informed by an early user study revealing problems of using the Eclipse IDE with the default touch support provided by the operating system. By using the emerging prototype during its implementation, we were able to iteratively improve the prototype based on our own experience and gain first insights into the potential of using direct manipulation methods within the IDE. First results suggest that using an additional touch device within the classical desktop setup enables a precise and fast work flow.

During early phases of a software development process co-located group work is an important technique that involves all stakeholders to derive requirements and a design of a future software system. However, such group work is usually applied without any computer-assistance and often faces the problem that information is not well preserved for subsequent steps. In order to examine whether group work benefits from computer-assistance, we developed CREWSpace. It leverages mobile devices to allow simultaneous interaction with a shared software model. In particular, it implements a digital variant of the CRC method. In this paper, we discuss advantages and disadvantages of the traditional CRC method, briefly introduce CREWSpace along with important implementation details, and focus on a qualitative usability study. Its results suggest that our prototype keeps the advantages of traditional CRC method and compensates many of its weaknesses.

In requirements engineering, CRC modeling and use case analysis are established techniques and are often performed as a group work activity. In particular, role play is used to involve different stakeholders into the use case analysis. To support this kind of co-located collaboration we developed CREW-Space, which allows several users to simultaneously interact through Android-enabled mobile devices with the same model displayed on a shared screen. Furthermore, it keeps track of the current state of the role play and, in addition, each mobile device serves as a private workspace; it actually turns into a tangible digital CRC card.

Software systems are modularized to make their inherent complexity manageable. While there exists a set of well-known principles that may guide software engineers to design the modules of a software system, we do not know which principles are followed in practice. In a study based on 16 open source projects, we look at different kinds of coupling concepts between source code entities, including structural dependencies, fan-out similarity, evolutionary coupling, code ownership, code clones, and semantic similarity. The congruence between these coupling concepts and the modularization of the system hints at the modularity principles used in practice. Furthermore, the results provide insights on how to support developers to modularize software systems.

Identifying refactorings in software archives has been an active research topic in the last decade, mainly because it is a prerequisite for various software evolution analyses (e.g., error detection, capturing intent of change, capturing and replaying changes, and relating refactorings and software metrics). Many of these techniques rely on similarity measures to identify structurally equivalent code, however, up until now the effect of this similarity measure on the performance of the refactoring identification algorithm is largely unexplored. In this paper we replicate a well-known experiment from Weisgerber and Diehl, plugging in three different similarity measures (text-based, AST-based, token-based). We look at the overlap of the results obtained by the different metrics, and we compare the results using recall and the computation time. We conclude that the different result sets have a large overlap and that the three metrics perform with a comparable quality.

In this paper, we present CREWW, a tool for co-located, collaborative CRC modeling and use case analysis. In CRC sessions role play is used to involve all stakeholders when determining whether the current software model completely and consistently captures the modeled use case. In this activity it quickly becomes difficult to keep track of which class is currently active or along which path the current state was reached. CREWW was designed to alleviate these and other weaknesses of the traditional approach.

Reverse engineering methods produce different descriptions of software architectures. In this article we address the task of exploring and comparing these descriptions. We present a novel visualization technique to compare architectures consisting of a decomposition of the software system and the dependencies among the code entities. This technique uses a visual representation of an adjacency matrix to provide a scalable analysis tool. Advanced layout features such as an automatic level of detail algorithm and sorting strategies improve the readability of the visualization. Using a case study, we show how this technique can be applied in practice.

Code clone detection is an enabling technology for plenty of applications, each having different requirements for a code clone detector. In the tool demonstration we present JCCD, a code clone detection API, which is based on a pipeline model. By combining and parameterizing predefined API components as well as by adding new components, the pipeline model does not only facilitate to build new custom code clone detectors, but also to parallelize the detection process.

In business as well as science a clear and professional presentation of quantitative information is often required and helps to efficiently communicate new insights. The predominant approach is to integrate charts into slide shows created with standard presentation programs. In this paper, we introduce the chart flight metaphor for visualizing spatially distributed statistical data as a computer-generated three-dimensional camera flight over a map with animated charts. Our web application leverages the Blender 3D modeling and animation tool to allow end users to submit their data sets, and easily generate chart flight videos without profound knowledge of computer graphics methods and systems. The generated videos can be included into slide show presentations, put on web pages or shared via file hosting sites, and even displayed on low-performance hardware devices like mobile phones or netbooks.

In many applications transactions between the elements of an information hierarchy occur over time. For example, the product offers of a department store can be organized into product groups and subgroups to form an information hierarchy. A market basket consisting of the products bought by a customer forms a transaction. Market baskets of one or more customers can be ordered by time into a sequence of transactions. Each item in a transaction is associated with a measure, for example, the amount paid for a product.In this paper we present a novel method for visualizing sequences of these kinds of transactions in information hierarchies. It uses a tree layout to draw the hierarchy and a timeline to represent progression of transactions in the hierarchy. We have developed several interaction techniques that allow the users to explore the data. Smooth animations help them to track the transitions between views. The usefulness of the approach is illustrated by examples from several very different application domains.

Software development is heavily dependent on the participants of the process and their roles within the process. Each developer has his specific skills and interests and hence contributes to the project in a different way. While some programmers work on separate modules, others developers integrate these modules towards the final product. To identify such different groups of people one approach is to work with methods taken from social network analysis. To this end, a social network has to be defined in a suitable way, and appropriate analysis strategies have to be chosen. This paper shows how a network of software developers could be defined based on information in a software repository, and what it can possibly tell about roles of developers (and what not) in the process of the application server Tomcat.

In this paper we combine the results of our refactoring reconstruction technique with bug, mail and release information to perform process and bug analyses of the ARGOUML CVS archive.

Refactorings are program transformations which should preserve the program behavior. Consequently, we expect that during phases when there are mostly refactorings in the change history of a system, only few new bugs are introduced. For our case study we analyzed the version histories of several open source systems and reconstructed the refactorings performed. Furthermore, we obtained bug reports from various sources depending on the system. Based on this data we identify phases when the above hypothesis holds and those when it doesn't.

Software repositories such as source control systems,defect tracking systems,or archived communications between project personnel are used to help manage the progress of software projects.Software practitioners and researchers are beginning to recognize the potential bene .t of mining this information to support the maintenance of software systems,improve software design/reuse,and empirically validate novel ideas and techniques.Research is now proceeding to uncover the ways in which mining these repositories can help to understand software development,to support predictions about software development,and to plan various aspects of software projects.Following the success of the first two iterations of the MSR workshop in 2004 and 2005,MSR 2006 attracted even more submissions:We received 45 papers from 15 different countries.The international program committee accepted 16 full and 12 short papers for presentation at the workshop and inclusion in the proceedings.We are grateful for the excellent and professional review job done by the reviewers on such a tight schedule.

Software archives contain historical information about the development process of a software system. Using data mining techniques rules can be extracted from these archives. In this paper we discuss how standard visualization techniques can be applied to interactively explore these rules. To this end we extended the standard visualization techniques for association rules and sequence rules to also show the hierarchical order of items. Clusters and outliers in the resulting visualizations provide interesting insights into the relation between the temporal development of a system and its static structure. As an example we look at the large software archive of the MOZILLA open source project. Finally we discuss what kind of regularities and anomalies we found and how these can then be leveraged to support software engineers.

Manufacturers rarely provide information about their products as CAD data, not to mention even 3D animations. Thus, it is desirable for example for the products of an online store to have the possibility to describe and record products in a simple way. This paper deals with visualizing product components by means of Java and Java3D and recording this data in an XML based data format. With the help of this data format 3D-objects can be reconstructed and reused. We explain how a product configuration which may later be shown as an animation can be constructed. Here, the central issues are the representation of the product components in the scenegraph and connecting them according to their physical relation in reality.

In this paper we discuss the benefits of extending VRML by constraints and present a new way based on prototypes and scripting to implement this extension. Our approach is easy-to-use, extensible and it considerably increases the expressivity of VRML. Our implementation supports one-way equational and finite domain constraints. We demonstrate the use of these constraints by means of several examples. Finally we argue that in the long run constraints should become an integral part of VRML.