Search

Software updates are highly significant in autonomous vehicles. These updates are utilized to provide enhanced features and updated security mechanisms. In order to ensure scalability and smooth roll-out Over-the-air (OTA) mechanism is a preferred option to propagate a software update. However, this approach is vulnerable to security attacks because of existence of wireless communication channel between the vehicle and the manufacturer. In that, an attacker can replace the legitimate software with a malicious software with an intent to get control over the vehicle. In this work, we are motivated to address this problem. We develop an enhanced uptane framework for detection of malicious OTA software updates in autonomous vehicles. For enhancing security, we incorporate convolutional neural network (CNN) in the uptane framework. The proposed framework is able to distinguish between malicious and benign software executables with high accuracy. For training and testing, we create two datasets by collecting executables of Windows and Linux operating system. We encourage the use of transfer learning by exploiting the developed CNN models in order to detect malicious executable designed for autonomous vehicles. We also benchmark the CNN models against state-of-the art models. Our work is highly beneficial for the community in providing a secure mechanism for software updates.

An emergency response process outlines the workflow of different activities that need to be performed in response to an emergency. Effective emergency response requires communication and coordination with the operational systems belonging to different collaborating organizations. Therefore, it is necessary to establish information sharing and system-level interoperability among the diverse operational systems. Unlike typical e-government processes that are well structured and have a well-defined outcome, emergency response processes are knowledge-centric and their workflow structure and execution may evolve as the incident unfolds. It is impractical to define static plans and response process workflows for every possible situation. Instead, a dynamic response should be adaptable to the changing situation. We present an integrated approach that facilitates the dynamic composition of an executable response process. The proposed approach employs ontology-based reasoning to determine the default actions and resource requirements for the given incident and to identify relevant response organizations based on their jurisdictional and mutual aid agreement rules. The Web service APIs of the identified response organizations are then used to generate an executable response process that evolves dynamically. The proposed approach is implemented and experimentally validated using an example scenario derived from the FEMA Hazardous Materials Tabletop Exercises Manual.

Different web services can be composed to perform increasingly complex tasks (e.g., making an on-line payment). However, existing approaches compose web services with hard-coded control and data flows. To proactively and autonomously compose web services, developers can develop agents. However, the development of agents for service composition is complex, due to the reasons that: 1) developers may not have the knowledge from various domains to identify the necessary tasks to carry out the required web services; and 2) a deep understanding of the agent specific code is required in order to implement agents. To alleviate the required efforts to develop agents, we propose an approach to separate the development of agent specific code from the business logic code in the service composition. More specifically, we provide an easy-to-understand syntax that abstracts agent specific code and automatically generates executable agent code. Our experimental results show that our approach can accurately identify tasks for service composition with an Area Under the Curve (AUC) of 0.88. Our experiments also demonstrate that our approach can correctly generate agent code from seven agent specifications. Finally, our user studies reveal that developers are satisfied with our approach to develop agents for service composition.

As the reduced instruction set computing (RISC) processors are widely used nowadays, to meet the requirement that no secret instructions be included in the processor ISA or implemented in the processor micro-architecture, a consistency testing approach capable of revealing any possible dark instructions (i.e., executable instructions without clear definitions) in RISC processors has been proposed and comes in three phases. During the generation phase, based on the instruction set encoding rules, all the undefined instructions are generated. Even with a smaller test space, this step guarantees the test coverage needed to reveal all possible dark instructions that exist. In the next phase, all the undefined instructions obtained from the previous phase are executed on the processor under test, following some persistence strategies; any instruction exhibiting usual execution result will be deemed suspicious and recorded so. During the last analysis phase, each of those recorded suspicious instructions will be checked and analyzed to decide whether it truly constitutes a dark instruction. We have applied the proposed testing model and strategy to several RISC processors and found that all of them have a few dark instructions previously unknown. The potential vulnerabilities introduced by these dark instructions have thus been evaluated and exposed.

Obfuscation is a prevalent security technique which transforms syntactic representation of a program to a complicated form, but still keeps program semantics unchanged. So far, developers heavily rely on obfuscation to harden their products and reduce the risk of adversarial reverse engineering. However, despite its spectacular progress, one crucial hurdle is that each of existing obfuscation method is designed specifically for obfuscating one program feature (e.g., identifier name, control flow), so an effective obfuscation scheme usually composes a considerable amount of different obfuscation methods. Therefore, one primary challenge lies in identifying effective combinations of obfuscation methods. In this research, we propose a principled technique for generating an optimal program obfuscation scheme by adopting a reinforcement learning approach. Given a program and a set of obfuscation transformations, a reinforcement learning model is progressively trained to select a sequence of obfuscation transformations, such that applying each transformation in order towards the program yields the optimal obfuscation result, making programs dissimilar while retaining reasonable instrumentation overhead. Our implementation can directly work on raw binary executables without source code, and our evaluation demonstrates that the trained models can effectively obfuscate executable files with low cost.

The emergence of Virtual Prototypes (VPs) at the Electronic System Level (ESL) has played a major role in modernizing the System-on-Chips (SoCs) design process to raise design productivity and reduce time-to-market. A VP is an abstract and executable software model implemented typically using SystemC and its Transaction Level Modeling (TLM) framework. However, this modern VP-based design process still has weaknesses, in particular, due to the significant manual effort involved for design understanding, analysis and modeling tasks which is both time consuming and error-prone. This paper introduces an automated and fast design understanding approach that enables designers to trace detailed information of the VPs’ structure and behavior. Experimental results including a real-world VP-based SoC show the advantages of our approach such as its accuracy, applicability, and scalability.

