•
•
•
How to execute
Program structure
Variables
•
•
•
• name, keywords, binding, scope,
• Threads
• Reflection
• Libraries
lifetime
•
Data types
–
–
–
–
•
type system
primitives, strings, arrays, hashes
pointers/references
type conversions and equality
short-circuiting, conditional
expression
– Referential transparency
– Statements vs Expressions
•
Control flow
– conditionals
– loops
•
•
Functional Language – other
aspects, covered later
•
QUICK EX: With a partner
Expressions
– Operators, overloading, booleans,
Functions
Classes
Exception handling
Other features
• how do you learn a new
programming language?
• What types of programs do you
write?
A
binding is an association, such as:
• bind type of variable
• bind operation to symbol (e.g., meaning of *)
• bind function to its definition
 Binding
time is the time at which a
binding takes place.
 Type binding
• may be static or dynamic
• explicit or implicit






Language design time -- bind operator symbols to operations :
sum = sum + count
Language implementation time-- bind type to a representation :
int => number of bits, etc.
Compile time -- bind a variable to a type: int count;
Link time – bind library subprogram to code: cout << x;
Load time -- bind a FORTRAN 77 variable to a memory cell (or a
C static variable)
Runtime -- bind a nonstatic local variable to a memory cell
A
binding is static if it first occurs before run
time and remains unchanged throughout
program execution.
 A binding is dynamic if it first occurs during
execution or can change during execution of the
program
 NOTE: doesn't
consider paging etc. which is at
the hardware level
This distinction may apply to:
 variable typing
 variable lifetime
 variable scope
 polymorphism
• overloaded operators vs late binding
Static is also used to identify class vs
instance variables – not really a static vs
dynamic example
 Type
not specified by declaration, not
determined by name (JavaScript, PHP, Ruby)
 Specified through an assignment statement
list = [2, 4.33, 6, 8];
list = 17.3;
• Advantage: flexibility (generic program units)
• Disadvantages:
 High cost (dynamic type checking requires run-time
descriptors, normally interpreted… upcoming discussion)
 Type error detection by the compiler is difficult
How are generic program units done in C++? Java?
 How
would dynamic types be
implemented? What data structure(s)
would you use? How does this impact
your code – consider efficiency,
reliability.
 Now think about challenges with +
•
•
•
•
total = 3 + 5
message = “hello” + “ world”
something = “count “ + 3 + 5
other = 3 + “count”
i = x; // desired, x is scalar
i = y; // typed accidentally, y is array
 Definitions not precise
 In general, a strongly typed
language will
generate a compiler error if the value used
(e.g., passed to a function, assigned to a
variable) does not match the expected type
 May also be considered strongly typed if
type errors are prevented at runtime due to
dynamic typing (so type safety is more
important for reliability)
 A language may be considered weakly
typed if it includes features that allow types
to be used interchangeably
https://en.wikipedia.org/wiki/Strong_and_weak_typing
 Implicit
type conversions
• A language with more implicit conversions is
considered less strongly typed
• C supports more implicit conversions than Java,
for example
 Pointers*
 Untagged
unions*
* covered later

Widening Conversions: can include at least approximations to all of the
values of the original type. Examples (Java/C++)
• byte to short, int, long, float or double
• short to int, long, float or double
• char to int, long, float or double
• int to long, float or double
• long to float or double
• float to double

Narrowing conversions: cannot include all of the values of the original type
• short to byte or char
• char to byte or short
• int to byte, short, or char
• long to byte, short, char or int
• float to byte, short, char, int or long
• double to byte, short, char, int, long or float
 Even
widening conversions may lose
accuracy. Example: integers stored in 32
bits, 9 digits of precision. Floating point
values also stored in 32 bits, only about 7
digits of precision (because of space
used for exponent).
Conversions should be used with care! Warnings should
not just be ignored…
Strongly typed language minimizes type conversions
 Type
safety is the extent to which a
programming language discourages or
prevents type errors
 A type error is erroneous or undesirable
program behavior caused by a discrepancy
between differing data types (e.g., trying to
perform an operation that is not valid for
that type)
 Type enforcement can be static (compile
time) or dynamic (run-time)
https://en.wikipedia.org/wiki/Type_safety
 Explicit
– stated by programmer
 Implicit – determined by language
 Can be applied to:
• type declaration
• variable lifetime






An explicit declaration is a program statement used for
declaring the types of variables: int count;
An implicit declaration is a default mechanism for
specifying types of variables (the first appearance of
the variable in the program)
Both create static bindings to types (i.e., type doesn’t
change during execution of program)
FORTRAN, PL/I, BASIC, and Perl provide implicit
declarations
• Advantage: writability
• Disadvantage: reliability
Perl: @ is array, % is hash, $ is scalar
Fortran: I-N integer, others single precision, can
override
many words have special meaning (e.g. if, true, def,
etc.)
 Keyword: has special meaning in particular
context, but can be used as variable name

• Algol, PL/I, Fortran

Reserved: can’t be used as variable
• COBOL has ~400, Java has ~50
• Ruby has reserved words (evolving, no fixed number)
• Advantage: may avoid confusion
• Disadvantage: may need to be aware of language parts
you aren’t even using
Compare to Java/C++
 In
Fortran, this is potentially valid:
• if if then then else else
 In
Java, goto is a reserved word (you
can’t use) but not a keyword (language
doesn’t use)
 Functions in libraries are not keywords
OR reserved words
http://stackoverflow.com/questions/1078908/what-is-the-difference-between-keyword-and-reserved-word
<!DOCTYPE html>
<html>
<body>
<pre>
<script>
function bark() {};
bark.prototype.alert = "woof";
bark.prototype.alertOwner =
function(){return this.alert};
var myDog = new bark();
alert(myDog.alert);
// displays dialog saying woof
</script>
</pre>
</body>
</html>
 Read

this:
http://www.u.arizona.edu/~rubinson/copyright_violations/Go_To_Considered_Harmful.html
 Why
are goto statements harmful??
Turn in brief explanation for participation