Java Annotations Research Articles

Matcha

Apple and Google introduced their versions of privacy nutrition labels to the mobile app stores to better inform users of the apps' data practices. However, these labels are self-reported by developers and have been found to contain many inaccuracies due to misunderstandings of the label taxonomy. In this work, we present Matcha, an IDE plugin that uses automated code analysis to help developers create accurate Google Play data safety labels. Developers can benefit from Matcha's ability to detect user data accesses and transmissions while staying in control of the generated label by adding custom Java annotations and modifying an auto-generated XML specification. Our evaluation with 12 developers showed that Matcha helped our participants improved the accuracy of a label they created with Google's official tool for a real-world app they developed. We found that participants preferred Matcha for its accuracy benefits. Drawing on Matcha, we discuss general design recommendations for developer tools used to create accurate standardized privacy notices.

Manipulating Data Lakes Intelligently With Java Annotations

Manipulating Data Lakes Intelligently With Java Annotations

Automatic Information Extraction from Construction Quality Inspection Regulations: A Knowledge Pattern–Based Ontological Method

Quality compliance checking is essential to ensure construction quality, the prerequisite for which is information extraction from construction quality inspection regulations (CQIRs). Due to the inclusion of multiple qualitative constraints, complex syntax, semantic structures, and exceptions, extracting constraint information from CQIR automatically is difficult. To address the research gap, a knowledge pattern–based ontological method was developed to extract constraint information automatically from CQIR. The entire study process was guided by design science. To begin, knowledge patterns of three typical types of construction quality constraints were investigated to identify constraint elements and their semantic relationships, namely construction procedure constraints, product quality attribute constraints, and resource selection constraints. Then an ontology model was developed to represent these knowledge patterns by defining concepts and properties based on identified constraint elements and semantic relations. Based on the proposed ontology model, Java Annotation Patterns Engine (JAPE) rules were encoded to extract constraint information from CQIR. Finally, a prototype system was created to validate the proposed method, using text data from five mandatory regulations of groundwork and foundation construction. Experimental results demonstrated the theoretical feasibility of the presented method in automatically extracting constraints from CQIR.

Using Java annotations as a tool for providing API

Although Java has such syntax instrument as annotations which are a strong part of that programming language, they are often employed by consumers of logic rather than by theirs’ writers. A quite good example, it’s not hard to discover from Java source code with the @Override, Java compiler processing, the @Autowired commonly used annotation for such framework as Spring, but userwritten annotations are uncommon. Although custom annotations are a rare feature of the Java language, stench, like frameworks like Spring, may be a valuable resource for writing code that is easy to comprehend and accomplishes its goals quickly. Annotations in Java are a kind of labels in the code describing the metadata for a function / class / package. For example, the well-known @Override annotation, which means that we are going to override the method of the parent class. Yes, on the one hand, it is possible without it, but if the parents do not have this method, there is a possibility that we wrote the code in vain, because specifically, this method may never be called, and with the @Override annotation, the compiler will tell us that there was not found such a method in the parents something is unclean here. However, Annotations can carry not only the meaning for reliability, but they can also store some data that will then be used. Annotations as well can be described as descriptors included in the program text and are used to store the metadata of the program code required at different stages of the program life cycle. The information stored in annotations can be used by appropriate processors to create the necessary auxiliary files or to mark classes, fields, etc. Please note that the annotation itself does not affect the method override in any way, but it allows you to control the success of the override during compilation or assembly. We have protected a piece of code from an inconspicuous error that would take hours to find in a large program. This is just one of the many uses for annotations.

Unified programming concepts for unobtrusive integration of cloud-based and local parallel computing

