1

440 Review 2012

2

Topics• Covers everything

– in slides – from the very beginning.

• Language classification, history, and comparison• How to describe a (programming) language

– Syntax (not covered)– Semantics ( Axiomatic semantics)

• Programming paradigms– Structured programming vs. Unstructured programming – Imperative programming vs. Declarative programming – Functional programming (Scheme, lambda calculus, XSLT, Mapreduce)– Logic programming (Prolog, Horn Clause)– Object-oriented programming (polymorphism, persistence)– Aspect Oriented Programming (AspectJ)

• Concepts and programming

3

Types of questions

• Multiple choices; true/false; filling in blanks.

• Running results of programs;

• Modify programs;

• Short explanations;

• Others.

4

• Which of the following is not an OO programming language?– Java– C++– Smalltalk– Simula 67– None of the above.

5

6

• The following figure is used to explain which language:

– Prism language– Requirement language– Aspect oriented language– Persistent programming language– Business process language

7

• Which of the following language is not a declarative language? – Java– Prolog– SQL– Scheme– None of the above.

• Imperative: a programming paradigm that describes computation in terms of a program state and statements that change the program state.

• A program is "declarative" if it describes what something is, rather than how to create it.– Imperative programs make the algorithm explicit and leave the goal implicit; – Declarative programs make the goal explicit and leave the algorithm implicit.

• Examples of declarative languages: – Functional programming languages, Logic programming languages, SQL.

8

• Which of the following is a script language?– Java – C#– PHP– Prolog– Scheme– None of the above.

• Scripting: connecting diverse pre-existing components to accomplish a new related task. – Favor rapid development over efficiency of execution; – Often implemented with interpreters rather than compilers; – Strong at communication with program components written in

other languages.

9

• BNF was first used to describe the syntax of which language:– C– Fortran– Algol– COBOL– LISP– None of the above

10

ALGOL (ALGOrithmic Language)

• de facto standard way to report algorithms in print • Designed to improve Fortran• John Backus developed the Backus Normal/Naur Form method of describing programming

languages. • ALGOL 60 inspired many languages that followed it

"ALGOL 60 was a great improvement on its successors.“The full quote is "Here is a language so far ahead of its time, that it was not only an improvement on its

predecessors, but also on nearly all its successors" --C. A. R Hoare

procedure Absmax(a) Size:(n, m) Result:(y) Subscripts:(i, k); value n, m; array a; integer n, m, i, k; real y; comment The absolute greatest element of the matrix a, of size n by m is transferred to y, and the subscripts of this

element to i and k; begin integer p, q; y := 0; i := k := 1; for p:=1 step 1 until n do for q:=1 step 1 until m do if abs(a[p, q]) > y then begin y := abs(a[p, q]); i := p; k := q end end Absmax

11

• Which of the following is not part of a compiler?– Scanner;– Parser;– Code generator;– Optimizer;– Interpreter;– None of the above.

12

Compilation and execution

Output DataInput Data

Target Program

Abstract Program(Optimized)

Parse TreeSymbol Table

Source program

CodeOptimization

SemanticAnalysis

Loader / LinkerCodeGeneration

Computer

Lexical Analysis(scanning)

Syntactic Analysis(parsing)

compiler

Token Sequence

Abstract Program(Intermediate code)

Object Program(Native Code)

Classification by implem

entation methods

13

• When you run the following Java program: public class Hello {

public static void main(String [ ] a){

System.out.println("Hello");

}

}

• How many classes will be loaded into the system? – One – Two– Three– Hundreds

14

Run java -verbose

sol:~/440>java -verbose Hello

[Opened /usr/jdk/instances/jdk1.5.0/jre/lib/rt.jar]

[Opened /usr/jdk/instances/jdk1.5.0/jre/lib/jsse.jar]

[Opened /usr/jdk/instances/jdk1.5.0/jre/lib/jce.jar]

[Opened /usr/jdk/instances/jdk1.5.0/jre/lib/charsets.jar]

[Loaded java.lang.Object from /usr/jdk/instances/jdk1.5.0/jre/lib/rt.jar]

[Loaded java.io.Serializable from /usr/jdk/instances/jdk1.5.0/jre/lib/rt.jar]

