Existing Software Libraries Research Articles

API-Driven Program Synthesis for Testing Static Typing Implementations

We introduce a novel approach for testing static typing implementations based on the concept of API-driven program synthesis. The idea is to synthesize type-intensive but small and well-typed programs by leveraging and combining application programming interfaces (APIs) derived from existing software libraries. Our primary insight is backed up by real-world evidence: a significant number of compiler typing bugs are caused by small test cases that employ APIs from the standard library of the language under test. This is attributed to the inherent complexity of the majority of these APIs, which often exercise a wide range of sophisticated type-related features. The main contribution of our approach is the ability to produce small client programs with increased feature coverage, without bearing the burden of generating the corresponding well-formed API definitions from scratch. To validate diverse aspects of static typing procedures (i.e., soundness, precision of type inference), we also enrich our API-driven approach with fault-injection and semantics-preserving modes, along with their corresponding test oracles. We evaluate our implemented tool, Thalia on testing the static typing implementations of the compilers for three popular languages, namely, Scala, Kotlin, and Groovy. Thalia has uncovered 84 typing bugs (77 confirmed and 22 fixed), most of which are triggered by test cases featuring APIs that rely on parametric polymorphism, overloading, and higher-order functions. Our comparison with state-of-the-art shows that Thalia yields test programs with distinct characteristics, offering additional and complementary benefits.

Gonomics: uniting high performance and readability for genomics with Go.

Many existing software libraries for genomics require researchers to pick between competing considerations: the performance of compiled languages and the accessibility of interpreted languages. Go, a modern compiled language, provides an opportunity to address this conflict. We introduce Gonomics, an open-source collection of command line programs and bioinformatic libraries implemented in Go that unites readability and performance for genomic analyses. Gonomics contains packages to read, write, and manipulate a wide array of file formats (e.g. FASTA, FASTQ, BED, BEDPE, SAM, BAM, and VCF), and can convert and interface between these formats. Furthermore, our modular library structure provides a flexible platform for researchers developing their own software tools to address specific questions. These commands can be combined and incorporated into complex pipelines to meet the growing need for high-performance bioinformatic resources. Gonomics is implemented in the Go programming language. Source code, installation instructions, and documentation are freely available at https://github.com/vertgenlab/gonomics.

VALIDATION OPTIMIZATION ENVIRONMENT FOR IMPROVED SELECTION OF SOFTWARE COMPONENTS: CONCEPTUAL MODELING AND ARCHITECTURE

Responding to the needs of a user, the selection of software components for building computer applications is a crucial step. In the matter, optimization tools exist to experiment the developed models. However, these tools are not suitable for the user and especially for a non-expert. In this article, we propose to build a software environment validating our optimization model. It is therefore an automatic aid simulator for the choice of software components of websites for the construction of modular systems. By using the method of analysis in particular the unified process of UML, at the end of our conceptual modeling, the diagrams of classes, sequences and activities are obtained. Moreover, a simulator architecture, an operation algorithm and an optimization algorithm capable of improving the choice in the selection of software components among the existing software libraries are built. Our simulator system environment is nearing completion.

UncertainSCI: Uncertainty quantification for computational models in biomedicine and bioengineering

Background:Computational biomedical simulations frequently contain parameters that model physical features, material coefficients, and physiological effects, whose values are typically assumed known a priori. Understanding the effect of variability in those assumed values is currently a topic of great interest. A general-purpose software tool that quantifies how variation in these parameters affects model outputs is not broadly available in biomedicine. For this reason, we developed the ‘UncertainSCI’ uncertainty quantification software suite to facilitate analysis of uncertainty due to parametric variability. Methods:We developed and distributed a new open-source Python-based software tool, UncertainSCI, which employs advanced parameter sampling techniques to build polynomial chaos (PC) emulators that can be used to predict model outputs for general parameter values. Uncertainty of model outputs is studied by modeling parameters as random variables, and model output statistics and sensitivities are then easily computed from the emulator. Our approaches utilize modern, near-optimal techniques for sampling and PC construction based on weighted Fekete points constructed by subsampling from a suitably randomized candidate set. Results:Concentrating on two test cases—modeling bioelectric potentials in the heart and electric stimulation in the brain—we illustrate the use of UncertainSCI to estimate variability, statistics, and sensitivities associated with multiple parameters in these models. Conclusion:UncertainSCI is a powerful yet lightweight tool enabling sophisticated probing of parametric variability and uncertainty in biomedical simulations. Its non-intrusive pipeline allows users to leverage existing software libraries and suites to accurately ascertain parametric uncertainty in a variety of applications.

