Java Application Programming Interface Research Articles

RECOMMENDING JAVA API METHODS BASED ON PROGRAMMING TASK DESCRIPTIONS BY NOVICE PROGRAMMERS

The overwhelming number of Application Programming Interfaces (APIs) and the lexical gap between novices’ programming task descriptions in their search queries and API documentations deter novice programmers from finding suitable API methods to be used in their code. To address the lexical gap, this study investigated novice programmers’ descriptions of their programming tasks and used the found insights in a novel approach (APIFind) for recommending relevant API methods for the programming tasks. Queries written by novice programmers were collected and analysed using term frequency and constituency parsing. Four common patterns related to the return type of an API method and/or API class that provides an implementation for the API method were found and captured in the Novice Programming Task Description Model (NPTDM). APIFind uses NPTDM that was operationalised in a rule-based module, a WordNet map of API word-synonyms, a programming task dataset comprising the collected queries, a Java API class and method repository, a Stack Overflow Q&A thread repository, and the BM25 model in Apache Lucene, to produce the top-5 API methods relevant to a search query. Benchmarking results using mean average precision @ 5 and mean reciprocal rank @ 5 as the evaluation metrics show that APIFind outperformed BIKER and CROKAGE when the novice queries test dataset was used. It performed slightly better than BIKER but slightly worse than CROKAGE when the reduced BIKER test dataset was used. In conclusion, common patterns exist in novice programmers’ search queries and can be used in API recommendations for novice programmers.

Enhancing Monte Carlo Workflows for Nuclear Reactor Analysis with Metamodel-Driven Modeling

Monte Carlo codes are essential components of many reactor physics simulation workflows as high-fidelity continuous-energy neutron transport solvers. Among Monte Carlo radiation transport codes, MCNP is particularly notable due to its diverse simulation capabilities, large user base, and long validation history. Despite being a powerful simulation tool, MCNP provides limited capabilities to allow automated execution, model transformation, or support for user-defined logic and abstractions that limit its compatibility with modern workflows. To better integrate MCNP into a modern scientific workflow, we have developed an intuitive yet full-featured MCNP Application Program Interface (API) in Python, named MCNPy, which provides a specialized set of classes for MCNP input development. Moreover, to guarantee that our reading, writing, and modeling capabilities remain self-consistent (and to render the huge scope of the MCNP API manageable), we have adopted a strategy of model-driven software development in which a generalized model of the MCNP input format has been created. From this generalized model, or “metamodel,” problem-specific implementations such as an engine for input validation or a codebase for programmatic operations may be automatically generated. Since MCNPy primarily acts as a Python front-end to the underlying Java API that directly interfaces with the metamodel, it is intrinsically linked to the metamodel and thus remains maintainable. With MCNPy, users can programmatically read, write, and modify any syntactically valid MCNP input file regardless of its origin. These capabilities allow users to automate complicated tasks like design optimization and model translation for nuclear systems. As examples, this work demonstrates the use of MCNPy to find the critical radius of a plutonium sphere and to translate a 9000+ line MCNP input file into a corresponding OpenMC model.

The ORIS tool

ORIS is a tool for quantitative modeling and evaluation of concurrent systems with non-Markovian durations. It provides a Graphical User Interface (GUI) for model specification as Stochastic Time Petri Nets (STPNs), validation by interactive simulation, and evaluation by several techniques, computing instantaneous and cumulative rewards. It also provides an open-source Java Application Programming Interface (API) to automate the workflow, and it can be used as a toolkit for derivation and evaluation of STPNs in model driven engineering. As distinguishing features, ORIS implements transient and steady-state analysis of STPNs with underlying Markov Regenerative Process (MRP), and transient analysis of STPNs with underlying Generalized Semi- Markov Process (GSMP). It also implements nondeterministic analysis of Time Petri Nets (TPNs), simulation of STPNs, and solution methods for Continuous-Time Markov Chains (CTMCs) and MRPs with at most one non-exponential timer in each state. The well-engineered software architecture of ORIS supports agile implementation of new STPN features, new modeling formalisms, and new analysis methods.

