It is common for large-scale Java applications to suffer memory problems, whether inefficient designs that impede scalability, or lifetime bugs such as leaks Making sense of heaps with many millions of objects is difficult given the extensive layering, framework reuse, and shared ownership in current applications We present Yeti, a tool that summarizes memory usage to uncover the costs of design decisions, rather than of lower-level artifacts as in traditional tools, making it possible to quickly identify and remediate problems Yeti employs three progressive abstractions and corresponding visualizations: it identifies costly groups of objects that collectively perform a function, recovers a logical data model for each, and summarizes the implementation of each model entity and relationship Yeti is used by development and service teams within IBM, and has been effective in solving numerous problems Through case studies we demonstrate how these abstractions help solve common categories of problems

Making Sense of Large Heaps

Refactoring is the art of improving the structural design of a software system without altering its external behavior. Today, refactoring has become a well-established and disciplined software engineering practice that has attracted a significant amount of research presuming that refactoring is primarily motivated by the need to improve system structures. However, recent studies have shown that developers may incorporate refactoring strategies in other development-related activities that go beyond improving the design especially with the emerging challenges in contemporary software engineering. Unfortunately, these studies are limited to developer interviews and a reduced set of projects. To cope with the above-mentioned limitations, we aim to better understand what motivates developers to apply a refactoring by mining and automatically classifying a large set of 111,884 commits containing refactoring activities, extracted from 800 open source Java projects. We trained a multi-class classifier to categorize these commits into three categories, namely, Internal Quality Attribute, External Quality Attribute, and Code Smell Resolution, along with the traditional Bug Fix and Functional categories. This classification challenges the original definition of refactoring, being exclusive to improving software design and fixing code smells. Furthermore, to better understand our classification results, we qualitatively analyzed commit messages to extract textual patterns that developers regularly use to describe their refactoring activities. The results of our empirical investigation show that (1) fixing code smells is not the main driver for developers to refactoring their code bases. Refactoring is solicited for a wide variety of reasons, going beyond its traditional definition; (2) the distribution of refactoring operations differs between production and test files; (3) developers use a variety of patterns to purposefully target refactoring-related activities; (4) the textual patterns, extracted from commit messages, provide better coverage for how developers document their refactorings.

How we refactor and how we document it? On the use of supervised machine learning algorithms to classify refactoring documentation

In software evolution, developers typically need to identify whether the failure of a test is due to a bug in the source code under test or the obsoleteness of the test code when they execute a test suite. Only after finding the cause of a failure can developers determine whether to fix the bug or repair the obsolete test. Researchers have proposed several techniques to automate test repair. However, test-repair techniques typically assume that test failures are always due to obsolete tests. Thus, such techniques may not be applicable in real world software evolution when developers do not know whether the failure is due to a bug or an obsolete test. To know whether the cause of a test failure lies in the source code under test or in the test code, we view this problem as a classification problem and propose an automatic approach based on machine learning. Specifically, we target Java software using the JUnit testing framework and collect a set of features that may be related to failures of tests. Using this set of features, we adopt the Best-first Decision Tree Learning algorithm to train a classifier with some existing regression test failures as training instances. Then, we use the classifier to classify future failed tests. Furthermore, we evaluated our approach using two Java programs in three scenarios (within the same version, within different versions of a program, and between different programs), and found that our approach can effectively classify the causes of failed tests.

/pdf/is-this-a-bug-or-an-obsolete-test-391aco6y6a.pdf

Is this a bug or an obsolete test

Object invariants describe the consistency of object states, and are crucial for reasoning about the correctness of object-oriented programs. However, reasoning about object invariants in the presence of object abstraction and encapsulation, arbitrary object aliasing and re-entrant method calls, is difficult.We present a framework for reasoning about object invariants based on a behavioural contract that specifies two sets: the validity invariant-- objects that must be valid before and after the behaviour; and the validity effect--objects that may be invalidated during the behaviour. The overlap of these two sets is critical because it captures precisely those objects that need to be re-validated at the end of the behaviour. When there is no overlap, no further validity checking is required.We also present a type system based on this framework using ownership types to confine dependencies for object invariants. In order to track the validity invariant, the type system restricts updates to permissible contexts, even in the presence of re-entrant calls. Object referencing and read access are unrestricted, unlike earlier ownership type systems.

/pdf/validity-invariants-and-effects-3hfw1stuyz.pdf

Validity invariants and effects