[Loaded java.lang.Comparable from /usr/jdk/instances/jdk1.5.0/jre/lib/rt.jar]

[Loaded java.lang.CharSequence from /usr/jdk/instances/jdk1.5.0/jre/lib/rt.jar]

[Loaded java.lang.String from /usr/jdk/instances/jdk1.5.0/jre/lib/rt.jar]

[Loaded java.lang.reflect.GenericDeclaration from /usr/jdk/instances/jdk1.5.0/jre/lib/rt.jar]

[Loaded java.lang.reflect.Type from /usr/jdk/instances/jdk1.5.0/jre/lib/rt.jar]

[Loaded java.lang.reflect.AnnotatedElement from /usr/jdk/instances/jdk1.5.0/jre/lib/rt.jar]

[Loaded java.lang.Class from /usr/jdk/instances/jdk1.5.0/jre/lib/rt.jar]

[Loaded java.lang.Cloneable from /usr/jdk/instances/jdk1.5.0/jre/lib/rt.jar]

[Loaded java.lang.ClassLoader from /usr/jdk/instances/jdk1.5.0/jre/lib/rt.jar]

[Loaded java.lang.System from /usr/jdk/instances/jdk1.5.0/jre/lib/rt.jar]

… (hundreds of related classes)

[Loaded Hello from file:/global/fac2/jlu/440/]

Hello

[Loaded java.lang.Shutdown from /usr/jdk/instances/jdk1.5.0/jre/lib/rt.jar]

[Loaded java.lang.Shutdown$Lock from /usr/jdk/instances/jdk1.5.0/jre/lib/rt.jar]

public class Hello {public static void main(String [] a){ System.out.println("Hello");}}

15

• A program written in an interpreted language is usually – slow to run;– slow to develop;– slow to compile;– None of the above.

16

Interpreted language• Programs are executed from source form, by an interpreter.

– many languages have both compilers and interpreters, including Lisp, BASIC, and Python.

• Disadvantages:– Much slower

– Real time translation;– Initially, interpreted languages were compiled line-by-line; each line was

compiled as it was about to be executed, and if a loop or subroutine caused certain lines to be executed multiple times, they would be recompiled every time.

– Require more space.– Source code, symbol table, …

• Advantage of interpreted languages– Easy implementation of source-level debugging operations, because

run-time errors can refer to source-level units– E.g., if an array index is out of range, the error message can easily

indicate the source line and the name of the array.

– It can take less time to interpret it than the total time required to compile and run it. This is especially important when prototyping and testing code when an edit-interpret-debug cycle can often be much shorter than an edit-compile-run-debug cycle. (e.g., csh)

Classification by implem

entation methods

17

• Compared with declarative languages, which of the following is not true for imperative languages:– Can have side effects;– More efficient to run;– Closer to computer; – Harder to implement the language;– None of the above.

• True or false: Declarative languages are more difficult to implement than imperative languages.

18

Why is it difficult to implement declarative languages?

• By definition, it specifies what the task is, not the way how to solve it.• Consider the following query:

– customers(id, name, phone)– Orders(o-id, c-id, product, price, date)

SELECT product, price, dateFROM customers, ordersWHERE customers.id = orders.c-id AND customers.name=“john”

• It declares what we want. Does not specify how to implement it.– e.g. which condition to run first?

• There are many different ways to implement. – A naïve one would be very expensive (construct the Cartesian product of the

two tables, join two ids first) would be very expensive;• Query engine (compiler) will take care of these implementation issue.

• Conclusions:– Declarative programming focus on higher level of abstraction;– It is more difficult to implement.

19

• True or false: Imperative languages are very high level programming languages.

thought

Languagesmachine

High Level Language

Assembly Language

Machine Language

Very high level Language

Closer to humans

20

• Which of the following is not a technology for distributed objects? – CORBA– Java RMI– EJB– AspectJ

21

• True or false: A compiler translates source code of one high level language to another high level language.

• Compilation: translating high-level program (source language) into machine code (machine language)

– Slow translation, fast execution

• High level to high level language translation: programming language transformation

22

Which of the following is the rule for if statement?

