Fluent ConferenceEarlier this summer, I had the privilege of attending O’Reilly Media’sFluent Conference: JavaScript and Beyond” in San Francisco, California. This was a fantastic 3 day event with many amazing workshops and presentations. The conference featured many of O’Reilly’s authors, some of who work for companies like Google, Mozilla and Twitter.

The conference offered sessions and workshops through a variety of tracks including General , in the Browser, , , Ancillary Technologies, Business JS, and Gaming. My personal focus was in the General JavaScript, , Mobile, and Node.js. The conference was a busy, feature packed event, pushing me to full 10-11 hour days. There were 3-5 sessions and events happening at the same time. It was hard to be in that many places at once. Fortunately, as part of my All-Access pass, I recently received access to the videos from the sessions I missed and have plans on reviewing them very soon.

The conference presentation was very professional with a casual, comfortable feel from the speakers and the audience. Unlike some “conferences” I have been to where sponsors are shoving their products down your throat, strangely, it was almost difficult to get the vendors to talk about their products.

The diversity of the audience at Fluent was amazing. Attendees came from all over the world and were of all ages, genders and skill sets. It was a very impressive mix. The JavaScript world is nothing like the “Old Boys Club” that exists in other technologies spaces.

For more information on the Fluent Conference, visit http://fluentconf.com. All of the keynotes and interviews are freely available on YouTube at http://www.youtube.com/view_play_list?p=PL75AC4484E6866741.

The following is a summary of my experiences at Fluent. It is a compilation of my notes from a the conference workshops, sessions, vendors exhibits, and interactions with other attendees.

Front-End Stacks are Becoming Increasingly Complex