With the widespread application of smart devices, spatial crowdsourcing (SC) has been extensively integrated into daily life. Task assignment is a crucial issue in SC and has attracted much attention. Most prior studies on task assignment ignore the importance of dependency among tasks, resulting in some ineffective matching pairs and wasting workers’ time. To this end, we formulate a new problem in SC, abbreviated as multi-stage complex task assignment (MSCTA), which aims to assign workers to multi-stage complex tasks to maximize the total profit. Compared with existing studies, MSCTA can obtain more effective assignments by considering the dependency constraints among tasks. We prove that the MSCTA problem is NP-hard and propose a greedy algorithm and a game algorithm. Specifically, both algorithms iteratively utilize a filtering module to obtain a set of executable tasks (ET) for assignment. The greedy algorithm can quickly assign the most profitable workers to the subtasks in each round of ET, and obtain a provable approximate result. The game algorithm is proved to be convergent and can win a Nash equilibrium when processing the subtasks in each round of ET. Extensive experimental results demonstrate the efficiency of our algorithm.

Motivation Protein model quality assessment is a key component of protein structure prediction. In recent research, the voxelization feature was used to characterize the local structural information of residues, but it may be insufficient for describing residue-level topological information. Design features that can further reflect residue-level topology when combined with deep learning methods are therefore crucial to improve the performance of model quality assessment. Results We developed a deep-learning method, DeepUMQA, based on Ultrafast Shape Recognition (USR) for the residue-level single-model quality assessment. In the framework of the deep residual neural network, the residue-level USR feature was introduced to describe the topological relationship between the residue and overall structure by calculating the first moment of a set of residue distance sets and then combined with 1D, 2D and voxelization features to assess the quality of the model. Experimental results on the CASP13, CASP14 test datasets and CAMEO blind test show that USR could supplement the voxelization features to comprehensively characterize residue structure information and significantly improve model assessment accuracy. The performance of DeepUMQA ranks among the top during the state-of-the-art single-model quality assessment methods, including ProQ2, ProQ3, ProQ3D, Ornate, VoroMQA, ProteinGCN, ResNetQA, QDeep, GraphQA, ModFOLD6, ModFOLD7, ModFOLD8, QMEAN3, QMEANDisCo3 and DeepAccNet. Availability and implementation The DeepUMQA server is freely available at http://zhanglab-bioinf.com/DeepUMQA/. Supplementary information Supplementary data are available at Bioinformatics online.

The potential benefits of autonomous systems are obvious. However, there are still major issues to be dealt with before developing such systems becomes a commonplace engineering practice, with accepted and trustworthy deliverables. We argue that a solid, evolving, publicly available, community-controlled foundation for developing next-generation autonomous systems is a must, and term the desired foundation Autonomics. We focus on three main challenges: (i) how to specify autonomous system behavior in the face of unpredictability; (ii) how to carry out faithful analysis of system behavior with respect to rich environments that include humans, physical artifacts, and other systems; and (iii) how to build such systems by combining executable modeling techniques from software engineering with artificial intelligence and machine learning.

Rail corrugation (RC) is one of the most important indicator to evaluate the quality of rail, which is used to describe the irregularity of rail surface, also known as rail's vertical flatness. However, the definition of RC is still an empirical description for low-speed measurement devices. In this paper, the process of RC measurement is divided into two steps, sampling and extraction, which helps the users to understand more clearly. Then a new mathematic model is proposed to make the process of RC's extraction be an executable operation for machine calculation. The model adopts a new concept of flexible virtual ruler to perform sliding filtering on an overall rail and extract the instantaneous RC with a successive approximation algorithm according to user's requirements and national standards. The proposed FVR model can not only be fully compatible with the traditional extraction method of RC, but also provide a new idea for evaluating RC's quality. Comparing with the current popular methods, the proposed model gives a meaningful strategy for rail maintenance with a complete mathematic description having more degrees of freedom. Experiment results demonstrate its validity and reliability for both indoor simulation and actual outdoor experiments.

Model-driven methodology has been widely adopted in embedded software design, and Dataflow is a widely used computation model, with strong modeling and simulation ability supported in tools such as Ptolemy. However, its code synthesis support is quite limited, which restricts its applications in real industrial practice. In this paper, we focus on the automatic code synthesis of Dataflow, and implement , a code generator that could support most of the widely used modeling features such as expression type and boolean switch, more efficiently. First, we disassemble the Dataflow model into actors embedded in if-else or switch-case statements based on schedule analysis, which bridges the semantic gap between the code and the original Dataflow model. Then, we design well-designed templates for each actor, and synthesize well-structured executable C and Java codes with sequential code assembly. Compared to the existing C and Java code generators of Dataflow model in Ptolemy-II, and the C code generator in Simulink, the lines of code synthesized by are decreased by an average of , and , and the execution time of the synthesized code by is also decreased by an average of , and respectively.

Communicating linear algebra in written form is challenging: mathematicians must choose between writing in languages that produce well-formatted but semantically-underdefined representations such as LaTeX; or languages with well-defined semantics but notation unlike conventional math, such as C++/Eigen. In both cases, the underlying linear algebra is obfuscated by the requirements of esoteric language syntax (as in LaTeX) or awkward APIs due to language semantics (as in C++). The gap between representations results in communication challenges, including underspecified and irreproducible research results, difficulty teaching math concepts underlying complex numerical code, as well as repeated, redundant, and error-prone translations from communicated linear algebra to executable code. We introduce I$\heartsuit$LA, a language with syntax designed to closely mimic conventionally-written linear algebra, while still ensuring an unambiguous, compilable interpretation. Inspired by Markdown, a language for writing naturally-structured plain text files that translate into valid HTML, I$\heartsuit$LA allows users to write linear algebra in text form and compile the same source into LaTeX, C++/Eigen, Python/NumPy/SciPy, and MATLAB, with easy extension to further math programming environments. We outline the principles of our language design and highlight design decisions that balance between readability and precise semantics, and demonstrate through case studies the ability for I$\heartsuit$LA to bridge the semantic gap between conventionally-written linear algebra and unambiguous interpretation in math programming environments.