GinJinn2: Object detection and segmentation for ecology and evolution

Abstract Collection and preparation of empirical data still represent one of the most important, but also expensive steps in ecological and evolutionary/systematic research. Modern machine learning approaches, however, have the potential to automate a variety of tasks, which until recently could only be performed manually. Unfortunately, the application of such methods by researchers outside the field is hampered by technical difficulties. Here, we present GinJinn2, a user‐friendly toolbox for deep learning‐based object detection and instance segmentation on image data. Besides providing a convenient command‐line interface to existing software libraries, it comprises several additional tools for data handling, pre‐ and postprocessing, and building advanced analysis pipelines. We demonstrate the application of GinJinn2 for biological purposes using four exemplary analyses, namely the evaluation of seed mixtures, detection of insects on glue traps, segmentation of stomata and extraction of leaf silhouettes from herbarium specimens. GinJinn2, by providing a coding‐free environment, will enable users with a primary background in biology to apply deep learning‐based methods for object detection and segmentation in order to automate feature extraction from image data.

Open-Source Coprocessor for Integer Multiple Precision Arithmetic

This paper presents an open-source digital circuit of the coprocessor for an integer multiple-precision arithmetic (MPA). The purpose of this coprocessor is to support a central processing unit (CPU) by offloading computations requiring integer precision higher than 32/64 bits. The coprocessor is developed using the very high speed integrated circuit hardware description language (VHDL) as an intellectual property (IP) core. Therefore, it can be implemented within field programmable gate arrays (FPGAs) at various scales, e.g., within a system on chip (SoC), combining CPU cores and FPGA within a single chip as well as FPGA acceleration cards. The coprocessor handles integer numbers with precisions in the range 64 bits–32 kbits, with the limb size set to 64 bits. In our solution, the sign-magnitude representation is used to increase the efficiency of the multiplication operation as well as to provide compatibility with existing software libraries for MPA. The coprocessor is benchmarked in factorial ( n ! ), exponentiation ( n n ) and discrete Green’s function (DGF) computations on Xilinx Zynq-7000 SoC on TySOM-1 board from Aldec. In all benchmarks, the coprocessor demonstrates better runtimes than a CPU core (ARM Cortex A9) executing the same computations using a software MPA library. For sufficiently large input parameters, our coprocessor is up to three times faster when implemented in FPGA on SoC, rising to a factor of ten in DGF computations. The open-source coprocessor code is licensed under the Mozilla Public License.

Implementation of Graphic Plugin Loading Platform Based on Python

With the scripting language getting more and more mature, individual developers can also develop script programs according to their own needs based on the existing software library. In order to help individual developers to quickly and simply complete the software graphical problems, a graphical plugin loading platform is developed based on Python language. Through the specified plugin class standard, developers can quickly convert existing scripts or develop scripts according to plugin class, and easily realize the software graphical.

Cryptography for #MeToo

Abstract Reporting sexual assault and harassment is an important and difficult problem. Since late 2017, it has received increased attention as the viral #MeToo movement has brought about accusations against high-profile individuals and a wider discussion around the prevalence of sexual violence. Addressing occurrences of sexual assault requires a system to record and process accusations. It is natural to ask what security guarantees are necessary and achievable in such a system. In particular, we focus on detecting repeat offenders: only when a set number of accusations are lodged against the same party will the accusations be revealed to a legal counselor. Previous solutions to this privacy-preserving reporting problem, such as the Callisto Protocol of Rajan et al., have focused on the confidentiality of accusers. This paper proposes a stronger security model that ensures the confidentiality of the accuser and the accused as well as the traceability of false accusations. We propose the WhoToo protocol to achieve this notion of security using suitable cryptographic techniques. The protocol design emphasizes practicality, preferring fast operations that are implemented in existing software libraries. We estimate that an implementation would be suitably performant for real-world deployment.

