MUp Early Preview V6

M ( em-’up )

A Functional Logic Programming Mashup Language

!
Early Preview

Monday, March 2, 2009 1

Agenda
• What is MUp?

• Features

• How it works

• Console & Tools

• MUp architecture

• MU language

• Examples

• Validation scenarios

• Comparison with similar products

• Results

• RoadMap

• Project Resources


What is MUp (1)

• MUp stay for Mash Up.

• MUp is a framework for creating mashup of web contents.

• MUp is based on a specific high level language called MU.

• MUp is written in Java.

• MUp defines two runtime profiles : JRE and Javascript.


What is MUp (2)

• MUp is compiled in Javascript with GWT (Google Web Toolkit).

• MUp Javascript proﬁle runs entirely client side (inside a browser).

• MUp can be used client side to deﬁne Javascript widgets embedded in Web pages.

• MUp can be used server side to integrate heterogeneous contents.


MUp Features
• Simpliﬁes data aggregation and transformation.
• Provides support for uniﬁcation of JSON objects over JSON models.
• Provides Graph manipulation native support.
• Provides Type Morphing support.
• Provides (forward) XPath native support.
• Provides JSONPath native support.
• Provides UI Induction capabilities.


How it works (1)
MUp supports a special language to perform data mashing,
this language is called MU.

MU is both a logic and functional language, it provides also procedural constructs.

All predicates provided by MU can be grouped in functional sets.

The main functional sets are:

Source Operations: allow to retrieve web resources.

Inspect Operations: allow to decompose data retrieved from Web.

Model Operations: allow to create JSON models from raw data.

Renderization Operations: allow to renderize JSON models.


How it works (2)
MU functional sets:

XPath JPath
Get Post
Type
Source Operations Inspect Operations

Context PContext Jsonize Apply
Renderize
Unify
StackTrace
Model Operations
Context operations
Renderization Operations

Substring Regex
if for

Add Put
Flow Control String Operations
Remove

Data operations
-
Type As<Type>
+ /
* == <
%
Type Management
OR != AND
Math Operations
Conditional / Logical
Operations


A simple processing ﬂow
a
b
Get Post
c Source() : Get('http://www.mysource.org/rss');
d
Source Operations

a Type Path
b
Entries() : Path('/rss/item/description', Source() );
c
d Inspect Operations

Jsonize
Model() : Jsonize('{ entry : quot;_quot; }', Entries() );
[a,b,c,d]

Model Operations

a
Renderize
b
GUI() : Renderize( Model() );
c
d Renderization Operations


A complex processing ﬂow
a e
b f
Get Post Get Post
c g
d h
Source Operations Source Operations

a e
b f
Type Path Type Path
c g
Inspect Operations Inspect Operations
d h

Jsonize
[ [a,b,c,d] , [e,f,g,h] ]
Model Operations

a e
b f Renderize
Renderization
c g Operations
d h


MUp Console (1)

MUp provides a Web console that can be executed inside any browser
supported by GWT (Firefox, Safari, IE).

MUp Console provides a text area to launch commands and an
operation’s history.


MUp Console (2)
Console Tab

Executed
command

Command
result

command
input area


MUp Console: tools (1)
Editable
Inspector Panel
Tree view

JSON Inspector

Editable
Text view


MUp Console: tools (2)
Inspector Panel

Native
predicates

User
deﬁned
predicates

Context
Inspector

Predicate
description
panel


MUp Architecture (1)
Console Tools

Cast
Processor Digester
Parser GUI
Manager

MU Core

Native

JRE Native Impl GWT Native Impl



Console: the MU console.

Tools: the tools included in the console.

MU Core : provides core functionalities for the MUp framework.

Parser: parser for MU language.

GUI: GUI abstraction able to renderize JSON objects in widgets.



Processor: abstract processor able to interpret compiled MU operations.

Cast Manager: provides support for type morphing.

Digester: XML/HTML generic path digester.

Native: abstraction layer of native implementation.

JRE Native : implementation of Native layer in Java Runtime Environment.

GWT Native : implementation of Native layer on GWT Javascript.


MU Language (1)
MU is based on an hybrid programming paradigm based on functional, procedural and logic
constructs.

An example of procedural expression is:

Procedure(a,b) : r1=Process(a), r2=Process(b), if( Gt(r1,r2), Process(r1), Process(r2) );

An example of functional expression is:

Function(a,b) : sum( F1(a), F2(b) );

An example of logic expression is:

