On some innovations in teaching the formal semantics using software tools

2.1 Language, syntax and semantics

Derivation of behavior of a command written in a computer language can be made with help of the exact definition of the language. Formal definition of a language consists of its syntax and semantics. The syntax of a language is considered as the set of rules that defines the combinations of symbols that are considered to be a correctly structured document or fragment in that language [18]. Syntax determines which character strings constitute well-formed programs. The programming language syntax determines the design and structure of programs written in some language [19, 20, 21]. Generally, the syntax is defined by

1. a grammar – a set of rules that specify how input is structured;

2. extended Backus-Naur form (BNF);

3. an inductive definition.

Because syntax defines only the language structure, i.e. how it is allowed to classify individual constructions, it is necessary to use the second part of the language definition which is the specification of semantics. The semantics of a language describes the meaning (behavior) of a program in terms of the basic concepts of a language [22]. The only possibility of unambiguous writing of semantics is writing it using formal semantic methods.

The definition of formal semantics includes:

1. semantic domains,

2. specifications of semantic functions,

3. semantic equations or deduction rules.

The semantic domain is a (mathematical) structure that contains the mathematical elements of a particular form representing meanings of elements from a given syntactic domain [21]. The sets serving as domains have a lattice-like structure [23]. For simplicity, we view these semantic domains as normal mathematical sets: basic sets (Z - sets of integers, N - natural numbers, B - Boolean values) and sets that arise by applying operations to these sets are very practical in the teaching process. The semantic function maps syntactic entities to the elements of semantic domain. Schematically, its specification is given as follows [21]:

Semantic function is mostly given by:

1. semantic equations (mainly for expressions), and

2. production rules (for statements, see Section 2.3).

We determine in the production rules the meaning of each element (syntactic pattern/element) for a given syntactic domain [21]. For each syntactic domain, a unique semantic function is defined.

2.2 Formal definition of Jane programming language

In the previous section, we explained how a syntax and semantics of programming language are usually defined. In this section, we define the language that is used in teaching the course on the Semantics of Programming Languages. We present an abstract (non-real) programming language with language patterns belonging to an imperative paradigm. In the course on Semantics, we are focused on teaching the formal semantics of imperative languages. Therefore, abstract language with imperative patterns serves as a background. Its syntax is adopted from the well-known toy language While [16] and we refer to this language as Jane.

Now, we list the various syntactic categories (domains) and give a meta-variable that will be used to range over constructs of each category. For our language Jane, the meta-variables and categories are in the Table 1.

The domains for numerals (Num) and variables (Var) have no internal structure from the semantic point of view. For the three remaining domains, particular production rules describing the syntax are defined.

For the arithmetic expressions, we formulate the following production rule:

where

1. n denotes an integer numeral;

2. x stands for a program variable;

3. e • e represents an arithmetic operation that can be applied to arithmetic expressions (here in standard notation: addition (+), subtraction (−), multiplication (*));

4. (e) represents an arithmetic expression enclosed into parenthesis.

The Boolean expressions of the language Jane are given by the following production rule. In the case of language Jane, their rôle is to provide a logical condition in a conditional or a loop statement.

where

1. false, true represent syntactic forms of Boolean constants;

2. e = e represents an equality of arithmetic expressions;

3. e ≤ e represents a relation “less then or equal” of arithmetic expressions;

4. ¬b stands for a negation of a Boolean expression;

5. b ∧ b is a conjunction of Boolean expressions;

6. (b) represents a Boolean expression enclosed into parenthesis.

The language Jane contains five (standard) imperative constructs [21]:

1. a variable assignment statement;

2. an empty statement, used when there are no operations to perform in a context where a statement is required;

3. a pattern of sequencing the statements – a statement list that consists of one or more statements written in sequence;

4. a conditional statement with two mandatory ways of control-flow; and

5. a loop statement that conditionally executes an embedded statement zero or more times.

Of course, for teaching purposes, the language Jane can be extended on syntactic level with new constructs and elements, like various types of loops, variables’ declarations, or procedures, as well. In this approach, we work with standard D-constructs, without any extension.

The syntax of statements is given by the following production rule:

These five commands are considered as standard (basic) constructs of the imperative programming languages. They are also referred to as Dijkstra commands (or D-diagrams) [21]. Based on this abstract syntax, we can define standard imperative constructs in real imperative languages.

