Overview of Software Toolkits and Frameworks for Prototyping in Groupware Applications

1. Software Tools, Part 2 Fall, 2002

2. Overview • Toolkits • Prototyping Languages • Frameworks • Groupware Frameworks • GroupKit • THYME • Wrap Up

3. Toolkits • Ease development by providing fully-fleshed out UI widgets • A UI component has two major parts • The UI presentation (a button) • The outlet (how the program is informed when the button is pressed)

4. Toolkits • TCL/Tk • Motif • Mac Toolbox • MFC • Java AWT

5. Toolkits • Disadvantages • does not necessarily contain all the functionality you need • constrained by the programming model • motif and pseudo-objects • AWT and layout managers • toolkits can be specific to a language • AWT and Java • TCL/Tk and TCL

6. Prototyping Languages • By hiding programming details, a developer can build a functional prototype quicker • Hidden details • memory allocation / garbage collection • UI • flow control

7. Prototyping Languages • Java • Application / Applet language • Cross platform. Intent is that all applications act the same on all platforms • Hypercard • Movement between Cards (screens) • Tcl/Tk • Scripting language

8. Prototyping Languages • The final prototype unsuitable for a released product • speed • memory footprint • Interface to external libraries can be difficult (but is usually possible) • JNI for interfacing to C libraries from Java • SWIG for Perl

9. Toolkits and LanguagesThe Message • Toolkits provide UI widgets that can be used to develop the application • This lets the developer focus on building the application, instead of the widgets • Prototyping languages allow the rapid development of prototype applications, but can entail trade-offs

10. Frameworks • My definition: Frameworks provide structure for the developer to build an application around • Other definitions: • MacOSX frameworks (i.e., Cocoa, Carbon) as object oriented libraries • Often synonym for toolkit

11. Groupware Frameworks • Provide the infrastructure for building groupware • UI Toolkit • Messaging / Networking / etc • Discovery • Other features • transcription • analysis

12. GroupKit • Roseman and Greenberg, 1995 • TCL/Tk framework for building distributed, synchronous groupware • Room-based, called conferences, handled by the session manager

13. GroupKit • Features • runtime infrastructure • manage communication • handle interconnections • groupware programming abstractions • RPC • shared data structures

14. GroupKit • Features • groupware widgets • multi-user scrollbar • shared whiteboard • telepointers • session management • discovery of sessions • grouping of users

15. THYME • flexible • the developer should have access to the infrastructure, not be limited by it • extensible • the developer should be able to add infrastructure • introspectable • the developer should be able to extract contextual information • consistent • patterns and structure

16. THYME • component model • driven by communication between components • developer’s work involves writing new components which communicate to other developer written components and existing, infrastructure components • infrastructure follows this component model, no special cases

17. What You Get • my-project-base • contains thyme-core • chats - the THYME Chat Room • swab - the THYME Shared Whiteboard • abs - the THYME Build System • my-project - your stuff goes here • building everything involves `make` or `ant`

19. What You’ll Do • add your components and message source code to my-project • the room • the client • add your component specifications to my-project • run your application • collect data

20. Anatomy of a Component • a component is the functional piece of THYME application • uniquely identified • sends and receives messages • lifecycle • on<Stage>() methods • infrastructure • taken care of for you • functional • your responsibility

21. Reference Ids • An Id uniquely points to a component • Contains a classid and an instanceid • the classid is specified in the specification file • the instanceid is developer specified • the combination of instanceid and classid is unique within a Node • An Id is never constructed by the developer, it is obtained via the Id manager

22. Obtaining a Component • A given Id always references the same component. There is no difference between obtaining and constructing a component • No direct construction (i.e., you will never call new MyComponent()) • You should pass around an Id, not a component • How it works • obtain an Id that represents the component • obtain the component manager • request a new component

23. Messaging • THYME provides simple semantics for communicating between components, local or remote. • No RMI / RPC (yet) • A message object is constructed and sent to a specified component • A component is informed of a new message via the receive() method

24. Lifecycle • Lifecycle stages exist to provide a granular set of post-constructors • Extensible, but don’t bother here • Cumulative and ordered • i.e., setReady() on a constructed component will call onInit() and onReady(), in order • 3 methods • set<StageTransition>() is called on the component and causes a transition is • <Stage>() is called on a component and returns a boolean • on<Stage>() is implemented in the component and called appropriately

25. Lifecycle • Stages (in order) • constructed • initialized • ready • shutdown • Transitions • constructed + init = initialized • initialized + ready = ready • * + reset = initialized • * + shutdown = shutdown

26. Transcription • Transcription is performed by collecting messages that are sent between components • Transcript is optional, a message can be ignored by setting setTranscribe(false). • Transcribed messages are set the transcription service, which exists within a separate VM

27. Running Your Application • Each component exists in exactly one container component, called a Node • The Node brokers the component for discovery and ensures that addressed messages get to it • Each Node exists on exactly one host, although one host can have multiple nodes

29. Running Your Application • To run your application, you need to • tell the node what components it might need to create and use • instantiate at least one component to start the application going • pass control to that component

30. Running Your Application • Each application has a specification file, which provides these elements <?xml?> <system> <init class=“some.class”/> <blocs> <bloc id=“an-id” class=“the.class.for.id”/> </blocs> </system>

31. Discovery • I start up a chat room client, how do I get a list of all chat rooms I might want to connect to? • Explicit, specify the room on the command line • Implicit, talk to the registrar

32. Registrar • The node registrar provides a list of all Nodes that have been registered with it • Each node can be introspected to get a list of components that it contains • The list can be searched for matching criteria • All this is encapsulated by the THYME find manager component

33. Wrap Up • Specification Methods • grammars, transition diagrams, state charts, UAN • Interface Building Tools • rapid prototyping • Evaluation Tools • Toolkits • Frameworks • GroupKit, THYME

34. THYME Resources • Email • thyme@cs.brandeis.edu • IRC • irc://group.cs.brandeis.edu #thyme • Webpage • http://group.cs.brandeis.edu/thyme • JavaDocs • http://group.cs.brandeis.edu/thyme/api • Manual • http://group.cs.brandeis.edu/thyme/manual