Programming Languages: Design, Specification, and Implementation

1
Programming LanguagesDesign, Specification, and
Implementation

• G22.2210-001
• Rob Strom
• October 26, 2006

2
Administrative

• Alternative mailing address for me
  robstrom_at_us.ibm.com
• Everyone should subscribe to the class mailing
  list http//www.cs.nyu.edu/mailman/listinfo/g22_2
  110_001_fa06
• Reading
• Ada, C generics
• Java http//java.sun.com/j2se/1.5/pdf/generics-tu
  torial.pdf
• Simple Homework (due next class)
• Polymorphism Project (due 2 weeks after simple
  homework) BUT START NOW!!!!
• Come to office hours for help!

3
Academic integrity

• Violation of any of the following rules
  constitutes cheating
• Students are to do all assignments individually,
  with no collaboration or sharing of work, unless
  the instructor explicitly permits collaboration.
  If one student shows or gives his/her work to
  another, then both students are considered to be
  cheating. Students may not use work provided by
  any person outside the class. Furthermore,
  students may not solicit other people to do
  assignments (in whole or in part) for them.
• When an instructor permits collaboration on an
  assignment, then collaboration is permitted only
  to the degree and in the respects that he/she
  specifies. Each assignment that is done
  collaboratively must state that it was done
  collaboratively and must list the collaborators.
• External sources, such as published materials or
  material on the Web, may be used in assignments
  only to the extent permitted by the instructor.
  If such a source is used, the assignment must
  include an attribution to the source. Ideas,
  algorithms, text, code, and experimental results
  all require proper attribution.
• A student may not submit the same assignment to
  two different classes, whether in the same
  semester or in different semesters, without the
  explicit permission of both instructors.
• During an exam, students must not communicate in
  any way, nor use any materials or technology not
  explicitly permitted by the instructor, other
  than pens and pencils. One student may not look
  at another student's test.
• A student may not attempt to gain possession of
  or look at an exam before the start of the exam.
• Students providing unauthorized information and
  those using it are cheating and are ALL subject
  to disciplinary action.Disciplinary actions can
  vary in severity and can result in probation or
  termination from the graduate program. The GSAS
  Policies and Procedures Manual, under "Topic 3
  Discipline" includes a complete outline of
  sanctions and procedures.Departmental policy is
  to give a grade of F in the course in which the
  cheating occurred. By the rules of GSAS, the
  penalty for a second offense is termination from
  the graduate program.

4
Small homework (next week)

• In C, Java, and Ada, first define a simple type
  Person, either as a record or as a class,
  containing Name, Address, and PhoneNumber. Then
  implement a container class that uses doubly
  linked lists to create a list of Person,
  supporting operations
• Insert add a person to the list at position (n)
• Position of return position of the person on the
  list (starting at 0 exception if not on the
  list)
• Get nth return a copy of the nth item (exception
  if no nth item)
• Remove nth remove the nth item (exception if no
  nth item)
• (In later homework, we will use generics to allow
  a single package to work with any type, not just
  Person).
• This homework verifies that you are familiar with
  defining new abstract classes that hide their
  implementation.

5
Polymorphic Programming Project (2 weeks)

• This project builds a system exploiting
  polymorphism. Choose one of the 3 languages C,
  Ada, or Java to do it.
• This system models a world composed of the
  following kinds of objects
• rooms they have doors to neighboring rooms, and
  access to factories
• factories (they create objects)
• solids (coins, keys, bags, pots), some of which
  are containers (bags, pots, jars)
• liquids (water, juice) must be in a container,
  can only be transferred with a funnel
• doors (they transfer solid objects from one room
  to a neighbor)
• funnels (they transfer liquids from one container
  to another)
• Objects have attributes (weight, mass), and
  different kinds enforce different restrictions.
• You manipulate things by repeatedly choosing a
  room, and giving it a script that can do any of
  these things in that room
• Ask factories in the room for things by name
  e.g., you can ask for 10 keys different
  factories might return different weight keys, or
  might return them in a bag inside a package, etc.
  
• You can ask containers whats inside them.
• You can remove solid things from inside
  containers you have in the room with you. You can
  insert solid things from the room into
  containers. A container will complain if its
  capacity is exceeded, or if you are trying to mix
  solids and liquids in the same container.
• You can transfer x amount of liquid from one
  container to another, by invoking a method on a
  funnel It will complain if there is too little
  liquid in the source container or if the
  receiving container doesnt accept that kind of
  liquid. Usually containers will not accept
  liquid if they are also holding solids.
• You can ship a container (and by implication,
  everything in it) from a room to a neighbor by
  invoking a method on one of the rooms doors.
• Use polymorphic programming to
• Configure a network of at least 5 rooms with
  doors between them, and different kinds of
  factories in each
• Design different kinds of solid objects,
  containers, and liquids, with different
  properties (at least 3 of each). Example pot1
  can hold solid up to 5 pounds or liquid up to 10
  ounces, but not both solid and liquid.
• Write a variety of scripts to obtain things from
  factories, extract their contents from
  containers, repackage them and ship them to
  neighboring rooms, and then go to the neighboring
  rooms and unpackage them again.

6
Programming Languages Core Exam