The Internet-of-Things (IoT) scenarios commonly present security and privacy concerns, either due to the processing constraints of devices or the employment of external servers to process and store data, for instance, in cloud-based IoT applications. In this sense, to protect data and decrease user distrust in external entities, security technologies are of utmost importance. Trusted execution environments (TEEs), which process data in an isolated and protected region of memory, are among these technologies. We focus on a trusted architecture solution based on the use of TEEs and the application of authentication, authorization, and encryption mechanisms to protect data in IoT applications. We specified the trusted IoT architecture (TIoTA) using hierarchical colored Petri nets, and performed simulations and model checking of key security properties related to desired and prohibited behaviors, enabling model-based testing. This article enhances the state of the art by providing project artifacts (e.g., executable and parametric models) for correctly implementing the TIoTA and by presenting evidence that the usage of the architecture can improve security and privacy.

Model-based testing is an automated process in which executable tests are derived from behavioral models of a system. Model checking is a verification technique to reveal errors in which all reachable states of a system can be generated as state space. In the literature, different approaches suggest using model checkers for model-based testing. Model checker explores all possible system states, so utilizing the various paths in the state-space as test cases seems a promising solution. However, these approaches suffer from two main challenges. The first challenge is state space explosion, which prevents generating all reachable states by the model checker. The second one is generating redundant test cases. Recently, several methods using meta-heuristic and evolutionary approaches have been proposed to cope with these problems. Therefore, exploring a portion of state space using an optimization approach to detect the test objectives can be a proper way to manage the state space explosion and generate an optimal test suite with the least redundancy. In this paper, a method is proposed using a Bayesian optimization algorithm (BOA), and a model checker is as a bed to generate test cases for the service-oriented systems. In the proposed approach, the test suite is a set of paths on the state space starting from an initial state and leading to the state in which all the test objectives are satisfied. In this research, we have implemented BOA with three different structures in GROOVE toolset, an open-source toolset for designing and model checking graph transformation. Experimental results show that our solution generates better results in terms of coverage and speed in different case studies than the existing approaches.

Background The aim of the present paper is to construct an emulator of a complex biological system simulator using a machine learning approach. More specifically, the simulator is a patient-specific model that integrates metabolic, nutritional, and lifestyle data to predict the metabolic and inflammatory processes underlying the development of type-2 diabetes in absence of familiarity. Given the very high incidence of type-2 diabetes, the implementation of this predictive model on mobile devices could provide a useful instrument to assess the risk of the disease for aware individuals. The high computational cost of the developed model, being a mixture of agent-based and ordinary differential equations and providing a dynamic multivariate output, makes the simulator executable only on powerful workstations but not on mobile devices. Hence the need to implement an emulator with a reduced computational cost that can be executed on mobile devices to provide real-time self-monitoring. Results Similarly to our previous work, we propose an emulator based on a machine learning algorithm but here we consider a different approach which turn out to have better performances, indeed in terms of root mean square error we have an improvement of two order magnitude. We tested the proposed emulator on samples containing different number of simulated trajectories, and it turned out that the fitted trajectories are able to predict with high accuracy the entire dynamics of the simulator output variables. We apply the emulator to control the level of inflammation while leveraging on the nutritional input. Conclusion The proposed emulator can be implemented and executed on mobile health devices to perform quick-and-easy self-monitoring assessments.

This is the world’s first tutorial article on Python Packaging for beginners and practitioners for translational medicine or medicine in general. This tutorial will allow researchers to demonstrate and showcase their tools on PyPI packages around the world. Nowadays, for translational medicine, researchers need to deal with big data. This paper describes how to build an executable Python Package Index (PyPI) code and package. PyPI is a repository of software for the Python programming language with 5,019,737 files and 544,359 users (programmers) as of 19 October 2021. First, programmers must understand how to scrape a dataset over the Internet; second, they must read the dataset file in csv format; third, build a program to compute the target values; fourth, convert the Python program to the PyPI package.; and fifth, upload the PyPI package. This paper depicts a covidlag executable package as an example for calculating the accurate case fatality rate (CFR) and the lag time from infection to death. You can install the covidlag by pip terminal command and test it. This paper also introduces deathdaily and scorecovid packages on PyPI Stats, which can inform how many users have downloaded the specified PyPI package. The usefulness and applicability of a developed tool can be verified by PyPI Stats with the number of downloaded users.

Background Antimicrobial peptides are promising tools to fight against ever-growing antibiotic resistance. However, despite many advantages, their toxicity to mammalian cells is a critical obstacle in clinical application and needs to be addressed. Results In this study, by using an up-to-date dataset, a machine learning model has been trained successfully to predict the toxicity of antimicrobial peptides. The comprehensive set of features of both physico-chemical and linguistic-based with local and global essences have undergone feature selection to identify key properties behind toxicity of antimicrobial peptides. After feature selection, the hybrid model showed the best performance with a recall of 0. 876 and a F1 score of 0. 849. Conclusions The obtained model can be useful in extracting AMPs with low toxicity from AMP libraries in clinical applications. On the other hand, several properties with local nature including positions of strand forming and hydrophobic residues in final selected features show that these properties are critical definer of peptide properties and should be considered in developing models for activity prediction of peptides. The executable code is available at https://git.io/JRZaT.

