Ch. 0 - 2 Ch. 0 - 2 1 jcmt CSE 3302 Programming Languages CSE3302 Programming Languages Dr. Carter...

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

CSE3302CSE3302Programming LanguagesProgramming Languages

Dr. Carter Tiernan


programming languageprogramming languagea language that is intended

for the expression of computer programs and is capable of expressing anyany

computer program

A is


Why is this interesting?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


Why is this useful?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


PrinciplesPrinciples• Open the front cover of your

textbook.• Yes, right now.


Early computingEarly 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


ConstraintsConstraints• Very slow• Very small memory• Computer time cost more than

programmer time• For numeric programming -

– Significant floating point calculations– Requirement for indexing data


What must a “pseudo-code” (or a What must a “pseudo-code” (or a programming language) do?programming language) do?

Originally based on what the actual Originally based on what the actual machine could do:machine could do:

• Floating point arithmetic and comparisons

• Indexing• Transfer of control• I/O


Decisions to makeDecisions to make(OK, just a few of them)(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…


The Principles (again)The Principles (again)• Identify elements most important

to good programming language design

• Apply with flexibility• Balance among contradictory

• Modeled on Strunk and White


Arithmetic vs. ComparisonArithmetic vs. Comparison• Calculate

values• Use operands• Values created

can be used or stored

• Test values• Use operands• Test results can

be used or stored

• Test results may control program flow


Moving, Indexing & LoopingMoving, Indexing & Looping[ Addresses ][ 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


Input and OutputInput and Output• Based on I/O devices and methods

of the time– Punched cards– Paper tape– Keyboards

• {Not much to say about this one}


Program StructureProgram Structure• Declarations• Instructions• Input data

InterpreterInterpreterExecutionExecution

1. Read instruction2. Decode3. Execute4. Repeat steps with

next instruction


Interpreter enhancementsInterpreter enhancements• Program tracing

– Breakpoints– Data trap

• Labels for statements and variables– Beginning of symbol table

• Translation


Symbolic Pseudo CodeSymbolic Pseudo Code• Syntax• Punch cards led to fixed format

fields• Key punches only had upper case• VAR format• Prefix notation


PhenomenologyPhenomenology• Ampliative and Reductive• Fascination and Fear• Direct vs. Mediated (transparency)• Focus and Action


Efficiency : FortranEfficiency : 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


Adoption and Use of FortranAdoption 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)


Fortran structureFortran 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


Imperative statementsImperative 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


Fortran Control IssuesFortran 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)


Subroutines in FortranSubroutines 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


Fortran: Activation RecordFortran: Activation Record• Nonrecursive subprogram invocation• Contains all data needed to activate

or restart a subprogram– Parameters– Instruction pointer (resumption address)– Dynamic link– Temporary storage


Fortran: Data StructuresFortran: 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


Fortran: Data StructuresFortran: Data Structures• Arrays• Contiguous memory allocation for

indexing– Column-major order

• Easy to optimize– Loop controls used array address to start– Subscript format was restricted– Index register increment easy to

determine

A(1)A(2)A(3)

A(4)


Fortran: Data IssuesFortran: 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


Fortran: Name structuresFortran: 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


COMMON blocksCOMMON blocks• Data sharing between subprograms• Subprogram explicitly calls out the

COMMON block to be used• Aliasing

EQUIVALENCEEQUIVALENCE• Share memory within a subprogram


Language DefinitionLanguage 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)


Fortran syntaxFortran 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


First Generation LanguagesFirst 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


Language Design IssuesLanguage 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

Ch. 0 - 2 Ch. 0 - 2 1 jcmt CSE 3302 Programming Languages CSE3302 Programming Languages Dr. Carter...

Documents

Transcript of Ch. 0 - 2 Ch. 0 - 2 1 jcmt CSE 3302 Programming Languages CSE3302 Programming Languages Dr. Carter...