1 / 54

OOFwDPfBDIS

OOFwDPfBDIS. O-O Frameworks with Design Patterns for Building Distributed Information Sharing Dissertation by Björn Eiderbäck NADA/KTH, 3/2001 Presentation by Stephen Travis Pope (stp@create.ucsb.edu). Outline. Overview Goals & Definitions The Problems with Patterns

lacey-kidd
Download Presentation

OOFwDPfBDIS

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. OOFwDPfBDIS • O-O Frameworks with Design Patterns for Building Distributed Information Sharing • Dissertation by Björn Eiderbäck • NADA/KTH, 3/2001 • Presentation by Stephen Travis Pope (stp@create.ucsb.edu)

  2. Outline • Overview • Goals & Definitions • The Problems with Patterns • Distributed Processing Systems • UI Builders • The MultiGossip Patterns & Framework • Evaluation, Comments & Questions

  3. Overview of the Work • Background of the team and project • IPLab, MultiG • COMIC: Shared Obj. Svc, Interface Svc. • MMProg Project (DMIB?) • OOP & OOD Patterns • Distributed Processing for CSCW (a natural combination) • The MultiGossip Framework

  4. The Thesis • Three components: • Survey and R&D questions (70 p) • Solutions and implementations (100 p) • Evaluation and conclusions (24 p) • Topical focus: • OOP, CSCW, design patterns, GUI Frameworks, DPE, UIBs

  5. Goals of this Work • Integrated framework for information sharing • Distribution and cooperation via agents • Reflexive environment • Information sharing techniques • New design patterns • Use of OO techniques

  6. My Comments • Pick fights with Björn’s quotes and abuse of basic definitions • Complain about the state of the current “pattern frenzy” • Sell you all CORBA ORBs • Evangelize for Smalltalk • Generally know it all better...

  7. Basic Definitions • Problems: Object, Actor, and Agent • Object: encapsulated state and behavior • Has: identity, well-known behavioral interface, possible class relationship • Agent: Object with a “thread” • Implies self-directed action, dependency • E.g., Observer, blackboard, Cellular Automaton

  8. Service/Object/Agent Semantics • Task service • Resource manager • Method servers(?) • Project (meta) agents • Weak vs. strong agency a la Kendall

  9. Design Patterns • Pattern history • Architecture, Eiffel/Smalltalk OOD (reverse architecture or pattern mining) • “Pattern describes an abstract problem and the basic structure of a solution” • Ways of describing OO design patterns (formally) • Wegner: “Objects, components, and frameworks cannot be specified by algorithms.” (hogwash!)

  10. The GO4 Pattern Template • Several formats: • Name • Intent • AKA • Problem/Motivation • Solution/Applicability • Structure/Participants • Known Uses • Consequences • See also (relatives) • Augmented by: • Free text • UML Diagrams • Class relationships • Action sequences • E/R diagrams • Code examples

  11. Example: Dependency • Name/AKA: Observer, constraint, publish/subscribe, data-flow • Context/Intent: dist. systems • Motivation : indep. objects + constraint • Forces: loose coupling • Solution/Structure/Applicability: dependency mechanism • Known Uses: MVC, Observer/-able

  12. GO4 Pattern Relationships Purpose Creational Structural Behavioral Class Factory Method Adapter Interpreter ScopeTemplate Method Object Abstract Factory Adapter Resp. Chain Scope Builder Bridge Command Prototype Composite Iterator Singleton Decorator Mediator Façade Memento Flyweight Publish/Subscribe Glue State Proxy Strategy Visitor

  13. Structure of Patterns & Pattern Decomposition • Dependency/Observer/P-S/Constraint • Model is-a observable (has-a dependents) • View implements updating • Transparent forwarding between Model and (0-n) (1-n) Views • Adaptor/Holder/DynamicValue/Wrapper/ Proxy/Bridge • Holder implements external protocol (has-a value) • Value does something else • Transparent forwarding between Holder and (0-n) (1) Values • Does this help to differentiate them?

  14. Pattern Issues • Q: Is call-back a pattern? What about dependency or adaptation? • Q: What’s the (formal) difference between tool kits, libraries, and frameworks? • Q: Is MVC a pattern or a framework? (p. 75) • Q: Are all frameworks architectural?

  15. Pattern Hierarchies and Primitives • Are there primitives and notations that we could use to formally describe the construction and composition of patterns and the relationships between them? • Well, are there?

  16. Distributed Processing Defined • Multiple processors without shared memory(?) • Communicate by sending messages via some network • Focus on behavioral interfaces

  17. Distributed Processing “Light” • Managing concurrency, multi-processing, and physical distribution • Requirements • Network, low-level protocols (assumed) • XDR: external data representation • RPC/RMI: remote method invocation • These may be described in an IDL • A few basic services (naming, 1:n events)

  18. Distributed Processing Issues • XDR and marshalling (pass-by-reference supported?) • RMI modes: sync, blocking, 1:n, call-back, etc. • IDL: fcn. prototypes, exceptions, interface class hierarchy, QoS • Run-time configuration and management

  19. DPE Systems & Semantics • Actors & Laws of Parallel Processing • Concurrent OO Languages • ABCL/1 • ConcurentSmalltalk • DST/CORBA • Heavy-weight • Possibly transparent

  20. Required Services (BE) • Required • Naming • Messaging (RMI) • Life-cycle • Optional • User registration • Trading • Transactions/concurrency • Events • Persistency

  21. The Problems with Sharing • Concurrency and threading problems • Session state and persistency problems • Distributed garbage collection • Fault-tolerance

  22. The Goal of DPE • Transparency across • Access • Location • Concurrency* • Replication* • Faults • Migration* • Performance • Scaling

  23. Architectural Style in DPE • Information issues • Centralized vs. replicated • Communication Issues • Host-terminal • Client-server • Broadcast data • Batch communication • Peer-to-peer? • Others?

  24. OOP and DPE • Natural mix • Data-hiding and encapsulation • Behavior via message-passing • Focus on interfaces and shared behavior • Various “transparencies” • But: • No explicit call-by-reference • No answers for concurrency, distribution, 1:n events, etc.

  25. GUIs and Frameworks • GUI Architecture and OO patterns • Impact on the design of widget sets • UI Builders and GUI construction • VisualWorks: • Merge of display list graphics and view layout • All connections via adaptors • All “adornment” via wrappers • Run-time GUI construction

  26. UI Builder Semantics • Graphical configuration • “Wiring” • Complexity and scaling • VisualWorks: • Layout and graphical constraints • Dialogs for complex connections, pre/post-conditions, etc. • Too complex for simple tasks, but scales well to very complex GUIs

  27. CSCW • Collaboration across place (physical/geographical distribution) • Collaboration across time (off-line partnering) • Many terms: messaging, conferencing, co-authoring, etc. • Special vs. custom tools

  28. Information Sharing Patterns • Viewing patterns • Shared access patterns • Transport patterns • Extension patterns • Migration patterns • Distribution patterns Issues: location, access, replication, consistency, views and interfaces, etc.

  29. Viewing patterns • Multiviewing – separate semantics and presentation (MVC, etc.) • Shared view – identify shared state as semantic (tight coupling, WYSIWIS) • Partly-shared view – divide semantics and presentation, I and O (WYSIWIMS) • Different outfits – configurable presentations (medium coupling) • Sharing through objects – shared state as separate object (loose coupling) (Fig p. 87)

  30. Shared access techniques • Transparent distribution (the goal) • Transparent object locations (using a mediator/adaptor) • Two-tier architecture (but no implied hierarchy, may be P2P) • Three-tier architecture (“shared business objects”) • Splitting semantics from presentation (many options)

  31. Transport patterns • Communicating changes to replicates – several approaches, standard fare • Message-passing – loose coupling • State-poking – abstract/composite setters • Meta-model – just an object! (or a component) (Fig p. 95)

  32. Distribution patterns • Marshalling – serialization, streaming • Messenger – proxy, forwarder • Low-level connection – ORB + IIOP • High-level connection – API based on LLC • Arriving back at the origin – blocking calls • Mother – DPE Manager • Coping with errors – exception propagation • Providing undoable actions – no solution!

  33. Extension patterns • Template method – pluggable (or parameterized) behavior, see pluggable MVC • Aggregation with black box – COM composites, JavaBeans

  34. Migration patterns • Proxy – adaptor? forwarder? wrapper? • Adaptor for distribution – see above...

  35. Architectural Guidelines • Dynamic architecture • Indirect • Use metaclasses • Events and notifications • Use adaptors • Encapsulate • Migration and agents • Are these patterns?

  36. Architecture for Information-Sharing Applications • Technical/Design requirements • OO aesthetics • Structured design rules • Required services • Naming, trading, transaction, life-cycle • History, versioning, locking, persistency • Applied patterns • Proposed architecture

  37. Conceptual Components (p. 144) • Comm. Infrastructure (L/HLC, RMI) • Messaging system (sync) • Server & clients • Services (required services) • Agents, mobile objects • Client application

  38. Architectural Guidelines • Structural advice (malleable) • Recommended patterns (factory, metaclass, adaptors, etc.) • Recommended design techniques (transparency, mobility) • Central components (communication, RMI, obj. manager, naming svc., transaction/migration, etc.)

  39. Integration • Easy! (given a sophisticated enough OO development platform...)

  40. MultiGossip: A DMIB • Implementation Issues • Naming and identifiers • RMI mechanisms (Marshalling and protocols) • Distributed instances • Syntax (ST80) • Examples (p. 180 ff)

  41. Remote Message Objects • Message • ID • Receiver • Do reply • Acknowledge • Timestamp

  42. Evaluation of MultiGossip • Controllability • Support for Experimentation • Extensibility/Flexibility • Active services • Malleability • Support for various media • Smooth integration into programming environment

  43. Assessment • Useful for prototyping • Scalable • Transparent • Controllable • Safe and reliable • Development speed • Performance and latency • Coverage • Expressive • Useable

  44. Evaluation Criteria • Object sharing • Distributed error handling • Extension • Port to new version of platform • IB adaptation • Core extension

  45. Building tools • Chat • Browsers • Paint • Pong • IP (video) phone • Window copying • Async. Tools

  46. Discussion • Server vs. loose-coupling • Homogeneous protocols • Casual vs. server-based connections • Persistency • Integration with environment • MM object integration • Extending ST interaction techniques

  47. Who Cares? • Who needs this? (We do!) • Internet since 1980, WWW since 1992… • Still depressing scarcity of new applications. • CORBA, COM, etc. are still hard to use for building truly novel (MM) applications (see, e.g., our work at CREATE) • What’s the contribution of this work? • Important new patterns and their impact on architecture analyzed • Design and implementation alternatives assessed and MG decisions justified

More Related