Operational Semantics of a Focusing Debugger

Nowadays, when algorithms are combined with programming languages, great technological works are emerging. Examples of these works continue to differentiate and increase in military and police systems, agricultural applications, image processing applications, data engineering field, language processing works, and cyber security applications. With the differentiation of the areas of use of algorithms, the programming languages used on these platforms are also changing. Python is an object-oriented and functional modern programming language. It is ideal for beginners due to its readability and ease of use. C# is a simple, modern, object-oriented, and type-safe programming language that combines the high productivity of application development languages with the raw power of C and C++. The Java programming language, on the other hand, shares many features that are common to most programming languages used today. Since it is designed with the structures of C and C++, where their languages are similar, the language is familiar to C and C++ programmers (Lerdorf, 2002; Hejlsberg, 2003; Arnold, 2005; Deitel, 2004; Kelly, 2016; Gavrilović, 2018; Pala, 2019; Chollet, 2021; Chen, 2023).

With the latest revision of the ITU-T Specification and Description Language (SDL-2000), a formal language definition based on the concept of Abstract State Machines (ASMs) became integral part of the standard. Together with the formal definition, we have developed software tools that allow executing the formal language definition on a computer. In doing so, we found that tools greatly help to eliminate numerous errors from the formal definition, which likely would have not been found without tools.

The Organisation Management Infrastructure (OMI) is an important component to support and monitor the execution of large-scale open multi-agent organisations whose functioning is described using high-level abstract modelling languages. Their interpretation by the OMI leads to heavy-weight programs, hindering flexibility and evolution. In this paper, we introduce a normative organisation programming language, called NOPL, based on a simple and elegant normative programming language. We show the suitability of these languages for programming the OMI of the MOISE framework; in particular, we show how MOISE's Organisation Modelling Language can be translated into NOPL. We also briefly describe how this all has been implemented on top of ORA4MAS, the artifact-based OMI for MOISE.

In this thesis, we explore techniques for the development and verification of programs in a high-level, expressive, and safe programming language. Our programs can express problems over unbounded domains and over recursive and mutable data structures. We present an implementation language flexible enough to build interesting and useful systems. We mostly maintain a core shared language for the specifications and the implementation, with only a few extensions specific to expressing the specifications. Extensions of the core shared language include imperative features with state and side effects, which help when implementing efficient systems. Our language is a subset of the Scala programming language. Once verified, programs can be compiled and executed using the existing Scala tools. We present algorithms for verifying programs written in this language. We take a layer-based approach, where we reduce, at each step, the program to an equivalent program in a simpler language. We first purify functions by transforming away mutations into explicit return types in the functions' signatures. This step rewrites all mutations of data structures into cloning operations. We then translate local state into a purely functional code, hence eliminating all traces of imperative programming. The final language is a functional subset of Scala, on which we apply verification. We integrate our pipeline of translations into Leon, a verifier for Scala. We verify the core functional language by using an algorithm already developed inside Leon. The program is encoded into equivalent first-order logic formulas over a combination of theories and recursive functions. The formulas are eventually discharged to an external SMT solver. We extend this core language and the solving algorithm with support for both infinite-precision integers and bit-vectors. The algorithm takes into account the semantics gap between the two domains, and the programmer is ultimately responsible to use the proper type to represent the data. We build a reusable interface for SMT-LIB that enables us to swap solvers transparently in order to validate the formulas emitted by Leon. We experiment with writing solvers in Scala; they could offer both a better and safer integration with the rest of the system. We evaluate the cost of using a higher-order language to implement such solvers, traditionally written in C/C++. Finally, we experiment with the system by building fully working and verified applications. We rely on the intersection of many features including higher-order functions, mutable data structures, recursive functions, and nondeterministic environment dependencies, to build concise and verified applications.

