The web and converged services paradigm promises tremendous flexibility in the creation of rich composite services for enterprises and end users. The flexibility and richness offers the possibility of highly customized, individualized services for the end user and hence revenue generating services for service providers (e.g. ASPs, telecom network operators, ISPs). But how can end users (and enterprises) specify their preferences when a myriad of possibilities and potential circumstances need to be addressed? In this paper, we advocate a solution based on policy management where user preferences are specified through forms but translated into rules in a high-level policy language. This paper identifies the requirements for this kind of interpretation, and describes the Houdini system (developed at Bell Labs) which offers a rich rule-based language and a framework that supports intuitive, forms-based provisioning interfaces.

The web services paradigm holds the promise of tremendous flexibility in how services are combined to meet the needs of individual end-users. The “convergence” of networks (wireline telephony, wireless, data) further enhances the web services paradigm, by enabling the incorporation of real time contextual information (e.g., presence and location) along with opportunities for web services to impact the physical world more immediately (e.g., a vending machine delivering a soda based on a purchase via a cell phone). But it will not be possible for most end-users to enjoy the rich and intricate possibilities, unless a broad variety of personalization technologies are available and respect the end user’s legitimate need for privacy. This seminar begins with examples illustrating why personalization will be so important for the emerging web and converged services. The main body of the seminar focuses on 3 inter-related technologies. First is profile data management, the ability for services to share and access end-user profile data (including address, credit card, “simple” preferences, current location, current presence, ...) as appropriate for the services to be provided. Second is preference and policy management, the ability to store and execute on intricate, interrelated preferences that end-users may have (e.g., “during working hours, calls from strangers should be routed to voice-mail”; “I usually work from 9 to 6, but on Thursdays it is from 8 to 4”; ...). And third is personalized and privacy-conscious data sharing of profile data and preferences, the notion that an end-user should have complete control over what profile and preference data is shared with whom and under what circumstances and how it is interpreted. In addition to describing emerging approaches for providing these capabilities, the seminar will describe how to add value to applications by using personalization, from both the end-user and the application provider perspectives.

This paper provides detail on two key components of the Houdini framework under development at Bell Labs, that enable context-aware and privacy-conscious user data sharing appropriate for mobile and/or ubiquitous computing. The framework includes an approach for integrating data from diverse sources, for gathering user preferences for what data to share and when to share it, and a policy management infrastructure in the network for enforcing those preferences. The current paper focuses on two components of this infrastructure that are essential for mobile and ubiquitous computing, namely the framework to support self-provisioning of preferences, and the performance of the underlying rules engine.

Article Share on WebViews: accessing personalized web content and services Authors: Juliana Freire View Profile , Bharat Kumar View Profile , Daniel Lieuwen View Profile Authors Info & Claims WWW '01: Proceedings of the 10th international conference on World Wide WebMay 2001 Pages 576–586https://doi.org/10.1145/371920.372160Online:01 April 2001Publication History 48citation1,378DownloadsMetricsTotal Citations48Total Downloads1,378Last 12 Months13Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access

A great deal of corporate data is buried in network devices-such as PBX messaging/email platforms, and data networking equipment-where it is difficult to access and modify. Typically, the data is only available to the device itself for its internal purposes and it must be administered using either a proprietary interface or a standard protocol against a proprietary schema. This leads to many problems, most notably: the need for data replication and difficult interoperation with other devices and applications. MetaComm addresses these problems by providing a framework to integrate data from multiple devices into a meta-directory. The system allows user information to be modified through a directory using the LDAP protocol as well as directly through two legacy devices: a Definity(R) PBX and a voice messaging system. In order to prevent data inconsistencies, updates to any system must be reflected appropriately in all systems. This paper describes how MetaComm maintains consistency when data integration is performed across several systems with no triggers and with extremely weak typing and transactional support. We also discuss implementation details and experiences.

