NDLI: Call graph construction for Java libraries

Please wait, while we are loading the content...

"Womenomics" and gender-inclusive software: what software engineers need to know (invited talk)

Continuous deployment of mobile software at facebook (showcase)

Titanium: efficient analysis of evolving alloy specifications

Sustainable software design

Bing developer assistant: improving developer productivity by recommending sample code

NonDex: a tool for detecting and debugging wrong assumptions on Java API specifications

Refactoring and migration of cascading style sheets: towards optimization and improved maintainability

Effective assignment and assistance to software developers and reviewers

Enforcing correct array indexes with a type system

Building a socio-technical theory of coordination: why and how (outstanding research award)

Model, execute, and deploy: answering the hard questions in end-user programming (showcase)

Mining performance specifications

Designing for dystopia: software engineering research for the post-apocalypse

Cluster-based test suite functional analysis

TIPMerge: recommending developers for merging branches

Developing a reusable control-based approach to build self-adaptive software systems with formal guarantees

RABIEF: range analysis based integer error fixing

Discovering additional violations of Java API invariants

Correct or usable? the limits of traditional verification (impact paper award)

Making invisible things visible: tracking down known vulnerabilities at 3000 companies (showcase)

Designing minimal effective normative systems with the help of lightweight formal methods

Disrupting developer productivity one bot at a time

A portable interface for runtime energy monitoring

Time-travel debugging for JavaScript/Node.js

Automating repetitive code changes using examples

Fine-grained binary code authorship identification

Preventing signedness errors in numerical computations in Java

Developer workflow at google (showcase)

Proteus: computing disjunctive loop summary via path dependency analysis

Training the future workforce through task curation in an OSS ecosystem

Learning for test prioritization: an industrial case study

PUMConf: a tool to configure product specific use case and domain models in a product line

Understanding and improving continuous integration

Identifying participants for collaborative merge

Bounded model checking of state-space digital systems: the impact of finite word-length effects on the implementation of fixed-point digital controllers based on state-space modeling

A cross-tool communication study on program analysis tool notifications

Reaching the masses: a new subdiscipline of app programmer education

Combinatorial generation of structurally complex test inputs for commercial software applications

T2API: synthesizing API code usage templates from English texts with statistical translation

Guided code synthesis using deep neural networks

Cozy: synthesizing collection data structures

Atlas: an intelligent, performant framework for web-based grid computing

Factors influencing code review processes in industry

Studying developer gaze to empower software engineering research and practice

Automated test input generation for Android: are we really there yet in an industrial case?

JBSE: a symbolic executor for Java programs with complex heap inputs

Generating interactive web pages from storyboards

Constraint-based event trace reduction

Foraging and navigations, fundamentally: developers' predictions of value and cost

DeepSoft: a vision for a deep model of software

ARdoc: app reviews development oriented classifier

Data structure synthesis

Automatic trigger generation for end user written rules for home automation

How to break an API: cost negotiation and community values in three software ecosystems

Budgeted testing through an algorithmic lens

Hunter: next-generation code reuse for Java

Understanding behavioural patterns in JavaScript

Hotspot symbolic execution of floating-point programs

Python predictive analysis for bug detection

Reasoning with imprecise privacy preferences

BigDebug: interactive debugger for big data analytics in Apache Spark

Regression testing of web applications using Record/Replay tools

Evaluation of fault localization techniques

Crash consistency validation made easy

Visualizing code and coverage changes for code review

Supporting change in product lines within the context of use case-driven development and testing

How should static analysis tools explain anomalies to developers?

Discovering bug patterns in JavaScript

End-to-end memory behavior profiling with DINAMITE

Input-sensitive performance testing

Repairing test dependence

Effort-aware just-in-time defect prediction: simple unsupervised models could be better than supervised models

Validate your SPDX files for open source license violations

On the utility of dominator mutants for mutation testing

Combining bug detection and test case generation

Detecting sensitive data disclosure via bi-directional text correlation analysis

FSX: a tool for fine-grained incremental unit test generation for C/C++ programs

SmartDebug: an interactive debug assistant for Java

Multi-representational security analysis

Static loop analysis and its applications

String analysis for side channels with segmented oracles

Social health cues developers use when choosing open source packages

WebRanz: web page randomization for better advertisement delivery and web-bot prevention

Finding and breaking test dependencies to speed up test execution

A discrete-time feedback controller for containerized cloud applications

Automatic performance testing using input-sensitive profiling

Keep it SIMPLEX: satisfying multiple goals with guarantees in control-based self-adaptive systems

Automated change impact analysis between SysML models of requirements and design

Parameter-free probabilistic API mining across GitHub

API deprecation: a retrospective analysis and detection method for code examples on the web

When should internal interfaces be promoted to public?

POLLUX: safely upgrading dependent application libraries

Extracting instruction semantics via symbolic execution of code generators

Efficient generation of inductive validity cores for safety properties

Correctness witnesses: exchanging verification results between verifiers

SMT-based verification of parameterized systems

On-the-fly decomposition of specifications in software model checking

On well-separation of GR(1) specifications

Lightweight specification and analysis of dynamic systems with rich configurations

Gray links in the use of requirements traceability

Understanding and detecting wake lock misuses for Android applications

DiagDroid: Android performance diagnosis via anatomizing asynchronous executions

Minimizing GUI event traces

Causal impact analysis for app releases in google play

Static DOM event dependency analysis for testing web applications

On-demand strong update analysis via value-flow refinement

