1

CS 3120 Final Exam Review

15 short answer questions

Programming Language Concepts

Chapter 1: Preliminaries

3

Main Topics Reasons for studying programming

languages Programming Domains Language Evaluation Criteria Influences on Language Design Language Categories Language Design Tradeoffs Implementation Methods Programming Environments

4

Why Study PLC? Increased capacity to express ideas Improved background for choosing

appropriate languages Increased ability to learn new languages Better understanding of the significance

of implementation Increased ability to design new

languages Overall advancement of computing

5

Increased capacity to express ideas Programming language constrains

Control structures Data structures Abstractions that can be used

Awareness of language features reduces these limitations Features of one language may be simulated

in another Study of PLC builds appreciation for

language features and encourages their use

6

Language Evaluation Criteria Readability Writability Reliability Cost

7

Readability Overall Simplicity Control Statements Data Types and Structures Syntax Considerations

8

Writability Support for abstraction

Process abstraction Data abstraction

Expressivity APL has powerful operators that accomplish

lots of computation with little coding for statements for counting loops (instead of

while) and then, or else Boolean operators in Ada

9

Reliability Type checking

Subscript ranges: Ada vs. C Static vs. dynamic type checking

Exception handling Intercept runtime errors, take action to correct

problem, and continue processing PL/I, C++, Ada, Java

Aliasing 2 or more ways to reference same memory cell Possible via pointers, reference parameters,

unions

10

Costs Training programmers Writing programs Compiling programs Executing programs Language implementation system Poor reliability Maintaining programs

11

Influences on Language Design Computer architecture

Imperative languages model von Neumann architecture

Functional programming languages need a non-von Neumann architecture to be implemented efficiently

Programming methodologies Top-down design, stepwise refinement Data-oriented vs. process-oriented design Object-oriented design Concurrency (process-oriented)

12

Language Categories Imperative Functional Logic Object-oriented

13

Language Design Tradeoffs Reliability vs. cost of execution

Ada’s runtime type checking adds to execution overhead

Readability vs. writability C and APL

Flexibility vs. safety Pascal variant record is a flexible way to

view a data object in different ways, but no type checking is done to make it safe

14

Questions to Ponder

What are language design criteria? What are some design trade-offs? What are some language design

criteria that are in direct conflict with each other?

15

Implementation methods Compilation Interpretation Hybrid implementation systems

Java applets are compiled into byte code

Compiled applets are downloaded and interpreted by byte code interpreter

16

Evolution of Major Programming Languages

Chapter 2: Evolution Languages

Good chapter for background language evolution information.

NOT on the final exam!

Lexical and Syntax Analysis

Chapter 3 and 4

Describing Syntax and Semantics

Lexical and Syntax Analysis

18

Definitions Syntax: the form or structure of the

expressions, statements, and program units Semantics: the meaning of the expressions,

statements, and program units Sentence: a string of characters over some

alphabet Language: a set of sentences Lexeme: the lowest level syntactic unit of a

language (e.g., *, sum, begin) Token: a category of lexemes (e.g., identifier)

19

Describing Syntax Recognizers: used by compilers A grammar is used to describe

the syntax of a language. A context-free grammar can be

used to develop language translators.

20

Context-Free Grammar A context-free grammar is one

whose productions take the form A , where A is a single non-terminal symbol and is any string of terminals and/or non-terminals.

Context-free grammars are used to describe the syntax of modern programming languages.

21

Derivation A derivation is a repeated application of

rules, starting with the start symbol and ending with a sentence. In each step of a derivation, exactly one non-terminal is expanded.

Every string of symbols in a derivation is a sentential form. A sentential form may contain terminal and non-terminal symbols.

A sentence is a sentential form that has only terminal symbols.

22

Parse Trees Grammars describe the hierarchical

syntactic structure of sentences in the language they define

These hierarchical structures are called parse trees. Every internal node is labeled with a non-

terminal symbol Every leaf is labeled with a terminal

symbol

23

Questions to Ponder What’s syntax and semantics? What’s syntax analysis? What’s lexical analysis? What’s a lexeme and a token? What are grammars used for? No graphs or parse trees on the

final!

Names, Bindings, Type Checking, and Scopes

Chapter 5

25

Naming Naming is the process by which the

programmer associates a name with a potentially complicated program fragment The goal is to hide complexity Programming languages use name to

designate variables, types, classes, methods, operators,…

