This article presents Makina, a library written in the Elixir programming language, and a domain specific language for writing property-based testing models for stateful programs. Models written in the domain specific language are translated into standard QuickCheck state machines. Our main goals with Makina are to facilitate the task of developing correct and maintainable models, and to encourage model reuse. To meet these goals, Makina provides a declarative syntax for defining model states and commands. In particular, Makina encourages the typing of specifications, and ensures that such type information can be used by Elixir type checking tools. Moreover, to promote model reuse, the domain specific language provides constructs that allow models to be defined in terms of collections of previously defined ones. To this end a number of operators for combining models have been defined and implemented in our library. A semantics for Makina models is presented in two steps. First, a novel operational semantics for standard QuickCheck state machine models is provided. Then, a translation from a Makina model to a standard QuickCheck state model is given.

ABSTRACT Cybersecurity is a critical global concern, particularly for small‐ and medium‐sized enterprises (SMEs) with limited resources and expertise. The authors are developing CyberESP, a tailored cybersecurity framework supported by a semi‐automated tool to ensure Spanish SMEs' cybersecurity management. Following the Design Science Research (DSR) methodology and grounded in international standards, the authors identified six requirements to be satisfied by a cybersecurity framework for SMEs, which should support the identification of assets, vulnerabilities, threats, and risks. This paper presents the first part of the CyberESP framework dealing with asset management, particularly their identification and analysis of dimensions and cost. A prototype supporting these activities was developed and validated through a case study in a retail SME, showing the solution's potential and identifying particular improvements. The paper also addresses threats to validity and limitations, noting the framework's focus on hardware, software, and networks. Future work includes vulnerability management and will explore the use of cloud and IoT deployment, positioning CyberESP as a practical solution to enhance SMEs' cybersecurity resilience.

This article provides a formal specification of the distribution and fault-tolerance mechanisms of eJason. The eJason programming language is an extension to the agent-oriented programming language Jason that introduces native support for the transparent distribution of agents as well as fault-tolerance mechanisms. This formal semantics is presented from a multiagent system perspective. It unambiguously describes both the possible evolution of the distributed multiagent system over time and the different instruments for fault detection and fault recovery, hence exposing their strengths. This specification may serve as a reference for researchers interested in the inclusion of similar mechanisms in agent-oriented programming languages. The formal semantics has been mechanized through an (open-source) implementation written in Prolog, which implements both the standard Jason operational semantics, along with the new rules for distribution and fault-tolerance introduced in this article.

Abstract We present a declarative framework for the compilation of constraint logic programs into variable-free relational theories which are then executed by rewriting. This translation provides an algebraic formulation of the abstract syntax of logic programs. Logic variables, unification, and renaming apart are completely elided in favor of manipulation of variable-free relation expressions. In this setting, term rewriting not only provides an operational semantics for logic programs, but also a simple framework for reasoning about program execution. We prove the translation sound, and the rewriting system complete with respect to traditional SLD semantics.

This article describes a systematic approach to testing behavioural aspects of Web Services that communicate using the JSON data format. As a key component, the Quviq QuickCheck property-based testing tool is used to automatically generate a large number of test cases from an abstract description of the service behaviour in the form of a finite state machine. The same behavioural description is also used to decide whether the execution of a test case is successful or not. To generate random JSON data for populating tests we have developed a new library, jsongen, which given a characterisation of the JSON data as a JSON schema, automatically derives a QuickCheck generator which is capable of generating an infinite number of JSON values that validate against the schema.

We present an undergraduate course on concurrent programming where formal models are used in different stages of the learning process. The main practical difference with other approaches lies in the fact that the ability to develop correct concurrent software relies on a systematic transformation of formal models of inter-process interaction (so called shared resources ), rather than on the specific constructs of some programming language. Using a resource-centric rather than a language-centric approach has some benefits for both teachers and students. Besides the obvious advantage of being independent of the programming language, the models help in the early validation of concurrent software design, provide students and teachers with a lingua franca that greatly simplifies communication at the classroom and during supervision, and help in the automatic generation of tests for the practical assignments. This method has been in use, with slight variations, for some 15 years, surviving changes in the programming language and course length. In this article, we describe the components and structure of the current incarnation of the course—which uses Java as target language—and some tools used to support our method. We provide a detailed description of the different outcomes that the model-driven approach delivers (validation of the initial design, automatic generation of tests, and mechanical generation of code) from a teaching perspective. A critical discussion on the perceived advantages and risks of our approach follows, including some proposals on how these risks can be minimized. We include a statistical analysis to show that our method has a positive impact in the student ability to understand concurrency and to generate correct code.

We formalize a translation of an asynchronous Pi-calculus into Flat GHC which does not disrupt too much the intuitive correspondence between them, specially in which regards names vs. logical variables. However, our approach depends on the introduction of some artifacts, namely channel managers. Contrasting other studies, here the communication between managers and other processes is asynchronous. Although this approach is justified by a relaxed notion of compositionality for process algebras, we still need some methodology that allows us to reason about programs in the presence of managers. We show how techniques from program transformation and a form of dynamic search strategy can cope with this. The encoding has been implemented in Haskell and executable programs are obtained from asynchronous Pi-calculus specifications by means of the KLIC compiler. Alternatively, we have developed in Prolog an interpreter for Flat GHC that has proven useful to analyze aspects of the translation.

Abstract To alleviate the inefficiencies caused by the interaction of the logic and functional sides, integrated languages may take advantage ofdemandinformation, i.e. knowing in advance which computations are needed and, to which extent, in a particular context. This work studiesdemand analysis– which is closely related tobackwards strictness analysis– in a semantic framework ofpartial predicates, which in turn are constructive realizations of ideals in a domain. This will allow us to give a concise, unified presentation of demand analysis, to relate it to other analyses based on abstract interpretation or strictness logics, some hints for the implementation, and, more important, to prove the soundness of our analysis based ondemand equations. There are also some innovative results. One of them is that a set constraint-based analysis has been derived in a stepwise manner using ideas taken from the area of program transformation. The other one is the possibility of using program transformation itself to perform the analysis, specially in those domains of properties where algorithms based on constraint solving are too weak.