Yee haw! Paperless Post sent three people to the cowboy-themed JSConf in Scottsdale, Arizona recently, and now that we’re back from the Wild, Wild West, I thought I’d share some of my conference experiences.

Though I’ve been using JavaScript professionally for quite some time, and I keep up with the community at large, I have never been to a JSConf before, and many of the people at the conference were new to me. Traveling with Paperless Post CTO and JSConf Alumnus @aq certainly helped, but the openness and accessibility of the conference venue and its participants certainly would have made this conference approachable and fun for anyone.

Instead of attempting to recap the entire experience, which isn’t possible, or even trying to cover all of the amazing talks, which would also be difficult, I thought I’d highlight a few of my favorite moments which I think will properly speak to the quality and success of the two-day conference.

The Return of Play and a Standing Ovation

The community of developers who congregate a few times a year to celebrate JavaScript and all of its incarnations is a thoroughly modern bunch. They are creating cutting edge web application architecture stacks, trying to overthrow the hegemony of native mobile software, and writing 3D graphics simulations in fewer characters than I’ve used in this sentence. While this penchant for the next leads to a lot of innovation and progress, it can also manifest itself in a repetitive way when presented in the conference setting: “Here’s this cool thing I did! It doesn’t really work, but check it out, I did it!” or “Here’s this thing that will certainly be the best thing ever!” are all too common.

Two talks were stark contrasts to this theme, in that they presented ideas that rooted themselves firmly in the trajectory of computing history, and tried to focus as much on ideas as implementation. David Nolen’s talk about Jelly Stains was a trip through the history of his various programming language love affairs, and Daniel Henry Holmes Ingalls, Jr.’s presentation on The Lively Kernel was a hilarious and surprising retelling of the manifestation of a lifetime’s worth of work.

Jelly Stains was a talk about how David Nolen, a JavaScript developer at the New York Times, by chance stumbled upon a series of Computer Science books which manages to share two qualities not often found in the same text: playfulness and denseness. The Little Schemer, The Seasoned Schemer, and The Reasoned Schemer take the reader through a conversational and philosophical journey through the Scheme programming language, a “minimalist LISP” that is also the deus ex machina of another hallmark Computer Science text, The Structure and Interpretation of Computer Programs. Nolen talked about how a relatively unknown “third paradigm” of Programming Languages, Relational or Logic Programming, changed the way he thought about problem solving, and the defining role that the freedom to play had in his transformation. He then took us on a trip back in time, sharing with us the notorious Zebra Puzzle, and illustrated with ease the stark contrasts between Functional, Object Oriented, and Logic Programming. Nolen showed some recent experiments with ClojureScript, which brings Clojure syntax to the JS runtime, and talked about implementing a logic engine in Clojure called core.logic. A trip that started with Javascript and ended with Nolen working alongside his idols was routed heavily through playful terrains that were radically disconnected from the work he was doing in a professional context. This is a lesson we can all use.

The Lively Kernel is “a new approach to web programming” that was founded at Sun Microsystems in 2006 by Dan Ingalls and Antero Taivalsaari. In case Ingall’s name isn’t familiar, read up about his history with the Smalltalk programming language and advances in Virtual Machine technology here. During his talk, Ingalls took the JSConf audience through a tour of the Kernel, which is quite aptly named. Illustrating that every aspect of the system is “alive,” and that it exists in order to make other connections possible, Ingalls used it to make pianos play, elephants dance, and graphs fill with data. His ease at the podium was highlighted by several exhortations that “that’s how it should be,” noting that he has spent a large part of his career trying to make live systems de rigeur, and that our pleasure at seeing things “just work” should be a catalyst for us to actually get up and make them work. I was very impressed that the JSConf community overlooked the lack of visual polish in this presentation and that everyone seemed to gain easy delight from the fact that the simple interactivity obviously rested on a deeply complex and well implemented kernel. Ingalls gave the crowd the gift of vision, and the crowd returned the favor with a well-deserved standing ovation.

Embracing the Low-Level

In addition to the fanciful-but-technical talks, there were a few technical-but-fanciful talks which also went beyond the stereotypical areas of interest for JavaScript programmers. In fact it should be noted that after JSConf it’s no longer worthwhile to harbor stereotypes about “JavaScript programmers” at all – they’re doing all kinds of things you’d never expect. Blowing straight past frameworks, libraries, and even browsers, these talks focused on the Virtual Machines that make JavaScript run so ubiquitously. Stephan Herhut from Intel gave a presentation on Parallel Extensions for JavaScript, while Vyacheslav “Slava” Egorov asked the question Can V8 Do That?

