History of Programming Languages

History Early History : The first programmers 1940s: Von Neumann and Zuse 1950s: The First Programming Language 1960s: Explosion in Programming languages 1970s: Simplicity, Abstraction, Study 1980s: Object-oriented, Logic programming 1990s: Internet, Java, C++, C# 2000s: Scripting, Web, … 2010s: Parallel computing, concurrency

Early History: First Programmers 1672: The Pascaline

o Designed and built by Blaise Pascalo One of the first mechanical calculatorso Could do addition and subtraction

The Pascaline: One of the Earliest Mechanical Calculators

http://www.edumedia-sciences.com/en/a558-pascaline (try me!)

1

Jacquard loom of early 1800so Translated card patterns into cloth designs

the Jacquard loom

The holes are the first simple type of Boolean response. Needles will pull thread if there is an empty spot.

Charles Babbage’s analytical engine (1830s & 40s)o Programs were cards with data and operations. o Steam powered!

2

Charles Babbage’s analytical engine

Ada Lovelace – first programmer“The engine can arrange and combine its numerical quantities exactly as if

they were letters or any other general symbols; And in fact might bring out its results in algebraic notation, were provision made.”

Konrad Zuseo Plankalkul (plan calculus) in Germany in the 1940so the first algorithmic programming language (not a machine)o with an aim of creating the theoretical preconditions for the formulation of

problems of a general nature. o Seven years earlier, Zuse had developed and built the world's first binary

digital computer, the Z1. He completed the first fully functional program-controlled

electromechanical digital computer, the Z3, in 1941. o Only the Z4 – the most sophisticated of his creations -- survived World

War II. o Wrote algorithms in the language, including a program to play chess.

3

o His work finally published in 1972.o Included some advanced data type features such as

Floating point, used twos complement and hidden bits Arrays records (that could be nested)

Plankalkul Code

A(7) := 5 * B(6) | 5 * B => A V | 6 7 (subscripts) S | 1.n 1.n (data types)

Von Neumann o led a team that built computers with stored programs and a central

processoro ENIAC was programmed with patch cords (cables to transmit data)

4

Machine Codes (40’s) Initial computers were programmed in raw machine codes.

o analog!!! What was wrong with using machine code? Everything!

o Poor readabilityo Poor modifiabilityo Expression coding was tediouso Inherit deficiencies of hardware, e.g., no indexing or floating point

numberso hard to train others!!!

TDC Example

This stood a couple of feet high!!

5

The 1950s: The First Programming Language Pseudocodes: interpreters for assembly language Fortran: the first higher level programming language COBOL: the first business oriented language Algol: one of the most influential programming languages ever designed LISP: the first language outside the von Neumann model APL: A Programming Language

Pseudocodes (1949) Short Code or SHORTCODE - John Mauchly, 1949. Pseudocode interpreter for math problems (only), on Eckert and Mauchly’s

BINAC and later on UNIVAC I and II. Possibly the first attempt at a higher level language. Expressions were coded, left to right, e.g.:

ShortCode Example

X0 = sqrt(abs(Y0))00 X0 03 20 06 Y0

ShortCode Translation Table

