Justin Donaldson's speech at WWX2014, other videos, photos, slides and comments : http://www.silexlabs.org/?p=202971 The 4th International Haxe Conference WWX2014 organized by Silex Labs took place from 23th to 26th may 2014 in Paris. http://wwx.silexlabs.org/2014/

1. promhx
Programming Reactive Object Methods in Haxe

2. A bit about me…
Data Visualization + Data
Science + Machine Learning +
Advanced UI

3. I “Promhx” to explain…
var p = new Promise<Explanation>();
var s = new Stream<Examples>();
var d = new Deferred<Understanding>();
But first some background…

4. Asynchronous Programming
• Client code is often single threaded. Excessive time delays due to computation
causes rendering lag, and can block IO.
We often need to break up computation in multiple loops.
• Client code often handles server responses through asynchronous callbacks.
We need to wait for the server to respond.
• Managing error handling often involves careful use of try-catch in several
locations. It is difficult to ensure all exceptions are caught.
We want a better way of handling generic errors.
• Callbacks generally follow a nested pattern
Nested code indentation patterns can become difficult to read.
• Server side platforms are finding success with asynchronous programming
techniques, with the same opportunities and pitfalls (nodejs). However, server side
implementations often have different methods of managing asynchronous
callbacks.
We want to implement asynchronous code the same way on client/server.

5. Asynchronous Programming
How many potential problems in this code?

6. Asynchronous Programming
Missed error handling
Lost space due to indentation
Duplicate error handling
Not *really* 0 seconds

7. Functional Reactive
Programming to the Rescue
Wikipedia : “In computing, reactive programming is a programming
paradigm oriented around data flows and the propagation of change.
This means that it should be possible to express static or dynamic data
flows with ease in the programming languages used, and that the
underlying execution model will automatically propagate changes
through the data flow.”
Reactive programming moves the unit of asynchronous programming
from a callback to a special object. It is a variable over time.

8. Promhx Object
Container Object
Value : _

9. Promhx Object
Container Object
Value :_resolve thenx function(_){…}
function(_){…}
function(_){…}

10. Promhx Object
Container Object
Value : xresolve thenx function(x){…}
function(x){…}
function(x){…}

11. Promhx Object
Container Object
Value : xresolve thenx function(x){…}
function(x){…}
function(x){…}
Loop n Loop n+1

12. Promhx Looping
Container Object
Value : x
Loop n Loop n+1
setImmediate
• Avoid the default delay of
4ms-10ms in setTimeout
• Avoid scheduling a new paint
task in
requestAnimationFrame
• Provide polyfill for backwards
compatibility (via noble.js)
Javascript specific details

13. Promhx Looping
Container Object
Value : x
Loop n Loop n+1
???
Other platforms : BYOEL
(bring your own event loop)

14. Promhx Object
Chaining
Value :_resolve then_ Value :_resolve then
Loop n Loop n+1 Loop n+2

15. Promhx Object
Chaining
Value : xresolve thenx Value :_resolve then
Loop n Loop n+1 Loop n+2

16. Promhx Object
Chaining
Value : xresolve thenx Value : xresolve then
Loop n Loop n+1 Loop n+2

17. Promhx Object
Chaining
Value : xresolve thenx Value : xresolve then
Loop n Loop n+1 Loop n+2
x

18. Wikipedia : “In computer science, future, promise, and
delay refer to constructs used for synchronizing in some
concurrent programming languages. They describe an
object that acts as a proxy for a result that is initially
unknown, usually because the computation of its value is
yet incomplete.”
What is a Promise?

19. What is a (Reactive) Stream?
Wikipedia : “In computer science, a stream is a
sequence of data elements made available over time. A
stream can be thought of as a conveyor belt that allows
items to be processed one at a time rather than in large
batches.”

20. Promises vs. Streams
• Promises
• Good for providing initial configuration, and ensuring that an asynchronous workflow
progresses “forward”.
• Can only resolve once!
• Streams
• Good for providing general-purpose reactive programming.
• Resolves more than once.
• Promises and Streams
• Generally, promises can be substituted where streams are expected, but not vice-versa.
• Both provide the same error semantics, and optimized asynchronous event loop
management.
• Both use Deferreds as a writable interface…