Dynamic Dependence Summaries

Software engineers construct modern-day software applications by building on existing software libraries and components that they necessarily do not author themselves. Thus, contemporary software applications rely heavily on existing standard and third-party libraries for their execution and behavior. As such, effective runtime analysis of such a software application’s behavior is met with new challenges. To perform dynamic analysis of a software application, all transitively dependent external libraries must also be monitored and analyzed at each layer of the software application’s call stack. However, monitoring and analyzing large and often numerous external libraries may prove to be prohibitively expensive. Moreover, an overabundance of library-level analyses may obfuscate the details of the actual software application’s dynamic behavior. In other words, the extensive use of existing libraries by a software application renders the results of its dynamic analysis both expensive to compute and difficult to understand. We model software component behavior as dynamically observed data- and control dependencies between inputs and outputs of a software component. Such data- and control dependencies are monitored at a fine-grain instruction-level and are collected as dynamic execution traces for software runs. As an approach to address the complexities and expenses associated with analyzing dynamically observable behavior of software components, we summarize and reuse the data- and control dependencies between the inputs and outputs of software components. Dynamically monitored data- and control dependencies, between the inputs and outputs of software components, upon summarization are called dynamic dependence summaries . Software components, equipped with dynamic dependence summaries, afford the omission of their exhaustive runtime analysis. Nonetheless, the reuse of dependence summaries would necessitate the abstraction of any concrete runtime information enclosed within the summary, thus potentially causing a loss in the information modeled by the dependence summary. Therefore, benefits to the efficiency of dynamic analyses that use such summarization may be afforded with losses of accuracy. As such, we evaluate the potential accuracy loss and the potential performance gain with the use of dynamic dependence summaries. Our results show, on average, a 13× speedup with the use of dynamic dependence summaries, with an accuracy of 90% in a real-world software engineering task.

Augmented reality implementation methods in mainstream applications

Augmented reality has became an useful tool in many areas from space exploration to military applications. Although used theoretical principles are well known for almost a decade, the augmented reality is almost exclusively used in high budget solutions with a special hardware. However, in last few years we could see rising popularity of many projects focused on deployment of the augmented reality on dif­ferent mobile devices. Our article is aimed on developers who consider development of an augmented reality application for the mainstream market. Such developers will be forced to keep the application price, therefore also the development price, at reasonable level. Usage of existing image processing software library could bring a significant cut-down of the development costs. In the theoretical part of the article is presented an overview of the augmented reality application structure. Further, an approach for selection appropriate library as well as the review of the existing software libraries focused in this area is described. The last part of the article out­lines our implementation of key parts of the augmented reality application using the OpenCV library.

Open source libraries and frameworks for mass spectrometry based proteomics: A developer's perspective

Data processing, management and visualization are central and critical components of a state of the art high-throughput mass spectrometry (MS)-based proteomics experiment, and are often some of the most time-consuming steps, especially for labs without much bioinformatics support. The growing interest in the field of proteomics has triggered an increase in the development of new software libraries, including freely available and open-source software. From database search analysis to post-processing of the identification results, even though the objectives of these libraries and packages can vary significantly, they usually share a number of features. Common use cases include the handling of protein and peptide sequences, the parsing of results from various proteomics search engines output files, and the visualization of MS-related information (including mass spectra and chromatograms). In this review, we provide an overview of the existing software libraries, open-source frameworks and also, we give information on some of the freely available applications which make use of them. This article is part of a Special Issue entitled: Computational Proteomics in the Post-Identification Era. Guest Editors: Martin Eisenacher and Christian Stephan.

Comparing and evaluating computer graphics and visualization software

AbstractWhen starting a new computer graphics or visualization software project, students, researchers, and businesses alike must decide whether or not to start from scratch or with third‐party software. Since computer graphics and visualization applications are typically quite large, developers often build upon existing software libraries in order to take advantage of the tens of thousands of hours worth of development and testing already invested. Thus, developers and managers must face the decision of which library to build on. We present a side‐by‐side comparison and evaluation of four popular, state‐of‐the‐art visualization and computer graphics libraries, namely the Visualization Toolkit (VTK), Open Inventor, Coin3D, and Hoops 3D. The evaluation is based on the feature set, ease of installation, development of a benchmark application, documentation, and technical support for each package. The results of our comparison and evaluation are described and recommendations are given as for whom the libraries are best suited. The VTK prevails on top in many of the aspects we compared and evaluated. Copyright © 2007 John Wiley & Sons, Ltd.

