11/19 Reviews - Flapjax

[Rodrigo]

Please post your reviews here.

[Marcelo Martins]

Paper Title "Flapjax: A Programming Language for Ajax Applications"

Author(s) Leo A. Meyerovich et al.

Date OOPSLA'09, October'09

Novel Idea

Flaxpjax is a language designed for contemporary Web applications,
extending the Javascript model and providing a declarative interface. It
interoperates with Javascript code and leverages two key features that
guarantee consistency and uniformity when developing Web applications
using Javascript: event streams and event-driven reactivity.

Impact

Flapjax is a dataflow-based reactive language where values are updated
automatically to guarantee consistency. It collaborates to make programs
more declarative, and to achieve valuable separation of concerns,
relieving developers of this burden.

Evidence

Flapjax has been successfully used by several third-party developers to
build Web applications, e.g., Data Grid, Interactive Wiki, Network
Monitor, Resume, Continue 2.0, etc.

Prior Work/Competitive work

The article is filled with many references to techniques and tools
previously used that have inspired or are similar to Flapjax. Here we
mention only a few of them. Open Lazlo, Flex, JavaFX, and Arrowlets also
allow developers to specify control flow of JavaScript programs. A key
feature of Flapjax is its adoption of functional reactive programming, a
characteristic also present in FrTime.

Reproducibility

Flapjax is available for download and can be used as a library or
compiled to Javascript code.

Criticism

1.) The authors assume that the reader is already familiar with
Javascript and builds from small examples to describe the new features
of Flapjax. It took me a while to understand the source code and make
sense of what Flapjax is supposed to compile. The authors should have
described the API first and then started with the boilerplate examples.
I believe this is a more friendly approach to Ajax neophytes.

Ideas for future work

Considering the large amount of Web-based applications nowadays, an
evaluation of how Flapjax can improve their readability and consistency
would be an interesting example of how much power it provides to the
developer.

[Steve Gomez]

Author: L.A. Meyerovich, A. Guha, J. Baskin et al.

Paper Title: "Flapjax: A Programming Language for Ajax Applications"

Date: In OOPSLA '09

Flapjax is a language/JavaScript library "designed for contemporary
Web applications" - many of which handle data from multiple sources
and streams. The authors stress reactive semantics for the language,
consistency for developers reasoning about values in their code, and
uniformity for handling both external events and local events.

Reactive, event-flow semantics is a good choice for a Web program.
Reactive semantics (where variables composed of other values
automatically reflect mutations to 'component' values) is featured in
several other languages, and it makes sense to incorporate that into a
language like JavaScript. So this could have a big impact for
developers, who have a much harder time reasoning about current
JavaScript programs that don't account for side-effects well.