The growth in the data and computation need of today’s operations has led to technical solutions that distribute workload over several entities for better performance. To facilitate such a paradigm, research studies have been investigating efficient approaches for combining high performance computing in shared-memory with distributed-memory environments. Meanwhile, the benefits of cloud computing and its modern enhancements have created potentials for applications to leverage the powerful, ubiquitous and cheap resources of cloud infrastructures. Yet, a small portion of the work in this area addresses the programming aspects of cloud-related technologies. Despite the extensive improvements in the fundamental mechanisms of this realm, programming environments offer little support for incorporating the high performance mechanisms of shared-memory computing with cloud computing. This study proposes a solution for an unobtrusive definition and integration of cloud-based and shared-memory parallel computing, in order to further simplify the application of cloud capabilities in local systems. It does so by implementing the proposed concepts in @PT (Annotation Parallel Task), a parallel-programming environment that utilizes native Java annotations as its language constructs. The experimental evaluations discussed here demonstrate that the proposed approach facilitates achieving the potential benefits of cloud computing for performance and energy consumption in local devices.

Mutating code annotations: An empirical evaluation on Java and C# programs

• 100 new bugs regarding C# code annotations listed. • Evaluation on mutation operators validity for C# code annotations. • A mutation engine tool capable of targeting Java annotations. • A discussion over relationship between bugs found and code annotation use/design. • An evaluation of mutation operators applicability for Java and C# code annotations. • A GitHub repository with 200 bugs related to code annotations in Java and C#. • A mutation engine tool capable of targeting Java annotations. • A discussion over relationship between bugs found and code annotation use/design. Mutation testing injects code changes to check whether tests can detect them. Mutation testing tools use mutation operators that modify program elements such as operators, names, and entire statements. Most existing mutation operators focus on imperative and object-oriented language constructs. However, many current projects use meta-programming through code annotations. In a previous work, we have proposed nine mutation operators for code annotations focused on the Java programming language. In this article, we extend our previous work by mapping the operators to the C# language. Moreover, we enlarge the empirical evaluation. In particular, we mine Java and C# projects that make heavy use of annotations to identify annotation-related faults. We analyzed 200 faults and categorized them as “misuse,” when the developer did not appear to know how to use the code annotations properly, and “wrong annotation parsing” when the developer incorrectly parsed annotation code (by using reflection, for example). Our operators mimic 95% of the 200 mined faults. In particular, three operators can mimic 82% of the faults in Java projects and 84% of the faults in C# projects. In addition, we provide an extended and improved repository hosted on GitHub with the 200 code annotation faults we analyzed. We organize the repository according to the type of errors made by the programmers while dealing with code annotations, and to the mutation operator that can mimic the faults. Last but not least, we also provide a mutation engine, based on these operators, which is publicly available and can be incorporated into existing or new mutation tools. The engine works for Java and C#. As implications for practice, our operators can help developers to improve test suites and parsers of annotated code.

A declarative enhancement of JavaScript programs by leveraging the Java metadata infrastructure

Web browsers have evolved into indispensable software platforms for modern applications. Although JavaScript has become a de-facto lingua franca for developing web applications, the JavaScript software development tools and methodologies lag behind those of languages such as Java and C#. In particular, to enhance JavaScript programs with non-functional concerns (e.g., persistence, security, transactions, and logging) JavaScript developers need to modify the source code by hand. Developers then often end up having to maintain the resulting modified version separately for reasons that include poor design, the complexities of program evolution, and fundamental language limitations. The necessity to modify code by hand could be avoided if JavaScript had metadata facilities for developers to specify non-functional concerns declaratively. To address this problem, we present a novel declarative approach, T ransparent A utomated E nhancement for J ava S cript (TAE-JS) that enhances JavaScript programs with the ability to use declarative metadata. The metadata is expressed by means of Java annotations. We have implemented our technique in an open-source plug-in for the Eclipse IDE. This plug-in allows a developer to enhance the original version of a JavaScript program by specifying concerns declaratively using Java annotations. It then analyzes an original version of the program to automatically generate enhanced program versions by adding the declared concerns. We evaluated TAE-JS with four practical examples that enhance JavaScript programs by declaratively adding concerns such as persistence, security, transactions, and logging. In a user study with ten student developers and three professional engineers at PayPal, the participants viewed favorably TAE-JS's flexible declarative enhancement capabilities, seeing them as a valuable mechanism for implementing non-functional concerns in JavaScript programs. Our evaluation results are promising in demonstrating the potential benefits of our approach to complement existing JavaScript development tools.

