Source Code Annotations Research Articles

Automated facial recognition for wildlife that lack unique markings: A deep learning approach for brown bears.

Emerging technologies support a new era of applied wildlife research, generating data on scales from individuals to populations. Computer vision methods can process large datasets generated through image‐based techniques by automating the detection and identification of species and individuals. With the exception of primates, however, there are no objective visual methods of individual identification for species that lack unique and consistent body markings. We apply deep learning approaches of facial recognition using object detection, landmark detection, a similarity comparison network, and an support vector machine‐based classifier to identify individuals in a representative species, the brown bear Ursus arctos. Our open‐source application, BearID, detects a bear’s face in an image, rotates and extracts the face, creates an “embedding” for the face, and uses the embedding to classify the individual. We trained and tested the application using labeled images of 132 known individuals collected from British Columbia, Canada, and Alaska, USA. Based on 4,674 images, with an 80/20% split for training and testing, respectively, we achieved a facial detection (ability to find a face) average precision of 0.98 and an individual classification (ability to identify the individual) accuracy of 83.9%. BearID and its annotated source code provide a replicable methodology for applying deep learning methods of facial recognition applicable to many other species that lack distinguishing markings. Further analyses of performance should focus on the influence of certain parameters on recognition accuracy, such as age and body size. Combining BearID with camera trapping could facilitate fine‐scale behavioral research such as individual spatiotemporal activity patterns, and a cost‐effective method of population monitoring through mark–recapture studies, with implications for species and landscape conservation and management. Applications to practical conservation include identifying problem individuals in human–wildlife conflicts, and evaluating the intrapopulation variation in efficacy of conservation strategies, such as wildlife crossings.

MCAF: Developing an Annotation-Based Offloading Framework for Mobile Cloud Computing

Offloading computation from mobile to remote cloud servers is a promising way to reduce energy consumption and improve the performance of mobile applications. However, a great challenge arises as automatic integration of powerful computing resources in remote cloud infrastructure and the portability of mobile devices. In this paper, we develop a Java annotation-based offloading framework, called MCAF, for android mobile devices. This framework is designed and committed to simplifying the development of android applications enabled with the offload capability. All the developers need to do is to import the SDK library of our MCAF and annotate the computation-intensive methods. MCAF can automatically extract the annotated source code and generate the code that will be run in the Cloud. Moreover, the codes of making the offloading decisions are automatically inserted into the original source code. We also conducted the real experiments to show the applicability of our MCAF.

Deep Integration of Health Information Service System and Data Mining Analysis Technology

Abstract The scale and complexity of health information service system has increased dramatically, and its development activities and management are difficult to control. In the field of, Traditional methods and simple mathematical statistics methods are difficult to solve the problems caused by the explosive growth of data and information, which will adversely affect health information service system management finally. So, it is particularly important to find valuable information from the source code, design documents and collected software datasets and to guide the development and maintenance of software engineering. Therefore, some experts and scholars want to use mature data mining technologies to study the large amount of data generated in software engineering projects (commonly referred to as software knowledge base), and further explore the potential and valuable information inherently hidden behind the software data. This article initially gives a brief overview of the relevant knowledge of data mining technology and computer software technology, using decision tree graph mining algorithm to mine the function adjustment graph of the software system definition class, and then source code annotations are added to the relevant calling relationships. Data mining technology and computer software technology are deeply integrated, and the decision tree algorithm in data mining is used to mine the knowledge base of computer software. Potential defect changes are listed as key maintenance objects. The historical versions of source code change files with defects are found dynamically and corrected in time, to avoid the increase of maintenance cost in the future.

OS-Aware Interaction Model for the Verification of Multitasking Embedded Software