Over the past few years, there has been a surge in the popularity of binary optimizers such as BOLT, Propeller, Janus and HALO. These tools use dynamic profiling information to make optimization decisions. Although effective, gathering runtime data presents developers with inconveniences such as unrepresentative inputs, the need to accommodate software modifications, and longer build times. In this paper, we revisit the static profiling technique proposed by Calder et al. in the late 90’s, and investigate its application to drive binary optimizations, in the context of the BOLT binary optimizer, as a replacement for dynamic profiling. A few core modifications to Calder et al.’s original proposal, consisting of new program features and a new regression model, are sufficient to enable some of the gains obtained through runtime profiling. An evaluation of BOLT powered by our static profiler on four large benchmarks (clang, GCC, MySQL and PostgreSQL) yields binaries that are 5.47 % faster than the executables produced by clang -O3.

While the open-source software development model has led to successful large-scale collaborations in building software systems, data science projects are frequently developed by individuals or small teams. We describe challenges to scaling data science collaborations and present a conceptual framework and ML programming model to address them. We instantiate these ideas in Ballet, the first lightweight framework for collaborative, open-source data science through a focus on feature engineering, and an accompanying cloud-based development environment. Using our framework, collaborators incrementally propose feature definitions to a repository which are each subjected to software and ML performance validation and can be automatically merged into an executable feature engineering pipeline. We leverage Ballet to conduct a case study analysis of an income prediction problem with 27 collaborators, and discuss implications for future designers of collaborative projects.

Strong rock blocks embedded in a weaker soil matrix are found in many geological units. When tunneling in ground containing cobbles and boulders, extremely challenging conditions can be encountered. Such inconveniences may be avoided by means of appropriate tunneling methods and cutterhead designs, which require the content, frequency, and size of rock blocks to be predicted as accurately as possible. Several approaches have been developed to estimate the block fraction of heterogeneous geomaterials for excavation. However, the estimation of cobble–boulder quantities both all along the tunnel and only partially embedded within the tunnel face remains a critical issue. This study develops a methodology for the estimation of the probability of encountering blocks partially or totally contained within the tunnel excavation area, wherein the area of intersection with the tunnel face is greater than the given critical values. For this purpose, a statistical approach has been implemented in a Matlab routine. The potential of this code is that it provides extremely useful and statistically based information that can be used for making a more rational choice regarding tunneling technique and in terms of designing a suitable cutterhead in order to avoid technical problems during tunnel excavations in heterogeneous ground. The executable code is provided.

A new version of the DielParamFit program [J. Colloid Interface Sci. 419 (2014) 102-106] for the fitting of a superposition of dispersion terms to measured dielectric data is presented. It extends its applicability to a wide range of new systems by allowing the use of up to three Havriliak-Negami dispersions, each of which can be readily transformed into Debye, Cole-Cole, or Cole-Davidson terms. Moreover, it greatly enhances its usability by means of a graphic interface that displays the measured data together with the model spectra allowing to iteratively adjust the chosen terms and guess parameter values guided by a live view of the obtained results. The DielParamFit_2 program executable file for Microsoft Windows is available upon request from the author.

Junto al primer robot manipulador, el UNIMATE de Devol y Engelberger, nació la preocupación de investigadores e ingenieros por demostrar el potencial de autómatas similares en aplicaciones industriales. En consecuencia muchas prestigiosas universidades percibieron cuán importante era incluir asignaturas del área en planes de estudios de carreras como Ingeniería Eléctrica, Electrónica, Mecánica o Mecatrónica. La presente investigación fue bajo el método constructivista y el análisis de resultados se apoya en la respuesta observada en un simulador mediante el uso combinado de una Toolbox para modelación cinemática de robots (basada en scripts ejecutables en un entorno como GNU Octave o similar), además de un software para simulación 3D. La ejemplificación del uso de las herramientas y el reto al estudiante de programar RI virtuales en escenarios típicos de manufactura, empaquetado o paletizado, ha sido probado a lo largo de cuatro períodos lectivos, obteniéndose una realimentación positiva de los aprobados y egresados. Los resultados alcanzados al simular demuestran la exactitud de los modelos cinemáticos obtenidos mediante formulaciones matemáticas, lo cual evidencia la utilidad de las herramientas descritas para el aprendizaje a distancia basado en la práctica.

Monitoring environmental conditions is an important application of cyber-physical systems. Typically, the monitoring is to perceive surrounding environments with battery-powered, tiny devices deployed in the field. While deep learning-based methods, especially the convolutional neural networks (CNNs), are promising approaches to enriching the functionalities offered by the tiny devices, they demand more computation and memory resources, which makes these methods difficult to be adopted on such devices. In this article, we develop a software framework, RAP , that permits the construction of the CNN designs by aggregating the existing, lightweight CNN layers, which are able to fit in the limited memory (e.g., several KBs of SRAM) on the resource-constrained devices satisfying application-specific timing constrains. RAP leverages the Python-based neural network framework Chainer to build the CNNs by mounting the C/C++ implementations of the lightweight layers, trains the built CNN models as the ordinary model-training procedure in Chainer, and generates the C version codes of the trained models. The generated programs are compiled into target machine executables for the on-device inferences. With the vigorous development of lightweight CNNs, such as binarized neural networks with binary weights and activations, RAP facilitates the model building process for the resource-constrained devices by allowing them to alter, debug, and evaluate the CNN designs over the C/C++ implementation of the lightweight CNN layers. We have prototyped the RAP framework and built two environmental monitoring applications for protecting endangered species using image- and acoustic-based monitoring methods. Our results show that the built model consumes less than 0.5 KB of SRAM for buffering the runtime data required by the model inference while achieving up to 93% of accuracy for the acoustic monitoring with less than one second of inference time on the TI 16-bit microcontroller platform.