Characterizing the Usage, Evolution and Impact of Java Annotations in Practice

Annotations have been formally introduced into Java since Java 5. Since then, 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 knowledge about the actual usage of annotations in practice, the changes made to annotations during software evolution, and the potential impact of annotations on code quality. To fill this gap, we perform the first large-scale empirical study about Java annotations on 1,094 notable open-source projects hosted on GitHub. Our study systematically investigates annotation usage, annotation evolution, and annotation impact, and generates 10 novel and important findings. We also present the implications of our findings, which shed light for developers, researchers, tool builders, and language or library designers in order to improve all facets of Java annotation engineering.

Dandelion: A Unified Code Offloading System for Wearable Computing

Execution speed seriously bothers application developers and users for wearable devices such as Google Glass. Intensive applications like 3D games suffer from significant delays when CPU is busy. Energy is another concern when the devices are in low battery level, but users need them for urgency use. To ease such pains, one approach is to expand the computational power by cloud offloading. This paradigm works well when the available Internet access has enough bandwidth. Another way is to leverage nearby devices for computation-offloading, which is known as device-to-device (D2D) offloading. In this paper, we present Dandelion, a unified code offloading system for wearable computing. Such applications can leverage both the nearby devices and cloud for performance acceleration and energy efficiency. Dandelion is a novel generic code offloading system for wearable computing with a reference implementation on Google Glass. Dandelion includes a programmer-friendly framework based on Java annotation, a lightweight offloading service, and a runtime task scheduler to make offloading decisions. We design some wearable applications and several parallel execution benchmark methods for Dandelion performance evaluation. Extensive experiments on a testbed of Google Glass and Android phones demonstrate that Dandelion generally achieves over 5X execution speedup for local execution and can quickly recover from errors caused by network disruption.

@PT: Unobtrusive parallel programming with Java annotations

SummaryParallel computing techniques have been supported by programming languages in two major ways: either library‐based APIs or extended language constructs. Library‐based features are portable and offer fine‐grained control on parallelization details. However, they rely on individual programmer skills; thus, they may lead to inconsistent implementations and considerable code restructurings. On the contrary, language constructs promote environments that largely conceal the details of parallel programming techniques. However, they normally reduce programmer control over the granularity of parallelization and impose additional development concepts and compilation requirements that may sacrifice ease of use and portability. Therefore, approaches that balance between programmer control on parallelization details, intuitiveness of concepts, and portability can gain priority over other paradigms. In this paper, we discuss @PT (Annotation Parallel Task), a parallel computing framework that proposes Java annotations, standard Java components, as its language constructs. @PT takes an object‐oriented approach on efficient execution and management of asynchronous tasks, with a special focus on GUI‐responsive applications. This paper presents the annotation‐based programming interface of the framework and its fundamental parallelization concepts. Furthermore, it studies the usability and performance of @PT by comparisons with other Java parallelization approaches in a set of standard benchmarks. The observations suggest that @PT maintains a simple programming interface, whereas it performs efficiently in different parallel computing domains.

Design annotations to improve API discoverability

User studies have revealed that programmers face several obstacles when learning application programming interfaces (APIs). A considerable part of such difficulties relate to discovery of API elements and the relationships among them. To address discoverability problems, we show how to complement APIs with design annotations, which document design decisions in a program-processable form for types, methods, and parameters. The information provided by the annotations is consumed by the integrated development environment (IDE) in order to assist API users with useful code completion proposals regarding object creation and manipulation, which facilitate API exploration and learning. As a proof of concept, we developed Dacite, a tool which comprises a set of Java annotations and an accompanying plugin for the Eclipse IDE. A user study revealed that Dacite is usable and effective, and Dacite’s proposals enable programmers to be more successful in solving programming tasks involving unfamiliar APIs.

Spatiotemporal Information Extraction from a Historic Expedition Gazetteer