The notion of a session is fundamental in service-oriented applications, as it serves to separate interactions between clients and different instances of the same service, and to group together logical units of work. Recently, the Service Centered Calculus (SCC) has been proposed as a process calculus designed around the concept of a dyadic session between a service side and an invoker side, where interaction protocols and service orchestration can be conveniently expressed. In this paper we propose a generic type system to collect services' behaviours and then we fix a class of well-typed processes that are guaranteed to be deadlock free, in the sense that they either diverge by invoking new service instances or reach a normal form. The type system is based on previous research on traditional mobile calculi, here conveniently extended and simplified thanks to the neat discipline imposed by the linguistic primitives of SCC.

Types and Deadlock Freedom in a Calculus of Services, Sessions and Pipelines

Keynote- Design Patterns - 15 Years Later- Program Query and Persistence- codeQuest: Scalable Source Code Queries with Datalog- Efficient Object Querying for Java- Automatic Prefetching by Traversal Profiling in Object Persistence Architectures- Ownership and Concurrency- The Runtime Structure of Object Ownership- On Ownership and Accessibility- Scoped Types and Aspects for Real-Time Java- Transparently Reconciling Transactions with Locking for Java Synchronization- Special 20th Anniversary Session- Object Technology - A Grand Narrative?- Peak Objects- From ECOOP'87 to ECOOP 2006 and Beyond- The Continuing Quest for Abstraction- Early Concurrent/Mobile Objects- Keynote- Turning the Network into a Database with Active XML- Languages- SuperGlue: Component Programming with Object-Oriented Signals- Ambient-Oriented Programming in AmbientTalk- Responders: Language Support for Interactive Applications- Type Theory- Variance and Generalized Constraints for C Generics- A Semantic Analysis of C++ Templates- Session Types for Object-Oriented Languages- Parameterized Modules for Classes and Extensible Functions- Keynote- The Closing of the Frontier- Tools- Augmenting Automatically Generated Unit-Test Suites with Regression Oracle Checking- Automated Detection of Refactorings in Evolving Components- Modeling Runtime Behavior in Framework-Based Applications- Modularity- Modular Software Upgrades for Distributed Systems- Demeter Interfaces: Adaptive Programming Without Surprises- Managing the Evolution of Aspect-Oriented Software with Model-Based Pointcuts

ECOOP 2006 - object-oriented programming : 20th European Conference, Nantes, France, July 3-7, 2006 : proceedings

Handle everyday research tasks with reliable, citation-backed results

Your personal Research Agent to handle research tasks with citation-backed results

Popular Tasks used by Researchers

How can I help with your research?

Meet SciSpace

Get more enhanced response by uploading the PDFs you want me to reference.

No relevant PDFs in your library

SciSpace is the AI research assistant for academics. Run systematic literature reviews on 280M+ papers, and write papers with cited sources. Trusted by 1M+ students, PhDs & researchers.

SciSpace | AI for Research

Analyze PDFs

Code & Manuscripts

Funding & Grants

Literature & Patents

Medical & Clinical Data

Systematic Review

Visualize & Present

Web & Data

Build a Google Scholar-like website for your research.

Build a website

Create charts and images for your research

Create a Chart

Write a paper for submission to a journal

Draft a manuscript

Patent Search

Design eye-catching scientific posters in minutes.

Scientific Poster Generation

Systematic Literature Review

One task is running at the moment. Your messages will be shown right after.

Drag and drop or click here to browse

Loved by <highlight>1 million+</highlight> researchers

Extract a list of specific topics and their sources from unstructured text

Topics

Compare and analyze relevant papers that matches with your search

Papers

Get insights from PDFs and bookmarked papers from your library

My library

Recent searches

Try searching for:

Catch AI-generated content in scholarly and non-scholarly content

{ai} Detector

Ai Writer

Get PDF Summaries, highlighted text explanations 

Chat with PDF

Effortlessly create in-text citations and bibliographies in APA and 2,500 other formats

Citation generator

Get explanations, summaries, and answers on academic papers

Ease up your research workflow with {scispace}'s cohort of exciting AI tools

Elevate your academic writing skills and convey your ideas the way you want

Paraphraser

Explore our range of reading and writing tools

Your file is being prepared and should be ready in a few minutes. If it's a large file, it might take a bit longer. You can close this window, and we'll email you the file when it's done.

You have reached a maximum limit of <strong>{limit}</strong> columns in the table. Remove at least <strong>1</strong> column to add or create another one.

Dave Thomas

Author Tools

Chat about Author

Papers

ECOOP 2006 - object-oriented programming : 20th European Conference, Nantes, France, July 3-7, 2006 : proceedings