Search

Web3.0, often cited to drastically shape our lives, is ubiquitous. However, few literatures have discussed the crucial differentiators that separate Web3.0 from the era we are currently living in. Via a thorough analysis of the recent blockchain infrastructure evolution, we capture a key invariant featuring the evolution, based on which we provide the first academic definition for Web3.0. Our definition is not the only way of understanding Web3.0, yet, it captures the fundamental and defining trait of Web3.0, and meanwhile it is has two desirable properties. Under this definition, we articulate three key infrastructural enablers for Web3.0: individual blockchains, federated or centralized platforms capable of publishing verifiable states, and an interoperability platform to hyperconnect those state publishers. While innovations in all categories are necessary to fully enable Web3.0, in this paper, we present a design for the third enabler, namely HyperService, that delivers interoperability and programmability across heterogeneous blockchains and state publishers. HyperService is powered by two innovative designs: a developer-facing programming framework that allows developers to build cross-chain applications in a unified programming model; and a secure blockchain-facing cryptography protocol that provably realizes those applications on blockchains. We implement a prototype of HyperService in 62,000 lines of code to demonstrate its practicality, usability, and scalability.

Deep learning has sparked a renaissance in computer systems and architecture. Despite the breakneck pace of innovation, there is a crucial issue concerning the research and industry communities at large: how to enable neutral and useful performance assessment for machine learning (ML) software frameworks, ML hardware accelerators, and ML systems comprising both the software stack and the hardware. The ML field needs systematic methods for evaluating performance that represents real-world use cases and useful for making comparisons across different software and hardware implementations. MLPerf answers the call. MLPerf is an ML benchmark standard driven by academia and industry (70+ organizations). Built out of the expertise of multiple organizations, MLPerf establishes a standard benchmark suite with proper metrics and benchmarking methodologies to level the playing field for ML system performance measurement of different ML inference hardware, software, and services.

In clinical scenarios, there is an increasing interest in complex computational experiments, as for example the training of Deep Learning models. Reproducibility is an essential property of such experiments, especially if the result contributes to a patient’s treatment. This paper introduces Curious Containers, a software framework for computational reproducibility that treats data, software and runtime environment as decentralized network resources. All experiment resources are described in a single file, using a new format that is compatible with a subset of the Common Workflow Language. Docker is used to deploy the experiment software in a container image, including arbitrary data transmission programs to connect with existing storage solutions. The framework supports Deep Learning applications, that have a high demand in storage and processing capabilities. Large datasets can be mounted inside containers via network filesystems like SSHFS based on the filesystem in user-space technology. The Nvidia-Container-Toolkit enables GPU usage. Curious Containers has been tested in two biomedical scenarios. The first use case is a Deep Learning application for tumor classification in images that requires a large dataset and a GPU. In this context, a prototypical integration of the framework with the existing Data Version Control system for exploratory Deep Learning modeling has been developed. The second use case extends an existing container image, including a scientific workflow for detection and comparison of human protein in mass spectrography data. The container image was originally developed for an archiving platform and could be extended to be compatible with both Curious Containers and cwltool, the Common Workflow Language reference implementation. The presented solution allows for consistent description and execution of computational experiments, while trying to be both flexible and interoperable with existing software and standards. Support for Deep Learning experiments is gaining importance as such systems are increasingly validated as medical decision support systems.

The microservice architectural style has gained much attention from both academia and industry recently as a novel way to design, develop, and deploy cloud-native applications. This concept encourages the decomposition of a monolith into multiple independently deployable units. A typical microservices-based application is formed of two service types: functional services, which provide the core business logic, and infrastructure services, which provide essential functionalities for a microservices ecosystem. To improve developers' productivity, many software frameworks have been developed to provide those reusable infrastructure services, allowing programmers to focus on implementing microservices in arbitrary ways. In this work, we made use of four open source frameworks to develop a cloud-based application in order to compare and evaluate their usability and practicability. While all selected frameworks promote asynchronous microservice design in general, there are differences in the ways each implements services. This leads to interoperability issues, such as message topic naming convention. Additionally, a key finding is the long startup times of JVM-based services that might reduce application's resiliency and portability. Some other advantages come directly from the programming language, such as the ability of Go to generate native binary executables, which results in very small and compact Docker images (up to 78\% smaller compared to other languages).

Emergent paradigms of Industry 4.0 and Industrial Internet of Things expect cyber-physical systems to reliably provide services overcoming disruptions in operative conditions and adapting to changes in architectural and functional requirements. In this paper, we describe a hardware/software framework supporting operation and maintenance of software-controlled systems enhancing resilience by promoting a Model-Driven Engineering (MDE) process to automatically derive structural configurations and failure models from reliability artifacts. Specifically, a reflective architecture developed around digital twins enables representation and control of system Configuration Items properly derived from SysML Block Definition Diagrams, providing support for variation. Besides, a plurality of distributed analytic agents for qualitative evaluation over executable failure models empowers the system with runtime self-assessment and dynamic adaptation capabilities. We describe the framework architecture outlining roles and responsibilities in a System of Systems perspective, providing salient design traits about digital twins and data analytic agents for failure propagation modeling and analysis. We discuss a prototype implementation following the MDE approach, highlighting self-recovery and self-adaptation properties on a real cyber-physical system for vehicle access control to Limited Traffic Zones.