21. What is a Deferred?
Deferreds are a writable interface for reactive objects. Use them to prevent other developers
from mistakenly resolving a Promise or Stream that they should not have access to.*
!
*The notable exception is PublicStream, which is globally write-accessible.

22. What is a Deferred?
Container Object
Value :_
!
resolve
then
x
function(_){…}
function(_){…}
function(_){…}
Deferred

23. Basics of Reactive
Programming in Promhx
Move the callback to the proxy object

24. Basics of working with
Promises
then vs. when : instance vs. static usage

25. Error handling
• Errors are propagated through the reactive chain
• catchError() functions like a try/catch, preventing updates to other reactive variables.
• Use Haxe’s try/catch semantics to catch typed errors.

26. Promhx Object
Error Handling
Value :_resolve then Value :_resolve then
Loop n Loop n+1 Loop n+2
catchError
(private error linking method)

27. Promhx Object
Error Handling
Value :_resolve thenE Value :_resolve then
Loop n Loop n+1 Loop n+2
E
catchError
(private error linking method)

28. Promhx Object
Error Handling
Value :_resolve thenE Value :_resolve then
Loop n Loop n+1 Loop n+2
E E
catchError
(private error linking method)E

29. Promhx Object
Error Handling
Value :_resolve thenE Value :_resolve then
Loop n Loop n+1 Loop n+2
(private error linking method)
E
E
E
catchError E

30. Error handling
• errorThen() allows you to convert an error back into the appropriate
variable type.
• This variable can be propagated as if it were resolved normally.

31. Promhx Object
Recovering from an error
Value :_resolve then
Loop n+1
errorThen
Value :_resolve then
Loop n Loop n+2

32. Promhx Object
Value :_resolve then
Loop n+1
E
errorThen
E Value :_resolve then
Loop n Loop n+2
Recovering from an error

33. Promhx Object
Value :_resolve then
Loop n+1
E
errorThen
E Value :xresolve then
X
Loop n Loop n+2
Recovering from an error

34. Promhx Object
Value :_resolve then
Loop n+1
E
errorThen
E Value :xresolve then
X
X
Loop n Loop n+2
Recovering from an error

35. Are promhx objects
Monads?
• Type constructor : Create a monadic type for the underlying type. For example
it defines type Promise<Int> for the underlying type Int. I.e. the class
constructor
• unit function : Wraps a value of underlying type into a monad. For Promise
monad it wraps value 2 of type number into value Promise(2) of type
Promise<Int>. I.e. Promise.promise.
• bind function : Chains operations on monadic values. I.e. the “then” function.
…So yes, but why should we
care?
Three requirements for Monads:

36. Monads are useful
!
• Allows for new capabilities for a given type, and allows the original functions to use
the new capabilities.
• Captures operations on types, making it easier to build complex compositions that
all behave by the same simple rules.
• Represents side-effecting operations cleanly in languages where this is problematic

37. Monad Composability
• Do-notation provided courtesy of Monax (Stephane Ledorze)
• The “<=“ operator binds the result returned via then()
• We can drop the chain syntax, and write out promises as if they were a
simple series of expressions.

38. Composability vs. Standards
• JS: callback usage is predominant, especially in
platforms like node.
• Should we follow standards? Standards are good
right?

39. Promises A+ Spec
Promise<Promise<T>?
pipe/flatMap
then /map
No composability

40. Well Tested
~30 f tests
x 7 platforms
(2 have problems)

41. Promhx Speed

42. That’s it!
• I talked about why we need better asynchronous programming methods
• I talked about the basics of functional reactive programming
• I talked about the basic types of FRP that promhx supports, Promise,
Stream, and PublicStream. I also talked about what each one is
designed for, and how they use Deferred where appropriate.
• I talked about the way promhx handles errors and loop behavior
• I talked about some cool tricks that promhx can do since it behaves as
a monad
• I talked about how fast and well tested the library is

43. QUESTIONS
?

44. We’re Hiring!
• UI Dev Positions - Search and other teams
• Offices in Paris/Grenoble/Seattle/(etc.)
(San Francisco HQ)
• Not much Haxe… yet!