CSE 3302 Programming Languages Dr Carter Tiernan CSE











![Moving, Indexing & Looping [ Addresses ] • Moving – Put a value into Moving, Indexing & Looping [ Addresses ] • Moving – Put a value into](https://slidetodoc.com/presentation_image_h2/f42bd17d9a77c6b7c1f919295c024670/image-12.jpg)





















- Slides: 33

CSE 3302 Programming Languages Dr. Carter Tiernan CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 1 jcmt

A programming language is a language that is intended for the expression of computer programs and is capable of expressing any computer program CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 2 jcmt

Why is this interesting? • Although it’s possible to write any program in any language, it’s not equally easy to do so. • Languages are the tools of the central activity of computer science • The structure of language defines the boundaries of thought • Motivation for and use of modern language facilities CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 3 jcmt

Why is this useful? • Learning language mechanisms can allow you to simulate such things even in a language that does not provide them • Presents the most important principles for the design, evaluation, and implementation of programming languages CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 4 jcmt

Principles • Open the front cover of your textbook. • Yes, right now. CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 5 jcmt

Early computing • Numeric programming with coding of instructions • A “pseudo-code” was a primitive language that implemented the machine code operations with different, and hopefully easier to use, codes – interpreted or – (eventually) compiled CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 6 jcmt

Constraints • Very slow • Very small memory • Computer time cost more than programmer time • For numeric programming – Significant floating point calculations – Requirement for indexing data CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 7 jcmt

What must a “pseudo-code” (or a programming language) do? Originally based on what the actual machine could do: • Floating point arithmetic and comparisons • Indexing • Transfer of control • I/O CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 8 jcmt

Decisions to make (OK, just a few of them) • • • Syntax? How large can addresses be? How long can instructions be? How should we code the operations? and so on… CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 9 jcmt

The Principles (again) • Identify elements most important to good programming language design • Apply with flexibility • Balance among contradictory • Modeled on Strunk and White CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 10 jcmt

Arithmetic vs. Comparison • Calculate values • Use operands • Values created can be used or stored CSE 3302 CSE@UTA • Test values • Use operands • Test results can be used or stored • Test results may control program flow Programming Languages Ch. 0 - 2 11 jcmt
![Moving Indexing Looping Addresses Moving Put a value into Moving, Indexing & Looping [ Addresses ] • Moving – Put a value into](https://slidetodoc.com/presentation_image_h2/f42bd17d9a77c6b7c1f919295c024670/image-12.jpg)
Moving, Indexing & Looping [ Addresses ] • Moving – Put a value into a memory address • Indexing – Access a single element from a multiple element structure - an array • Looping – Change the flow of the program back to a previous location CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 12 jcmt

Input and Output • Based on I/O devices and methods of the time – Punched cards – Paper tape – Keyboards • {Not much to say about this one} CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 13 jcmt

Program Structure • Declarations • Instructions • Input data Interpreter Execution 1. 2. 3. 4. CSE 3302 CSE@UTA Read instruction Decode Execute Repeat steps with next instruction Programming Languages Ch. 0 - 2 14 jcmt

Interpreter enhancements • Program tracing – Breakpoints – Data trap • Labels for statements and variables – Beginning of symbol table • Translation CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 15 jcmt

Symbolic Pseudo Code • • • Syntax Punch cards led to fixed format fields Key punches only had upper case VAR format Prefix notation CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 16 jcmt

Phenomenology • • Ampliative and Reductive Fascination and Fear Direct vs. Mediated (transparency) Focus and Action CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 17 jcmt

Efficiency : Fortran • Inclusion of floating point arithmetic and indexing in hardware exposed the overhead of interpreters • John Backus of IBM recognized that language adoption would be based on : – Use of conventional mathematical notation – Highly efficient (machine) code produced CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 18 jcmt

Adoption and Use of Fortran • Development of a usable Fortran took 2 years (18 person/years) of effort (starting in 1955) • Within a year and a half, approximately half the code being written for the IBM 704 machines was in Fortran • Why? – Exceptionally clear documentation – Very sophisticated optimization techniques • Many versions exist and are in use • Book focuses on ANS Fortran IV (’ 66) CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 19 jcmt

Fortran structure • Subprograms – Parameters – COMMON blocks • Declarative or Imperative (nonexecutable vs. executable) – Allocate, bind and initialize at declaration – Compute, control flow, or I/O • Stages and phases of compilation CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 20 jcmt

Imperative statements • Assignment (=) is most important and most common computational statement • Control structures developed to direct control to primitive statements – Structures were based on IBM 704 branches – GOTO used to transfer control with IF for selection and iteration – DO loop is only higher level construct • Counted loop with CONTINUE • Can be nested hierarchically CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 21 jcmt

Fortran Control Issues • Static and dynamic structure hard to see and correlate • Confusion of GOTO plethora • Weak typing • DO-loop is optimized with all needed info for execution stated at the top • Procedural abstraction – SUBROUTINE name (input & output parameters) – FUNCTION name (input parameters) CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 22 jcmt

Subroutines in Fortran • • CALL passes parameters and control RETURN passes control back to caller Allows modularity and encourages libraries Parameters passed by reference for efficiency but with side effects – Compare with pass by value-result • Activation records save state CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 23 jcmt

Fortran: Activation Record • Nonrecursive subprogram invocation • Contains all data needed to activate or restart a subprogram – Parameters – Instruction pointer (resumption address) – Dynamic link – Temporary storage CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 24 jcmt

Fortran: Data Structures • Scalars - integers, floating point – Integers, Hollerith constants (strings) – Double precision, complex, logical (boolean) • Representation – Word-based – Appropriate to operations on the type • Mathematical operations – Representation-independent – Overloaded for each type CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 25 jcmt

Fortran: Data Structures • Arrays • Contiguous memory allocation indexing A(1) for A(2) A(3) – Column-major order A(4) • Easy to optimize – Loop controls used array address to start – Subscript format was restricted – Index register increment easy to determine CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 26 jcmt

Fortran: Data Issues • Overloaded operators • Integer type used for integers and character strings (Hollerith constants) • No facilities for character manipulation • Arrays are static – Dimensions must be constants – Limited to 3 dimensions CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 27 jcmt

Fortran: Name structures • • Declaration does binding DATA statement does initialization Static allocation Fortran would automatically declare previously-unseen variables – “I through N” names assumed as integer – Major typo problems created • Variable names are local scope • Subprogram names are global scope CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 28 jcmt

COMMON blocks • Data sharing between subprograms • Subprogram explicitly calls out the COMMON block to be used • Aliasing EQUIVALENCE • Share memory within a subprogram CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 29 jcmt

Language Definition • Lexics – The way characters are combined to form words and symbols • Syntax – The way words and symbols are combined to form statements and expressions • Lexical analysis (scanning) • Syntactic analysis (parsing) CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 30 jcmt

Fortran syntax • Fixed-format columns – Free-format statement in columns 7 - 72 • • • Ignored blanks (ugh!) No “reserved” words Allowed (quasi) algebraic notation Operator precedence Linear instruction sequence CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 31 jcmt

First Generation Languages • Machine dependence – Especially seen in control structures – And in primitive data types supported • • Non-nested and rely on GOTO One parameter passing mode Definite loops supported but not recursion Arrays Weak typing Static allocation and disjoint scoping of names Linear organization CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 32 jcmt

Language Design Issues • Interaction of features • “Higher level” construct allows programmer to state what they want rather than how to do it • “Regular” flow of control • “Cost” of choices, e. g. Fortran efficiency CSE 3302 CSE@UTA Programming Languages Ch. 0 - 2 33 jcmt