• Save
Ousia Weaver -A tool for creating and publishing mashups-
Upcoming SlideShare
Loading in...5
×
 

Like this? Share it with your network

Share

Ousia Weaver -A tool for creating and publishing mashups-

on

  • 2,221 views

This presentation describes Ousia Weaver, a tool for creating and publishing mashups as impressive Web pages. ...

This presentation describes Ousia Weaver, a tool for creating and publishing mashups as impressive Web pages.
This will be presented in MEM2010 (3rd Workshop on Mashups, Enterprise Mashups and Lightweight Composition on the Web) held on April 26th.

Statistics

Views

Total Views
2,221
Views on SlideShare
2,132
Embed Views
89

Actions

Likes
1
Downloads
3
Comments
0

3 Embeds 89

http://www.ousia.jp 79
http://www.slideshare.net 9
https://si0.twimg.com 1

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Ousia Weaver -A tool for creating and publishing mashups- Presentation Transcript

  • 1. Ousia WeaverA tool for creating and publishing mashupsas impressive Web pages
    Ikuya Yamada, WataruYamaki, Hirotaka Nakajima, YoshiyasuTakefuji
    Studio Ousia Inc.
    Keio University
    3rd Workshop on Mashups, Enterprise Mashups
    and Lightweight Composition on the Web (MEM 2010)
  • 2. Mashup is a technique which combines data and functions from multiple Web sources into new Web contents.
    Mashups have become very popular. Numerous mashups have been created on the Web.
    There are over 4500 mashups registered on ProgrammableWeb (http://www.programmableweb.com/).
    Mashups in a nutshell
  • 3. Recently, software tools called “mashup editors”have been attracting attention.
    Yahoo! Pipes
    Microsoft Popfly
    Intel MashMaker
    These editors are typically targeted at non-expert users and allow them to create mashups without writing any code.
    Mashup Editors
  • 4. However, existing mashup editors tend to focus only on creating mashups and lack in publishing and visualizing mashups.
    If users want to publish mashup results on the Web, they eventually have to do complex programming and/or settings.
    Issues
  • 5. Yahoo! Pipes only supports three simple visualizations (List, Image, Map).
    Users cannot customize these visualizations.
    Pipes doesn’t support publishing its mashups as independent Web pages.
    Example
    Visualized mashup result by Yahoo! Pipes
  • 6. We propose a novel mashup editor namedOusia Weaver.
    Ousia Weaver has distinguished functions that strongly support publishing and visualizing mashups.
    Ousia Weaver provides a visual editor which enables users to create mashups without writing any code.
    Users can create, visualize, and publish mashups without any complex programming and settings.
    Ousia Weaver
  • 7. With Ousia Weaver, users can create mashups using three steps:
    Creating the mashup with Visual Editor
    Visualizing the mashup with Visualization Widgets
    Publishing the mashup withMashup Server
    Three Steps to Publish Mashups with Ousia Weaver
  • 8. Creating Mashups
  • 9. Ousia Weaver provides a visual editor which enables users to create mashups by visually stringing together components.
    Mashups are represented using directed graph structure.
    Operators (nodes) represent data operations.
    Connections (edges) connect two operators and define data paths between these.
    Programming Model
    Operators
    Connections
  • 10. Creating a mashup with Ousia Weaver is an iterative process:
    Adding desired operators.
    Stringing operators together using connections.
    Mashups are executed in a data-flow manner.
    InputString operator receives a keyword from a user.
    AmazonAllByKeyword operator performs a search on Amazon.com with the keyword.
    OutputItemList operator returns the search result.
    Programming Model
    Operators
    Connections
  • 11. Movie
    Programming Model
  • 12. Operators
    Input terminal
    Argument name
    Argument value
    Output terminal
    The most fundamental component of Ousia Weaver is operators.
    Operators represent all data operations in Ousia Weaver.
    An operator consists of input terminals, argument name/value pairs, and output terminals.
  • 13. Currently, Ousia Weaver provides over 300 operators.
    All operators can be classified into three groups:
    Base operators provide basic programming operations.
    Arithmetic operation
    Data type conversion
    Standard selection operation (If /Switch)
    Loop operation (While/Foreach)
    Data source operators represent Web data sources.
    Web API
    Web data extraction (RSS / CSV)
    Data transformation operators transform data into a visualizable form.
    AddImage operator adds thumbnails to the data
    AddLocation operator attaches geographical locations to the data
    AddDate and AddDateRange operator add dates and ranges of dates to the data respectively.
    AddCoordinate2d operator adds two dimensional coordinates to the data.
    Operators
  • 14. Extending Operators
    class AppendTerminal(OperatorBaseTerminal):
    def __init__(self,args):
    OperatorBaseTerminal.__init__(self, args)
    Input_terminal = {}
    input_terminal["Input"] = None
    self.set_input_terminals(input_terminal)
    class AppendBody(OperatorBaseBody):
    def __init__(self, args, manager_args, worker):
    OperatorBaseBody.__init__(self, args, manager_args, worker)
    def run(self, input_terminals):
    output_terminals = {}
    output_terminals["Output"] = str(input_terminals["Input"]) + str(self.get_args()["text"])
    return output_terminals
    ousiaweaver.Operators.Append = function(){
    this.addInputTerminal("string", "Input");
    this.addOutputTerminal("string", "Output");
    }ousiaweaver.Operators.Append.packageName = "base.string";
    ousiaweaver.Operators.Append.arguments = {
    "text": {
    label: "Text",
    type: "string",
    required: true,
    }
    }
    Append.js
    Append.py
    Operators are extensible. Users can add and update arbitrary operators whenever they need.
    An operator consists of two files:
    Simple metadata file (JavaScript)
    Program code file (Python)
    Ousia Weaver provides code templates. Users can create new operators by writing just a few code fragments.
  • 15. Data Types
    Ousia Weaver implements a simple data typing system.
    There are some unique data types:
    any can represent any data including other data types.
    itemlistrepresents a mashup result and contains multiple item.
    data-flow represents a mashup.
  • 16. Data Types
    All terminals have data type properties.
    Two terminals, which have different data type properties, cannot be connected unless either or both properties are any.
    When users start dragging one terminal, other terminals will automatically be disabled and turn gray if they cannot be connected with the dragged terminal.
    Terminals which cannot be connected with the dragged terminal will automatically turn gray.
  • 17. Visualizing Mashups
  • 18. With Ousia Weaver, the user can visualize the mashup result by choosing the desired visualization widgets from the list.
    Visualizing Mashups
  • 19. Visualization Widgets
    Catalog widget
    Plot widget
    Table widget
    Map widget
    Timeline widget
    Visualization widgets are components which visualize mashup results.
    Catalog widget
    Plot widget
    Table widget
    Map widget
    Timeline widget
  • 20. Catalog Widget
    Catalog widget
    Plot widget
    Table widget
    Map widget
    Timeline widget
    Catalog widget visualizes the mashup results like a catalog.
  • 21. Plot Widget
    Catalog widget
    Plot widget
    Table widget
    Map widget
    Timeline widget
    Plot widget plots the mashup results on a two dimensional space.
  • 22. Table Widget
    Catalog widget
    Plot widget
    Table widget
    Map widget
    Timeline widget
    Table widget presents all titles and descriptions of the mashup results in a table.
  • 23. Map Widget
    Catalog widget
    Plot widget
    Table widget
    Map widget
    Timeline widget
    Map widget depicts the mashup results visually on a map.
  • 24. Timeline Widget
    Catalog widget
    Plot widget
    Table widget
    Map widget
    Timeline widget
    Timeline widget puts the mashup results into a graphical timeline.
  • 25. Ousia Weaver provides a function which automatically selects appropriate visualization widgets for the mashup.
    The function scans the mashup result and detects if the result has all of the data which need to be visualized.
    Automatic Widgets Selection
  • 26. Publishing Mashups
  • 27. Ousia Weaver provides a lightweight server named Mashup Server.
    Mashup server executes mashups dynamically and makes the mashup results accessible to external users.
    The server automatically assigns a URL to each mashup and dynamically executes the mashup when an external user accesses it.
    The URL of a mashup named “search_videos” in the “foo” server would be “http://foo/search_videos/”
    Mashup Server
  • 28. Implementation
  • 29. Architecture
    Sources of mashups
    Visual editor
    Mashup server
    Results of mashups
    Metadata ofoperators
    Results ofvisualization
    Operator manager
    Visualizer
    Program codes of operators
    Run-timeengine
    Ousia Weaver consists of five main components:
    Operator manager
    Run-time engine
    Visualizer
    Visual Editor
    Mashup server
  • 30. Operator Manager
    Sources of mashups
    Visual editor
    Mashup server
    Results of mashups
    Metadata ofoperators
    Results ofvisualization
    Operator manager
    Visualizer
    Program codes of operators
    Run-timeengine
    Operator manager is a simple component implemented using Python.
    It manages the list of all operators and delivers their program codes and metadata to other components.
  • 31. Run-time Engine
    Sources of mashups
    Visual editor
    Mashup server
    Results of mashups
    Metadata ofoperators
    Results ofvisualization
    Operator manager
    Visualizer
    Program codes of operators
    Run-timeengine
    Run-time engine is a component responsible for executing mashups.
    It is implemented as a multi-process server daemon using Python and Python’s multiprocessing module.
  • 32. Visualizer
    Sources of mashups
    Visual editor
    Mashup server
    Results of mashups
    Metadata ofoperators
    Results ofvisualization
    Operator manager
    Visualizer
    Program codes of operators
    Run-timeengine
    Visualizer is a component which contains visualization widgets inside and visualizes mashups using the widgets.
    It is implemented in JavaScript and uses jQuery (jquery.com) and Simile Widgets (simile-widgets.org).
  • 33. Visual Editor
    Sources of mashups
    Visual editor
    Mashup server
    Results of mashups
    Metadata ofoperators
    Results ofvisualization
    Operator manager
    Visualizer
    Program codes of operators
    Run-timeengine
    Visual editor provides a rich visual editing interface for creating mashups.
    It is implemented using JavaScript and HTML, and can be run on most commonly used Web browsers.
    It can also be executed as a stand-alone application on Windows, Mac OS X, and Linux using Mozilla’s XUL technology.
  • 34. Mashup Server
    Sources of mashups
    Visual editor
    Mashup server
    Results of mashups
    Metadata ofoperators
    Results ofvisualization
    Operator manager
    Visualizer
    Program codes of operators
    Run-timeengine
    Mashup server makes mashups accessible to external users.
    It is written in Python and uses Apache CouchDB as a datastore.
  • 35. Execution Model
  • 36. Mashup Execution Model(Mashup Server)
    (2)
    Visualizer
    External user
    Mashup server
    Run-timeengine
    (1)
    (4)
    (3)
    The basic sequence of operations of the mashup server.
    Mashup server executes mashups when external users access them.
    Mashups are executed as follows:
    Executing the mashup using the runtime engine.
    Visualizing the result using the visualizer.
    Returning the visualized result to the user.
  • 37. Mashup Execution Model(Run-time Engine)
    result
    result
    result
    task
    task
    task
    Task queue
    Add tasks
    Take tasks
    Result buffer
    Watch progress
    Add/getresults
    Manager processes
    Workerprocesses
    Run-time engine executes mashups in parallel.
    It divides a mashup into multiple, independent tasks and executes them using worker processes.
  • 38. Examples
  • 39. Book Mashup
    “Book Mashup” provides a simple book search function.
    Receiving a keyword from the user.
    Performing a book search on Amazon.com.
    Attaching coordinates, which consists of price and the number of pages, to the result.
    Returning the result to the user.
  • 40. Movie
    Book mashup
  • 41. Event mashup
    “Event mashup” provides an event search function.
    Receiving a keyword from the user.
    Retrieving event information from Upcoming and Eventful.
    Adding ranges of dates and geographic locations of the events to the result.
    Returning the result to the user.
  • 42. Movie
    Event mashup
  • 43. Conclusion and Future Work
  • 44. We proposed a mashup editor called Ousia Weaver.
    OusiaWeaver provides a sophisticated visual editor which enables users to create mashups without writing any code.
    Ousia Weaver offers a variety of rich visualization widgets which visualize mashups in an impressive way.
    Ousia Weaver includes a simple Web server which makes the mashup accessible to external users.
    With Ousia Weaver, users can easily create, visualize, and publish mashups as impressive Web pages.
    Conclusion
  • 45. We plan to do an extensive user evaluation which compares Ousia Weaver to existing mashup editors.
    We will continue to develop Ousia Weaver.
    We are planning to release Ousia Weaver as an open source product.
    Future Work