Transcript Chapter 1

INTRODUCTION
"When the only tool you have is a hammer,
everything looks like a nail"
(Abraham Maslow)
Administrivia
•
•
•
•
This is me: Cyndi Rader
You can reach me: [email protected]
Or find me here: BB 280D
Class notes here:
http://eecs.mines.edu/Courses/csci400/
• Office Hours: 8-9:15 T/Th
and by appointment
Why study programming languages?
LUA
MEL
Others??

To enhance your ability to learn new languages

To allow you to choose an appropriate tool for a given task
Let’s see, should I use a scripting
language, do I need speed &
reliability, …

To gain an appreciation for the challenges involved in
implementing a language
What does that compiler message
mean?
Why did they design the language
that way???
Why study programming languages?


To expand your ability to express your ideas
(effectively) using a given language
To see some very different styles of
programming (e.g., Ruby, Haskell)

To avoid being a language zealot

Because it's fun!
Course Format
• Sage on stage vs Guide on side...
Course Evaluation
• 45% homework, projects
• 5% class participation
• 50% exams and quizzes
Programming Domains
• Scientific applications - Fortran
▫ Large number of floating point computations
▫ Efficiency (compete with assembly)
• Business applications - COBOL
▫ Produce reports, use decimal numbers and characters
• Artificial intelligence - LISP
▫ Symbols rather than numbers manipulated
▫ Linked structures rather than arrays
• Systems programming - C
▫ Need efficiency because of continuous use
▫ Need low-level features to interface with hardware
• Web Software
▫ Eclectic collection of languages: markup (e.g., XHTML), scripting
(e.g., PHP), general-purpose (e.g., Java)
Pick your tool – often depends on your domain…
Language Evaluation Criteria
What criteria would you use to
evaluate/choose a language?
Language Evaluation Criteria
• Writability: how easy is it to write a program?
• Readability: how easy is it to read a program?
• Reliability: does it include features that help to
produce more reliable software?
• Cost: what’s the ultimate cost?
Writeable and Readable
•
•
•
•
•
•
•
Simplicity
Support for abstraction
Control statements
Data types
Syntax
Orthogonality
Expressivity
What aspects of a language might make it easier to read than
write (or vice versa)?
Orthogonality
– A relatively small set of primitive constructs can
be combined in a relatively small number of ways
– Every possible combination is legal
– Changing one thing has no effect on another
• As stated by Michael Scott:
▫ Orthogonality means that features can be used in
any combination, the combinations all make
sense, and the meaning of a given feature is
consistent regardless of other features with
which it is combined.
261 example: arrays
Expressivity
Find something to share with the class – turn in for
attendance points
• http://gafter.blogspot.com/2007/03/on-expressive-power-ofprogramming.html
• http://redmonk.com/dberkholz/2013/03/25/programming-languagesranked-by-expressiveness/
• http://babel.ls.fi.upm.es/~jjmoreno/expre.html
• http://stackoverflow.com/questions/638881/what-does-expressive-meanwhen-referring-to-programming-languages
• http://en.wikipedia.org/wiki/Expressive_power
• http://mt4.radified.com/2009/08/expressive-power-computerprogramming-language-literature.html
Evaluation Criteria: Reliability
• Type checking
▫ Testing for type errors
• Exception handling
▫ Intercept run-time errors and take corrective measures
• Aliasing
▫ Presence of two or more distinct referencing methods for the
same memory location
• Readability and writability
▫ A language that does not support “natural” ways of expressing an
algorithm will necessarily use “unnatural” approaches, and
hence reduced reliability
What do you think of this (from http://expressivejava.com/):
“I know that some readers will be looking at this code and thinking
how unsafe it is. But what the hell – it fails fast, and in all the years
I’ve had map in my toolkit I’ve never once messed it up.”
1-14
Evaluation Criteria: Cost
• Training programmers to use language
• Writing programs (closeness to particular
applications)
• Compiling programs
• Executing programs
• Language implementation system: availability of
free compilers (Ada vs Java)
• Reliability: poor reliability leads to high costs
• Maintaining programs
How does this relate to programming languages?
1-15
Evaluation Criteria: Others
• Portability
▫ The ease with which programs can be moved from
one implementation to another
• Generality
▫ The applicability to a wide range of applications
• Well-definedness
▫ The completeness and precision of the language’s
official definition
Copyright © 2006 Addison-Wesley. All rights reserved.
1-16
Language Design Trade-Offs
• Reliability vs. cost of execution
▫ Conflicting criteria
▫ Example: Java demands all references to array elements be
checked for proper indexing but that leads to increased execution
costs
• Readability vs. writability
▫ Another conflicting criteria
▫ Example: APL provides many powerful operators (and a large
number of new symbols), allowing complex computations to be
written in a compact program but at the cost of poor readability
• Writability (flexibility) vs. reliability
▫ Another conflicting criteria
▫ Example: C++ pointers are powerful and very flexible but not
reliably used. Not included in Java.
1-17
Evaluation Criteria: the Players
• Language implementors: concerned with
difficulty of implementing constructs and
features
• Language users: worried about writability first,
readability later
• Language designers: likely to emphasize elegance
and ability to attract widespread use
▫ (on your own:
http://www.paulgraham.com/popular.html)
Copyright © 2006 Addison-Wesley. All rights reserved.
1-18
Influences on Language Design
• Computer Architecture
• Programming Methodologies
Copyright © 2006 Addison-Wesley. All rights reserved.
Computer Architecture Influence
• Well-known computer architecture: Von Neumann
• Imperative languages, most dominant, because of von
Neumann computers
▫
▫
▫
▫
Data and programs stored in memory
Memory is separate from CPU
Instructions and data are piped from memory to CPU
Basis for imperative languages
 Variables model memory cells
 Assignment statements model piping
 Iteration is efficient
John Von Neuman (1903-1957). Mathematician, influential in set theory, quantum mechanics, game
theory, self-replicating cellular automata, pseudo-random numbers and more. On faculty of Princeton
Institute for Advanced Studies with Einstein and Godel. VonNeumann architecture based on ENIAC.
Copyright © 2006 Addison-Wesley. All rights reserved.
1-20
Programming Methodologies Influences
• 1950s and early 1960s: Simple applications; worry about
machine efficiency
• Late 1960s: People efficiency became important;
readability, better control structures
▫ structured programming
▫ top-down design and step-wise refinement
• Late 1970s: Process-oriented to data-oriented
▫ data abstraction
• Middle 1980s: Object-oriented programming
▫ Data abstraction + inheritance + polymorphism
1-21
Language Categories
• Imperative/Procedural
▫ Central features are variables, assignment statements, and iteration
▫ Examples: C, Pascal, scripting languages such as Perl
• Functional
▫ Main means of making computations is by applying functions to given
parameters
▫ Examples: LISP, Scheme
• Logic
▫ Rule-based (rules are specified in no particular order)
▫ Example: Prolog, SQL
• Object-oriented
▫ Data abstraction, inheritance, late binding
▫ Examples: Java, C++, C#
• Markup
▫ New; not a programming language per se, but used to specify the layout
of information in Web documents
▫ Examples: XHTML, XML
What about CSS?
More Language Categories
• Stack Based
▫ Stack is central feature
▫ Examples: PostScript, Forth
• Prototype
▫ Use the object, not the class, as the basis for object
definition and inheritance
▫ Examples: Io, Lua, Self, JavaScript
1-23
Implementation Methods
• Compilation
• Pure Interpretation
• Hybrid Implementation Systems
Think like a compiler
• Scanner (lexical analyzer): identifies the tokens
of a program statement
• Parser (syntax analyzer): determines whether
the statement is valid, based on the language
definition/grammar
▫ int count = 20;
Tokens: Grammar:
Based on BNF
int
count
=
20
;
The Compilation Process
Compilation process has several phases:
• lexical analysis: converts characters in
the source program into lexical units
• syntax analysis: transforms lexical
units into parse trees which represent
the syntactic structure of program
• Semantics analysis: generate
intermediate code
• code generation: machine code is
generated
Slow translation, fast execution
Copyright © 2006
Addison-Wesley. All rights
reserved.
Additional Compilation Terminologies
• Load module (executable image): the user and
system code together
• Linking and loading: the process of
collecting system program and linking them to
user program
1-27
Pure Interpretation
• No translation
• Easier implementation of programs (run-time
errors can easily and immediately displayed)
• Slower execution (10 to 100 times slower than
compiled programs)
• Often requires more space
• Becoming rare on high-level languages
• Significant comeback with some Web scripting
languages (e.g., JavaScript)
1-28
Pure Interpretation Process
Copyright © 2006
Addison-Wesley. All rights
reserved.
1-29
Hybrid Implementation Systems
• A compromise between compilers and pure
interpreters
• A high-level language program is translated to
an intermediate language that allows easy
interpretation
• Faster than pure interpretation
• Examples
▫ Perl programs are partially compiled to detect errors before
interpretation
▫ Initial implementations of Java were hybrid; the intermediate
form, byte code, provides portability to any machine that has a
byte code interpreter and a run-time system (together, these are
called Java Virtual Machine)
1-30
Hybrid Implementation Process
Copyright © 2006
Addison-Wesley. All rights
reserved.
1-31
Just-in-Time Implementation Systems
• Initially translate programs to an intermediate
language
• Then compile intermediate language into
machine code
• Machine code version is kept for subsequent
calls
• JIT systems are widely used for Java programs
• .NET languages are implemented with a JIT
system
Copyright © 2006 Addison-Wesley. All rights reserved.
Orthogonality
Another Topic Exploration
▫ http://stackoverflow.com/questions/1527393/what-is-orthogonality
▫ http://stackoverflow.com/questions/3272019/is-java-orthogonal
▫ http://www.artima.com/intv/rubyP.html
1-33
Summary
• The study of programming languages is valuable for a
number of reasons:
▫ Increase our capacity to use different constructs
▫ Enable us to choose languages more intelligently
▫ Makes learning new languages easier
• Most important criteria for evaluating programming
languages include:
▫ Readability, writability, reliability, cost
• Major influences on language design have been machine
architecture and software development methodologies
• The major methods of implementing programming
languages are: compilation, pure interpretation, and
hybrid implementation
Copyright © 2006 Addison-Wesley. All rights reserved.