As the behavior of multitasking embedded software is dependent on the underlying operating system(s), rigorous and efficient verification in this domain requires models of operating systems (OS) that enable OS-aware verification of application programs at reduced cost. However, the heterogeneity of the languages used for OS models and of the program source code makes it difficult to compose these seemingly independent components and thus requires translation of one language into another, causing various issues in verification. To alleviate this problem, we propose a hybrid approach that composes formal OS models with application programs in an interaction model. Based on typical OS-application interaction behavior, our interaction model is a composition framework that connects an OS model to application programs as long as they share the same Application Program Interface (API). It provides seamless composition of two heterogeneous software artifacts by formulating source code annotations based on control-flow analysis and by synchronizing state transitions over API function calls to regulate the context switching of multitasking programs. A prototype implementation of the interaction model was applied to eight benchmark programs of the Erika OS and a control program with real-scale complexity from the automotive domain. It was shown that the framework supports systematic and effective verification of multitasking embedded software, which has not been possible using code-level model checking.

A practical guide to adaptive light-sheet microscopy.

We describe the implementation and use of an adaptive imaging framework for optimizing spatial resolution and signal strength in a light-sheet microscope. The framework, termed AutoPilot, comprises hardware and software modules for automatically measuring and compensating for mismatches between light-sheet and detection focal planes in living specimens. Our protocol enables researchers to introduce adaptive imaging capabilities in an existing light-sheet microscope or use our SiMView microscope blueprint to set up a new adaptive multiview light-sheet microscope. The protocol describes (i) the mechano-optical implementation of the adaptive imaging hardware, including technical drawings for all custom microscope components; (ii) the algorithms and software library for automated adaptive imaging, including the pseudocode and annotated source code for all software modules; and (iii) the execution of adaptive imaging experiments, as well as the configuration and practical use of the AutoPilot framework. Setup of the adaptive imaging hardware and software takes 1-2 weeks each. Previous experience with light-sheet microscopy and some familiarity with software engineering and building of optical instruments are recommended. Successful implementation of the protocol recovers near diffraction-limited performance in many parts of typical multicellular organisms studied with light-sheet microscopy, such as fruit fly and zebrafish embryos, for which resolution and signal strength are improved two- to fivefold.

Exploiting architectural features of a computer vision platform towards reducing memory stalls

Computer vision applications are becoming more and more popular in embedded systems such as drones, robots, tablets, and mobile devices. These applications are both compute and memory intensive, with memory bound stalls (MBS) making a significant part of their execution time. For maximum reduction in memory stalls, compilers need to consider architectural details of a platform and utilize its hardware components efficiently. In this paper, we propose a compiler optimization for a vision-processing system through classification of memory references to reduce MBS. As the proposed optimization is based on the architectural features of a specific platform, i.e., Myriad 2, it can only be applied to other platforms having similar architectural features. The optimization consists of two steps: affinity analysis and affinity-aware instruction scheduling. We suggest two different approaches for affinity analysis, i.e., source code annotation and automated analysis. We use LLVM compiler infrastructure for implementation of the proposed optimization. Application of annotation-based approach on a memory-intensive program shows a reduction in stall cycles by 67.44%, leading to 25.61% improvement in execution time. We use 11 different image-processing benchmarks for evaluation of automated analysis approach. Experimental results show that classification of memory references reduces stall cycles, on average, by 69.83%. As all benchmarks are both compute and memory intensive, we achieve improvement in execution time by up to 30%, with a modest average of 5.79%.

A concurrent constraint programming interpretation of access permissions

AbstractA recent trend in object-oriented programming languages is the use of access permissions (APs) as an abstraction for controlling concurrent executions of programs. The use of AP source code annotations defines a protocol specifying how object references can access the mutable state of objects. Although the use of APs simplifies the task of writing concurrent code, an unsystematic use of them can lead to subtle problems. This paper presents a declarative interpretation of APs as linear concurrent constraint programs (lcc). We represent APs as constraints (i.e., formulas in logic) in an underlying constraint system whose entailment relation models the transformation rules of APs. Moreover, we use processes inlccto model the dependencies imposed by APs, thus allowing the faithful representation of their flow in the program. We verify relevant properties about AP programs by taking advantage of the interpretation oflccprocesses as formulas in Girard's intuitionistic linear logic (ILL). Properties include deadlock detection, program correctness (whether programs adhere to their AP specifications or not), and the ability of methods to run concurrently. By relying on a focusing discipline for ILL, we provide a complexity measure for proofs of the above-mentioned properties. The effectiveness of our verification techniques is demonstrated by implementing the Alcove tool that includes an animator and a verifier. The former executes thelccmodel, observing the flow of APs, and quickly finding inconsistencies of the APs vis-à-vis the implementation. The latter is an automatic theorem prover based on ILL.