LDAP (Lightweight Directory Access Protocol) directories are being rapidly deployed on the web. They are currently used to store data like white pages information, user profiles, and network device descriptions. LDAP directories offer scalability advantages over current database technologies, as well as being more flexible. However, as users begin to use them for Directory Enabled Networking tasks such as provisioning network services, allocating resources, reporting, managing end-to-end security, and offering mobile users customized features that follow them, LDAP's limited functionality becomes a significant barrier to progress. For example, LDAP directories do not have active database functionality (i.e., triggers). However, triggers are necessary for monitoring changes to directories and taking appropriate actions, just as they are for databases. Such functionality is crucial to take full advantage of proposals such as the Directory Enabled Network (DEN) initiative. Currently, trigger functionality is non-standardized for LDAP and each vendor's solution is non-portable. We built the Lightweight Trigger Access Process (LTAP) gateway to provide a portable way to add triggers to a LDAP directory. We describe the trigger language, the gateway's implementation, as well as our experiences gained both during implementation and from our users. LTAP is currently being used in several projects. LTAP can be downloaded at http://ltap.bell-labs.com. Copyright © 2000 John Wiley & Sons, Ltd.

The Ode object-oriented database system supports the creation and manipulation of objects with versions. Versioning is orthogonal to type – any object in the database can be versioned at any time, and the same code works on both versioned and non-versioned instances. Object versioning is supported by many object-oriented databases (e.g. Gemstone, ObjectStore, Versant). However, the facilities are often complex and may not quite match application requirements. Furthermore, the implementation techniques are not well-documented. Ode took the approach of designing a minimal set of versioning primitives with which users can specify the exact policy they require. To illustrate the flexibility and power of these versioning facilities, we use them to implement a set of previously suggested versioning capabilities. We describe how these versioning facilities are implemented, and discuss our experience in using them. Copyright © 1999 John Wiley & Sons, Ltd.

Database programming languages (DBPLs), fourth generation languages (4GLs) and embedded SQL all include the ability to iterate sequentially through a set/relation. Nested iterators can be used to express joins. Without program analysis, such joins must be evaluated using a tuple-at-a-time join algorithm at a central site, otherwise program semantics may be violated. This paper's analysis often allows parallel join algorithms to be used. Also, this paper's compile-time optimizations can produce better parallel code than a straightforward parallelization of the nested iterators. The transformations allow the compiler to identify parallelization opportunities that it could not detect in the original code. These techniques are important for aiding the migration from hand-optimized code on a sequential machine to system-optimized code on a parallel machine. Without such rewrites, moving to a parallel system may produce only meager performance improvements when porting legacy systems.

Materialized views and view maintenance are becoming increasingly important in practice. In order to satisfy different data currency and performance requirements, a number of view maintenance policies have been proposed. Immediate maintenance involves a potential refresh of the view after every update to the deriving tables. When staleness of views can be tolerated, a view may be refreshed periodically or (on-demand) when it is queried. The maintenance policies that are chosen for views have implications on the validity of the results of queries and affect the performance of queries and updates. In this paper, we investigate a number of issues related to supporting multiple views with different maintenance policies.

The Ode object-oriented database provides sophisticated trigger facilities. We illustrate their use and capabilities by writing a non-trivial trigger application–a stock market monitoring application. We will then describe our experiences in using the Ode trigger facilities to build the stock monitoring application. Our experiences with the performance and expressiveness of Ode triggers reveal advantages and limitations of the current system. Finally, we propose future work to remove the limitations. ©1997 by John Wiley & Sons, Ltd.

Ode is an active database system and environment based on the object paradigm. Triggers are the basic ingredient of active databases. Ode triggers are event-action pairs. An event can be a composite event (i.e. an event composed from other events). Composite events are detected by translating the event specifications into finite state machines. In this paper, we describe the integration and implementation of composite event-based triggers into the Ode object database. We focus on implementation details such as the basic trigger events supported, the efficient posting of these events, the handling of transaction-related events and the integration of triggers into a real database. We also describe the run-time facilities used to support trigger processing and describe some experiences we gained while implementing triggers. We illustrate Ode trigger facilities with a credit card example.

Database programming languages like O2, E, and O++ include the ability to iterate through a set. Nested iterators can be used to express joins. This paper describes compile-time optimizations similar to relational transformations like join reordering for such programming constructs. This paper also shows how to use a standard transformation-based optimizer to optimize these joins. An optimizer built using the EXODUS Optimizer Generator [GRAE87] was added to the Bell Labs O++ [AGRA89] compiler. We used the resulting optimizing compiler to experimentally validate the ideas in this paper. The experiments show that this technique can significantly improve the performance of database programming languages.