Finite element method coupled with TLBO for shape control optimization of piezoelectric bimorph in COMSOL Multiphysics

Finite element methods (FEMs) are more advantageous for analyzing complex geometry and structures than analytical methods. Local search optimization techniques are suitable for the unimodal problem because final result depends on the starting point. On the other hand, to optimize the parameters of multi-minima/maxima problems, global optimization-based FEM is used. Unfortunately, global optimization solvers are not present in, COMSOL Multiphysics, a versatile tool for solving varieties of problems using FEM. Teaching–learning-based optimization (TLBO) is a global optimization technique and does not require any algorithm-specific parameter. In this paper, FEM is coupled with TLBO algorithms in COMSOL Multiphysics for solving the global optimization problem. The TLBO algorithm is implemented in COMSOL Multiphysics using the JAVA application programming interface and tested with the standard benchmark functions. The solutions of the standard benchmark problem in COMSOL Multiphysics are in close agreement with the results presented in literature. Furthermore, the optimization procedure thus established is used for the optimization of actuator voltage for piezoelectric bimorphs to achieve the desired shapes. The FEM-based TLBO method is compared with two optimization methods present in COMSOL Multiphysics for a shape control problem; (i) method of moving asymptotes (MMA) and (ii) Bound Optimization BY Quadratic Approximation (BOBYQA). The root mean square error shows that the FEM-based TLBO algorithm converges to a global minimum and gives the same result (19.3 nm) at multiple runs, whereas MMA and BOBYQA trapped in local minimum and gave different results for different starting points.

The ORIS Tool: Quantitative Evaluation of Non-Markovian Systems

We present the next generation of ORIS, a toolbox for quantitative evaluation of concurrent models with non-Markovian timers. The tool shifts its focus from timed models to stochastic ones, it includes a new graphical user interface, new analysis methods and a Java Application Programming Interface (API). Models can be specified as Stochastic Time Petri Nets (STPNs) through the graphical editor, validated using an interactive token game, and analyzed through several techniques to compute instantaneous or cumulative rewards. STPNs can also be exported as Java code to conduct extensive parametric studies through the Java library, now distributed as open-source. A well-engineered software architecture allows the user to implement new features for STPNs, new modeling formalisms, and new analysis methods. The most distinctive features of ORIS include transient and steady-state analysis of STPNs modeling Markov Regenerative Processes (MRPs), and transient analysis of STPNs modeling generalized semi-Markov processes. ORIS also supports state-space analysis of Time Petri Nets (TPNs), simulation of STPNs, and standard analysis techniques for continuous-time Markov chains or MRPs with at most one non-exponential timer in each state. We illustrate the general workflow for the application of ORIS to the modeling and evaluation of non-functional requirements of software-intensive systems.

Automatic Detection and Repair Recommendation of Directive Defects in Java API Documentation

Application Programming Interfaces (APIs) represent key tools for software developers to build complex software systems. However, several studies have revealed that even major API providers tend to have incomplete or inconsistent API documentation. This can severely hamper the API comprehension and, as a consequence, the quality of the software built on them. In this paper, we propose DRONE (Detect and Repair of dOcumentatioN dEfects), a framework to automatically detect and repair defects from API documents by leveraging techniques from program analysis, natural language processing, and constraint solving. Specifically, we target at the directives of API documents, which are related to parameter constraints and exception handling declarations. Furthermore, in presence of defects, we also provide a prototypical repair recommendation system. We evaluate our approach on parts of the well-documented APIs of JDK 1.8 APIs (including javaFX) and Android 7.0 (level 24). Across the two empirical studies, our approach can detect API defects with an average F-measure of 79.9, 71.7, and 81.4 percent, respectively. The API repairing capability has also been evaluated on the generated recommendations in a further experiment. User judgments indicate that the constraint information is addressed correctly and concisely in the rendered directives.