Flapjax can be used as a JavaScript library, and other libraries (like
jQuery, Arrowlets) and frameworks (Ruby-on-Rails, Django) that address
event sequencing and DOM transformations are considered for related
work. The reactive model that Flapjax uses is based on FrTime ("a
call-by-value instantiation of the FRP model"). Other work in this
area includes languages based around dataflow and stream processing
(Pipes, Formlets).

There is no quantitative evaluation of Flapjax. The authors seem to
argue that this is unnecessary ("It is impossible to measure the
'performance' of a language...") but I disagree with that claim. A
user could achieve the same program semantics and consistency
guarantees in plain old JavaScript (I mean, that is essentially what
Flapjax *is* - in a cleaner implementation), so they could compare two
JavaScript programs that do the same thing - one using Flapjax - and
see how they perform.

Maybe quantitative testing just says something about their
implementation, which may not have much scientific value. But the
project itself is a JavaScript library, and by definition just an
implementation of abstractions that help the developer. So those
numbers may be valuable. At least part of this paper is supposed to
convince a real developer to adopt the library, right??

Other criticism I have is the overwhelming describe-by-example feel of
this paper. I prefer more succinct writing, and not looking at pages
of code snippets. I think it is interesting to see some proof-of-
concept projects using Flapjax (like the Google Maps/Twitter example),
but a few is enough! Parts of the paper are just badly communicated
(I felt); for instance, in the "Performance" section, the paragraph
beginning "The most significant cost of Flapjax..." is all over the
place.

[Xiyang Liu]

Paper Title           
Flapjax: A Programming Language for Ajax Applications

Author(s)           
Leo A. Meyerovich, Arjun Guha, Jacob Baskin, Gregory H. Cooper, Michael Greenberg, Aleks Bromfield, Shriram Krishnamurthi

Date               
OPSLA’09, October 25–29, 2009

Novel Idea           
Flapjax is a web application programming language built atop JavaScript. Different from JavaScript, it abstracts event and behavior and uses the event-driven reactive paradigm in which the behavior is determined by event stream. The event-driven reactive model automatically propagates changes to DOM tree which eliminates callbacks and value inconsistencies. Flapjax also has interfaces to communicate with web services and persist objects to files.

Main Result(s)           
The authors developed Flapjax compiler which it can be used as a language or a Javascript library. It is now public and has been used to build several experimental and working applications.

Evidence           
The paper is full of Flapjax code snippet to demonstrate its principle and functionality.

Prior Work           
Flapjax is built atop Javascript. Flapjax program is compiled into Javascript beforehand or at run time.

Competitive work       
Flapjax is unique in web programming languages to adopt functional reactive programming where the idea is derived from dataflow programming. Some other languages and systems use dataflow-like features such as Yahoo! Pipes and Flex.

Reproducibility           
Yes. Flapjax is public and requires no modifications to browsers.

Question           
Flapjax seems to have implemented limited APIs. How do these APIs cover common programming use? For those haven't been implemented, is it better to write a Flapjax interface by developers to keep the abstraction of event/behavior or just turn to their familiar JavaScript.

Impact & Criticism           
Applying event-driving reactive programming to web programming language sounds attractive. But its use might be restricted by its hard-to-understand grammar when web developers are getting used to simple scripting languages. Especially current web development is largely done within IDEs. It is more efficient to drag UI component, set their attributes and write action scripts than embedding UI component code with functional-language-like program and worrying about the grammar correctness.

Future Work
It would be great to incorporate Flapjax with IDEs, probably developing an Eclipse plugin.

[James Tavares]

*Flapjax*

Paper Title: Flapjax: A Programming Language for Ajax Applications

Author(s): Leo A. Meyerovich, Arjun Guha, Jacob Baskin, Gregory H.

Cooper, Michael Greenberg, Aleks Broomfields, Shiriram Krishnamurthi

Date: OOPSLA �09. October 25-29, 2009.

Novel Idea: Flapjax is �language� built atop Javascript and HTML
designed to guarantee consistency in the face of numerous external and
internal events. Instead of forcing developers to reason about callbacks
and their effects on global state, the Flapjax developers have provided
JavaScript developers with so-called reactive semantics though the
addition of behaviors and event streams. Changes to behavior variables
and new events on event streams automatically propagate through the
system and recalculate any dependent values akin to a spreadsheet.
Execution occurs using a mostly-acyclical directed graph; cycles must be
broken by explicit or implicit delays. Flapjax can be used either a
language (where a compiler compiles Flapjax code into Javascript,
allowing users to get the full syntactic benefits of Flapjax), or as a
JavaScript library. The authors argue that consistency is so important
that a language authors should offer it as a basic primitive.

Main Result(s): The paper presents a case for why a new paradigm is
needed, presents the Flapjax language by a series of examples, and
discusses a number of instances where Flapjax has been used to create
�real� websites at Brown and elsewhere. Some lessons learned are
exposed, but no substantial evaluation is given.

Impact: This type of project usually gets judged by the size of its user
community�I noticed a website (flapjax-lang.org), but I�m not sure how
prevalent usage is.

Evidence: Simple JavaScript examples are given to demonstrate the
complexity of processing asynchronous events in JavaScript. Those, along
with narratives of the author�s development experiences, serve as
justification for the creation of the Flapjax language.

Prior/Competitive Work: The authors provided an authorities and detailed
review of prior and competitive work; a major asset of this paper. Some
highlights: Flapjax borrows its main ideas from FRP and FrTime. Stream
processing languages and systems such as Yahoo! Pipes, StreamIt,
Borealis, and Aurora all precede Flapjax and offer event processing in
streams. Open Laszlo allows for variables to be bound to user interface
elements, but differs from Flapjax in that lacks its glitch-freedom.
Alternatives such as MapJAX mask AJAX communication details by instead
providing a virtual shared memory and locking interface.

Reproducibility: Little to reproduce in quantitative terms. The Flapjax
language compiler and library are freely downloadable. Some of the sites
profiled (resume, contribute) could be recreated as illustrations of
developing in Flapjax.

Question: Open-ended: How will developers take to the event & behavior
model? It seemed a bit foreign to me while reading the paper, but it was
growing on me by the end.

Criticism: 1.) The authors should have made some type of stab at making
a quantitative performance measurement of either memory usage or CPU
usage vs. non-Flapjax-enabled apps, even if it was for one or more of
the simple application stubs presented in the examples. Of course, if
they had I would probably criticized them for a doing a poor evaluation
� I�m sure they couldn�t win!! 2.) Syntactically, it would be nice if
Flapjax distinguished between imperative variables and event/behavior
variables.