• Syntactic issues regular expressions,
  context-free grammars (CFG), BNF.
• Imperative languages program organization,
  control structures, exceptions
• 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.

7
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
• Implementations can extend other implementations,
  specifying only whats new or changed

Object-based
8
Inheritance

• 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

9
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 virtual, Java) normally the
  decision about which operation to invoke is made
  statically, UNLESS you explicitly ask Ada to do a
  run-time-based dispatch.

10
Run-time Dispatch in Ada

• A variable using dynamic dispatch is of type
  FOOCLASS or access FOOCLASS.
• 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.
• Dynamic dispatch variables provide true
  polymorphism
• Correspond to virtual member functions in C,
  and to methods in Java (which are virtual by
  default)

11
Yet another parameter passing style (Adas three
modes)

• in (default) the value must exist before the
  call, and the formal parameter will see the same
  value. The formal parameter is constant, and may
  not be changed (same as call by value)
• in out the value must exist before the call, and
  the formal will see the same value. The formal
  may be changed any changes to the value will be
  reflected back to the caller (call by
  value/result)
• out the value at the time of the call is
  ignored it is undefined within the called
  procedure. The formal must be assigned a value,
  which will be reflected back to the caller.
• Strangely, the manual defines certain types as
  reference and others as by value types. However,
  provided aliasing is forbidden, and constancy of
  in parameters is enforced, the implementation can
  pass by copy, reference, or value-result.

12
Limited Ada

• It means that there is no copying or assignment
  permitted
• A private type may be limited, while its record
  representation is not
• Example uses
• File descriptor you can get a new one from the
  file system with OPEN, but you shouldnt be able
  to just copy it around

13
Initialization and finalization - Ada

• Ada does not have constructors.
• (But of course you can call a factory method that
  will return either an initialized abstract object
  or a reference to one)
• You can also build a child derived from
  CONTROLLED or LIMITED_CONTROLLED
• It will invoke INITIALIZE each time an object is
  created FINALIZE when it is destroyed ADJUST
  when it is assigned
• Important for
• Initialization needs to make external calls (e.g.
  to acquire resources like files)
• Finalization needs to do more than just throw
  away the state of the object (e.g. to release
  resources like files)
• Copying needs to create resources other than an
  exact copy of the original e.g. deep copies
  that lack aliasing.

14
Object-orientation in C

• Objects can be created on stack or on heap (like
  Ada, unlike Java). But those allocated on stack
  use implicit constructors. Those on heap can use
  explicit constructor new Mytype(parm), which
  can have parameters
• Heap objects must be explicitly freed with delete
  (unchecked that or a copy of the reference still
  exists). Arrays must be freed with special array
  syntax.
• You can separately control the storage
  allocator/deallocator, the constructor/destructors
  
• Polymorphic (dynamic) dispatch depends upon
  whether the member function is virtual or not (as
  opposed to Ada, where it depends upon what type
  of object was used to perform the dispatch, or
  Java, where it is always dynamic)
• Classes are like structs, but with member
  functions defined within the class. Like Java,
  but unlike Ada, which defines them within the
  package.
• Everything within the Ada package is a friend
  C explicitly defines who is a friend Java
  defines what has package visibility as opposed to
  public, private, or protected. Only tagged Ada
  private types support inheritance.
• C allows multiple inheritance (Ada and Java
  dont.)
• Issues overlapping operations on objects,
  ambiguous up-casting
• All polymorphism is based upon class hierarchies
  (as with Ada).

15
Object-Orientation in Java

• Objects can be created only on the heap. There
  can be multiple constructor forms per class.
• Freeing is only done with garbage collection
  destructors (called finalize methods are called
  when objects are freed.
• Objects can share information in multiple new
  ways
• Class variables are shared by each object of the
  class
• Instances of non-static nested classes share the
  instance variables of the nesting classes
• All methods are virtual that is, the code that
  is executed is based on the run-time class of the
  object on which the method is invoked, not on the
  compile-time type of the reference
• Instance variables are private (accessible only
  from within the class but possibly from other
  instances of the class!!!), protected (accessible
  only from within the class or a subclass),
  package (accessible from anywhere in the package
  containing the class), or public (accessible from
  anywhere an instance is accessible)
• A reference can have interface type rather than
  class type. Each class can explicitly support
  multiple interfaces totally independently of its
  implementation. Calls via interfaces exhibit
  unconstrained polymorphism.

16
Exceptions

• Builtin, e.g.
• Running out of memory
• Division by zero
• User-defined, e.g.
• NoSuchEntry
• BufferFull
• Raising an exception causes a block or procedure
  to abnormally terminate, and to signal the
  particular exception (possibly with a message)
• A containing block or caller in the dynamic chain
  will catch the exception and either take
  alternative action or reraise it
• Differences Ada-C exceptions not on
  interfaces, Java puts them on interfaces, except
  RuntimeExceptions Ada exceptions are not
  objects. Java try-finally block to allow contexts
  to do context-specific finalization
• Advantages
• If a function is supposed to return something, or
  a procedure is supposed to initialize or modify
  something, and it doesnt do it, it should not be
  able to return to a context where it is assumed
  it has done its job.
• Simply returning a return code is not enough,
  because programmers will forget to check it.