Object-oriented programming languages


Additional keywords and phrases: programming languages, orthogonality, reliability, complexity, types, delegation, multiple paradigms, prototypes, reflection

slide: Object-oriented programming languages


The notion of object -- Simula

slide: The heritage of Simula





slide: Perspectives of object orientation

Objects -- language characteristics

  • object creation facility
  • message-passing capability
  • class capability
  • inheritance features


  • hybrid -- C, Lisp, Pascal, Prolog
  • frame-based -- knowledge-based reasoning
  • distributed, concurrent, actor -- parallel computing
  • alternative object models -- prototypes, delegation

slide: A classification of languages

Object extensions

Commercial products -- languages

slide: Object-oriented languages

class and struct">

Object structure -- efficient mapping


  struct A { ... }  ==  class   A { public: ...  } 
  class   A { ... }  ==  struct A { private: ... } 

slide: The equivalence between

Script languages

Java embedding

slide: Script languages

  <script language=Javascript> 
function object_display(msg) { // object method return msg + ' (' + this.variable++ + ')'; } function object() { // object constructor this.variable=0; this.display = object_display; return this; } var a = new object(); // create object document.write(a.display("a message")); document.write(a.display("another message")); </script>


Criteria for comparison

slide: Criteria for comparison

Language characteristics

slide: Language characteristics


Object-oriented language design

  • object: state + operations
  • class: template for object creation
  • inheritance: super/base and subclasses

  object-oriented = 
        objects + classes + inheritance 

data abstraction -- state accessible by operations

strong typing -- compile time checking

slide: Object-based versus object-oriented

Orthogonal approach

slide: Orthogonal dimensions

Open systems

  • reactive -- flexible (dynamic) choice of actions
  • modular -- (static) scalability

Dimensions of modularity

  • encapsulation boundary -- interface to client
  • distribution boundary -- visibility from within objects
  • concurrency boundary -- threads per object, synchronization

slide: Dimensions of modularity

Object-based concurrency

slide: Objects and concurrency


  active class S { 
     m () { ... } 
     @S () {  // pseudo-constructor
           select { 
              01 -> m(); // external call 
              instructions ...
              accept m;  // accept internal method
              instructions ... 
              waituntil (date); // time-out
              instructions ... 
              default           // default
              instructions ... 

slide: Synchronization conditions in sC++


Prototypes -- exemplars

slide: Prototypes


  • slots -- parents
  • variables and methods


  • shallow cloning
  • deep cloning


  • implicit delegation
  • explicit delegation

slide: Prototypes -- state, creation, delegation

Improving performance

slide: Improving performance

Self -- prototypes

Dynamic compilation -- type information

slide: Dynamic compilation -- Self

The class concept

slide: The concept of class

slide: Meta architectures

Postulates -- class-based languages

slide: Class-based languages -- postulates


Reflective definition of Class

   name         Class
   supers      (Object)
   iv     (name supers iv methods)
   methods      (new ...)

slide: A reflective definition of

The object paradigm


slide: Section 5.1: The object paradigm

Comparing Smalltalk, Eiffel, C++ and Java


slide: Section 5.2: Comparing Smalltalk, Eiffel, C++ and Java

Design dimensions of object-oriented languages


slide: Section 5.3: Design dimensions of object-oriented languages

Prototypes -- delegation versus inheritance


slide: Section 5.4: Prototypes -- delegation versus inheritance

Meta-level architectures


slide: Section 5.5: Meta-level architectures

  1. What are the basic characteristics of object-oriented languages?
  2. How would you classify object-oriented languages? Name a few representatives of each category.
  3. What do you consider to be the major characteristic of the object model supported by C++? Explain.
  4. Why would you need friends?
  5. How would you characterize the difference between object-based and object-oriented?
  6. Along what orthogonal dimensions would you design an object-oriented language? Explain.
  7. Give a characterisation of active objects. In what situations may active objects be advantageous?
  8. How would you characterize prototype-based languages?
  9. What are the differences between inheritance and delegation? Does C++ support delegation? Explain. And Java?
  10. How would you characterize the concept of a class?
  11. Can you sketch the meta architecture of Smalltalk?
  12. How would you phrase the postulates underlying class-based languages? Can you give a reflective version of these postulates?

A concise treatment of programming languages is given in  [BG94]. For a collection of papers on object-oriented concepts, see  [KL89]. Further, you may want to consult  [Wegner87], which contains the original presentation of the discussion concerning the distinction between {\em object-based} and {\em object-oriented}. Concurrency is studied in  [AWY93]. For Java, read the original white paper,  [Java]. An interesting extension of C++ is described in  [Petitpierre98]. At the corresponding web site, ltiwww.epfl.ch/sCxx , there is much additional material. Finally, for an account of the design and evolution of C++, read  [Stroustrup97]. For more information on C++, visit www.accu.org , and for Java, www.javasoft.com .