Historic expeditions are events that are flavored by exploratory, scientific, military or geographic characteristics. Such events are often documented in literature, journey notes or personal diaries. A typical historic expedition involves multiple site visits and their descriptions contain spatiotemporal and attributive contexts. Expeditions involve movements in space that can be represented by triplet features (location, time and description). However, such features are implicit and innate parts of textual documents. Extracting the geospatial information from these documents requires understanding the contextualized entities in the text. To this end, we developed a semi-automated framework that has multiple Information Retrieval and Natural Language Processing components to extract the spatiotemporal information from a two-volume historic expedition gazetteer. Our framework has three basic components, namely, the Text Preprocessor, the Gazetteer Processing Machine and the JAPE (Java Annotation Pattern Engine) Transducer. We used the Brazilian Ornithological Gazetteer as an experimental dataset and extracted the spatial and temporal entities from entries that refer to three expeditioners’ site visits (which took place between 1910 and 1926) and mapped the trajectory of each expedition using the extracted information. Finally, one of the mapped trajectories was manually compared with a historical reference map of that expedition to assess the reliability of our framework.

Aspect oriented implementation of design patterns using metadata

Computer programming paradigms aim to provide better separation of concerns. Aspect oriented programming extends object oriented programming by managing crosscutting concerns using aspects. Two of the most important critics of aspect oriented programming are the “tyranny of the dominant signature” and lack of visibility of program's flow. Metadata, in form of Java annotations, is a solution to both problems. Design patterns are assumed as the general solutions for Object-Oriented matters. They assist in software complexity management and serve as a bridge among software designers as well. These properties have led the patterns to be introduced as a choice in order to prove new technologies. Successful implementations share a generic solution: the usage of annotation to configure and mark the participants, while the pattern's code is encapsulated in aspects. This loses the coupling between aspects and type signatures and between the code base and a specific AOP framework. Also, it increases the developer's awareness of the program's flow. In the present article, aspect oriented programming and design patterns are introduced and also taking the benefit of annotation equipment in java language is proposed as a solution to reduce tight coupling and increase program flow observation rate for aspect oriented programming. Keywords: aspect oriented programming, design patterns, object oriented programming, metadata.

ASPECT ORIENTED IMPLEMENTATION OF DESIGN PATTERNS USING METADATA

Computer programming paradigms aim to provide better separation of concerns. Aspect oriented programming extends object oriented programming by managing crosscutting concerns using aspects. Two of the most important critics of aspect oriented programming are the “tyranny of the dominant signature” and lack of visibility of program's flow. Metadata, in form of Java annotations, is a solution to both problems. Design patterns are assumed as the general solutions for Object-Oriented matters. They assist in software complexity management and serve as a bridge among software designers as well. These properties have led the patterns to be introduced as a choice in order to prove new technologies. Successful implementations share a generic solution: the usage of annotation to configure and mark the participants, while the pattern's code is encapsulated in aspects. This loses the coupling between aspects and type signatures and between the code base and a specific AOP framework. Also, it increases the developer's awareness of the program's flow. In the present article, aspect oriented programming and design patterns are introduced and also taking the benefit of annotation equipment in java language is proposed as a solution to reduce tight coupling and increase program flow observation rate for aspect oriented programming. Keywords : aspect oriented programming, design patterns, object oriented programming, metadata.

Automatic Classification of Ultrasound Screening Examinations of the Abdominal Aorta.

