Principles of Object-Oriented Software Development

Component Technology

Component Technology

Introduction

Objects versus components Standards for interoperability The Java Platform A simple workgroup application Crush -- extending hush with CORBA

Summary Q/A Literature

Component Technology

• 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

Objects versus components

Subsections:

Definitions The technology matrix Component myths

Definitions

Component substitutability

unit of independent deployment unit of third party composition no persistent state

Object identity

unit of instantiation (persistent) state encapsulation of state and behavior

A software component is a unit ofcomposition with contractuallyspecified interfaces and explicitcontext dependencies only. Asoftware component can bedeployed independently and issubject to composition by thirdparties.

Szyperski

The technology matrix

distribution mobility language platform reflection COM - - * - +/- DCOM + - * +/- +/- CORBA + - * * +/- Java/Beans - classes Java * + Java/RMI + classes Java * + Voyager + objects Java * +

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 support mega applications it affects performance significantly

component-ware is a revolution wrong, it is an evolution from OO and C/S

unknown source

Component Questions

• How to describe the interaction between components?

• How to manage variety and flexibility?

• How to guarantee critical system-wide properties?

Standards for interoperability

Subsections:

Microsoft COM OMG CORBA ODMG persistency

Object linking and embedding

COM

Object-enabling technology

• document centered -- text, graphics, reports

• component software -- standard programmatic interface

• distributed object systems -- component object model

OLE

(D)COM

Features linking, embedding, storage

Alternatives IBM SOM/DSOM, Apple OpenDoc

Object Request Brokers

CORBA

Standardization -- system integration OMG information sharing -- technology, policy

Object Management Architecture -- interface standards IDL

Object Services Object Request Broker CORBA

Common Facilities -- file manipulation, print queuing, email Application Objects -- spreadsheets, word processor

The OMG standardization effort

Object Services

• life cycle -- creation and deletion

• persistence -- management of object storage

• naming -- mapping names to references

• event notification -- registration of events

Future

transactions, concurrency, relationships,...,time

Persistent objects

ODMG

Persistent objects ODMG database extension -- unified type system

Object Definition Language ODL standard types -- objects and literals references -- Ref< T > collections -- List< T > , Bag< T >, Set< T >

Object Manipulation Language OML create, delete, modify, reference

Object Query Language OQL oql(type& value, const char* query,...)

The ODMG-93 standardization efforts

Design principles 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

Language binding -- C++ ODL/OML

C++ODL/OML binding -- future

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

Modifications to C++

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

Standardization efforts -- de facto market share

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

Future standardization efforts

The Java Platform

technology innovation

Perspectives

• Internet Applications -- the dial-tone of the Internet

• Software Engineering -- long-term maintenance

• Language Design -- semantic compromises

• System Development -- light weight clients, heavy weight servers

• Computer Science -- towards declarative, verifiable technology

• IT (in) Business -- standards for business objects and processes

• Global Village -- virtual world technology

An Internet-based Workgroup Applications

Object Model

Crush

extending hush with CORBA

Extending a frameworkwith CORBA

• 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

Interfaces

The hush module

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 item : handler { item void move( in long x, in long y ); };

interface widget : handler { widget

string path(); void eval( in string cmd ); void configure( in string options ); void pack( in string options ); };

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); };

The widgets module 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); }; };

Examples

A remote interpreter kit client hush::dot* hush; // (distributed) object tables widgets::dot* widgets; // widgets contains hush hush::kit* tk; // remote kit object widgets::message* banner; try { hush = widgets = widgets::dot::_bind (SERVER, argv[1]); tk = hush->kit("tk"); banner = widgets->message("hello"); // must exist } catch (...) { cerr << "Unexpected exception ..." << endl; return -1; }

while (1) { client (ctnd) char text = readtext(); // from stdin banner->text( text ); // display text tk->eval(text); }

class application : public session { server public: application(int argc, char* argv[]) : session(argc,argv,"hello") { } void corba(); int main();};

int application::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; }

void application::corba() { widgets::dot* dw = new widgets_dot_srv(); // create dot for widgets try { CORBA::Orbix.registerIOCallback(it_orbix_fd_open, FD_OPEN_CALLBACK); CORBA::Orbix.registerIOCallback(it_orbix_fd_close, FD_CLOSE_CALLBACK); CORBA::Orbix.impl_is_ready(SERVER,0); CORBA::Orbix.processEvents(0); } catch (...) { cout << "apparently something went wrong" << endl; }}

Evaluating logical queries

try { client 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; }

A remote canvas

class draw_clt : public canvas { draw_clt public: void plug(widgets::canvas* x) { draw = x; } int operator()() { hush::event* e = hush->event(_event->type()); cerr << "Getting event " << e->type() << endl; e->x(_event->x()+10); e->y(_event->y()+10); hush::event::_duplicate(e); // CORBA 2.0 hush::event* res = draw->dispatch(e); return canvas::operator()(); }

draw_clt(const widget* w, char* path ) : canvas(w,path) { configure("-background white"); geometry(200,100); self()->bind(this); dragging = 0; } draw_clt(char* path ) : canvas(path) { configure("-background white"); geometry(200,100); self()->bind(this); dragging = 0; }

void press( event& ) { dragging = 1; } void motion( event& e) { if (dragging) { self()->circle(e.x(),e.y(),2,"-fill black"); draw->circle(e.x(),e.y(),3,"-fill yellow"); } } void release( event& ) { dragging = 0; } protected: int dragging; widgets::canvas* draw; };

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; };

Moving items

server list<hush::item>* rlist = new list<hush::item>; 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<hush::item>(rlist); list<hush::item>::declare("items",rx); // store server iter<hush::item>* riter = rlist->walk(); iter<hush::item>::declare("riter",riter);

Summary

Objects versus components

• definitions -- components

• the technology matrix

• component myths -- (r)evolution

1

Standards for interoperability

• Microsoft COM

• OMG CORBA

• ODMG persistency

2

The Java Platform

• a matter of perspectives

3

An Internet-basedworkgroup application

• agent, workgroup, agenda, appointment

• CORBA server, Java applets

4

Crush -- extending hushwith CORBA

• factories -- (distributed) object tables

• server wrappers -- remote objects

• client-side adaptors -- transparant typing

5

Questions

1. Give a definition of the notion of components. How is this related to a definition of objects? Explain the difference between these definitions. 2. What actual component technologies can you think of? How would you compare them? 3. Describe Microsoft (D)COM, OMG CORBA, ODMG Persistent Objects. Is there any relation between these standards? 4. Discuss the Java platform. What perspectives can you think of? Discuss pros and cons! 5. Describe the architecture of an Internet-based workgroup application. What technology would you use? 6. What issues may arise in extending a given library or framework with CORBA? Can you think of any solutions?

Further reading

I recommend [Szyperski97], both as an introduction to component-technology, and as a reference for more advanced readers. For an introduction to CORBA, you may read [Siegel96]. A readable account of the ODMG standard is given in [Cattell94]. For more information on Java, again, visit http://www.javasoft.com . For information on (D)COM, look at http://www.microsoft.com/com . Learning how to program CORBA applications is probably best learned from the manuals that come with your CORBA distribution.