programming languages n.
Skip this Video
Loading SlideShow in 5 Seconds..
Programming Languages PowerPoint Presentation
Download Presentation
Programming Languages

Loading in 2 Seconds...

play fullscreen
1 / 31

Programming Languages - PowerPoint PPT Presentation

  • Uploaded on

Programming Languages. The Beginning. In the beginning. Computers were very expensive; programmers were cheap Programming was by plugboards or binary numbers (on-off switches) Memories were maybe 4K and up Cycle times were in milliseconds No compromises for programmer's ease.

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about 'Programming Languages' - alain

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
in the beginning
In the beginning...
  • Computers were very expensive; programmers were cheap
  • Programming was by plugboards or binary numbers (on-off switches)
  • Memories were maybe 4K and up
  • Cycle times were in milliseconds
  • No compromises for programmer's ease
early compromises
Early compromises
  • Assembly language
    • reduced human error
    • programs were just as efficient
    • the compiler generated very efficient code
    • easier to read, understand, debug
    • need to compile was still extra overhead
    • the idea was: compile once, run many times
  • Mechanical, tedious, or error-prone activities should be automated
    • Higher-level languages are an example
    • Assembly language automates writing binary code
    • FORTRAN automates writing assembly language or binary code
  • Efficiency was everything
  • Card oriented, with information in fixed columns
  • First language to catch on in a big way
  • Because it was first, FORTRAN has many, many "mistakes"
  • Algol 60 was a great leap forward
  • In FORTRAN, an expression...
    • In a WRITE statement, could be c (constant), v (variable), or v+c, or v-c
    • As a parameter, could be c or v
    • As an array subscript, could be c, v, c*v, v+c, v-c, c*v+c, or c*v-c
    • On the RHS of an assignment, could be anything
  • In Algol 60, an expression is an expression is an expression!
  • Regular rules, without exceptions, are easier to learn, use, describe, and implement.
    • Arithmetic expressions in FORTRAN vs. Algol are an example
    • BNF is a great aid to imposing regularity
lexical conventions
Lexical Conventions
  • Reserved words, used in most modern languages (C, Pascal, Java)
    • Easier for experts, somewhat harder for novices
  • Keywords, unambiguously marked
    • Hard to type and often hard to read
  • Keywords in context (FORTRAN, PL/1)
    • If it makes sense as a keyword, it's a keyword, otherwise it's something else
the reserved word controversy
The Reserved Word Controversy
  • FORTRAN had no reserved words
  • IF (I) = 1 was an array assignment
  • Advantages of reserved words
    • Easier for the compiler writer
    • Helps avoid ambiguities in the language
  • Disadvantages of reserved words
    • Programmer has to know them all
    • Few reserved words imply less language power?
other fortran mistakes
Other FORTRAN "Mistakes"
  • The FORTRAN compiler ignored blanks
    • DO 50 I=1,10 became DO50I=1,10
  • Did not require variable declarations
    • Misspellings were automatically new variables
  • Earliest versions did not have subprograms
    • But they did have callable library routines
  • DO , IF, and GO TO were the only control structures
the impossible error principle
The Impossible Error Principle
  • Making errors impossible to commit is preferable to detecting them after their commission.
    • In FORTRAN, variables were declared simply by appearing in a program
    • DO 50 I = 1. 10 is an assignment to DO50I
    • In general, the earlier an error can be detected, the better
algol 60
Algol 60
  • Introduced the idea of a virtual machine
  • Used BNF to define syntax formally
  • Introduced nested scopes
  • Introduced free-format programs
  • Introduced recursion
  • Required declarations of all variables
  • Introduced if-then-else and flexible loops
  • BNF is a simple notation used to describe syntax precisely
  • Example:<integer> ::= <digit> | <integer> <digit> <digit> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
algol 60 was three languages
Algol 60 was three+ languages
  • The language definition was given in the reference language
  • Algorithms were published using the publication language, in which keywords were boldface
  • Programs were in a hardware representation
    • Often looked like: 'IF' X < Y 'THEN' X := X + 1
    • Difficult to type, difficult to read