Future Work: I think a framework like this will find difficulty being
successful on its own right�I think it would need a higher-level layer
on top (think CPAN on Perl). Developers already using GWT, Dojo, or some
other library might encounter too much inertia in attempting to make the
switch to Flapjax.

[Andrew Ferguson]

Paper Title
"Flapjax: A Programming Language for Ajax Applications"

Authors
Meyerovich, Leo A., Guha, Arjun, Baskin, Jacob, Cooper, Gregory H.,
Greenberg, Michael, Bromfield, Aleks, and Krishnamurthi, Shriram

Date
ACM OOPSLA 2009

Novel Idea / Main Results
This paper presents Flapjax, a functional reactive programming
language built on JavaScript which provides two new first-class
citizens, event streams and behaviors, which make applications built
using Flapjax naturally consistent. Event streams can include external
events such as network traffic and internal events such as mouse
clicks. Flapjax propagates the events in the stream automatically and
updates dependent values. Behaviors describe how some property should
change based on the associated event stream. Flapjax provides a strong
API for interacting with event streams to combine events, filter
events, etc. Flapjax exists as both a library for traditional
JavaScript programs and a compiler to enable syntactic sugar.

Impact
Non-zero. Flapjax has been in use for a few years.

Evidence
Flapjax exists and has been used for a variety of projects (Continue
2.0 is very impressive), including some not developed by the authors
of this paper.

Prior Work
Flapjax is built on top of JavaScript and takes its cues from
functional reactive programming languages such as FrTime. Flapjax is
also informed by Haskell.

Competitive Work
There is a large collection of libraries and languages which are
similar to Flapjax including Frappé, Yahoo! Pipes, StreamIt, Aurora,
Borealis, Open Laszlo, Flex, JavaFX, ThingLab, Kaleidoscope,
Arrowlets, Formlets, Links and Hop.

Reproducibility
This language is publicly available and the simple examples discussed
in the paper could be reproduced with ease.

Question
What other languages besides JavaScript would be good candidates for
the ideas in Flapjax?

Criticism
In the subsection evaluating Flapjax's performance, the authors write
"we have used several (sound) heuristics to ...". I would have
appreciated if they had enumerated and described those heuristics so
that readers could determine for themselves whether they are sound or
not. Secondly, it is always annoying when a paper includes language
like "the astute reader may have noticed that..." -- don't talk down
to your readers! Lastly, I would have appreciated a comparison of
Flapjax on various browser/platform combinations -- How well does it
perform in IE7 on Windows? How about Safari? Firefox 2.0? Are there
some aspects of Flapjax which don't work under certain browsers?

Ideas for further work
None.

[Dan Rosenberg]

Paper Title
Flapjax: A Programming Language for Ajax Applications

Authors

Leo A. Meyerovich, et al.

Date
October 2009

Novel Idea
Flapjax is a language built on Javascript, designed for writing interactive web applications using two abstractions: event streams and behaviors.

Main Result
Flapjax enables programmers to use reactive primitives to provide interactive applications.

Impact
Flapjax is a good example of a functional reactive language, and requires no modification to existing browsers to run.

Evidence
The paper presents many real examples demonstrated how to write Flapjax programs.  Flapjax is readily available and can be used to write applications, including those mentioned in the paper.

Prior Work
Flapjax builds on previous work in functional-reactive programming, such as FrTime, and other languages with dataflow-like features, such as Yahoo Pipes, StreamIt, Open Laszlo, and JavaFX.

Reproducibility
N/A

