All Proposals: In no particular order

If you purchase your ticket before Wednesday the 27th of February you can vote on which proposals you want to see at ScotlandJS 2013!

Title #1

Figurepool, HTML5 diagramming editor, front-end & back-end architecture


Introducing Figurepool, an HTML5 diagramming and graphics editor. Figurepool is written from ground-up in JavaScript - front-end (Backbone.js + Raphael), backend (NodeJS + ExpressJS) up to the database (CouchDB). In this talk, I'd like to cover the whole architecture of Figurepool starting with client side implementation of the editor up to the production server configuration with NodeJS, CouchDB, Redis and ElasticSearch.

Title #2

Writing databases in JavaScript


Have a look at the database ecosystem we have: There are many solutions that work for this or work for that, some more specific like Redis and others a lot more general, like the relational ones, but every db is to be taken as is. When your application's needs don't fit into one of those schemes, you're screwed. Either combine multiple of them into a big stack that's difficult to manage and you never know if it will work with future requirements. Or just use one and do it the even uglier way. I don't like either. It's a shame that there is no system or framework for writing databases. For combining your desired replication scheme with exactly the data model you need, where you decide which tradeoffs you make. But wait: there is! There's a recent development in node.js where several people are paving the way of writing databases in JavaScript. They often share a strong focus on realtime and distributed computing (as that's what node is good for) and can be combined at will for the databases of the future. I will walk you through the ecosystem as it is today and show with some live coding how much you can accomplish when combining the right kinds of tools in a simple way.

Title #3



The getUserMedia API is one of the most exciting APIs to talk about right now. What if we could use the webcam to detect movement from the user? In this riveting presentation, (PROPOSER) will show each of us how to use the getUserMedia API. He will show us how to capture the users' webcam. He will show us how to analyze their feed to detect movements from your users. Join the show and learn how to add gestures to your site.

Title #4

JS.Next - ECMAScript 6


Come check out the show. We will spend the time intimately touching each of the features in the ES6 release. By the time the show is over, attendees will be conjugally familiar with ES6. As the author of the upcoming O'Reilly book 'JS.Next: ES6', (PROPOSER) will show us each of the new features in the new JavaScript API.

Title #5

Asynchronous patterns


Asynchronous programming is hard to understand for people coming from a different language or sometimes even experienced developers. In this talk, I'll give a refresher on the theorical aspects of the event loop and JavaScript concurrency model. Then, I'll move on to different async programming patterns, use cases where they apply, tips to recognize these patterns and what a good JavaScript API for each pattern looks like.

Title #6

Application security is easy with POLA and Object Capabilities


Back in December 2011, I was unemployed and took this opportunity to read Mark Miller's thesis and related papers and talks. I discovered the "Virus-Safe Computing Initiative" and the amazing work of people like Marc Stiegler, Alan Karp and Tyler Close. At first, the work of these crazy computer scientists is a jungle with quotes of Buffy the Vampire Slayer, defeating Skynet, URLs being enough to build a secure web application, security without annoying confirmation popups, etc. But at some point it all to started to make sense. I learned that well-applied object oriented programing good practices can be all you need to build secure JavaScript and web applications. More than that, I acquired a thought framework helping me to understand whether an application is secure and why. While most developers consider security as a complicated aspect of applications that should be left to experts, "object capabilities" and POLA (Principle Of Least Authority) make it easy to understand the security implications of your code or library code. In this talk, I'll share with you this thought framework.

Title #7

Anatomy Of A Million User Real-Time Node.js Application


What's the ideal architecture for a chat app with a million+ concurrent users? I don't know the ideal way to do it, but I know a way that works because I built it. This talk will tell you how. Some relevant keywords: Node.js,, Redis, HAProxy, Tsung.

Title #8

the database of the future: leveldb


What if the database was not a black box? What if the performant hard-core was implemented in C, but a vibrant community could rapidly iterate on the high level features in a dynamic language? What if you could experiment with all sorts of evented features, a realtime database? What if that database could be easily installed via npm on any VM, _and_ it ran in the browser? What if you could have all this and anything else you can build & publish! You can with leveldb!

Title #9

Confessions of a Phonegap developer, and a need for speed


I've been attempting to build apps using Phonegap for over 2 years now, but I've always had this nagging....lag. The apps I'm producing just don't feel right. Sticky, laggy, just not...native. Why is this, is there anything that can be done about it? This is the story of my continuing adventure in the world of Phonegap apps...