Rise of the API Copyright Dead?: An Updated Epitaph for Copyright Protection of Network and Functional Features of Computer Software

After a decade of bruising legal battles, the courts and software industry norms largely resolved the costly war over the scope of copyright protection for computer software. By the mid 1990s, freedom to develop interoperable devices, systems, and software triumphed over broad copyright protection for network features of computer software. Copyright peace prevailed throughout the software industry for the next 15 years. But in 2010, Oracle reignited the smoldering embers of that war when it brought suit alleging that Google infringed copyright in the Java application program interface packages (APIs)... This article updates and expands upon an earlier “epitaph” for copyright protection of network features of computer software to address the second API copyright wave. As background, Part I reviews the first wave of API copyright legislation and litigation. Part II examines the Oracle v. Google litigation, tracing the development of Java and Android and the subsequent (and still ongoing) battle over the scope of copyright protection for APIs. Part III critically analyzes the Oracle v. Google decisions. It explains that copyright law’s fundamental exclusion of protection for functional features dictates that the labeling conventions and packaging of functions within interface specifications generally fall outside of the scope of copyright protection even as implementing code garners thin copyright protection. This interpretation of copyright law comports with fundamental principles channeling protection among the modes of intellectual property. It also serves the larger goals of intellectual property law and competition policy.

On the reaction to deprecation of clients of 4 + 1 popular Java APIs and the JDK

Application Programming Interfaces (APIs) are a tremendous resource—that is, when they are stable. Several studies have shown that this is unfortunately not the case. Of those, a large-scale study of API changes in the Pharo Smalltalk ecosystem documented several findings about API deprecations and their impact on API clients. We extend this study, by analyzing clients of both popular third-party Java APIs and the JDK API. This results in a dataset consisting of more than 25,000 clients of five popular Java APIs on GitHub, and 60 clients of the JDK API from Maven Central. This work addresses several shortcomings of the previous study, namely: a study of several distinct API clients in a popular, statically-typed language, with more accurate version information. We compare and contrast our findings with the previous study and highlight new ones, particularly on the API client update practices and the startling similarities between reaction behavior in Smalltalk and Java. We make a comparison between reaction behavior for third-party APIs and JDK APIs, given that language APIs are a peculiar case in terms of wide-spread usage, documentation, and support from IDEs. Furthermore, we investigate the connection between reaction patterns of a client and the deprecation policy adopted by the API used.

Functionality and Expression in Computer Programs: Refining the Tests for Software Copyright Infringement

Functionality and Expression in Computer Programs: Refining the Tests for Software Copyright Infringement

Functionality and Expression in Computer Programs: Refining the Tests for Software Copyright Infringement

Functionality and Expression in Computer Programs: Refining the Tests for Software Copyright Infringement

A java application programming interface for in-vehicle infotainment devices

Traveling long distances by vehicle in the modern world has become bearable with the availability of In-Vehicle Infotainment systems to entertain and inform both drivers and other occupants. One of the problems faced by application developers for In-Vehicle Infotainment systems is the lack of an open and standard platform across different vehicle manufacturers. The Application Programming Interface and the concepts proposed in this paper should reduce the closed, proprietary and non-extensible systems being released today and bolster the design and development of open, more complete, feature-full systems in vehicles that will not only assist but also entertain drivers and passengers.

Interfaces on Trial 3.0: Oracle America v. Google and Beyond