A Metrics Suite for code annotation assessment

Code annotation is a language feature that enables the introduction of custom metadata on programming elements. In Java, this feature was introduced on version 5, and today it is widely used by main enterprise application frameworks and APIs. Although this language feature potentially simplifies metadata configuration, its abuse and misuse can reduce source code readability and complicate its maintenance. The goal of this paper is to propose software metrics regarding annotations in the source code and analyze their distribution in real-world projects. We have defined a suite of metrics to assess characteristics of the usage of source code annotations in a code base. Our study collected data from 24947 classes extracted from open source projects to analyze the distribution of the proposed metrics. We developed a tool to automatically extract the metrics and provide a full report on annotations usage. Based on the analysis of the distribution, we defined an appropriate approach for the calculation of thresholds to interpret the metric values. The results allow the assessment of annotated code characteristics. Using the thresholds values, we proposed a way to interpret the use of annotations, which can reveal potential problems in the source code.

An open-source method to analyze optokinetic reflex responses in larval zebrafish

BackgroundOptokinetic reflex (OKR) responses provide a convenient means to evaluate oculomotor, integrative and afferent visual function in larval zebrafish models, which are commonly used to elucidate molecular mechanisms underlying development, disease and repair of the vertebrate nervous system. New methodWe developed an open-source MATLAB-based solution for automated quantitative analysis of OKR responses in larval zebrafish. The package includes applications to: (i) generate sinusoidally-transformed animated grating patterns suitable for projection onto a cylindrical screen to elicit the OKR; (ii) determine and record the angular orientations of the eyes in each frame of a video recording showing the OKR response; and (iii) analyze angular orientation data from the tracking program to yield a set of parameters that quantify essential elements of the OKR. The method can be employed without modification using the operating manual provided. In addition, annotated source code is included, allowing users to modify or adapt the software for other applications. ResultsWe validated the algorithms and measured OKR responses in normal larval zebrafish, showing good agreement with published quantitative data, where available. Comparison with existing method(s)We provide the first open-source method to elicit and analyze the OKR in larval zebrafish. The wide range of parameters that are automatically quantified by our algorithms significantly expands the scope of quantitative analysis previously reported. ConclusionsOur method for quantifying OKR responses will be useful for numerous applications in neuroscience using the genetically- and chemically-tractable zebrafish model.

Sixty-Five Million Years of Change in Temperature and Topography Explain Evolutionary History in Eastern North American Plethodontid Salamanders.

For many taxa and systems, species richness peaks at midelevations. One potential explanation for this pattern is that large-scale changes in climate and geography have, over evolutionary time, selected for traits that are favored under conditions found in contemporary midelevation regions. To test this hypothesis, we use records of historical temperature and topographic changes over the past 65 Myr to construct a general simulation model of plethodontid salamander evolution in eastern North America. We then explore possible mechanisms constraining species to midelevation bands by using the model to predict plethodontid evolutionary history and contemporary geographic distributions. Our results show that models that incorporate both temperature and topographic changes are better able to predict these patterns, suggesting that both processes may have played an important role in driving plethodontid evolution in the region. Additionally, our model (whose annotated source code is included as a supplement) represents a proof of concept to encourage future work that takes advantage of recent advances in computing power to combine models of ecology, evolution, and earth history to better explain the abundance and distribution of species over time.

On narrowing the gap between verification and systematic testing

