Emerging Technologies Conference 2012
>
Emerging Technologies Conference 2012

Emerging Technologies Conference 2012

It’s not often that the RSuite technical team gets to travel from their caffeine-laced lairs. But last week Rob Diana, director of product engineering, and Bryan Elliott, senior UI architect, attended the Emerging Technologies Conference in Philadelphia and reported back. The conference had record attendance and was sold out. Following are some of their thoughts on the various presentations.

Self Engineering, Chad Fowler (LivingSocial)

Bryan: The ideas presented in this talk were more life-hacking than tech-hacking—but the talk was inspiring. The premise was that of treating one’s life goals as engineering problems, and using those principles—measurement, decomposition, analysis, iteration, etc.—to drive the goals forward.

Rob: The talk set the tone for the conference as a whole. Digging into other areas of the sciences can help with whatever you are working on. The measurement, analysis, improvement loop was a common theme in many presentations.

Javascript, Programming style, and your brain, Douglas Crockford (Yahoo)

Bryan: I didn’t know what to expect from this talk but I am familiar with Crockford and some of his work. He proceeded to outline the motivation for creating JSLint and the reasoning behind some of the most restrictive cases, making a convincing case for each—citing reduction of common error frequency as the most common reason for most subsetting rules. I came away feeling humbled and knowing that I should probably lint 3.7 to, at least, understand where the failures were likely to be.

Ember.js: Attacking Boilerplate where it lives, Yehuda Katz (SproutCore, Ruby on Rails, jQuery core)

Bryan: Ember.js is a fairly lightweight (143k) framework that solves common problems in application development—the most notable being that of end-to-end data binding. That is to say, a single update to the client-side model of a ManagedObject would update every presentational instance of that Object with no further coding. This is the end result, but this result is enabled by an object model that includes many missing language constructs in Javascript; it can be, among other things, considered a “java.util.*” for Javascript.

Just beyond HTML5: Device APIs with PhoneGap, Brian Leroux (PhoneGap)

Bryan: (Web) Device APIs are an ongoing set of independent projects going on at the W3C, Mozilla, several Cell manufacturers and service providers. They are simply ways for a browser to get access to the device’s hardware in useful ways. While the projects are all starting to converge now – and standards emerging – there are significant problems yet to be solved. Most notable of these are a common security model that asks the user for permission to perform a task in a way that is both not annoying (“may coolthing.com do this, please?” every 5 seconds) and not cursory (like the install-time permissions for Android apps, resulting in a “yeah whatever you like” response from most users).

Abstracting CSS for Sustainable UI, David Kaneda (Sencha)

Bryan: CSS can quickly become a mess for even the most basic web application. Less, Sass/Scss, and Stylus are CSS preprocessors that enable simple, abstracted style rules to be constructed that produce complex CSS. I had already considered using Less with the RSuite product, and this talk convinced me.

The Evolution of CSS Layout: Through CSS 3 and Beyond, Elika J. Etemad (W3C)

Bryan: This was a brief walk down the history of CSS, the technical challenges inherent in describing the CSS level 3 2d layout spec. Fascinating and lots of political intrigue, but not much meat to report on.

Emerging Programming Languages: A Tour of the Horizon, Alex Payne (Simple Finance)

Rob: There is a ton of work going into developing new languages. Whether it is a better Java or JavaScript, or something completely different like new querying languages. Alex tried to focus on languages people mostly have not heard of, so the direct applicability is not readily apparent. However, he essentially gave an overview of the various types of languages that are available and what to use them for.

Building Real-Time Web Applications, Aaron Mulder (Chariot Solutions)

Bryan: Discussion of Web Sockets and Web workers as enablers of real-time applications in a browser. Web Sockets are especially interesting to me to enable the server to push notifications out to the browser, rather than rely on polling. Web workers are less interesting to be in the context of RSuite: while they enable serious client-side processing without interupting the interface thread, the hardest thing RSuite does is parse JSON and XML – and because webworkers have to communicate via serialized data, that’s hardly a help.

The Coffeescript Edge, Trevor Burnham (Author of CoffeeScript: Accelerated Javascript Development)

Bryan: CoffeeScript is a terse language that compiles into clean Javascript. I was aware of it before, and I may seek to learn it now. Integrating it into the CMS build process and the build for our plugins would be fairly trivial, and may be useful for writing better code but I don’t intend to use it in RSuite unless a compelling case can be made, and even adding the feature may just be the urge to Kitchen Sink in every cool thing.

Javascript Testing: Completing the BDD Circle in Web Development, Trevor Lalish-Menagh (Comcast, EnvJasmine)