Naming provides abstraction E.g. Mathematics is all about the formal

notation (i.e. naming) that lets us explore more and more abstract concepts

26

Variable Names

Design issues - What should the maximum length be? - Are connector characters allowed? - Are names case sensitive? - Are special words reserved words or keywords?

Length

- FORTRAN I: maximum 6 - COBOL: maximum 30 - FORTRAN 90 and ANSI C: maximum 31 - Ada: no limit, and all are significant - C++: no limit, but implementers often impose one

27

Case sensitivity

Disadvantage: readability (names that look alike are different)

• C, C++, Java, and Modula-2 names are case sensitive• The names in other languages are not

Special words

A keyword is a word that is special only in certain contextsDisadvantage: poor readability

A reserved word is a special word that cannot be used as a user-defined name

Variable Names

28

A variable is an abstraction of a memory cell

Variables can be characterized as a collection of attributes: name, address, value, type, lifetime, and scope

Name - not all variables have them

Address - the memory address with which it is associated

• A variable may have different addresses at different times during execution• A variable may have different addresses at different places in a program• If two variable names can be used to access the same memory location, they are called aliases

Variable Names

29

Attributes of variables Name—not all variables have a name Address

The memory address with which a variable is associated

A variable may have different addresses at different times

Two names that can be used to access the same memory location are called aliases

30

Attributes of variables Type

Determines the range of values of variables and the set of operations defined for those values

Value The contents of the location with

which a variable is associated

31

Some definitions Binding—an association, such as

between an attribute and an entity, or between an operation and a symbol

Binding time—the time at which a binding takes place

32

Binding times Compile time

Example: binding of a variable to a type in C

Load time Example: binding of a C static variable to

a memory cell Run time

Example: binding of a non-static local variable to a memory cell

33

More on binding A binding is static if it

occurs before run time and remains unchanged throughout

execution A binding is dynamic if it

Occurs during execution, or Can change during execution

34

Scope The scope of a variable is the range of

statements over which it is visible The non-local variables of a program

unit are those that are visible but not declared there

The scope rules of a language determine how references to names are associated with variables

Scope may be static or dynamic

35

Static scope Based on the text of a program

To connect a name reference to a variable, the compiler must find the declaration Search process: search declarations, first

locally, then in increasingly larger enclosing scopes, until one is found for the given name.

36

Dynamic scope Based on calling sequences of

program units, not their textual layout

References to variables are connected to declarations by searching back through the chain of subprogram calls that forced execution to this point

37

Scope vs. lifetime Scope and lifetime are sometimes closely

related, but are different concepts. Consider a static variable in a C or C++

function:void fun() { static int x = 0; int y = 0; …}

Scope of x and y is from point of declaration to end of function block

Lifetime of x is entire execution of program Lifetime of y is during execution of fun()

38

Scope and Blocks

Blocks - a method of creating static scopes inside program units. Example:

C and C++:

for (...) { int index; ... }

39

Variable initialization The binding of a variable to a value

at the time it is bound to storage is called initialization

Initialization is often done on the declaration statement:

C++: float sum = 0.0;

40

Type Checking

Type checking is the activity of ensuring that the operands of an operator are of compatible typesA compatible type is one that is either legal for the operator, or is allowed under language rules to be implicitly converted, by compiler-generated code, to a legal type.A type error is the application of an operator to an operand of an inappropriate typeA programming language is strongly typed if type errors are always detected

41

Strong Typing

Allows the detection of the misuses of variables that result in type errors.

C and C++ don’t have strong typing: parameter type checking can be avoided; unions are not type checked (Java is similar)

42

Questions to Ponder What are some design issues for

names? What is static and dynamic scoping? What is type checking? What’s strong typing?

Chapters 6 and 8(no 7 on exam)

Data TypesStatement-Level Control Structures

44

Abstract Data Types

Abstract Data Type

- the use of type is separated from the representation and operations on values of that type

45

Ordinal Types ( user defined )

An ordinal type is one in which the range of possible values can be easily associated with the set of positive integers.

Enumeration Types - one in which the user enumerates all of

the possible values, which are symbolic constants

Design Issue: Should a symbolic constant be allowed to

be in more than one type definition?

46

Arrays

• An array is an aggregate of homogeneous data elements in which an individual element is identified by its position in the aggregate, relative to the first element.

Specific element of an array is identified by: i) Aggregate name; ii) Index (subscript):