Criticism
Examples are good for demonstrating how the language can be used in real life, but I felt there were a few too many and slightly cluttered the paper.  I've coded some small applications in Flapjax (using it as a library rather than a compiled language), and I would not describe it as intuitive to any programmer who doesn't have some background using dataflow-oriented languages - but it looks like the pre-compiled code is much easier to understand and write.

Questions/Ideas for Further Work
I would like to see more comprehensive user study examining whether programmers actually find this style more intuitive for their interactive applications.  In addition, while it's difficult to evaluate the "performance" of a programming language, comparing implementations of common tasks in different languages might be informative.

[Rodrigo Fonseca]

---------- Forwarded message ----------
From: Spiros Eliopoulos <seli...@gmail.com>
Date: Thu, Nov 19, 2009 at 3:52 PM
Subject: Flapjax review
To: Rodrigo Fonseca <rfon...@cs.brown.edu>


The paper presents Flapjax, a JavaScript library for
functional-reactive programming. Rather than directly using the
event-based interface to the DOM, or the asynchronous AJAX API of
modern browsers, Flapjax wraps these APIs in objects called event
streams that are composable via simple combinator library.

Integrating web services into the Flapjax framework is not as
straightforward as the paper makes it seem. Most of this discussion
assumes a RESTful API of sorts. Though this would be ideal, many web
APIs are not so straightforward, and usually do not conform to HTTP in
the slightest. Regardless, each web API must be "Flapjaxified," which
may leave some users at the mercy of the community to do this for
them. At best, they would simply use the non-Flapjaxified API wich
many users would find familiar.

While propagating events, some computations may be repeated. If the
computation involves side-effects, this can be detected. The Flapjax
abstraction is therefore leaky.

The motivating example is such an obvious straw-man that it diminished
the impact of the rest of the paper. Specifically, functional-reactive
programming is not the only way to eliminate the possibility of the
bug in the example.. Another possible approach would be to encapsulate
the state (elapsedTime) in some object, and offer an API to read and
modify the state. (For simplicity, consider a simple get() and set()
API). One could then register event handlers with this object that
would be called every time set() is called, with the event handlers
being passed the new state. This is the approach that many
widely-deployed JavaScript libraries with great success. So the
question is then why is Flapjax better than this approach?

Continuing with the criticism of the first example, the first argument
to setTimeout() need not be a string, but in fact may be a function
that will be called when the timer goes off. This is important to
point out. A string containing code to be executed may not admit
static analysis, whereas function callback could be analyzed just like
any other piece of code. The emphasis of the word string in step 5 is
meant to convey this, and furthermore suggest that this is inherent to
the event-based model of the browser. Indeed, we can take the content
of any string literal and place it as program text into the body of an
anonymous function to achieve the same goal. For non-string literals
that are used in this position, I'd argue it's either the case that
you could turn the string into a callback, or the string should not be
used at all. (For example, strings returned by web services.) I would
argue, but I won't here.

Furthermore, the description of what's going on in the first example
is hardly generous in its clarity.

The evaluation claims that "it is impossible to measure the
'performance' of a language." Yet, there are sites dedicated to
precisely that goal, such as the great language shootout. By
implementing and profiling standard benchmarks for each language
implementation, one is given a sense of their relative performance.
There is no reason this could not have been done for Flapjax.

[Rodrigo Fonseca]

---------- Forwarded message ----------
From: James Tavares <james....@gmail.com>
Date: Wed, Nov 18, 2009 at 10:20 PM
Subject: [csci2950-u] 11/19 Reviews - Flapjax
To: CSCI2950u <brown-cs...@googlegroups.com>


*Flapjax*

Paper Title: Flapjax: A Programming Language for Ajax Applications

Author(s): Leo A. Meyerovich, Arjun Guha, Jacob Baskin, Gregory H.
Cooper, Michael Greenberg, Aleks Broomfields, Shiriram Krishnamurthi

Date: OOPSLA ’09. October 25-29, 2009.

Novel Idea: Flapjax is “language” built atop Javascript and HTML