Call graph construction for Java libraries

Revamping JavaScript static analysis via localization and remediation of root causes of imprecision

What would users change in my app? summarizing app reviews for recommending software changes

API code recommendation using statistical learning from fine-grained changes

TIPMerge: recommending experts for integrating changes across branches

Interactive and guided architectural refactoring with search-based recommendation

Can testedness be effectively measured?

A large-scale empirical comparison of static and dynamic test case prioritization techniques

Analyzing the validity of selective mutation with dominator mutants

An extensive study of static regression test selection in modern software evolution

PerfGuard: binary-centric application performance monitoring in production environments

Python probabilistic type inference with natural language support

Detecting and fixing precision-specific operations for measuring floating-point errors

Deep API learning

Build system with lazy retrieval for Java projects

iGen: dynamic interaction inference for configurable software

CacheOptimizer: helping developers configure caching frameworks for hibernate-based database-centric web applications

BinGo: cross-architecture cross-OS binary search

Relationship-aware code search for JavaScript frameworks

Code relatives: detecting similarly behaving software

Understanding and generating high quality patches for concurrency bugs

Anti-patterns in search-based program repair

Semi-supervised verified feedback generation

WATERFALL: an incremental approach for repairing record-replay tests of web applications

Efficiency of projectional editing: a controlled experiment

ECHO: instantaneous in situ race detection in the IDE

Detecting table clones and smells in spreadsheets

Flow-sensitive composition of thread-modular abstract interpretation

A deployable sampling strategy for data race detection

Online shared memory dependence reduction via bisectional coordination

Parallel data race detection for task parallel programs with locks

Paradise unplugged: identifying barriers for female participation on stack overflow

Why we refactor? confessions of GitHub contributors

Effectiveness of code contribution: from patch-based to pull-request-based tools

Isomorphic regression testing: executing uncovered branches without test augmentation

Directed test generation to detect loop inefficiencies

Field-exhaustive testing

Call graph construction for Java libraries

Content Provider	ACM Digital Library
Author	Eichberg, Michael Hermann, Ben Lerch, Johannes Reif, Michael Mezini, Mira
Abstract	Today, every application uses software libraries. Yet, while a lot of research exists w.r.t. analyzing applications, research that targets the analysis of libraries independent of any application is scarce. This is unfortunate, because, for developers of libraries, such as the Java Development Kit (JDK), it is crucial to ensure that the library behaves as intended regardless of how it is used. To fill this gap, we discuss the construction of call graphs for libraries that abstract over all potential library usages. Call graphs are particularly relevant as they are a precursor of many advanced analyses, such as inter-procedural data-flow analyses. We show that the current practice of using call graph algorithms designed for applications to analyze libraries leads to call graphs that, at the same time, lack relevant call edges and contain unnecessary edges. This motivates the need for call graph construction algorithms dedicated to libraries. Unlike algorithms for applications, call graph construction algorithms for libraries must take into consideration the goals of subsequent analyses. Specifically, we show that it is essential to distinguish between the scenario of an analysis for potential exploitable vulnerabilities from the scenario of an analysis for general software quality attributes, e.g., dead methods or unused fields. This distinction affects the decision about what constitutes the library-private implementation, which therefore, needs special treatment. Thus, building one call graph that satisfies all needs is not sensical. Overall, we observed that the proposed call graph algorithms reduce the number of call edges up to 30% when compared to existing approaches. .
Starting Page	474
Ending Page	486
Page Count	13
File Format	PDF
ISBN	9781450342186
DOI	10.1145/2950290.2950312
Language	English
Publisher	Association for Computing Machinery (ACM)
Publisher Date	2016-11-01
Publisher Place	New York
Access Restriction	Subscribed
Subject Keyword	Java Libraries Call graph construction
Content Type	Text
Resource Type	Article

Central Library (ISO-9001:2015 Certified)
Indian Institute of Technology Kharagpur
Kharagpur, West Bengal, India | PIN - 721302

See location in the Map
03222 282435
Mail: support@ndl.gov.in

Sl.	Authority	Responsibilities	Communication Details
1	Ministry of Education (GoI), Department of Higher Education	Sanctioning Authority	https://www.education.gov.in/ict-initiatives
2	Indian Institute of Technology Kharagpur	Host Institute of the Project: The host institute of the project is responsible for providing infrastructure support and hosting the project	https://www.iitkgp.ac.in
3	National Digital Library of India Office, Indian Institute of Technology Kharagpur	The administrative and infrastructural headquarters of the project	Dr. B. Sutradhar bsutra@ndl.gov.in
4	Project PI / Joint PI	Principal Investigator and Joint Principal Investigators of the project	Dr. B. Sutradhar bsutra@ndl.gov.in Prof. Saswat Chakrabarti will be added soon
5	Website/Portal (Helpdesk)	Queries regarding NDLI and its services	support@ndl.gov.in
6	Contents and Copyright Issues	Queries related to content curation and copyright issues	content@ndl.gov.in
7	National Digital Library of India Club (NDLI Club)	Queries related to NDLI Club formation, support, user awareness program, seminar/symposium, collaboration, social media, promotion, and outreach	clubsupport@ndl.gov.in
8	Digital Preservation Centre (DPC)	Assistance with digitizing and archiving copyright-free printed books	dpc@ndl.gov.in
9	IDR Setup or Support	Queries related to establishment and support of Institutional Digital Repository (IDR) and IDR workshops	idr@ndl.gov.in