Arie van Deursen

Delft University of Technology, Delft, South Holland, Netherlands

Are you Arie van Deursen?

Claim your profile

Publications (225)45.13 Total impact

  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: Teamwork in software engineering is time-consuming and problematic. In this paper, we explore how to better sup-port developers' collaboration in teamwork, focusing on the software implementation phase happening in the integrated development environment (IDE). Conducting a qualitative in-vestigation, we learn that developers' teamwork needs mostly regard coordination, rather than concurrent work on the same (sub)task, and that developers successfully deal with scenar-ios considered problematic in literature, but they have prob-lems dealing with breaking changes made by peers on the same project. We derive implications and recommendations. Based on one of the latter, we analyze the current IDE support for receiving code changes, finding that historical information is neither visible nor easily accessible. Consequently, we de-vise and qualitatively evaluate BELLEVUE, the design of an IDE extension to make received changes always visible and code history accessible in the editor.
    CSCW 2015: 18th ACM conference on Computer-Supported Cooperative Work and Social Computing, Vancouver, BC, Canada; 03/2015
  • Arie van Deursen, Ali Mesbah, Alex Nederlof
    [Show abstract] [Hide abstract]
    ABSTRACT: In this paper we review five years of research in the field of automated crawling and testing of web applications. We describe the open source Crawljax tool, and the various extensions that have been proposed in order to address such issues as cross-browser compatibility testing, web application regression testing, and style sheet usage analysis.Based on that we identify the main challenges and future directions of crawl-based testing of web applications. In particular, we explore ways to reduce the exponential growth of the state space, as well as ways to involve the human tester in the loop, thus reconciling manual exploratory testing and automated test input generation. Finally, we sketch the future of crawl-based testing in the light of upcoming developments, such as the pervasive use of touch devices and mobile computing, and the increasing importance of cyber-security.
    Science of Computer Programming 01/2015; 97. DOI:10.1016/j.scico.2014.09.005 · 0.55 Impact Factor
  • Michael W. Godfrey, Arie van Deursen
    Empirical Software Engineering 10/2014; 19(5):1259-1260. DOI:10.1007/s10664-014-9329-5 · 1.64 Impact Factor
  • Eric Bouwers, Arie van Deursen, Joost Visser
    [Show abstract] [Hide abstract]
    ABSTRACT: In the past two decades both the industry and the research community have proposed hundreds of metrics to track software projects, evaluate quality or estimate effort. Unfortunately, it is not always clear which metric works best in a particular context. Even worse, for some metrics there is little evidence whether the metric measures the attribute it was designed to measure. In this paper we propose a catalog format for software metrics as a first step towards a consolidated overview of available software metrics. This format is designed to provide an overview of the status of a metric in a glance, while providing enough information to make an informed decision about the use of the metric. We envision this format to be implemented in a (semantic) wiki to ensure that relationships between metrics can be followed with ease.
  • Georgios Gousios, Martin Pinzger, Arie van Deursen
    [Show abstract] [Hide abstract]
    ABSTRACT: The advent of distributed version control systems has led to the development of a new paradigm for distributed software development; instead of pushing changes to a central repository, developers pull them from other repositories and merge them locally. Various code hosting sites, notably Github, have tapped on the opportunity to facilitate pull-based development by offering workflow support tools, such as code reviewing systems and integrated issue trackers. In this work, we explore how pull-based software development works, first on the GHTorrent corpus and then on a carefully selected sample of 291 projects. We find that the pull request model offers fast turnaround, increased opportunities for community engagement and decreased time to incorporate contributions. We show that a relatively small number of factors affect both the decision to merge a pull request and the time to process it. We also examine the reasons for pull request rejection and find that technical ones are only a small minority.
  • Alex Nederlof, Ali Mesbah, Arie van Deursen
    [Show abstract] [Hide abstract]
    ABSTRACT: Today’s web applications increasingly rely on client-side code execution. HTML is not just created on the server, but manipulated extensively within the browser through JavaScript code. In this paper, we seek to understand the software engineering implications of this. We look at deviations from many known best practices in such areas of performance, accessibility, and correct structuring of HTML documents. Furthermore, we assess to what extent such deviations manifest themselves through client-side code manipulation only. To answer these questions, we conducted a large scale experiment, involving automated client-enabled crawling of over 4000 web applications, resulting in over 100,000,000 pages analyzed, and close to 1,000,000 unique client-side user interface states. Our findings show that the majority of sites contain a substantial number of problems, making sites unnecessarily slow, inaccessible for the visually impaired, and with layout that is unpredictable due to errors in the dynamically modified DOM trees.
  • Nicolas Dintzner, Arie Van Deursen, Martin Pinzger
    [Show abstract] [Hide abstract]
    ABSTRACT: The Linux kernel feature model has been studied as an example of large scale evolving feature model and yet details of its evolution are not known. We present here a classification of feature changes occurring on the Linux kernel feature model, as well as a tool, FMDiff, designed to automatically extract those changes. With this tool, we obtained the history of more than twenty architecture specific feature models, over ten releases and compared the recovered information with Kconfig file changes. We establish that FMDiff provides a comprehensive view of feature changes and show that the collected data contains promising information regarding the Linux feature model evolution.
    Proceedings of the Eighth International Workshop on Variability Modelling of Software-Intensive Systems; 01/2014
  • Felienne Hermans, Martin Pinzger, Arie van Deursen
    Empirical Software Engineering 01/2014; DOI:10.1007/s10664-013-9296-2 · 1.64 Impact Factor
  • Source
    Tao Xie, Thomas Zimmermann, Arie van Deursen
    [Show abstract] [Hide abstract]
    ABSTRACT: Support for generic programming was added to the Java language in 2004, representing perhaps the most significant change to one of the most widely used programming languages today. Researchers and language designers anticipated this addition would relieve ...
    Empirical Software Engineering 12/2013; 18(6). DOI:10.1007/s10664-013-9273-9 · 1.64 Impact Factor
  • [Show abstract] [Hide abstract]
    ABSTRACT: In this paper, we present two descriptive case studies covering the re-engineering and further evolution of adopting service-oriented architecture (SOA) in the industry. The first case was carried out for a company in the transport sector with an application portfolio of over 700 systems. The second case study was conducted for an organization in the public sector. The goal of both case studies is to identify the possible benefits and drawbacks of realizing SOA in large organizations in order to obtain a better perspective on the real, rather than the assumed, benefits of SOA in practice. We describe how the two cases were developed and carried out, and discuss the experiences gained and lessons learned from adopting SOA in the two organizations. Based on these findings, we propose several directions for further research. Copyright © 2011 John Wiley & Sons, Ltd.
    Journal of Software Maintenance and Evolution Research and Practice 06/2013; 25(6). DOI:10.1002/smr.540 · 1.27 Impact Factor
  • Michaela Greiler, Arie van Deursen, M.-A. Storey
    [Show abstract] [Hide abstract]
    ABSTRACT: Designing automated tests is a challenging task. One important concern is how to design test fixtures, i.e. code that initializes and configures the system under test so that it is in an appropriate state for running particular automated tests. Test designers may have to choose between writing in-line fixture code for each test or refactor fixture code so that it can be reused for other tests. Deciding on which approach to use is a balancing act, often trading off maintenance overhead with slow test execution. Additionally, over time, test code quality can erode and test smells can develop, such as the occurrence of overly general fixtures, obscure in-line code and dead fields. In this paper, we show that test smells related to fixture set-up occur in industrial projects. We present a static analysis technique to identify fixture related test smells. We implemented this test analysis technique in a tool, called TestHound, which provides reports on test smells and recommendations for refactoring the smelly test code. We evaluate the tool through three industrial case studies and show that developers find that the tool helps them to understand, reflect on and adjust test code.
    Software Testing, Verification and Validation (ICST), 2013 IEEE Sixth International Conference on; 01/2013
  • [Show abstract] [Hide abstract]
    ABSTRACT: Open source software (OSS) development teams use electronic means, such as emails, instant messaging, or forums, to conduct open and public discussions. Researchers investigated mailing lists considering them as a hub for project communication. Prior work focused on specific aspects of emails, for example the handling of patches, traceability concerns, or social networks. This led to insights pertaining to the investigated aspects, but not to a comprehensive view of what developers communicate about. Our objective is to increase the understanding of development mailing lists communication. We quantitatively and qualitatively analyzed a sample of 506 email threads from the development mailing list of a major OSS project, Lucene. Our investigation reveals that implementation details are discussed only in about 35% of the threads, and that a range of other topics is discussed. Moreover, core developers participate in less than 75% of the threads. We observed that the development mailing list is not the main player in OSS project communication, as it also includes other channels such as the issue repository.
    Mining Software Repositories (MSR), 2013 10th IEEE Working Conference on; 01/2013
  • F. Hermans, B. Sedee, M. Pinzger, A. van Deursen
    [Show abstract] [Hide abstract]
    ABSTRACT: Spreadsheets are widely used in industry: it is estimated that end-user programmers outnumber programmers by a factor 5. However, spreadsheets are error-prone, numerous companies have lost money because of spreadsheet errors. One of the causes for spreadsheet problems is the prevalence of copy-pasting. In this paper, we study this cloning in spreadsheets. Based on existing text-based clone detection algorithms, we have developed an algorithm to detect data clones in spreadsheets: formulas whose values are copied as plain text in a different location. To evaluate the usefulness of the proposed approach, we conducted two evaluations. A quantitative evaluation in which we analyzed the EUSES corpus and a qualitative evaluation consisting of two case studies. The results of the evaluation clearly indicate that 1) data clones are common, 2) data clones pose threats to spreadsheet quality and 3) our approach supports users in finding and resolving data clones.
    Software Engineering (ICSE), 2013 35th International Conference on; 01/2013
  • S. Raemaekers, G.F. Nane, A. van Deursen, J. Visser
    [Show abstract] [Hide abstract]
    ABSTRACT: Best practices in software development state that code that is likely to change should be encapsulated to localize possible modifications. In this paper, we investigate the application and effects of this design principle. We investigate the relationship between the stability, encapsulation and popularity of libraries on a dataset of 148,253 Java libraries. We find that bigger systems with more rework in existing methods have less stable interfaces and that bigger systems tend to encapsulate dependencies better. Additionally, there are a number of factors that are associated with change in library interfaces, such as rework in existing methods, system size, encapsulation of dependencies and the number of dependencies. We find that current encapsulation practices are not targeted at libraries that change the most. We also investigate the strength of ripple effects caused by instability of dependencies and we find that libraries cause ripple effects in systems using them and that these effects can be mitigated by encapsulation.
    Mining Software Repositories (MSR), 2013 10th IEEE Working Conference on; 01/2013
  • M. Greiler, A. Zaidman, A. van Deursen, M.-A. Storey
    [Show abstract] [Hide abstract]
    ABSTRACT: An important challenge in creating automated tests is how to design test fixtures, i.e., the setup code that initializes the system under test before actual automated testing can start. Test designers have to choose between different approaches for the setup, trading off maintenance overhead with slow test execution. Over time, test code quality can erode and test smells can develop, such as the occurrence of overly general fixtures, obscure inline code and dead fields. In this paper, we investigate how fixture-related test smells evolve over time by analyzing several thousand revisions of five open source systems. Our findings indicate that setup management strategies strongly influence the types of test fixture smells that emerge in code, and that several types of fixture smells often emerge at the same time. Based on this information, we recommend important guidelines for setup strategies, and suggest how tool support can be improved to help in both avoiding the emergence of such smells as well as how to refactor code when test smells do appear.
    Mining Software Repositories (MSR), 2013 10th IEEE Working Conference on; 01/2013
  • [Show abstract] [Hide abstract]
    ABSTRACT: Distributed teams face the challenge of staying connected. How do team members stay connected when they no longer see each other on a daily basis? What should be done when there is no coffee corner to share your latest exploits? In this paper we evaluate a microblogging system which makes this possible in a distributed setting. The system, WeHomer, enables the sharing of information and corresponding emotions in a fully distributed organization. We analyzed the content of over a year of usage data by 19 team members in a structured fashion, performed 5 semi-structured interviews and report our findings in this paper. We draw conclusions about the topics shared, the impact on software teams and the impact of distribution and team composition. Main findings include an increase in team-connectedness and easier access to information that is traditionally harder to consistently acquire.
    Mining Software Repositories (MSR), 2013 10th IEEE Working Conference on; 01/2013
  • E. Bouwers, A. van Deursen, J. Visser
    [Show abstract] [Hide abstract]
    ABSTRACT: A wide range of software metrics targeting various abstraction levels and quality attributes have been proposed by the research community. For many of these metrics the evaluation consists of verifying the mathematical properties of the metric, investigating the behavior of the metric for a number of open-source systems or comparing the value of the metric against other metrics quantifying related quality attributes. Unfortunately, a structural analysis of the usefulness of metrics in a real-world evaluation setting is often missing. Such an evaluation is important to understand the situations in which a metric can be applied, to identify areas of possible improvements, to explore general problems detected by the metrics and to define generally applicable solution strategies. In this paper we execute such an analysis for two architecture level metrics, Component Balance and Dependency Profiles, by analyzing the challenges involved in applying these metrics in an industrial setting. In addition, we explore the usefulness of the metrics by conducting semi-structured interviews with experienced assessors. We document the lessons learned both for the application of these specific metrics, as well as for the method of evaluating metrics in practice.
    Software Engineering (ICSE), 2013 35th International Conference on; 01/2013
  • E. Bouwers, A. van Deursen, J. Visser
    [Show abstract] [Hide abstract]
    ABSTRACT: Using software metrics to keep track of the progress and quality of products and processes is a common practice in industry. Additionally, designing, validating and improving metrics is an important research area. Although using software metrics can help in reaching goals, the effects of using metrics incorrectly can be devastating. In this tutorial we leverage 10 years of metrics-based risk assessment experience to illustrate the benefits of software metrics, discuss different types of metrics and explain typical usage scenario's. Additionally, we explore various ways in which metrics can be interpreted using examples solicited from participants and practical assignments based on industry cases. During this process we will present the four common pitfalls of using software metrics. In particular, we explain why metrics should be placed in a context in order to maximize their benefits. A methodology based on benchmarking to provide such a context is discussed and illustrated by a model designed to quantify the technical quality of a software system. Examples of applying this model in industry are given and challenges involved in interpreting such a model are discussed. This tutorial provides an in-depth overview of the benefits and challenges involved in applying software metrics. At the end you will have all the information you need to use, develop and evaluate metrics constructively.
    Software Engineering (ICSE), 2013 35th International Conference on; 01/2013
  • S. Raemaekers, A. van Deursen, J. Visser
    [Show abstract] [Hide abstract]
    ABSTRACT: We present the Maven Dependency Dataset (MDD), containing metrics, changes and dependencies of 148,253 jar files. Metrics and changes have been calculated at the level of individual methods, classes and packages of multiple library versions. A complete call graph is also presented which includes call, inheritance, containment and historical relationships between all units of the entire repository. In this paper, we describe our dataset and the methodology used to obtain it. We present different conceptual views of MDD and we also describe limitations and data quality issues that researchers using this data should be aware of.
    Mining Software Repositories (MSR), 2013 10th IEEE Working Conference on; 01/2013
  • Michaela Greiler, Arie van Deursen
    [Show abstract] [Hide abstract]
    ABSTRACT: Software architectures such as plug-in and service-oriented architectures enable developers to build extensible software products, whose functionality can be enriched by adding or configuring components. A well-known example of such an architecture is Eclipse, best known for its use to create a series of extensible IDEs. Although such architectures give users and developers a great deal of flexibility to create new products, the complexity of the built systems increases. In order to manage this complexity developers use extensive automated test suites. Unfortunately, current testing tools offer little insight in which of the many possible combinations of components and components configurations are actually tested. The goal of this paper is to remedy this problem. To that end, we interview 25 professional developers on the problems they experience in test suite understanding for plug-in architectures. The findings have been incorporated in five architectural views that provide an extensibility perspective on plug-in-based systems and their test suites. The views combine static and dynamic information on plug-in dependencies, extension initialization, extension and service usage, and the test suites. The views have been implemented in ETSE, the Eclipse Plug-in Test Suite Exploration tool. We evaluate the proposed views by analyzing eGit, Mylyn, and a Mylyn connector.
    Empirical Software Engineering 10/2012; 18(5). DOI:10.1007/s10664-012-9235-7 · 1.64 Impact Factor

Publication Stats

5k Citations
45.13 Total Impact Points

Institutions

  • 2003–2015
    • Delft University of Technology
      • Faculty of Electrical Engineering, Mathematics and Computer Sciences (EEMCS)
      Delft, South Holland, Netherlands
  • 1997–2008
    • Technische Universiteit Eindhoven
      • Department of Electrical Engineering
      Eindhoven, North Brabant, Netherlands
    • University of Amsterdam
      Amsterdamo, North Holland, Netherlands
  • 2000–2006
    • Centrum Wiskunde & Informatica
      Amsterdamo, North Holland, Netherlands
  • 2005
    • Durham University
      Durham, England, United Kingdom
  • 2004
    • College of Western Idaho
      Nampa, Idaho, United States