Transcript Programming Languages: Design, Specification, and Implementation G22.2210-001 Rob Strom October 19, 2006 Administrative   Alternative mailing address for me: [email protected] Everyone should subscribe to the class mailing list: http://www.cs.nyu.edu/mailman/listinfo/g22_2110_001_fa06  Reading: •

Programming Languages:
Design, Specification, and
Implementation
G22.2210-001
Rob Strom
October 19, 2006
Administrative


Alternative mailing address for me: [email protected]
Everyone should subscribe to the class mailing list:
http://www.cs.nyu.edu/mailman/listinfo/g22_2110_001_fa06

Reading:
• Ada http://burks.bton.ac.uk/burks/language/ada/ada95.pdf
•
•

sections 6,10 (classes and inheritance)
Alternative C++ book: Lippman & Lajoie “C++ Primer”
(Addison Wesley); ch 13, 14 (classes, initializers and
finalizers)
Java (http://java.sun.com/docs/books/jls/) 8 (classes)
Course Evaluations: During the break, please spend 5
minutes filling out the evaluation form. At the end of that
time, collect forms and deliver them to Room 405.
Programming Languages Core
Exam











Syntactic issues: regular expressions, context-free grammars (CFG), BNF.
Imperative languages: program organization, control structures.
Types in imperative languages: strong typing, type equivalence, unions and
discriminated types in C and Ada.
Block structure, visibility and scoping issues, parameter passing.
Systems programming and weak typing: exposing machine characteristics, type
coercion, pointers & arrays in C.
Run-time organization of block-structured languages: static scoping, activation
records, dynamic and static chains, displays.
Programming in the large: abstract data types, modules, packages and namespaces
in Ada, Java, and C++.
Functional programming: list structures, higher order functions, lambda expressions,
garbage collection, metainterpreters in Lisp and Scheme. Type inference and ML.
Object-Oriented programming: classes, inheritance, polymorphism, dynamic
dispatching. Constructors, destructors and multiple inheritance in C++, interfaces in
Java.
Generic programming: parametrized units and classes in C++, Ada and Java.
Concurrent programming: threads and tasks, communication, race conditions and
deadlocks, protected methods and types in Ada and Java.
Classes of Types, continued





Functions/procedures, including closures
•
Type signature includes parameter/result types
Pointers/References
•
•
•
Type defines type of target
In C++, a reference is a bound-once alias
In C/C++, a pointer p supports p+i, meaning go to the i-th
instance of the object of the type p points to.
Object Abstractions (OOLs)
•
Type determines sets of operations (methods)
Tasks (Ada)
Special (files, etc.)
Issues with Pointers




Stacks are deallocated on exit
Heaps are not.
In some languages (Pascal, C++), you can explicitly free objects. This can lead
to dangling references.
If you can make pointers to the stack, you can still get dangling references
unless you have a rule, such as:
•
•




Algol 68: Pointers may not point to an object whose lifetime is shorter than that of the pointer.
Ada 95: Pointers may not point to an object whose lifetime is shorter than that the of the pointer’s
type.
Otherwise, to be safe, you must retain objects until they’re guaranteed
unusable.
If you can copy pointers, then any heap object or any stack object to which a
pointer was ever made could be aliased.
Ada has a control: Non-references can’t be made into references unless the
“aliased” attribute is specified
Aliasing makes simple invariant analysis more complicated
•
•
•
Does a procedure change X because it changes Y, an alias of X?
Does a procedure change X because it holds an alias of X?
Does a concurrent task hold an alias to X and hence potentially always change X?
Avoiding dangling references

Tombstones:

Key/lock
• Extra level of indirection
• Nulled out when object deallocated
• Advantage: object can be dynamically moved
• Disadvantages: speed, can’t collect tombstone
• Each pointer has address + key
• Each pointed to object has matching lock
Automatic Reclamation
techniques




Reference counting
•
Problem: circular garbage
Mark and sweep garbage collection
•
•
•
•
Initially, every allocated block is “suspected garbage”
Each reachable block is labelled “non-garbage”
Finally, every suspected garbage block is collected
Variations: stop-and-copy, generational
Both require that we know:
•
•
•
where all the pointers are and
when they’re initialized
the extents of allocated memory
Hybrid techniques
•
Rely on the fact that
•
•
References to some blocks are isolated within some region, and
Some regions are not aliased
Object-Oriented Concepts

Encapsulation (Information Hiding)
•


User of an “object” need only know the interface to the
object: i.e. the operations supported on it, not the
implementation
The implementation can be specified separately
Polymorphism
•
Different instances of an object could have different
implementations, so long as they all obeyed the same
interface
Inheritance
•
Object-based
•
Implementations can extend other implementations,
specifying only what’s new or changed
Ada: Packages and Private
types
Package P is
type abs is [limited] private; -- this is what users know
procedure method1(a: in out abs);
procedure method2(b: in out abs, c: INTEGER)
private
type abs is record – this is what implementer knows
i1: t1;
i2: t2;
end record;
end P;
Package body P is … -- implementation of methods
Data Abstraction in Ada






Information hiding by packages
No special role of the object
All functions in the package are “friends”, in that they can
access the private data of any types defined in the
package
Need not be allocated by reference (good thing!)
Note, that the private part of the package must be
available at compile time where it’s used
Hides the implementation, but does not by itself provide
polymorphism. That is, all objects of type abs have not
only the same interface, but also the same
implementation
Inheritance in Ada

Interface inheritance:
• A subclass has all of the methods of its parent
class, and possibly more

Implementation inheritance:
• A subclass has all of the data components of
•
the parent, and possibly more
A subclass may have different
implementations of some of the methods of
the parent class
Inheritance in Ada
Private types that can be subclassed (inherited
from) are called “tagged”. They are extensible
records
type person is tagged …
type president is new person with …
Derived types can either inherit operations or can
over-ride (redefine) them
BUT (unlike C++, Java) normally the decision
about which operation to invoke is made
statically, UNLESS you explicitly ask Ada to do
a run-time-based dispatch.
Run-time Dispatch in Ada




A variable using dynamic dispatch is of type
FOO’CLASS or access FOO’CLASS.
This means it will use the run-time type
(implemented in the tag) to determine which type
to use when dispatching a call.
This is only usable for methods (so-called
“primitive” operations) for types.
No primitive operations can have operands of
mixed types.