Improving numerical software

Traditionally there have been two opposite theories in software engineering. The first is that users want “black box” software that they can use with complete confidence for general problem classes without having to understand the fine algorithmic details. The second is that users want to be able to tune data structures for a particular application, even if the software is not as reliable as that provided for general methods. It turns out both are true, for different groups of users. Traditionally, users have asked for and been provided with “black box” software in the form of mathematical libraries such as LAPACK, LINPACK, NAG, and IMSL. More recently, the high-performance community has discovered that they must write custom software for their problem. Their reasons include inadequate functionality of existing software libraries, data structures that are not natural or convenient for a particular problem and overly general software that sacrifices too much performance when applied to a special case of interest. Can we improve numerical libraries? The answer is yes and we are going to investigate in this paper some methods.

QCS: A system for querying, clustering and summarizing documents

Information retrieval systems consist of many complicated components. Research and development of such systems is often hampered by the difficulty in evaluating how each particular component would behave across multiple systems. We present a novel integrated information retrieval system—the Query, Cluster, Summarize (QCS) system—which is portable, modular, and permits experimentation with different instantiations of each of the constituent text analysis components. Most importantly, the combination of the three types of methods in the QCS design improves retrievals by providing users more focused information organized by topic. We demonstrate the improved performance by a series of experiments using standard test sets from the Document Understanding Conferences (DUC) as measured by the best known automatic metric for summarization system evaluation, ROUGE. Although the DUC data and evaluations were originally designed to test multidocument summarization, we developed a framework to extend it to the task of evaluation for each of the three components: query, clustering, and summarization. Under this framework, we then demonstrate that the QCS system (end-to-end) achieves performance as good as or better than the best summarization engines. Given a query, QCS retrieves relevant documents, separates the retrieved documents into topic clusters, and creates a single summary for each cluster. In the current implementation, Latent Semantic Indexing is used for retrieval, generalized spherical k-means is used for the document clustering, and a method coupling sentence “trimming” and a hidden Markov model, followed by a pivoted QR decomposition, is used to create a single extract summary for each cluster. The user interface is designed to provide access to detailed information in a compact and useful format. Our system demonstrates the feasibility of assembling an effective IR system from existing software libraries, the usefulness of the modularity of the design, and the value of this particular combination of modules.

APECS – the Atacama pathfinder experiment control system

APECS is the distributed control system of the new Atacama Pathfinder EXperiment (APEX) telescope located on the Llano de Chajnantor at an altitude of 5107 m in the Atacama desert in northern Chile. APECS is based on Atacama Large Millimeter Array (ALMA) software and employs a modern, object-oriented design using the Common Object Request Broker Architecture (CORBA) as the middleware. New generic device interfaces simplify adding instruments to the control system. The Python based observer command scripting language allows using many existing software libraries and facilitates creating more complex observing modes. A new self-descriptive raw data format (Multi-Beam FITS or MBFITS) has been defined to store the multi-beam, multi-frequency data. APECS provides an online pipeline for initial calibration, observer feedback and a quick-look display. APECS is being used for regular science observations in local and remote mode since August 2005.

Extending object database interfaces with fuzziness through aspect-oriented design

Fuzzy logic has been used yet for extending database models to deal with vagueness in the definitions of linguistic concepts as "tall" or "long". However, the extension of existing programming interfaces for fuzziness requires a proper modularization of the underlying concerns of numerical imprecision handling. Such modularization should not interfere with existing programming practices, and they should not obscure the original design. Aspect-oriented design (AOD) enables such form of non-intrusive extensions to be added to existing software libraries. In this paper, the main design and implementation issues of such AOD-based extensions on OJB database libraries are briefly sketched.

Introducing fuzziness in object models and database interfaces through aspects

