Æliens

Smalltalk

• literal -- constants
• object -- action by messages
• class -- collection of protocols
• protocol -- related methods
• category -- collection of classes

• number -- 1, 34.6, 8r24
• character -- $a, $b, ...
• string -- "this is a string"
• symbol -- #Float
• byte array -- # [0 255 2 7]
• array of literals -- # (12.1 # ($a $b))

• $aVar\; :=\; 1.$

• temporary, instance, class, pool, global

Block expressions

• $[\; :arg\; |\; expression\; ]$

Keyword methods

    (i <= 7) 
          ifTrue: [ m:= "oke" ]
          ifFalse: [ ... ]
  

• instance variables, methods

• super for ancestors

  Model subclass: #Ctr 
   Model  
    ...
    initialize
      value := 0.
      TV open: self.
    ...
    add: anInt  
      value := value + anInt.
      self changed: #value.
  

  View subclass: #TV 
   View  
  instanceVariableNames: ''
  TV methodsFor: 'updating'
  update: aValue
       Transcript show: 'ok'; cr .
  TV class
  instanceVariableNames: ''
  TV class methodsFor: 'instance creation'
       open: aCtr
  	self new model: aCtr
  

A

• design principles -- prototyping
• terminology -- object, class, protocols
• syntax -- method expressions
• objects -- self reference
• inheritance -- class hierarchy
• techniques -- MVC paradigm

• class -- a model for a set of objects
• feature -- attribute, function, procedure
• export -- interface declaration
• inherit -- class inclusion and subtyping (!)
• redefine, rename -- to change inherited features
• deferred -- to postpone the implementation
• require, ensure, invariant -- assertions

• branching -- if ... then ... elsif ... else ... end
• iterations -- from ... until ... loop ... end

    class  counter  export  inc val  feature 
   count : Integer
   create  is do  count := 0  end 
   inc( n : Integer )  is 
  	 require  n > 0  do 
  	count := count + n
  	 ensure  count =  old  count + n
  	 end 
   val : Integer  is do   Result  := count  end 
    invariant  count >= 0
    end  -- class counter
  

B

• design principles -- correctness
• terminology -- keywords
• syntax -- type conformance, control
• objects -- counter example
• inheritance -- renaming, redefining

name -- denotes an object, a function, set of functions, enumerator, type, class member, template, a value or a label

• introduced by a declaration,
• used within a scope, and
• has a type which determines its use.

object -- region of storage

• a named object has a storage class that determines its lifetime, and
• the meaning of the values found in an object is determined by the type of the expression used to access it

• basic types -- int, char, float, ...
• array -- int $ar[SIZE]$
• function -- void $f(int)$
• pointer -- $int*\; ,\; char*,\; void\; (*f)(int)$
• reference --
• class, union, struct -- user-defined

• conditional -- $if\; (b)\; S1;\; else\; S2;$
• selection -- $switch(n)\; \{\; case\; n1:\; S1;\; break;\; ...\; default:\; ...\; \}$
• iteration -- $while\; (b)\; S$
• looping --
• jumps -- return, break, continue, goto

• templates -- template<class T> class C { ... }
• overloading -- void read(int); void read(float)
• friends -- to bypass protection
• type conversions -- by class constructors or type operators
• type coercion -- by explicit casts (is dangerous)
• smart pointers -- by overloading de-reference

  class ctr { 
   C++  
  public:
  ctr(int i = 0, char* x = "ctr") { 
  	n = i; strcpy(s,x); 
  	}
  ctr& operator++(int) { n++; return *this; }
  int operator()() { return n; }
  operator int()   { return n; }
  operator char*() { return s; }
  private:
  int n; char s[64];
  };
  

  ctr c; cout << (char*) c++ << "=" << c();
  

C

• design principles -- efficiency
• terminology -- object, type
• syntax -- object, reference, pointer
• objects -- abstract data types
• inheritance -- virtual functions
• techniques -- operators, templates, overloading

• basic types -- int, char, float, ...
• Array -- int $ar[SIZE]$
• String -- $String[]\; args$
• class -- user-defined

• conditional -- $if\; (b)\; S1;\; else\; S2;$
• selection -- $switch(n)\; \{\; case\; n1:\; S1;\; break;\; ...\; default:\; ...\; \}$
• iteration -- $while\; (b)\; S$
• looping --
• jumps -- return, break, continue

  
  public class HelloWorld {
  public static void main(String[] args) {
         System.out.println("Hello World");
         }
  };
  

  import java.awt.Graphics; 
  public class HelloWorld extends java.applet.Applet { 
  
  public void init() { resize(150,50); } 
  
  public void paint(Graphics g) { 
         g.drawString("Hello, World!", 50, 25); 
         } 
  }; 
  

• applets -- extend your browser
• servlets -- extend your server
• networking -- urls, sockets
• RMI -- remote method invocation
• reflection -- meta-information
• beans -- component technology
• JNI -- writing native methods
• javadoc -- online class documentation

D

• design principles -- safety
• terminology -- object, interface
• syntax -- like C++
• objects -- abstract data types, interfaces
• inheritance -- single inheritance
• techniques -- dynamic casts, reflection, APIs