2.3 Natural semantics of imperative languages

We briefly express the basic properties of natural semantics of imperative languages: we list standard rules of this method and we show how this method is applied for the language Jane. We note that natural semantics [24] is considered as a hybrid of operational and denotational semantics that shows computation steps performed in a compositional manner. It is also referred as a “big-step semantics”. This method has been proposed that is halfway between operational semantics and denotational semantics [25, 26]. Like structural operational semantics, natural semantics shows the context in which a computation step occurs, and like denotational semantics, natural semantics emphasizes that the computation of a phrase is built from the computations of its sub-phrases.

So, the main rôle of natural semantics is to define the relationship between the initial state before executing the language statement and the final state after executing this statement. The meaning of the statement (its semantics) is therefore considered as a change of memory state. Natural semantics does not follow the detailed execution of the statement; it is focused on changing the state that occurs by executing the entire statement, as it expresses the transition relation in natural semantics [21, 25]:

The general form of the production rule of natural semantics looks as follows [21]:

where

1. S stands for a statement, possibly consisting of one or more statements written in sequence S₁, . . . , S_n;

2. s₀ is an initial state;

3. s is a final state;

4. s₁, . . . , s_n−1 are states during the particular steps;

5. in the notation (rule_ns) of a rule, rule represents name (or numeric notation) of the rule and an index “ns” indicates that it is a rule of natural semantics.

Notation of a general production rule (rule_ns) expresses the natural semantics of the statement S as a one-step change from the initial memory state s₀ to the final state s [21]. Now, we briefly introduce the rules of natural semantics for the statements of the language Jane listed in (3).

The assignment statement is defined by the axiom

The rule (1_ns) above notation represents the meaning of the assignment command: the variable x is assigned to the value of an arithmetic expression e (implicitly typed as integer) calculated in the state s and a memory state is being actualized from s to s^′.

An empty statement is defined by the axiom:

Here, the state is not being changed after the execution of a statement.

The list of statements is defined by the following rule:

This rule expresses that statements are executed in particular steps with step-wise computing and passing the actual memory state.

The conditional statement is defined by the following two rules:

For the conditional statements, two rules based on the value of a Boolean conditions are defined. They are symmetric and their use is straightforward.

The loop statement is defined by the following two rules:

A while loop allows code to be executed repeatedly based on a given Boolean condition zero or more times.

Generally, a program in Jane is considered as a sequence of statements, i.e. one compound statement. For simplicity, we can denote the whole program by one statement (meta-)variable, e.g. P. Deriving the semantics of a program P we start in an initial state, e.g. s₀ and we construct a transition relation to a final state s. Such defined relation is a root of a derivation tree in natural semantics of a program P:

Then

1. the transition of the program will form the root of the tree;

2. by applying the rules of natural semantics, we create inner vertices;

3. the leaves will form the axioms of natural semantics.

4.1 Implementation of the visualization

The visualization has been implemented as a unit that takes an output provided by a compiler of a Jane code. We follow the basic idea that a compiler is a program that reads a program written in a source language and translates it in to an equivalent form in another language, called target language or target representation [29, 30]. In our case, a source program is written in a language Jane. As a target form, visual representation of program is provided: a semantic-driven simulation of program execution by step-wise application of concrete semantic rules.

The compiler is designed with its standard phases:

1. the lexical analysis, which reads the input string from the code and produce tokens;

2. syntax analysis – it analyzes the syntactical structure of the given input; and

3. semantic analysis, which judges whether the syntax structure constructed in the source program derives any meaning or not.

A grammar that represents the language Jane is the following:

• commands → sub_commands ; {sub_commands ;

• sub_commands → assign | statement | cycle

• sub_commands → EPSILON

• assign → VARIABLE ASSIGNMENT expr

• assign → EPSILON

• statement → IF (expr) then commands

•     {else commands}

• statement → EPSILON

• cycle → WHILE (expr) do commands

• cycle → EPSILON

• expr → sig_operator log

• log → PM operator log

• log → EPSILON

• sig_operator → PM operator

• sig_operator → operator

• operator → sig_term sum

• sum → PM term sum

• sum → EPSILON

• sig_term → PM term

• sig_term → term

• term → factor product

• product → MD sig_factor product

• product → EPSILON

• sig_factor → PM factor

• sig_factor → factor

• factor → value

• factor → NEG factor

• factor → O_BR expr C_BR

• value → NUM

• value → VAR

The compiler provides as its output the binary version of an input source – a byte-code. This form is used only internally, i.e. the compiler translates the source into the sequence of elements that are ready to provide a visual form – a tree in natural semantics. Visualizing mode is run after the compilation is successfully finished: it depicts the derivation tree of an input program in natural semantics by reading the provided compiled byte-code and interpreting it step-by-step. Before starting the visualization, the user is asked to put the values of input variables. After this step, the semantic implementation is ready to be visualized (depicted). Visualizing mode practically simulates particular steps of an input program with real (concrete) input values. When an input program was correct (at least without the logical errors), the program shows at the end of simulation a complete derivation tree in natural semantics with all memory states (the new variable values) that have occurred during the program simulation.

The program allows to input of the source code manually or by loading it from a file. For the Jane source codes, standard syntax according to the rules (1), (2) and (3) is used. The program recognizes the key words and supports the syntax-highlighting. We note, that for easier manipulation with the source and better readability:

1. we enriched the blocks in a loop statement and a conditional statement with the keywords (textual “brackets”) begin and end; and

2. we allowed the use of C-like syntax for Boolean expressions (in contrast to rule (2)): ‘==’ for equality of expressions, ‘<=’ for less-or-equal symbol, ‘!’ for negation and ‘&&’ for logical conjunction.

The final step in implementation is to design a graphical interface. The interface was implemented using external JavaFX^[1] which is a part of the Oracle JDK 9 implementation of Java, and JLaTeXMath libraries^[2]. Using the first one, components were created to interact with the user, and the second allowed to render a graphical representation of the specified source code on the tree of natural semantics.

The resulting GUI look can be seen in Figure 1.

Figure 1

Graphical User Interface of visualizing tool

At the end of a simulation, the provided visual output can be stored into separate file as a picture (in one of PNG or JPG formats) for its future use. Moreover, the depicted derivation tree is displayed using the style. The user can export and store the source code of the displayed derivation tree into separate TEX file.

4.2 Graphic user interface of a program

In this section, we briefly present how this software can be used. When launched, the main application window appears, which contains the components to interact with. At the top of the window, we can see the menu bar where the user can work with all the features that the application offers. Right below this panel, there is a text area into which input code can be put. Below this text area is a set of buttons that perform the following tasks:

1. Generate button – it calls the main program method and generates an application output.

2. Save Input button – it is used to store an input to a user-selected location in the computer memory.

3. Set Variables button – it allows user to set variables before the output is generated.

4. Clear Input button – it serves for clearing the text area.

After entering the input string in the form of a Jane code and possibly setting the variables and pressing the Generate button, a new component appears at the bottom of the screen. This component contains a canvas to render the resulting natural semantic tree and a set of buttons. The set consists of the following buttons:

1. Show States button – it displays a pop-up window in which the table shows the states that the program has passed during execution.

2. Save as TeX button – it saves the latex-code output string to a text file on a user-selected location in the computer memory.

3. Save as Figure button – similar to the previous button, it saves the result to the computer’s memory but in the image format of the user’s choice. Supported formats are JPG or PNG.

4. Clear button – it removes the entire component that was created after pressing the Generate button.

Accessing these functions is also possible from the upper menu bar.

4.3 Example of using the application

As an example of using this program, we show how our software tool produces a visual output for the Euclidean algorithm finding the greatest common divisor of two given numbers.

In the text area, we insert the program realizing the Euclidean algorithm in the form of Jane code. We write the program into the text area, then we set the initial values for variables x and y to 96 and 64, resp.

The following is an example of a program given as an input:

• while !(x == y) do begin

• if (x <= y) then begin y := y − x end

•   else begin x := x − y end

• end

The result can be seen in Figure 3. Moreover, we can see the states that occurred during the program functioning in the table. When the user recalls the states (using the Show States button), the table appears with all the states (Figure 4).

Figure 2

Application after output generation

Figure 3

Example of using the tools with implementation of Euclidean algorithm

Figure 4

Memory states during the computation of Euclidean algorithm