Each of these talks were particularly interesting in how they walked the audience through the process of looking at code in JavaScript and seeing how it manifested itself by the time it got to the assembler code that the Virtual Machines use to “speak” to the host OS. Herhut demonstrated the River Trail parallel data structures that Intel is experimenting with, which could allow for the design of concurrent JavaScript applications that didn’t rely on process concurrency. The idea that a JavaScript developer could look at code that needs to be written and reason about it in terms of data concurrency semantics is a very encouraging one. It means that parallel execution of code paths could be a reality in modern JavaScript implementations, and that developers could write code to execute this way without having to do more than choose the right data structure and model their algorithms accordingly.

Can V8 Do That? gave the audience a chance to peer into the mind of one of the hackers doing work most relevant to modern JavaScript implementations, as presenter Slava Egorov is a member of the V8 team in Aarhus, Denmark. V8 is the JavaScript runtime that both Google Chrome and node.js use to interpret JavaScript code. Egorov took a gentle approach with the audience, encouraging us to not be afraid of the assembler code he displayed on slides, instead telling us that the patterns we saw and explanations he give could lead us to logical conclusions. The basic question is one that is common to developers in any language - to optimize now, or to optimize later? The twist here is that V8 does a lot to optimize our code for us, and Egorov used this fact to debunk some common optimization strategies (such as caching array.length()) and to show us other areas where V8 doesn’t optimize as successfully. The message was a clear and hopeful one - write your code, reason about it, and read up on what V8 can do - it can make you a more confident programmer who writes more efficient code.

Standing in Circles and Nodding

The one thing that I had heard about JSConfs that proved to be very true was that the experiences outside of the conference rooms would be as valuable as the talks themselves. The conference in general has an air of accessibility and in general doesn’t take itself too seriously, and this lends itself to lots of casual conversation. I cannot stress enough how many of the most fun and enlightening moments from the two day conference came from standing in circles with people and chatting. At one point I found myself standing around with beers or coffees in hand with Brian Ford of Rubinius, Slava Egorov, Rick Hudson of Intel, and David Nolen, chatting about the cutting edge Garbage Collection technology used by Rubinius, the JVM and V8. All I could do was smile and nod, knowing that I was in the company of brilliance, and feeling lucky enough to get a glimpse.

What’s even cooler is that when you looked around at JSConf, these kinds of conversations were happening everywhere – speakers made themselves available after their talks or at the sponsored parties, and in general, a congenial air of collaboration amongst peers dominated.

Hope for “the language with a bad upbringing”

After Dan Ingall’s rousing demonstration of the Lively Kernel, I asked him a question about something he hadn’t addressed – what are his opinions and thoughts about working with JavaScript as a language? Since I know he was involved in the implementation of Virtual Machines and was obviously a deep thinker with regard to evaluating Programming Languages, I thought he would have some brilliant insights. His response was more or less that he obviously loved it or he wouldn’t be working with it, and that although JavaScript “had a bad upbringing,” Brendan (referring to Brendan Eich, credited as the creator of the language) had “done a great job with it.”

At first I wanted him to dig some dirt and maybe get a little controversial, but upon reflection, Mr. Ingall’s words depict a hopeful future for the language. I showed up at the conference expecting a lot of whizz-bang, and ended up with a lot of deep ideas. People continue to do astounding things with JavaScript, despite it being a language that is not without its warts and technological and political constraints. Between these speakers and others, the atmosphere, the voracious minds of the community– it’s difficult to leave this conference not convinced that there is a strong foundation and a bright adulthood ahead for JavaScript.

If you’re interested in Paperless Post’s commitment to professional development, we’ve posted about going to conferences before, and keep in mind: we’re looking for more talented people in NYC and SF.

Some Resources

• Daniel Friedman’s Work, including the Reasoned Schemer
• The Zebra Puzzle that David Nolen spoke of
• The Lively Kernel that Dan Ingalls demonstrated
• Intel’s River Trail as provided by Intel
• Google’s V8: an overview

Update 04/18/2012 - The photos from the booth sponsored by Paperless Post are up! Check them out here!