algol 60 shortcomings
Algol 60 Shortcomings
  • Algol 60 had no input/output!
    • I/O was considered to be too hardware-specific
    • Most implementations “borrowed” FORTRAN's I/O
  • Used “call by name” semantics
    • powerful, but hard to implement
    • sometimes hard to understand
  • Few but very flexible control structures were considered to be “baroque”
functions and procedures
Functions and Procedures
  • In mathematics, a function:
    • returns a value
    • has no side effects (except maybe I/O)
    • does not alter its parameters
  • A procedure (a.k.a. subroutine):
    • does not return a value
    • is called precisely for its side effects
    • may (probably does) alter its parameters
c has no procedures
C Has No Procedures
  • Functions may return void (no value)
  • Functions really can’t alter their parameters
  • This is inadequate for real programs
  • There are workarounds, such as passing pointers to values
  • Hence, “functions” in C are seriously distorted
  • A predicate is a binary (two-valued) function
  • In some languages, a predicate returns “true” or “false”
  • In other languages (Snobol IV, Prolog, Icon), a predicate “succeeds” or “fails”
  • A procedure or function is called directly
  • In an O-O language, an object has methods
  • A message is sent to an object
  • The object decides what to do about the message
  • Typically, the object chooses a method to execute
scope rules
Scope Rules
  • The scope of a variable is the part of a program in which it is defined and accessible
  • FORTRAN: scope is the enclosing subprogram
  • Prolog: scope is the (one) enclosing clause
  • Java: scope is from point of definition to }
  • Algol, Pascal: scopes are nested
nested scopes
Nested Scopes

begin int x, y; --int x and int y are defined here begin float x, z; -- int y, float x, float z are defined here -- this is a “hole” in the scope of int x end -- int x, int y are defined hereend

actual and formal parameters
Actual and Formal Parameters
  • Parameters are passed to subprograms in a variety of ways
  • Actual parameters are the values used in a call to the subprogram
  • Formal parameters are the names used for those values in the subprogram
parameter transmission
Parameter Transmission
  • Call by reference (FORTRAN, Pascal, Java)
  • Call by value (C, Pascal, Java)
  • Call by name (Algol 60)
  • Call by value-result (Ada)
  • Call by unification (Prolog)
call by reference
Call by Reference
  • Every value (data item) is stored at some particular machine address
  • The subprogram is given that address
  • The subprogram directly manipulates the original data item
  • This is the most efficient way to pass parameters
  • In FORTRAN, could alter “constants” this way
example of call by reference
Example of Call by Reference

procedure A int X X = 5

call B (X)end

procedure B (Y) Y = Y + 1


X is stored in only one place (that place is in A), and B is made to refer to that place.

call by value
Call by Value
  • Subprograms are given a copy of the formal parameter
  • Subprograms are free to change their copy
  • The changed value is not copied back
  • Safe, but not efficient or flexible
  • C uses call-by-value exclusively
    • workaround: pass a pointer to the data item
example of call by value
Example of Call by Value

procedure A int X X = 5

call B (X)end

procedure B (Y) Y = Y + 1


Value is copied down when B is called, and never copied back up

call by name
Call by Name
  • Used in Algol 60, hardly anywhere else
  • Uses the copy rule: the subprogram acts as if it had a textual copy of the formal parameter
  • Mathematically, this is very neat
  • Doesn’t play well with scope rules
  • Violates information hiding (names matter)
  • Difficult to implement and usually inefficient
example of call by name
Example of Call by Name

int a, r;

function fiddle (int x) { int a = 3, b = 5; return a * x + b; // means a * (a+1) + b}

a = 9;r = fiddle (a+1); // should return 17print (r);

algol supported recursion
Algol Supported Recursion
  • Example:
  • integer function factorial (n) begin if (n = 0) then return 1 else return n * factorial (n - 1) end