cse 341, s. tanimoto concepts 1- 1 programming language concepts formal syntax paradigms data types...

CSE 341, S. Tanimoto Concepts 1-

1

Programming LanguageConcepts

Formal Syntax

Paradigms

Data Types

Polymorphism

CSE 341, S. Tanimoto Concepts 1-

2

General Issues

Representation (of data, of computation)

Form (Syntax)

Meaning (Semantics)

Paradigm (General way of thinking)

Naming (names, name spaces, bindings, locality)

Functionality (numeric, data manip, I/O, communication, synchronization, security)

Correctness (types, exception handling, error checking, bug avoidance)

CSE 341, S. Tanimoto Concepts 1-

3

SyntaxSyntax: The grammatical form of programs.

vs Semantics: The meaning of the program

Syntax (of textual languages) is typically specified by production rules for a context-free grammar using Backus-Naur Form (BNF) or Extended BNF (EBNF)

In visual languages, syntax is described by a set of restrictions on how diagrams may be constructed. (e.g., connection constraints)

CSE 341, S. Tanimoto Concepts 1-

4

Syntactic Components

Identifiers and reserved words

Numeric constants

Parentheses, braces and brackets

Expressions

Statements

CSE 341, S. Tanimoto Concepts 1-

5

BNF (Backus-Naur Form)

(2.0 * PI) / n

<expression> ::= <expression> + <term>

| <expression> - <term>

| <term>

<term> ::= <term> * <factor>

| <term> / <factor>

| <factor>

<factor> ::= number

| name

| ( <expression> )

CSE 341, S. Tanimoto Concepts 1-

6

Extended BNF

Optional constructs written as [ x ]

Zero or more of x written as { x }

Choice (“or”) written using |

Grouping with parentheses ( x | y ) as in { (x | y ) z }

<expression> ::= <term> { (+ | -) <term> }

<term> ::= <factor> { (* | /) <factor> }

<factor> ::= ’(’ <expression> ’)’ | name | number

CSE 341, S. Tanimoto Concepts 1-

7

DerivationE ::= E + T | E - T | T

T ::= T * F | T / F | F

F ::= number | name | ( E )

E

E + T

T + T

T / F + T

F / F + T

F / F + F

25 / F + F

25 / 100 + F

25 / 100 + total

CSE 341, S. Tanimoto Concepts 1-

8

Representation of DataConstants, Variables

Types, classes

Compounds: arrays, structures.

Non-numeric objects: strings, images, audio.

Values vs references

Machine dependencies: word size, addressing resolution.

In C, characters and booleans are actually integers.

CSE 341, S. Tanimoto Concepts 1-

9

Representation of ProcessArithmetic and logical expressions

Conditional expressions

Loops

Recursive and nonrecursive functions

Multiple threads of control, forking, joining, synchronizing

Single-threaded Parallel processing (in Single-instruction stream/multiple data stream processors)

Throwing and catching of exceptions

Declaration of constraints and rules

CSE 341, S. Tanimoto Concepts 1-

10

ParadigmGeneral style of thinking that underlies a programming language

Webster’s New World Dictionary: “a pattern, example, or model”.

Imperative Rule-based

Functional Logic

Object-oriented Visual data-flow

CSE 341, S. Tanimoto Concepts 1-

11

The Imperative Paradigm

An imperative program is a sequence of commands

Read a value from a file.

Evaluate an arithmetic expression.

Assign a value to a variable.

Test a condition and branch if it is true.

Iterate a loop body until a condition is false.

Print a value onto the screen.

CSE 341, S. Tanimoto Concepts 1-

12

The Functional Paradigm

An functional program is a collection of function definitions and function applications.

Define SQR(x): {

Apply the * function to x and x}

Apply SQR to 7;

CSE 341, S. Tanimoto Concepts 1-

13

The Object-Oriented Paradigm

An object-oriented program is a collection of object class definitions, in which both data members and methods are specified.

Class Student extends Person {

int student_number;

int get_student_number() { return student_number; }

int set_student_number (int num) {

student_number = num;

}

CSE 341, S. Tanimoto Concepts 1-

14

The Rule-Based Paradigm

A rule-based program is a collection of if-then rules.

if name = "" then input name;

if name starts with "A" then print "Early in the alphabet";

CSE 341, S. Tanimoto Concepts 1-

15

The Logic-Programming Paradigm

A logic program is a collection of logical propositions and questions.

If x is a bird or an airplane, then x has wings.

Tweety is a bird.

Does Tweety have wings?

CSE 341, S. Tanimoto Concepts 1-

16

The Visual Data-Flow ParadigmA visual data-flow program is a diagram in which boxes represent operations and arrows indicate the flow of data from outputs of operations to inputs of other operations.

input x

*

*

*

5

3

++

8

3x2 + 5x + 8

CSE 341, S. Tanimoto Concepts 1-

17

Types

Category or class for a value (or object) that permits its bits to be interpreted.

Central Processing Unit instruction sets recognize certain types, such as integers and floats of different sizes.

A programming language is not limited to the types that are directly supported by the CPU.

CSE 341, S. Tanimoto Concepts 1-

18

Strong vs Weak TypingStrong typing:

Every variable must be declared with a type.

A variable may receive only values of its type.

Type-related bugs can be reduced.

Type identification tags are not needed a run time.

Weak typing:

Variables need not be declared with particular types.

The type of value held by a variable can change dynamically.

Values must be tagged during execution with their types.

CSE 341, S. Tanimoto Concepts 1-

19

Coercion and ContagionCoercion: Any automatic type conversion.

A value of type A is being assigned to a variable of type B.

The value is coerced into one of type B.

double x = 3 * 5;

Contagion:

Values of lower precision “catch” the precision of their higher precision co-arguments.

int y = 10 * (3.1415 / 10); /* result is 3, not 0. */

In Common Lisp, when a rational meets a float, the rule of floating-point contagion rules.

CSE 341, S. Tanimoto Concepts 1-

20

Type InferenceWith weak typing, type inference is needed.

The resulting type can be determined from the types of the arguments, and the nature of the operations.

Contagion provides one method for type inference:

With strong typing, means for determining type equivalence are needed.

int x[10];

int y[10];

Here x and y have structurally equivalent types.

C and C++ recognize structurally equivalent types as equivalent.

In Modula, most structurally equivalent types are not automatically considered equivalent, but they can be declared equivalent.

CSE 341, S. Tanimoto Concepts 1-

21

PolymorphismThe ability for a function or a variable to receive values of different types.

(setq x 5)

(setq x ‘(a b c))

In Perl, is this polymorphism?

$x = 5;

$x = "This is a string. ";

CSE 341, S. Tanimoto Concepts 1-

22

Polymorphism in JavaVector v = new Vector( );

v.addElement(5);

v.addElement("A string");

Generality of type can be achieved by declaring formal parameters to be of class Object.

Vector returnTwo(Object obj) {

Vector pair = new Vector( );

pair.addElement(obj);

pair.addElement(obj.clone());

return pair;

}

CSE 341, S. Tanimoto Concepts 1-

23

Benefits of PolymorphismOne polymorphic function does the work of several more specific functions.

(push element)

(push-integer 5)

(push-string "string")

A polymorphic variable can hold a piece of data in different forms without requiring additional variables.

(setq president ’(abe lincoln))

(setq president (format nil "~A" president ))