In aiming to create added intelligence for Things interfacing with IoT principles in the form of Services, Smart Heating Management is consistently a field of promising research. In the currently demonstrated work, an approach will be described for an operational software framework of modular components that can create intelligence in Housing Units as those presented in our scenario. The framework is based on the lightweight Case Based Reasoning approach and principles in order to describe the Problem and Solution of heating management, as well as to extract knowledge from generic historical data. Collaboration between houses is included through the sharing of anonymized high level problem-solution data, as an instantiation of the same social learning principles that govern human behavior and enable Knowledge diffusion. The approach is validated through historical data acquired in two time periods from the Camden (London) community residencies and demonstrates an average of 22% savings in boiler active time. Knowledge sharing is also analyzed along with the benefits and pitfalls it might produce.

A wide variety of Hardware Trojan countermeasures have been developed, but less work has been done to determine which are optimal for any given design. To address this, we consider not only metrics related to the performance of the countermeasure, but also the likely action of an adversary given their goals. Trojans are inserted by an adversary to accomplish an end, so these goals must be considered and quantified in order to predict these actions. The model presented here builds upon a security economic approach that models the adversary and defender motives and goals in the context of empirically derived countermeasure efficacy metrics. The approach supports formation of a two-player strategic game to determine optimal strategy selection for both adversary and defender. A game may be played in a variety of contexts, including consideration of the entire design lifecycle or only a step in product development. As a demonstration of the practicality of this approach, we present an experiment that derives efficacy metrics from a set of countermeasures (defender strategies) when tested against a taxonomy of Trojans (adversary strategies). We further present a software framework, GameRunner, that automates not only the solution to the game but also mathematical and graphical exploration of “what if” scenarios in the context of the game. GameRunner can also issue “prescriptions,” a set of commands that allows the defender to automate the application of the optimal defender strategy to their circuit of concern. Finally, we include a discussion of ongoing work to include additional software tools, a more advanced experimental framework, and the application of irrationality models to account for players who make subrational decisions.

The rise of programmable open distributed consensus platforms based on the blockchain technology has aroused a lot of interest in replicated stateful computations, aka smart contracts. As blockchains are used predominantly in financial applications, smart contracts frequently manage millions of dollars worth of virtual coins. Since smart contracts cannot be updated once deployed, the ability to reason about their correctness becomes a critical task. Yet, the de facto implementation standard, pioneered by the Ethereum platform, dictates smart contracts to be deployed in a low-level language, which renders independent audit and formal verification of deployed code infeasible in practice. We report an ongoing experiment held with an industrial blockchain vendor on designing, evaluating, and deploying Scilla, a new programming language for safe smart contracts. Scilla is positioned as an intermediate-level language, suitable to serve as a compilation target and also as an independent programming framework. Taking System F as a foundational calculus, Scilla offers strong safety guarantees by means of type soundness. It provides a clean separation between pure computational, state-manipulating, and communication aspects of smart contracts, avoiding many known pitfalls due to execution in a byzantine environment. We describe the motivation, design principles, and semantics of Scilla, and we report on Scilla use cases provided by the developer community. Finally, we present a framework for lightweight verification of Scilla programs, and showcase it with two domain-specific analyses on a suite of real-world use cases.

Cloud services must typically be distributed across a large number of machines in order to make use of multiple compute and storage resources. This opens the programmer to several sources of complexity such as concurrency, order of message delivery, lossy network, timeouts and failures, all of which impose a high cognitive burden. This paper presents evidence that technology inspired by formal-methods, delivered as part of a programming framework, can help address these challenges. In particular, we describe the experience of several engineering teams in Microsoft Azure that used the open-source Coyote Actor programming framework to build multiple reliable cloud services. Coyote Actors impose a principled design pattern that allows writing formal specifications alongside production code that can be systematically tested, without deviating from routine engineering practices. Engineering teams that have been using Coyote have reported dramatically increased productivity (in time taken to push new features to production) as well as services that have been running live for months without any issues in features developed and tested with Coyote.

For an effective deployment in manufacturing,Collaborative Robots should be capable of adapting theirbehavior to the state of the environment and to keep the usersafe and engaged during the interaction. Artificial Intelligence(AI) enables robots to autonomously operate understandingthe environment, planning their tasks and acting to achievesome given goals. However, the effective deployment of AI technologiesin real industrial environments is not straightforward. There is a need for engineering tools facilitating communicationand interaction between AI engineers and Domain experts. Thispaper proposes a novel software tool, called TENANT (ToolfostEriNg Ai plaNning in roboTics) whose aim is to facilitatethe use of AI planning technologies by providing domainexperts like e.g., production engineers, with a graphical softwareframework to synthesize AI planning models abstracting fromsyntactic features of the underlying planning formalism.

