Search

A core goal of Continuous Integration (CI) is to make small incremental changes to software projects, which are integrated frequently into a mainline repository or branch. This paper presents an empirical study that investigates if developers adjust their commit activity towards the above-mentioned goal after projects start using CI. We analyzed the commit and merge activity in 93 GitHub projects that introduced the hosted CI system Travis CI, but have previously been developed for at least one year before introducing CI. In our analysis, we only found one non-negligible effect, an increased merge ratio, meaning that there were more merging commits in relation to all commits after the projects started using Travis CI. This effect has also been reported in related work. However, we observed the same effect in a random sample of 60 GitHub projects not using CI. Thus, it is unlikely that the effect is caused by the introduction of CI alone. We conclude that: (1) in our sample of projects, the introduction of CI did not lead to major changes in developers' commit activity, and (2) it is important to compare the commit activity to a baseline before attributing an effect to a treatment that may not be the cause for the observed effect., 7 pages, 3 figures, Proceedings of the 4th ACM SIGSOFT International Workshop on Software Analytics (SWAN 2018)

Zusammenfassung Der Simulation kommt im Rahmen einer durchgehenden digitalen Fabrikplanung immer größere Bedeutung zu. Eine Möglichkeit, die Qualität sowie Termintreue bei der Erstellung von automatisierten fertigungstechnischen Anlagen sicherzustellen, stellt die virtuelle Inbetriebnahme (VIBN) dar. Der dafür notwendige Modellbildungsprozess ist jedoch oftmals mit hohen Aufwänden verbunden. Der Beitrag zeigt, wie sich dieser Aufwand durch eine automatische Simulationsmodellgenerierung minimieren lässt.

Stack Overflow (SO) is the most popular question-and-answer website for software developers, providing a large amount of copyable code snippets. Using those snippets raises maintenance and legal issues. SO's license (CC BY-SA 3.0) requires attribution, i.e., referencing the original question or answer, and requires derived work to adopt a compatible license. While there is a heated debate on SO's license model for code snippets and the required attribution, little is known about the extent to which snippets are copied from SO without proper attribution. We present results of a large-scale empirical study analyzing the usage and attribution of non-trivial Java code snippets from SO answers in public GitHub (GH) projects. We followed three different approaches to triangulate an estimate for the ratio of unattributed usages and conducted two online surveys with software developers to complement our results. For the different sets of projects that we analyzed, the ratio of projects containing files with a reference to SO varied between 3.3% and 11.9%. We found that at most 1.8% of all analyzed repositories containing code from SO used the code in a way compatible with CC BY-SA 3.0. Moreover, we estimate that at most a quarter of the copied code snippets from SO are attributed as required. Of the surveyed developers, almost one half admitted copying code from SO without attribution and about two thirds were not aware of the license of SO code snippets and its implications., Comment: 44 pages, 8 figures, Empirical Software Engineering (Springer)

Sketching is an important activity for understanding, designing, and communicating different aspects of software systems such as their requirements or architecture. Often, sketches start on paper or whiteboards, are revised, and may evolve into a digital version. Users may then print a revised sketch, change it on paper, and digitize it again. Existing tools focus on a paperless workflow, i.e., archiving analog documents, or rely on special hardware - they do not focus on integrating digital versions into the analog-focused workflow that many users follow. In this paper, we present the conceptual design and a prototype of LivelySketches, a tool that supports the "round-trip" lifecycle of sketches from analog to digital and back. The proposed workflow includes capturing both analog and digital sketches as well as relevant context information. In addition, users can link sketches to other related sketches or documents. They may access the linked artifacts and captured information using digital as well as augmented analog versions of the sketches. We further present results from a formative user study with four students and outline possible directions for future work., Comment: 5 pages, 4 figures, 2017 IEEE Working Conference on Software Visualization (VISSOFT 2017), IEEE, 2017

Stack Overflow (SO) is the largest Q&A website for developers, providing a huge amount of copyable code snippets. Using these snippets raises various maintenance and legal issues. The SO license requires attribution, i.e., referencing the original question or answer, and requires derived work to adopt a compatible license. While there is a heated debate on SO's license model for code snippets and the required attribution, little is known about the extent to which snippets are copied from SO without proper attribution. In this paper, we present the research design and summarized results of an empirical study analyzing attributed and unattributed usages of SO code snippets in GitHub projects. On average, 3.22% of all analyzed repositories and 7.33% of the popular ones contained a reference to SO. Further, we found that developers rather refer to the whole thread on SO than to a specific answer. For Java, at least two thirds of the copied snippets were not attributed., 3 pages, 1 figure, Proceedings of the 39th International Conference on Software Engineering Companion (ICSE-C 2017), IEEE, 2017, pp. 161-163