Abstract Our work on narrowing the gap between verification and systematic testing has two directions: (1) complementing verification with systematic testing, and (2) pushing systematic testing toward reaching verification. In the first direction, we explore how to effectively combine static analysis with systematic testing, so as to guide test generation toward properties that have not been previously checked by a static analyzer in a sound way. This combination significantly reduces the test effort while checking more unverified properties. In the second direction, we push systematic testing toward checking as many executions as possible of a real and complex image parser, so as to prove the absence of a certain class of errors. This verification attempt required no static analysis or source code annotations; our purely dynamic techniques targeted the verification of the parser implementation, including complicated assembly patterns that most static analyses cannot handle.

A hybrid methodology to detect memory leaks in soft real-time embedded systems software

As embedded software becomes complex and time to production needs to be minimized, early fixing of flaws in a software design is important. Memory leaks are the most important memory-related problems commonly occurring in embedded software development. We propose a novel hybrid automated memory leak detection approach for soft real-time embedded system software. Our approach combines static and dynamic methodologies to overcome their individual limitations. The static phase generates potential memory leak warnings with the help of source code annotation and control flow graphs. The dynamic phase involves simulation of abstracted memory behaviour with data collected in an abstract memory model (AMM). Actual leaks are determined from the potential leak warnings generated in the static phase. The dynamic simulation phase makes our approach faster and enables early phase leak detection. Our approach is platform independent and evaluation shows that it is more accurate than existing tools.

A hybrid methodology to detect memory leaks in soft real-time embedded systems software

As embedded software becomes complex and time to production needs to be minimized, early fixing of flaws in a software design is important. Memory leaks are the most important memory-related problems commonly occurring in embedded software development. We propose a novel hybrid automated memory leak detection approach for soft real-time embedded system software. Our approach combines static and dynamic methodologies to overcome their individual limitations. The static phase generates potential memory leak warnings with the help of source code annotation and control flow graphs. The dynamic phase involves simulation of abstracted memory behaviour with data collected in an abstract memory model (AMM). Actual leaks are determined from the potential leak warnings generated in the static phase. The dynamic simulation phase makes our approach faster and enables early phase leak detection. Our approach is platform independent and evaluation shows that it is more accurate than existing tools.

Recording concerns in source code using annotations

A concern can be characterized as a developer׳s intent behind a piece of code, often not explicitly captured in it. We discuss a technique of recording concerns using source code annotations (concern annotations). Using two studies and two controlled experiments, we seek to answer the following 3 research questions: (1) Do programmers׳ mental models overlap? (2) How do developers use shared concern annotations when they are available? (3) Does using annotations created by others improve program comprehension and maintenance correctness, time and confidence? The first study shows that developers׳ mental models, recorded using concern annotations, overlap and thus can be shared. The second study shows that shared concern annotations can be used during program comprehension for the following purposes: hypotheses confirmation, feature location, obtaining new knowledge, finding relationships and maintenance notes. The first controlled experiment with students showed that the presence of annotations significantly reduced program comprehension and maintenance time by 34%. The second controlled experiment was a differentiated replication of the first one, focused on industrial developers. It showed a 33% significant improvement in correctness. We conclude that concern annotations are a viable way to share developers׳ thoughts.

Language composition using source code annotations

In this paper we examine source code annotations from the viewpoint of formal languages - we discuss their abstract syntax, concrete syntax, and semantics, thus showing the correspondence between annotations and formal languages. We propose to consider a set of all annotations and their parameters processed by the same reference implementation (they belong to the same domain) to be called an annotation-based language. The performed analysis also pinpoints a specificity of annotations in comparison with formal languages in general - the binding between annotations and a host language. We elaborate this idea with an analysis of annotations? potential for language composition, in particular for pure embedding. We then show how pure embedding with annotations can be used for language unification, language referencing by extension, and language extension. This work provides a basis for further research in the field of source code annotations in the context of formal languages.

Safe and efficient hybrid memory management for Java

