Showing papers on "Java annotation published in 2018"

JCIA: A Tool for Change Impact Analysis of Java EE Applications

Abstract: This paper presents a novel tool for change impact analysis of Java EE applications named JCIA. Analyzing the source code of the Java EE applications is a big challenge because of the complexity and large scale of the applications. Moreover, components in Java EE applications are not only in Java language but also in different languages such as XHTML, XML, JSP. This tool analyzes source code of Java EE applications for building the dependency graphs (called JDG). The main idea for generating JDG is based on developing the source code analyzers for the typical technologies of Java EE such as JavaServer Faces, Context and Dependency Injection, Web services. Based on the obtained JDG and the given change sets, JCIA calculates the corresponding impact sets by applying the change impact analysis (CIA) based on change types and Wave-CIA method. The calculated impact sets help managers in planning and estimating changes, developers in implementing changes, and testers with regression testing.

Ann: A domain-specific language for the effective design and validation of Java annotations

Abstract: This paper describes a new modelling language for the effective design and validation of Java annotations. Since their inclusion in the 5th edition of Java, annotations have grown from a useful tool for the addition of meta-data to play a central role in many popular software projects. Usually they are not conceived in isolation, but in groups, with dependency and integrity constraints between them. However, the native support provided by Java for expressing this design is very limited. To overcome its deficiencies and make explicit the rich conceptual model which lies behind a set of annotations, we propose a domain-specific modelling language. The proposal has been implemented as an Eclipse plug-in, including an editor and an integrated code generator that synthesises annotation processors. The environment also integrates a model finder, able to detect unsatisfiable constraints between different annotations, and to provide examples of correct annotation usages for validation. The language has been tested using a real set of annotations from the Java Persistence API (JPA). Within this subset we have found enough rich semantics expressible with Ann and omitted nowadays by the Java language, which shows the benefits of Ann in a relevant field of application.

Leveraging Annotation-based Modeling with JUMP

Abstract: The capability of UML profiles to serve as annotation mechanism has been recognized in both research and industry. Today’s modeling tools offer profiles specific to platforms, such as Java, as they facilitate model-based engineering approaches. However, considering the large number of possible annotations in Java, manually developing the corresponding profiles would only be achievable by huge development and maintenance efforts. Thus, leveraging annotation-based modeling requires an automated approach capable of generating platform-specific profiles from Java libraries. To address this challenge, we present the fully automated transformation chain realized by Jump, thereby continuing existing mapping efforts between Java and UML by emphasizing on annotations and profiles. The evaluation of Jump shows that it scales for large Java libraries and generates profiles of equal or even improved quality compared to profiles currently used in practice. Furthermore, we demonstrate the practical value of Jump by contributing profiles that facilitate reverse engineering and forward engineering processes for the Java platform by applying it to a modernization scenario.

Characterizing the Usage and Impact of Java Annotations Over 1000+ Projects.

Abstract: As a kind of meta-data feature, annotations have been formally introduced into Java since Java 5. Since the introduction, annotations have been widely used by the Java community for different purposes, such as compiler guidance and runtime processing. Despite the ever-growing use, there is still limited empirical evidence about how developers use annotations in practice and the impact of annotation use on software quality. To fill this gap, we perform the first large-scale empirical study about Java annotation uses on 1,094 open-source projects hosted on GitHub. Our study answers some fundamental questions about Java annotation use. First, we answer the question "annotate what?" and find that annotations are typically used to annotate 4 aspects of program elements. Second, we answer the question "how annotations evolve?" and identify 6 different annotation change types, their frequencies, and their characteristics. Third, we answer the question "who uses annotations?" and establish the relationships between annotation uses and code ownership and developer experience. In addition, we also use regression models to explore the correlation between annotation uses and code quality, and we find that annotations do have an impact on making code less error-prone.

Unobtrusive Asynchronous Exception Handling with Standard Java Try/Catch Blocks

Abstract: The sophisticated nature of parallel computing concepts makes parallel programming challenging. This has encouraged investigations for higher-level frameworks that conceal much of the complications behind abstraction layers. Paradigms in this category are mostly performance centric, and do not share the same sentiments for the robustness of asynchronous executions. This is while current applications demand consistency and soundness in addition to fast performance. Therefore, programming environments that offer high-level support for asynchronous exception handling will have higher chances for popularity. This paper discusses our latest enhancements to @PT, a parallel computing environment that is based on Java annotations. The proposed concept promotes the robustness of parallelized programs by adhering to the familiar exception handling standards of sequential codes, and reducing the asynchronous execution concerns in the API level. This study suggests that the concept simplifies efficient management of asynchronous exception handling concepts that appears to be challenging in parallel programming.

Unobtrusive Support for Asynchronous GUI Operations with Java Annotations

Abstract: The complexities involved in parallel programming encourage frameworks to detach programmers from these concerns via higher-level abstraction. The high-performance nature of parallel computing drifts the focus of these programming environments towards facilitating and safeguarding faster computations. Therefore, aspects such as asynchronous graphical user interfaces (GUIs) do not see as much emphasis, even though many applications today depend on concurrent human-computer interactions. The significance of this topic is growing such that facilitating the efficient management of asynchronous GUI operations is currently a virtue, but will soon become necessary for parallel-programming frameworks. This paper discusses an unobtrusive and annotation-based approach for managing different types of asynchronous GUI operations within the layout of familiar sequential code. The proposed solution minimizes the restructuring of sequential code, in order to simplify developing, testing and maintaining GUI-based applications. Furthermore, the paper presents an implementation of the concept for @PT, a parallel programming environment based on Java annotations. The evaluation discussed in this paper suggests that the proposed mechanism is valid, and demonstrates timely and efficient handling of asynchronous GUI operations.

The Tiny Java Library for Maintaining Model Provenance

Abstract: We present a small library for maintaining the provenance of objects in a software model called The Tiny Java Library for Maintaining Model Provenance (TJLP). A unique characteristic of the library is that it may be applied to existing software models with minimal modification. The library allows the software developer to introduce the ability to move back (undo) and forward (redo) through an object’s instance history with minor alteration of existing code. The requirement is that the model implements the Model interface. Finally, methods that are considered critical in the object’s provenance are adorned with an Undoable annotation. The code necessary to maintain the object’s history is automatically inserted into the critical, undoable-method bytecode when the class definition is loaded by an extended class loader. The states of the model objects are preserved both in memory and on disk to accommodate various computer system configurations. The library performs well for small to medium size models using the default settings, but it may be customized in order to perform better with larger models – especially if the model size approaches the RAM of the underlying computer system.

A modelling language for the effective design of Java annotations

Abstract: This paper describes a new modelling language for the effective design of Java annotations. Since their inclusion in the 5th edition of Java, annotations have grown from a useful tool for the addition of meta-data to play a central role in many popular software projects. Usually they are conceived as sets with dependency and integrity constraints within them; however, the native support provided by Java for expressing this design is very limited. To overcome its deficiencies and make explicit the rich conceptual model which lies behind a set of annotations, we propose a domain-specific modelling language. The proposal has been implemented as an Eclipse plug-in, including an editor and an integrated code generator that synthesises annotation processors. The language has been tested using a real set of annotations from the Java Persistence API (JPA). It has proven to cover a greater scope with respect to other related work in different shared areas of application.