01 introduction

Nature of Programming LanguagesIntroduction

Nguyễn Hữu Đức

Faculty of Information TechnologyHanoi University of Technology

Introduction What is a Programming Language? Abstractions in Programming Languages Computational Paradigms Language Definition Language Translation Language Design

Contents I

1 Introduction

2 What is a Programming Language?

3 Abstractions in Programming Languages

4 Computational Paradigms

5 Language Definition

6 Language Translation

7 Language Design

Nature of programming Languages N.H. Đức FACULTY OF INFORMATION TECHNOLOGY 2 / 54


Goal of this course

There are over 2500 programming languages

We shall not study any special programming language

We are going to study major principles and concepts of programminglanguages.



Computers and Programming Languages

Before 1940s: “hard-wired” computers“Special purpose” computing

After 1940s: John Von Neumann’s computersseries of codes could be stored as data and would be executed by CPU“General purpose” computing



John Von Neumann’s Machine

developed in 1940’s so that a series of codes could be stored in memoryas data and would be executed by CPU.

“memory” : where programs and data are stored

“CPU” : sequentially executes instructions



What is a Programming Language?

binary instructionslow-level languages (i.e. assembly)

machine-dependentdifficult to write and to understand programslow-level of abstraction

high-level languages (i.e. C, Java,...)higher-level of abstractioncode does not change (or little change) from machine to machineeasier to write and to understand



What is a Programming Language?

DefinitionA programming language is a notational system for describing computation inmachine-readable and human-readable form.



Computation

Turing machineA mathematical model of computationHigh precisionCan carry out any computation that any current computer can carry out



Computation

Church’s thesisIt is not possible to build a machine more powerful than a Turing machine

Practical aspect of this courseincluding mathematical computation, text processing, information storageand retrieval,...concentrating on “general purpose” programming languages (“specialpurpose” languages exist)



Machine readability

Machine-readable language can be translated efficially by a computerinto a form that can be executed by the target computer.

There must be an algorithm that translates the languageThis step-by-step process is unambiguous and finiteThe algorithm mus be able to translate in time proportional to the size ofthe program

O(n) complexity

Machine readability is ensured by restricting the structure of aprogramming language to that of “context-free languages”



Human readability

Require that a programming language provide abstractions of the actionsof computers that are easilly understood

By someone who is not familiar with the details of the underlyingcomputerProgramming languages should tend to resemble natural languages



Human readability

Require suitable mechanisms for reducing the amount of detail requiredfor understanding the whole program

A small change to one part of a program should not require major changesto the entire programRequires collection of local information in one place

Programming language is part of the software development environmentMany people involved in software development

We will not study PLs from software engineering point of view

We will focus on languages themselves



Two Categories of Abstraction

Data abstractionabstract properties of data (strings, numbers, ...) which is the subject ofcomputation

Control abstractionabstract properties of the transfer of controlEx. loops, conditional statements, procedure calls



Three Levels of Abstraction

Basic abstractionscollect together the most localized machine information

Structured abstractionscollect more global information about the structure of the program

Unit abstractioncollect information about entire pieces of a program



Data Abstractions - Basic Abstraction

Abstract internal representation of the common data valuesEx. integers are often stored in computer using a two’s complementrepresentationEx. floating point values are stored using IEEE 754 standard

Locations in memory are abstracted by a name – a variable

Kind of data values is given a name – data type

Examplevar x : integer; // PASCALint x; // C



Data Abstractions - Structured Abstraction

Data structures abstract collection of data that are relatedArrayRecord in Pascal or struct in Cdatatype in ML

Exampleint a[10]; // Array in C

struct Tree { // struct in Cstruct Tree *left, *right;void *data;

}

datatype ’a tree = // datatype in MLNil

| Node of {left : ’a tree, right : ’a tree, data : ’a}



Data Abstractions - Unit Abstraction

Collect related code into specific locations in the programData encapsulation and Information Hiding

Ex. modules in ML, classes in object-oriented languages, packages in Javaclass is also considered as a structured abstraction

ReusabilityAbility of reuse data abstration in different parts of a programSave writing code from scratchComponents : Operationally complete pieces of programsContainers : Data structures containing other user-defined data

Basis for language library

Many interface standards (COM, CORBA)



Control Abstractions - Basic Abstraction

Statements in a programming languagecombine a few machine instruction into a more understandable abstractstatementEx. “x := x + 3” fetches, adds and stores valuesEx. “GOTO 10” abstracts the jump instruction



Control Abstractions - Structured Abstraction