Crowdsourcing offers great potential to overcome the limitations of controlled lab studies. To guide future designs of crowdsourcing-based studies for visualization, we review visualization research that has attempted to leverage crowdsourcing for empirical evaluations of visualizations. We discuss six core aspects for successful employment of crowdsourcing in empirical studies for visualization – participants, study design, study procedure, data, tasks, and metrics & measures. We then present four case studies, discussing potential mechanisms to overcome common pitfalls. This chapter will help the visualization community understand how to effectively and efficiently take advantage of the exciting potential crowdsourcing has to offer to support empirical visualization research.

In systems which are sourcing their electric energy from a battery system, such as electric or hybrid electric vehicles, it is of crucial importance to monitor the battery’s condition in order to ensure its usability and longevity. The battery management system (BMS) is a control unit which supervises the physical variables in order to assess the condition of the battery. For the development and testing of control units in the automotive industry, such as the BMS, the AUTOSAR standard was introduced, which separates application code from platform-specific software. By using AUTOSAR tools and the model exchange via the Functional Mock-up Interface (FMI), this paper shows how BMS algorithms can be validated and tested in several abstraction layers. A sub-function of the algorithm is tested first in the Modelica-based system simulation tool Dymola on a personal computer and then on Hardware-in-the-Loop (HiL) platform which emulates the hardware of an automotive ECU. In order to provide realistic inputs of the physical variables, a battery model in Modelica is built using the Dymola add-on Battery Library by Dassault Systemes. In order to run on the HiL platform the battery model is implemented such that it is real-time compliant. For both, the BMS algorithm and the battery model, it is described along the process which adjustments need to be made when switching from the simulation framework to the HiL platform.

Visualization is a powerful tool. It can play a crucial role when it comes to generating hypotheses or presenting results. Visualization should become an integral part of your analysis process. You can use it to clean the data before the actual analysis. During the analysis, it can help you to see the unexpected and to generate hypotheses for further analysis. Finally, you can combine different kinds of visualizations to tell a story about your data and present your findings to others.

Humans are very efficient in processing and remembering visual information. That is why metaphors and visual representations are important in education. Because of their high visual expressiveness, presentation tools like Microsoft PowerPoint are very popular for teaching in classrooms. However, representing source code with such tools is tedious and cumbersome, while alternatives like source code editors lack visual expression. Moreover, modifying prepared content, e.g. while responding to questions, is not well supported. In this paper, we introduce VisualCues, an approach with the goal of combining the flexibility of source code editors with the visual expressiveness of classical slide-based presentation tools. A key concept of VisualCues is linking visual artifacts to specific elements of source code. The main advantage is that when changing the underlying source code, the positions of linked visual artifacts are changed simultaneously. We implemented a first prototype and evaluated it in two undergraduate computer science courses.

This paper introduces a novel proposal on how to parameterize models with data, taking a subsequent model export into account, using e.g. the Functional Mock-Up Interface (FMI). During model export parameters are either assigned with values directly or they are linked to external data-files. If the design of models or libraries is done without considering how data is handled in an exported model, those concepts are often mixed, resulting in an inconsistent data management which is cumbersome or even error prone for the user.

In this paper we introduce a visual representation of Java objects that can be used for observing and manipulating behavior and state of currently developed classes. It runs separately, e.g., on a tablet, beside an integrated development environment. Within the visualization, developers are able to arbitrarily change the object state, then invoke any method with custom parameters and observe how the object state changes. When changing the source code of the related class, the visualization holds the previous object state and adapts the new behavior defined by the underlying source code. This instantly enables developers to observe functionalities objects of a certain class have and how they manipulate their state, and especially, how source code changes influence their behavior. We implemented a first prototype as a touch-enabled web application that is connected to a conventional integrated development environment. In order to gain first practical insights, we evaluated our approach in a pilot user study.

In a selective retrospective of the history of software visualization we discuss examples of applying visualization techniques to analyze the past and present state of software. Based on this retrospective, we make various suggestions for future research. In particular, we argue that the prediction of future aspects of a software system is an important task, but that software visualization research has only scratched the surface of it and that speculative visualization will be one of the major future challenges.