position relative to the first element.

47

Design Issues for Arrays

1. What types are legal for subscripts?2. Are subscripting expressions in

element references range checked?3. When are subscript ranges bound?4. When does allocation take place?5. What is the maximum number of

subscripts?6. Can array objects be initialized?

48

Pointers

A pointer type is a type in which the range of values consists of memory addresses and a special value, null. The value null indicates that a pointer cannot currently be used to reference another object.

Design Issues: 1. What is the scope and lifetime of pointer variables? 2. What is the lifetime of heap-dynamic variables? 3. Are pointers restricted to pointing at a particular type?4. Are pointers used for dynamic storage management,

indirect addressing, or both?5. Should a language support pointer types, reference

types, or both?

49

Fundamental Pointer Operations

1. Assignment: Sets a pointer variable to the address of some object.

2. References: Obtaining the value of the memory cell whose address is in the memory cell to which the pointer variable is bound to.

In C and C++, dereferencing is specified by prefixing a identifier of a pointer type by the dereferencing operator (*).

50

Problems with pointers

1. Dangling pointers (dangerous) - A pointer points to a heap-dynamic variable

that has been de-allocated 2. Memory Leak (wasteful)- A heap dynamic variable that is no longer

referenced by any program pointer

51

Levels of Control Flow

The flow of control, or execution sequence, in program can be examined at several levels:

1. Within expressions 2. Among program units3. Among program statements

Def: Statements that provide capabilities such as, selecting among alternative control flow paths or causing the repeated execution of certain collection of statements are called control statements

Def: A control structure is a control statement and the statements whose execution it controls

52

Classification of Control Statements

 Selection statements: Choose between two or more execution paths in a program.

Two-way selection statements:

Select one of two execution paths—if-then-else statements.

Design issues What is the form and type of the expression that controls

the selection Can a single statement, a sequence of statements, or a

compound statement be selected How should the meaning of nested selectors be specified

53

Multiple selection constructs

Multiple selection construct allows the selection of one or any number of statements or statement groups (switch construct).

Design issues for multiple way selectors: What is the type and form of expression that controls the

selection? May single statement, sequence of statements or compound

statement be selected? Is the entire construct encapsulated in a syntactic structure? Is execution flow through the structure restricted to include just

one selectable segment? How should unrepresented selector expression values be

handled, if at all?

54

Iterative Statements

The repeated execution of a statement or compound statement is accomplished either by iteration or recursion.

General design Issues for iteration control statements:

1. How is iteration controlled? 2. Where is the control mechanism in the loop? The primary possibilities for iteration control are

logical, counting or combination of this two. Main choices for the location of the control mechanism are top or bottom of the loop.( posttest, or pretest)

55

Questions to Ponder

What are some common data types?

What are some design issues associated with arrays and pointers?

What are some design issues related to control structures?

Chapter 9 – Subprograms(No 10 or 11 on Final Exam)

Fundamentals of SubprogramsDesign Issues for Subprograms

57

1. A subprogram has a single entry point2. The caller is suspended during execution of the called subprogram3. Control always returns to the caller when the called subprogram’s execution terminates

A subprogram definition is a description of the actions of the subprogram abstraction

A subprogram call is an explicit request that the subprogram be executed

A subprogram header is the first line of the definition, including the name, the kind of subprogram, and the formal parameters

The parameter profile of a subprogram is the number, order, and types of its parameters

Subprogram Definitions

58

1. What parameter passing methods are provided?2. Are parameter types checked?3. Are local variables static or dynamic?4. What is the referencing environment of a passed subprogram?5. Are parameter types in passed subprograms checked?6. Can subprogram definitions be nested?7. Can subprograms be overloaded?8. Are subprograms allowed to be generic?9. Is separate or independent compilation supported?

Design Issues for Subprograms

59

Value or Name - copy it to the stack; passes the identify for the parameter

Result – same

Reference - regardless of form, put the address in the stack. Evaluate the address of the parameter

Implementing Parameter Passing

60

Design Considerations for Parameter Passing

1. Efficiency2. One-way or two-way

- These two are in conflict with one another!

Good programming => limited access to variables, which means one-way whenever possible

Efficiency => pass by reference is fastest way to pass structures of significant size

61

1. Are parameter types checked?2. What is the correct referencing environment for a subprogram that was sent as a parameter?

- Possibilities: a. It is that of the subprogram that enacts it. - Shallow binding