Predicate(a,b) : P1(a) & P2(b) | P3(a,b);


MU Language (2)
MU native types JSON counterpart

BooleanValue boolean
NumericValue integer / ﬂoat
StringValue string
ListValue array
MapValue object
GraphValue object
JSONValue object


MU Language (3)
MU language types are polymorphic: every native type can be always
casted to another native type.
Casting among primitive types is managed by Cast Manager.

Boolean

Non
Numeric
primitive

JSON String

List
Graph

!
Under Development

Map


MU Advanced Language (1)

MU supports Erlang/Prolog language features like predicate overloading.

Factorial(0) : 1;
Factorial(n) : Mult( n , Factorial( Minus(n,1) ) );

Predicate overloading is based on unification: given a set of predicates with the same name, it
will be invoked the first predicate in order of definition which signature unifies with given
arguments.

Unlike Erlang/Prolog, MU implements unification over JSON data structures.


MU Advanced Language (2)
Unification samples:
# Basic unification #
P1(a, b, c) =::= (List(1,2,3)) ==> P1(a:=1,b:=2,c:=3)

# List unification. #
P1([a,b|c]) =::= (List(1,2,3,4,5)) ==> P1(a:=1,b:=2,c:=[3,4,5])

# Object unification. #
P1( { “k1” : a, “k2” : b | o} ) =::= ({“k1” : 1 , “k2” : “2”, “k3” : “3”}) ==> P1(a:=1,b:=”2”,c:={ “k3” : “3” })


MU Language Examples (1)
# This is a comment. #

PI() : 3.14; # Declaring a const. #

Const() : quot;This string is const.quot;;

# Functional programming. #
TriangleArea(l1, l2) : Div( Mult(l1,l2), 2 );
MinorOf(a,b) : if( Lt(a,b), a, b );

# Iterative constructs.
PrintRange(start, stop) :
for( Range(start,stop,1), x, Print(x) );


# Procedural programming. #

P1(v1, v2) : v3=P2(v1, k1), v4=P3(v3,k2), P4(v4);

P1(v1, v2);
# Invoking a predicate. #

v1=P1(v2, v3), P2(v1, v4); # Complex invocation. #

# Predicate Overloading #
OL([a,b,c] , v) : Print('overload1');
OL([a,b,c,d], v) : Print('overload2');
OL({quot;k1quot; : v1, quot;k2quot; : v2} , v) : Print('overload3');
OL({quot;k1quot; : v1, quot;k2quot; : v2, quot;k3quot; : v3} , v) : Print('overload4');

# Invocation #
OL(List(1,2,3) , 4); # prints: overload1 #
OL(List(1,2,3,4), 5); # prints: overload2 #
OL(Map('k1',1,'k2',2) , 4); # prints: overload3 #
OL(Map('k1',1,'k2',2,'k3',3), 5); # prints: overload4 #


# JSON Path integration #

var = DoSomething(), var.p1.p2.p3[i];

# XPath integration #

var = GetFeed(), var//title;

!
Under Development


MU UI Model

UIButton

UILabel

UIComponent

UITextArea

UIList

UIPanel

UIContainer

UIWindow


GUI Induction (1)
The GUI Induction is the ability of the language of
automatically generate a GUI for a JSON data. In

The Renderize() predicate provides the hidden processing
ﬂow shown on the right. JSON data

To customize the GUI generation it is possible to use the
couple Modelize() / Concretize() instead of the Renderize() Modelize()

operation.
JSON UI
Apply()
The Modelize() operation generates a JSON UI Model by Model

applying a set of default transformations.
Concretize()

The JSON UI Model can be customized by using the Apply()
operation.
GUI native
model

The Concretize() operation transforms a JSON UI Model in a
GUI Native Model .
Out

!
Under Development
Renderize()

GUI Induction (2)
Examples of GUI Inductions based on the uniﬁcation are:
# Change Background color. #
ChangeBG( { “background” : bg | o } ) : Add(o, Map(“background”, “red”) );

# Change panel orientation if size exceed 10. #
ChangePO( { o } ) : if( Gt( Size(o), 10 ) , Add(o, Map(“orientation”, “vertical”) ) );

!
Under Development


Validation scenarios

Validation scenarios are applications of MUp on real and synthetic
data meant to verify the applicability of all the implemented
features.


Synthetic validation scenario:
description

“We have a Web service S1 returning a list of restaurants in a
speciﬁed city, providing for each restaurant the street in which it is
located.

We've also a Web service S2 returning a list of hotels near a given
street.

