We introduce the concept of information components and show how it can allow non-expert users to construct personal information spaces by selecting, customising and composing components de ned by the system or other users. The system presented is based on a plug-andplay concept and new user-de ned applications can be integrated into the portal-style interface based on default templates which can easily be customised by the users.
The term Web 2.0 refers to a new generation of Web-based applications that empower the user in the creation and management of content and services. Combined with the concepts of portals, widgets and mashups, users are nowadays able to not only manage and share their own data, but also integrate a wide range of external data and services. At the same time, users are encouraged to collaborate in a range of ways|including the community-based development of application libraries o ered by sites such as Facebook.
It is therefore not surprising that users are increasingly turning to Web 2.0 sites for the management of personal information. However, this can in turn create its own problems in terms of losing control of one's own data and increased fragmentation of information across a range of Web 2.0 applications and desktop applications. At the same time, while sites such as Facebook provide a very large collection of applications for the management of personal information such as contacts, photo albums, places visited and virtual bookshelves, it is not possible to personalise these or combine them in exible ways.
Our goal was to adopt concepts from Web 2.0 to empower users in the management of all of their personal information by allowing them to customise and compose information components. Instead of o ering units of reuse at the interface or service level, we o er them at the database level, thereby allowing users to focus on their data requirements and to extend, customise, group or associate data items as they choose. A Web-based pluggable interface architecture generates the interfaces automatically based on default or selected templates which can easily be customised.
Section 2 provides the background to our work and an overview of the approach is given in Sect. 3. Section 4 describes the development process, while implementation details are given in Sect. 5. Our approach is compared to related work in Sect. 6. Concluding remarks are given in Sect. 7. 2
Personal information management (PIM) systems proposed in research tend to
either use a prede ned PIM domain model e.g. [
Web 2.0 has had a tremendous impact in terms of how people use the Web
to communicate, collaborate and manage personal data. Its success can provide
valuable lessons in how to provide easy-to-use, customisable and extensible
platforms for PIM. In particular, users have become familiar with the plug-and-play
style of interfaces o ered by portals as well as applications o ered by social
networking sites such as Facebook. They are also becoming increasingly familiar
with the notions of widgets that allow small, lightweight applications to be
integrated into Web pages and Web-based mashups that allow the integration of
services within a client. Taken together with the notions of user-generated
content underlying Web 2.0, users are increasingly becoming empowered to manage
their own information needs. However, on the negative side, the increased usage
of Web 2.0 applications for PIM has drastic consequences in terms of loss of user
control over their own data and also information fragmentation [
We have adopted features of Web 2.0 for a PIM platform that allows users to de ne and manage their own personal information space by creating, sharing, customising and composing so-called information components. These components de ne the data structures, application logic and interaction logic that support particular information management tasks. Being able to build a personal information space in a plug-and-play manner through the selection and composition of components allows even non-expert users to pro t from the experience of more advanced users and have ne-grained control over their PIM. 3
Information components are intended to be the basic units of reuse in information systems at both the schema and data level. An information space consists of a set of information components where each component can contain both metadata and data. If an information component consists of only metadata, reuse is only at the schema level to support the design of an information space. Optionally, an information component may contain data as well as metadata which allows the reuse of data. Information components can be composed from other components as shown in Fig 1.
InformationSpace
InformationComponent
MetaData Data
ModelPart Model Concepts
Class
Collection
Association
Our prototype was developed using an object database based on the OM
model [
Our approach allows users to construct their personal information space by de ning their own components through a process of selecting, extending and combining existing components. A core set of system-de ned components are provided to support the basic, common information management tasks in PIM systems such as the management of contacts and we show in the next section how a user can use these as the starting point for developing their own PIM applications. In addition, users can also reuse components de ned by other users based on a global component registry.
An application consists of an information component together with an associated user interface (UI). To create an application, the user basically models the application domain and associates domain concepts to templates. The system then generates both the database representation of the domain model and the user interface based on the domain concept-template assignment speci ed by the user and deploys the application into the user interface. 4
Assume a user has a simple contact application and a picture management application and would like to tag pictures with contacts. We will now illustrate how the user could extend their personal information space with this functionality by creating a new information component from the composition of the existing components. Figure 2 gives an overview of the steps involved as supported by the Application Manager integrated into our prototype system PIM 2.0.
1 shows the PIM 2.0 UI with three applications. In order to create a new application, a user rst creates a new information component 2 by modeling the application domain reusing existing component parts and/or specifying new domain concepts. Note that an information component can have arbitrarily complex models, but may also represent a single domain concept. Figure 3 shows a screenshot of component composition in the Application Manager.
Component Composition
Create new component parts Import components Associate component parts
2 6
PPicitcutruerses ContactsEPvicetnutrses
tagged Contacts Pictures
Automatic Steps Component Generation
(Database) 3 UI Generation 5
Associate with templates User-defined templates
tagged Contacts Pictures 4
We assume the reuse of a Contacts component and a Pictures component. The following assumes a combined de nition of collections and types.
contacts(name:string, birthday:date, phone:set, address:set) } Pictures{ pictures(picture:uri, caption:string) albums(name:string) picturesInAlbums(picture:ref, album:ref) } Users can drag and drop component parts into the composer area of the Application Manager to reuse them. New classes, collections and associations can be created by using the menu on the left. As shown in Fig. 3, a PictureTagging component can be created by reusing contacts from the Contacts component and pictures from the Pictures component and associating them with a tagged association. The textual representation of the new component is:
Contacts.contacts(name:string, birthday:date, phone:set, address:set) Pictures.pictures(picture:uri, caption:string) tagged(picture:ref, contact:ref) } Collection and association names are quali ed with their component names to ensure uniqueness. However, users can rename objects during composition in order to simplify the interface of the new component. Once de ned, the component model is automatically created in the database 3 .
To create the UI for the new component, it is associated with a structural template 4 which de nes what should be displayed in terms of attributes and associated entities, the order in which these should be displayed and also the operations o ered through context menus and buttons. To support the de nition of the UI, there are standard templates for displaying collections and objects in read or write modes. Further, structural templates can be created automatically by the Application Manager by users de ning views through the simple selection and ordering of object attributes. Also, context menus to select from various standard options are available where appropriate.
The actual layout and positioning of data is de ned in separate layout templates that are applied upon interface generation. Note that users can create their own layout templates or extend existing ones. During UI generation, a view is generated which includes the layout as well as the structural information and represents the actual UI through which the user interacts with the data.
The default collection template displays a collection as a list and the user has to specify the object attributes to appear in that list. For example, they might specify that the contacts collection be displayed as a list of surnames followed by forenames. By default, collection views are always in write mode, so that objects can be selected, added to and removed from the list.
The default structural templates represent objects in a generic way. It is easy for users to create their own custom templates. For example, they might specify that in the picture detail view, the actual picture together with a caption should be displayed rather than the URL. To support such customisations, templates can be created which specify a set of applicable types and users are presented with a choice of presentations. The picture detail template would have the form: <view name=`PictureDetailView' mode=`read'> <layout source=`defaultGridLayout'> <compatibletypes>
<type name=`pictures'/> </compatibletypes> <attributes> <attribute name=`picture' resource=`attributes/picture'/> <attribute name=`caption' value=`attributes/caption/'> </attributes> </view>
Attribute picture is a resource which means that the value is the path to the resource to be displayed, while the attribute caption is a value that can displayed directly. This template uses a default layout template defaultGridLayout, but a user can also de ne their own layout template or extend the default ones.
A user may wish to reuse the customised templates of imported components, extending them to cater for new data or functionality. For example, in the picture tagging application, the user might want to display the names of tagged persons along with the picture and caption. This could be done by creating a template that extends the PictureDetailView template as follows: <view name=``TPictureDetailView'' extends name=``PictureDetailView''> ... <attributes> <attribute name = `Tagged'
value=`associations/tagged/contacts/attributes/name' type=`set'> </attributes> </view> The previous template is extended with an attribute that provides a set of names of the people related by the `tagged' association of the PictureTagging component as speci ed by a path expression. By declaring type=`set', we indicate that the navigation may yield a set of values all of which should be displayed. After associating the model with the templates, the actual views are generated by combining the structural and layout templates 5 . The application is then deployed into the portal. In our example, the PIM portal is extended and features the additional picture tagging application 6 .
The rst step of implementing the PIM 2.0 system was to implement an object database that supported the concept of information components. In a second step, we implemented a Web application on top of the database that allows users to manage their personal information space by creating, composing and accessing information components through a portal-style interface.
Figure 4 provides an overview of the PIM 2.0 architecture. The system has two main parts|the Interface Manager and the Component Manager. The Component Manager is responsible for the creation and manipulation of information components as well as the management of the template assignments. The Interface Manager manages the template repository where the default structural and layout templates as well as user-de ned templates are stored. Structural templates are written in an implementation-independent XML dialect whereas layout templates are written in an implementation-dependent manner since they are part of the underlying UI technology.
The component manager is implemented as a metamodel extension
module [
Generated Applications
Application Manager UI
HTTP Interface Manager
Interface Cache Template Repository
Runtime Compiler Interface Generator
View Repository
Component Manager Template Assignment
Events
Pictures
Contacts
The Web client o ers a portal interface to a user's PIM system, where components are represented as portal applications. The Application Manager is also a portal application embedded within the PIM interface. The UI was implemented using the OpenLaszlo Web application framework. The OpenLaszlo architecture allows Web applications to be speci ed using a declarative XML syntax, Openlaszlo XML (LZX), that is then compiled to Flash on-the- y. As an immediate bene t, this architecture allows us to compile automatically generated OpenLaszlo applications dynamically at runtime. We make use of this functionality to automatically load newly created applications into the PIM interface upon invocation of the view generation process on the server side. 6
Our approach combines the advantages of prede ned, no-schema and schemalater approaches to PIM by o ering users a set of PIM components that can either be imported from a global registry or are already present in a user's local information space. The user can then extend or compose these to create new information components according to their information needs as they evolve.
While reuse in databases has been considered at the architectural level in
terms of component database systems [
Our studies of existing PIM systems and also various Web 2.0 platforms such as Facebook shows that PIM application schemas tend to be rather small and simple. Users therefore tend to nd PIM schemas easy to understand and our initial experiences with PIM 2.0 suggest that they have no problems to work with and compose our information components. However, this is something that requires detailed studies in the future.
We have presented the concept of information components as a mechanism for allowing users to construct their personal information space in a plug-and-play style of composing schemas and data. By supporting reuse within and across PIM systems, we believe that the more advanced Web users can create and share components with other users, while non-expert users can bene t from the expertise and experience of the community similar to collaboration evident in many Web 2.0 communities.