Divide a program into groups of instructions that are nested within teststhat govern their execution

Selection statement (“if”, “case”)

They can be nested




Selection statement in Cif (x > 0) {numSols = 2;r1 = sqrt(x);r2 = - r1;

} else {numSols = 0;

}




Selection statement in MLcase numSols(x) of0 => []2 => [sqrt(x), - sqrt(x)]




Looping mechanisms: for, while, repeat ... until,loop

Subroutines (procedures)Allows programmer to consider sequence of actions as one actionSubroutines must be declaredSubroutines must be called (they have point of invocation or activation)Formal parameters are defined in declarationArguments or actual parameters are passed when subroutine calledInformation about subroutine must be saved at the point of invocation andrestored when subroutine finishes

Runtime environment or operational stack

A subroutine can return a value or does not need to return a value whenfinished




Loop and subroutine in Cint gcd(int u, int v) {

int x = u;int y = v;int t;while ( y != 0) {

t = y;y = x % yx = t;

}return x;

}

Loop and subroutine in MLfun gcd(x, 0) = x| gcd(x, y) = gcd(y, x mod y)



Control Abstractions - Unit Abstraction

Procedures can be collected into a package or a program unitCarefully controlled interfacesCan be understood without knowing the detailsReusability and library buiding are the same as data unit abstraction



Parallel Programming Mechanism

Programming languages that are capable of executing parts of a programsimultaneously

They also have mechanism for synchronization and communicationamong programs or parts of a program



Abstraction Mechanism

All abstractions are provided for human readability

They should also provide all mechanisms to do any computation that aTuring machine can do

Turing completeA programming language is Turing complete provided it has integer variablesand arithmetic and sequentially executes statements, which include asignment,selection (if) and loop (while) statement.



Computational Paradigms

Most of programming languages are designed based on Von Neumannmodel

Sequential execution of instructionsVariables represent memory locationsAsignment allows program to operate on these memory variables

Programming languages characterized by these properties are calledimperative (or procedural) programming languagesIt is not neccessary for a programming language to be imperative

Von Neumann model restricts parallel computation, non-deterministiccomputation, or computation that does not depend on order (VonNeumann Bottleneck)

Computational paradigmsImperative paradigmFunctional paradigmLogic paradigmObject-oriented paradigm



Computational Paradigms - Imperative Paradigm

Properties of imperative programming languagesSequential execution of instructionsVariables represent memory locationsAsignment allows program to operate on these memory variablesSequentially execution of statementsAlso called “procedural” programming languages

Most PLs today based on this model

Deterministic computation

Can’t use this to describe parallel computation

Typical examples: FORTRAN, PASCAL, C



Imperative Paradigm

Example of gcd in Cint gcd(int u, int v) {

int x = u;int y = v;int t;while ( y != 0) {

t = y;y = x % yx = t;

}return x;

}



Computational Paradigms - Functional Paradigm

Based on description of computation on the evaluation of functions orthe application of functions to known values

Also called “applicative” languagesFunctional call

Passing the values as parametersActual evaluation of functionReturning values

No notion of variable or assignment

Repetitive operation can be done with recursion instead of loops

Typical examples: LISP, SCHEME, ML, HASKEL



Functional Paradigm

Example of gcd in MLfun gcd(x, 0) = x| gcd(x, y) = gcd(y, x mod y)



Computational Paradigms - Logic Paradigm

Based on symbolic logic

Program is a set of statements that describe what is true about a desiredresult

No loops or selections

Control is suplied by the underlying program

Also called “descritive” language

Typical example: PROLOG



Logic Paradigm

Example of gcd in PROLOGgcd(U, V, U) :- V = 0gcd(U, V, X) :- not(V = 0),

Y is U mod V,gcd(V, Y, X)



Computational Paradigms - Object-oriented Paradigm

Based on notion of an object which can be loosely described as acollection of memory locations together with all the operations that canchange the values of these memory locations

Objects are grouped into classes that represent all the objects with thesame properties

Object can be created as an instance of a class

Members represent memory locations

Methods represent operations on these memory locations

Provide data encapsulation and information hiding

Typical example: C++, JAVA



Object-oriented Paradigm

Example of gcd in JAVApublic class IntWithGcd {public IntWithGcd(int val) {value = val;}public int intValue() { retuen value; }public int gcd(int v) {

int z = value;int y = v;while ( y != 0) {

int t = y;y = z % y;z = t;

}return z;

}

private int value;};



Language Definition

A complete, precise description is neededTo know precisely what a computation does

Even today, most PLs are described informally by the so-call “referencemanual”