We want to combine these sources to obtain a list of restaurants
in a given city with a sublist of hotels near each restaurant.”


formalization
#01# S1(city) : PGet('http://findrestaurants.com/find?city=_', city);
#02# RawRomeRestaurants() : S1('Rome');
#03# ListOfRomeRestaurants() : Path( 'html/body/table/tr', RawRomeRestaurants() );
#04# RestaurantName(row) : Path( 'td[0]' , row );
#05# RestaurantStreet(row) : Path( 'td[1]' , row );
#06# S2(city,street) : PGet('http://findhotels.com/find?city=_street=_', List(city, street) );
#07# HotelsInRomeAtStreet(street) : S2('Rome', street);
#08# ListOfStreetHotels(street) : Path( 'html/body/table/tr' , HotelsInRomeAtStreet(street) );
#09# HotelName(row) : Path( 'td[0]', row );
#10# HotelStars(row) : Path( 'td[1]' , row );
#11# JsonHotel(row) : Jsonize( '{ hotel-name : quot;_quot;, hotel-stars : quot;_quot; }', List( HotelName(row),
HotelStars(row) ) );
#12# HotelsInStreet(street) : for( ListOfStreetHotels(street), hotel, JsonHotel(hotel) );
#13# Restaurant(row) : Jsonize( '{ restaurant-name : quot;_quot;, restaurant-street : quot;_quot;, hotels : _ }',
List(RestaurantName(row), street=RestaurantStreet(row), HotelsInStreet(street)) );
#14# RomeRestaurants() : for( ListOfRomeRestaurants(), row, Restaurant(row) );


result
[

{

quot;restaurant-namequot; : quot;RN1Romequot;,

quot;restaurant-streetquot; : quot;RS1Romequot;,

quot;hotelsquot; : [

{ quot;hotel-namequot; : quot;HN1RomeRS1Romequot;, quot;hotel-starsquot; : quot;SR1RomeRS1Romequot; },


{ quot;hotel-namequot; : quot;HN3RomeRS1Romequot;, quot;hotel-starsquot; : quot;SR3RomeRS1Romequot; }

]

},

{







]

},

{







]

}
]


Real validation scenario:
description

“Given an RSS feed extract all title elements inside it and show a
panel containing them.”


formalization
#01# Feed() : PGet(quot;http://www.repubblica.it/rss/homepage/rss2.0.xmlquot;, List());

#02# Titles() : Path( 'title', Feed() );

#03# JsonTitle(t) : Jsonize('{ quot;titlequot; : %s }', List(t));

#04# JsonTitles() : for( Titles(), title, JsonTitle(title) );

#05# Renderize( JsonTitles() );


result


Comparison with
similar products


Results / Issues
• The GWT profile raises problems when recompiling with
performance flags.

• GWT is not enough mature for the complexity of this
project, in the following months resources will be invested
on the JRE profile.


RoadMap (1)
( http://code.google.com/p/em-up/wiki/RoadMap )

Ongoing Tasks

• Implement the GraphValue data type:
1. implement the core type. (2) DONE
2. implement the manipulation operations. (3) DONE
3. implement the triple syntax. (3)
4. add graph search and transformation operators. (3)

• Add support for JSON storaging and querying. (4)
• Empower the JSON Model syntax. (3)

RoadMap (2)
Rewrite the MUp Console Shell with Gwt-EXT. (3)

Complete the User Documentation. (3)

Complete the build system. (2)

Add command-line console. (3)

Complete the XPath support (some operators are missing).


RoadMap (3)
Complete the JSONPath support (some operators are missing).

Add Regexp support for string manipulation. (2)

TODOs reduction in code and documentation. (10)

Add arithmetic expression support in language. (2)

--- MILESTONE ---


Documentation & Code
The MU documentation is hosted in

http://code.google.com/p/em-up/
and can be found here:

The MU source code will be released soon under the
Apache License,Version 2.0 .


Articles
“MU: an hybrid language for Web Mashups”
Davide Palmisano & Michele Mostarda

TODO: add Article URL

!
Under Development


Credits
Michele Mostarda (michele.mostarda)

michele.mostarda

michele.mostarda@gmail.com

michele@asemantics.com

http://www.asemantics.com


/* EOF */


MUp Early Preview V6

Recomendados

Recomendados

Más contenido relacionado

Similar a MUp Early Preview V6

Similar a MUp Early Preview V6 (20)

Último

Último (20)

MUp Early Preview V6