
Netflix Releases Falcor Developer Preview - vquemener
http://techblog.netflix.com/2015/08/falcor-developer-preview.html
======
samwgoldman
I really admire Netflix's ability to put together developer documentation for
their open source projects. I think it reflects well on their engineering
culture.

I was similarly impressed when I was reading the documentation for Hystrix,
which seems to share some functionality with Falcor, like request batching and
caching.

The path syntax is very readable and obviously plays to JavaScripts strengths
as a dynamic language. However, I would gladly pay the cost of more cumbersome
syntax to recover static analyzability through a tool like Flow or TypeScript.
With Observables in particular, the ability to track the type of the value
inside the Observable is really convenient.

~~~
Keats
I read some of the docs but that's the thing I noticed as well, it makes
typing impossible or at least very hard.

On the other hand, it looks very nice and the document is very well done as
well

------
rymndhng
I wish the website would link to this talk which gives some background on how
they got to falcor.

[https://www.youtube.com/watch?v=hOE6nVVr14c](https://www.youtube.com/watch?v=hOE6nVVr14c)

~~~
plurby
Thanks for that, great info. I've opened an issue
[https://github.com/Netflix/falcor/issues/430](https://github.com/Netflix/falcor/issues/430)
as it really should be included on the website.

------
EdSharkey
I have been following the falcor announcements, presentations and discussions
for a few months. I am really impressed at what a good job the Netflix team
has done with introducing the json graph concepts, I've learned a lot it
regardless of falcor. Kudos Netflix!

I really like the concepts and client/server model. If it is performant, it
will be fun to see persistent videogame worlds written through falcor. To that
end, would it be possible/effective to hang parts of the graph off of WeakMap
so that big, not recently used parts of the graph are allowed to fall away?
(Perhaps that is how it works right now, I haven't had a chance to look at the
source code, pardon my ignorance...)

~~~
findjashua
iirc, falcor maintains an LRU cache, so unused data keeps getting flushed out
of memory.

~~~
trxcllnt
Yes, this is the case.

------
javiercr
For those not yet familiarized with JSON Graphs, the Falcor's docs
introduction to JSON Graphs is awesome:
[http://netflix.github.io/falcor/documentation/jsongraph.html](http://netflix.github.io/falcor/documentation/jsongraph.html)

------
jrnkntl
This makes so much sense, after learning about Relay/GraphQL I was wondering
who else was working on something like it, it appears Netflix is one of them
:)

------
ixtli
I wish they'd tried to work with existing formats :(
[http://jsonapi.org/](http://jsonapi.org/) /
[https://github.com/jsog/jsog](https://github.com/jsog/jsog)

~~~
pat2man
Both those formats feel very unfriendly to me. Lots of odd standards that I
have never seen on any other popular API.

JSON Graph seems to just need one: { $type: "ref" }

------
hnruss
I think Falcor is conceptually interesting, but after reading some of the
documentation and project code, I don't want to use it (at this point).

The library bills itself as "middleware", but it looks more like an
application framework. I don't see how this would cleanly fit with other
application frameworks, as it appears that you have to use Falcor models,
routers, and datasources.

The project's code is concerning in a few ways: it's a large codebase, it
reads more like C++ than JavaScript, and there's not enough comments. In my
experience, successful JavaScript libraries are: small, use JS conventions,
and have well-documented source code.

It's great that they are releasing open-source software, though. I hope that
this project evolves into something that I want to use.

~~~
toomim
What's an example of the C++ conventions you're referring to? I'm looking at
the source now trying to identify them. I don't see them. Looks javascripty to
me.

------
stickfigure
For a _much_ simpler solution to the json graph problem:

[https://github.com/jsog/jsog](https://github.com/jsog/jsog)

Implementations in Javascript, Python, Ruby, and Java.

~~~
arxpoetica
Honest question, how is it simpler?

~~~
latchkey
One simple metric would be the number of lines of code:

[https://github.com/jsog/jsog/blob/master/src/JSOG.coffee](https://github.com/jsog/jsog/blob/master/src/JSOG.coffee)

------
gdi2290
Did anyone notice they walk you through Netflix-like microservice architecture
using Falcor Router?
[http://netflix.github.io/falcor/documentation/router.html#wa...](http://netflix.github.io/falcor/documentation/router.html#walkthrough-
building-a-router-for-netflix-like-application)

~~~
condescendence
what else would you expect?

------
WorldMaker
This seems interesting. Given Netflix's admitted love of RX [Reactive
Extensions] I'm somewhat curious if there is a design reason that this uses
Promises instead of (RxJS/Bacon/...) Observables? At first skim this seems
like it could be even more useful as an Observable model. I'm also curious if
there is a design reason they aren't using ES5 defineProperty/ES6 property
syntax over get()/set()?

(Reposting my questions from:
[https://news.ycombinator.com/item?id=10075433](https://news.ycombinator.com/item?id=10075433))

~~~
jhusain
Interestingly enough, we actually return Observables. The model returns a
Model Response, which inherits from Observable. It also adds a "then" method
which returns a promise when called.

The primary advantage of using the Observable's "subscribe" method instead of
"then" is that you can cancel a request. Netflix makes heavy use of this
feature. For example when quickly browsing through titles, we may cancel the
request for data that you are no longer looking at.

~~~
WorldMaker
That's very good to know. All of the examples I saw in the documentation were
using the Promise "then" and I didn't see any mention that they were in fact
returning Observables.

If I may suggest it, perhaps you might add this a bit more explicitly to the
documentation including possibly an example or two that makes use of them as
Observables?

------
d0m
Thoughts on the difference between graphql and Falcor?

~~~
xanderjanz
json wins

------
lyschoening
I've used a similar approach for Flask-Potion, a REST API framework
([http://potion.readthedocs.org/](http://potion.readthedocs.org/)). References
are JSON objects in the format {"$ref": uri}, which makes them exceedingly
simple to fetch and cache.

~~~
nathancahill
I've been looking for something like this!

------
danellis
My main issue with this is that it breaks HTTP caching, both in the browser
and upstream.

------
akilism
Just waiting on Om Next now...

~~~
lynndylanhurley
Yeah me too!! Anybody know the status?

~~~
derek
Some early ideas have already hit the repo[1]. David Nolen has been focused on
ClojureScript bootstrapping work[2] of late, but I expect he'll get back to Om
Next in the coming weeks.

1\.
[https://github.com/omcljs/om/blob/master/dev/om/dev.cljs](https://github.com/omcljs/om/blob/master/dev/om/dev.cljs)
2\.
[http://swannodette.github.io/2015/07/29/clojurescript-17/](http://swannodette.github.io/2015/07/29/clojurescript-17/)

------
fineline
This is really interesting and welcome contribution in an important space.
Three features that would make it compelling:

1\. Offline. Making the local datastore as "invisible" as the memory cache and
the cloud - keeping everything in sync under the hood. 2\. Push. Notifying
clients when changes occur. 3\. Diff. Efficiently handling changes in larger
values.

I realise none of these are central to the challenge they faced, and
congratulate them on an elegant solution for their situation.

~~~
gdi2290
yes it has offline :) They're working on the roadmap for Push

------
marknadal
This is great work, and neighbors very closely to what I am doing with
[http://github.com/amark/gun](http://github.com/amark/gun). But the caveat of
Falcor is that it does not have realtime updates (unless they have since
changed this, please let me know). I think this will be an Achilles heel for
their architecture, so I hope they improve on this. Otherwise, really exciting
news!

------
ken47
"Falcor automatically traverses references in your graph and makes requests as
needed."

This seems like it could be as much of a curse as a blessing. I hope 1.0 ships
with a good development/debug mode to gauge the efficiency auto-generated
requests.

------
dustingetz
If the underlying object graph isn't immutable, how does one guarantee
consistency when refreshing only portions of the graph?

~~~
trxcllnt
Falcor engineer here. In short, we don't expose the cache's structure directly
through any of the public methods. While we don't lock you out of your own
data if your JSON value is a complex Object (it's wrapped inside an Atom -
[http://netflix.github.io/falcor/doc/global.html#Atom](http://netflix.github.io/falcor/doc/global.html#Atom)),
any branches returned from get/set/call are separate Objects.

------
hokkos
Look more like OData for graph than GraphQL because of the paths query.

------
sweetcakes_2600
IMO, the name is to close to that of the Falcon (Python) web framework.
[http://falconframework.org/](http://falconframework.org/)

~~~
_neil
I disagree, though maybe I could see your point if you are unfamiliar with The
Never-ending Story. Even then, they are in different spaces so a mental name
collision seems unlikely.