Reference manual is not preciseWith these definitions, it is possible to reason mathematically aboutprograms

formal verification, proof of behavior



Language Definition

Formal definition of a language leads to standadizationLanguage becomes independent of hardware platform, OS, ...

ANSI (American National Standards Institute) and ISO (InternationalOrganization for Standardization) standards

definitions of many languages including PASCAL, FORTRAN, C, C++,Ada, PROLOG



Language Definition

From practical point of view, formal definition neededbecause question about program’s behavior may ariseto provide discipline during the design of the language



Language Definition

Two parts of language definitionSyntax : structure of the languageSemantics : Meaning of the language



Language Syntax

Language syntax is like the grammar of a natural languageLanguage syntax can be given in context free grammar form

<if-statement> ::= if (<expression>) <statement>[else <statement>]

Language syntax can be given in form using special character andformatting

if-statement ::= if (expression) statement [else statement]



Language Syntax

Lexical structureSimilar to spelling in a natural languageprovide structure of words or token in the language

if, else are token“+”, “<=” are token“;”, “.” are token



Language Semantics

Semantics describes the meaning of the languageeffect of execution of a piece of codemuch more complex and difficult to describe precisely

C if-statement, Kernighan and Richie [1988]An if-statement is executed by first evaluating its expression, which must havearithmetic or pointer type, including all side effects, and if it comparesunequal to 0, the statement following the expression is executed. If there is anelse part, and the expression is 0, the statement following the “else” isexecuted.

What’s happen if there is no else part?



Language Semantics

Usin formal methods to describe the language semanticsNo generally accepted methodThere are several methods

operational semanticsdenotational semanticsaxiomatic semantics



Language Translation

There must be a translator that accepts a program written in theprogramming language and

either executes the program directly (interpreter)or transforms into a form in which it can be executed (compiler)



Interpretation

Source code

input outputinterpreter

one-step process that simulates the underlying machine



Compilation

Executable code

input outputprocessor

Source code

targetcode

Executablecodecompile further

transtaltion

two-step process that simulates the underlying machineoutput of the compiler is called the target codemost common target language is assembler languageassembler program is then generated to object code of the underlyingmachine and then linked with other object codes by a linker and loadedinto memory by a loader



Compilation

Pseudo-translatertranslates a source program into an intermediate codeinterpreter will execute the intermediate code

A language is different from a translator for that languageSome translators may or may not adhere closely to the language definition



Phases of a Translator

Lexical Analyzer (or scanner) converts source code (in text form) intosequence of tokens representing keywords, identifiers, constants,...

Syntax Analyzer (or parser) determines structure of the sequence oftoken

Semantic Analyzer must determine enough of the meaning of theprogram to allow the execution of the target code



Operations Performed by a Translator

Translater must maintain a run-time environment which has suitablememory for program data and record the progress of execution

Interpreter itself maintains a run-time environmentCompiler maintains run-time environment indirectly through target code

Language may require a pre-processor which is run to make the programsuitable for translation

Example#define PI 3.14



Static and Dynamic Properties

Static propetiesDetermined prior to executionStatic memory allocation: all variables located in a fixed possitions duringthe execution

Dynamic propetiesDetermined during the executionDynamic memory allocation

Static properties are useful for compilers



Static and Dynamic Properties

Language with large amount of static properties more suitable forcompilation

Language with large amount of dynamic properties more suitable forinterpretation

Imperative languages tend to be compiled

Functional and logic languages tend to be interpreted

Languages like C have both aspects



Efficiency

Interpreted language generally less efficient than compiled language

Compiler efficiency can be boosted by optimization

Interpreters are better than compilers if interactive input and outputrequired



Error-handling

Translators should try to fix errors or provide meaningful error messages

Translators should be able to find more errors after the first one caughtErrors can be caught by

scanner: use illegal charactersparser: syntax error (Ex. x = 2 +* 6)semantic analyser: undefined variables, incompatible type

Semantic error can be found during the executionIndex out-of rangeDivide by zero



Error-handling

Not all logic error can be found by the language translator (Ex. infiniteloops)Language specification often specifies

What error must be caught at compile timeWhat error must be generated at run timeWhat error go undetected



Debugging

Translator must provide option for debugging, for interfacing with OSand with IDE



Language Design

Machine readability and Human readability are main requirements

Data abstractions and control abstractions

Complexity control


01 introduction

Documents

programming languagesbefore

programming languageswe

language translation

placeprogramming language

special programming

computation inmachinereadable

humanreadable form

little change