Bryan: Unit testing of Javascript code was not something I had considered to be feasible. I had always approached the UI testing question as an end-to-end matter: use Selenium to test your final product. This talk gave an example of how to unit test Javascript at build time, and enable UI developers (i.e., me) to notice a build break before commit, rather than after; how to integrate a platform like EnvJasmine into Maven or Ant; how to run a CI such as Jenkins. Being able to TDD my Javascript will be a nice change.

Storm: Scalable and Fault-Tolerant Realtime Computation, Nathan Marz (Twitter)

Rob: Realtime data collection and processing is a hot topic right now and Storm is an open source product from Twitter. Twitter uses Storm for much of their analytics tracking, so it is required to be a distributed solution. Basically, it is like Hadoop for realtime data.

The Programming Ape, Coda Hale (Yammer)

Rob: “Software needs to fit the human mind.” The basic idea being our brains are wired to do some things better than others. Pattern matching is one thing humans do well. As an example, a graph showing some performance metric might show a spike at some points, but what is the context and is it really a problem. Baselining the information and potentially showing a colored based chart is intuitively easier for humans to process.

SQL, NoSQL or NewSQL, Chris Richardson (SpringSource)

Rob: Simple comparison of some of the NoSQL solutions (MongoDB and Cassandra) as well as NewSQL tools (VoltDB) and why they can be used instead of a traditional RDBMS. MongoDB looks very interesting and could be useful for storing internal metrics. Cassandra is widely used but querying the data just sucks. NewSQL is really an RDBMS but with distributed scaling built in. VoltDB does not look ready for production use.

Emerging Languages, Alex Payne (Simple Finance)

Rob: There is a ton of work going into developing new languages. Whether it is a better Java or JavaScript, or something completely different like new querying languages. Alex tried to focus on languages people mostly have not heard of, so the direct applicability is not readily apparent. However, he essentially gave an overview of the various types of languages that are available and what to use them for.

Behind the Scenes with Spring Batch, Josh Long (SpringSource)

Rob: Spring Batch is yet another framework for batch processing. I am not sure if it would fit with our background processing or scheduled job frameworks, but definitely something to look into. I did not stay for the whole session.

Effective use of FindBugs in large software development efforts, Bill Pugh (inventor, Skip Lists; lead, FindBugs)

Rob: I joined this session half way through. FindBugs is a static analysis tool that can find potential errors in your Java code. He talked about prioritizing issues, customizing FindBugs, sharing issue data and using annotations with FindBugs. There was some mention of plugins but I would rather not worry about the structure of a class file and how to manipulate Java bytecode.

HTML5 Apps in Java and Scala with Play, James Ward (Heroku)

Rob: Not much about HTML5, but plenty of discussion about Play, a web development framework. Essentially, Play is a hybrid of Restlet and some of the Spring Controller ideas. I had hoped to see more information about the breadth of Play but it is definitely something I will be looking into for upcoming RSuite releases. Also, this was one of many sessions to talk about Scala, a newer language built on the Java VM. I will be looking at Scala to determine if it fits into our architecture and whether it would benefit us at all. Akka is another framework, used for actors and event-driven applications, mentioned fairly often and supposedly integrates with Play.

Building Applications with Functional Domain Models, Event Sourcing and Actors, Debasish Ghosh (Author, DSLs in Action)

Rob: This was a difficult presentation to follow. Slides were text heavy. However, the content was interesting and complex. Modeling functions or behaviors in the system as opposed to modeling objects is becoming more popular in the mainstream. By modeling behaviors, event-driven applications become much simpler to implement as they have a direct relation to your domain model. This was another presentation using Scala and Akka.

Kanban, Lean and Large-Scale Agile, James Shore (Author, The Art of Agile Development)

Rob: First, large-scale agile is really just more than one team using agile processes. Kanban comes from the Toyota production systems, where a Kanban is an empty bucket or bin. The basic idea is that we are trying to no significant backlog of work products. This means, no huge pile of requirements documents, but giving a partial set of requirements to the design team. This can be extrapolated to all of the groups on a project where they are assured of having a small list of things to be working on, and all of the teams are working in parallel.

Creating a Cross Platform Experience, Doug Bellenger (Movitas)

Rob: Movitas develops mobile applications for the hospitality industry. The apps have to run on various platforms, like the web, tables, blackberry, iphone and android. They created layers of abstraction when some things needed similar functionality, but the user interface or skin needed to be different. Knowing where the abstractions should be is difficult. There was not a lot of coding detail in the presentation, mostly just some high level concepts.

Share on

There are no comments

Leave a Reply

Your email address will not be published. Required fields are marked *

Start typing and press Enter to search

Shopping Cart