1. Principles of Object-Oriented Software Development Software Architecture

2. Software Architecture Introduction Elements of architecture Case study -- multimedia feature detection Crossing boundaries Architectural patterns and styles Cross-platform development Summary Q/A Literature

3. Software architecture • architecture -- components and boundaries • case study -- a framework for multimedia feature detection • native objects -- the language boundary • embedded logic -- the paradigm boundary • architectural styles -- distributed object technology • cross-platform development -- Unix versus Windows Additional keywords and phrases: components, information architecture, multimedia information retrieval, feature detection, portability

4. Elements of Architecture [Wolf] • processing elements -- transformation on data • data elements -- contain information • connections -- glue that holds elements together

5. Models and Views [Kruchten95] • logical -- functional requirements • process -- performance, availability, distribution • physical -- scalability, configuration • development -- organization of software modules • scenarios -- instances of use cases Definitions http://www.sei.cmu.edu/architecture/definitions.html

6. The software architecture of a program or computing system is the structure of the system, which comprises software components, the externally visible properties of those components, and their interrelationships. Bass et al.

7. Technological infrastructure [CS2001] • client-platform -- hardware, OS • presentation services -- windows, multimedia • application software -- code, business logic • network -- communication support • middleware -- distribution, (object) brokers • server platform -- hardware, OS • database -- data management system

8. Distributed Object Patterns [CorbaPatterns] Framework (class hierarchies) Applications (wrappers) System (horizontal, vertical, metadata) Enterprise (reference models, infrastructure, policies) Intra/Internet (standards)

9. Case study multimedia feature detection

10. The extended ACOI architecture

11. The ACOI framework detector world; finds the name of the world detector people; checks name, eliminates institutes detector company; looks if there are at least two persons atom str name; community: world people company; world: name; people: person*; person: name; A sample grammar

