Library Of Reusable Components Research Articles

Semantic models and tools for designing adaptive user interfaces of intelligent systems

Objectives. Models and tools for designing adaptive user interfaces for intelligent systems are being developed. The relevance is determined by the need to reduce overhead costs and development time for user interfaces and to provide their adaptation to the specific characteristics of the user of the intelligent system.Methods. Existing approaches to designing user interfaces are being analyzed. A semantic model of an adaptive user interface for intelligent systems is proposed, implemented using a basic universal language for representing knowledge based on set theory and graph theory.Results. An adaptive user interface model for intelligent systems has been developed, which includes a knowledge base model of the user interface, an agent-oriented model of the user interface, and a library of reusable components that provide integration of the user interface into both individual intelligent systems and intelligent systems groups. A method of transferring user interface components within an intelligent systems group during the operation of an intelligent system has also been developed.Conclusion. Developed models and tools allow to simplify the reuse of user interface components together with knowledge base and problem-solving components in the design and development of individual intelligent systems, as well as in the design and development of a group of semantically compatible intelligent systems, ensuring automation of integration of user interfaces and their adaptation for each user. The developed set of user interface components has been included in a library of reusable user interface components. Further expansion of the set of components in the library and their integration into a group of semantically compatible intelligent systems is planned.

Problem Solver Model of Intelligent Framework for the Development of Artificial Neural Networks

The article describes an approach to implementing the ability of intelligent systems to self-learn through an intelligent framework for the development of artificial neural networks. A method of interaction between intelligent systems and a framework based on a library of reusable components is proposed, which allows to automatically design and train artificial neural networks based on a given problem specification. Based on the analysis of the activity of developers of artificial neural networks, a model of the problem solver of such a framework is described in the form of a hierarchy of actions for the development of artificial neural networks.

OpenFIBSEM: A universal API for FIBSEM control