designed to guarantee consistency in the face of numerous external and
internal events. Instead of forcing developers to reason about
callbacks and their effects on global state, the Flapjax developers
have provided JavaScript developers with so-called reactive semantics
though the addition of behaviors and event streams. Changes to
behavior variables and new events on event streams automatically
propagate through the system and recalculate any dependent values akin
to a spreadsheet. Execution occurs using a mostly-acyclical directed
graph; cycles must be broken by explicit or implicit delays. Flapjax
can be used either a language (where a compiler compiles Flapjax code
into Javascript, allowing users to get the full syntactic benefits of
Flapjax), or as a JavaScript library. The authors argue that
consistency is so important that a language authors should offer it as
a basic primitive.

Main Result(s): The paper presents a case for why a new paradigm is
needed, presents the Flapjax language by a series of examples, and
discusses a number of instances where Flapjax has been used to create

“real” websites at Brown and elsewhere. Some lessons learned are

exposed, but no substantial evaluation is given.

Impact: This type of project usually gets judged by the size of its

user community—I noticed a website (flapjax-lang.org), but I’m not

sure how prevalent usage is.

Evidence: Simple JavaScript examples are given to demonstrate the
complexity of processing asynchronous events in JavaScript. Those,

along with narratives of the author’s development experiences, serve

as justification for the creation of the Flapjax language.

Prior/Competitive Work: The authors provided an authorities and
detailed review of prior and competitive work; a major asset of this
paper. Some highlights: Flapjax borrows its main ideas from FRP and
FrTime. Stream processing languages and systems such as Yahoo! Pipes,
StreamIt, Borealis, and Aurora all precede Flapjax and offer event
processing in streams. Open Laszlo allows for variables to be bound to
user interface elements, but differs from Flapjax in that lacks its
glitch-freedom. Alternatives such as MapJAX mask AJAX communication
details by instead providing a virtual shared memory and locking
interface.

Reproducibility: Little to reproduce in quantitative terms. The
Flapjax language compiler and library are freely downloadable. Some of
the sites profiled (resume, contribute) could be recreated as
illustrations of developing in Flapjax.

Question: Open-ended: How will developers take to the event & behavior
model? It seemed a bit foreign to me while reading the paper, but it
was growing on me by the end.

Criticism: 1.) The authors should have made some type of stab at
making a quantitative performance measurement of either memory usage
or CPU usage vs. non-Flapjax-enabled apps, even if it was for one or
more of the simple application stubs presented in the examples. Of
course, if they had I would probably criticized them for a doing a

poor evaluation – I’m sure they couldn’t win!! 2.) Syntactically, it

would be nice if Flapjax distinguished between imperative variables
and event/behavior variables.

Future Work: I think a framework like this will find difficulty being

successful on its own right—I think it would need a higher-level layer

[Rodrigo Fonseca]

---------- Forwarded message ----------
From: Kevin Tierney <herr...@gmail.com>
Date: Thu, Nov 19, 2009 at 10:00 AM
Subject: Re: [csci2950-u] 11/19 Reviews - Flapjax
To: brown-cs...@googlegroups.com


Title: Flapjax: A Programming Language for Ajax Applications

Author(s): Meyerovich, et. al.
Date: OOPSLA 2009
Novel Idea
Flapjax is a programming language/library that recognized dependencies
in data and provides event streams to JavaScript. It is implemented in
JavaScript.

Main Result(s)
The paper shows through examples that cleaner client-side scripting is
possible through the use of FlapJax. FlapJax enables the easy
construction of interesting mash ups (twitter + google maps) through
its event streams.

Impact
I don't think this will have a major impact, but that doesn't mean it
won't get some use across the web.

Evidence
Provided on their website.

Prior Work
Yahoo Pipes seems like the most similar prior work, in that it can
take in streams of other websites.

Reproducibility
Not only can I, I went to their website and I confirmed that it works.

Question
Could the problems in JavaScript Flapjax addresses be better fixed by
replacing JavaScript with a better language entirely?

Criticism
The paper basically sidesteps the idea of a performance hit for using
Flapjax over coding in regular javascript- but some tests (perhaps on
their example problems?) would illuminate this issue.

I find the dynamically updating variables based on dependencies to be
rather cool, but it seems like that could cause some unwanted side
effects for a programmer who isn't paying really close attention.

Ideas for further work
No

On Wed, Nov 18, 2009 at 10:43 PM, Rodrigo <rodrigo...@gmail.com> wrote:

[Rodrigo]

From Qiao:

