Science of Computer Programming最新文献

This paper shows an exploratory study of the syntactic and semantic similarities and discrepancies of the terms of four selected project management glossaries. The main purpose of this study is to provide recommendations on adoptions and adaptations of labels and/or definitions of project management glossary terms to be included in a new or existing project management ontology. As a result, a list of recommended terms for a project management ontology to be built is analyzed. The recommendation of terms will be limited to generic terms that can be located at the core level instead of the domain level in the context of an ontological architecture. In particular, the list of terms will be discussed in light of a previously developed project management ontology that will be updated in future work. Another goal of this work is to evaluate the level of syntactic and semantic consistency and harmonization that currently exists in these glossaries. As a result, it becomes apparent from this early research that many opportunities exist to improve these terminologies for greater consistency, harmonization, and standardization in the field.

IDEs are in full mutation thanks to more and more intelligent code completion and validation functionalities. These intelligent features also facilitate the creation of new ways of programming such as low-code or no-code. In the meantime, modeling environments still suffer, for the most part, from their outdated interfaces, their too basic features, or their lack of usability. Our research work on the topic of modeling assistance has led to the creation of a first building block to initiate a revolution similar to development environments in the landscape of modeling. In this paper, we present the Modeling Assistant Recommender, a score-based multi-criteria recommendation system for class diagrams.

In [1] we proposed to verify LTL properties using a fine grain analysis classifying formulae into four classes (stutter, shortening, lengthening insensitive or none of these). With this classification we extend the applicability of structural reduction to two new classes of formulas, when classical techniques are only applicable for stutter insensitive formulas. This comes at the price of a semi-decision procedure where only some verdicts are reliable.

In this paper, we present an implementation of this approach, built as an extension to the ITS-Tools model-checker that relies on the Spot library to analyze automata. This new approach significantly improves the ITS-tools model-checker when verifying properties that are not stutter insensitive. It can also be used as a front-end simplification step for any other model-checker.

Security-critical applications often rely on memory isolation mechanisms to ensure integrity of critical data (e.g., keys) and program instructions (e.g., implementing an attestation protocol). These include software-based security microvisor S μV or hardware-based (e.g., TrustLite or SMART) techniques. Here, we must guarantee that during an execution of a program, none of the assembly-level instructions corresponding to the program violate the imposed memory access restrictions. We focus on two security architectures (S μV and TrustLite). We use Binary Analysis Platform (BAP) to generate assembly-level code in an intermediate language (BIL) for a compiled C program. This is then translated to Isabelle/HOL theories. We develop an operational semantics by defining a collection of transition rules for a subset of BIL (called AIRv2) that is sufficient for our work. We develop an adversary model and define conformance predicates for each assembly-level instruction. A conformance predicate holds iff the associated memory access restriction imposed by the underlying security architecture is satisfied. We generate a set of programs covering all possible cases in which an assembly-level instruction attempts to violate at least one of the conformance predicates. For S μV, we capture all such violations not only by checking specific lines of the program but also by applying the operational semantics for every machine-state transition. This shows that the memory access restrictions of S μV is operationally maintained. For TrustLite, we capture all such violations by checking specific lines of the program. Also, we provide an example to show how we can use the operational semantics to capture such violations.

Context

Software Product Lines (SPLs) constitute a popular method for encouraging the methodical reuse of software artefacts. Just like any other piece of software, SPLs require management throughout their evolution, namely to preserve the consistency between requirements and the code.

Problem

Over time, for a given SPL, many change requests are made and all of them need to be integrated in a consistent and coordinated way. The evolution of an SPL is facilitated if there exist links between its artefacts, namely between each feature and its respective pieces of implementation code.

Method

This paper proposes FMap, a systematic feature mapping approach to be used within SPLs. FMap traces a Feature Model (FM) to other artefacts of an SPL, the reference architecture, and the code, and it establishes connections between each feature of the FM and its locations in the code-base. Additionally, we have created a tool called friendlyMapper to provide some automatic support for the approach. Using two case studies from two different companies, FMap and friendlyMapper are evaluated.

Results

The evaluation of the case studies indicates that the FMap approach outperforms the baseline approach (i.e., the branching approach).

Contribution

This work contributes with FMap, a novel tool-based approach that supports feature-architecture-code mappings based on reference architecture. FMap assists software engineers in adapting the evolution of the SPLs to accommodate new features and change requests as the SPLs evolve. The case studies for both companies demonstrate that the approach is applicable to real-world products and is able to support feature traceability and maintain consistency among features, architecture, and code.

Algebraic effects & handlers are a modular approach for modeling side-effects in functional programming. Their syntax is defined in terms of a signature of effectful operations, encoded as a functor, that are plugged into the free monad; their denotational semantics is defined by fold-style handlers that only interpret their part of the syntax and forward the rest. However, not all effects are algebraic: some need to access an internal computation. For example, scoped effects distinguish between a computation in scope and out of scope; parallel effects parallelize over a computation, latent effects defer a computation. Separate definitions have been proposed for these higher-order effects and their corresponding handlers, often leading to expedient and complex monad definitions. In this work we propose a generic framework for higher-order effects, generalizing algebraic effects & handlers: a generic free monad with higher-order effect signatures and a corresponding interpreter. Specializing this higher-order syntax leads to various definitions of previously defined (scoped, parallel, latent) and novel (writer, bracketing) effects. Furthermore, we formally show our framework theoretically correct, also putting different effect instances on formal footing; a significant contribution for parallel, latent, writer and bracketing effects.

With the increasing use of intelligent systems in various domains such as self-driving cars, robotics, and smart cities, it is crucial to ensure the quality of intelligent systems for their reliable and effective use in various domains. However, testing intelligent systems poses unique challenges due to their complex structure, low efficiency, and the high cost associated with manually collecting a large number of test cases. Hence, it is crucial to design tools that can adequately test intelligent systems while overcoming these obstacles.

We propose an intelligent system test tool called ISTA+. This tool implements automatic generation and optimization of test cases based on coverage analysis, resulting in improved test adequacy for intelligent systems. To evaluate the effectiveness of ISTA+, we applied it to two different models (fully-connected DNN and the Rambo model) and two datasets of different data types (i.e., image and text). The evaluation results demonstrate that ISTA+ successfully improves the test dataset quality and ensures comprehensive testing for both text and image data types.

• •

  Link to source code: https://github.com/wuxiaoxue/ISTAplus

• •

  Link to video demonstration: https://youtu.be/6CkzMJ0ghq8

Social coding platforms such as GitHub or GitLab have become the de facto standard for developing Open-Source Software (OSS) projects. With the emergence of Machine Learning (ML), platforms specifically designed for hosting and developing ML-based projects have appeared, being Hugging Face Hub (HFH) one of the most popular ones. HFH aims at sharing datasets, pre-trained ML models and the applications built with them. With over 400 K repositories, and growing fast, HFH is becoming a promising source of empirical data on all aspects of ML project development. However, apart from the API provided by the platform, there are no easy-to-use solutions to collect the data, nor prepackaged datasets to explore the different facets of HFH. We present HFCommunity, an extraction process for HFH data and a relational database to facilitate an empirical analysis on the growing number of ML projects.