3D charge-trap (CT) NAND flash-based SSD has been used widely for its large capacity, low cost per bit, and high endurance. One-shot program (OSP) scheme, as a variation of incremental step pulse programming (ISPP) scheme, has been employed to program data for CT flash, whose program unit is the Word-Line (WL) instead of the page. The existing program optimization schemes either make trade-offs among program latency and reliability by adjusting the program step voltage on demand; or remap the most error-prone cell states to others by re-encoding programmed data. However, the data pattern, which represents the ratio of 1s in data values, has not been thoroughly studied. In this paper, we observe that most small files do not contain uniform 1s and 0s among these common file types (i.e., image, audio, text, executable file), leading to programming WL cells in different states unevenly. Some cell states dominate over the WL, while others are not. Based on this observation, we propose a flexible reliability enhancement scheme based on the OSP scheme. This scheme programs the cells into different states with varied , i.e., these cells in one state, whose number is the largest in one WL, are programmed with a fine-grained (namely slow write). In contrast, the minority are programmed with a coarse-grained (namely fast write). So the reliability is improved due to averaging the major enhanced cells with the minor degraded cells without program latency overhead. A series of experiments have been conducted, and the results indicate that the proposed scheme achieves 34% read performance improvement and 16% lifetime elongation on average.

Owing to the vast volume of information gathered by computers, data protection and security has become a problem for organizations with the enormous rise in data transmission. Due to many advantages that cloud service providers provide, mainly economic benefits, several data owners outsource their data to cloud repositories. However, data owners do not have full ownership of the data after their data are outsourced. Thus, external data management systems are implemented to manage the data. Several kinds of research refer to the use of encryption techniques to prevent unauthorized access to data. Selective encryption aims at supporting selective and private access to outsourced data. However, the combination of this approach and indexing techniques cause confidentiality violations. In this article, a blockchain-based approach to data access is presented by implementing smart contracts over data access. These executable scripts bind users by stating access policies on the data. Furthermore, we provide a system, where users can offload their computational capabilities due to limitations in their computations. Our systems’ computational capabilities outperform that of when users do the computation on their own. The results show a practical approach to data access management using blockchain technology.

With the proliferation of smartphone demand, the number of malicious applications has increased exponentially with about tens of thousands per month. Among smartphone platforms, the Android operating system with high popularity has become the most target by malware. By some techniques such as employing polymorphic or encrypting payload, signature-based scanning is easily bypassed. With the support from some useful tools and sandboxes recently, the Android applications could be easy to decoded and tracked the executable behavior. It leads machine learning methods to have potential benefits to classify the malware. However, how to define the suitable model with competent features and avoid over-fitting in learning models become other challenges for researchers. In this paper, we propose MINAD (Multi-Inputs Neural network based on application structure for Android malware Detection) method. First, we collect the features of an Android application based on many aspects, and then those features are grouped into three categories: System-based, Library-based, and User-based corresponding the parts of Android application structure which are related with Android system definition, library, users’ definitions. Second, each group is reconstructed to have effective feature sets. At last, a multi-input deep neural network is designed with two phases to learn the abstract of each feature group before making the final decision for malware detection. Our performances are evaluated in various samples which are collected from Google Play Store, the Drebin, and AMD Datasets with more than 155,000 samples. The results show that the MINAD method does not only improve Android malware detection’s accuracy in comparison with other methods but also improves the stability of the model and reduces the computation costs.

This article presents a methodology to formalize the behavior of the machines composing a production line, and to automatically generate their virtual prototypes for efficient and correct plant simulation. The approach exploits assume-guarantee reasoning through contracts to model the interaction between the different components of a production line. The approach is guided by a well-known taxonomy of industrial machines and associated manufacturing processes to identify each elementary action related to a specific machine. Contracts enable to build executable models of all the machines available in the production line by using automatic synthesis. The generated models can be integrated into a state-of-the-practice industrial plant simulation software to estimate and validate the production line's behavior. The presentation of the methodology is supported by a running example based on a real production line, showing the step-by-step application of the approach to a concrete scenario.

Summary This work describes two novel workflows for variant calling that extend the widely used algorithms of Strelka2 and FreeBayes to call somatic mutations from multiple related tumour samples and one matched normal sample. We show that these workflows offer higher precision and recall than their single tumour-normal pair equivalents in both simulated and clinical sequencing data. Availability and implementation Source code freely available at the following link: https://atlassian.petermac.org.au/bitbucket/projects/DAW/repos/multisamplevariantcalling and executable through Janis (https://github.com/PMCC-BioinformaticsCore/janis) under the GPLv3 licence. Supplementary information Supplementary data are available at Bioinformatics online.

Aiming at insufficient situation to express and operate assets in smart contracts, in this article we attempt to add a new asset model into smart contract language (such as SPESC) through combing method of asset's expressions and transactions in real-world contracts. Moreover, a translation mechanism can be set up to accomplish a conversion from the asset model to an executable contract program. On this basis, we propose a new language design toward asset-driven specific smart contracts, called TA-SPESC. This language complies with the structure of real-world contracts and supports a formal definition composed of four modules: Party, asset, term, and contract attribute. This asset model on it can be used to define various types of rights (including the right of ownership, use, possession, usufruct, and disposition of assets), as well as five asset operations (including asset registration, deposit, withdrawal, transfer, and cancellation) to effectively support asset transaction. More important, a series of generation rules are proposed to translate the TA-SPESC contract to an executable contract program. Moreover, taking house rental contract as an example, we provide a TA-SPESC instance and its specific description of translation process according to the generation rules, which supports a semiautomatic generation to executable programs. Finally, the Solidity codes derived from TA-SPESC contracts are run and tested, and the experiment and comparison results indicate that TA-SPESC contracts have high abstraction and low complexity, as well as versatility and convenience of asset transaction, which lead to more reliable software with less errors and fewer misunderstanding.

International audience; This paper presents a novel formal semantics, mechanized in Coq, for a large, sequential subset of the LLVM IR. In contrast to previous approaches, which use relationally-specified operational semantics, this new semantics is based on monadic interpretation of interaction trees, a structure that provides a more compositional approach to defining language semantics while retaining the ability to extract an executable interpreter. Our semantics handles many of the LLVM IR's non-trivial language features and is constructed modularly in terms of event handlers, including those that deal with nondeterminism in the specification. We show how this semantics admits compositional reasoning principles derived from the interaction trees equational theory of weak bisimulation, which we extend here to better deal with nondeterminism, and we use them to prove that the extracted reference interpreter faithfully refines the semantic model. We validate the correctness of the semantics by evaluating it on unit tests and LLVM IR programs generated by HELIX.

Due to their advantages, there is an increase of applying robotic systems for small batch production as well as for complex manufacturing processes. However, programming and configuring robots is time and resource consuming while being also accompanied by high costs that are especially challenging for small- and medium-sized enterprises. The current way of programming industrial robots by using teach-in control devices and/or using vendor-specific programming languages is in general a complex activity that requires extensive knowledge in the robotics domain. It is therefore important to offer new practical methods for the programming of industrial robots that provide flexibility and versatility in order to achieve feasible robotics solutions for small lot size productions. This paper focuses on the development of a knowledge-driven framework, which should overcome the limitations of state-of-the-art robotics solutions and enhance the agility and autonomy of industrial robotics systems using ontologies as a knowledge-source. The framework includes reasoning and perception abilities as well as the ability to generate plans, select appropriate actions, and finally execute these actions. In this context, a challenge is the fusion of vision system information with the decision-making component, which can use this information for generating the assembly tasks and executable programs. The introduced product model in the form of an ontology enables that the framework can semantically link perception data to product models to consequently derive handling operations and required tools. Besides, the framework enables an easier adaption of robot-based production systems for individualized production, which requires swift configuration and efficient planning. The presented approach is demonstrated in a laboratory environment with an industrial pilot test case. Our application shows the potential to reduce the efforts needed to program robots in an automated production environment. In this context, the benefits as well as shortcomings of the approach are also discussed in the paper.

We developed EasyNanopore which is a ready-to-use software to select the events of a nanopore molecular translocation experiment. The software is released as an executable file with a graphical user interface and provides several versions suitable for different operating systems without installing any running environment to execute it. We use the adaptive threshold which adapts to the low-frequency variation of the baseline to detect events and uses a multiprocess method to accelerate the process of event detection. After the event is identified, its duration and amplitude information will be extracted and a resulting txt file will be generated for further analysis. Our software runs fast and can effectively extract the data from data of large-scale nanopore molecular translocation experiments.

Quadruped robots have superior terrain adaptability and flexible movement capabilities than traditional robots. In this article, we innovatively apply it in person-following tasks, and propose an efficient motion planning scheme for quadruped robots to generate a flexible and effective trajectory in confined spaces. The method builds a real-time local costmap via onboard sensors, which involves both static and dynamic obstacles. And we exploit a simplified kinodynamic model and formulate the friction pyramids formed by ground reaction forces’ inequality constraints to ensure the executable of the optimized trajectory. In addition, we obtain the optimal following trajectory in the costmap completely based on the robot's rectangular footprint description, which ensures that it can walk through the narrow spaces avoiding collision. Finally, a receding horizon control strategy is employed to improve the robustness of motion in complex environments. The proposed motion planning framework is integrated on the quadruped robot JueYing and tested in simulation as well as real scenarios. It shows that the execution success rates in various scenes are all over 90%.

Successful software authorship de-anonymization has both software forensics applications and privacy implications. However, the process requires an efficient extraction of authorship attributes. The extraction of such attributes is very challenging, due to various software code formats from executable binaries with different toolchain provenance to source code with different programming languages. Moreover, the quality of attributes is bounded by the availability of software samples to a certain number of samples per author and a specific size for software samples. To this end, this work proposes a deep Learning-based approach for software authorship attribution, that facilitates large-scale, format-independent, language-oblivious, and obfuscation-resilient software authorship identification. This proposed approach incorporates the process of learning deep authorship attribution using a recurrent neural network, and ensemble random forest classifier for scalability to de-anonymize programmers. Comprehensive experiments are conducted to evaluate the proposed approach over the entire Google Code Jam (GCJ) dataset across all years (from 2008 to 2016) and over real-world code samples from 1,987 public repositories on GitHub. The results of our work show high accuracy despite requiring a smaller number of samples per author. Experimenting with source-code, our approach allows us to identify 8,903 GCJ authors, the largest-scale dataset used by far, with an accuracy of 92.3%. Using the real-world dataset, we achieved an identification accuracy of 94.38% for 745 C programmers on GitHub. Moreover, the proposed approach is resilient to language-specifics, and thus it can identify authors of four programming languages (e.g., C, C++, Java, and Python), and authors writing in mixed languages (e.g., Java/C++, Python/C++). Finally, our system is resistant to sophisticated obfuscation (e.g., using C Tigress) with an accuracy of 93.42% for a set of 120 authors. Experimenting with executable binaries, our approach achieves 95.74% for identifying 1,500 programmers of software binaries. Similar results were obtained when software binaries are generated with different compilation options, optimization levels, and removing of symbol information. Moreover, our approach achieves 93.86% for identifying 1,500 programmers of obfuscated binaries using all features adopted in Obfuscator-LLVM tool.