[Novel Idea]
Allow developpers to write reactive interfaces in a declarative and
compositional style. Can be considered as either a programming
language or a
JavaScript library


[Main Result(s)]
Flapjax's design and implementation.

[Impact]
Provide a choice to write reactive interfaces eaisier, and can be
writen purely new or inherited from standard JavaScript. Run on
unmodified
browsers and interoperates.


[Evidence]
- Flapjax has two features: event streams, and reactive.
- Flapjax is push-driven, event-driven, reactive dataflow evaluation.
- Flapjax is a dataflow-based reactive language wherein values are
automatically updated to be consistent, relieving developers of this
burden.
- Flapjax converts JavaScript programs into dataflowgraphs. A graph
noderepresents a computation.
- The push-based,demand-driven evaluation strategy is a good match for
systemswith many kinds of external stimuli that do not obey asingle
central
clocking strategy.
- The Flapjax source code has JavaScript’ syntax.

[Prior Work]
FRP(related to functional reactive programming) and DP(dataflow
programming).

[Competitive work]
FrTime; Frappe.

[Reproducibility]
Yes, develop both as a new library and a newly-designed-language
compilier.

[Question & Criticism]
Authors are clever to make it useable as library, now only a new
language.
They can also provide some usually used functions as build-in.

[Juexin Wang]

Paper Title  

Flapjax: A Programming Language for Ajax Applications

Author(s)  

Leo A. Meyerovich,  Arjun Guha,  Jacob Baskin,  Gregory H. Cooper,  Michael Greenberg

 

Date  
Oct, 2009
 
Novel Idea  
Useable as either a programming language or as a JavaScript library, and it's designed for both uses. Events and behaviors are essentially signal-processing abstractions.

 

 

Main Result(s) 
Flapjax, designed around the demands of modern, client-based Web applications, provides a unified framework for programming with events, both within the program and when communicating withWeb services.

 

Impact  

Provide web-application developers a language/library to write reactive interfaces in a declarative and compositional style. And it's built upon JavaScript, allows it to run on unmodified browsers and interoperates.

 
Evidence  

- Two features: event streams, and reactive.

- Event streams: a uniform abstractionfor communication within a program as well as with externalWeb services.

- Reactive: it's a dataflow-like, spreadsheet-like mechanism that makes it easy to work with dynamically-changing variables, automatically tracks data dependencies and propagates updates along those dataflows, makes values to be consistent, relieving developers of this burden.

- Flapjax converts JavaScript programs into dataflowgraphs. Dataflow graphs are mostly-acyclic directed graphsfrom sources to sinks. Flapjax “pushes” values through the graph.

- Flapjax is globally persistent. The language comes with built-in server-side storage. User-based ownership is also built in, and data can be shared between users.

- Flapjax is an event-stream abstraction for communicating with web services, an interfaces to external web services.

- The Flapjax source code has JavaScript’ syntax. The Flapjax compiler transforms Flapjax code into JavaScriptand produces standard Web pages containing just HTML andJavaScript. It includes the Flapjax library and elaboratesFlapjax source code to call library functions as necessary. 

- The transparent reactivity strategy: compiler allows Flapjax and JavaScript code toseamlessly interoperate, because they share namespaces.

 

  
Prior Work

Related to Functional Reactive Programming and Dataflow Programming. 

 
Competitive work  

FrTime, employs a purely push-based, event-driven updatestrategy.

And some other dataflow-like languages, constraint programming systems.

 
Reproducibility  

Consider it as a new language, the mainly task is to design a programming language and write a (to-JavaScript) compilier.
 
Question  

Is it necessary to provide debugging for Flapjax ?

 

Criticism  
In all, it seems not great enough to encourage developers, especially experienced ones, to learn a new language. But it does not need to modify anything and can be used as library, things are not that bad. So in future they should consider adding more build-in funtions to attract more developpers.
--
J.W
Happy to receive ur message

On Wed, Nov 18, 2009 at 10:43 PM, Rodrigo <rodrigo...@gmail.com> wrote:

Please post your reviews here.

--
J.W
Happy to receive ur message

[Kevin Tierney]

Title: Flapjax: A Programming Language for Ajax Applications

On Wed, Nov 18, 2009 at 10:43 PM, Rodrigo <rodrigo...@gmail.com> wrote: