The grammar and spelling rules of a programming language constitute its

Publisher Summary

Programming languages were created to describe the computations performed by computers. Each language defines its own format (syntax) declaring how code should be structured, and the meaning (semantics) of the language elements. The compiler's responsibility is to generate machine instructions based on the “contract” declared between the source code represented using the language definition. This chapter discusses what happens if one changes the language definition. The chapter established a technique that is used to customize the runtimes, namely .NET, Java, and Dalvik. It begins by demonstrating the steps of modifying the implementation of .NET's WriteLine method so that each application calling this method will be influenced by the modified logic. Further, the steps for modifying Java, by using a similar example with the println method, are demonstrated. Finally, the chapter discusses the steps of modifying Dalvik, this time demonstrating how to eliminate the behavior of a specific method. The significance of these kinds of simple PoCs is that the runtimes can be changed using a variety of techniques.

Programming languages

Programming languages evolve as well, with new languages appearing periodically, able to take advantages of the new hardware and operating systems. Object-oriented languages (e.g. C++, Smalltalk, Sun’s Java, Microsoft’s C#) almost completely replaced the traditional procedural code that was the standard ten years ago (i.e. Fortran and C). Developers of CAPE applications increasingly use sophisticated development tools such as Microsoft’s Visual Studio or Sun’s J2EE toolkit. Source code is often generated from higher-level or abstract models and descriptions, and component libraries supplied with Application Programming Interfaces (APIs) are used for several simple and not-so-simple tasks (handling of lists and arrays, database handling, numerical processing, graphical user interface widgets, etc.). We cannot leave this list without adding the many languages used for the Internet, from the simple HTML static descriptions to the CGI scripts for database access, and to the Javascript and Active Server Pages dynamic systems, some of the most popular technologies in this field.

3.3.1.3 Programming language-level virtualization

Programming language-level virtualization is mostly used to achieve ease of deployment of applications, managed execution, and portability across different platforms and operating systems. It consists of a virtual machine executing the byte code of a program, which is the result of the compilation process. Compilers implemented and used this technology to produce a binary format representing the machine code for an abstract architecture. The characteristics of this architecture vary from implementation to implementation. Generally these virtual machines constitute a simplification of the underlying hardware instruction set and provide some high-level instructions that map some of the features of the languages compiled for them. At runtime, the byte code can be either interpreted or compiled on the fly—or jitted5—against the underlying hardware instruction set.

Programming language-level virtualization has a long trail in computer science history and originally was used in 1966 for the implementation of Basic Combined Programming Language (BCPL), a language for writing compilers and one of the ancestors of the C programming language. Other important examples of the use of this technology have been the UCSD Pascal and Smalltalk. Virtual machine programming languages become popular again with Sun’s introduction of the Java platform in 1996. Originally created as a platform for developing Internet applications, Java became one of the technologies of choice for enterprise applications, and a large community of developers formed around it. The Java virtual machine was originally designed for the execution of programs written in the Java language, but other languages such as Python, Pascal, Groovy, and Ruby were made available. The ability to support multiple programming languages has been one of the key elements of the Common Language Infrastructure (CLI), which is the specification behind .NET Framework. Currently, the Java platform and .NET Framework represent the most popular technologies for enterprise application development.

Both Java and the CLI are stack-based virtual machines: The reference model of the abstract architecture is based on an execution stack that is used to perform operations. The byte code generated by compilers for these architectures contains a set of instructions that load operands on the stack, perform some operations with them, and put the result on the stack. Additionally, specific instructions for invoking methods and managing objects and classes are included. Stack-based virtual machines possess the property of being easily interpreted and executed simply by lexical analysis and hence are easily portable over different architectures. An alternative solution is offered by register-based virtual machines, in which the reference model is based on registers. This kind of virtual machine is closer to the underlying architecture we use today. An example of a register-based virtual machine is Parrot, a programming-level virtual machine that was originally designed to support the execution of PERL and then generalized to host the execution of dynamic languages.

The main advantage of programming-level virtual machines, also called process virtual machines, is the ability to provide a uniform execution environment across different platforms. Programs compiled into byte code can be executed on any operating system and platform for which a virtual machine able to execute that code has been provided. From a development life-cycle point of view, this simplifies the development and deployment efforts since it is not necessary to provide different versions of the same code. The implementation of the virtual machine for different platforms is still a costly task, but it is done once and not for any application. Moreover, process virtual machines allow for more control over the execution of programs since they do not provide direct access to the memory. Security is another advantage of managed programming languages; by filtering the I/O operations, the process virtual machine can easily support sandboxing of applications. As an example, both Java and .NET provide an infrastructure for pluggable security policies and code access security frameworks. All these advantages come with a price: performance. Virtual machine programming languages generally expose an inferior performance compared to languages compiled against the real architecture. This performance difference is getting smaller, and the high compute power available on average processors makes it even less important.

Implementations of this model are also called high-level virtual machines, since high-level programming languages are compiled to a conceptual ISA, which is further interpreted or dynamically translated against the specific instruction of the hosting platform.

1.2.6.2 Agent-Oriented Programming Languages

An agent programming language, sometimes also called agent-oriented programming language (AOP), permits developing and programming intentional agents—in other words, the developed agents usually operate on a semantically higher level than those developed with the help of development toolkits. An AOP usually provides the basic building blocks to design and implement intentional agents by means of a set of programming constructs. These programming constructs facilitate the manipulation of the agents’ beliefs and goals and the structuring of their decision making. The language usually provides an intuitive programming framework based on symbolic or practical reasoning. Shoham (1993) suggests that an AOP system needs the following three elements in order to be complete:

A formal language with clear syntax for describing the mental state. This includes constructs for declaring beliefs and their structure (e.g., based on predicate calculus) and passing messages.

A programming language that permits defining agents. The semantics of this language should be closely related to those of the formal language.

A method for converting neutral applications into agents in order to allow an agent to communicate with a non-agent by attributing intentions.

The most important AOPs are logic-based. They had their high in research some time ago, which is why many of them are not maintained any longer. Table 1.4 lists some relevant AOPs.

Table 1.4. Agent-Oriented Programming Language

NameReference3APLDastani et al. (2005)AgentSpeak(L)/JasonKinny et al. (1996), Rao (1996), Bordini et al. (2007)ASPECSCossentino et al. (2007)GOALHindriks et al. (2012) GOAL (2011)GologLevesque et al. (1997)MetateMDennis et al. (2008)PLACAThomas (1995)

8.2.3 Communicating with a computer: Programming languages

Programming languages provide the link between human thought processes and the binary words of machine language that control computer actions, in other words, instructions written by a programmer that the computer can execute. A computer chip understands machine language only, that is, the language of 0’s and 1’s. Programming in machine language is incredibly slow and easily leads to errors. Assembly languages were developed that express elementary computer operations as mnemonics instead of numeric instructions. For example, to add two numbers, the instruction in assembly language is ADD. Even though programming in assembly language is time consuming, assembly language programs can be very efficient and should be used especially in applications where speed, access to all functions on board, and size of executable code are important. A program called an assembler is used to convert the application program written in assembly language to machine language. Although assembly language is much easier to use since the mnemonics make it immediately clear what is meant by a certain instruction, it must be pointed out that assembly language is coupled to the specific microprocessor. This is not the case for higher-level languages. Higher languages such as C/C ++, JAVA, and scripting languages like Python, were developed to reduce programming time, which usually is the largest block of time consumed in developing new software. Even though such programs are not as efficient as programs written in assembly language, the savings in product development time when using a language such as C has reduced the use of assembly language programming to special situations where speed and access to all a computer's features is important. A compiler is used to convert a C program into the machine language of a particular type of microprocessor. A high-level language such as C is frequently used even in software for 8-bit controllers, and C ++ and JAVA are often used in used in the design of software for 16-, 32-, and 64-bit microcontrollers.

Fig. 8.1 illustrates the translation of human thought to machine language by use of programming languages.

Single statements in a higher-level language, which is close to human thought expressions, can produce hundreds of machine instructions, whereas a single statement in the lower-level assembly language, whose symbolic code more closely resembles machine code, generally produces only one instruction.

Fig. 8.2 shows how a 16-bit processor would execute a simple 16-bit program to add the numbers in memory locations X, Y, and Z and store the sum in memory location D. The first column shows the binary instructions in machine language. Symbolic instructions in assembly language, which have a nearly one-to-one correspondence with the machine language instructions, are shown in the next column. They are quite mnemonic and should be read as “Load the number at location X into the accumulator register; add the number at location Y to the number in the accumulator register; add the number at location Z to the number in the accumulator register; store the number in the accumulator register at location D.” The accumulator register in a microcontroller is a special register where most of the arithmetic operations are performed. This series of assembly language statements, therefore, accomplishes the desired result. This sequence of assembly statements would be input to the assembler program that would translate them into the corresponding machine language (first column) needed by the computer. After assembly, the machine language program would be loaded into the machine and the program executed. Because programming in assembly language involves many more details and low-level details relating to the structure of the microcomputer, higher-level languages have been developed. FORTRAN (FOR-mula TRANslator) was one of the earlier and most widely used programming languages and employs algebraic symbols and formulas as program statements. Thus the familiar algebraic expression for adding numbers becomes a FORTRAN instruction; for example, the last column in Fig. 8.2 is the FORTRAN statement for adding the three numbers and is compiled into the set of corresponding machine language instructions of the first column.

Checking Syntax

To check the syntax of the input program, the compiler must compare the program's structure against a definition for the language. This requires an appropriate formal definition, an efficient mechanism for testing whether or not the input meets that definition, and a plan for how to proceed on an illegal input.

Mathematically, the source language is a set, usually infinite, of strings defined by some finite set of rules, called a grammar. Two separate passes in the front end, called the scanner and the parser, determine whether or not the input code is, in fact, a member of the set of valid programs defined by the grammar.

Programming language grammars usually refer to words based on their parts of speech, sometimes called syntactic categories. Basing the grammar rules on parts of speech lets a single rule describe many sentences. For example, in English, many sentences have the form

Sentence → Subject verb Object endmark

where verb and endmark are parts of speech, and Sentence, Subject, and Object are syntactic variables. Sentence represents any string with the form described by this rule. The symbol “→” reads “derives” and means that an instance of the right-hand side can be abstracted to the syntactic variable on the left-hand side.

Consider a sentence like “Compilers are engineered objects.” The first step in understanding the syntax of this sentence is to identify distinct words in the input program and to classify each word with a part of speech. In a compiler, this task falls to a pass called the scanner. The scanner takes a stream of characters and converts it to a stream of classified words—that is, pairs of the form (p,s), where p is the word's part of speech and s is its spelling. A scanner would convert the example sentence into the following stream of classified words:

(noun,“Compilers”), (verb,“are”), (adjective,“engineered”),(noun,“objects”), (endmark,“.”)

Scanner

the compiler pass that converts a string of characters into a stream of words

In practice, the actual spelling of the words might be stored in a hash table and represented in the pairs with an integer index to simplify equality tests. Chapter 2 explores the theory and practice of scanner construction.

In the next step, the compiler tries to match the stream of categorized words against the rules that specify syntax for the input language. For example, a working knowledge of English might include the following grammatical rules:

By inspection, we can discover the following derivation for our example sentence:

RulePrototype Sentence—Sentence1Subject verb Object endmark2noun verb Object endmark5noun verb Modifier noun endmark6noun verb adjective noun endmark

The derivation starts with the syntactic variable Sentence. At each step, it rewrites one term in the prototype sentence, replacing the term with a right-hand side that can be derived from that rule. The first step uses Rule 1 to replace Sentence. The second uses Rule 2 to replace Subject. The third replaces Object using Rule 5, while the final step rewrites Modifier with adjective according to Rule 6. At this point, the prototype sentence generated by the derivation matches the stream of categorized words produced by the scanner.

The derivation proves that the sentence “Compilers are engineered objects.” belongs to the language described by Rules 1 through 6. The sentence is grammatically correct. The process of automatically finding derivations is called parsing. Chapter 3 presents the techniques that compilers use to parse the input program.

Parser

the compiler pass that determines if the input stream is a sentence in the source language

A grammatically correct sentence can be meaningless. For example, the sentence “Rocks are green vegetables” has the same parts of speech in the same order as “Compilers are engineered objects,” but has no rational meaning. To understand the difference between these two sentences requires contextual knowledge about software systems, rocks, and vegetables.

The semantic models that compilers use to reason about programming languages are simpler than the models needed to understand natural language. A compiler builds mathematical models that detect specific kinds of inconsistency in a program. Compilers check for consistency of type; for example, the expression

a ← a × 2 × b × c × d

might be syntactically well-formed, but if b and d are character strings, the sentence might still be invalid. Compilers also check for consistency of number in specific situations; for example, an array reference should have the same number of dimensions as the array's declared rank and a procedure call should specify the same number of arguments as the procedure's definition. Chapter 4 explores some of the issues that arise in compiler-based type checking and semantic elaboration.

Type Checking

the compiler pass that checks for type-consistent uses of names in the input program

Scope Rules Across Various Languages

Programming language scope rules vary idiosyncratically from language to language. The compiler writer must understand the specific rules of a source language and must adapt the general translation schemes to work with these specific rules. Most alls have similar scope rules. Consider the rules for the languages fortran, c, and Scheme:

fortran has a simple name space. A fortran program creates a single global scope, along with a local scope for each procedure or function. Global variables are grouped together in a “common block”; each common block consists of a name and a list of variables. The global scope holds the names of procedures and common blocks. Global names have lifetimes that match the lifetime of the program. A procedure's scope holds parameter names, local variables, and labels. Local names obscure global names if they conflict. Names in the local scope have, by default, lifetimes that match an invocation of the procedure, The programmer can give a local variable the lifetime of a global variable by listing it in a save statement.

Separate compilation makes it hard for fortran compilers to detect different declarations for a common block in distinct files. Thus, the compiler must translate common-block references into 〈block, offset〉 pairs to produce correct behavior.

c has more complex rules. A c program has a global scope for procedure names and global variables. Each procedure has a local scope for variables, parameters, and labels. The language definition does not allow nested procedures, although some compilers have implemented this feature as an extension. Procedures can contain blocks (set off with left and right braces) that create separate local scopes; blocks can be nested. Programmers often use a block-level scope to create temporary storage for code generated by a preprocessor macro or to create a local variable whose scope is the body of a loop.

c introduces another scope: the file-level scope. This scope includes names declared as static that not enclosed in a procedure. Thus, static procedures and functions are in the file-level scope, as are any static variables declared at the outermost level in the file. Without the static attribute, these names would be global variables. Names in the file-level scope are visible to any procedure in the file, but are not visible outside the file. Both variables and procedures can be declared static.

Static Name

A variable declared as static retains its value across invocations of its defining procedure.

Variables that are not static are called automatic.

Scheme has a simple set of scope rules. Almost all objects in Scheme reside in a single global space. Objects can be data or executable expressions. System-provided functions, such as cons, live alongside user-written code and data items. Code, which consists of an executable expression, can create private objects by using a let expression. Nesting let expressions inside one another can create nested lexical scopes of arbitrary depth.

Sequential function charts

Another programming language used by PLCs and defined within the IEC-61131-3 standard is “sequential logic” or “sequential function charts (SFC).” Sequential logic differs from ladder logic in that each step is executed in isolation and progresses to the next step only upon completion, as opposed to ladder logic where every step is tested in each scan. This type of sequential programming is very common in batch-oriented operations. Other common languages defined by IEC-61131-3 include “structured text (ST),” “function block diagram (FBD)” and “instruction list (IL)” methods. No matter what programming language is used with a particular PLC, the end goal is ultimately to automate the legacy electromechanical functions common in industrial systems by checking inputs, applying logic (the program), and adjusting outputs as appropriate,4 as shown in Figure 4.4.

The logic used by the PLC is created using a software application typically installed on an engineering workstation that combines similar tools, or may be combined with other system functions like the HMI. The program is compiled locally on the computer, and then downloaded from the computer to the PLC by either direct serial (RS-232) or Ethernet connections, where the logic code is loaded onto the PLC. PLCs can support the ability to host both the source and compiled logic programs, meaning that anyone with the appropriate engineering software could potentially access the PLC and “upload” the logic.

What are the rules of a programming language called?

Does every programming language has rules governing its word usage and punctuation?

Is the set of rules that every programming language must strictly follow?

What is the function of a programming language quizlet?