One of the promising techniques to address the dependability of a system is to apply, at early design stages, domain-specific languages (DSLs) with execution semantics. Indeed, an executable DSL would not only represent the expected system’s structure, but it is intended to itself behave as the system should run. In order to make executable DSLs a powerful asset in the development of safety-critical systems, not only a rigorous development process is required but the domain expert should also have confidence in the execution semantics provided by the DSL developer. To this aim, we recently developed the Meeduse tool and showed how to bridge the gap between MDE and a proof-based formal approach. In this work, we apply our approach to the Petri-net DSL and we present MeeNET, a proved Petri-net designer and animator powered by Meeduse. MeeNET is built on top of PNML (Petri-Net Markup Language), the international standard ISO/IEC 15909 for Petri-nets, and provides underlying formal static and dynamic semantics that are verified by automated reasoning tools. This paper first presents simplified MDE implementations of Petri-nets applying Java, QVT, Kermeta and fUML that we experimented in order to debug a safety-critical system and summarises the lessons learned from this study. Then, it provides formal alternatives, based on the B method and process algebra, which are well-established techniques allowing interactive animation on the one hand and reasoning about the behaviour correctness, on the other hand.

This paper provides a survey of methods and tools for automated code-reuse exploit generation. Such exploits use code that is already contained in a vulnerable program. The code-reuse approach allows one to exploit vulnerabilities in the presence of operating system protection that prohibits data memory execution. This paper contains a description of various code-reuse methods: return-to-libc attack, return-oriented programming, jump-oriented programming, and others. We define fundamental terms: gadget, gadget frame, gadget catalog. Moreover, we show that, in fact, a gadget is an instruction, and a set of gadgets defines a virtual machine. We can reduce an exploit creation problem to code generation for this virtual machine. Each particular executable file defines a virtual machine instruction set. We provide a survey of methods for gadgets searching and determining their semantics (creating a gadget catalog). These methods allow one to get the virtual machine instruction set. If a set of gadgets is Turing-complete, then a compiler can use a gadget catalog as a target architecture. However, some instructions can be absent. Hence we discuss several approaches to replace missing instructions with multiple gadgets. An exploit generation tool can chain gadgets by pattern searching (regular expressions) or considering gadgets semantics. Furthermore, some chaining methods use genetic algorithms, while others use SMT-solvers. We compare existing open-source tools and propose a testing system rop-benchmark that can be used to verify whether a generated chain successfully opens a shell.

Tackling binary program analysis problems has traditionally implied manually defining rules and heuristics, a tedious and time consuming task for human analysts. In order to improve automation and scalability, we propose an alternative direction based on distributed representations of binary programs with applicability to a number of downstream tasks. We introduce Bin2vec, a new approach leveraging Graph Convolutional Networks (GCN) along with computational program graphs in order to learn a high dimensional representation of binary executable programs. We demonstrate the versatility of this approach by using our representations to solve two semantically different binary analysis tasks – functional algorithm classification and vulnerability discovery. We compare the proposed approach to our own strong baseline as well as published results, and demonstrate improvement over state-of-the-art methods for both tasks. We evaluated Bin2vec on 49191 binaries for the functional algorithm classification task, and on 30 different CWE-IDs including at least 100 CVE entries each for the vulnerability discovery task. We set a new state-of-the-art result by reducing the classification error by 40% compared to the source-code based inst2vec approach, while working on binary code. For almost every vulnerability class in our dataset, our prediction accuracy is over 80% (and over 90% in multiple classes).

The final executable code should no longer be considered as a central element in a software development process but rather a naturally important component that results from a model transformation. The objective of the MDA (Model Driven Architecture) approach is to lift the lock of software development automation from the CIM (Computation Independent Model) requirements until the code of an application is obtained. Therefore, we have proposed in the framework of MDA an approach that consists of automatically generating object-oriented code from the CIM model represented by ReLEL (Restructuring extended Lexical Elaborate Language). ReLEL is a natural language-oriented model that represents both the client requirements and the conceptual level of a system. However, the MDA framework does not recommend the type of UML model that corresponds to each business activity. Consequently, automating the software development process from the CIM model specified by ReLEL becomes a complex task. Our strategy in this paper includes the instantiation of the ReLEL model in the Praxeme methodology, which models each of the company's concerns, grouped in a homogeneous whole, using the UML (Unified Modeling Language) and which considers the articulation of these aspects by adopting the MDA principle. To do this, we propose to automate the articulation that covers the intentional, semantic, logical, and software aspects of Praxeme. To validate our approach, we measure the coupling and cohesion of the UML class diagram obtained from the Java code generated from this article using the slicing technique. The results show that the coupling is weak, and the cohesion is strong. It can be deduced that the method proposed in this paper can produce a more reliable and efficient system.

The purpose of the study is to develop a reliable computer-aided statistical instrument for data processing. The researcher come up to the idea to formulate an executable program running in Microsoft Excel platform. The platform is chosen based on the fact that it is widely used office application and known to be user-friendly. EASIER or Executable Access to Statistics for Interactive and Efficient Research was born. Executable because the program can be run by a computer, it is accessible in terms that most teachers use MS Excel as an office application, it can solve and analyze most statistics problems, interactive because there is a two-way flow of information between a computer and the user which respond to a certain input, the system promise to achieve a maximum productivity with a minimum wasted effort or expense, and to establish facts and reach new conclusions. The statistical instrument was evaluated by twenty-four (24) Senior High School Teachers from Nagcarlan, Liliw, Majayjay, Magdalena, Pila, Victoria, and Sta. Cruz district and six (6) College Teachers from Laguna State Polytechnic University Sta. Cruz Main Campus, and from Philippine Women’s University Sta. Cruz, Laguna. It sought to answer the following questions: (1). What is the mean level of basic requirements of using computer-aided statistical instrument in terms of: 1.1 knowledge, 1.2 software and 1.3 hardware.? (2). What is the mean level of capability of EASIER as a computer-aided statistical instrument in computing statistical problems in terms of: 2.1 accepting input and data parameters, 2.2 organizing data, and 2.3 generating result, figures, charts, and drawing conclusion? (3). What is the mean level of acceptability of EASIER as a computer-aided statistical instrument in statistical analysis in terms of; 3.1 tool interface, and 3.2 operation and function? (4). Is there a significant difference between the level of responses of teachers from Senior High School and College instructors in terms of capability and acceptability of EASIER as a computer-aided statistical instrument?

