Chris Granger sort of thinks he's Steve Jobs. He's probably around my age, with a boyish face and nerdy demeanor, the prototypical wiz kid. His main claim to fame is Light Table, a "new kind of IDE" for programmers, which was successfully Kickstarted back in 2012 to the tune of $316,720.

Light Table was my first breakthrough in programming. Usually in programming, you write some code, have some idea of what it will do, and run it and find out. It probably doesn't do what you thought it would do. Then you look at the code and try to figure out what went wrong. Light Table turned this process on its head, showing exactly how data flows through the code, each step of the way. For me, a beginner, it gave me insight into how my code went wrong. By seeing how the code was actually behaving at the function level — this chunk took in this input, gave out this output — I learned much more about programming. It removed some of the "black box" aspect of code, and gave me a deeper understanding than trial and error ever had.

The ideas in Light Table, like most good ideas anywhere, weren't entirely Chris Granger's. He openly drew on the work of Bret Victor, a former Apple employee, who has waged a long crusade about how wrong-headed most programming methods are for learning. Chris was also previously employed at Microsoft, where he worked on Visual Studio, and was able to observe in what way new users struggled to understand programming paradigms. What was so impressive about Light Table is that it took these ideas out of the theoretical and into reality.

Light Table was built with ClojureScript, a version of the programming language Clojure which compiles to JavaScript, the universal language of the web. By building on ClojureScript, Light Table was able to run in a browser engine (a now popular idea for many apps, including GitHub's own code editor, Atom), and be easily extensible.

ClojureScript, and its parent language Clojure, were also the perfect languages to work on in Light Table. Their functional paradigm fit well with Light Table's model: look at your program as a transformation of data from one form to another. Since ClojureScript was built to run in a web browser, and Light Table was built on a web browser, it was also the perfect place to experiment with web development. Your code on the left, the resulting web page your were forging on the right.

ClojureScript was built by a really cool guy. David Nolen lived in New York, worked at The New York Times, and tweeted about jazz. In a way, though, his mission was quite similar to Chris's: there was something fundamentally wrong about most programming languages, and ClojureScript could deliver the fix where it was needed the most, in the web browser.

David always seemed a little more pragmatic than Chris. In his blog posts and conference talks he'd always talk about how you can do something cool and different right now with your code. He'd tell you how things should be. Chris, in his blog posts and various videos, would tell you how things could be in some glorious future. I liken Chris to Steve Jobs because he has that same tactic of tearing down everything that's currently in vogue in the space, and then introducing his solution. Except his solutions never quite seem to materialize, at least not entirely.

The problem

Light Table was buggy from the beginning. It was entirely too easy for me, as a terrible programmer, to create infinite loops or stack overflows with my code which would require a force quit of the program. There was always something finicky about how Light Table would connect, or not connect, to a web browser or other external process — connections which were required for its code evaluation magic to work.

And then, at the peak of Light Table, just as it was getting great and meeting all its Kickstarter stretch goals and changing my life and getting written up by everyone including David Nolen who made whole tutorials for ClojureScript based on Light Table... Chris open sourced Light Table and moved on to a new project.

Open source is a two-edged sword, but mostly we're lucky in the 21st century to deal with the good edge. Programmers especially are able to do the majority of their work with free, open source, continually improved, and surprisingly composable tools. And yet, the high bar of quality or inherent complexity of many of these projects means that many people — like me — aren't good enough to contribute to our favorite open source projects. We take, and take, and we think to ourselves "Well, this can't be sustainable, can it?"

Some open source projects have a corporate backer, which can ensure their survival. Other projects are simply so popular that they're unstoppable. Many of the best open source projects are a combination of both of those things. And yet, many other open source projects are simply a labor of love by one or two dedicated contributors, who give their software to the community while expecting little in return. It's a marvel of human kindness, but it can't be taken for granted.

Chris Granger's new project is kind of hard to explain. It's a "radical rethink" of just about everything to do with programming. It's an editor, a language, a framework... it promises to make programming accessible to even more people than Light Table did, and give them the tools to create full, powerful web apps. It sounds glorious, and it sounds too good to be true, and I watch the project obsessively.

David Nolen, meanwhile, left The New York Times to work full time for Clojure's primary corporate sponsor, Cognitect. Since he joined Cognitect, he's been rapidly iterating on ClojureScript, and the Clojure and ClojureScript community is booming. David's side project, Om, which offers an ideal way to make web apps with ClojureScript, is not only popular in the functional programming community, but has impacted the web developer community as a whole. Ideas from David's side of the programmer ideological camp (there's a growing Red / Blue-style distinction between "functional" and "object oriented" programming paradigms) are making big waves across the industry.

And, unfortunately, Light Table hasn't kept up with the changes in ClojureScript. Over time it's become more difficult, to the point of almost being impossible, to develop new ClojureScript applications, especially web applications, with Light Table. I eventually gave up trying, and moved to a "real" text editor (Vim) and an entirely different hipster programming language (Elixir). Without Light Table's insights, I found ClojureScript too difficult for my brain. I miss the Light Table-fueled learning process, but I'm also more productive and more effective now. I'm learning programming the old fashioned way; my apologies to Bret Victor.

The fight

Recently, a spat bloomed in the Light Table project's discussion group. Titled "Version 0.8 - status or lack thereof," the thread became a sounding board for the frustrations of some of the users with the stagnation of the project.

Chris chimed in, explaining why the project was stalling. Mostly, he blamed the way he built Light Table for making a high barrier to entry: "I optimized for keeping the codebase small enough that one person could work on it and along the way I ended up making decisions that ultimately made it more difficult for others to contribute."

Eventually, he even pointed to ClojureScript as culprit:

A whole lot has changed, and I would certainly do things differently if I were starting from scratch today. For one, I probably wouldn't have chosen to do it in CLJS *(ClojureScript)*. It's just too much of a moving target and architecture ends up being far more important than the specific language used.

Soon after, David Nolen chimed in on Twitter:

The fallout

And that's when I got sad. That's when I got this phrase stuck in my head, "My open source parents are fighting." I owe so much to these two guys. The industry owes so much to these two guys. And they don't owe me a thing. But it sucks.

And no, they're not really fighting. Passive aggression? Maybe. But it's not an all out war. Light Table actually is progressing with better Clojure support contributed by the community. The ideas of Light Table keep on popping up in other places, like Apple's own "Playgrounds" in Xcode. Meanwhile, the ideas in ClojureScript and Om are some sort of miracle salve for most of what troubles front end web developers. After I'm done flirting with Elixir, I'll probably migrate back to ClojureScript because it feels like the "right" way to make web apps. Other rapidly-emerging tools, like Figwheel and Cursive, take up some of Light Table's slack.

But it's still been hard for me to process. A big part of programming is choosing the right tool for the job. And that sort of means picking sides. And then it becomes a little personal. And if the two progenitors of your tool of choice aren't getting along? I guess it shouldn't really impact me emotionally or even technologically, but it does.

On the other side of the open source world, there's good news: Node.js and io.js are merging. Io.js is a fork of the wildly popular open source Node.js project, created by a cadre of core Node.js developers, dissatisfied with the corporate parentage of Node to the best of my understanding. It was a big fight, as far as open source fights go, requiring a multitude of developers to choose between two literal, divergent sides. But io.js folks got their way, it seems, and now it's one big happy family again.

Isn't it great when everything just works out?

About Paul Miller

That guy who left the internet for a year