Key Moments
From Composing Services to Composing Gadgets
Google TalksWant to know something specific about what's covered?
We've already dissected every moment. Ask and we will deliver (with timestamps).
Key Moments
A new spreadsheet-based environment allows end-users to compose web services into personalized applications, similar to creating custom gadgets. This approach offers greater flexibility and scalability than traditional service composition architectures.
Key Insights
The spreadsheet metaphor, previously fundamental to personal computing, is being re-envisioned as a tool for end-users to compose web services into personalized applications and processes.
Gadgets, initially seen as simple user interfaces, are reframed as fundamental building blocks for distributed applications, sitting atop service-oriented architectures.
The proposed Husky system uses a spreadsheet interface to define service composition by treating each cell as an event, allowing for intuitive expression of concurrency and non-determinism.
A novel three-tiered distributed architecture, called USCA, separates interaction elements into distinct services, offering more granularity and flexibility in scheduling compared to orchestration, choreography, or multi-agent systems.
Experiments show that the USCA architecture provides significantly better execution times than other architectures for a given number of host machines, due to its enhanced flexibility in mapping functional elements to services and scheduling them.
The Husky tool translates spreadsheet-based gadget compositions into Python code, enabling efficient execution in distributed environments, while the Pi tool translates a simple service composition language into a mix of BCLR and WSDL for mobility.
Reimagining the spreadsheet for service composition
The presentation introduces Husky, a new environment that leverages the familiar spreadsheet metaphor for designing and composing web services. The analogy of spreadsheets revolutionizing personal computing is drawn, suggesting that this paradigm can be extended to organizing and giving semantic meaning to web resources. Unlike traditional approaches that might rely on complex programming languages or automated semantic web processes, Husky aims to empower end-users, even those without extensive programming experience, to build complex, distributed web processes by composing existing services. This approach acknowledges the difficulty of building inherently distributed and parallel systems, even for professional programmers, and proposes a user-friendly alternative.
Gadgets as building blocks for distributed applications
The core idea behind gadget composition is to treat individual gadgets not merely as user interfaces to services, but as the fundamental, top-level building blocks of distributed applications. This perspective positions gadgets as an abstraction layer above traditional service-oriented architectures. The presentation illustrates this with an example of composing two bookstore gadgets to find the best book offer. Initially, this would require manual retyping and re-entering information. However, by composing these gadgets into a single, new gadget, the process becomes streamlined. This new composite gadget is built using a blank 'Pinocchio' gadget, to which existing gadgets are assembled, defining inputs, outputs, and the sequence of events that govern their interaction.
Designing composite gadgets with spreadsheet-like temporal ordering
The Husky system utilizes a spreadsheet interface to define how a composite gadget functions. Users define the input (e.g., book title) and output (e.g., best offer) of the new gadget. The core logic is then built by populating cells in a spreadsheet, where each cell represents an event or a step in the process. These cells are arranged temporally, moving from top to bottom or left to right to indicate the sequence of execution. The spreadsheet’s grid naturally allows for the intuitive expression of concurrency; by placing events in separate 'event sequences' or rows, they can be executed in parallel, thus reducing overall response time. Conditional events can also be defined, allowing for dynamic execution paths based on the outcomes of previous steps. This temporal and spatial arrangement in the spreadsheet provides a powerful yet accessible way to design complex workflows.
Translating gadget logic to service-oriented execution
The composition defined in the Husky spreadsheet is then translated into a service-oriented execution model. It is assumed, for simplicity, that each gadget corresponds to a single service. For instance, a 'get price' event in a gadget translates to calling a 'get price' operation on a specific service (e.g., 'foodbook.com/get_price'). To enable distributed execution, additional services are introduced for input (user interaction) and communication. Queues are used as a mechanism to transfer data between service calls, ensuring that results from one service can be used as parameters for another. The system can also employ communication mechanisms like CBR (Content-Based Routing) and token-based synchronization to manage data flow and ensure proper execution order across distributed components.
The USCA architecture for flexible service composition
To address the limitations of existing service composition architectures (orchestration, choreography, multi-agent systems), a new three-tiered distributed architecture called USCA (Uncoupled Service Composition Architecture) is proposed. This architecture extends the traditional functional and coordination elements to include interaction elements. These interaction elements, such as queues or synchronization mechanisms, are decoupled and can be implemented as separate services. The key advantage of USCA is its flexibility; it imposes no constraints on how functional elements (computation, coordination, interaction) are mapped to services or how these services are scheduled onto host machines. This granular mapping allows for a more efficient distribution of workload across available resources.
Performance and scalability benefits of USCA
Experiments have demonstrated that the USCA architecture offers significant advantages in terms of performance and scalability compared to traditional approaches. By allowing each functional element to be mapped to a separate service and potentially scheduled on a distinct machine, USCA can distribute the definition of a gadget across more host machines than other architectures. Graphically represented results show that for any given number of host machines, USCA consistently yields better execution times. This increased flexibility in scheduling not only boosts performance but also enhances the overall scalability of the system, making it more adept at handling complex and demanding distributed applications.
Tools for implementation and accessibility
The research has resulted in practical tools to support this vision. The Husky tool translates the spreadsheet-based gadget compositions into Python code, equipped with specific libraries for efficient message sending and receiving, enabling execution in distributed environments. Additionally, the Pi (Programmable Internet Environment) tool translates a simple service composition language into a mixed BCLR and WSDL language, which allows for the mobility of coordination elements. These tools make the concepts of gadget composition and flexible service execution more accessible to users and developers.
Future business models and personalized experiences
The ability for end-users to easily compose services into personalized web processes and gadgets opens up new avenues for business models. The development and personalization of gadgets can lead to a proliferation of unique applications, driving demand for hosting, development, and integration services. This fundamentally shifts the paradigm towards a more user-centric web, where personalization is not just about content display but about active creation of functionalities by the end-users themselves, potentially transforming how we interact with and build upon the internet's infrastructure.
Mentioned in This Episode
●Software & Apps
●Concepts
Gadget Composition with Husky: A Quick Guide
Practical takeaways from this episode
Do This
Avoid This
Common Questions
Current tools often require professional programming knowledge and struggle to handle inherently distributed and parallel processes, making them difficult for end-users to utilize effectively.
Topics
Mentioned in this video
A programming language used to interpret a competition language for mobility of coordination elements.
A software application for organizing and analyzing data in tabular form, considered a catalyst for the PC Revolution and a new metaphor for organizing web data.
A popular programming language used for service composition and implemented in the Husky tool.
A script language previously proposed for service composition.
The name of the proposed end-user environment for service composition, based on spreadsheets and gadgets.
A customizable webpage where users can select and arrange various widgets or gadgets.
A vision of the World Wide Web where data is published and linked in ways that are machine-readable and understandable.
The historical period of widespread adoption of personal computers.
An architectural style that structures an application as a collection of loosely coupled services.
More from GoogleTalksArchive
View all 48 summaries
58 minEverything is Miscellaneous
54 minStatistical Aspects of Data Mining (Stats 202) Day 7
45 minKey Phrase Indexing With Controlled Vocabularies
63 minMysteries of the Human Genome
Ask anything from this episode.
Save it, chat with it, and connect it to Claude or ChatGPT. Get cited answers from the actual content — and build your own knowledge base of every podcast and video you care about.
Get Started Free