Vision systems are now delivering real-time tracked and classified data from which behaviours can be inferred. Behavioural specifications of observable entities are viewed as attribute grammars with general constraints on the values of the attributes. The characteristics features of realistic input data to a behavioural recogniser are missing, inserted and noisy values. Behaviour recognition is defined in terms of a simple language which is used to express behaviour specifications. The meaning of a specification is given by a mapping to the set of observable value sequences which exhibit the specified behaviour. A computational mechanism for behaviour recognition, which is consistent with the meaning of behaviour specifications, is given using a simple functional programming language which has been enriched with non-deterministic features. The non-determinism is controlled using a simple belief mechanism.

Functional programming is a programming paradigm that is becoming increasingly popular among software developers. This is due in part to the rise of distributed systems and the need for more robust and scalable code. In the paper is presented an overview of the syntax and capabilities of Lambda expressions in three programming languages – C#, Java and Python. Performance of programming language constructions is an important research task. Some popular topics for investigation are comparison of programming languages efficiency in fields like bioinformatics or classification of Lambda expression usage and their productiveness. In the current study the performance of Lambda expressions is tested with three specific test cases and the results are compared to alternative technologies that could be used to solve similar problems. The results shows that speed performance of C# is the best from the compared languages and that List Comprehensions is the optimal method for collection filtering in Python.

Definition of programming languages consists of the formal definition of syntax and semantics. One of the most popular semantic methods used in various stages of software engineering is structural operational semantics. It describes program behavior in the form of state changes after execution of elementary steps of program. This feature makes structural operational semantics useful for implementation of programming languages and also for verification purposes. In our paper we present a new approach to structural operational semantics. We model behavior of programs in category of states, where objects are states, an abstraction of computer memory and morphisms model state changes, execution of a program in elementary steps. The advantage of using categorical model is its exact mathematical structure with many useful proved properties and its graphical illustration of program behavior as a path, i.e. a composition of morphisms. Our approach is able to accentuate dynamics of structural operational semantics. For simplicity, we assume that data are intuitively typed. Visualization and facility of our model is not only a new model of structural operational semantics of imperative programming languages but it can also serve for education purposes.

Various methods are used to describe communication protocols. The search for suitable description methods for communication protocols in the 1980s yielded a broad range of approaches out of which some fundamental methods have crystallized. These methods constitute the basis of the semantic models of the various formal description techniques. Therefore we first consider the most important description methods in this chapter before we turn to the formal description techniques. From these, finite state machines, Petri nets, process calculi, and temporal logics have crystallized as the most important and most common ones. Apart from these methods, other approaches were also investigated, such as the use of grammars, data flow languages, and functional languages. They did not receive wider attention because they were not applied to real-life protocols. The use of high-level programming languages was considered likewise. Programming languages support the algorithmic description of protocol procedures as well as the generation of prototypes, but they usually do not possess a formally defined semantics. In addition, programming languages are primarily implementation languages and not specification languages. They often yield descriptions which are close to an implementation. For that reason, high-level programming languages are not used for protocol description. Many formal description techniques, however, use programming language features.

Modular language implementation in Rascal – experience report