This paper introduces OpenFIBSEM, a universal API to control Focused Ion Beam Scanning Electron Microscopes (FIBSEM). OpenFIBSEM aims to improve the programmability and automation of electron microscopy workflows in structural biology research. The API is designed to be cross-platform, composable, and extendable: allowing users to use any portion of OpenFIBSEM to develop or integrate with other software tools. The package provides core functionality such as imaging, movement, milling, and manipulator control, as well as system calibration, alignment, and image analysis modules. Further, a library of reusable user interface components integrated with napari is provided, ensuring easy and efficient application development.OpenFIBSEM currently supports ThermoFisher and TESCAN hardware, with support for other manufacturers planned. To demonstrate the improved automation capabilities enabled by OpenFIBSEM, several example applications that are compatible with multiple hardware manufacturers are discussed. We argue that OpenFIBSEM provides the foundation for a cross-platform operating system and development ecosystem for FIBSEM systems. The API and applications are open-source and available on GitHub (https://github.com/DeMarcoLab/fibsem).

Nightingale: web components for protein feature visualization.

The visualization of biological data is a fundamental technique that enables researchers to understand and explain biology. Some of these visualizations have become iconic, for instance: tree views for taxonomy, cartoon rendering of 3D protein structures or tracks to represent features in a gene or protein, for instance in a genome browser. Nightingale provides visualizations in the context of proteins and protein features. Nightingale is a library of re-usable data visualization web components that are currently used by UniProt and InterPro, among other projects. The components can be used to display protein sequence features, variants, interaction data, 3D structure, etc. These components are flexible, allowing users to easily view multiple data sources within the same context, as well as compose these components to create a customized view. Nightingale examples and documentation are freely available at https://ebi-webcomponents.github.io/nightingale/. It is distributed under the MIT license, and its source code can be found at https://github.com/ebi-webcomponents/nightingale.

Revisiting Language Support for Generic Programming: When Genericity Is a Core Design Goal

Context: Generic programming, as defined by Stepanov, is a methodology for writing efficient and reusable algorithms by considering only the required properties of their underlying data types and operations. Generic programming has proven to be an effective means of constructing libraries of reusable software components in languages that support it. Generics-related language design choices play a major role in how conducive generic programming is in practice. Inquiry: Several mainstream programming languages (e.g. Java and C++) were first created without generics; features to support generic programming were added later, gradually. Much of the existing literature on supporting generic programming focuses thus on retrofitting generic programming into existing languages and identifying related implementation challenges. Is the programming experience significantly better, or different when programming with a language designed for generic programming without limitations from prior language design choices? Approach: We examine Magnolia, a language designed to embody generic programming. Magnolia is representative of an approach to language design rooted in algebraic specifications. We repeat a well-known experiment, where we put Magnolia's generic programming facilities under scrutiny by implementing a subset of the Boost Graph Library, and reflect on our development experience. Knowledge: We discover that the idioms identified as key features for supporting Stepanov-style generic programming in the previous studies and work on the topic do not tell a full story. We clarify which of them are more of a means to an end, rather than fundamental features for supporting generic programming. Based on the development experience with Magnolia, we identify variadics as an additional key feature for generic programming and point out limitations and challenges of genericity by property. Grounding: Our work uses a well-known framework for evaluating the generic programming facilities of a language from the literature to evaluate the algebraic approach through Magnolia, and we draw comparisons with well-known programming languages. Importance: This work gives a fresh perspective on generic programming, and clarifies what are fundamental language properties and their trade-offs when considering supporting Stepanov-style generic programming. The understanding of how to set the ground for generic programming will inform future language design.

PDBe-KB: collaboratively defining the biological context of structural data.

The Protein Data Bank in Europe – Knowledge Base (PDBe-KB, https://pdbe-kb.org) is an open collaboration between world-leading specialist data resources contributing functional and biophysical annotations derived from or relevant to the Protein Data Bank (PDB). The goal of PDBe-KB is to place macromolecular structure data in their biological context by developing standardised data exchange formats and integrating functional annotations from the contributing partner resources into a knowledge graph that can provide valuable biological insights. Since we described PDBe-KB in 2019, there have been significant improvements in the variety of available annotation data sets and user functionality. Here, we provide an overview of the consortium, highlighting the addition of annotations such as predicted covalent binders, phosphorylation sites, effects of mutations on the protein structure and energetic local frustration. In addition, we describe a library of reusable web-based visualisation components and introduce new features such as a bulk download data service and a novel superposition service that generates clusters of superposed protein chains weekly for the whole PDB archive.

A Fast and Scalable Heuristic for the Solution of Large-Scale Capacitated Vehicle Routing Problems

In this paper, we propose a fast and scalable, yet effective, metaheuristic called FILO to solve large-scale instances of the Capacitated Vehicle Routing Problem. Our approach consists of a main iterative part, based on the Iterated Local Search paradigm, which employs a carefully designed combination of existing acceleration techniques, as well as novel strategies to keep the optimization localized, controlled, and tailored to the current instance and solution. A Simulated Annealing-based neighbor acceptance criterion is used to obtain a continuous diversification, to ensure the exploration of different regions of the search space. Results on extensively studied benchmark instances from the literature, supported by a thorough analysis of the algorithm’s main components, show the effectiveness of the proposed design choices, making FILO highly competitive with existing state-of-the-art algorithms, both in terms of computing time and solution quality. Finally, guidelines for possible efficient implementations, algorithm source code, and a library of reusable components are open-sourced to allow reproduction of our results and promote further investigations.

Reuse estimate and interval prediction using MOGA-NN and RBF-NN in the functional paradigm

• Measuring reusability of functions in functional programming paradigm. • Using Haskell source code metrics to predict reuse estimate of a given function. • Providing interval prediction for reusability rather than point estimates. • Comparing two algorithms used for interval prediction viz. MOGA-NN and RBF-NN. • Concluding that RBF-NN are more useful for interval prediction. Context: Reusability estimation of a software component is beneficial in constructing a library of reusable components. The inherent characteristics of the functional paradigm in principle support reuse better than other paradigms. In this paper, we consider the reusability of functions written in the Haskell programming language, which is a functional programming language. Objective: We aim to develop a framework for measuring the reusability of Haskell functions. Given a function, we build a model that can provide a reuse estimate of that function using source code metrics derived solely from that function. This developed model provides a prediction interval for the reuse estimate, which is more useful than a point estimate because of the confidence associated with the prediction. This paper also compares two algorithms used for interval prediction viz. MOGA-NN and RBF-NN. Method: We have used the Indegree of a function and probabilities derived from the clustering of functions to construct our reuse estimate. We have used a multiobjective genetic algorithm trained neural network (MOGA-NN) and radial basis function neural nets (RBF-NN) combined with the k-nearest neighbor algorithm for making interval predictions. Results: The developed model successfully predicts the reuse estimate of three open-source Haskell packages. Both MOGA-NN and RBF-NN have quite similar performance in terms of Root mean square error values for training and testing data, but RBF-NN dominates in the prediction of the bounds of the reuse estimate. Conclusion: We have shown how source code metrics computed from a Haskell function can be used to predict the reuse estimate of a given function. We also conclude that radial basis function neural networks are more accurate in providing a prediction interval for reuse estimate.

Using prototyping to choose a bioinformatics workflow management system.

Workflow management systems represent, manage, and execute multistep computational analyses and offer many benefits to bioinformaticians. They provide a common language for describing analysis workflows, contributing to reproducibility and to building libraries of reusable components. They can support both incremental build and re-entrancy—the ability to selectively re-execute parts of a workflow in the presence of additional inputs or changes in configuration and to resume execution from where a workflow previously stopped. Many workflow management systems enhance portability by supporting the use of containers, high-performance computing (HPC) systems, and clouds. Most importantly, workflow management systems allow bioinformaticians to delegate how their workflows are run to the workflow management system and its developers. This frees the bioinformaticians to focus on what these workflows should do, on their data analyses, and on their science.RiboViz is a package to extract biological insight from ribosome profiling data to help advance understanding of protein synthesis. At the heart of RiboViz is an analysis workflow, implemented in a Python script. To conform to best practices for scientific computing which recommend the use of build tools to automate workflows and to reuse code instead of rewriting it, the authors reimplemented this workflow within a workflow management system. To select a workflow management system, a rapid survey of available systems was undertaken, and candidates were shortlisted: Snakemake, cwltool, Toil, and Nextflow. Each candidate was evaluated by quickly prototyping a subset of the RiboViz workflow, and Nextflow was chosen. The selection process took 10 person-days, a small cost for the assurance that Nextflow satisfied the authors’ requirements. The use of prototyping can offer a low-cost way of making a more informed selection of software to use within projects, rather than relying solely upon reviews and recommendations by others.

Retrieval of Java Program Code Components using Case Based Reasoning CBR

Object Oriented Programming (OOP) facilitates to create libraries of reusable software components. The reusability approach in developing a new system can be applied to an existing system with prior modifications. The reusability definitely decreases the time and effort required for developing the new system. To support reusability of program code, a proper code retrieval process is necessary. It makes possible to search the similar code component of java programming environment. OOP paradigm has specific style of writing the program code. The program code is a collection of objects, classes and methods. It is very easy to store the cases and reuse or revise wherever necessary. To get the similarity between the program code components, it is necessary to have an efficient retrieval method. The retrieval phase can retrieve the program code components as classes, methods, and interfaces depending on components selection by the user. A purely case-based approach is adopted for revising or reusing the existing cases to solve the new problems. Case Based Reasoning (CBR) is the process of solving new problems based on the experience coming from similar past problems.

A Component-Based Formal Language Workbench

The CBS framework supports component-based specification of programming languages. It aims to significantly reduce the effort of formal language specification, and thereby encourage language developers to exploit formal semantics more widely. CBS provides an extensive library of reusable language specification components, facilitating co-evolution of languages and their specifications. After introducing CBS and its formal definition, this short paper reports work in progress on generating an IDE for CBS from the definition. It also considers the possibility of supporting component-based language specification in other formal language workbenches.

Sensitivity Analysis of Evolutionary Algorithm for Software Reusability

Fast and competitive software industry demands rapid development using Component Based Software Development (CBSD). CBSD is dependent on the availability of the high-quality reusable component libraries. Recently, evolutionary multi-objective optimization algorithms have been used to identify sets of reusable software components from the source-code of Object Oriented (OO) software, using different quality indicators (e.g. cohesion, coupling, etc.). Sometimes, these used quality indicators are quite sensitive towards the small variations in their values, although they should not be. Therefore, this paper analyzes the sensitivity of the evolutionary technique for three quality indicators used during the identification: Frequent Usage Pattern (FUP), Semantic and evolutionary coupling. The sensitivity analysis is performed on three widely used open-source OO software. The experimentation is performed by mutating the system to different degrees. Results of the empirical analysis indicate that the semantic parameter is most sensitive and important. Ignoring this feature highly degrades the quality; FUP relation is uniformly sensitive and evolutionary relations's sensitivity is non-uniform.

Software meta-language engineering and CBS

The SLE conference series is devoted to the engineering principles of software languages: their design, their implementation, and their evolution. This paper is about the role of language specification in SLE. A precise specification of a software language needs to be written in a formal meta-language, and it needs to co-evolve with the specified language. Moreover, different software languages often have features in common, which should provide opportunities for reuse of parts of language specifications. Support for co-evolution and reuse in a meta-language requires careful engineering of its design.The author has been involved in the development of several meta-languages for semantic specification, including action semantics and modular variants of structural operational semantics (MSOS, I-MSOS). This led to the PLanCompS project, and to the design of its meta-language, CBS, for component-based semantics. CBS comes together with an extensible library of reusable components called ‘funcons’, corresponding to fundamental programming constructs. The main aim of CBS is to optimise co-evolution and reuse of specifications during language development, and to make specification of language semantics almost as straightforward as context-free syntax specification.The paper discusses the engineering of a selection of previous meta-languages, assessing how well they support co-evolution and reuse. It then gives an introduction to CBS, and illustrates significant features. It also considers whether other current meta-languages might also be used to define an extensible library of funcons for use in component-based semantics.

GC4S: A bioinformatics-oriented Java software library of reusable graphical user interface components.

Modern bioinformatics and computational biology are fields of study driven by the availability of effective software required for conducting appropriate research tasks. Apart from providing reliable and fast implementations of different data analysis algorithms, these software applications should also be clear and easy to use through proper user interfaces, providing appropriate data management and visualization capabilities. In this regard, the user experience obtained by interacting with these applications via their Graphical User Interfaces (GUI) is a key factor for their final success and real utility for researchers. Despite the existence of different packages and applications focused on advanced data visualization, there is a lack of specific libraries providing pertinent GUI components able to help scientific bioinformatics software developers. To that end, this paper introduces GC4S, a bioinformatics-oriented collection of high-level, extensible, and reusable Java GUI elements specifically designed to speed up bioinformatics software development. Within GC4S, developers of new applications can focus on the specific GUI requirements of their projects, relying on GC4S for generalities and abstractions. GC4S is free software distributed under the terms of GNU Lesser General Public License and both source code and documentation are publicly available at http://www.sing-group.org/gc4s

Retrieval of Similarity Measures of Code Component

<div><p><em>Modern programming languages, especially object oriented languages facilitate to create libraries of reusable components (e.g. class definition). The majority of software companies are designing the components and reusing those wherever applicable. Maintaining such components (i.e. class library) and accessing those at right time in right form is challenging because large no. of components in library. Object Oriented Programming supports the reusability of the code. The major challenge in programming is to improve the learning quality and productivity of the software developer, subject teachers and students. </em></p><p><em>To support programming in Java, researcher implemented a design retrieval algorithm which will make it possible to search through potentially reusable Java classes. </em><em>The proposed work, selects the appropriate descriptors of the inputted cases - .java files. It will separate the code components automatically and stores in the repository. The different levels of ambiguity in selection of cases are controlled through data preprocessing technique of data mining. The set of adjustments applied to get the similarity of the code components.</em></p></div>

Reusability of model components for environmental simulation – Case studies for integrated coastal zone management

Model constructs in environmental models are seldom reused beyond the project lifetime or in other modelling studies. A library of reusable model components could facilitate the maintenance of existing models and make the design of new models more efficient. Although component-based design is the common standard in software engineering and manufacturing few examples are yet found in environmental science. The multi-disciplinary project SPICOSA used a common, component-based simulation framework for environmental modelling, based on 18 case studies through Europe. The development of high-quality model components with potential for reuse turned out to be a challenge despite of the guidelines and tutorial examples provided. Well-designed components are of appropriate granularity, encapsulated, with a limited use of connectors and proper data handling. Ultimately, the success of a model library depends on a sufficient set of quality components with complementary functionalities, a framework for quality control, and support of the environmental modelling community.

Synthesis from Probabilistic Components

Synthesis is the automatic construction of a system from its specification. In classical synthesis algorithms, it is always assumed that the system is "constructed from scratch" rather than composed from reusable components. This, of course, rarely happens in real life, where almost every non-trivial commercial software system relies heavily on using libraries of reusable components. Furthermore, other contexts, such as web-service orchestration, can be modeled as synthesis of a system from a library of components. Recently, Lustig and Vardi introduced dataflow and control-flow synthesis from libraries of reusable components. They proved that dataflow synthesis is undecidable, while control-flow synthesis is decidable. In this work, we consider the problem of control-flow synthesis from libraries of probabilistic components . We show that this more general problem is also decidable.

Synthesis of hierarchical systems

In automated synthesis, given a specification, we automatically create a system that is guaranteed to satisfy the specification. In the classical temporal synthesis algorithms, one usually creates a “flat” system “from scratch”. However, real-life software and hardware systems are usually created using preexisting libraries of reusable components, and are not “flat” since repeated sub-systems are described only once.In this work we describe an algorithm for the synthesis of a hierarchical system from a library of hierarchical components, which follows the “bottom-up” approach to system design. Our algorithm works by synthesizing in many rounds, when at each round the system designer provides the specification of the currently desired module, which is then automatically synthesized using the initial library and the previously constructed modules. To ensure that the synthesized module actually takes advantage of the available high-level modules, we guide the algorithm by enforcing certain modularity criteria.We show that the synthesis of a hierarchical system from a library of hierarchical components is Exptime-complete for μ-calculus, and 2Exptime-complete for Ltl, both in the cases of complete and incomplete information. Thus, in all cases, it is not harder than the classical synthesis problem (of synthesizing flat systems “from scratch”), even though the synthesized hierarchical system may be exponentially smaller than a flat one.

Trading obliviousness for modularity with cooperative aspect-oriented programming

The potential of aspect-oriented programming to adequately capture crosscutting concerns has yet to be fully realized. For example, authors have detailed significant challenges in creating reusable aspect component libraries. One proposed solution is to introduce Explicit Join Points (EJPs) to increase modularity by reducing obliviousness, enabling a Cooperative Aspect-Oriented Programming (Co-AOP) methodology where base code and aspects synergistically collaborate. This article explores the trade-offs between obliviousness and modularity. We briefly introduce EJPs and Co-AOP, and hypothesize how to balance obliviousness and modularity using Co-AOP. We build upon a prior empirical study to refactor three real-life Java applications to implement the exception handling concern using three distinct strategies: (1) using fully oblivious aspects in AspectJ, (2) using EJPs in a fully explicit fashion, and (3) using EJPs while following the Co-AOP methodology. We study other crosscutting concerns by refactoring a fourth application, JHotDraw. The differences in terms of common code metrics are analyzed, and the impact on modularity is assessed using design structure matrices. Results indicate that the Co-AOP methodology can in many cases significantly improve code quality attributes versus fully oblivious or fully explicit approaches. We conclude with guiding principles on the proper use of EJPs within the Co-AOP methodology.

Implementing Clustering Based Approach for Evaluation of Success of Software Reuse using K-means algorithm

A great deal of research over the past several years has been devoted to the development of methodologies to create reusable software components and component libraries. But the issue of how to find the contribution of the factor towards the successfulness of the reuse program is still in the naïve stage and very less work is done on the modeling of the success of the reuse. The success and failure factors are the key factors that predict the successful reuse of software. An algorithm has been proposed in which the inputs can be given to K-Means Clustering system in form of tuned values of the Data Factors and the developed model shows the high precision results , which describe the success of software reuse.