b. It is that of the subprogram that declared it. - Deep binding

Parameters that are Subprogram Names

62

A generic or polymorphic subprogram is one that takes parameters of different types on different activations

Overloaded subprograms provide polymorphism

A subprogram that takes a generic parameter that is used in a type expression that describes the type of the parameters of the subprogram provides parametric polymorphism

Generic Subprograms

63

Design Issues: 1. Are side effects allowed?2. What types of return values are allowed?3. What should the variable access method be?

The non-local variables of a subprogram are those that are visible but not declared in the subprogram

Global variables are those that may be visible in all of the subprograms of a program

Functions

64

Questions to Ponder What are some design issues for

subprograms? What are some design issues for

parameter passing? What is polymorphism? What are some design issues for

functions?

Chapter 12, 15, 16

Object-Oriented, Functional and Logical Programming Languages

66

Object-Oriented Languages

Abstract Data Types are called classesClass instances are called objects

A class that inherits is a derived class or a subclassThe class from which another class inherits is a parent class or superclass

Subprograms that define operations on objects are called methodsIn the simplest case, a class inherits all of the entities of its parent

67

Pure Functional Languages The concept of assignment is not part of

functional programming1. no explicit assignment statements2. variables bound to values only through parameter

binding at functional calls3. function calls have no side-effects4. no global state

Control flow: functional calls and conditional expressions no iteration! repetition through recursion

68

FPLs vs imperative languages

Imperative programming languages Design is based directly on the von Neumann

architecture Efficiency is the primary concern, rather than the

suitability of the language for software development Functional programming languages

The design of the functional languages is based on mathematical functions

A solid theoretical basis that is also closer to the user, but relatively unconcerned with the architecture of the machines on which programs will run

69

Lambda expressions A mathematical function is a mapping of

members of one set, called the domain set, to another set, called the range set

A lambda expression specifies the parameter(s)and the mapping of a function in the following form

(x) x * x * xfor the function

cube (x) = x * x * x Lambda expressions describe nameless functions

70

Fundamentals of FPLs The objective of the design of a FPL is to mimic

mathematical functions as much as possible The basic process of computation is fundamentally

different in a FPL than in an imperative language: In an imperative language, operations are done and the

results are stored in variables for later use Management of variables is a constant concern and

source of complexity for imperative programming languages

In an FPL, variables are not necessary, as is the case in mathematics

The evaluation of a function always produces the same result given the same parameters. This is called referential transparency

71

LISP

Functional language developed in the mid 50’s Semantics based on the lambda-calculus All functions operate on lists or symbols (called

S-expressions) Only 6 basic functions

list functions: cons, car, cdr, equal, atom conditional construct: cond

Useful for list processing Useful for Artificial Intelligence applications:

programs can read and generate other programs

72

Scheme A mid-1970s dialect of LISP,

designed to be a cleaner, more modern, and simpler version than the contemporary dialects of LISP

Functions are first-class entities They can be the values of expressions

and elements of lists They can be assigned to variables

and passed as parameters

73

PrologPROgramming in LOGic It is the most widely used logic

programming language

Its development started in 1970

What’s it good for? Knowledge representation Natural language processing State-space searching (Rubik’s cube) Expert systems, deductive databases, Agents

74

Overview ofLogic Programming Main idea: Ask the computer to solve

problems using principles of logic: Program states the known facts To ask a question, you make a statement

and ask the computer to search for a proof that the statement is true

Additional mechanisms are provided to guide the search to find a proof

75

Declarative vs. Imperative

Languages used for logic programming are called declarative languages because programs written in them consist of declarations rather than assignment and flow-of-control statements. These declarations are statements, or propositions, in symbolic logic.

Programming in imperative languages (e.g., Pascal, C) and functional languages (e.g., Lisp) is procedural, which means that the programmer knows what is to be accomplished by the program and instructs the computer on exactly how the computation is to be done.

76

Logic Programming Programming in logic programming

languages is non-procedural. Programs in such languages do not

state how a result is to be computed. Instead, we supply the computer with: relevant information (facts and rules) a method of inference for computing

desired results. Logic programming is based on the

predicate calculus.

77

Questions to Ponder

What are some characteristics of Object-Oriented, Functional and Logical Programming Languages?

What’s the difference between Declarative and Imperative Programming Languages?

78

End of Final Exam Review

• 15 short answer questions• Good luck!