Æliens

Component technology

6

• objects versus components -- definitions
• interoperability
• requirements for distribution
• a simple workgroup application
• extending hush with CORBA

Additional keywords and phrases: (D)COM, Java, CORBA, OLE, persistent objects, ODMG, workgroup

Components: myths and reality

• component-ware allows for combining components

if semantical issues can be resolved

• component-ware simplifies software distribution and maintenance

development becomes more complex

• component-ware supports mega applications

it affects performance significantly

• component-ware is a revolution

wrong, it is an evolution from OO and C/S

unknown source

Object Services

• life cycle -- creation and deletion
• persistence -- management of object storage
• naming -- mapping names to references
• event notification -- registration of events

• transactions, concurrency, relationships, ... ,time

object model

• the programmer feels that there is one language

Language binding

C++ODL/OML

• objects and literals -- embedded objects are literals
• relationships -- not directly supported by C++
• extents -- must be maintained by programmer
• keys -- simulated by C++ data members

C++ODL/OML binding -- future

• no distinction between persistent and transient objects
• better integration of the query sublanguage

• overloading dot (access operator), r/l values, ...

Standardization efforts -- de facto market share

• PDES/STEP, ODA, PCTE, OSI/NMF, ISO ODP, ANSI X3

• Internet applications -- the dial-tone of the Internet
• Software engineering -- long-term maintenance
• Language design -- semantic compromises
• System development -- lightweight clients, heavyweight servers
• Computer science -- towards declarative, verifiable technology
• IT (in) business -- standards for business objects and processes
• Global village -- virtual world technology

• the legacy problem -- granularity of wrappers
• object creation and access -- factories and tables
• client-side adaptors -- to fit within native type system
• events versus objects -- natural interfaces

  interface handler { 
   handler  
          event dispatch( in event data );
  	};
  

  interface event : handler { 
   event  
  
  	attribute long type;
  
  	attribute long x;
  	attribute long y;
  	};
  

  interface kit : handler { 
   kit  
  
  	void source(in string file);
  	void eval(in string command);
  	string result();
  
  	widget root();
  	};
  

  interface widget : handler { 
   widget  
  
     string path();
  
     void eval( in string cmd );
  
     void configure( in string options );
     void pack( in string options );
  };
  

  interface item : handler { 
   item  
  
          void move( in long x, in long y );
  	};
  

  interface iterator { 
   iterator  
          Object next();
  	};
  

  interface container { 
   container  
  
          long length();
  
          Object first();
          Object next();
          Object current();
  
          iterator walk();
  	};
  

  interface factory { 
   factory  
  
          hush::kit kit(in string name);
          hush::event event(in long type);
  };
  

  interface dot {  
   dot  
  
          hush::kit kit(in string name);
  
          hush::container container(in string name);
          hush::iterator iterator(in string name);
  
          hush::factory hush(in string name);
  };
  

  module widgets {
  
  interface canvas : hush::widget { 
   canvas  
  
  	canvas create( in hush::widget anc, in string path );
  
  	hush::item circle( in long x, in long y, in long radius, in string options );
  	// other items ...
  	};
  
  
  
  interface message : hush::widget { 
   message  
  
  	message create( in hush::widget anc, in string path );
  	void text(in string txt);
  	};
  
  
  
  interface factory : hush::factory { 
   factory  
  
   	widgets::canvas  canvas(in string name, in string options);
   	widgets::message message(in string name, in string options);
  	};
  
  
  interface dot : hush::dot {  
   dot  
  
  	widgets::canvas  canvas(in string name);
  	widgets::message message(in string name);
  
  	widgets::factory widgets(in string name);
  	};
  
  
  };
  

server

  class application : public session {
  public:
  application(int argc, char* argv[]) : session(argc,argv,"hello") {
  }
  void corba();
  int main() {
      tk->trace();
      kit::declare("tk",tk);
  
      message* m = new hello(".hello"); 
      m->pack();
  
      message::declare("hello",m);
  
      corba(); // make yourself available as a server
  
      return OK;
      }
  };
  

client

      try {
  
          tk = hush->kit("bp");       // A kit for BinProlog
          tk->eval("consult(facts)");
          }
      catch(...) {
          cout << "An exception ... " << endl;
      }
  
      while (1) {
          char* text = readtext();
          tk->eval(text);
          char* q = 0;
          while ( (q = tk->result()) )
                  cout << "Result: " << q << endl;
  	}
  

  class draw_srv : public canvas { 
   draw_srv    
  public:
  
  draw_srv( const widget* w,  char* path ) : canvas(w,path) {  
          geometry(200,100);
          self()->bind(this);
          dragging = 0;
  }
  
  void press( event& ) { dragging = 1; }
  
  void motion( event& e) { 
          if (dragging) circle(e.x(),e.y(),10,"-fill black");
  }
  
  void release( event&  ) { dragging = 0; }
  
  protected:
  int dragging;
  };
  

server

      list* rlist =  new list;
      item* it = draw->circle(40,40,10,"-fill yellow");
      hush::item* rit = new item_srv(it);
      rlist->insert(rit);
      it = draw->circle(30,30,10,"-fill red");
      rit = new item_srv(it);
      rlist->insert(rit);
  
      hush::container* rx = new list_srv(rlist);
      list::declare("items",rx); // store server
  
      iter* riter = rlist->walk();
      iter::declare("riter",riter);
  

1

• definitions -- components
• the technology matrix
• component myths -- (r)evolution

2

• Microsoft COM
• OMG CORBA
• ODMG persistency

3

• a matter of perspectives

4

• agent, workgroup, agenda, appointment
• CORBA server, Java applets

5

• factories -- (distributed) object tables
• server wrappers -- remote objects
• client-side adaptors -- transparent typing