James Long

What do CRDTs and frontends have to do with each other?

What do CRDTs and frontends have to do with each other? 

James talks about how CRDTs finally deliver on the promise of local-first apps, which provide superior user experience, and explains how simple CRDTs can be and how to leverage them to create robust local-first apps.

2019

dotJS

CRDTs for Mortals

2018

React Conf

Block the Main Thread

2017

A Prettier Printer (plus bonus clip!)

Come sit around the fire and listen to the tale of rebuilding the Firefox JavaScript Debugger with React and Redux. We’ll tell you the horrors, the glorious triumphs, and lessons learned while building a very complex UI with these technologies. Take a swig of our tales and wipe away the enduring fatigue as you see how this is all actually worth it.

You will also get a sneak peek into our ultra-secretive new JavaScript debugger frontend (it’s on github), and see what we think a modern debugger should be.

2016

React Rally

Debugging Your Debugger

The frontend landscape changes at a relentless pace. New ideas seem to appear every month. How can you possibly keep up? I'm on the Firefox Developer Tools team, and we are starting to move towards React and Redux for our frontend. I will explain these choices, the reasons behind them, and how we're migrating old code. Our minds can only keep up with a certain level of abstraction, and it's important to choose abstractions that solve fundamental problems rather than shallow ones. The right abstractions will make an order of magnitude difference in power and simplicity, and the wrong ones can be deadly. It's important to estimate the cost of every abstraction, and be ruthless about keeping it as simple as possible.


Works for Mozilla on the Firefox Developer Tools, mostly trying to make debugging JavaScript better. He's spent the last 8 years studying programming languages like Lisp and Scheme, and trying to bring various ideas to JavaScript. He likes to write in-depth articles about interesting programming ideas. Most of his free time is now happily dedicated to his daughter

2015

ReactiveConf

Abstracting just enough

React has a simple way for components to communicate with each other: pass event handlers down through children and events will flow upwards to parent components. This works well for simple components and certain UI events, but it breaks down with large complex apps. The Flux architecture helps with this by defining 'actions' that components can fire and subscribe to, and you write code outside of your components to handle data and dependencies of the actions.

With the advent of 'goroutines' and channels in languages like Go and Clojure, we have a new style of coordinating actions. We have developed a library that allows you to write goroutine-like code on top of generators, called js-csp. I will take a look at how this might be used to handle complex data flow in a React-based app. We will see what parts of Flux and React's event system might be improved, or if it even helps at all!