None of above

}{}{}{}{QSthenBifP

QSP

}{}{}{}{QSthenBifP

QSBP

}{}{}{}{

QSthenBifPQBQSP

}{}{}{}{

QSthenBifPQBQSP

23

Which of the following is the rule for while statement?

}{}{}{}{

QSdoBwhilePQSP

}{}{}{}{

QSdoBwhilePQPPSP

}{}{}{}{

QSdoBwhilePQBPPSBP

}{}{}{}{

BPSdoBwhilePPSP

24

• Given the following Hoare triple

{true}

f := 1; n:=10;

while (n != 0) do ( f := n*f; n:=n-1; )

{f=10!}

• Write its loop invariant. You don’t need to write the proof of the program.

25

• Solution:

n f

10 1

9 10*1

8 9*10*1

7 8*9*10*1

…

P is f=10!/n!

26

• Given the following Hoare triple {true}

x := 0; f := 1;

while ( x < n ) do (x := x + 1; f := f * x;)

{f=n!}

• Write its loop invariant. f=x!

∧ x<=n

27

• Prove that the following Hoare triple is true. You should write down the details of derivation. In each step please write the rule name that is used. {x=2 y=0} x:=y; y:=x; {x=0 y=0}

Solution:{x=0 y=0 [x/y]} y:=x; {x=0 y=0}, by assignment Axiom{x=0 x=0} y:=x; {x=0 y=0}, by simplificationa) {x=0} y:=x; {x=0 y=0}, by simplification

{x=0 [y/x]} x:=y; {x=0}, by assignment axiomb) {y=0} x:=y; {x=0}, by simplification

By sequential composition rule and a), b),c) {y=0} x:=y; y:=x; {x=0 y=0}d) x=2 y=0 y=0 , by logic

by Consequence rule and c), d), we can get e) {x=2 y=0} x:=y; y:=x; {x=0 y=0}

28

• True or false: Modern high level programming languages removed GOTO statement, hence they can’t describe some computational tasks that could have been described using GOTO statement.

29

Structured programming

• Any program can be goto-free (1966, Böhm and Jacopini, CACM)– any program with gotos could be transformed into a goto-free form

involving only – Sequential composition– choice (IF THEN ELSE) and – loops (WHILE condition DO xxx),– possibly with duplicated code and/or the addition of Boolean variables

(true/false flags).

C

S

Y NS2

C

S1

Y N

S1 S2

Classification by programm

ing paradigms

30

If we can prove the Hoare triple {P} S {Q}, we can say that program S is totally correct for the pre-condition P and pos-condition Q.

• {P} S {Q} means “if we assume that P holds before S starts executing, then Q holds at the end of the execution of S”

– I.e., if we assume P before execution of S, Q is guaranteed after execution of S

• To prove total correctness we also have to prove that the loop terminates

31

• List four different language paradigms and give at least one example language for each paradigm.

• Aspect-oriented programming addresses the problem of crosscutting concerns. What are crosscutting concerns and what are the two main problems of crosscutting concerns?

32

Given the following partial program, fill in the missing part so that it will print the following:

Hello Harry, having fun?

public class MessageCommunicator {

public static void deliver(String person, String message) {

System.out.print(person + ", " + message);

}}

public class Test {

public static void main(String[] args) {

MessageCommunicator.deliver("Harry", "having fun?");

}}

public aspect HindiSalutationAspect {

pointcut sayToPerson(String person) :

call(void MessageCommunicator.deliver(____________ )) && args(____________________________);

void around(String person) : sayToPerson(person) { proceed(______________);

}}

//Listing 2.4 HindiSalutationAspect.java

public aspect HindiSalutationAspect {

pointcut sayToPerson(String person):

call(void helloV3.MessageCommunicator.deliver(String, String))

&& args(person, String);

void around(String person) : sayToPerson(person) {

proceed(person + " -ji");

}

}

33

34

For our Account example in this course, suppose the main method will run the following two statements in sequel. The initial account balance is zero.account.credit(100);account.debit(20);

• What will be the account balance for the following advice?void around(): call(* *.credit(..)){ proceed();}

• What will be the balance if we run the following advice instead? void around(float amount): call(* *.credit(float)) && args(amount) { proceed(amount+1000); }

• What will be the balance for the following advice without including the previous two advices:– void around(): call(* *.debit(..)){ }

• Functional and logic programming (and everything else) will be tested again

35