This is the third volume of a history of the global legal debate concerning copyright and competition in the software industry. The debate has centered on two related issues. First, does copyright protect the elements of computer programs necessary to achieve interoperability? Second, to the extent that those elements are unprotectable, can copyright law nevertheless prevent the incidental to uncover those unprotectable elements?I wrote the first volume, INTERFACES ON TRIAL: INTELLECTUAL PROPERTY AND INTEROPERABILITY ON THE GLOBAL SOFTWARE INDUSTRY, with Masanobu Katoh. It was published by Westview Press in 1995.The second volume, INTERFACES ON TRIAL 2.0, also written with Masanobu Katoh, was published by MIT Press in 2011. It covers the developments in this field between 1995 and 2010. The third volume, INTERFACES ON TRIAL 3.0: ORACLE AMERICA v. GOOGLE AND BEYOND, picks off where the second volume left off, focusing in particular on the Oracle America v. Google litigation concerning Google’s copying of certain elements of the Java Application Program Interface (API). This litigation, initiated by Oracle in 2010, is still ongoing. However, there now is a break in the action as the 2016 fair use jury verdict is on appeal to the U.S. Court of Appeals for the Federal Circuit. Because the CAFC may not issue a ruling until 2018, it made sense to me to release this volume now.

Jury returns verdict for Google in question of fair use of Oracle’s code

On 26 May 2016 a jury returned a verdict that upheld Google’s fair use defence in a long-running copyright dispute brought by Oracle over Google’s misappropriation of certain Java code. The recent jury verdict is the latest installment in a litigation that began in 2010 with Oracle accusing Google of copying certain portions of its Java application programming interface in Google’s Android operating system. The verdict, if upheld on appeal, exonerates Google of liability for infringing Oracle’s copyright on the software in question. The case had the potential for significant damages because of the size of the Android market in question and significant implications on the commercial use of open source software.

MzJava: An open source library for mass spectrometry data processing

Mass spectrometry (MS) is a widely used and evolving technique for the high-throughput identification of molecules in biological samples. The need for sharing and reuse of code among bioinformaticians working with MS data prompted the design and implementation of MzJava, an open-source Java Application Programming Interface (API) for MS related data processing. MzJava provides data structures and algorithms for representing and processing mass spectra and their associated biological molecules, such as metabolites, glycans and peptides. MzJava includes functionality to perform mass calculation, peak processing (e.g. centroiding, filtering, transforming), spectrum alignment and clustering, protein digestion, fragmentation of peptides and glycans as well as scoring functions for spectrum–spectrum and peptide/glycan-spectrum matches. For data import and export MzJava implements readers and writers for commonly used data formats. For many classes support for the Hadoop MapReduce (hadoop.apache.org) and Apache Spark (spark.apache.org) frameworks for cluster computing was implemented. The library has been developed applying best practices of software engineering. To ensure that MzJava contains code that is correct and easy to use the library's API was carefully designed and thoroughly tested. MzJava is an open-source project distributed under the AGPL v3.0 licence. MzJava requires Java 1.7 or higher. Binaries, source code and documentation can be downloaded from http://mzjava.expasy.org and https://bitbucket.org/sib-pig/mzjava.This article is part of a Special Issue entitled: Computational Proteomics.

Impact of Developer Choices on Energy Consumption of Software on Servers

The power cost of running a data center is a significant portion of its total annual operating budget. With the aim of reducing power bills of data centers, “Green Computing” has emerged with the primary goal of making software more energy efficient without compromising the performance. Developers play an important role in controlling the energy cost of data center software while writing code. In this paper, we show how software developers can contribute to energy efficiency of servers by choosing energy efficient APIs (Application Programming Interface) with the optimal choice of parameters while implementing file reading, file copy, file compression and file decompression operations in Java; that are performed extensively on large scale servers in data centers. We performed extensive measurements of energy cost of those operations on a Dell Power Edge 2950 machine running Linux and Windows servers. Measurement results show that energy costs of various APIs for those operations are sensitive to the bu ff er size selection. The choice of a particular Java API for file reading with different buffer sizes has significant impact on the energy cost, giving an opportunity to save up to 76%. To save energy while copying files, it is important to use APIs with tunable buffer sizes, rather than APIs using fixed size buffers. In addition, there is a trade off between compression ratio and energy cost: because of more compression ratio, xz compression API consumes more energy than zip and gzip compression APIs. Finally, we model the energy costs of APIs by polynomial regression to avoid repeated measurements.

Classification and Searching in Java API Reference Documentation