Quantum computing is a technology that promises to offer significant advantages during the coming decades. Though the technology is still in a prototype stage, the last few years have seen many of these prototype devices become accessible to the public. This has been accompanied by the open-source development of the software required to use and test quantum hardware in increasingly sophisticated ways. Such tools provide new education opportunities, not just for quantum computing specifically, but also more broadly for quantum information science and even quantum physics as a whole. In this paper we present a case study of one education resource which aims to take advantage of the opportunities: the open-source online textbook `Learn Quantum Computation using Qiskit'. An overview of the topics covered is given, as well as an explanation of the approach taken for each.

Internet of things (IoT) devices are mostly ubiquitous in this day and age, and it is hard to imagine a life without them, especially in the productive sectors (industry, agriculture, and automotive) and in our daily life activities (consumer electronics, home automation, and intelligent buildings). The high demand for these devices has created significant competition to provide them at the best price, at the right time, and with the best features. The trend in which these devices have increased their product features has resulted in their embedded software being more complex, leading to extended development and testing times. Consequently, as the types of advanced IoT products keep diversifying, the field maintenance of all the different models deployed grows more complicated. This paper proposes an embedded software development framework for IoT devices independent of the microcontroller architecture, the compiler, and the development environment. This framework allows having a common software baseline between different projects, which shortens the learning curve, development time, and module validation while allowing code reuse for embedded software professionals. A proof-of-concept evaluation is also presented to demonstrate the efficiency and reliability of the obtained embedded software code for a simple but representative IoT application.

In the past few years, microservice architecture has become a dominant software development and deployment paradigm and has aroused interest from both academia and industry. Although the microservice architecture has many advantages, it still faces some challenges. Due to the mobility and changing needs of users, microservice systems (MSS) need to continuously evolve to ensure that the Quality of Service (QoS) perceived by users remains at a satisfactory level. Besides, because of the complexity of MSS constituted by plenty of microservices and users, it is difficult for developers to evolve the MSS manually, and automatic evolutionary adaptability is necessary. However, existing technologies do not well support the automatically adaptive evolution of MSS. To meet this challenge, this paper summarizes common abilities that are necessary for automatically adaptive evolution in MSS, including monitor system runtime status, generate an evolution plan and execute an evolution plan, and an Evolution-Oriented Programming Framework for Microservices (EPF4M) is designed to support individual microservices to achieve those abilities. Considering both the development cost and operational efficiency of microservices, EPF4M is implemented by lightweight methods in Java, including annotations. Experiments are carried out to verify the usability of the functions provided by EPF4M and compare an MSS before and after using EPF4M to demonstrate the acceptability of the additional cost of EPF4M for MSS development and operation. An example is also presented to illustrate the performance of EPF4M in adaptive evolution.

In this work a new and open source software framework for vein recognition is presented, which supports a complete tool chain to conduct biometric experiments. The software can be used out of the box on several publicly available databases and offers a convenient mechanism to configure the tool chain to fit the needs for individual experimental setups. It is implemented in C++ and works on Linux as well as on Windows and therefore offers an advantage over existing vein recognition libraries. The project’s aim is to offer a valuable tool to conduct research in the field of vein recognition and importantly, supporting reproducible research.

Workflow management systems (WMSs) are commonly used to organize/automate sequences of tasks as workflows to accelerate scientific discoveries. During complex workflow modeling, a local interactive workflow environment is desirable, as users usually rely on their rich, local environments for fast prototyping and refinements before they consider using more powerful computing resources. However, existing WMSs do not simultaneously support local interactive workflow environments and HPC resources. In this paper, we present an on-demand access mechanism to remote HPC resources from desktop/laptop-based workflow management software to compose, monitor and analyze scientific workflows in the CyberWater project. Cyber-Water is an open-data and open-modeling software framework for environmental and water communities. In this work, we extend the open-model, open-data design of CyberWater with on-demand HPC accessing capacity. In particular, we design and implement the LaunchAgent library, which can be integrated into the local desktop environment to allow on-demand usage of remote resources for hydrology-related workflows. LaunchAgent manages authentication to remote resources, prepares the computationally-intensive or data-intensive tasks as batch jobs, submits jobs to remote resources, and monitors the quality of services for the users. LaunchAgent interacts seamlessly with other existing components in CyberWater, which is now able to provide advantages of both feature-rich desktop software experience and increased computation power through on-demand HPC/Cloud usage. In our evaluations, we demonstrate how a hydrology workflow that consists of both local and remote tasks can be constructed and show that the added on-demand HPC/Cloud usage helps speeding up hydrology workflows while allowing intuitive workflow configurations and execution using a desktop graphical user interface.

It is widely acknowledged that the construction of large-scale dynamic models in systems biology requires complex modelling problems to be broken up into more manageable pieces. To this end, both modelling and software frameworks are required to enable modular modelling. While there has been consistent progress in the development of software tools to enhance model reusability, there has been a relative lack of consideration for how underlying biophysical principles can be applied to this space. Bond graphs combine the aspects of both modularity and physics-based modelling. In this paper, we argue that bond graphs are compatible with recent developments in modularity and abstraction in systems biology, and are thus a desirable framework for constructing large-scale models. We use two examples to illustrate the utility of bond graphs in this context: a model of a mitogen-activated protein kinase (MAPK) cascade to illustrate the reusability of modules and a model of glycolysis to illustrate the ability to modify the model granularity., Author summary The biochemistry within a cell is complex, being composed of numerous biomolecules and reactions. In order to develop fully detailed mathematical models of cells, smaller submodels need to be constructed and connected together. Software and standards can assist in this endeavour, but challenges remain in ensuring that submodels are both consistent with each other and consistent with the fundamental conservation laws of physics. In this paper, we propose a new approach using bond graphs from engineering. In this approach, connections between models are defined using physical conservation laws. We show that this approach is compatible with current software approaches in the field, and can therefore be readily used to incorporate physical consistency into existing model integration methodologies. We illustrate the utility of this approach in streamlining the development of models for a signalling network (the MAPK cascade) and a metabolic network (the glycolysis pathway). The advantage of this approach is that models can be developed in a scalable manner while also ensuring consistency with the laws of physics, enhancing the range of data available to train models. This approach can be used to quickly construct detailed and accurate models of cells, facilitating future advances in biotechnology and personalised medicine.

Computer-aided design (CAD) software is a fundamental engineering tool that is often integrated into educational programs, including those for electronics. When the COVID-19 pandemic spread worldwide in 2020, an introductory electronics course at our Institution had to be reformulated due to restrictions on holding face-to-face classes. In this scenario, traditional lab tasks were replaced by computer-based assignments that students worked on using CAD software. This paper introduces the software framework used for this purpose, which has the two features considered necessary to closely replicate a practical experiment: i) the ability to mimic breadboard circuit prototyping activities and ii) the ability to simulate the prototyped circuits. In order to enhance students' motivation for the educational activities, the assignments proposed in our course have focused on robotics applications for several years. This was conveniently accounted for by combining simulation of electronic circuits with robotics simulation. In this way, we can be reproduce the embodiment of electronic circuits and the interaction with an external environment that takes place in a real experiment. The paper describes the proposed software framework, gives examples of its use, and reports on students' results for the first distance learning semester using the framework.

The subject of this paper is development of software framework for real-time management of intelligent devices. The framework enables intelligent management of IoT devices in cyber-physical systems using models based on recurrence relations and differential equations. The platform was developed using Python programming language, Django framework and wide corpus of modules and libraries that supports continuous simulation. The software framework incorporates application programming interface as well, for specification of system behaviour, transmission of input parameters and output results, sending control actions via web services to the IoT system.

Mastering the “arcana of neuroimaging analysis”, the obscure knowledge required to apply an appropriate combination of software tools and parameters to analyse a given neuroimaging dataset, is a time consuming process. Therefore, it is not typically feasible to invest the additional effort required generalise workflow implementations to accommodate for the various acquisition parameters, data storage conventions and computing environments in use at different research sites, limiting the reusability of published workflows.We present a novel software framework, Abstraction of Repository-Centric ANAlysis (Arcana), which enables the development of complex, “end-to-end” workflows that are adaptable to new analyses and portable to a wide range of computing infrastructures. Analysis templates for specific image types (e.g. MRI contrast) are implemented as Python classes, which define a range of potential derivatives and analysis methods. Arcana retrieves data from imaging repositories, which can be BIDS datasets, XNAT instances or plain directories, and stores selected derivatives and associated provenance back into a repository for reuse by subsequent analyses. Workflows are constructed using Nipype and can be executed on local workstations or in high performance computing environments. Generic analysis methods can be consolidated within common base classes to facilitate code-reuse and collaborative development, which can be specialised for study-specific requirements via class inheritance. Arcana provides a framework in which to develop unified neuroimaging workflows that can be reused across a wide range of research studies and sites.

An important task in the processing of Earth remote sensing data is the automation of the decoding process of aerospace images, in particular the detection and recognition of objects in military decoding. In the article the directions of automation of decryption of photos are considered and promising from them is selected, which is based on the use of neural networks of deep learning, and also analyzed the technical problems that arise during the creation of algorithms and the deployment of trained models on a variety of mobile devices. The important role of deep-instruction software frameworks in the process of training of neural network models is aimed at facilitating development and deployment. The changes in the popularity of software frameworks in recent years have been analyzed and the need to analyze their dynamically changing capabilities has been analyzed. The most widely used software frameworks for the implementation of deep learning approaches, their advantages and disadvantages for solving tasks of thematic decryption on accessible computational resources are explored. The types of computational graphs, which use the software of deep learning, and programming languages, with the help of which it is allowed to create and deploy models of neural networks are considered. The analysis of the frameworks according to selected criteria was performed: distributed execution, architecture optimization, reflection of the learning process, joint support and portability. As a result, the software framework to be used in conducting research is highlighted, and the conclusion is drawn about the predominant framework for industrial use in the course of in-depth training of the neural network for the processing of Earth remote sensing data.

Background/Objectives: The OSS is generally unique in relation to the proprietary programming. In the OSS improvement situation an absolute designer alternately aggregation for developers composes that source book to the primary rendition of the product and makes it uninhibitedly accessible over those webs. At that point other developers would welcome to help the existing code to its next arrival. Settling on the source book of the programming accessible on the web permits developers around the universe to help code, include new functionality, change of the existing source book and submitting bug fixes of the current arrival. Previously, such a programming improvement situation the upkeep of the open hotspot product is a culprit assignment. Creating an OSS framework infers an arrangement from claiming incessant upkeep deliberations to debugging existing purpose what’s more including new purpose of the programming framework. The procedure for making those adjustments to product frameworks then afterward their initially arrival may be known as upkeep procedure. The expression maintainability may be nearly identified with that product support. Portability, adaptability and issue tolerance are the opposite essential part that ensures that seamlessness of the programming item. Those generally utilized programming metric to quantify the maintainability is known as Maintainability list (MI). Methods: In this investigation the MI from claiming four A large portion mainstream OSS to be specific Apache, Mozilla Firefox, MySql and FileZilla for fifty progressive discharges might have been observationally investigated. The MI as far as programming measurements in particular Lines about code (LOC), Cyclomatic unpredictability (CC), and Halstead Volume (V) might have been registered for every last one of fifty progressive variants about four OSS. Findings: Proposed agent based approach are cost effective, efficient and accurate solutions to evaluate the software (web application) RMA metrics including the monitoring in cloud computing services that means “Testing/Debugging as a Service Evaluation”. Proposed system has performs faster and produce more accurate results to assure the quality of the software related to the non-functional. Keywords: Agent, Availability, Cloud Computing, Cyclomatic intricacy, Lines Code, Maintenance, Maintainability, Maintainability Index, Reliability, RMA, Software of Open Source, T/DaaS, Volume of Halstead

Our software framework, Proteus, treats adaptation as a first-class object, enabling rapid development of robust, adaptive applications. Proteus developers specify their programs' intent and adaptable components (or knobs). A control-theoretic runtime continually monitors the running application, adjusting knobs so that the specified intent is met.

In the near future, it will be common that a variety of robots are cooperating to perform a mission in various fields. A key technical challenge to realize this vision is software challenge on how to specify the mission at the user level and how to program each robot separately. In this paper, we propose a novel software development framework that separates mission specification and robot behavior programming. For mission specification, a novel scripting language is proposed with the expression capability of dynamic mode change and multitasking. For robot behavior programming, an extended dataflow model is used for task-level behavior specification that does not depend on the robot hardware platform. In the proposed framework, the actual robot software is automatically generated from the model. The viability of the proposed framework is demonstrated with two real-life experiments.

Theory of scheduling and project planning is widely applied in diverse scientific and industrial areas. To effectively solve application-specific problems, it is necessary to state right objectives as well as to take into account a lot of factors, such as task execution models, precedence relationship between tasks, resource limitations, directive deadlines, working calendars, conditions for financial and logistics support of project tasks, specific spatio-temporal requirements, et al. Therefore, the development of scheduling applications becomes more and more complicated purposes, risky and costly ones. In this paper, we present an innovative object-oriented Scheduling Application Framework (SAF) designed to simplify and accelerate the software development processes. The presented SAF framework is a system of C++ classes that implement basic abstractions of the scheduling theory as well as provide ready-to-use components to build target applications of typical scheduling functionality. As a general-purpose mathematical library, the framework enables to set and solve so-called RCPSP problems (Resource-Constrained Project Scheduling Problem) in extended statements peculiar to popular project management systems. Branch and bound and linear dispatching algorithms have been implemented and included as a part of the framework. A dozen of heuristics has been implemented and has been provided by the framework too to solve large-scale problems more effectively. Thereby target application developers can adjust the application solver properly taking into account application-specific issues and making the search of suboptimum schedules more effective. As a software toolkit the framework enables developers to implement own components and to configure target applications in unified and flexible manner. Due to object-oriented paradigm, multi-layer architecture and class package organization, the application development takes relatively small efforts. The SAF framework has been successively validated during development of a software application intended for visual modeling and planning of projects under diverse spatial-temporal, resource and finance constraints. Due to achieved advantages, the framework looks promising for development of both sophisticated multi-disciplinary systems and effective domain-specific scheduling applications.

It is largely recognized that the architectures of embedded systems are becoming more and more complex both at hardware and software levels. Despite the significant advances in the development tools, developing the software of such systems while ensuring their safety is still a difficult task. In this paper, we propose an end-to-end programming framework to ease the development of safe software systems. The programming framework, supported by a proper methodology and workflow, make it possible to design safe/secure software that implements functional requirements while respecting multiple non-functional requirements and mastering architectural complexity, time-to-market and cost. The programming framework is based on five concepts: (1) model-based system engineering: MBSE, (2) design-by-contract approach, (3) formal analysis of models based on symbolic execution, (4) code generation, and (5) static and dynamic code analysis. The effectiveness of the methodology has been demonstrated through multiple use-cases. The framework is realized using CEA LIST ( http://www-list.cea.fr/en/ ) open-source development platforms: Papyrus, Frama-C, and UNISIM-VP. These platforms are results of many research and industrial projects such as FP7-SafeAdapt 1 , FUI-EQUITAS 2 , FP7-STANCE 3 , CATRENE-OpenES 4 , FSN-SESAM Grids 5 , and H2020-VESSEDIA 6 .

Software frameworks make developing applications for a specific domain easier than doing so from scratch. Unfortunately, frameworks can also place unexpected requirements on a developer’s application, which can, in turn, lead to application bugs in the development process. We propose an automated technique for repairing violations of state-based framework requirements, FrameFix. First, developers of a framework can encode state-based framework requirements. Then, FrameFix automatically checks whether a developer’s application follows the encoded requirements. Once a violation of these requirements has been detected, FrameFix tries three different approaches — reordering method calls, moving method calls to different method definitions, and comparing the faulty method to similarly defined methods on GitHub. These repair approaches are based on the principles of how frameworks interact with framework applications: object protocols and inversion of control. To demonstrate that these principles can be used to aid automated repair for framework applications, we created a sample implementation of FrameFix for Android applications. Our evaluation shows that FrameFix is effective, repairing both real bugs in real applications, and a large number and variety of injected defects.

There are competing priorities between creative freedom and the need for robust, stable software frameworks to facilitate the rapid implementation of creative ideas in game development. This may result in a disparity between system and user requirements. Qualitative data extracted from seminars at the Game Developers Conference informs the design of several interviews with veteran game-system designers to explore this phenomenon. A survey of modular software plug-ins from the Unity Asset Store then validates the interview findings and explores the benefits of modular software architectures. Findings indicate that modifications to the native user experience (UX) design of Unity and plug-ins that reengineer for different workflows are most popular. The most popular workflows provide for data, asset, and project management. Discussion reflects on how modular architecture can alleviate points of failure within a game engine’s architecture whilst providing customized usability for different user needs.

International audience; Parallel programming is much more complex and difficult than sequential programming, and it is therefore more challenging to achieve the same software quality in a parallel context. High-level parallel programming models, if implemented as software frameworks, could increase productivity and reliability. Important requirements such as extensibility and adaptability for different platforms are required for such a framework, and this paper reflects on these requirements and their relation to the software engineering methodologies that could put them in practice. All these are exemplified on a Java framework-JPLF; this is a high-level parallel programming approach being based on the model brought by the PowerLists associated theories, and it respects the analysed requirements. The design of JPLF is analysed by explaining the design choices and highlighting the design patterns and design principles applied.

In this chapter, I will show you how to build a small project in Python. You will use all the knowledge about the software development process you have learned so far from the previous chapters. Part of every project is the decisions you need to make as to what technologies you are going to use. Lots of things can affect these decisions, such as your own skillset, your team's skillset, general best practices, and your project itself. You will stick to a conservative but realistic approach to solve your problem. You will build a small system that communicates with a database. This will be a complete project setup, including the GitLab repositories, changes to the Docker file, and installing the software you need for your project. One new aspect I will introduce is the software framework. When we create systems, we don't necessarily write all the code from scratch. We may opt to use a framework. A framework houses all the basic tools we need in order to bring our software up quickly. The tools may include routing of requests, where your external request is served up via specific “routes” into the system, or the basic code for database access models.

In order to avoid the spread of new coronavirus, it is necessary to keep a distance, wear masks and wash hands, not close contact. When the academic research or market survey needs to fill in the questionnaire, it is a safe and necessary choice to use the network electronic form. In order to prevent the spread of virus, it is necessary to keep a safe distance between people. The demand for electronic forms is more diverse and vigorous. To prevent the spread of virus through interviews and questionnaires, we can change the way of filling in electronic forms to achieve the purpose of maintaining a safe distance. As a result, the demand for electronic forms has increased, and the electronic forms can be more convenient. At the same time, the anti-counterfeiting function of electronic signature is used. The undeniable characteristics of personal signature can be customized and diversified. At present, the system development and technology of web forms are various and mature. In order to increase the employability of college students, the implementation course of online spreadsheet is added to the professional courses of University, which has gradually become a popular option of software engineering for students' graduation design. From the system analysis and system design, JavaScript, HTML5, CSS3 and other technologies are selected. Through the programming framework on the server, through the browser, it is convenient to use the web spreadsheet. The system functions are successfully implemented, and the graduation design of university professional courses is completed, which is a reference for successful cases of course practice. This model is a successful example of system development. Combined with the theory of university courses and the practice of project design, the system development, design and system testing are completed successfully within the effective time limit. From the system analysis and system design, JavaScript, HTML5, CSS3 and other technologies are selected. Through the programming framework on the server, through the browser, it is convenient to use the web spreadsheet. The system functions are successfully implemented, and the graduation design of university professional courses is completed, which is a reference for successful cases of course practice. This model is a successful example of system development. Combined with the theory of university courses and the practice of project design, the system development, design and system testing are completed successfully within the effective time limit.

Prognostics is a systems engineering discipline focused on predicting end-of-life of components and systems. As a relatively new and emerging technology, there are few fielded implementations of prognostics, due in part to practitioners perceiving a large hurdle in developing the models, algorithms, architecture, and integration pieces. Similarly, no open software frameworks for applying prognostics currently exist. This paper introduces the Generic Software Architecture for Prognostics (GSAP), an open-source, cross-platform, object-oriented software framework and support library for creating prognostics applications. GSAP was designed to make prognostics more accessible and enable faster adoption and implementation by industry, by reducing the effort and investment required to develop, test, and deploy prognostics. This paper describes the requirements, design, and testing of GSAP. Additionally, a detailed case study involving battery prognostics demonstrates its use.

Since IBM first introduced the Instruction Set Architecture (ISA), there has been tremendous research conducted on novel hardware architectures and new high-level software frameworks, perhaps to a fault. With innovation came an ever growing gap between a program's description and how it is executed on hardware. Successful exploitation of these innovations calls for a unifying contract to be in place which distinguishes the program description from the low-level execution on target hardware; namely, a Program Execution Model (PXM). By decoupling the programming API from the hardware description the obstacles imposed by low-level architectures and high-level language interoperability are avoided by utilizing program manipulation, source-level optimizations, and eventual lowering into machine code across a wide variety of different heterogeneous hardware. To achieve these goals in software, compilers must adapt to the ever-changing climate of hardware and software development. They must be able to represent data at varying levels so as to provide maximum opportunities for optimizations based on information which would otherwise be lost without utilizing progressive lowering. The target hardware should also not limit the amount of possible software-based optimizations. We propose CODIR, the Codelet Model domain-specific language extension and intermediate representation built using the already existing Multi-Level Intermediate Representation (MLIR) compiler infrastructure. It aims to progressively lower a high-level language to an intermediate representation well suited for maximizing optimization opportunities available to the compiler while additionally providing a plethora of hardware support. Underlying CODIR is the Codelet Model which we believe to be a sound program execution model for mapping computation to the machine and utilizing all available hardware resources.

During the last decade, automated three-dimensional (3D) object reconstruction and inspection have become widely used in the same way that 3D sensors and positioning systems have become affordable. For example, nowadays drones or underwater vehicles are capable of building 3D models of complex structures. To achieve an autonomous reconstruction it is essential to determine each pose of the sensor, from where an observation is made. In the literature, this task is called view planning. To develop a custom application or propose a new view planning algorithm requires several software tools that are usually reimplemented each time; this causes an effort duplication and is one of the reasons why view planning research papers usually do not present comparisons. We present VPL, a software framework to develop view planning algorithms and compare their performance versus other approaches. The library is written in C++ and it is released under open source BSD license.

Microservices architecture has emerged as an architectural style which focuses on the design and development of software systems as a set of small independent services. Although MSA is inspired by the Service-Oriented Architecture style (both are service-based architectures), it presents important differences. Likewise, software architecture must evolve as new architectural styles and software frameworks arise, and the evolution of the software architecture is considered as a central feature of any software system. In this way, this paper proposes an approach to evolve SOA to MSA architectures through the use of Sarch language. To accomplish this, the language was extended to allow the modeling of the two architectural styles from the component-and-connector view, the inclusion of a decomposition view for functional properties, and the use of a model-to-model transformation algorithm.

Cyber physical production systems (CPPS) focus on increasing the flexibility and adaptability of industrial production systems, systems that comprise hardware such as sensors and actuators in machines as well as software controlling and integrating these machines. The requirements of customised mass production imply that control and integration software needs to be adaptable after deployment in a shop floor (factory), possibly even without interrupting production. Today, software frameworks provide support to model and execute manufacturing processes. They, however, provide little support for reuse. In this paper, we present a framework based on capabilities, which supports manufacturing process templates. These templates are bound/allocated to a specific shopfloor setup, a specific set of machines, and executed using a distributed set of process engines. This enables the reuse of manufacturing processes, as well as transmitting and executing changed processes. The framework is implemented using the Eclipse Milo implementation of OPC UA in Java. It is used to control a lab-scale modular shopfloor programmed in IEC61499 and Java.

Face recognition, as one of the major biometrics identification methods, has been applied in different fields involving economics, military, e-commerce, and security. Its touchless identification process and non-compulsory rule to users are irreplaceable by other approaches, such as iris recognition or fingerprint recognition. Among all face recognition techniques, principal component analysis (PCA), proposed in the earliest stage, still attracts researchers because of its property of reducing data dimensionality without losing important information. Nevertheless, establishing a PCA-based face recognition system is still time-consuming, since there are different problems that need to be considered in practical applications, such as illumination, facial expression, or shooting angle. Furthermore, it still costs a lot of effort for software developers to integrate toolkit implementations in applications. This paper provides a software framework for PCA-based face recognition aimed at assisting software developers to customize their applications efficiently. The framework describes the complete process of PCA-based face recognition, and in each step, multiple variations are offered for different requirements. Some of the variations in the same step can work collaboratively and some steps can be omitted in specific situations; thus, the total number of variations exceeds 150. The implementation of all approaches presented in the framework is provided.

Service-orientation is a promising paradigm that enables the engineering of large-scale distributed software systems using rigorous software development processes. The existing problem is that every service-oriented software development project often requires a customized development process that provides specific service-oriented software engineering tasks in support of requirements unique to that project. To resolve this problem and allow situational method engineering, we have defined a set of method fragments in support of the engineering of the project-specific service-oriented software development processes. We have derived the proposed method fragments from the recurring features of eleven prominent service-oriented software development methodologies using a systematic mining approach. We have added these new fragments to the repository of OPEN Process Framework to make them available to software engineers as reusable fragments using this well-known method repository. Keyword. Service-Oriented Software Development, OPEN Process Framework, OPF Repository, Method Fragment, Situational Method Engineering

Selective symbolic execution (SSE) is a powerful program analysis technique for exploring multiple execution paths of a program. However, it faces a challenge in analyzing programs with environments that cannot be modeled nor virtualized. Examples include OS services managing I/O devices, software frameworks for accelerators, and specialized applications. We introduce Mousse, a system for analyzing such programs using SSE. Mousse uses novel solutions to overcome the above challenge. These include a novel process-level SSE design, environment-aware concurrent execution, and distributed execution of program paths. We use Mousse to comprehensively analyze five OS services in three smartphones. We perform bug and vulnerability detection, taint analysis, and performance profiling. Our evaluation shows that Mousse outperforms alternative solutions in terms of performance and coverage.

The software used to implement advanced functionalities in critical domains (e.g. autonomous operation) impairs software timing. This is not only due to the complexity of the underlying high-performance hardware deployed to provide the required levels of computing performance, but also due to the complexity, non-deterministic nature, and huge input space of the artificial intelligence (AI) algorithms used. In this paper, we focus on Apollo, an industrial-quality Autonomous Driving (AD) software framework: we statistically characterize its observed execution time variability and reason on the sources behind it. We discuss the main challenges and limitations in finding a satisfactory software timing analysis solution for Apollo and also show the main traits for the acceptability of statistical timing analysis techniques as a feasible path. While providing a consolidated solution for the software timing analysis of Apollo is a huge effort far beyond the scope of a single research paper, our work aims to set the basis for future and more elaborated techniques for the timing analysis of AD software. This work has been partially supported by the Spanish Ministry of Economy and Competitiveness (MINECO) under grant TIN2015-65316-P, the SuPerCom European Research Council (ERC) project under the European Union’s Horizon 2020 research and innovation programme (grant agreement No.772773), and the HiPEAC Network of Excellence. MINECO partially supported Enrico Mezzetti under Juan de la Cierva-Incorporación postdoctoral fellowship (IJCI-2016-27396), and Leonidas Kosmidis under Juan de la Cierva-Formación postdoctoral fellowship (FJCI-2017-34095).

Data, and its collection, is one core aspect of technology and research, nowadays. Various scientific disciplines are interested in collecting human data in practically any context (at home, at work, during leisure time). For example, experts from the field of Psychology design studies for reliable and valid data collection in the laboratory and in the wild. We propose a generic platform for data-collection software development to be used by scientists without a programming background. This is done by adapting a basic Unity project through a configuration file provided by the platform users through an easy to use user interface. The scientific user can adapt and rearrange pre-defined data collection modules targeting a desired research question, implement it as application within the data collection platform and use and manage the application for data collection and later data analysis. As a proof of concept, the platform was embedded with build-in application modules for wide-spread Psychology data collection experiments. The versatility of the platform was tested by creating three diverse prototypical applications. Finally, the usability of the proposed platform evaluated using the System Usability Scale obtained high usability results. The robust module-based nature of the platform architecture makes is possible to create a various range of of psychologically-proven applications with different features to be decided by the researcher. This holds true for both the development phase of the applications, as well as, for after deployment.

We witnessed great advancement in artificial intelligence (AI) powered technologies over the past few decades. Wide use of AI technologies has led to the creation of an ecosystem where human and AI systems are partners, complementing each other with their strengths. To build a successful human-AI team, there are several considerations, including context awareness, effective communication, pro-activeness, etc. In this paper, we present a taxonomy of human-AI teaming concepts. We extend a multi-agent framework, Java Agent Development Framework (JADE), to support the proposed taxonomy. Our solution framework, Human-AI Collaboration (HACO), enables a model-driven development of human-AI teaming systems through graphical user interface. In this paper, we present the solution architecture for extending JADE with human-AI teaming taxonomy. A user study performed to assess the usefulness of HACO, shows that HACO is a promising framework. We evaluated the proposed framework by developing a set of use cases for a contact center and observed a signification reduction in the overall development effort. The framework video can be viewed at https://youtu.be/lNyrrk8dMqU.