Title #10

Look ma - no backend!


In the past year something one might call "Backend as a Service" has been popping up all over the place. The promise is: You can focus on building what's unique to your apps, the frontend. The "boring stuff", like user authentication, data storage, payments, you name it - that's already there. It empowers frontend developers to build fully distributed, data driven apps without having to set up and maintain a backend. Examples are [](, [](, []( and a couple of others. They all differ in their approach, but they all go in roughly the same direction. For the past 10 months, we also worked on an open source solution called [Hoodie]( However, I don't just want to pitch it, but rather want to explain what the overall idea means to frontend developers, and then later in the talk compare the different approaches that are currently available. I'd also love to give a live demo of Hoodie, which is full stack JavaScript btw. I think this is a game changer. Let me tell you why. And how.

Title #11



A lightweight, component-based front-end framework by Twitter.

Title #12

Abusing Firefox OS and HTML5 games for fun and profit


There's a new player in the mobile world - Firefox OS. You probably don't know him yet, but you already know his tools of the trade - HTML5 and JavaScript. What's so special about him? Well, if you're a front-end developer there's a huge chance you're already building Internets that can be used as an Firefox OS apps with almost no hassle. If you're into HTML5 game development I've got some good news for you.

Title #13

Is it CSS4 already?


I'll take the CSS4 buzzword and show only the true facts about the 4th Level documents of the CSS specification. The CSS3 will stay with us for some time no matter what the docs numbers are. Let's see some cutting-edge CSS features from the future.

Title #14

Automated Cross-browser Testing with Node


Web apps have proven to be a solid foundation for many tasks that were reserved for 'serious' desktop apps not that long ago. Their complexity grows rapidly making codebase hard to grasp. Errors during implementation are inevitable (at least for us - humans ;) ). As application grows, probability of unwanted effects and regression is becoming a real issue that can ruin project in a long term. Furthermore, development cycle that does not give immediate feedback to development team about effects of changes on the application behavior makes them unaware of the real effects of their code modifications. As if this was not enough, web developers need to live in an ecosystem of diversified browsers on which their app might be used. Solutions to such problems are available to the public as an open source projects. Selenium has been created to imitate real user behavior as closely as possible. Creating integration tests as a part of development process is really fun as it's basically writing code in your favorite language. During my talk I will show the optimal development cycle for rich user interface apps, the difference between unit and integration tests, how to start your first cross-browser test with Node, talk about best practices, show both pros and cons, present handful Node tools that will make creating tests even easier, share some tips that will make you tests rock and make a little sneak peak into the future of test automation!

Title #15

Creating Mobile apps with JavaScript


JavaScript is the lingua-franca of the web, if you work on the web, you have to know it. Increasingly though, JavaScript is becoming an important tool in other areas of development as well. node.js brings javaScript to server-side programming, Windows 8 brings JavaScript to the desktop and KonyOne bring JavaScript to mobile devices. In this talk I will do a live coding demo of a simple app that pulls a feed of images from Flickr and displays them on the screen. I will demo the app in Android, iPhone and Windows 8 emulators. Along the way I'll discuss some of the gotchas that developers need to look out for.

Title #16

Is HTML5 ready for gaming?


I'd like to review the HTML5 as a whole and check whether or not it is ready to be the platform for making games. That's a rethorical question of course - despite some of the weak spots and inconsistencies it's a great time to develop HTML5 games, especially for mobile. I'm going to destroy some myths about HTML5 too - like poor performance or monetisation.

Title #17

What is "this" all about?


The resolution of "this" in JavaScript is often a confusing subject for developers. I aim to take the magic out of "this" by describing the different scenarios functions can be called and how it affects the value of "this." I plan to cover the value of "this" when invoking functions: directly, as a method, with call/apply, and as a constructor. I'll also breifly cover ECMAScript 6 "fat arrow" functions and how that affects the binding of "this." I'll also discuss closures, how/why they're used, and how to properly capture the value of "this" in case it is lost inside a callback function. We'll also dive into how the JavaScript interpreter creates function objects and how the Execution Context/Activation Object defines scope and "this" at runtime (b/c JavaScript is dynamic)

Title #18

So, You Want to be a Front-End Engineer


Browsers: The Final Frontier. The most volatile programming platform the world has ever known. You're a seasoned engineer who has mastered the art of server-side dev. You've conquered .NET, Java, and many more. You know a little bit about the strange new world of client-side development and you'd like to take your understanding to the next level. Good! Our mission: to explore the implementation details of the Browser, HTML, CSS, and JavaScript; to examine the tools and techniques that will help you boldly go where few have gone before, from Hacker to Front-End Engineer.

Title #19

Web Components and EnyoJS


The web needs a better object-oriented programming model for application development in order to achieve consistently high-quality user interfaces that compete with native applications. The talk argues why it takes more than HTML templates and UI plugins to deliver a native quality user experience, and then walks through several examples of how encapsulating different parts of an application into reusable components simplifies development. It also shows how Enyo, an source object-oriented JavaScript framework, implements those ideas by emphasizing encapsulation and modularity. Enyo contains everything you need to create fast, scalable and cross-platform mobile or web applications. Enyo powers webOS, and was designed from the beginning to work great on mobile devices.

Title #20

Autobiography of an API


The Internet these days is all about APIs. Nokia has several APIs, Facebook has APIs, Foursquare, Twitter, Flickr, they all have public APIs. For companies that provide services on the Internet, APIs are a must have. With the data available through APIs, developers build the cool and inspiring stuff that shows up in your Twitter stream every day. An API is however completely useless when it is not well documented, or when the documentation is not updated with the API itself. Developers need to know in a clear way how to make an API call, and they need to have an exact idea of the response they should expect. Unfortunately, delivering a product often takes priority over producing good documentation while creating and maintaining documentation that evolves with the API takes time and requires quite some effort and resources. Until now. This talk is about how my team at HERE went from an obscure bunch of JSON responses to a clean and completely self-documenting API in a matter of hours, by leveraging the power of JavaScript and some of the tools and NodeJS modules that are publicly available with open source licenses.

Title #21

Don't Hide The Address Bar


This talk is about building mobile web apps. It is not about using any particular framework, or following any particular philosophy, but just some important lessons that I often ended up learning the hard way and would now like to share. This main topics of this talk will be:
  • Libraries - The building blocks, not the building
  • Scrolling - Does it bounce?
  • Animations - A requirement or an enhancement?
  • Semantics - A link is a link is a link.
  • User Experience - Don't hide the address bar!
The above will be discussed with plenty of visual examples and live coding.

Title #22

REST Easy With Deployd (Rapid API Creation)


Deployd is an open source platform, built on NodeJS and MongoDB, that allows you to create custom JSON API's in minutes, not days. In this brief talk, (PROPOSER) will explain what the Deployd platform is and show you how it really is the simplest way to design, build and manage a REST API. We'll create our collections and API interfaces in real time, extending them with custom JavaScript events and explain how you can further customise your Deployd installation using standard NodeJS modules.

Title #23

Building Native Apps in JavaScript with Appcelerator Titanium


(PROPOSER) will present an introductory session on Appcelerator Titanium - what it is, how to use it, and how you can build mobile-native, enterprise grade mobile applications for both iOS and Android using only JavaScript. It will be a general overview of the platform, the standards being introduced, and a general rundown of how Titanium works and how it really is the easiest way to build a native, cross platform application.

Title #24

Help the Aged. Optimising performance for older computers


It's a horrible problem to have, but not everyone can afford to ignore users with older computers and browsers. In other words, the dreaded IE6 on Windows XP. With over 100,000 IE6 users each year and an extensive Javascript code base, (PROPOSER), head web developer at (EMPLOYER), has oodles of experience optimising front-end performance for older browsers. He'll share (EMPLOYER)'s approach to improving the performance of front-end code as well as practical techniques you can use to improve your javascript's performance on older computers.

Title #25

Automated deployments with robots


Continuous deployment is the high art of devops. So there are several ways to achieve this: many use a one-click deployment tool like 'Deployinator', or something self-written. This talk should give some insights about how we at my old employer (EMPLOYER) deploy our apps controlled by an awesome chat robot named hubot (by github). It will also show you how to simply do it the way we did it!

Title #26

Tips & Tricks when Developing Sencha Touch Apps


The learning curve for Sencha Touch is fairly significant and it's easy to develop bad practices, misunderstand documentation and structure apps poorly. This session will explore some key tips and tricks for architecting and developing scalable, maintainable and well performing Sencha Touch applications. The core topics we'll cover will be:
  • Extending the framework
  • Using MVC in your applications architecture
  • Trimming the framework fat with Ext.Loader
  • Sencha CMD for generating code and building/deploying your app
  • Choosing the right component for the job
  • Methods to improve performance
This session will be perfect for those new to the framework and will even provide excellent validation to the seasoned Sencha Touch developer.

Title #27

shafty: a functional reactive programming toolkit


There is no doubt that today's web applications continue to grow in adoption, replacing their desktop counterparts in all areas of computation. Essential to their growth is their ability to provide near-native performance and rich user experiences. As these applications grow in essential complexity, they also grow in accidental complexity due to the imperative callback processing style found in most web applications. The asynchronous nature of most of these applications also further compounds the issues due to guarantees around message ordering, and a level of indirection required in callbacks handling events. Functional reactive programming is one approach for mitigating accidental complexity, using a declarative and composable data-flow model. During this talk, we will look at shafty, an open source ClojureScript project which explores using the functional reactive programming model for building dynamic user interfaces. This talk will provide a basic overview of functional reactive programming, the motivations behind shafty, basic usage of the library and a few example web applications built using the library.

Title #28

The browser, the programmer and the Dalek


UI testing has been around for years, but never been part of a hype, never made it into the daily workflow of most frontend devs, never has been seen as one of these things that makes our lives easier. Why is this essential tool in our chain treated like a misbehaving stepson? In this talk we will answer that question, looking back to when it all started to go wrong, examine the current state and looking into the future and how we can bring the power of UI and e2e testing back to the people who build the frontend of the web.

Title #29

Beyond jslint - Feedback is the food of Champions!


Deploy early and often ---------------------- Specifically in modern web application development **continous integration** is a generally accepted concept. However, the development cycle of a web application should not stop after a successful jslint run. Continuously **capturing feedback** from the QA team and from real users is what drives a product to **better UX and UI concepts**. Providing the QA team and the users effective tools to express their wishes and to report bugs therefore improves the overall product quality significantly. Usersnap -------- In our talk, we will present Usersnap, which is an **in-browser feedback tool**. Usersnap comes with a highlighting tool, a sticky note tool and pen tool which allows to report issues and suggest improvements directly in the users' browser. The annotated screen is subsequently delivered as rendered screenshot to the dev-teams' bug tracking system and includes also important meta information such as the used browser or the screen resolution. Needless to say that Usersnap is not dependent on any third party addon such as Adobe Flash.

Title #30

jQuery Plugin Unit Testing - Get around the event loop


For many front end developers, including me, a jQuery plugin was their first repository on github. Reading that code again, I found many bugs and I am very grateful that no one ever used it in production. At the time, I was completely confident about my code working as I intended it to, but I never stopped to think twice about why I felt that way. Since then, the most significant tool that I have picked up is unit testing and the biggest hindrance in learning how to unit test has consistently been the event loop. For example, how do I ensure that particular code paths are followed when an element is clicked, double clicked, or if the window has scrolled into a particular state. Most unit testing examples focus on very straightforward imperative tests. I have seen many explanations of javascript unit testing that describe how to verify the logic behind a calculator or a form validation library, but not how to test a more complex, event triggered interaction. In this talk, I will address how to begin unit testing jQuery plugins, and how to avoid common pitfalls when dealing with asynchronous, or event handling code. Most importantly, I will explain how to deal with verifying that code is executed when native browser events fire. I'll walk through two examples of jquery plugins that we will write and unit test during the talk. I will describe techniques that can be used to gain confidence that your plugin acts as designed and explicitly addresses edge cases. First, we will start off with writing the plugin code and unit testing a simple konami code easter egg plugin that will verify that a desired function will execute once the konami code is typed into a page. Second, we will write the code for a more complicated sticky scroll plugin that will describe how to programatically assert that changes in the state of the page trigger the appropriate responses from our plugin code. After that, I will wrap up with an explanation of how to mock ajax requests and trigger ajax events from your unit tests.

Title #31

ES6 on the frontend, in the real world


The list of solidified ES6 features keeps growing and we, on the client side, just get greener with envy. Many of these new features won't be supported in a broad base of browsers for years to come, but there is hope for us nonetheless. While we don't have the ease of flipping a command line flag, like node, to bask in the warm sunlight of ES6 sugar, I've pieced together a system that gives us the best that we can hope for. Using a combination of shims and transpilers, we can enjoy these new language features while still maintaining support for all of the browsers you'd need. I'll first explain some of the great new additions to the javascript programming language and example use cases with code that take advantage of ES6's elegance for client side development. I will go through the details of setting up a development environment with source maps for debugging the code that you wrote, rather than what is generated by a transpiler. Then I will discuss setting up a production build system to generate code for non-ES6 browsers. After listening to this talk, I hope your jealousy will be soothed, and I know that your curiosity will be satisfied.

Title #32

Javascript - The Real Bad Parts


Douglas Crockford's book "Javascript: The Good Parts," is one of the best selling javascript books of all time and is only 176 pages long. For most developers, there's an tacit belief that the rest of Javascript falls under "bad," especially when comparing that to the 900 pages of "Javascript: The Definitive Guide" There are websites dedicated to these list of language mis-features and anti-patterns, and dozens of blog posts about how to avoid the "bad" in your own code. I don't think that these most of these things are actually "bad". In their day to day, developers don't need to worry about all of these smaller issues. Chances are, a javascript developer has encountered these difficult issues, learned the solution, and then immediately absorbed the concepts. I'm going to explain to you, the real "bad" parts of the language. These are at least three javascript language features that are the most likely to trip up a javascript developer. Once you innately understand these three issues, you will become significantly more productive in javascript, and will be a lot less confused when reading through large javascript code bases. I'll be walking you through at least three concepts within javascript language semantics:
  1. What on earth does "this" mean, and in what context does its meaning change?
  2. How does prototypal inheritance work?
  3. What is hosting? Why do I care what a function expression or function declaration is?

Title #33

HTML5 WebSockets


This session will introduce WebSockets by exploring a few practical applications. Afterward, we will dig into the JavaScript API before concluding with a look at the WebSocket communication protocol.

Title #34

Front-to-back: Architecting your data reporting and visualization stack


With web applications tracking billions of data-points each day it is no wonder that data visualization is one of the most talked about subjects in the industry. A good solution can deliver valuable insights, but a bad one can waste everyone's time, from engineering to the end users. In this talk we will explore how we tackled this problem at Fastly. From collection, storage and broadcast on the back end to subscription, querying, and display on the front.

Title #35

Realtime replication in the realworld with node.js


A deep dive into javascript solutions for replication and p2p style networks.

Title #36

The Web of Tomorrow


The web is changing and new changes are coming. How will the new RFCs will affect the web as we know it? What technologies will raise again? Are we prepared for this changes? I want to answer these questions and talk about new web technologies and how we need to change to adapt to this upcoming era. From web sockets to WebRTC. From distributed to decentralised. The storm is coming... are you ready?

Title #37

Writing (testable-maintainable-scalable-rock solid) JavaScript


Everyone knows they *should be testing their code*, but there's a huge gap between knowing and doing. This talk is aimed at beginner and intermediate JavaScript developers looking to bridge that gap, so they're able to test their code effectively and ship with confidence! Using real life code examples, the following questions will be answered in this talk:
  • What test suite should I use
  • How do I get started testing
  • What should I test
  • How do I test my jQuery
  • What should I not test
  • Why you should do TDD
  • Some tips and tricks to turbocharge your JavaScript development

Title #38

Everything Is Terrible: Why You Should Be Angry


Node.js seems pretty sweet, sure. It has asynchronous IO, sane stream APIs, and one of the best package managers in open source. Plus, it's javascript. But when it comes to node.js web frameworks, not all is well in the world. Why is the most commonly-used web framework pretty much the same as Sinatra? Why is the most common way of separating http app functionality based on a hack from WSGI? Why does installing an app pull down half of NPM? Why do we have to not only write routes at *all*, but write them *multiple times*, for server-side views, client-side views, json APIs and command-line interfaces, using a different router for each with arbitrarily different interfaces? We can do better, and with [the Big framework]( (also [on github](, I will show you how.

Title #39

Embracing IndexedDB


November 2010, the W3C announced the deprecation of WebSQL specification, causing web developers around the world to mourn. To those comfortable with relational databases, WebSQL seems to be a natural fit for offline storage. On the other hand, IndexedDB -- WebSQL's successor -- can appear unruly by only supporting asynchronous API (for now) and missing many commonly used features such as joins, aggregation methods, multiple conditions,... So what is this IndexedDB? What can it do and how can we truly embrace its abilities? This talk walks through usage of IndexedDB in common web application scenarios, explaining how to utilize indices and properly structure data for query performance.

Title #40

The JS Build


Developers test their JavaScript these days, it's expected. Test frameworks and tooling has drastically improved in recent years, so much so we expect the same level of TDD for our JavaScript as we would from languages like Ruby. When you have a team of developers working on the same client side codebase you also expect the same practices, continuous build being one of them. I lean toward using Jenkins. The majority of us use node, phantomjs for this kind of task. This will test out JavaScript code using WebKit, a pretty modern environment for JS. What happens when your code still must operate down to the depths of IE6? It's a horrible situation but one that more people than you think have to deal with. The talk will run through pushing the mundane task of testing cross browser to the Jenkins build using tools such as phantomjs for basic build sanity checks and then using testacualr pulling on services such as BrowserStack for detailed cross platform, cross browser integration.

Title #41

Automating with Grunt.js


Every language has a build tool, Ruby has rake, .NET has PSake, C has Make and now javascript has Grunt.js, an excellent little build tool for all those javascipt jobs that need to be automated. This talk will look at the basics of Grunt.js with setting it up to do things like compress javascript and css, compile coffee script, run test and along with using the power of node to automate other tedious tasks.

Title #42

Clever CSS to speed up your jQuery and make you happy


We all know CSS3 can do some nifty stuff for your layout and UI. But did you know you can use CSS3 to improve your jQuery performance and seriously increase the maintainability of your code? Starting with the basics of letting CSS some of the load off jQuery and building up to some lesser-know CSS3 selectors and tricks which can reduce the burden on your Javascript, this talk will give attendees a bunch of practical tips and tricks they will be able to use as soon as they get back to work.

Title #43

AMD - Latin for making testing hard


If you are a purist for testing you should know the difference between a unit test, an acceptance test or an integration test. In the world of javascript the line sort of blurs. We have a large dependency we can not ignore the DOM. Certain frameworks have made it easier to work with but we still often ignore it. Then we as a community got excited about AMD(and why not, it is great for spiltting code and if you are smart performance), but forgot about the testing. Let me, take you on a tour of common approaches their mistakes and how we can properly unit test javascript loaded through AMD with out the mess of having to load every units dependencies and how this adds a side effect of faster and more maintainable tests.

Title #44

Hyperaudio - Making Audio a First Class Citizen of the Web


Flash is dead, long live the web. It's been a long time coming but finally audio is breaking out of its black box and is becoming a first-class citizen of the web. Part of the team that brought you the popular audio/video library [jPlayer] ( Mark has seen the birth of the audio tag and watched it grow up. In this talk (PROPOSER) focusses on what we can do with audio now that it's all grown up and takes a look at what is just around the corner. He'll talk about his work with large media companies as diverse as Al Jazeera and the BBC and his newly formed experimental non-profit. Among other technologies we'll touch on the new Web Audio API standard, WebRTC, live-streaming and mobile audio.

Title #45

Livecoding in JS


Javascript, with its event-driven nature and integration with the browser, provides an awesome environment for building live-coding environments, allowing programs to be sculpted at runtime with instantaneous feedback. This talk will demonstrate a number of applications of live-coding, across areas such as web applications, games and music composition.

Title #46

Progressive UX


In the past we used to develop on just a most capable browser, and allowed them to degrade. Technology evolves, trends changed. Now almost all devices and gadgets are using the the Web as a service. In the near future we are going to have a vast number of devices using browsers to connect to the Web. These devices will be an unpredictable number of sizes but a controlled number of features. We must create progressive enhancement systems that take advantage of the device capabilities being used in order to create progressive user-experience. We are going to view the technical aspects of creating cross-browser and cross-platform web applications, how to solve real problems, embrace new trends and how to apply the best methodologies and techniques on real projects.

Title #47

Going mobile with web technologies - an interesting journey


The mobile market is on the rise and the technological landscape is changing dramatically fast. It turns out, that facts turn into *myths of the good ol' time* within months or even weeks. With that in mind, what is the right way to go? How to decide on that? You hear a lot about native, web, hybrid and such and much of these discussions is already around for quite a while - so what's the state of all this today? The talk will guide you through the questions you need to answer for your team, your product and your company as well as it gives an overview of the different options you can choose from. This introduction is followed by a case study of our company, (COMPANY), which has recently turned to an hybrid approach with Angular.js, Lungo.js and PhoneGap. There will be a short demonstration of the capabilities and potential roadbumps of this solution and what we've learnt during the transitioning period. It wraps up peeking into the near future of mobile platforms and the web.

Title #48

So you wanna make a jQuery plugin… jHERE deconstructed.


Out there on the Internet web developers can find a big universe of jQuery plugins for any need you can think of. Do you need a tooltip? There's a plugin for that. Do you need to handle cookies? There's a plugin for that. Do you want a map in your website? You are in luck, there's jHERE for that! Why do people create all these plugins? Mostly because they need a reusable component that can be easily be included into their web apps. So they build it, and then they are nice enough to make it available to everybody. A few months back I created jHERE, with the goal of providing a super simple API for something usually complicated: maps. With jHERE you can create maps, markers, info bubbles, heatmaps and even render KMLs with one line of code. To make life easier for the users, jHERE is however quite a complex jQuery plugin. First of all it depends on a 3rd-party API (HERE Maps) that is lazy-loaded when the plugin is first instantiated. Additionally it was built to work not only with jQuery, but with other jQuery-compatible APIs as well, e.g. Zepto.js and Tire.js. Finally, jHERE is extensible. In order to save bytes, only a small set of simple functionalities is included in the core. More advanced features can be added by writing extensions. This talk is about the journey from the first prototype of jHERE to the final, polished version of the plugin. I will start with the basics of writing a jQuery plugin, I will dive into leveraging Promises/Deferreds when 3rd-party libraries are required for the plugin to work, and I will show how to write the minimum amount of code that is essential to guarantee compatibility with other jQuery-like libraries. Then I will go into extensibility and talk about a way to support plugins for a plugin. And finally, how can you make sure a piece of code maintains the right behavior after you make changes and across releases? You can't, unless you write tests for it, so we'll have a look at unit testing for jQuery plugins. I promise you will see quite some code but also pretty slides.

Title #49

Introducing Magic ERB - generate one partial to rule them all!


Backbone is great for giving us a structure for Javascript front ends. But what happens if you want to gracefully degrade to a plain old request response application if Javascript is unavailable? You end up with two different versions of every view you want to Backboneify. This can become a maintenance nightmare with apps that have more than a couple of views. In this presentation I'll discuss a simple solution I implemented within a Rails app by using a combination of ERB, CoffeeScript and Treetop. The developer creates a series of rails ERB partials and runs a rake task which generates both the Rails ERB partial and a Backbone template using eco. I'll talk a bit about how I used Treetop to parse ERB as well as my first exposure to Backbone. Storytelling, clips of films and lots of silly analogies will keep this talk fun and memorable.

Title #50

Enemy of the state: An introduction to Functional Reactive Programming and Bacon.js


State is hell when working with asynchronous code. Trying to deal with realtime data and user interaction with callback after callback after callback quickly leads to madness. Any callback, called at any time, can modify application state making code complex and hard to reason about. Functional reactive programming is a powerful concept borrowed from Haskell that makes dealing with asynchonous code much easier (and fun!) to work with. Callbacks are replaced with event streams which can be mapped, merged, filtered and more, without having to manually maintain state! Bacon.js ( by Juha Paananen is a lovely little library that implements FRP in JavaScript. I'll introduce both FRP and Bacon - and with visualisations and examples show just how tasty Bacon is for working with asynchronous code.

Title #51

Don't let the server have all the fun. How testing can fill the client side with unicorns and rainbows.


The unit testing web developer population, in general, has been growing by leaps and bounds, but, so far, those gains haven't been as steady on the client side. I'd like to address a few of the reasons why that is, and how we can change that by unit testing our client side application code as thoroughly as possible. Most unit testing examples focus on very straightforward imperative tests. I have seen many explanations of javascript unit testing that describe how to verify the logic behind a calculator or a form validation library, but not how to test a more complex, event triggered application. I'll walk you through a simple unit tested backbone application and explain some design tips for effectively unit testing your code along the way. After that, I will explain how to effectively mock ajax requests and trigger ajax events from your unit tests. I will also be giving an introduction to the grunt build tool. I'll show you how to setup grunt in such a way that your test output can be easily integrated with your continuous integration suite as well as run every time you change a file. Hopefully, eventually, we'll all be able to have the confidence inspired by the green and red lights on a build monitor, on both sides of the great http divide.