For effective fault localization, we propose a modified Fisher’s test-based statistical method that makes use of test execution results as well as statement coverage information to determine the suspiciousness of each executable statement. Our technique returns a rank list of statements based on their suspiciousness of containing a fault. We also discuss an extension to our proposed approach for localizing programs with multiple faults. This involves partitioning the failed test cases into clusters such that they target different faults. Our experimental studies show that on an average, our proposed fault localization technique requires examination of 37.09% less code than existing techniques for localizing faults.

The periodic table allows students to easily understand the chemical elements and predict the behavior of theoretical yet undiscovered new elements. Many memorization techniques have been used for learning the periodic table, yet serious games (i.e., designed for a primary purpose other than pure entertainment) have been underexplored to complement or even replace such memorization techniques. Since CHEMMEND, an existing physical card game, was found to assist with learning the periodic table, we explore the potential of E-CHEMMEND, a digital version of the game as an aid to memorize the group and period numbers of the elements. E-CHEMMEND is a single-player serious game to explore the effect of four different game conditions involving two experimental factors that account for different educational scenarios. The first factor investigates the role of playing through levels of increasing difficulty versus playing with all elements from the very beginning. The second factor investigates the role of displaying the group and period numbers of the chemical element along with its symbol versus only displaying the element symbol. Preliminary results show that E-CHEMMEND is perceived as more enjoyable when the group and period numbers are displayed. In contrast, the game is found to better assist learning when this information is hidden and levels are shown. Taken together, our results suggest that a variety of educational purposes can be accommodated with a range of game settings. Ultimately, the design rationale and the lessons learned while testing E-CHEMMEND will be valuable for chemistry instructors and education researchers. A desktop-based Windows executable version of the game is available at http://www.chemmend.uji.es/game

Executable files still remain popular to compromise the endpoint computers. These executable files are often obfuscated to avoid anti-virus programs. To examine all suspicious files from the Internet, dynamic analysis requires too much time. Therefore, a fast filtering method is required. With the recent development of natural language processing (NLP) techniques, printable strings became more effective to detect malware. The combination of the printable strings and NLP techniques can be used as a filtering method. In this paper, we apply NLP techniques to malware detection. This paper reveals that printable strings with NLP techniques are effective for detecting malware in a practical environment. Our dataset consists of more than 500,000 samples obtained from multiple sources. Our experimental results demonstrate that our method is effective to not only subspecies of the existing malware, but also new malware. Our method is effective against packed malware and anti-debugging techniques.

For the cancer clinical trials with immunotherapy and molecularly targeted therapy, time-to-event endpoint is often a desired endpoint. In this paper, we present an event-driven approach for Bayesian one-stage and two-stage single-arm phase II trial designs. Two versions of Bayesian one-stage designs were proposed with executable algorithms and meanwhile, we also develop theoretical relationships between the frequentist and Bayesian designs. These findings help investigators who want to design a trial using Bayesian approach have an explicit understanding of how the frequentist properties can be achieved. Moreover, the proposed Bayesian designs using the exact posterior distributions accommodate the single-arm phase II trials with small sample sizes. We also proposed an optimal two-stage approach, which can be regarded as an extension of Simon's two-stage design with the time-to-event endpoint. Comprehensive simulations were conducted to explore the frequentist properties of the proposed Bayesian designs and an R package BayesDesign can be assessed via R CRAN for convenient use of the proposed methods.

Systems Modeling Language (SysML) is an object management group standard for systems-of-systems engineering. It enables the description of complex system models; however, it cannot effectively support all system engineering activities. For instance, system performance evaluation is usually performed via simulation. In this case, the transformation of SysML system models to executable simulation models for specific simulation methodologies and tools is required. Model transformation is a key component for addressing the challenges of seamless integration of SysML model simulation in model-based system engineering. In this paper, we explore a declarative approach, based on the query/view/transformation-relations (QVT-R) standard, for the transformation of SysML models to executable simulation models, fully adhering model-driven architecture (MDA) concepts. It is supported by a framework implemented to provide executable simulation model and code generation. Methodological guidelines, for the effective use of a declarative language as QVT-R, for model transformation, are provided, emphasizing the utilization of existing domain-specific SysML profiles, as well as executable simulation library components. The experience obtained from two different domains, namely, enterprise information and railway transportation systems, modeled as systems-of-systems via SysML, is discussed, based on a quantitative analysis of the respective QVT-R transformations.

The emergence of Internet of Things malware, which leverages exploited IoT devices to perform large-scale cyber attacks (e.g., Mirai botnet), is considered as a major threat to the Internet ecosystem. To mitigate such threat, there is an utmost need for effective IoT malware classification and family attribution, which provide essential steps towards initiating attack mitigation/prevention countermeasures. In this paper, motivated by the lack of sophisticated malware obfuscation in the implementation of IoT malware, we utilize features extracted from strings- and image-based representations of the executable binaries to propose a novel multi-dimensional classification approach using Deep Learning (DL) architectures. To this end, we analyze more than 70,000 recently detected IoT malware samples. Our in-depth experiments with four prominent IoT malware families highlight the significant accuracy of the approach (99.78%), which outperforms conventional single-level classifiers. Additionally, we utilize our IoT-tailored approach for labeling newly detected “unknown” malware samples, which were mainly attributed to a few predominant families. Finally, this work contributes to the security of future networks (e.g., 5G) through the implementation of effective tools/techniques for timely IoT malware classification, and attack mitigation.