01 – 06 abs 1n (n+2)nd power02 ) 07 + 2n (n+2)nd root03 = 08 pause 4n if <= n04 / 09 ( 58 print & tab

6

Blah Blah Blah instead of me going over all of the different languages that have been created (boring) in groups of 3, pick 3 languages from the list below

o at least one has to have a computer/laptop Gather information required below

o when complete, have a person write it (in order please) on the board

C Java Python BASICC++ Haskell Ruby Visual BasicFortran Lua COBAL APLAda Scheme LISP SNOBOLC# Perl Algol PrologSmalltalk Flash JavaScript JSPModula Oberon ML Logo

Here is the information I want (please place in order):

Language Pick 1 Language Pick 2 Language Pick 3Year CreatedOther Versions?Salary (East Coast)Salary (West Coast)Lots of Jobs?Application specific?Minimum DegreeRequired ExperienceClearance Required?Find a sample of code (do not post)GUI Features?

To specify your search for Jobs

7

Answer these as a group:1. Why do we study different languages?2. Why do we study languages created MANY years ago?3. Why could knowing other languages benefit you?

Go to Criteria of Languages!!!

8

Fortran FORmula TRANslator Developed at IBM under the guidance of John Backus

primarily for scientific, computational programming Dramatically changed forever the way computers used Has continued to evolve, adding new features & concepts. o FORTRAN II, FORTRAN IV, FORTRAN66, FORTRAN77, FORTRAN90

Always among the most efficient compilers, producing fast code

Fortran 90 Example Code

9

How Fortran Progressed in FeaturesFortran 1 • Names could have up to six characters

• Post-test counting loop (DO I=1, 100)• Formatted I/O• User-defined subprograms• Three-way selection statement (arithmetic IF with GOTO)

IF (ICOUNT-1) 100 200 300• Implicit data typing statements

variables beginning with i, j, k, l, m or n were integers, all else floating point• No separate compilation• Programs larger than 400 lines rarely compiled correctly, mainly due to

poor reliability of the 704• Code was very fast• Quickly became widely used

Fortran II • Independent compilation• Fix the bugs

Fortran IV • Explicit type declarations• Logical selection statement• Subprogram names could be parameters• ANSI standard in 1966

Fortran 77 • Character string handling• Logical loop control statement• IF-THEN-ELSE statement

Fortran 90 • Pointers• Recursion• CASE statement• Parameter type checking• A collection of array operations, DOTPRODUCT, MATMUL,

TRANSPOSE, etc• dynamic allocations and deallocation of arrays• a form of records (called derived types)• Module facility (similar Ada’s package)

10

COBOL COmmon Business Oriented Language Principal mentor: (Rear Admiral Dr.)

Grace Murray Hopper (1906-1992) Based on FLOW-MATIC which had such

features as:o Names up to 12 characters, with

embedded hyphenso English names for arithmetic operatorso Data and code were completely separateo Verbs were first word in every statement

CODASYL committee (Conference on Data Systems Languages) developed a programming language by the name of COBOL

Design goals:o Must look like simple Englisho Must be easy to use, even if that means it will be less powerfulo Must broaden the base of computer userso Must not be biased by current compiler problems

Design committee were all from computer manufacturers and DoD branches Contributions:

o First macro facility in a high-level languageo Hierarchical data structures (records)o Nested selection statementso Long names (up to 30 characters), with hyphenso Data Division

Comments:o First language required by DoD; would have failed without DoDo Still the most widely used business applications languageo Y2K Bug!!!

11

Cobol Examples $ SET SOURCEFORMAT"FREE"IDENTIFICATION DIVISION.PROGRAM-ID. ShortestProgram.

PROCEDURE DIVISION.DisplayPrompt. DISPLAY "I did it". STOP RUN. $ SET SOURCEFORMAT"FREE"IDENTIFICATION DIVISION.PROGRAM-ID. Multiplier.AUTHOR. Michael Coughlan.* Example program using ACCEPT, DISPLAY and MULTIPLY to * get two single digit numbers from the user and * multiply them together

DATA DIVISION.

WORKING-STORAGE SECTION.01 Num1 PIC 9 VALUE ZEROS.01 Num2 PIC 9 VALUE ZEROS.01 Result PIC 99 VALUE ZEROS.

PROCEDURE DIVISION. DISPLAY "Enter first number (1 digit) : " WITH NO ADVANCING. ACCEPT Num1. DISPLAY "Enter second number (1 digit) : " WITH NO ADVANCING. ACCEPT Num2. MULTIPLY Num1 BY Num2 GIVING Result. DISPLAY "Result is = ", Result. STOP RUN.

BASIC Beginner's All purpose Symbolic Instruction Code Designed by Kemeny & Kurtz at Dartmouth for the GE 225 with the goals:

o Easy to learn and use for non-science students and as a path to Fortran and Algol

o Must be “pleasant and friendly”o Fast turnaround for homeworko Free and private accesso User time is more important than computer time

12

Well suited for implementation on first PCs (e.g., Gates and Allen’s 4K Basic interpreter for the MITS Altair personal computer (circa 1975)

Current popular dialects: Visual BASIC Basic Example

answer = 2 + 3Print answerPrint answer * 2WaitKey()

LISP LISt Processing language (Designed at MIT by McCarthy) AI research needed a language that:

o Process data in lists (rather than arrays)o Symbolic computation (rather than numeric)

One universal, recursive data type: the s-expressiono An s-expression is either an atom or a list of zero or more s-expressions

Syntax is based on the lambda calculus Pioneered functional programming

o No need for variables or assignmento Control via recursion and conditional expressions

Statuso Still the dominant language for AIo COMMON LISP and Scheme are contemporary dialectso ML, Miranda, and Haskell are related languages

LISP Example

;;; testing.lisp;;; by Philip Fong;;;;;; Introductory comments are preceded by ";;;";;; Function headers are preceded by ";;";;; Inline comments are introduced by ";";;;

;;

13

;; Triple the value of a number;;

(defun triple (X) "Compute three times X." ; Inline comments can (* 3 X)) ; be placed here.

;;;; Negate the sign of a number;;

(defun negate (X) "Negate the value of X." ; This is a documentation string. (- X))

Algol Environment of development:

1. FORTRAN had (barely) arrived for IBM 70x2. Many other languages were being developed, all for specific machines3. No portable language; all were machine dependent4. No universal language for communicating algorithms

ACM and GAMM met for four days for designo Goals of the language:

1. Close to mathematical notation 2. Good for describing algorithms 3. Must be translatable to machine code

Not meant to be implemented, but variations of it were (MAD, JOVIAL) Although IBM was initially enthusiastic, all support was dropped by mid-

1959 Successes:

o It was the standard way to publish algorithms for over 20 yearso All subsequent imperative languages are based on ito First machine-independent languageo First language whose syntax was formally defined (BNF)

Failure: o Never widely used, especially in U.S., mostly becauseo No i/o and the character set made programs nonportableo Too flexible--hard to implemento Entrenchment of FORTRAN

14

o Formal syntax descriptiono Lack of support of IBM

Progress of Algol DesignAlgol 58 • Concept of type was formalized

• Names could have any length• Arrays could have any number of subscripts• Parameters were separated by mode (in & out)• Subscripts were placed in brackets• Compound statements (begin ... end)• Semicolon as a statement separator• Assignment operator was :=• if had an else-if clause

Algol 60 Modified ALGOL 58 at 6-day meeting in Paris adding such new features as:

• Block structure (local scope)• Two parameter passing methods• Subprogram recursion• Stack-dynamic arrays• Still no i/o and no string handling

Algol 68 Design is based on the concept of orthogonality Contributions:

o User-defined data structureso Reference typeso Dynamic arrays (called flex arrays)

APL designed by Ken Iverson at Harvard in late 1950’s APL = A Programming Language A language for programming mathematical computations

o especially those using matrices Functional style and many whole array operations Drawback is requirement of special keyboard APL required a special character set, usually provided by an IBM Selectric

15

typewriter Here’s an example that prints the squares of the first 10 integers: (ι 10) × (ι 10)

– ι (iota) is an operator takes a number and returns a vector from 1 to than number

The programming paradigm was focused on vector and matrix operations

PL/I Computing situation in 1964 (IBM's point of view)

o Scientific computing IBM 1620 and 7090 computers FORTRAN SHARE user group

o Business computing IBM 1401, 7080 computers COBOL GUIDE user group

IBM’s goal: develop a single computer (IBM 360) and a single programming language (PL/I) that would be good for scientific and business applications.

Eventually grew to include virtually every idea in current practical programming languages.

PL/I contributions:o First unit-level concurrencyo First exception handlingo Switch-selectable recursiono First pointer data typeo First array cross sections

Many new features were poorly designed Too large and too complex Was (and still is) actually used for both scientific and business applications Subsets (e.g. PL/C) developed which were more manageable PL/I contributions:

o First unit-level concurrencyo First exception handlingo Switch-selectable recursion

16

o First pointer data typeo First array cross sections

Many new features were poorly designed Too large and too complex Was (and still is) actually used for both scientific and business applications Subsets (e.g. PL/C) developed which were more manageable

Simula 1962-67 PL/I contributions:

o First unit-level concurrencyo First exception handlingo Switch-selectable recursiono First pointer data typeo First array cross sections

Many new features were poorly designed Too large and too complex Was (and still is) actually used for both scientific and business applications Subsets (e.g. PL/C) developed which were more manageable

The 1970s: Simplicity, Abstraction, Study Algol-W - Nicklaus Wirth and C.A.R.Hoare

o reaction against 1960so simplicity

Pascalo small, simple, efficient structureso great for teaching programmingo Designed by Wirth, who quit the ALGOL 68 committee because he

didn't like the direction of that worko Designed for teaching structured programmingo Introduces some modest improvements, such as the case statemento Was widely used for teaching programming in the 1980s

CMSC 201 used Pascal up to ~1994 or so C - 1972 - Dennis Ritchie

17

o aims for simplicity by reducing restrictions of the type systemo allows access to underlying systemo interface with O/S - UNIXo Designed for systems programming at Bell Labs by Dennis Richie and

colleagues.o Evolved primarily from B, but also ALGOL 68o Powerful set of operators, but poor type checkingo Initially spread through UNIX and the availability of high quality, free

compilers.

The 1980s: Consolidation & New Paradigms Ada

o US Department of Defenceo European team lead by Jean Ichbiaho In study done in 73-74 it was determined that the US DoD was spending

$3B annually on software, over half on embedded computer systemso The Higher Order Language Working Group was formed and initial

language requirements compiled and refined in 75-76 and existing languages evaluated

o In 1997, it was concluded that none were suitable, though Pascal, ALGOL 68 or PL/I would be a good starting point

o Language DoD-1 was developed thru a series of competitive contractso Renamed Ada in May 1979o Reference manual, Mil. Std. 1815 approved

10 December 1980. (Ada Bryon was born 10/12/1815) o Ada was “mandated” for use in DoD work during late 80’s and early 90’s.o Ada95, a joint ISO and ANSI standard, accepted in February 1995 and

included many new features.o The Ada Joint Program Office (AJPO) closed 1 October 1998 (Same day as

ISO/IEC 14882:1998 (C++) published!).o Contributions:

Packages - support for data abstraction Exception handling - elaborate

18

Generic program units Concurrency - through the tasking model

o Competitive designo Included all that was then known about software engineering and language

designo First compilers were very difficult; the first really usable compiler came

nearly five years after the language design was completedo Very difficult to mandate programming technology

Functional programmingo Common Lisp: consolidation of LISP dialects spurred practical use, as did

the development of Lisp Machines.o Scheme: a simple and pure LISP like language used for teaching

programming.o Logo: Used for teaching young children how to program.o ML: (MetaLanguage) a strongly-typed functional language first developed

by Robin Milner in the 70’s o Haskell: polymorphicly typed, lazy, purely functional language.

Logic programmingo Prolog

Developed at the University of Aix Marseille, by Comerauer and Roussel, with some help from Kowalski at the University of Edinburgh

Based on formal logic Non-procedural Can be summarized as being an intelligent database system that uses

an inferencing process to infer the truth of given queries Object-oriented programming

o Smalltalk Developed at Xerox PARC by Alan Kay and colleagues (esp. Adele

Goldberg) inspired by Simula 67 First compilation in 1972 was written on a bet to come up with "the

most powerful language in the world" in "a single page of code". In 1980, Smalltalk 80, a uniformly object-oriented programming

environment became available as the first commercial release of the Smalltalk language

19

Pioneered the graphical user interface everyone now uses Saw some industrial use in late 80’s and early 90’s

o Eiffel Eiffel - a related language that supports OOP (Designed by Bertrand Meyer - 1992) Not directly derived from any other language Smaller and simpler than C++, but still has most of the power

What goes into Designing a Language?? What is good programming language design? What criteria should be used to judge a language? How should success or failure of a language be defined? We will define a language as successful if it satisfies any or all of these

criteria: It achieves the goals of its designers It attains widespread use in an application area It serves as a model for other languages that are successful When creating a new language, decide on an overall goal and keep it in mind

throughout the design process This is especially important for special purpose languages The abstractions for the target application area must be built into the language

design

What’s Current on Google Searches (trends)

20

21

Historical Overview (How current resources dictate design) In the early days, machines were extremely slow and memory was scarce

o Program speed and memory usage were prime concerns Efficiency of execution: primary design criterion

o Early FORTRAN code more or less directly mapped to machine code, minimizing the amount of translation required by the compiler

Writability: the quality of a language that enables a programmer to use it to express computation clearly, correctly, concisely, and quickly

In the early days, writability was less important than efficiency Algol60 was designed for expressing algorithms in a logically clear and

concise wayo Incorporated block structure, structured control statements, a more

structured array type, and recursion COBOL attempted to improve readability of programs by trying to make them

look like ordinary Englisho However, this made them long and verbose

In the 1970s and early 1980s, the emphasis was on simplicity and abstraction, along with reliabilityo Mathematical definitions for language constructs were introduced, along

with mechanisms to allow a translator to partially prove the correctness of a program before translation

o This led to strong data typing In the 1980s and 1990s, the emphasis was on logical or mathematical

precisiono This led to a renewed interest in functional languages

The most influential design criteria of the last 25 years is the object-oriented approach to abstractiono Led to the use of libraries and other object-oriented techniques to

increase reusability of existing code In addition to the early goals of efficiency, nearly every design decision still

considers readability, abstraction, and complexity control

22

Efficiency Efficiency: usually thought of as efficiency of the target code Example: strong data typing, enforced at compile time, means that the runtime

does not need to check the data types before executing operations Example: early FORTRAN required that all data declarations and subroutine

calls had to be known at compile time to allow the memory space to be allocated once at beginning of execution

Programmer efficiency: how quickly and easily can a person read and write in the programming language?

Expressiveness: how easy is it to express complex processes and structures? Conciseness of the syntax also contributes to programmer efficiency Example: Python does not require braces or semi-colons, only indentation and

the colon (:) Reliability of a program can be viewed as an efficiency issue Unreliable programs require programmer time to diagnose and correct Programmer efficiency is also impacted by the ease with which errors can be

found and corrected Since roughly 90% of time is spent on debugging and maintaining programs,

maintainability may be the most important index of programming language efficiency

23

Regularity Regularity: refers to how well the features of a language are integrated Greater regularity implies: Fewer restrictions on the use of particular constructs Fewer strange interactions between constructs Fewer surprises in general in the way the language features behave Languages that satisfy the criterion of regularity are said to adhere to the

principle of least astonishment Regularity can be subdivided into three concepts:

o Generality achieved by avoiding special cases in the availability or use of

constructs and by combining closely related constructs into a single more general one

o Orthogonal design constructs can be combined in any meaningful way, with no

unexpected restrictions or behaviorso Uniformity

a design in which similar things look similar and have similar meanings while different things look different

Can classify a feature or construct as irregular if it lacks one of these three qualities

Generality Generality: A language with this property avoids special cases wherever

possible Example: procedures and functions

o Pascal allows nesting of functions and procedures and passing of functions and procedures as parameters to other functions and procedures but does not allow them to be assigned to variables or stored in data structures

Example: operatorso C, cannot directly compare two structures with ==; thus, this operator

lacks In generality Example: constants

o Pascal does not allow the value assigned to constants to be computed by

24

expressions, while Ada has a completely general constant declaration facility

Orthogonality In a language that is truly orthogonal, constructs do not behave differently in

different contexts Restrictions that are context dependent are nonorthogonal, while restrictions

that apply regardless of context exhibit a lack of generality Example: function return types

o Pascal allows only scalar or pointer types as return valueso C and C++ allow values of all data types except array typeso Ada and Python allow all data types

Example: placement of variable declarationso C requires that local variables be defined only at the beginning of a

blocko C++ allows variable definitions at any point inside a block prior to use

Example: primitive and reference typeso In Java, primitive types use value semantics (values are copied during

assignment), while object types (or reference types) use reference semantics (assignment produces two references to the same object)

Orthogonality was a major design goal of Algol68o It is still the best example of a language in which constructs can be

combined in all meaningful ways

Uniformity Uniformity: refers to the consistency of appearance and behavior of language

constructs Example: extra semicolon

o C++ requires a semicolon after a class definition but forbids its use after a function definition

Example: using assignment to return a valueo Pascal uses the function name in an assignment statement to return the

function’s value Looks confusingly like a standard assignment statement

Other languages use a return statement25

Causes of Irregularities Many irregularities are case studies in the difficulties of language design Example: extra semicolon problem in C++ was a byproduct of the need to be

compatible with C Example: irregularity of primitive types and reference types in Java is the

result of the designer’s concern with efficiency It is possible to focus too much on a particular goal Example: Algol68 met its goals of generality and orthogonality, but this led to

a somewhat obscure and complex language

Security Reliability can be affected if restrictions are not imposed on certain features

o Pascal: pointers are restricted to reduce security problemso C: pointers are much less restricted and thus more prone to misuse and

erroro Java: pointers were eliminated altogether (they are implicit in object

allocation), but Java requires a more complicated runtime environment Security: closely related to reliability A language designed with security in mind:

o Discourages programming errorso Allows errors to be discovered and reported

Types, type-checking, and variable declarations resulted from a concern for security

Exclusive focus on security can compromise the expressiveness and conciseness of a languageo Typically forces the programmer to laboriously specify as many things

as possible in the code ML and Haskell are functional languages that attempt to be secure yet allow

for maximum expressiveness and generalityo They allow multityped objects, do not require declarations, and yet

perform static type-checking Semantically safe: languages that prevent a programmer from compiling or

executing any statements or expressions that violate the language definitiono Examples: Python, Lisp, Java

26

Extensibility Extensible language: a language that allows the user to add features to it Example: the ability to define new data types and new operations (functions or

procedures) Example: new releases that extend the built-in features of the language Very few languages allow additions to the syntax and semantics

o Lisp allows new syntax and semantics via a macro Macro: specifies the syntax of a piece of code that expands to other standard

code when compiled

C++: An Object-Oriented Extension of C (Example of Design)

created by Bjarne Stroustrup at Bell Labs in 1979-80 He chose to base his new language on C because of its:

o Flexibilityo Efficiencyo Availability o Portability

He chose to add the class construct from Simula67 language Design goals for C++:

o Support for good program development in the form of classes, inheritance, and strong type-checking

o Efficient execution on the order of C or BCPLo Highly portable, easily implemented, and easily interfaced with other

tools

C++: First Implementations First implementation in 1979-80 in the form of a preprocessor called Cpre,

which generated ordinary C code 1985: replaced the preprocessor with a more sophisticated compiler (which

still generated C code for portability)o Compiler was called Cfronto Language was now called C++

27

o Added dynamic binding of methods, type parameters, and general overloading

Design goals for C++:o Maintain C compatibility as far as practicalo Should undergo incremental development based firmly in practical

experienceo Any added feature must not degrade runtime efficiency or affect existing

programs negativelyo Should not force any one style of programmingo Should maintain and strengthen its type-checkingo Should be learnable in stageso Should maintain compatibility with other systems and languages

C++: Growth Cpre and Cfront were distributed for educational purposes at no cost, creating

interest in the language 1986: first commercial implementation Success of the language indicated that a concerted effort at creating a standard

language was necessary

C++: Standardization Because C++ was rapidly growing in use, was continuing to evolve, and had

several different implementations, standardization was a problem 1989: Stroustrup produced a reference manual 1990-1991: ANSI and ISO standards committees accepted the manual as the

base document for the standardization effort 1994: addition of a standard library of containers and algorithms 1998: proposed standards became the actual ANSI/ISO standard

C++: Retrospective Why was C++ a success?

o Introduced just as interest in object-oriented techniques was explodingo Straightforward syntax, not tied to any operating environmento Its semantics incurred no performance penaltyo Its flexibility, hybrid nature, and its designer’s willingness to extend its

28

features were popular Detractors consider C++ to have too many features and too many ways of

doing similar things

Python: A General-Purpose Scripting Language Guido van Rossum developed a translator and virtual machine for a scripting

language called Python in 1986 One of his goals was to allow Python to act as a bridge between system

languages such as C and shell or scripting languages such as Perl Included a dictionary, a set of key/value pairs implemented via hashing, that

was useful for representing collections of objects organized by content or association instead of by position

Python: Simplicity, Regularity, and Extensibility Design goals included:

o A simple regular syntaxo A set of powerful data types and librarieso Easy to use by novices

Python: Interactivity and Portability Python was designed for users who do not typically write large systems but

instead write short programso Development cycle provides immediate feedback with minimal

overhead for I/O operations Python can be run in two modes:

o Expressions or statements can be run in a Python shell for maximum interactivity

o Can be composed into longer scripts saved in files and run from a terminal command prompt

Design goal of portability was accomplished in two ways:o Python compiler translates source code to machine-independent byte

code, which is run on a Python virtual machine (PVM)o Application-specific libraries support programs that must access

databases, networks, the Web, GUI, and other resources and technologies

29

Python: Dynamic Typing vs. Finger Typing Python incorporates the dynamic typing mechanism found in Lisp and

Smalltalko All variables are untypedo Any variable can name any thing, but all things or values have a typeo Type-checking occurs at runtime

This results in less overhead for the programmero Less “finger typing”o Programmer can get a code segment up and running much faster

Python: Retrospective Python was not intended to replace C or C++ for large or time-critical systems Runtime type-checking is not suitable for time-critical applications The absence of static type-checking can be a liability in testing and

verification of a large software system Its design goal of ease of use for a novice or nonprogrammer has largely been

achieved

Terms you just sawTerm Mix and matchTermsFunctional LanguagesStrong Data typingRecursionBlock StructureMachine Code

http://blog.lib.umn.edu/hael0002/alternativemedia5413/2011/02/the-jacquard-loom.htmlSebestahttp://www.catb.org/retro/plankalkuel/http://www.hicest.com/

30

http://www.maths.uq.edu.au/~rbs/sgi/node14.htmlhttp://www.csis.ul.ie/cobol/examples/Accept/Shortest.htmhttp://home.cmit.net/rwolbeck/programmingtutorial/http://www.cs.sfu.ca/CourseCentral/310/pwfong/Lisp/1/tutorial1.html

31