Download - Toward Process Mashups
Toward Process Mashups: Key Ingredients and Open Research Challenges
Abdallah NamounUniversity of Manchester
-Daniel Florian, Tobias Nestler, Agnes Koschmider, Marcus Roy-
Overview and Strategy Understand and define process mashups Introduce three dimensions:
Multi-user support Multi-page support Workflow support
Combine these dimensions to define new classes of mashups
Investigate existing mashup development tools and classify them according to the mashups they support
Highlight some challenges and issues
Motivation Mashup development has become very matured
recently Types of known Mashups: data mashups, service
mashups, user interface mashups A new concept emerged: process mashups? The aim is to
explain process mashups and identify the dimensions of process mashups
In the paper, we define a set of new mashups based on the dimensions For each mashup, we discuss suitable application scenario
and show tool support
Definitions and background Mashup: a web application integrating data,
application logic, and user interfaces A business process: a set of activities represented
in a visual form Business processes primarily focus on the control
flow perspective and technical level of Service to Service interactions
A workflow: an executable part of a process consisting of several activities and defining a series of tasks that need to be managed by different resources
Background (cont’d) Service composition is a complex, expensive, and error prone
process requiring specialist skills and knowledge Thus, the emergence of lightweight composition and mashup
platforms Graphical mashup platforms for web development include:
Yahoo! Pipes, Open mashup, Marmite Such tools mainly support the development of data-oriented
mashups; no multiple views are supported no control-flow is supported only single users are addressed
Other tools, e.g. SOA4All PE and Serena Mashup Composer, handle business processes but are considered professional development environments
Example – Leave request scenario
A business process typically involves multiple user roles and a workflow style composition
Might require multiple views and multiple users and a central workflow Employee enters his request Manager reviews and decides on the request Notification is sent to the employee
Currently, mashup development approaches do not adequately support the creation of applications supporting the above scenario Such applications are called Process Mashups
Process Mashups Process mashups were first introduced as the
next type of mashups that consider the integration of business processes (in addition to data and presentation layers)
In our opinion, process mashups are more than simply adding business processes to data and presentation layers
Process Mashups should consider multiple users and multiple pages and organise human tasks
Ingredients of Process Mashups (1)
Support for multiple users: enabling multiple users to concurrently operate on the same instance of a mashupapplication. This is different from sharing mashups.
Motivation: current mashups do not allow multiple users to concurrently work together on the same instance
Activities in a process model can be associated to different actors who will be authorised and assigned different tasks
Challenges arising: Concurrent access: How to support concurrent access of many
users to the same view of the mashup? Role-based access: How to support cooperative access of many
users to different views of the mashup based on the role of each user?
Ingredients of Process Mashups (2)
Support for navigation among multiple connected pages: ability to organise mashup components into a hierarchical navigation structure which can be explored via hyperlinks
Challenges arising: Navigation structure: How to structure the
components into a set of well-structured and connected pages?
Navigation state: How to keep the state of the navigation in multi-page mashups?
Ingredients of Process Mashups (3)
Support for workflows: ability to specify a control and data flow over human tasks; thus to define sequences, branches, and conditional executions of work items
Data mashups are mainly data flow-based mashups without control flow
Challenges arising: Workflow: how to define a workflow for human actors over
mashups or components of mashups? Dataflow: how to propagate data from one task to another task? Integration of data, services, UIs, and people: how to coordinate
, not only human actors, but also data, web services, and the UIs the human actors need to interact with?
The New Perspective
Putting the three dimensions together results in a variety of different mashuptypes with different characteristics
Simple Mashups
Simple Mashups: address single user , single page, and do not support workflow
E.g. employee has an integrated view of his colleague’s leave requests
Such mashups serve as informational sources
No direct interaction or cooperation with the manager
Representative tool: mashArt
Simple Mahups – mashArt Enables one to abstract
from low-level implementation details
Compose simple data feeds, complex web services –round construct-, and UI components (rectangles) by wiring events of 1 component to operations of another component
Other examples: Yahoo! Pipes (data mashups), Intel MashMaker(UI mashups)
Multi Page Mashups Multi page mashups: support a single user,
multiple pages, and no workflow E.g. a list of leave requests. Upon selecting
one item from the list, the mashup opens a new page and displays additional details about an employee
Users of such mashups do not interact or cooperate with other roles
Representative tool: EzWeb platform
Multi Page Mahups – EzWeb Users combine and
wire gadgets (mini applications)
Gadgets may consist of multiple screens arranged according to a screenflow
Connections between screens are automatically created
Guided Mashups Guided mashups: address a single user, a single page,
and a workflow Offer user guidance to the user in order to accomplish her
task React on user’s input and accordingly provide next possible
activities E.g. employee invokes a leave request, the mashup
guides the user through the process (after selection of name, mashups shows leave entitlement period, employee selects type of leave request)
Representative tool: We are not aware of guided mashups tools
Page Flow Mashups Page Flow Mashups: address a single user,
multiple pages, and a workflow E.g. a mashup supporting the manager to
handle a leave request. One page provides a list of incoming leave requests. Another page to request additional information if necessary. A 3rd page provides stats about all leave requests
Representative tool: ServFace Builder
Page Flow Mahups – ServFaceBuilder
WYSIWYG approach Service composition at
the presentation layer Compose web services
using their frontends Applications = a set of
pages connected to create a navigation flow
Connections between services define dataflow
Connections between pages define control flow
Shared Page Mashups Shared page mashups: address multiple users, a
single page, and support no workflow E.g. the Amazon.com shopping together mashup
(on Programmableweb.com) enables users to shop together through MSN Messenger. Users browse the catalogue and chat to each other
Different employees working simultaneously on a single leave request
Representative tool: we are not aware of any mashup tool for this category.
Shared Space Mashups Shared space mashups: address multiple users,
multiple pages, and do not support workflow Enable multiple users to concurrently share space
= collection of mashup pages connected together and have a navigational structure.
E.g. employee shares pages with his manager and a temporary replacement. Manager previews previous leave requests of the employee
Representative tool: IBM Mashup Centre, a collection of tools to create shared mashup pages.
Cooperative Mashups
Cooperative mashups: address multiple users, a single page, and support workflow
E.g. employees jointly view a conflict on one page and decide which leave request to remove. The interaction between the employees is guided
Representative tool: Gravity (within the Google Wave environment)
Cooperative Mashups -Gravity- A lightweight collaborative
business process modelling tool
Targets non-BPM-experts Multiple users can model a
business process (model view) and its UI (application-design view) at the same time
Users can drag and drop components and draw lines
Supports multiple-users control flow, and data flow
Process Mashups Process mashups: address multiple users,
multiple pages, and support workflow E.g. a mashup providing the employee with a
web page allowing him to configure his travel arrangements (flight, hotel) and the manager with a page to decide on the employee’s request. These two pages / tasks can be put into a cycle that terminates one a decision is made.
Representative tool: MarcoFlow platform
Process Mashups – MarcoFlowPlatform
Based on the idea of distributed orchestration of UIs
Users can bring together UIs, web services, and people in a single orchestration logic, language, and tool
Covers: design –visual editor-, deployment –code generators-, and execution (distributed runtime environment)
The coordination problem is split into two levels: intra-page UI synchronisation and distributed UI synchronisation and web service orchestration , and to provide runtime environments to both client side and server side environments
Other tools: JOpera allows the definition of interaction logic between components and multiple users - no support for UI comp
Findings and Issues (1) We were not able to always provide representative
platforms for all mashup classes (e.g. guided mashups and shared page mashups)
End users –especially non-programmers- are always looking for ease of development, so “easiness to use” and “user-friendliness” are must have criteria for successful mashupstools
Mashups tools should focus on the end user in order to accommodate their skills (e.g. inability to program)
Sadly, more user friendliness and simplicity often mean less expressiveness and complexity (of resulting applications)
Findings and Issues (2) MarcoFlow satisfies alls dimensions of process mashups but is
still considered a complex tool for web users, so can we really consider MarcoFlow a mashup platform?
Runtime support: coordinating different actors requires software support that is long running and sometimes stateful.
The need for adequate identification and authentication mechanisms in case of multiple users in the execution environment
Developing process mashups is not a trivial task and requires application planning (defining user roles), design (UI design), composition (workflow, coordination of actors), implementation and execution (runtime configuration).
THANK YOU!