DLP

  object name {
  var variables.
  
  constructor clauses
  method clauses
  }
  

Prolog

• constants -- a, "a string", $[\; ]$
• variables -- $X,Y,Z$
• compound -- $f(a,X)$, $[\; H\; |\; T\; ]$

Unification -- bi-directional parameter passing

• $f(X,a)\; =\; f(b,Y)$ results in $X\; =\; b$ and $Y\; =\; a$

DLP

• $v\; :=\; t$ -- to assign to non-logical variables
• $O\; =\; new(c(t))$ -- to create an active instance of the object c
• $O!m(t)$ -- to call the method $m(t)$ for the object O
• $accept(m1,...,m\_n)$ -- to accept method requests

  object agency : travel { 
   agency  
  agency() :- accept( any ), agency().
  book(X,Y) :-
  	reachable(X),
  	price(X,Y).
  price(amsterdam,5).
   ...
  }
  

• meta programming
• active intelligent agents

E

• design principles -- logic
• terminology -- distributed backtracking
• syntax -- Prolog + additional statements
• objects -- non-logical instance variables
• inheritance -- static
• techniques -- active intelligent agents

  module universe { 
   universe  
  
  interface world {
      	void hello();
  
  	void ask(in string x);
  	string tell();
  
  	oneway void halt();
  	};
  };
  
  

• integers, reals, booleans, enum, string, any

• struct, union, sequence, array, interface

• interface + operations

• in, out, inout -- parameter attributes

  exception out_of_range { long count; }
  
  interface writer {
    void position(in long pos) raises(out_of_range);
    }
  

Interfaces and inheritance

• no overriding, no overloading

Multiple (interface) inheritance

>
  interface A {  };
  interface B {  };
  interface C : A { };
  interface D : B, A { };
  

• types, references, access, ORB and BOA support

  interface Object { 
   PIDL   
  	InterfaceDef get_interface();
  	Object duplicate();
  	...
  }
  

H

• platform-independent
• language-independent
• server -- C++, Java, Prolog, ...
• client -- C++, Java, Prolog, ...
• 9 combinations -- test.sh

• broker -- access to ORB and BOA
• client -- needs ORB only
• server -- needs access to BOA
• implementation -- world-srv.h world-srv.c

C++ broker -- class

  class broker { 
   broker.h  
  public:
  
  broker();
  void init(int& argc, char**& argv, int fl=0); // 1 = client
  int operator()(); // to run the server
  
  char* ref(corba::object* x);  // object_to_string
  corba::object* ref(const char* s); // string_to object
  
  corba::object* object(const char* file); // get object IOR file
  void refout(const char* f, corba::object* x); // IOR to file
  };
  

C++ broker -- implementation

  broker::broker() { }  
   broker.c  
  
  void broker::init(int& argc, char**& argv, int fl=0) {
     _orb = CORBA_ORB_init(argc, argv);
     if (!fl) _boa = _orb -> BOA_init(argc, argv);
     }
  }
  
  int broker::operator()() {
     _boa -> impl_is_ready(CORBA_ImplementationDef::_nil());
     }
  

C++ server

  int main(int argc, char* argv[], char*[]) 
  server.c  
  {
      broker* _broker = new broker(); // get yourself a broker 
  
      try
      {
  	_broker->init(argc,argv); // initialize orb and boa
  	universe_world_var p = new universe_world_srv; 
  	_broker->refout("world.ref", p); // write identity
  	_broker->operator()(); // run the the world
      }
      catch(corba::exception& ex) { ... }
  }
  

C++ world implementation

  void universe_world_srv::hello() {  
  world_srv.c  
      	cout << "Hello World!" << endl;
  	}
  void universe_world_srv::ask(const char* s) {
      	cout << "Asking: " << s << endl;
  	}
  char* universe_world_srv::tell() {
  	char result[] = "ok";
  	CORBA_String_var s = (const char*) result; 
  	return s._retn();
  	}
  void  universe_world_srv::halt() {
  	exit(0);
  	}
  

• broker -- contact ORB and BOA
• client -- connect to server
• server -- announce server object
• implementation -- world_srv.java

• broker -- mediating service
• client -- get object reference
• server -- provide implementation
• implementation -- universe.pl

  :- [broker]. 
   server.pl   
  
  main :-
  	broker(server(universe:world)).
  
  

Prolog -- implementation

  :- module('universe',[]). 
   universe.pl  
  
  
  world_hello(_Self) :-
  	write('Hello World'),nl.
  
  world_ask(_Self, X) :-
  	write(asking(X)), nl.
  
  world_tell(_Self,Y) :-
  	Y = 'logically, ok',
  	write(telling(Y)),nl.
  
  world_halt(_Self) :-
  	halt.
  

• Makefile
• corba.cfg
• test.sh

Conclusions

• CORBA is ripe to be exploited in OO -- the practicum
• the broker is a useful abstraction
• forget about the wiring - concentrate on application logic

Software development projects

I

• gambling machine
• interactive video game

 [Coplien92]



• simple hypermedia system

 [Meyro86]



• direct manipulation score editor

 [Pope91]



• an object-oriented expert system

 [Hu89]



• 3D animation editor

 [Ammeraal]



• a simple case tool

 [CY91b]



• route planner