Conference PaperPDF Available

An Analysis of Spreadsheet-Based Services Mashup

Authors:

Abstract and Figures

Spreadsheets, a popular productivity tool, has gained attention as a potential mashup development environment targeted towards end-users. In this paper, we present a general architecture of mashup tools for spreadsheets. We also present an analysis of the state-of-the art on spreadsheet-based mashup tools. The analysis result is used to guide our research in developing a lightweight semi-automatic mashup tool using spreadsheet paradigm.
Content may be subject to copyright.
An Analysis of Spreadsheet-Based Services Mashup
Dat Dac Hoang Hye-young Paik Boualem Benatallah
School of Computer Science & Engineering
University of New South Wales,
Sydney, NSW 2052, Australia,
Email: {ddhoang, hpaik, boualem}@cse.unsw.edu.au
Abstract
Spreadsheets, a popular productivity tool, has gained
attention as a potential mashup development envi-
ronment targeted towards end-users. In this paper,
we present a general architecture of mashup tools
for spreadsheets. We also present an analysis of the
state-of-the art on spreadsheet-based mashup tools.
The analysis result is used to guide our research in
developing a lightweight semi-automatic mashup tool
using spreadsheet paradigm.
Keywords: Web services, Mashup, Spreadsheet, End-
user programming
1 Introduction
Mashup is a new application development method en-
abling users with little programming skills to create
application by reusing and combining data, appli-
cation functionalities and presentations from differ-
ent sources. Recently, we witnessed a sharp rise of
mashup tools and applications on the Web. In 2006
alone, there were hundreds of individual mashup tools
released, Yahoo Pipes1, Google Mashup Editors2, Mi-
crosoft Popfly3, IBM QEDWiki4, just to name a few.
Different mashup tools solve different problems so
that when users are embarking onto the mashup jour-
ney, they need to pick the right tool for the right prob-
lem. For example, data mashup allows users to re-
trieve data from one or several data sources, process,
mix the data and publish the result either as a feed or
another data source. Process mashup allows users to
automate processes by orchestrating services, forms
and other resources in a workflow. Web page cus-
tomization (i.e., presentation mashup) allows user to
change web sites by removing elements, adding addi-
tional widgets or changing the user interfaces (Gram-
mel & Storey 2008).
According to (Fischer et al. 2009), spreadsheet is one
of the six programming paradigms for mashup de-
velopment, along with integrated development en-
vironment, scripting languages, wiring (or piping)
paradigm, programming by demonstration and auto-
matic creation of mashup.
With spreadsheet-based mashup tool, spreadsheet
users (e.g., office workers, professional accountants)
Copyright c
2010, Australian Computer Society, Inc. This pa-
per appeared at the Twenty-First Australasian Database Con-
ference (ADC2010), Brisbane, Australia, January 2010. Con-
ferences in Research and Practice in Information Technology
(CRPIT), Vol. 104, Heng Tao Shen and Athman Bouguettaya,
Ed. Reproduction for academic, not-for profit purposes per-
mitted provided this text is included.
1http://pipes.yahoo.com
2http://code.google.com/gme
3http://www.popfly.com
4http://services.alphaworks.ibm.com/qedwiki
are provided an opportunity to access more infor-
mation, making their job more efficient. Recently,
some companies have already provided products for
spreadsheet-based mashup tool (e.g., StrikeIron, Ex-
tensio).
The motivations of using spreadsheet paradigm for
mashup tools are elaborated as follow:
First, spreadsheet is a widely used application
with millions of users (Scaffidi et al. 2005). The
popularity of spreadsheets can help increase the
level of acceptance of any mashup tool built in
the familiar environment.
Second, spreadsheet is an intuitive data manage-
ment, analysis and reporting tool with useful but
simple-to-use functions, such as import, export,
sort, visualize, etc. It could be considered as a
suitable paradigm for data mashup since most of
mashups are applications that reuse and combine
data available from difference sources.
Third, spreadsheet is a preferred programming
environment for end users with the following fea-
tures (Kandogan et al. 2005):
It offers a mixture of development environ-
ment and runtime environment facilitating
immediate feedback to the users.
It supports incremental (i.e., step-by-step)
development of an application.
It is more resilient and forgiving than most
programming languages (i.e., an error in a
cell only affects referring cells and does not
affect the whole program causing a program
crash).
In this paper, we present a qualitative survey on a
set of spreadsheet-based mashup tools. We believe
that understanding these mashup tools and other re-
lated issues will pave the way for research directions
to effectively address some of the research problems
(e.g., how users can take advantages of spreadsheet
paradigm for developing mashups).
As an illustration of spreadsheet-based mashup,
let us consider the following scenario5: Mary, a stu-
dent, is learning Spanish. To study a word, she
uses text-to-speech service (TTS), translation service
(TSL), spell-checking service (SPL) and online work-
book service (LOG). Instead of invoking these services
separately and manually link the results, she opens a
spreadsheet program, inputs an English word, writes
formulas to link these services so that the completed
formulas will now automatically suggest spelling cor-
rections, pronounce the word in English, translate the
word to Spanish, pronounce the word in Spanish then
finally write the English and Spanish words to her
5This scenario is inspired by the scenario provided in (Obrenovic
& Gasevic 2008)
Proc. 21st Australasian Database Conference (ADC 2010), Brisbane, Australia
141
online workbook. Obviously, the ability to quickly
compose such services in spreadsheet enables her to
create new applications that suit her needs and save
her time, while interacting with a tool she is already
familiar with.
Figure 1: Motivating scenario
Mary’s program is incrementally built. The “For-
mula view” in Figure 1 illustrates Mary’s tasks. First,
she specifies the location for user input by writing a
label “User input” in cell A1 and the input word “Or-
age” (in incorrect spelling format) in cell B1. Then
she invokes SPL service by putting a formula in cell
B2 (i.e., =SPL(B1)) which takes the value of cell B1
as a parameter for SPL. She will get the spelling sug-
gestion in cell B2 (i.e., “Orange”) as shown in Eval-
uation view. Similarly, she writes the formulas in
cell B3, B4, B5 and B6 step by step to get the voice
from TTS, TSL and LOG. The mashup application
is enacted when Mary changes the value in cell B1.
Spreadsheet paradigm will automatically trigger the
evaluation of formulas in dependent cells and produce
results.
The remainder of this paper is organized as fol-
lows. Section 2 presents a general architecture of
spreadsheet-based mashup tools. Section 3 intro-
duces a number of mashup tools using spreadsheet
paradigm. In sections 3 and 4, we discuss four dimen-
sions used in our survey and evaluates tools according
to the dimensions. We conclude the paper and have
a discussion on future work in section 6.
2 General Architecture of Spreadsheet-
Based Mashup Tools
When reviewing frameworks, it helps to have imple-
mentation architecture in mind. We describe here a
general architecture of the spreadsheet-based mashup
tools. Through the architecture, the readers should
be able to picture how a mashup application is built
in a spreadsheet. As depicted in the Figure 2, the
architecture comprises of four elements:
Spreadsheet Interface (1). This element is
a conventional spreadsheet interface which in-
cludes a grid of cells and a formula editor. Cells
are capable of storing values and formulas, while
formula editor allows users to build mashup ap-
plications by specifying composition logic and
layout information. The spreadsheet interface
plays a role as the development environment in a
mashup tool. For example, in the Mary’s sce-
nario, Mary writes her mashup application in
spreadsheet interface using formula as illustrated
in Figure 1.
Component Repository (2). This element is
a repository of all mashup components available
in the tool. Users choose an external resource
(e.g., web service, file, database or application)
and create a component that allows them to in-
teract with the resource within the tool. This
component can be assigned a friendly name (i.e.,
alias) for the spreadsheet formula editor. For ex-
ample, in the scenario of Mary’s, SPL is a com-
ponent representing a SOAP-based service that
suggests correct spelling of words. It is created
based on the WSDL document of the spelling
service.
Mashup Engine (3). This key element is re-
sponsible for evaluating the formula (i.e., compo-
sition logic) and “wire” mashup components to-
gether. It operates in a centrally-mediated fash-
ion and plays a role as a server to manage the
execution flow among components. Since most
of spreadsheet tools do not allow users to mod-
ify their formula evaluation mechanisms, mashup
engine could be developed as an extension to
spreadsheet evaluation engine. Mashup engine
is also responsible for maintaining the formula
evaluation context (i.e., the mashup result) and
facilitate the reaction to cell modification by trig-
gering the re-evaluation of dependent formula
(i.e., upon a service invocation returns, the corre-
sponding references need to be updated with the
returning value). For example, in Mary’s mashup
application, whenever she change the input value
in cell B1 (e.g., change “Orage” to “Lemoon” -
both are in incorrect spelling format), the for-
mulas in cells B2-B6 will be re-evaluated by the
engine to create new results.
Wrappers (4). Wrappers facilitate interop-
erability among resources which have different
data formats (e.g.,HTML, XML, RSS, etc) or use
different access protocols (e.g., HTTP, SOAP-
based, REST-based, etc). For example, we need
different wrappers to create components to cor-
rectly serve the Mary’s scenario, such as SOAP-
based service wrapper for SPL service, REST-
based service wrapper for LOG service or appli-
cation specific wrapper for TTS service.
3 Spreadsheet-Based Mashup Tools
In this section, we introduce the spreadsheet-based
mashup tools we studied for evaluation. For more
detailed classification and description of these tools,
readers are referred to (Hoang et al. 2009).
In these tools, the spreadsheet itself is a productiv-
ity tool which now equipped with functions to access
external resources (e.g., services in the Web, files in
desktop computer, databases, etc). Data from exter-
nal resources are placed in cells, wired to each other
to create a mashup application (e.g., output data of
a service can be used in the input fields of another
service).
We review the following tools: spreadsheet con-
nectors for mashup engines, StrikeIron (Brauer n.d.),
Extensio Extender6, A1 (Kandogan et al. 2005),
AMICO-CALC (Obrenovic & Gasevic 2008), Husky
(Srbljic et al. 2007).
1. Spreadsheet connectors for mashup engines.
JackBe Presto7, IBM Mashup Center8, and
Kapow9are mashup engines which provide sep-
arate “spreadsheet connectors” , allowing Mi-
6http://www.extensio.com/products/ExcelExtend.html
7http://www.jackbe.com/products/excel connector.php
8http://www.ibm.com/developerworks/blogs/page/etech?entry=
mashup center import for mirosoft
9http://kapowtech.com/
CRPIT Volume 104 - Database Technologies 2010
142
Figure 2: Common architecture of mashup tools using spreadsheet paradigm
crosoft Excel spreadsheet users to consume ex-
isting mashup applications directly from their
spreadsheets. These spreadsheet connectors al-
low the end-users to easily re-use already-buit
mashups (outside spreadsheets) in the spread-
sheet environment. However, they are not
fully-functional spreadsheet-based mahup tools
in their own right.
2. StrikeIron SOA Express for Excel and Extensio
Extender for Microsoft Excel10 are commercial
data mashup tools using spreadsheet paradigm.
The basic idea of these approaches is that they
allow the data contained in the web services to
be pulled in Microsoft Excel workbook, “live”
in cells, and integrated directly by users while
still take advantages of all the analytical powers
and flexibility of the spreadsheet tool. StrikeIron
and Extensio Extender use SOAPful web services
to create mashup applications by “hooking” the
output value of one service with the input pa-
rameter of another service.
3. AMICO:CALC is an OpenOffice Calc exten-
sion that let users configure and connect services
through a spreadsheet interface. Users manu-
ally write formula to compose the services in
order to create a mashup. The execution is
based on Adaptable Multi-Interface COmmuni-
cator (AMICO) middleware platform for compo-
nent integration. In AMICO:CALC, variables
are considered as services in order to be used
in spreadsheet. Users are provided some pre-
defined functions to read value from and assign
value to variables (i.e., to get data from and
post data to services). For example, the expres-
sion Amico Read(“spelling suggestion”) will
receive a value when the spelling service finishes.
AMICO provides a control panel tool where users
can read description of variables exported by ser-
vices, change their values or names.
4. A1, also known as Autonomic Task Manager
for Administrators, is a research prototype from
IBM. It facilitates a programming environment
for system administrators. With A1, users not
only use a spreadsheet-like environment with a
task-specific language to access remote and het-
erogeneous systems but also gather, integrate
status data and orchestrate control of different
systems. A1 extends conventional spreadsheets
by:
Allowing cells to contain arbitrary Java ob-
jects.
10We will call StrikeIron and Extensio Extender for short
Extending cell formulas to include calls to
methods of cell objects.
Allowing cells to contain procedural code
blocks whose execution is triggered by
events in the sheet.
5. Husky is a service composition tool. It extends
the spreadsheet paradigm enabling users to intu-
itively express composition logic through a spa-
tial arrangement of component services within
spreadsheet cells.
4 Evaluation
We have installed and tried the tools mentioned in
the previous section. Borrowing lessons from appli-
cation integrations, we believe that a spreadsheet-
based mashup framework needs the definition of
four basic elements: component model, composition
model, development environment, and runtime envi-
ronment. Here, we summarize and compare the fea-
tures across four dimensions: component model, com-
position model, development environment and run-
time environment.
4.1 Component Model
This dimension determines the nature of components
by means of the following properties:
4.1.1 Component Data Model
A data model, as defined in (Ullman 1990), contains
a notation for describing data and a set of opera-
tions used to manipulate that data. In our surveyed
mashup tools, the data model extends spreadsheet
data model to accommodate heterogeneous resources
from different sources (e.g., web services, databases,
files). Spreadsheet is a collection of cells organized in
a tabular grid. Each cell is identified by its coordi-
nates and contains either empty or atomic type val-
ues. Traditional spreadsheets have limited of atomic
types, such as number, string or datetime. Some
spreadsheets extend the atomic types so that the cells
can contain complex types such as object or XML
document. We identify two data models which are
currently used in the mashup tools: grid-based and
object-based.
In the grid-based model, data is presented in a
range of cells and each cell contains an atomic data
value (i.e., number, string, datetime). Using this data
model, complex data need to be transformed into two-
dimensional structure of the model. For example, in
AMICO:CALC, a service invocation may return an
Proc. 21st Australasian Database Conference (ADC 2010), Brisbane, Australia
143
XML document with complex structure (e.g., nested).
In order to display the output, AMICO:CALC uses
service adapters to linearize the complex structure
to a set of variables, which can be easily mapped to
spreadsheets cells and formulas. This transformation
at the component data model level means that user
does not have to deal with complex hierarchical struc-
tures.
In the object-based model, since the spreadsheet
cell is extended to contain complex types, a complex
XML document can be mapped to a single cell. For
example, A1 extends conventional spreadsheets by al-
lowing cells to contain arbitrary Java objects and for-
mulas call to methods in cell objects. The following
code snippet illustrates object-based data model used
in A1:
C1: ‘149.171.225.4’
C2: JMX("http://example.net/IPtoCountry?wsdl")
C3: = C2.IP2Country(C1)
Cell C1 contains a string value represents an IP ad-
dress. In cell C2, we use JMX (Java Management
Extensions) binding to a SOAP service, namely IP-
ToCountry. This web service has two operations:
IP2Country() and Country2IP() which returns a
country name of a given IP address and vice versa.
In cell C3, we invoke IP2Country() operation of this
web service and the result is returned as an XML
document.
To illustrate the differences between two compo-
nent data models, let us consider an example given
in Figure 3 which shows an RSS feed of Google news
service. The grid-based model is presented in Fig-
ure 3(a). The news, presented as an XML docu-
ment, is mapped to the range of cells B1:C9. Figure
3(b) shows how the data could be presented using
the object-based model. In which, the news data
is mapped to cell B1. Each element of the news
could be accessed by using “dot” notations in the
mapping definition. For example, the “channel lan-
guage” element can be put in cell B2 by using formula
=B1.language.
4.1.2 Component Access Model
Components are entities that allow users to interact
with external resources inside a mashup tool. Re-
sources can have heterogeneous data formats and use
different access protocols. In this dimension, we in-
vestigate different data formats and access protocols
supported by the mashup tools.
Some of the common data formats available in
component services could be HTML, XML, RSS,
Atom Syndication Format, JSON (Javascript Object
Notation), spreadsheet, text file or RDF (Resource
Description Framework).
The access protocols could be HTTP, TCP, UDP,
SMTP, REST, SOAP, RPC or user-specific applica-
tion protocols.
Most of the tools we studied provide support for
REST and SOAP protocols using XML data format
due to the prevalence of REST- and SOAP-based ser-
vices. Some tools allow users to “mash” with other re-
sources such as plain files, database, web applications
or even legacy applications. This could greatly ex-
pand component resources from which users can make
richer and better mashup application. For exam-
ple, AMICO:CALC supports various communication
protocols (e.g., TCP, UDP, XML-RPC, Open Sound
Control, HTTP, SOAP, SQL and some application-
specific interfaces such as Sesame RDF, WordNet,
etc) for interconnecting services with different inter-
faces.
4.1.3 Extensibility
Extensibility defines the ability of a mashup tool sup-
porting users to define their own functionalities (e.g.,
creating components, defining new mashup opera-
tors). Normally expert users use a general purpose
language (e.g., Java, C#) to achieve this extension.
For example, A1 allows users to extend the func-
tionality of the tool to best suit their need by de-
veloping custom plug-in components. These plug-in
components provide new interaction capabilities and
functionalities and could be developed by creating
new Java class extending A1Component class. The fol-
lowing code snippet illustrates an example of a user
defined component named SampleComponent:
package com.ibm.a1.plugin.api.samples;
public class SampleComponent {
String name;
public SampleComponent(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
After deployed, in A1 spreadsheet’s cell users can cre-
ate “samples” object and invoke its methods.
Extensibility can also be achieved by modifying
existing functionality provided by the tool. For ex-
ample, AMICO:CALC provides a generic adapter for
services using TCP. Users can modify (or parameter-
ize) this adapter to facilitate accessibility for a specific
application using TCP protocol (e.g., a game).
4.2 Composition Model
This dimension determines how components can be
glued together through the following properties:
4.2.1 Mashup Strategy
This dimension identifies the mashup strategy used in
spreadsheet mashup tools. We classify mashup strat-
egy into two categories:
The first category concerns the time when a
mashup application is created. This could be at
design time or run time. Static mashup takes
place during the design time when users plan the
logic and components to be used in the mashup
application. Components are selected, linked to-
gether and finally compiled and deployed. This
strategy is suitable with a scenario when com-
ponents and services are stable (e.g., in term of
availability) and rarely change (e.g., data struc-
ture).
When the component providers frequently
change the structure of data or business logic,
static mashup is too restrictive and requires users
to re-built mashup application adapting to the
changes. Dynamic mashup may solve this prob-
lem by adapting to unpredictable changes at the
run time. The web environment is highly dy-
namic where new services become available and
change frequently. Ideally, mashup application
should be able to transparently adapt to envi-
ronment changes, and to adapt to customer re-
quirements with minimal user intervention.
CRPIT Volume 104 - Database Technologies 2010
144
Figure 3: Component data model
The second category concerns the way users build
mashup application which could be either man-
ual or automatic. In manual mashup, users man-
ually describe the composition logic (i.e., data
flow and control flow) for mashup application.
This makes the development process of mashup
application tedious, error-prone and time con-
suming. On the contrary, automatic mashup
does not require users to be involved in low-level
development process. Instead, users only need
to provide high level requirements or goals of
mashup application. The mashup tool will au-
tomatically suggest or choose composition plan
based on given context or semantic of applica-
tion and components.
4.2.2 Orchestration Style
Orchestration describes the arrangement, coordina-
tion and management of components in mashup ap-
plication. It contains business logic of mashup ap-
plication specifically about execution order of com-
ponents. There are three orchestration styles could
be used in spreadsheet paradigm, namely flow-based,
layout-based and event-based:
Flow-based. In flow-based orchestration style,
mashup applications are built by using natural
data flow and control flow created by cell depen-
dencies in spreadsheet (i.e., linking one service’s
output into another service’s input fields). For
example, as shown in “Formula view” in Figure
1, Mary’s scenario can be implemented by “hook-
ing” output of SPL service in cell B2 with input
field of TSL service in cell B4. This orchestra-
tion style is naturally supported by spreadsheet
paradigm and easy to use. However, as discussed
in (Hoang et al. 2009) it has limitations when
users need to build a mashup application with
complex control flow logic.
Layout-based. In layout-based orchestration
style, users are allowed to explicitly define the
execution order of components in mashup appli-
cation by organizing spatial position of compo-
nents. For example, in Husky, the execution or-
der of mashup application is defined by spatial
organization of services in a grid of cells. Husky
transforms the spatial organization of services’
events into their ordering in time. Time pro-
gresses from left to right and from top to bot-
tom in cell blocks. A set of adjacent cells makes
a sequence of events, while empty cells disjoin
the workspace into temporally independent event
sequences. Let consider Mary’s scenario imple-
mented by using Husky as shown in Table 1 be-
low: The execution flow is defined by a sequence
of services in adjacent cells from C2 to C7. The
conditional split defined in cell C3 will trigger
the operation in cell C4 if the content of cell C2
is not empty (i.e., like “goto” or “jump” state-
ment in some programming languages). The rest
of the program is evaluated according to the fol-
lowing order: evaluate formula in C5, C6 and fi-
nally C7. By explicitly defining the control flow,
this orchestration style gives the users the bene-
fits of generality and extensibility. However, it
may break the philosophy of spreadsheet pro-
gramming and increase the learning curve.
Event-based. In event-based orchestration
style, the execution flow of mashup application is
determined by user actions (e.g., button clicks,
key presses, etc) or interactions with other
services (i.e., the completion of an action in one
service may cause an action in other service).
For example, in the A1 system, each cell is an
arbitrary Java object. Each object is associated
with a listener which is designed to manage
events. The listener explicitly triggers the
execution of a code block based on a condition.
There are two listener constructs: on() is used
to trigger an operation based on events and
when() is used to trigger an operation based
on boolean expression. Mary’s scenario can be
implemented in A1 as shown below in Table 2:
Services definitions are defined from cell B1 to
A B
1SP Lser vice(“address”)
2T T Sser vice(“address”)
3T SLser vice(“address”)
4W orkbook Service(“address”)
5Orage;
6Button();
7on(B6) B1!Spell(B5);
8when(B7<>“”) B2!V oiceEN(B7);
9when(B7<>“”) B3!E2S(B7);
10 on(B9) B2!V oiceSP (B9);
11 on(B10) B4!Send(B7, B 9);
Table 2: Event-based orchestration style in A1
cell B4. The program starts when user clicks
Proc. 21st Australasian Database Conference (ADC 2010), Brisbane, Australia
145
A B C
1 Orage
2 http://spl.com Execute[A2] “GetSpell”[A1]
3 If [C2]<>“” Then Set Clock To [C4]
4 http://tts.com Execute[A4] “Voice EN”[C2]
5 http://tsl.com Execute[A5] “Translate”[C2]
6 Execute[A4] “Voice SP”[C5]
7 http://log.com Execute[A7] “Send”[C2][C5]
Table 1: Layout-based orchestration style in Husky
on the button defined in cell B6. Based on the
user-generated event (i.e., button clicked), the
formula in cell B7 returns a spelling suggestion.
Based on the value of cell B7 (i.e., the output
of spelling service), two formulas in cell B8 and
B9 are evaluated. Similarly, the execution of
formula defined in cell B10 and cell B11 are
based on events generated by the execution of
formulas in cell B9 and B10, respectively.
4.2.3 Data Passing Style
This dimension identifies how the data is passed be-
tween components. There are two data passing styles:
Data Flow. In this style, data is passed from one
component to another component. For example,
in Mary’s scenario, the data from output of SPL
service in cell B2 is directly transferred to input
field of TSL service in cell B4. This is the default
data passing style of spreadsheet applications.
Blackboard. In this style, data is read from and
written to a shared data repository (e.g., vari-
able). For example, AMICO:CALC uses vari-
ables (which encapsulate services’ data struc-
ture) to abstract the heterogeneity of services.
Users are provided with various predefined func-
tions (e.g., Amico Read,Amico W rite, etc)
to get data from and post data to services.
The formula Amico Read(“SPL”) will receive
a value when the spelling services finished.
Amico W rite(“SPL”, B 1) will assign value in
cell B1 to the variable SPL. This data passing
style is used mainly in programming languages.
The dominant data passing style using in the evalu-
ated tools is data flow. This could be explained by
the fact that the data flow model is easy to use and
exists in most of mashup tools (e.g., Yahoo pipes) and
is naturally support by spreadsheet paradigm.
4.3 Development Environment
This dimension identifies the characteristics of the de-
velopment environment offered by a mashup frame-
work through the following properties:
4.3.1 Target Users
We identify three types of users in spreadsheet-based
mashup tools: developer, skilled user and novice user.
A developer, who is the most skillful user, should be
familiar with programming, web technologies, differ-
ent APIs as well as the usage of mashup tools. A
skilled user has no programming skills but does have
detailed functional knowledge about some technolo-
gies and a specific mashup tool. Novice user only has
knowledge on the functionality of spreadsheet and be
able to use some simple spreadsheet formulas and op-
erations (e.g., make a cell reference, copy and paste
the content of a cell).
Most of the tools target at spreadsheet users who
have limited programming skills. For example, users
of Extensio Extender do not need to spend too much
learning effort in order to use the tool since the pro-
gramming metaphor of the tool is similar to spread-
sheet programming style. Some tools extend the
spreadsheet paradigm to accommodate new orches-
tration style and require users to learn a specific for-
mula syntax in order to create a mashup applica-
tion. For example, in A1, the user needs to learn how
to write procedural codes within a cell formula. Or
users need to learn the rule for spatial arrangement
of services as well as four special objects (namely,
Clipboard, Queue, TokenCenter and BrokerCenter)
in Husky spreadsheet in order to define flow control
of service invocations.
4.3.2 Search-ability
Search-ability expresses the ability of a mashup tool
helping users in finding desired components (or even
mashup application) created by others. There are
three types of search:
Text/Keword-based. Users can search on the ti-
tle, description or tags of components by speci-
fying keywords.
Browsing. The tool displays a list of components
in a typical file-finder or folder-subfolder fashion.
Context-specific suggestion. The tool provides
(or suggests) the needed component to users de-
pending on the users’ context without having to
search.
Within the evaluated mashup tools, there is no tool
that offers context-specific suggestion to the users.
Having context-awareness could lead to the possibility
of having a framework that relies on the context and
incrementally guiding users in developing mashup ap-
plications. Browsing capability could make users feel
conformable when they want to find desired compo-
nents since it classifies components and services into
different categories in a conventional manner. For
example, StrikeIron provides browsing capabilities to
its “Web service Marketplace” which has different
categories (e.g., Communication, Financial, Market-
ing, E-Commerce, Utilities, etc). Text-base search-
ing is useful when users know the name or descrip-
tion of components. AMICO:CALC provide the text-
based searching capability for finding components in
its middleware control panel.
4.3.3 Community Features
One of the most important factors that could lead to
the success of an end-user development tool is com-
munity support (Nardi 1993). Some of the desirable
community support features are:
Sharing and reusing. Components and mashup
applications are created by one user but they can
be run, copied or modified by other users.
CRPIT Volume 104 - Database Technologies 2010
146
Collaborating. Users can co-operate to create or
modify mashup applications.
Discussion. A framework is provided with a fo-
rum or chatting capability for users to exchange
ideas, help each other in order to build a com-
munity.
To support collaboration among users, application in
A1 can be deployed as portlets in a J2EE-based web
portal server. In the portal, a user can execute or
customize program deployed by other users. This is
possible because all A1 spreadsheet is created in Java
Swing-based client application which can be launched
within the web portal framework using Java Web-
Start. Users can either save spreadsheet locally for
personal use or to server repository for sharing with
others. Extensio Extender and StrikeIron also sup-
port community features (e.g., sharing and discus-
sion).
4.3.4 Software Engineering Aspects
This dimension concentrates on the software engineer-
ing aspects including the following aspects:
Debugging. Users can locate and fix errors (in-
cluding composition logic error, syntax error,
etc).
Testing. Users can investigate the quality of
mashup application with respect to the context
in which it is intended to operate.
Version control. Users can manage the changes
and multiple users can access and modify a
mashup application.
The surveyed mashup tools mainly focus on offer-
ing functionalities for creating mashup applications.
The overall support for software engineering aspects
such as debugging and version control is very lim-
ited. There is only AMICO:CALC supports debug-
ging capability. In AMICO:CALC, debugging is en-
abled through the use of middleware control panel
for monitoring all the variables that are exchanged
among services.
4.4 Runtime Environment
This dimension expresses how the results of mashup
are delivered to users.
4.4.1 Mashup Engine
We identify two types of mashup engine could be used
in the spreadsheet-based mashup tools: (i) mashup
engine that based on spreadsheet evaluation engine;
and (ii) mashup engine that developed as a plug-in to
spreadsheet application. On one hand, spreadsheet
evaluation engine could be used for data mashup by
using natural data flow created by cell dependencies
in spreadsheet. The mashup application executed us-
ing this mashup engine must use spreadsheet pro-
gramming metaphor (e.g., using formula, cell refer-
encing, etc). For example, in StrikeIron, a very sim-
ple data mashup can be implemented by linking one
service’s output into another service’s input fields.
On the other hand, mashup engine can be devel-
oped separately from spreadsheet evaluation engine.
The mashup application does not need to conform
to spreadsheet programming metaphor. Tools which
use layout-based and event-based orchestration styles
usually have this type of mashup engine.
4.4.2 Execution Type
We identify three types of execution could be used
in mashup tools, namely centralized,distributed and
hybrid. Centralized execution is similar to the client-
server paradigm. In this case, the server is the cen-
tral scheduler that controls the execution of the com-
ponent services in a mashup application. The dis-
tributed paradigm in contrast expects the services to
share their execution context. Each component ser-
vice has its own coordinator, which has to collaborate
with the coordinators of the other services, to guar-
antee a correct ordered execution. Hybrid form of the
distributed and centralized paradigms may be coor-
dinator that controls not only one but a set of web
services (Benatallah et al. 2003).
All of surveyed mashup tools have centralized ex-
ecution type. For example, the execution of mashup
program in AMICO:CALC is based on a middle-
ware named Adaptable Multi-Interface COmmunica-
tor which is a centralized platform facilitates adap-
tation, abstraction, and mediation for diverse service
interfaces. The middleware maintains a list of vari-
ables which encapsulate data structures used by ser-
vices and can be easily mapped spreadsheet cells.
4.4.3 Exception and Transaction Handling
Exception handling is a collection of mechanism sup-
porting the detection, signaling and after-the-fact
handling of unusual events whether erroneous or not
(Burnett et al. 2000). In programming languages, ex-
ception handling is considered as necessity part and
exists in almost all of application development tools.
However, existing spreadsheet mashup tools have very
limited support for exception handling. In spread-
sheet, exception handling is compatible with reason-
ing model of spreadsheet formula. For example, in
Microsoft Excel, when an operation detects an excep-
tion, it will return one of seven possible error values
(e.g., NULL,DIV/0,VALUE,REF,NAME,NUM,
N/A). The error value model used in spreadsheet is
different from the use of status flag in traditional pro-
gramming language in the sense that it can be ignored
so that the error may not cause the whole “spread-
sheet program” to crash.
A transaction is an atomic operation which may
not be divided into smaller operations. Transaction
handling is a mechanism supporting the ACID (i.e.,
Atomic, Consistent, Isolated, and Durable) proper-
ties of transactions. In our surveyed mashup tools,
transaction handling is not supported.
5 Summary of Evaluation
So far, we have discussed different dimensions using
in this survey. In this section we discuss our analysis
result and summarize it in Table 3.
The majority of tools have grid-based component
data model. This design choice can be explained
by the fact that using grid-based model there is no
need to extend traditional spreadsheet data model to
present data. The issues of how to map structured
data to spreadsheet data model have been addressed
by existing works. For example, (Kongdenfha et al.
2008) provides a set of widgets for presenting com-
plex data in spreadsheet paradigm, namely content,
repeater, hierarchical, index. (Brauer n.d.) provides
a drag and drop interface for manually mapping data
to target location in spreadsheet. Ob ject-based data
model is more sophisticated since it encapsulates ob-
ject type in a cell. However, this data model re-
quires more advanced knowledge from users and is
more suitable with skilled users and developers than
Proc. 21st Australasian Database Conference (ADC 2010), Brisbane, Australia
147
novice users. This is the reason of why there are only
a few number of tools used object-based model.
In order to facilitate the mashup capability with
a specific resource (e.g., a specific application), user
need to write their own wrapper. Within reviewed
tools, only A1 and AMICO:CALC allow users to ex-
tend Java class to write plug-ins/adapters for devel-
oping new functionality of the tool. This could not be
suitable with all users since it requires users to have
programming skill.
All of the analyzed tools use static and manual
mashup strategies. Mashup programming using these
strategies is tedious, error-prone and time consuming
while the mashup application is incapable of adapting
to requirement changes. This limitation leads to the
need to have an automatic and dynamic mashup tool
supporting users in creating mashup applications.
Flow-based orchestration style is used in most of
the tools since it conforms to natural spreadsheet pro-
gramming metaphor (i.e., cell referencing). Layout-
based orchestration is rarely used in mashup tools
since it may break the functional programming na-
ture of spreadsheet (i.e., it introduces procedural pro-
gramming notions within spreadsheet). Event-based
orchestration is based on the Event-Condition-Action
form (i.e., on < event > if < condition > then
< operation >) and is preferred programming model
for programmers.
In summary, the reviewed mashup tools have pro-
vided many useful features for creating mashup appli-
cations. However there are plenty of rooms for further
improvement.
6 Conclusion and Future Work
Mashup is an application development method which
can be done in a lightweight manner to mix infor-
mation and automate processes. There has been a
plethora of mashup tools in many shapes and forms.
In this paper, we analyze a number of spreadsheet-
based mashup tools. We believe the spreadsheet en-
vironment has inherent advantages over other mashup
environment due to its popularity and familiarity with
the users.
We attempted to make a comparison among existing
spreadsheet-based tools by finding common dimen-
sions and characteristics. We hope that the analysis
will be useful for the researchers and developers in this
area to understand the architecture of spreadsheet-
based mashup tools, the strengths and weaknesses of
the current approaches.
The main limitation of our work is that we conducted
a qualitative instead of quantitative survey, therefore,
some of the observations could inherently be subjec-
tive. However, the results are only used to develop
an initial understanding and create a foundation for
further research. More rigorous surveys with quanti-
tative measures are planned to add objectivity to the
study.
Typically, components in our surveyed tools are
manually created and composed at design time with
user interactions. However, requirements and situ-
ations of the tasks in our daily life may change at
any time so that a mashup tool need to be able to
transparently adapt to environment changes, adapt
to customer requirements with minimal user inter-
vention. None of the reviewed tools can do this. This
problem leads to an unsatisfied support to the users
which can prevent them from being productive.
The goal of our future work is on alleviating aforemen-
tioned pain. We adopt the notion of context to be
used in our framework facilitating lightweight semi-
automatic mashup. Context is the information that
characterizes the interactions between humans, ap-
plications and the surrounding environment. For ex-
ample, location (e.g., geography coordinates, country,
time), user information (e.g., name, address, email)
or client context (e.g., hardware, software). Our fu-
ture work will concentrate on achieving the following
targets:
A Lightweight Programming Model
Mashup applications are often created manually by
combining available components with certain prede-
fined operators. With the increasing demand for com-
ponents, operators and functionalities, the user’s task
to efficiently select, combine and configure compo-
nents becomes more complex, time-consuming and
error prone even for experienced users.
The first target of our framework is to simplify the
programming process of mashup. Mashup framework
should leverage the spreadsheet model which com-
bines functional and visual approach to deliver an in-
tuitive environment with little or no learning barriers
(Brad et al. 2004).
Semi-automatic Mashup
Most of the current mashup approaches use manual
composition and full automatic support is still the
target of ongoing research activity. Our second tar-
get is to provide a semi-automatic mashup framework
with user intervention. In order to provide such a
framework, users’ requests and components need to
be stated in a way that rich semantic information
can be incorporated when components are queried.
We try to embed intelligence into the manual process
of mashup: service selection, binding and composi-
tion through the smart use of context. We intend to
construct a user model that reflects user preferences,
such as usage characteristic, interest, expertise and
community model that measure the interest of users
on a mashup or component. Based on these two mod-
els, our framework incrementally guides users on the
process of building mashup application. In addition,
when a requirement changed (e.g., interest changed)
the system will automatically suggest new mashup
plan to the users. Our research prototype will have
two basic components: a composer and an inference
engine. The inference engine stores the information
about known component, user model and community
model in its Knowledge Base (KB) and has the ca-
pability to suggest composition plans. The composer
has a spreadsheet grid interface that enable users to
incrementally build their mashup. The users start the
composition process by selecting preferred profile and
one component service. A query is sent to the infer-
ence engine to get the suggestion on possible mashup
plans. The composers then get the results and display
the plans for user to select.
References
Benatallah, B., Sheng, Q. Z. & Dumas, M. (2003),
‘The self-serv environment for web services compo-
sition’, IEEE Internet Computing 7(1), 40–48.
Brad, A. K., Ko, A. J., Myers, B. A. & Aung, H. H.
(2004), Six learning barriers in end-user program-
ming systems, in ‘IEEE Symposium on VL/HCC
2004’, pp. 199–206.
Brauer, B. (n.d.), ‘Next evolution of data integration
into microsoft excel’.
URL: http ://www.strikeiron.com/
Burnett, M., Agrawal, A. & van Zee, P.
(2000), ‘Exception handling in the spreadsheet
CRPIT Volume 104 - Database Technologies 2010
148
Excel connectors
StrikeIron
Extensio Extender
AMICO:CALC
A1
Husky
Data grid-based + + + + - +
model object-based - - - - + -
ProtocolaP1,P2,P3, P6P1,P2,P3, P1,P2,P3, P1,P4,P8N/A
Component P4,P5,P6,P7P4,P6,P7P6,P7,P8
access P8,P9,P10 P8,P9,P10 P9,P10
model Data formatbD1,D2,D3,D4D2D1,D2,D3D1,D2,D3, D1,D8D1,D2
D5,D6,D7,D8D6,D8D5,D7,D8
Extensibility - - - + + -
static + + + + + +
Mashup dynamic - - - - - -
strategies manual + + + + + +
automatic - - - - - -
Orchestration flow-based + + + - - -
styles layout-based - - - - - +
event-based - - - - + -
Data passing dataflow + + + - + +
styles blackboard - - - + - +
Target developer - - - - - -
user skilled user - - - + + +
novice user + + + - - -
Search- text-based - + + - - -
ability browsing + + + + - -
context suggestion - - - - - -
Community sharing - + + - + -
features collaborating - - - - + -
discussion - + + - - -
Software debugging - - - + - -
engineering testing - + + - + -
aspects version control - - - - - -
Execution spreadsheet + + + - - -
engine external - - - + + +
Execution centralized + + + + + +
types distributed - - - - - -
hybrid - - - - - -
Transaction & exception handling - - - - - -
(+) means the dimension is directly supported; (-) means the dimension is not supported;
(N/A) means the dimension is not mentioned in related publication.
aP1=HTTP; P2=TCP; P3=UDP; P4=SMTP; P5=REST; P6=SOAP; P7=RPC; P8=application specific;
P9=ODBC; P10=JDBC;
bD1=HTML; D2=XML; D3=RSS; D4=ATOM; D5=JSON; D6=XLS; D7=RDF; D8=Text;
Table 3: Evaluation results
paradigm’, IEEE Transactions on Software Engi-
neering 26(10), 923–942.
Fischer, T., Bakalov, F. & Nauerz, A. (2009), An
overview of current approaches to mashup gener-
ation, in ‘Wissensmanagement’, pp. 254–259.
Grammel, L. & Storey, M.-A. (2008), An end user
perspective on mashup makers, Technical Report
DCS-324-IR, University of Victoria.
Hoang, D. D., Benatallah, B. & Hye-young, P. (2009),
Towards a spreadsheet-based service composition
framework, in ‘PhD workshop, DASFAA 2009’.
Kandogan, E., Haber, E., Barrett, R., Cypher, A.,
Maglio, P. & Zhao, H. (2005), A1: End-user pro-
gramming for web-based system administration, in
‘UIST ’05’, ACM, New York, NY, USA, pp. 211–
220.
Kongdenfha, W., Benatallah, B., Saint-Paul, R. &
Casati, F. (2008), Spreadmash: A spreadsheet-
based interactive browsing and analysis tool for
data services, in ‘CAiSE ’08’, Springer-Verlag,
Berlin, Heidelberg, pp. 343–358.
Nardi, B. A. (1993), A Small Matter of Program-
ming: Perspectives on End User Computing, The
MIT Press.
Obrenovic, Z. & Gasevic, D. (2008), ‘End-user service
computing: Spreadsheets as a service composition
tool’, IEEE Transactions on Services Computing
1(4), 229–242.
Scaffidi, C., Shaw, M. & Myers, B. (2005), ‘Estimat-
ing the numbers of end users and end user program-
mers’, VL/HCC ’05 0, 207–214.
Srbljic, S., Zuzak, I. & Skrobo, D. (2007), ‘Husky
editor’. http://www.husky.fer.hr/.
Ullman, J. D. (1990), Principles of Database and
Knowledge-Base Systems: Volume II: The New
Technologies, W. H. Freeman & Co., New York,
NY, USA.
Proc. 21st Australasian Database Conference (ADC 2010), Brisbane, Australia
149
... The second limitation, according to Hoang et al. (2010), is that most of today's service composition approaches only support either RESTful or SOAP-based Web services. Moreover, SOAP-based Web services are mainly developed for the enterprise applications. ...
... AMICO:CALC. To support end-users with native calculating abilities, several spreadsheet-based approaches (Hoang et al., 2010) have been proposed over the past years. As stated by Obrenovic and Gasevic (2008), AMICO:CALC has been designed as a plugin to several existing spreadsheet systems to provide users the ability of composing services by means of creating spreadsheets. ...
...  Due to the nature of spreadsheet, users have to learn a certain number of formulas before being able to utilize them in composing Web services. In other words, as concluded by Hoang et al. (2010), this spreadsheet-based approach can only be helpful to skilled users rather than novices.  To use AMICO:CALC, users have to install corresponding plugins to extend the original spreadsheet systems to gain the ability of composing Web services. ...
... Mashup is an application development method which can be done be applied in a lightweight manner to mix information and automate processes. There has been a plethora of mashup tools in many shapes and forms [20]. In this paper, we analyzse a spreadsheet-based mashup tool with application to AIS data extracted from various web sources. ...
... In this paper, we analyzse a spreadsheet-based mashup tool with application to AIS data extracted from various web sources. We believe the spreadsheet environment has inherent advantages over other mashup environment due to its popularity and familiarity with the users [20]. ...
Conference Paper
Full-text available
The growth of big data and its popularity in maritime surveillance has increased at an exponential rate. The amount of maritime information being collected every minute around the world exceeds the capacity of traditional databases. The development of real-time, Geospatial Web Applications e.g., MarineTraffic and VesselFinder AIS vessel tracking web sites, provide us with huge sets of structured and unstructured data that are too complex for traditional data-processing software. The aim of this paper is to exploit the benefits of query and mashup amounts of maritime data using mashup tools as a result to create a single, unique visualization. The results show that using mashup techniques in maritime surveillance could be used to monitor, compare, combine, manipulate and analyse Big Maritime data. Therefore, research on Maritime Data offers a huge potential and an opportunity to benefit from the advantages.
... In [9], the authors propose to use a spreadsheet environment for the construction of mashups. The authors define custom functions that call web services and pass the cell value as input of the service. ...
... Then, end-users can compose mashups by linking functions using the cell reference property of spreadsheets. The authors in [9] offer a developing environment that is well-known to end-users, however, they have the same drawbacks as the general purpose mashups. ...
Conference Paper
Currently, there are a lot of people trying to leverage on the success of social networks by implementing social applications. However, implementing social applications is complex, due to the requirements and constraints put by the social networks to protect their data. In this work we present Simple Flow, a tool that simplifies the creation of social applications. Simple Flow proposes a processes-based approach to the design and execution of social applications. Simple Flow targets end-users and programmers with no experience in programming for social networks, giving them the possibility to design processes by concatenating social network actions (like post a message or comment a photo). For the execution of the designed processes Simple Flow interconnects, at runtime, template web pages (one page per action) according to the process design defined previously. These templates abstract the complexities of the interactions with social networks.
... They are generally used by teachers especially to compute grades and to keep track of the progress of their students. According to Benatallah, Hoang, and Paik (2010), spreadsheet is known as data management, analysis and reporting tool with applicable but user-friendly functions. ...
Article
Full-text available
With the onset of Education 4.0 and the VUCAD2 world, the use of technology in instruction has been fully maximized. This study aimed to determine the teachers' utilization of computer-based technology in science instruction. The study used descriptive survey research using the Computer-Based Technology Inventory Survey Questionnaire (CBTI-SQ). A total of 41 science teachers in two state-owned secondary schools in Zambales, Philippines served as respondents in the study. Based on the findings, the computer-based technology (CBT) in science instruction is a trend in the 21st-century learning. Teachers utilized CBT in instruction to improve their teaching that significantly uplifts students' learning interests and concept understanding. However, teachers encounter difficulties due to low ICT literacy, unstable internet connection, power interruption, and sometimes they find it too expensive to use the CBT. The study recommends ICT training-workshop and encourages teachers to utilize appropriate CBT instruction based on the context of the students. The findings have important implications for policy development and curriculum enhancement.
... We call this mechanism Metamorphic ‡ Data Source (MDS), since end users can define access points on LD, whose structure can be adapted to their specific needs. MDSs can be fruitfully used within visual environments for the integration of heterogeneous resources, for example, the different mashup platforms that have been proposed in the last decade (Daniel and Matera, 2014;Hoang et al., 2010;Paredes-Valverde et al., 2015;Yu et al., 2008). The notion of MDS has been indeed conceived as part of a larger project focusing on the design of mashup platforms that offer visual notations to enable the integration by end users of heterogeneous data sources and Web APIs (Ardito et al., 2014b;Desolda et al., 2016Desolda et al., , 2017b. ...
Article
Full-text available
In the last years, the debate about the success or failure of Linked Data (LD) has been growing. Despite the ever-increasing number of available ontologies and LD datasets, there is still a limited number of applications to let people benefit from using this huge amount of data. Some evident problems relate to the limited opportunities offered to the end users, i.e., people without skills in computer programming, to access, navigate and visualize LD. Tools supporting such tasks typically do not consider the end users’ needs; even when they provide abstraction mechanisms to avoid programming, they do not properly hide the complexity of getting oriented into the plethora of available resources. Thus, they end up to be inadequate to real daily scenarios. In this paper, we propose an approach that enables end users to create visually entry points, which we call Metamorphic Data-Sources (MDSs), to query and visualize the LD without requiring any prior knowledge of semantic Web or visualization technologies. Through the MDS visual paradigm, end users can tailor ad-hoc data sources to retrieve information on topics they are interested in. The MDS creation process is also driven by a quality model that further helps users select LD elements potentially free of data quality problems. The paper also reports on the results of a user study that we conducted to assess the validity of the MDS paradigm with respect to the user needs.
... Reference [20] presented the Linked Web APIs dataset which supports API consumers and API Provider in the process of discovery, selection and use of Web APIs. Spread sheet approach [21,22] is another UI approach which aims to provide a spreadsheet-like view to mash up the data and is becoming popular because most of the ordinary users are familiar with spread sheet. The RESTful architectural model is helpful for widget Future Internet 2018, 10, 98 4 of 37 development for mashup purpose because of its nature of portability, scalability and multi-platform support [5]. ...
Article
Full-text available
Due to the exponential growth of the data and its services, visiting multiple webs/apps by a user raises three issues—(1) consumption of extra bytes; (2) time killing process of surfing inside the webs/apps; (3) tedious task of remembering address of webs/apps with their credentials. The data mashup is a set of techniques and user-friendly approaches which not only resolves above issues but also allows ordinary user to fetch required data from multiple disparate data sources and to create the integrated view in his defined digital place. In this paper, we have proposed an extension of existing REST protocol called Structured Data REST (SDRest) protocol and user-friendly novel approach which allows even ordinary users to develop end to end data mashup, using the innovative concept of Structured Data Mashup Box (SDMB) and One Time Configuration (OTC)-Any Time Access (ATA) models. Our implementation shows that pre-mashup configuration can easily be performed by an ordinary user and an integrated user interface view of end user data mashup can be created without any technical knowledge or programming. We have also evaluated the proposed work by comparing it with some of the related works and found that the proposed work has developed user friendly configurable approach using the current state of the art techniques to involve not only the ordinary user but also the mashup service provider and the data service provider to develop public, private and hybrid data mashup.
... Spreadsheets-like programming are often considered ease-of-use, intuitive and with enough expressive power to represent and manage complex data. When it comes to mashups, Mashroom [71] and MashSheet [44][45] explore this approach. Mashroom builds Web applications by combining content coming from different Web sites. ...
Chapter
Full-text available
This chapter presents Web Augmentation (WA) technologies as tools and techniques for end-user development. WA technologies differ from other web development technologies as they target at improving existing Web pages and not at creating new Web sites. These improvements can deeply alter the way users use and interact with Web sites. This chapter revisits the concept of WA and provides an overview of the main features that characterize WA technologies. This characterization is used to position and compare the various contributions that have been made in WA. To make things more concrete we provide an illustration of WA technology through a case study using a dedicated tool called WebMakeup. Despite all their advantages, WA technologies present some limitations that might result in challenges on the user side. These aspects are also presented and discussed, highlighting directions for future work in that domain.
... An emerging End-User service composition technique is based on the Spreadsheet metaphor [8]: the process is modeled putting the service invocation in the cells. The HUSKY tool [14] enables the users to compose logic spatially arranging of component services within spreadsheet cells. ...
Article
The definition of an approach supporting an End- User in the development of mobile applications is a hard task because of the characteristics and the limitations of mobile device interfaces. In this paper, we present a visual approach to enable End-Users to compose visually their own applications directly on their mobile phone. To this aim, we propose a touchable interface and an ad-hoc visual language, enabling the user to compose simple focused applications, named MicroApps. The user has not in charge the creation of the user interface that is automatically generated. Moreover, we present the results of a preliminary usability study that revealed a good satisfaction degree of all the involved subjects, whereas an empirical analysis highlighted that the MicroApp visual approach is effective and efficacy.
... R ECENTLY as a popular fashion in web-based development, web mashup promotes end-user-doable ways for creating Web applications. Targeted at different problems, there are different kinds of mashup, such as the data mashup, process mashup, and the presentation mashup [1]. Data service mashup refers to a particular mashup, which allows users to access, process, and combine data from various data sources on the fly by business users and departmental IT staff to solve situational data integration problems [2], [3], [4]. ...
Article
Though the existing data service mashup tools are gaining acceptance, it is still challenging for developers with no or little programming skills to develop data service mashups for dealing with situational and ad-hoc business problems. The paper focuses on interactive recommendation in which assistance is provided in a context-sensitive manner when the mashup plan can't be determined in advance. The paper analyzes the problem with a motivating scenario of mashup building for criminal investigation. Inspired by the observation that there exist dataflow patterns for certain integration functionalities, a dataflow-pattern- based recommendation framework is proposed to solve the problems. The framework can not only recommend data services by discovering similar situations, but also recommend mashup patterns and target data services. We propose a method to analyze the relationships between data services and dataflow patterns through both mining history logs and matching the input/output parameters. Further, to recommend target data services, we propose a method to transform the data mashup plans into mixed graphs and apply the graph-based substructure pattern mining (gSpan) algorithm on them. Experiments show that the dataflow-pattern- based recommendation approach for data service mashup is effective and efficient.
Article
This article describes how in the last decade, business process repositories have grown significantly and the need for new processes to answer increasing market demands, has become a central interest of modern enterprises. However, developing open source business processes (BP) from scratch is one of the most time-consuming and high-cost tasks. Therefore, reusing mechanisms becomes a priority to deal with this issue. In this article, it is proposed that an open source user-friendly framework that mixes parts of existing process components to build a new process, in order to respond to a particular goal. This is known as business process mashup (BP-Mashup). The BP-mashup framework presented in this article allows users to perform a mixture of process fragments using a simple interface with a set of graphical and temporal events operators based on a formal model.
Article
Full-text available
In this paper, we show how spreadsheets, an end-user development paradigm proven to be highly productive and simple to learn and use, can be used for complex service compositions. We identify the requirements for spreadsheet-based service composition, and present our framework that implements these requirements. Our framework enables spreadsheets to send requests and retrieve results from various local and remote services. We show how our tools support different composition patterns, and how the style of declarative dependencies of spreadsheets can facilitate service composition. We also discuss novel issues identified by using the framework in several projects and education.
Conference Paper
Full-text available
System administrators work with many different tools to manage and fix complex hardware and software infrastructure in a rapidly paced work environment. Through extensive field studies, we observed that they often build and share custom tools for specific tasks that are not supported by vendor tools. Recent trends toward web-based management consoles offer many advantages but put an extra burden on system administrators, as customization requires web programming, which is beyond the skills of many system administrators. To meet their needs, we developed A1, a spreadsheet-based environment with a task-specific system-administration language for quickly creating small tools or migrating existing scripts to run as web portlets. Using A1, system administrators can build spreadsheets to access remote and heterogeneous systems, gather and integrate status data, and orchestrate control of disparate systems in a uniform way. A preliminary user study showed that in just a few hours, system administrators can learn to use A1 to build relatively complex tools from scratch.
Conference Paper
Full-text available
As programming skills increase in demand and utility, the learnability of end-user programming systems is of utmost importance. However, research on learning barriers in programming systems has primarily focused on languages, overlooking potential barriers in the environment and accompanying libraries. To address this, a study of beginning programmers learning Visual Basic.NET was performed. This identified six types of barriers: design, selection, coordination, use, understanding, and information. These barriers inspire a new metaphor of computation, which provides a more learner-centric view of programming system design
Conference Paper
Full-text available
In 1995, Boehm predicted that by 2005, there would be "55 million performers" of "end user programming" in the United States. The original context and method which generated this number had two weaknesses, both of which we address. First, it relies on undocumented, judgment-based factors to estimate the number of end user programmers based on the total number of end users; we address this weakness by identifying specific end user sub-populations and then estimating their sizes. Second, Boehm's estimate relies on additional undocumented, judgment-based factors to adjust for rising computer usage rates; we address this weakness by integrating fresh Bureau of Labor Statistics (BLS) data and projections as well as a richer estimation method. With these improvements to Boehm's method, we estimate that in 2012 there will be 90 million end users in American workplaces. Of these, we anticipate that over 55 million will use spreadsheets or databases (and therefore may potentially program), while over 13 million will describe themselves as programmers, compared to BLS projections of fewer than 3 million professional programmers. We have validated our improved method by generating estimates for 2001 and 2003, then verifying that our estimates are consistent with existing estimates from other sources.
Article
This paper presents a review of six mashup makers from an End User Development (EUD) perspective. The fast-paced development of mashup makers and related research in the last two years has created a wealth of features and approaches. To provide an overview of EUD support in current state-of-the art mashup makers, we explore, summarize and compare their features across six different themes (Levels of Abstraction, Learning Support, Community Support, Searchability, UI Design and Software Engineering Techniques). We found that the mashup makers provide many features to support end users, but there is still much room for further improvement. These results can be used to guide both research and tool design. User studies that reveal the difficulties in using mashup makers and comparisons of different notations are likely to be especially fruitful research opportunities. 1
Conference Paper
Spreadsheets are one of the most popular end-users programming environment. Although spreadsheets provide an interactive interface for data manipulation and analysis, they are mostly used today in data entry mode and not as interactive browsing tool for data stored in underlying data sources. In this paper, we present SpreadMash, a high-level language and tool for interactive data browsing and analysis for data services. The key innovation of SpreadMash is a repository of application building blocks called data widgets that characterize various data importation and presentation patterns in spreadsheets. Data widgets enable the separation of end-users tasks (composing data widgets) from the tasks of data architects (creating data abstractions and data widgets). Through a series of examples we illustrate how tasks that would be challenging in existing environments are facilitated by SpreadMash.
Conference Paper
The spreadsheet is a popular productivity tool. Recently, it has gained attention as a potential service integration environment targeted towards end-users. We discuss four possible ways of implementing web service composition in a spreadsheet environment, highlighting their significance and limitations. We, then, propose our approach which aims to address the need of service composition while maintaining all of the spreadsheet characteristics the users are familiar with. We briefly discuss the progress so far as well as the future plans.
Article
Self-Serv aims to enable the declarative composition of new services from existing ones, the multiattribute dynamic selection of services within a composition, and peer-to-peer orchestration of composite service executions. Self-Serv adopts the principle that every service, whether elementary or composite, should provide a programmatic interface based on SOAP and the Web Service Definition Language. This does not exclude the possibility of integrating legacy applications, such as those written in CORBA, into the service's business logic. To integrate such applications, however, first requires the development of appropriate adapters. The paper considers how the mechanism for composing services in Self-Serv is based on two major concepts: the composite service and the service container.