Our work facilitates the identification of veterans who may be at risk for abdominal aortic aneurysms (AAA) based on the 2007 mandate to screen all veteran patients that meet the screening criteria. The main research objective is to automatically index three clinical conditions: pertinent negative AAA, pertinent positive AAA, and visually unacceptable image exams. We developed and evaluated a ConText-based algorithm with the GATE (General Architecture for Text Engineering) development system to automatically classify 1402 ultrasound radiology reports for AAA screening. Using the results from JAPE (Java Annotation Pattern Engine) transducer rules, we developed a feature vector to classify the radiology reports with a decision table classifier. We found that ConText performed optimally on precision and recall for pertinent negative (0.99 (0.98-0.99), 0.99 (0.99-1.00)) and pertinent positive AAA detection (0.98 (0.95-1.00), 0.97 (0.92-1.00)), and respectably for determination of non-diagnostic image studies (0.85 (0.77-0.91), 0.96 (0.91-0.99)). In addition, our algorithm can determine the AAA size measurements for further characterization of abnormality. We developed and evaluated a regular expression based algorithm using GATE for determining the three contextual conditions: pertinent negative, pertinent positive, and non-diagnostic from radiology reports obtained for evaluating the presence or absence of abdominal aortic aneurysm. ConText performed very well at identifying the contextual features. Our study also discovered contextual trigger terms to detect sub-standard ultrasound image quality. Limitations of performance included unknown dictionary terms, complex sentences, and vague findings that were difficult to classify and properly code.

Leveraging annotation-based modeling with Jump

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.

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

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.

Scrap your boilerplate with object algebras

Traversing complex Abstract Syntax Trees (ASTs) typically requires large amounts of tedious boilerplate code. For many operations most of the code simply walks the structure, and only a small portion of the code implements the functionality that motivated the traversal in the first place. This paper presents a type-safe Java framework called Shy that removes much of this boilerplate code. In Shy object algebras are used to describe complex and extensible AST structures. Using Java annotations Shy generates generic boilerplate code for various types of traversals. For a concrete traversal, users of Shy can then inherit from the generated code and override only the interesting cases. Consequently, the amount of code that users need to write is significantly smaller. Moreover, traversals using the Shy framework are also much more structure shy, becoming more adaptive to future changes or extensions to the AST structure. To prove the effectiveness of the approach, we applied Shy in the implementation of a domain-specific questionnaire language. Our results show that for a large number of traversals there was a significant reduction in the amount of user-defined code.

Semantic framework for mapping object-oriented model to semantic web languages.

The article deals with and discusses two main approaches in building semantic structures for electrophysiological metadata. It is the use of conventional data structures, repositories, and programming languages on one hand and the use of formal representations of ontologies, known from knowledge representation, such as description logics or semantic web languages on the other hand. Although knowledge engineering offers languages supporting richer semantic means of expression and technological advanced approaches, conventional data structures and repositories are still popular among developers, administrators and users because of their simplicity, overall intelligibility, and lower demands on technical equipment. The choice of conventional data resources and repositories, however, raises the question of how and where to add semantics that cannot be naturally expressed using them. As one of the possible solutions, this semantics can be added into the structures of the programming language that accesses and processes the underlying data. To support this idea we introduced a software prototype that enables its users to add semantically richer expressions into a Java object-oriented code. This approach does not burden users with additional demands on programming environment since reflective Java annotations were used as an entry for these expressions. Moreover, additional semantics need not to be written by the programmer directly to the code, but it can be collected from non-programmers using a graphic user interface. The mapping that allows the transformation of the semantically enriched Java code into the Semantic Web language OWL was proposed and implemented in a library named the Semantic Framework. This approach was validated by the integration of the Semantic Framework in the EEG/ERP Portal and by the subsequent registration of the EEG/ERP Portal in the Neuroscience Information Framework.

@Java: Bringing a richer annotation model to Java

The ability to annotate code and, in general, the capability to attach arbitrary meta-data to portions of a program are features that have become more and more common in programming languages.Annotations in Java make it possible to attach custom, structured meta-data to declarations of classes, fields and methods. However, the mechanism has some limits: annotations can only decorate declarations and their instantiation can only be resolved statically.With this work, we propose an extension to Java (named @Java) with a richer annotation model, supporting code block and expression annotations, as well as dynamically evaluated members. In other words, in our model, the granularity of annotations extends to the statement and expression level and annotations may hold the result of runtime-evaluated expressions.Our extension to the Java annotation model is twofold: (i) we introduced block and expression annotations and (ii) we allow every annotation to hold dynamically evaluated values. Our implementation also provides an extended reflection API to support inspection and retrieval of our enhanced annotations.