12. int personDetector(tree *pt, list *tks ){ ... q = query_query("kit=pl src=check.pl"); while (t = next_token(tks)) { sprintf(buf,"person(\%s)",t); query_eval(q,buf); if (query_result(q,0)) // put name(person) on tokenstream putAtom(tks,"name",t); } ... } A person detector

13. V0 := newoid(); V1 := newoid(); community_world.insert(oid(V0),oid(V1)); world_name.insert(oid(V1),"casa"); community_people.insert(oid(V0),oid(V1)); V2 := newoid(); people_person.insert(oid(V1),oid(V2)); person_name.insert(oid(V2),"alice"); people_person.insert(oid(V1),oid(V2)); person_name.insert(oid(V2),"sebastiaan"); ... Database updates

14. The anatomy of a MIDI feature detector MIDI features

15. detector song; to get the filename detector lyrics; extracts lyrics detector melody; extracts melody atom str name; atom str text; atom str note; song: file lyrics melody; file: name; lyrics: text*; melody: note*; A simple feature grammar for MIDI files

16. event('kortjakje',2,time=384, note_on:[chan=2,pitch=72,vol=111]). event('kortjakje',2,time=768, note_off:[chan=2,pitch=72,vol=100]). Prolog representation

17. Processing MIDI file

18. int melodyDetector(tree *pt, list *tks ){ char buf[1024]; char* _result; void* q = _query; int idq = 0; idq = query_eval(q,"X:melody(X)"); while ((_result = query_result(q,idq)) ) { printf("note: \%s",_result); putAtom(tks,"note",_result); } return SUCCESS; } The melody detector

19. Queries -- the user interface Keyboard interface

20. User Query Processing

21. Crossing boundaries Subsections: Embedded logic -- crossing the paradigm boundary Native objects -- crossing the language boundary Combining Java and C++

22. Embedded Logic -- crossing the paradigm boundary <query kit=pl src=local.pl cmd=X:email_address(X)> <param format=" \%s"> <param result=""> <param display="<h4>The query</h4>"> <param header="<h4>The adresses</h4> <ul>"> <param footer="</ul>"> email_address(E) :- person(X), property(X,name:N), property(X,familyname:F), email(X,E), cout(['<li>', N,' ',F,' has email adress ']), cout([ '<a href=mailto:', E, '>', E, '</a>',nl]). </query>

23. query pl = new query("kit=pl src=remote.pl"); logic.java pl.eval("X:assistant(X)"); String res = null; while ( (res = pl.result()) != null ) { System.out.println("<li> " + res); }

24. Distributed knowledge servers remote.pl :- source('http://www.cs.vu.nl/~eliens/db/se/people.pl'). :- source('http://www.cs.vu.nl/~eliens/db/se/institute.pl'). :- source('http://www.cs.vu.nl/~eliens/db/se/property.pl'). :- source('http://www.cs.vu.nl/~eliens/db/se/query.pl').

25. interface query { query.idl void source(in string file); long eval(in string cmd); string result(in long id); oneway void halt(); };

26. Native objects crossing the language boundary

27. Objects in Prolog • representation -- object(Handler,Class,ID,REF,Ancestors) • object definition -- class_method(This,...) • object invocation -- self(This):method(...) • state variables representation -- value(ID,Key,Value) • state variable access -- var(Key) = Value, Var = value(key) • native binding - native(Handler,Method,Result)

28. low overhead, especially when not needed • natural syntax for object clause definitions • support for native objects

29. midi(This):midi, create midi object Self = self(This), Self:open('a.mid'), Self:header(0,1,480), Self:track(start), Self:melody([48,50,51,53,55]), // c d es f g, minor indeed Self:track(end), end track

30. midi :- use(library(midi:[midi,lily,music,process])). :- declare(midi:object,class(midi),[handler]). midi_midi(This) :- constructor midi(This):handler(H), // gets Handler from class declare(H,new(midi(This)),[],[],_). native methods midi_read(This,F) :- native(_,This,read(F),_). midi_analyse(This,I,O) :- native(_,This,analyse(I,O),_). midi_open(This,F) :- native(_,This,open(F),_). midi_header(This,M) :- native(_,This,header(M,0,480),_). midi_track(This,X) :- native(_,This,track(X),_). midi_tempo(This,X) :- native(_,This,tempo(X),_). midi_event(This,D,C,M,T,V) :- native(_,This,event(D,C,M,T,V),_).

31. midi_note(This,D,C,T,V) :- Self = midi(This), cast to midi Self:event(D,C,note_on,T,V), Self:event(D,C,note_off,T,V). midi_melody(This,L) :- self(This):melody(480,1,L,64). midi_melody(_This,_,_,[],_). midi_melody(This,D,C,[X|R],V) :- Self = self(This), Self:note(D,C,X,V), midi_melody(This,D,C,R,V). direct invocation

32. C++ bindings

33. int kit_object::operator()() { kit_object event* e = _event; vm<kit> self(e); smart pointer string method = e->_method(); if (method == "kit") { constructor kit* q = new kit(e->arg(1)); _register(q); result( reference((void*)q) ); } else if (method == "eval") { long res = self->eval(e->arg(1)); result( itoa(res) ); } else if (method == "result") { char* res = self->result( atoi(e->arg(1)) ); result(res); } else { // dispatch up in the hierarchy return handler_object::operator()(); } return 0; }

34. template <class T> class vm { smart pointer class public: vm(event* e) { int p = 0; char* id = e->option("ref"); if (id) { p = atoi(id); } _self = (T*) p; } virtual inline T* operator->() { return _self; } private: T* _self; };

35. Combining Java and C++

36. package hush.dv.api; class obscure { obscure public int _self; peer object pointer ... };

37. package hush.dv.api; public class kit extends handler { kit public kit() { _self = init(); } protected kit(int x) { } private native int init(); public native void source(String cmd); public native void eval(String cmd); public String result() { String _result = getresult(); if (_result.equals("-")) return null; else return _result; } private native String getresult(); public native void bind(String cmd, handler h); ... };

38. kit.c #include <hush/hush.h> #include <hush/java.h> #include <native/hush_dv_api_kit.h> #define method(X) Java_hush_dv_api_kit_##X JNIEXPORT jint JNICALL method(init)(JNIEnv *env, jobject obj) { jint result = (jint) kit::_default; // (jint) new kit(); if (!result) { kit* x = new kit("tk"); session::_default->_register(x); result = (jint) x; } return result; }

39. JNIEXPORT jstring JNICALL method(getresult)(JNIEnv *env, jobject obj) { java_vm vm(env,obj); char *s = vm->result(); if (s) return vm.string(s); else return vm.string("-"); }

40. JNIEXPORT void JNICALL method(bind)(JNIEnv *env, jobject obj, jstring s, jobject o) { java_vm vm(env,obj); java_vm* vmp = new java_vm(env,o,"Handler"); const char *str = vm.get(s); handler* h = new handler(); session::_default->_register(h); h->_vmp = vmp; h->_register(vmp); vm->bind(str,h); vm.release(s, str); }

41. handler::dispatch event* handler::dispatch(event* e) { _event = e; if (_vmp) { return ((vm*)_vmp)->dispatch(e); } else { int result = this->operator()(); if (result != OK) return 0; else return _event; } }

42. #include <hush/vm.h> #include template< class T > class java_vm : public vm< T > { java_vm public: java_vm(JNIEnv* env_, jobject obj_) { _env = env_; _obj = obj_; _self = self(); } ... event* dispatch(event* e) { java dispatch call("dispatch",(int)e); return e; }

43. T* operator->() { return _self; } T* self() { jfieldID fid = fieldID("_self","I"); return (T*) _env->GetIntField( _obj, fid); } void call(const char* md, int i) { // void (*)(int) jmethodID mid = methodID(md,"(I)V"); _env->CallVoidMethod(_obj, mid, i); } private: JNIEnv* _env; jobject _obj; T* _self; };

44. Architectural patterns and styles Subsections: From technology to style Case study -- perspectives in visualization

45. From technology to style • the distributed objects style • the (dynamically) downloadable code style • the mobile objects style

46. distributed downloadable mobile objects code objects Component object object/class agent Connector ORB various methods Creation server client any Location server client any Client fixed extensible extensible Server extensible fixed extensible Feature classification

47. Case study -- perspectives in visualization Exchanging perspectives

48. Guidelines for selecting a style Rules of thumb -- selecting an architectural style Dedicated hardware or legacy code distributed objects Strategic or secret code distributed objects Many users downloadable code Periodic updates downloadable code Communication and negotiation mobile objects

49. Cross-platform development

50. Cross-platform development Unix vs NT • open toolkits and standards -- OMG CORBA Research/GNU AT&T U/WIN -- Posix for 95/NT Cygnus -- GNU-win32 Commercial NuTCracker/MKS -- porting Unix applications to Windows Wind/U, Mainwin -- porting Windows applications to Unix Tributary -- developing Unix applications from Windows IDE