In this paper we discuss the semantics of a simple block-structured programming language which allows sharing or aliasing. Sharing, which arises naturally in procedural languages which permit certain forms of parameter passing, has typically been regarded as problematical for the semantic treatment of a language. Difficulties have been encountered in both denotational and axiomatic treatments of sharing in the literature. Nevertheless, we find that it is possible to define a clean and elegant formal semantics for sharing. The key to our success is the choice of semantic model; we show that conventional approaches based on locations are less than satisfactory for the purposes of reasoning about partial correctness, and that in a well defined sense locations are unnecessary.We begin by defining a denotational semantics for our programming language. The semantic model is not based on locations, but instead uses an abstract sharing relation on identifiers to represent the notion of aliasing, and uses an abstract state with a stack-like structure to capture the semantics of blocks and accurately model the scope rules. The semantics is shown to be fully abstract with respect to partial correctness properties, in contrast to conventional location-based models. This means that the semantics identifies terms if and only if they induce identical partial correctness behaviour in all program contexts. This property usually fails for location-based semantics because in such models it is possible to distinguish between terms on the basis of their effect on individual locations, which has no bearing on partial correctness.We believe that axiomatic reasoning about program behaviour should be based directly on a semantic model specifically tailored for that purpose; full abstraction with respect to an appropriate behavioural notion is a formal criterion against which to judge the suitability of a semantics. The structure of a semantic model should be used directly to suggest the structure of an assertion language for expressing program properties. With this in mind, we build a Hoare-style (syntax-directed) proof system for partial correctness properties of our programming language, and we prove soundness and relative completeness of this system. The proof system is built up in a hierarchical manner which reflects the syntactic and semantic structure of the programming language. We first design a proof system for declarations, and then use it in building proof rules for commands. We claim that our proof rules are conceptually simpler to understand than other rules proposed in the literature for aliasing, without losing any expressive power. We show, for example, that it is possible to define a “generic” inference rule for blocks which is uniformly applicable to3 blocks headed by different forms of declaration. The important point here is that, unlike most of the proof systems for these constructs in the literature, we do not have to design a separate rule for blocks for each possible form of declaration. This results in greater flexibility and adaptability in our proof system. We demonstrate that some well known rules from the literature for blocks can be derived in our system.

GPUs and other accelerators are popular devices for accelerating compute-intensive, parallelizable applications. However, programming these devices is a difficult task. Writing efficient device code is challenging, and is typically done in a low-level programming language. High-level languages are rarely supported, or do not integrate with the rest of the high-level language ecosystem. To overcome this, we propose compiler infrastructure to efficiently add support for new hardware or environments to an existing programming language. We evaluate our approach by adding support for NVIDIA GPUs to the Julia programming language. By integrating with the existing compiler, we significantly lower the cost to implement and maintain the new compiler, and facilitate reuse of existing application code. Moreover, use of the high-level Julia programming language enables new and dynamic approaches for GPU programming. This greatly improves programmer productivity, while maintaining application performance similar to that of the official NVIDIA CUDA toolkit.

A new programming language control structure as well as an improved approach to a formal definition of programming languages are presented. The control structure can replace both iteration and conditional structures. Because it is a semantic generalization of those structures, a single statement using the new control structure can implement the functions of loops, conditionals, and also programs that would require several conventional constructs. As a consequence of this increased capability, it is possible to write algorithms that are simpler, more efficient, and more clearly correct than those that can be written with earlier structured-programming control structures. In order to provide a precise definition of the new constructs, a new version of relational semantics, called LD - relations is presented. An algebra of these relations is developed and used to define the meaning of the new constructs. A short discussion of program development and the history of control structures is included.

We propose a simplified high-level programming language based on blocks and links dragged on a workspace which generates the skeleton code for robotic applications involving different types of robots. In order to develop such a high-level programming language that still can guarantee flexibility in term of implementation, our approach takes advantage of the robot operating system (ROS). ROS is a open source meta-operating system that provides a message passing structure between different processes (or nodes) across a network (inter-process communication). In our framework, we consider a hierarchical approach in which at the base there is ROS that allows inter-process communication between nodes in a robot and on the top we create a high-level language that interacts with ROS and thus with the real robot. The high-level language can be viewed as an extra layer added to simplify lower level code generation.

The aim of this paper is to show that some computational models inspired from biological membranes, such as P systems, can be simulated on digital computers in an efficient manner. To this aim, it is necessary to characterize non-determinism and parallel execution of evolution rules inside regions. Both these issues are formally described here in order to obtain a feasible description in terms of data structures and operations able to be implemented in a functional programming language. Static and dynamic structures of transition P systems are formalised in order to define a bio-language to represent them. Finally, a draft of a language for describing a transition P systems is presented. It will facilitate the description of transition P systems in terms of sentences in a high level programming language; such sentences will define a program. A process of compilation will parse the program to appropriate data structures and will launch the execution of the simulation process.

2 - Completion and Its Applications