Application Program Interface (API) allows programmers to use predefined functions instead of writing them from scratch. Description of API elements that is Methods, Classes, Constructors etc. is provided through API Reference Documentation. Hence API Reference Documentation acts as a guide to user or developer to use API’s. Different types of Knowledge Types are generated by processing this API Reference Documentation. And this Knowledge Types will be used for Classification and Searching of Java API Reference Documentation.

JqcML: an open-source java API for mass spectrometry quality control data in the qcML format.

The awareness that systematic quality control is an essential factor to enable the growth of proteomics into a mature analytical discipline has increased over the past few years. To this aim, a controlled vocabulary and document structure have recently been proposed by Walzer et al. to store and disseminate quality-control metrics for mass-spectrometry-based proteomics experiments, called qcML. To facilitate the adoption of this standardized quality control routine, we introduce jqcML, a Java application programming interface (API) for the qcML data format. First, jqcML provides a complete object model to represent qcML data. Second, jqcML provides the ability to read, write, and work in a uniform manner with qcML data from different sources, including the XML-based qcML file format and the relational database qcDB. Interaction with the XML-based file format is obtained through the Java Architecture for XML Binding (JAXB), while generic database functionality is obtained by the Java Persistence API (JPA). jqcML is released as open-source software under the permissive Apache 2.0 license and can be downloaded from https://bitbucket.org/proteinspector/jqcml .

JmzTab: A Java interface to the mzTab data standard

mzTab is the most recent standard format developed by the Proteomics Standards Initiative. mzTab is a flexible tab-delimited file that can capture identification and quantification results coming from MS-based proteomics and metabolomics approaches. We here present an open-source Java application programming interface for mzTab called jmzTab. The software allows the efficient processing of mzTab files, providing read and write capabilities, and is designed to be embedded in other software packages. The second key feature of the jmzTab model is that it provides a flexible framework to maintain the logical integrity between the metadata and the table-based sections in the mzTab files. In this article, as two example implementations, we also describe two stand-alone tools that can be used to validate mzTab files and to convert PRIDE XML files to mzTab. The library is freely available at http://mztab.googlecode.com.

The jmzQuantML programming interface and validator for the mzQuantML data standard

The mzQuantML standard from the HUPO Proteomics Standards Initiative has recently been released, capturing quantitative data about peptides and proteins, following analysis of MS data. We present a Java application programming interface (API) for mzQuantML called jmzQuantML. The API provides robust bridges between Java classes and elements in mzQuantML files and allows random access to any part of the file. The API provides read and write capabilities, and is designed to be embedded in other software packages, enabling mzQuantML support to be added to proteomics software tools (http://code.google.com/p/jmzquantml/). The mzQuantML standard is designed around a multilevel validation system to ensure that files are structurally and semantically correct for different proteomics quantitative techniques. In this article, we also describe a Java software tool (http://code.google.com/p/mzquantml-validator/) for validating mzQuantML files, which is a formal part of the data standard.

Light‐weight resource leak testing based on finalisers

Despite garbage collectors, programmers must manually manage many non-memory ‘finite system resources’ such as file descriptors and database connections. Unreleased resources result in ‘resource leaks’ that degrade application performance and can even result in system crashes. It is hard to test resource leaks because of their no immediate symptoms in the short run. There are analysis techniques to detect resource leaks statically or dynamically. However, all of them require the formal specification as input, which seriously decrease their practicability for common software developers. In this study, the authors propose an easy-to-use yet effective resource leak testing approach for Java programs based on existing finalisers of Java Application Programming Interface (API) classes. They instrument resource classes to check that the cleanup method of a resource object is called before its finaliser's execution. Otherwise, this resource object is leaked. To use this approach, programmers just add a few lines of code into their programs and no formal specifications are required. They carry out experiments on benchmarks in the literature to evaluate the incidence of object finalisation and performance cost of finalisers. Experimental results show that the authors' approach can test leaks of most system resources with high effectiveness and low overhead.