Java uses automatic memory management, usually implemented as a garbage-collected heap. That lifts the burden of manually allocating and deallocating memory, but it can incur significant runtime overhead and increase the memory footprint of applications. We propose a hybrid memory management scheme that utilizes region-based memory management to deallocate objects automatically on region exits. Static program analysis detects allocation sites that are safe for region allocation, i.e., the static analysis proves that the objects allocated at such a site are not reachable after the region exit. A regular garbage-collected heap is used for objects that are not region allocatable. The region allocation exploits the temporal locality of object allocation. Our analysis uses coarse-grain source code annotations to disambiguate objects with non-overlapping lifetimes, and maps them to different memory scopes. Region-allocated memory does not require garbage collection as the regions are simply deallocated when they go out of scope. The region allocation technique is backed by a garbage collector that manages memory that is not region allocated. We provide a detailed description of the analysis, provide experimental results showing that as much as 78% of the memory is region allocatable and discuss how our hybrid memory management system can be implemented efficiently with respect to both space and time.

ASAC

The approximation based programming paradigm is especially attractive for developing error-resilient applications, targeting low power embedded devices. It allows for program data to be computed and stored approximately for better energy efficiency. The duration of battery in the smartphones, tablets, etc. is generally more of a concern to users than an application's accuracy or fidelity beyond certain acceptable quality of service. Therefore, relaxing accuracy to improve energy efficiency is an attractive trade-off when permissible by the application's domain. Recent works suggest source code annotations and type qualifiers to facilitate safe approximate computation and data manipulation. It requires rewriting of programs or the availability of source codes for annotations. This may not be feasible as real-world applications tend to be large, with source code that is not readily available. In this paper, we propose a novel sensitivity analysis that automatically generates annotations for programs for the purpose of approximate computing. Our framework, ASAC, extracts information about the sensitivity of the output with respect to program data. We show that the program output is sensitive to only a subset of program data that we deem critical, and hence must be precise. The rest of the data can be computed and stored approximately.We evaluated our analysis on a range of applications, and achieved a 86% accuracy compared to manual annotations by programmers. We validated our analysis by showing that the applications are within the acceptable QoS threshold if we approximate the non-critical data.

XML to annotations mapping definition with patterns

Currently, the most commonly created formal languages are configuration languages. So far source code annotations and XML are the leading notations for configuration languages. In this paper, we analyse the correspondence between these two formats. We show that there are typical XML to annotations mapping solutions (mapping patterns) that indicate a correspondence between embedded and external metadata formats in general. We argue that mapping patterns facilitate creating configuration tools and we use a case study to show how they can be used to devise a mapping between these two notations.

Practical JFSL verification using TACO

SUMMARYTranslation of Annotated COde (TACO) is a SAT‐based tool for bounded verification of Java programs. One challenge many formal tools share is to provide a practical interface for a non‐proficient user. In this article, we present an Eclipse plug‐in for the static verifier TACO. This plug‐in allows a user to walk a counterexample trace mimicking a debugging session. TacoPlug (our plug‐in) uses and extends TACO to provide a better debugging experience. TacoPlug interface allows the user to verify an annotated software using the TACO verifier. If TACO finds a violation to the specification, TacoPlug presents it in terms of the annotated source code. TacoPlug features several views of the error trace to facilitate fault understanding. It resembles any software debugger, but the debugging occurs statically without executing the program. Furthermore, should a dynamic analysis be required, TacoPlug presents the user with a unit test case generated by TACO based on the detected violation. We show the usability of our tool by means of a motivational example taken from a real‐life software error. Copyright © 2013 John Wiley & Sons, Ltd.

Computing and visualizing the impact of change with Java PathFinder extensions

Change impact analysis techniques estimate the potential effects of changes made to software. Directed Incremental Symbolic Execution (DiSE) is a Java PathFinder extension that computes the impact of changes on program execution behaviors. The results of DiSE are a set of impacted path conditions that can be efficiently processed by a subsequent client analysis. Path conditions, however, may not be intuitive for software developers without the context of the source code. In this paper we present a framework for visualizing the results of DiSE. The visualization includes annotated source code and control ow graphs indicating program statements that are changed and statements that may be impacted by the changes. A simulation mode enables users to also observe the impact of changes on symbolic execution of the program, by showing the changes to the path conditions as the user steps through the sequences of statements executed.