Browsing by Author "Walker, Robert"

Now showing 1 - 10 of 10
  • Thumbnail Image
    ItemOpen Access
    API Deprecation: A Retrospective Analysis and Method for Detecting Deprecated API Usages in Code Examples on the Web
    (2016-02-03) Zhou, Jing; Walker, Robert; Oehlberg, Lora; Krishnamurthy, Diwakar
    Application Programming Interfaces (APIs) can get deprecated over time, to indicate that they are obsolete, dangerous, and/or to be eliminated in future versions. This thesis ad- dresses two problems involving API deprecation. API deprecation has not been systematically studied so far. We empirically study how API deprecation has been used in 26 open source Java systems. We find that API dep- recation seems to be underused and not enough information is provided to help users via deprecation messages. More than 40% of all deprecated APIs were removed, most of which were removed during transitions to major releases. A developer may waste valuable time consulting code examples on the web containing deprecated API usages. A version sensitive framework was proposed to detect deprecated API usages in code examples on the web and a prototype tool based on this framework was implemented. Our evaluation of this tool shows that it works fairly well.
  • Thumbnail Image
    ItemOpen Access
    Automatically Characterizing Logging Usage: An Application of Anti-Unification
    (2016) Zirakchianzadeh, Narges; Walker, Robert; Ruhe, Guenther; Denzinger, Jörg
    Logging has been a common practice to record the runtime behaviour of a software system, typically performed by inserting log statements in its source code. While several frameworks have been specifically created to help developers perform logging tasks, these do not provide guidance on where the log statements should be located in the source code. Thus, developers usually rely on their common sense to decide where to log. If logging is done properly, it can provide valuable information for software development and maintenance; if it is done poorly, system performance can degrade and maintenance can be made more difficult. Few studies have been conducted to characterize logging usage in real-world applications. This work tries to address the problem of where to log by proposing an automated approach that characterizes the location of log statements through the approximation of an anti-unification approach (specifically, higher-order anti-unification modulo theories) and a hierarchical clustering technique to construct a set of anti-unifiers, each describing the commonalities and differences between source code fragments that embody log statements. This approach has been reified in a prototype tool, called ELUS, that greedily identifies the best structural correspondences with respect to the highest similarity and some constraints. An empirical study was conducted by applying the tool on the source code of four open source systems and manually examining the generated anti-unifiers. The analysis resulted in five main categories of anti-unifiers in the logging usage. Two empirical evaluations were conducted in this work: (1) an experiment was conducted to evaluate the effectiveness of the proposed approach through the application of its supporting tool on a test suite; and (2) an experiment was performed to evaluate the quality of the anti-unifiers in describing the location of log statements in source code.
  • Thumbnail Image
    ItemOpen Access
    Communication, Collaboration, and Bugs: The Social Nature of Issue Tracking in Software Engineering
    (2009-06-16T15:50:52Z) Bertram, Dane; Voida, Amy; Greenberg, Saul; Walker, Robert
    Issue tracking systems help organizations manage issue reporting, assignment, tracking, resolution, and archiving. Traditionally, it is the Software Engineering community that researches issue tracking systems, where software defects are reported and tracked as ‘bug reports’ within an archival database. Yet issue tracking is fundamentally a social process and, as such, it is important to understand the design and use of issue tracking systems from that perspective. Consequently, we conducted a qualitative study of the use of issue tracking systems by small, collocated software development teams. We found that an issue tracker is not just a database for tracking bugs, features, and inquiries, but also a focal point for communication and coordination for many stakeholders within and beyond the software team. Customers, project managers, quality assurance personnel, and programmers all contribute to the shared knowledge and persistent communication that exists within the issue tracking system. We articulate various real-world practices surrounding issue trackers and offer design implications for future systems.
  • Thumbnail Image
    ItemOpen Access
    The End-to-End Use of Source Code Examples: An Exploratory Study - Appendix
    (2009-06-15T17:54:07Z) Holmes, Reid; Cottrell, Rylan; Walker, Robert; Denzinger, Joerg
    This appendix contains the details of our case studies outlined in our paper for the 2009 International Conference on Software Maintenance, as well as an expanded discussion section. The reader is directed to the main paper for introduction, motivation, and related work.
  • Thumbnail Image
    ItemOpen Access
    Ontology-Enhanced Automated Machine Learning
    (2024-11-20) Davies, Cooper T.S.; Denzinger, Jorg; Maurer, Frank; Jacob, Christian; Walker, Robert; Dick, Scott; Boyd, Jeffrey
    This thesis addresses the challenge of bridging the gap between traditional Problem-Specific Machine Learning (PSML) and Automated Machine Learning (AutoML) systems. While PSML offers high accuracy but demands substantial expertise, AutoML aims to auto-mate the process of building a machine learning (ML) model but often lacks domain-specific knowledge. To address this, we propose Ontology-Enhanced AutoML, a novel approach that integrates domain knowledge from ontologies into the AutoML pipeline. We first examine the current landscape of AutoML, highlighting the complexities faced by a system in selecting appropriate algorithms and hyperparameters. We identify the limitations of existing AutoML systems, particularly their blind reliance on datasets, which often leads to poor performance and lengthy training times. Our thesis presents experiments demonstrating the effectiveness of Ontology-Enhanced AutoML in mitigating these challenges. By incorporating mechanisms for ontology-based feature extraction and example filtering, we demonstrate significant improvements in accu-racy and optimization time compared to traditional AutoML. These results highlight the potential of Ontology-Enhanced AutoML to provide a wide range of systems lying between the extremes of PSML and AutoML. This thesis contributes not only a technical solution but also a conceptual framework for understanding ML as a spectrum. We discuss implications for future research and the potential for further advancements in bridging the gap between domain expertise and ML proficiency.
  • Thumbnail Image
    ItemOpen Access
    Pragmatic Software Reuse: A View from the Trenches
    (2016-09-22) Walker, Robert; Cottrell, Rylan
    Software reuse has been a part of the software engineering field since its inception. Research on reuse has focused almost exclusively on pre-planned approaches. Relatively little has been written about reuse performed in the absence of its pre-planning: pragmatic reuse. While many academics have dismissed nonpre- planned reuse as ill-advised, very little evidence exists about it, especially with respect to industrial practice. We conducted a survey of 59 industrial software developers to capture the perception, frequency, motivations, difficulties, and execution of the practice of pragmatic reuse within their development activities. We found that the majority of developers surveyed perceive that: pragmatic reuse has an important place in their repertoire of techniques; pragmatic reuse tasks are a frequent part of their development activities; and that they face a variety of practical difficulties while performing pragmatic reuse tasks. Opinions vary on the range and scale of situations where pragmatic reuse is suitable.
  • Thumbnail Image
    ItemOpen Access
    The Problems of Large-Scale Refactoring: Learning from Eclipse RCP
    (2015-02-23) Moazzen, Elham; Walker, Robert
    Investing in planning big refactoring changes prior to implementing them has been promoted as a positive practice that guarantees a high quality code change process. However, there is no empirical evidence of the potential risks that may degrade the quality of such a change process, even if changes are planned in advance. This paper identifies and categorizes potential risks based on a real-world case of large-scale refactoring: that which produced the Eclipse Rich Client Platform (RCP). This case is interesting because it is industrially relevant and three publicly available data sources exist for it. We analyzed these data sources in retrospect, and found that when expert engineers were mapping out changes, (1) they were uncertain about what the code does, (2) they were unclear about what it affects if the code is changed, and (3) they misunderstood each other when changes were described. If such lack of knowledge, and miscommunication among the expert engineers were not resolved via peer discussions prior to applying the changes, we anticipate that such changes would result in a later wrong decision or action. We also found that (4) many small changes are enacted in the code for which the sequencing matters and that were poorly-communicated while planning. Thus, these changes cannot be reviewed by other engineers until after they are fully implemented. We hypothesize that such lack of knowledge and miscommunication would adversely affect the quality of a largescale refactoring task, especially when the complexity of the task increases and the level of expertise decreases.
  • Thumbnail Image
    ItemOpen Access
    The Reduction Process for Change Type Cases to Consider
    (2014-09-03) Makady, Soha; Walker, Robert
    Pragmatic reuse tasks can be validated by a custom record-and-replay (R&R) technique that transforms automated test suites to focus on the reused code, reducing the need to develop test suites manually; this technique has previously been reified in the Skipper tool. In general, R&R test suites have been criticized as lacking maintainability when the source under test evolves, but the literature contains no empirical evidence on the merits or faults of R&R unit tests relative to alternatives. The associated paper “Maintaining Record-and-Replay Test Cases within Pragmatic Reuse Scenarios” reports on an empirical study with industrial developers that: (1) evaluates whether R&R unit tests within pragmatic reuse tasks are harder to maintain than ones written manually, and (2) investigates how developers would validate pragmatic reuse tasks in the absence of R&R tests. This technical report describes details of the process for reducing the number of cases to be considered to a manageable number.
  • Thumbnail Image
    ItemOpen Access
    Using Structural Generalization to Discover Replacement Functionality for API Evolution
    (2014-05-12) Cossette, Bradley; Walker, Robert; Cottrell, Rylan
    New versions of software libraries sometimes introduce incompatible and undocumented changes into their application programming interfaces (APIs). A developer whose software uses the API must determine how to migrate it in response. Existing approaches for determining migration paths are often of limited help, requiring speci c library characteristics, or resolving a small subset of actual changes. We present a new approach, matching via structural general- ization (MSG), that recommends replacement functionality from a new API version, based on its structural similarity to functionality removed from the old API. We rei ed our approach in a prototype API change recommendation tool called Umami, which we used to resolve binary incompatible changes in 20 Java library migrations, comparing its accuracy to other analysis and change recommendation techniques. Our results suggest MSG is complementary to existing approaches, providing useful results in API migration situations where the others fail.
  • Thumbnail Image
    ItemOpen Access
    Validating Pragmatic Reuse Tasks
    (2015-01-28) Makady, Soha; Walker, Robert
    Disciplined software development involves the ad hoc reuse of source code that was not designed for that reuse. Such pragmatic reuse tasks have long been criticized due to a lack of systematic support, and an inability to validate that the reused code still provides its functionality of interest within the target system. Although recent work has successfully systematized support for pragmatic reuse tasks, validating those reuse tasks has not been tackled yet. Current approaches to validating reuse tasks require the developer to rely on automated test generation techniques which could miss serious defects, or to create his own test suite—a time consuming process whose correctness would be questioned due to the developer’s limited knowledge about the reused code. A third alternative would be to modify the originating system’s test suite to only exercise and validate the reused code. But such a manual editing process can result in injecting more defects into the originally high quality source code and its corresponding test suite. The thesis of this dissertation is that, by providing developers with tool support to reuse test cases within pragmatic reuse scenarios, we can leverage the quality of the pragmatically reused code, while reducing the needed manual intervention. To validate this claim, we have proposed a novel approach and tool to semi-automatically reuse and transform relevant portions of the test suite associated with pragmatically reused source code, as a means to validate that the relevant constraints from the originating system continue to hold, while minimizing the needed developer intervention. We have evaluated various aspects of our proposed approach, through a series of empirical studies, and using a variety of source systems and tasks. The results show that, relative to the manual approach, our approach reduces task completion time and improves the correctness of the reused test cases. Furthermore, our proposed approach can make the process of finding and fixing errors within pragmatic reuse tasks faster, and its transformed test cases can be maintained.