Imperfection in information can be considered a crosscutting concern that manifests itself in diverse kinds of imprecision, uncertainty, or inconsistency in the data models of a software system. The extension of existing programming and querying interfaces for the different aspects of information imperfection requires a proper modularization of the different concerns of numerical imprecision handling, so that the extensions do not interfere with existing programming practices and do not obscure the original design. Aspect-oriented design (AOD) enables such a form of nonintrusive extensions to be added to existing software libraries, clearly separating fuzziness or other imperfections in data as a differentiated concern that can be considered from the early phases of development. In this article, a general framework for aspect-based extension of data models and fuzzy databases is described, and some design and implementation issues of such AOD-based extensions on OJB database libraries are described as a case study. © 2006 Wiley Periodicals, Inc. Int J Int Syst 21: 1199–1216, 2006.

Interfacing Software Libraries from Nondeterministic Prototypes

Modeling software systems is one of the most obvious uses of a formal specification language. A software prototype, automatically generated from the specification, enables the developer to validate the system in a real environment. However, real software systems are seldom developed from scratch, but rather built using existing libraries. In this paper, we show how a program based on existing software libraries is modeled in the Concurrent Object-Oriented Petri Net specification language, and how a prototype code is generated from the specification. In particular, we study the interface between nondeterminist synchronous prototypes and determinist asynchronous software libraries. We take into account, problems related with nonreversibility of actions and the transactional semantics of the specification language that is kept in the prototypes. A convenient delayed execution mechanism is proposed for the library linking part of the generated code.

Reusability of mathematical software: a contribution

Mathematical software is devoted to solving problems involving matrix computation and manipulation. The main problem limiting the reusability of existing mathematical software is that programs are often not initially designed for being reused. Therefore, it is hard to find programs that can be easily reused. A programming methodology useful for designing and implementing reusable code is presented. A portion of code designed and implemented for being reused is called a unit. The units are self-contained software components featuring a high degree of information hiding. This way of organizing software facilitates the reuse process and improves the understandability of units. To speed up the implementation process, a system supporting the reusability of units from an existing software library is particularly useful. The functionality of the EasyCard system, which creates, maintains, and queries a catalog of units is discussed.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

IDENTIFYING REUSABLE SOFTWARE COMPONENTS BY INDUCTION

The goal of the Partial Metrics Project is the automatic acquisition of planning knowledge from target code modules in a program library. In the current prototype the system is given a target code module written in Ada as input, and the result is a sequence of generalized transformations that can be used to design a class of related modules. This is accomplished by embedding techniques from Artificial Intelligence into the traditional structure of a compiler. The compiler performs compilation in reverse, starting with detailed code and producing an abstract description of it. The principal task facing the compiler is to find a decomposition of the target code into a collection of syntactic components that are nearly decomposable. Here, nearly decomposable corresponds to the need for each code segment to be nearly independent syntactically from the others. The most independent segments are then the target of the code generalization process. This process can be described as a form of chunking and is implemented here in terms of explanation-based learning. The problem of producing nearly decomposable code components becomes difficult when target code module is not well structured. The task facing users of the system is to be able to identify well-structured code modules from a library of modules that are suitable for input to the system. In this paper we describe the use of inductive learning techniques, namely variations on Quinlan's ID3 system that are capable of producing a decision tree that can be used to conceptually distinguish between well poorly structured code. In order to accomplish that task a set of high-level concepts used by software engineers to characterize structurally understandable code were identified. Next, each of these concepts was operationalized in terms of code complexity metrics that can be easily calculated during the compilation process. These metrics are related to various aspects of the program structure including its coupling, cohesion, data structure, control structure, and documentation. Each candidate module was then described in terms of a collection of such metrics. Using a training set of positive and negative examples of well-structured modules, each described in terms of the appointed metrics, a decision tree was produced that was used to recognize other well-structured modules in terms of their metric properties. This approach was applied to modules from existing software libraries in a variety of domains such as database, editor, graphic, window, data processing, FFT and computer vision software. The results achieved by the system were then benchmarked against the performance of experienced programmers in terms of recognizing well structured code. In a test case involving 120 modules, the system was able to discriminate between poor and well-structured code 99% of the time as compared to an 80% average for the 52 programmers sampled. The results suggest that such an inductive system can serve as a practical mechanism for effectively identifying reusable code modules in terms of their structural properties.