Most Web UI Developers are very familiar with the explosion of complexity when working with the /CSS3 and JavaScript. The number of available frameworks, libraries, tools, and plugins grows exponentially every day. It would take years to become an expert in the biggest players in the JavaScript space that are available today. CSS Pre-processors, JavaScript builders and compilers are basically standard now. As Brandon Eich, the father of JavaScript and CTO of Mozilla (@BrendanEich, http://brendaneich.com), discussed in his keynote, “JavaScript at 17“, future versions of JavaScript will embrace these complex stacks and standards may follow.

I have found it interesting that very few of these frameworks are attempting the toolbox approach in their libraries. Instead, there are numerous smaller, more focused projects that the developers can bring together into their application stack. Sencha and Dojo are the minority in this “kitchen sink” approach by providing the entire application toolbox for their products. It seems as though there are many reasons for projects not taking the toolkit approach, centering around budget and time as well as expertise.

Most of the speakers and attendees have been parting out their applications from a variety of projects and creating incredibly complex stacks. Combining concepts like event dispatchers, model-view-view model (MVVM) frameworks, and other libraries can build some powerful, modular applications. I am very interested to see how Web UI stacks evolves over time.

The Future of JavaScript

”Evolving a web language is hard.”
-Dr. Axel Rauschmayer, 2ality consulting

JavaScript is growing up. 17 years young and has a new edition in its future as well. In Brandon Eich’s keynote, he described two difficult objectives in the evolution of JavaScript: maintain backward compatibility and to preserve the way the language works.

The ECMAScript.next initiative is heating up in the Harmony working group to produce an update to JavaScript with attempts to make it better than ever by addressing some of the complaints of developers. Both Brandon Eich’s “JavaScript at 17” and Dr. Axel Raschmayer’s (@rauschma, http://www.2ality.com), “Improving JavaScript” keynotes discussed about JavaScript’s newest features like block-scoped variables, “arrow” functions, class and module declarations, etc… the next version of JavaScript will be a power house.

Good or bad, I am always amazed with how backwards compatibile the web is. The new features will be backwards compatible with the older revisions of JavaScript. Although the new standard is expected to be released in about a year and a half, prototypes of the new features are already in the latest nightly builds of Firefox and can be enabled through a flag in Chrome. As the details for features are finalized, other browsers will likely have these updates implemented before the specification is formally released.

Lean Server Architectures and APIs

My team has been using the term “Thick Client-like” to describe our API-centric, application logic in the browser architecture. However, this term drums up very scary app delivery and maintenance nightmares from the days of old and it made it difficult to describe the approach. At the conference, I heard the term “Lean Server” used by Lea Verou (@leaverou, http://lea.verou.me) in her keynote “Turning to the Client Side” and it fits perfectly with the strategy we are pushing forward to the business.

This architecture moves more of the application processing to the client browser while using APIs to interface with the server and the persistance layers. With browsers becoming more and more powerful and the web being a widely available delivery method, moving the application logic into the browser is very realistic and allows for the creation of wonderful user experiences. Using Lean Server Architectures, applications can have infinite scalability, responsive user interfaces, and reduced server costs. The architecture opens up the ability to minimize the amount of data transferred and can maximizes the usefulness of the application.

Verou also noted how Cross-Origin Resource Sharing (CORS) is changing the web. She mentioned that user’s trust popular 3rd party companies more than someone that they have never heard of. However, as Steve Souders (Google, @souders, http://stevesouders.com) noted in his keynote “Your Script Just Killed My Site“, 3rd party API’s can be a Single Point of Failure (SPOF) for your site. It is important to run your 3rd party APIs asynchronously so that they do not block the execution of your site or app if there is an issue.


The Fluent conference had an entire track dedicated to mobile. This included a wonderful workshop hosted by Maximiliano Firtman (@firt, http://www.firt.mobi) that discussed some of the many challenges of mobile and offered some great bits of information. In his session Firtman estimated that there are 2,000 to 4,000 combinations of devices, platforms and versions with 14 popular mobile browsers at this time. This makes development and testing a real nightmare. Hopefully through innovation, these issues will shake themselves out over time.

The exponentially increasing power of graphics and CPU’s in mobile devices was also discussed as well as the opportunities that this it presents. It is amazing that so much power can fit into a device that can slide into your pocket. However, this power does come with its limitations and bottlenecks. Globally, mobile networks are still very slow and battery capacity by weight has not improved much over time. Definitely some challenges that will need to be faced in an untethered world.

On the web front, the slow implantation of HTML5 features into the browsers was a popular topic. Fortunately, Firtman has put together a wonderful resource for tracking what HTML5 features are available on each mobile plaftorm at http://mobilehtml5.org. The missing or poorly implemented HTML5 fearures have hurt the mobile web and have allowed apps to take over. Ben Galbraith (http://functionsource.com) and Dion Almaer (@dalmaer, http://almaer.com) discussed in their keynote “Web vs. Apps”  how the web won this fight before as browsers, hardware and web technologies caught up with what could be accomplished on native platforms on the desktop.

Non-standard Computing Devices

”We didn’t buy Palm to be in the smartphone business.”
-Marc Hurd, Former HP CEO

We all know that “mobile” is the future. But mobile is much bigger than phones and tablets. Mobile is the beginning in the evolution of thinking differently about the web and how users interface with devices. It is the convergence of web technologies and non-traditional computer devices. As Tom Hughs-Croucher (@sh1mmer, http://tomhughescroucher.com) discusssed in his keynote, the Internet has become the “Internet of Things“. JavaScript and event driven programming are being used in a variety of places including things like cars and home automation.

”Minimize the amount of data, but maximize the usefulness.”
-Tom Hughes-Croucher, Author of O’Reilly’s Node.js, Consultant

It is the convergence of web technologies and non-traditional computer devices. An interesting point mentioned by Tom Hughes-Croucher was that iOS was really our first consumer grade operating system. It is the first OS that your grandmother could use without a lot of help. Before iOS, learning an OS was hard. There were some very interesting perspective that came out of the keynotes in this space and I am very excited to see how these conversations will shape up in the next year.

Maintainable and Reusable Code

“Be kind to your future self.”
-Chris Eppstein, Creator of Compass

There was a lot of random talk about the level of respect that UI code receives at Fluent. Nicholas C. Zakas (@slicknet, http://www.nczonline.net) hosted a session where he spoke about Maintainable JavaScript. He covered many items that all software developers should already know about, but it is important to hear again and again. Zakas discussed topics including documenting code, the importance of style guides, and to treat the code with respect. He also noted that you should build your code and anticipate that it will need to be maintained for up to 5 year. Separation of concerns was also a very common theme; keeping your presentation code out of the JavaScript, using templating strategies, styling out of your code, etc…

In my 12+ years of doing development work, I am am amazed that developers continuously need to be reminded how to make code clean and maintainable. Time, budget and/or poor implementation are usually cited as reasons for this problem. Fortunately, things are changing and the UI is getting a little more respect these days. Hopefully this will add more time and budget to projects helping make maintainable JavaScript a priority in the future. Either way, I believe that developers need to make writing high-quality, maintainable code a part of their daily work habits.

Tools of the Trade

”I think we’re seeing the emphasis shift from valuing trivia to valuing tools.”
-Rebecca Murphey, author of the open-source book jQuery Fundamentals

In the past, you would walk into a job interview for a web development job and you would get quizzed about your knowledge of working around Internet Explorer 6 bugs. In my interview for my current position, I was asked by my peers (who have been in this industry a decade longer than I have) a lot about the tools that I use to get my work done. In the end, the question was “how do you solve problems?” Trivia and name dropping don’t get you as far as it used to.

As important as tools can be, many web developers still aren’t using the best tools for the job. Many find something and stick with it. Paul Irish (@paul_irish, http://paulirish.com, http://setapp.me/users/paul_irish) spoke a lot about the tools of the trade in his keynote, “Javascript Development Workflow of 2013“. He discussed many useful tools, some of which can be found in the Resources section at the bottom of this post.

Irish was also very passionate about having developer’s share their development hardware and software setups. He discussed Setapp, a tool where developers can share their hardware and software configurations as well as rating and discussing them. You can find my Setapp profile at: http://setapp.me/users/jziggy618.

Up until very recently, I spent most of my time working in Eclipse due to its Tomcat server and Java integration. Since the conference, I have picked up Sublime Text 2 with many nice plugins to easy my Web UI development. I still run Eclipse in the background to edit, build and serve my Java projects, but I have it set to refresh from the file system so I can work with other technologies in more appropriate IDEs.

Another observation I made at Fluent was that Apple might as well just be standard equipment for JavaScript developers. In all of the sessions that I attended, all of the speakers used MacBooks. All of them. The audience was about 2/3rds on Mac hardware or were taking notes using iPads. Most of the tools Irish discussed are only available on OS X.


Node is such an interesting topic. There was a lot of talk about it and even a full workshop and session track discussing Node.js and its modules at Fluent. I was really hoping these workshops and sessions would give me to the information I needed to bring back a solution to my superiors on how to use Node.js in the business. The Node.js sessions confirmed a lot of my research and learning. Node is a clear performance leader and asynchronous, event-driven programming is the future. But, I am not ready to stand behind it as a viable business solution.

I attended a session led by Sean Hess titled “How to Deploy a Node.js App to Production (And Not Get Fired)”. What I learned was that if I used some of the standard strategies for running a production Node server, I would get fired. In its current state, I think Node.js may work great for a single task application, build process or maybe a small, high-I/O application. Application failure and scaling opportunities are still very difficult to manage. Node’s release cycle is way to fast to manage and the package library is littered with bad, outdated or incomplete projects. I still can’t recommend using it in a corporate environment until this matures.

Products and Frameworks

One of the things that really impressed me at the Fluent conference was that I didn’t have products and services pushed down my throat from sponsors or vendors. The vendors receptions were very casual and comfortable. The vendor hall was much smaller than I would have guessed and it was half full with startups that were demoing their products. These startups had an opportunity to be voted on by the attendees for the best startup and the winner would receive funds from O’Reilly.

I spoke with a variety of the startups including StackMob, kanban2go, xTuple, PicPlum and Ordrin and even had the pleasure of hearing some of them discuss their development stacks. xTuple stands out in my mind as they took an interesting approach of using Canvas to drive their software. They found it to have better performance on mobile devices that plain old HTML/CSS/JS. Kanban2Go is a simple task management system that looks and performed very well. Clipboard.com was another impressive startup from Gary “Dr. Flakenstein” Flake as demoed in his keynote, “Bookmarklets as Applications“,  that allows users to post web snippets to a central location. Very incredible work and smart thinking from these startups.

There were quite a few framework sponsors out at Fluent. I was very impressed by Enyo‘s presence at the show. I spent a lot of time at their booth talking about the evolution of Enyo and untimely death of WebOS. Even got a high quality t-shirt. Unfortunately, I was unable to attend the deeper dive into Enyo, but will be watching the video from that session soon. I hope to also have a good opportunity to use Enyo on a project in the future. It looks like a solid product for quality cross-platform JavaScript.

Sencha also had a large presence as a sponsor and I had the opportunity to sit in on Aditya Bansod’s (@adityabansod) demo of their Architect IDE building a mobile application. The Sencha booth in the vendor hall stood out from some of the others. I think they have made it to the big time: their booth staffed with very pretty sales girls and their engineer was all sorts of cocky. That’s OK… When you have a solid product and are making money, you can be like that.

The biggest vendor disappointment was Appcelerator. I stopped by their booth to discuss the future of their products and ask questions to their engineers about how their product worked. Although confident, the guy I spoke with didn’t seem to have much of a clue about what he was talking about and I was immediately turned off. I asked him to address some of the concerns that I had read about performance and bugs and he skated around the issues. They seem to be changing focus to cloud hosting and I’m not sure they know what they want to do with their Titanium product. Definitely didn’t get the warm and fuzzy feeling from that discussion.

Another impressive vendor at the show was Wijmo, a jQuery based library with Dojo-like widgets. I am very excited to explore this library and see what it can bring to the table. It moved up in my list of frameworks to evaluate. Scoring a t-shirt from them didn’t help with moving them up on the list. Yes, I can be bought.

And last… I have to comment on Yahoo!‘s presence at Fluent. It was sad. There wasn’t anything at their both. The people that were there didn’t really speak about anything. But they did have a drawing to get some very boring (and ugly) purple shirts. I guess there were happier days in Silicon Valley for Yahoo!. I’m not really sure why they showed up.

Dojo is being used?!?!?!?! WHA?

Dojo had absolutely no presence at the Fluent conference. There was no mention of it in any of the workshops or sessions that I attended. I am living in a Dojo world in my current position. One of my goals for this conference was to find out who, if anyone, was using Dojo in their development work and see how they overcome the challenges that my team and I have felt with it. I assumed I would be reporting that no one else uses it and that we should move on. However, much to my dismay, it seems developers I spoke with at Fluent are using Dojo full time.

However, the story was the same for most I spoke with: the use of Dojo was inherited from a team of Java developers who don’t know JavaScript. It was not the first choice of seasoned JavaScript developers. There were concerns about the documentation and road map of the product. The general consensus was that it had grown so large and bulky that the core developers can’t seem to handle it anymore. The code and markup it generates are old and outdated in an effort to support Internet Explorer 6, which no one supports anymore (finally).

But alas, it is being used. By why does no one talk about it? Why is there absolutely no community on the web? I guess when developers aren’t passionate about something, they just don’t talk about it… or admit they are using it.

NoSQL back to relational databases

When speaking with some other developers and vendors in the “stack talks”, there was an interesting trend of developers starting applications using NoSQL databases, especially with Node.js, and later deciding that their data belonged in a relational database. Many cited that their data “just made sense” in a relational format. This will be another interesting trend to keep an eye on.


Working in or with a company that has it’s development teams lead by the server-side teams is still normal and is usually a challenge for Web UI developers. Although most of the speakers and attendees I spoke with were proud and held their head’s high, there is a general lack of disrespect felt by other technology teams and peers for the UI developers and the work that they do. This is sad and very disappointing, especially when the popular push is for the majority of a web application to live in the client.

Nicole Sullivan’s (@stubbornella, http://stubbornella.org/content) “Don’t Feed The Feed Trolls” keynote was very popular at Fuent. Sullivan spoke about the different types of negative people that can be encountered on a daily basis and to keep from feeding this negativity. This topic doesn’t just apply for technology, but can be aplied anywhere.

Forward Thinking

”The web is still the widest platform.”
-Brendan Eich, CTO Mozilla and Father of JavaScript

The future is incredibly bright for JavaScript. It is 17 years young and still evolving. Engines like V8 and SpiderMonkey have paved the way for JavaScript and it is now beginning to be recognized as a”real” language in the software engineering space. The support for JavaScript work is increasing, the dollars are flowing and it is a great time to be a JavaScript and Web UI Developer!

Next year, I would love to see O’Reilly add an extra day and spread out the activities. The conference days were very long and I was nearly exhausted with information overload. I would also like to see more sessions relating to enterprise level development with JavaScript as well as an expansion to the Business JavaScript track. [As much as it pains me to say this] It also would have been nice to have more vendors to speak with and discuss product opportunities.

Overall, I was incredibly impressed with the Fluent Conference. I hope that I have an opportunity to attend again next year. This conference was filled with quality presentations and information. Even with over a decade of development experience, I learned a lot and solidified my knowledge in a lot of areas. I highly recommend that anyone who has an opportunity to attend this event in 2013 makes plans to do so.


The following are some resources, links and information I put together from the conference. Obviously this doesn’t include eveything that happened and everyone who spoke at Fluent. I put this together fairly quickly, please let me know if there are errors or issues.


The Speakers

Here is a list of some of the speakers that I had the opportunity to hear from with there Twitter accounts and blogs.



Frameworks, Libraries and Utilities

  • AngularJS – http://angularjs.org
    Google’s solution to HTML data binding with JavaScript and controllers. Very popular and very powerful.
  • Wijmo – http://wijmo.com
    Basically turns jQuery into Dojo. Adds UI widgets, Theming and uses Knockout at the MVVM framework.
  • Sencha – http://www.sencha.com
    Framework provider that offers a full MVC framework and widgets for desktop and mobile
  • Filer.js – https://github.com/ebidel/filer.js
    A library that uses the HTML5 Filesystem API to create a file system explorer using UNIX like commands for the API
  • idb.filesystem.js – https://github.com/ebidel/idb.filesystem.js
    A filesystem implementation for browsers that don’t support HTML5 Filesystem API natively. Uses indexedDB as a storage layer
  • props2js – https://github.com/nzakas/props2js
    Converts properties to a JavaScript-based format – JSON, JSONP, raw JavaScript)
  • Cloud9 Editor – http://ace.ajax.org
    A stand alone code editor written in JavaScript
  • Modernizr – http://modernizr.com
    An open-source JavaScript library that helps you build the next generation of HTML5 and CSS3-powered websites and gracefully falling back for older browsers.
  • RedRiver – https://github.com/RiverTrail/RiverTrail
    A ParallelArray abstraction for JavaScript and a Firefox add-on to enable parallel programming in JavaScript targeting multi-core CPUs and vector SSE/AVX instructions.