Usually, when you make changes to code you need to imagine what this
code will do, how your components will look like and how colors fit.
But you’ve got a computer for that!

I will show you how immediate feedback on your changes to JavaScript,
HTML or CSS code helps to be more productive, inspire yourself and
catch new ideas. In my opinion, this is definitely going to be the
next best practice in Web development.

Anders Heijlsberg (father of C#) and Luke Hoban (Microsoft rep to TC39) introduce TypeScript, a new language and toolset that makes it easier to write cross-platform, application-scale JavaScript. TypeScript is a typed superset of JavaScript that compiles to plain JavaScript. TypeScript adds optional static types, classes, and modules to JavaScript to enable great tooling and better structuring of large JavaScript applications. The TypeScript compiler is Open Source (Apache 2.0) and written in TypeScript. The compiler outputs standard JavaScript that runs in any browser or any host. The TypeScript language specification is available under the Open Web Foundation’s, Final Specification Agreement (OWFa 1.0).

A quick stroll through the horror land of mobile WebKit browser bugs. Dangerous forms and weeping angels lurk in the shadows, preying on the innocent mobile developers. Narrow escape passages and various walkarounds provided. Don’t blink, or you’ll end up using IE7 Mobile forever.

JavaScript has a vivid ecosystem of a passionate developer community,
libraries, and tools. New frameworks keep pushing the boundaries what
you can do with it, and the language family is rapidly expanding with
new cousins; TypeScript being the latest. We’re building language
tooling to provide an integrated experience with static error checks,
code completion, API documentation, and so on. But how can we keep up
with this changing environment? Let’s talk about effectively building
language tools.

With the upcoming release of IE10 you may be curious how much performance you can expect from JavaScript in IE. In this talk I’ll delve deep into the internals of Chakra (including changes added in IE10), its profiling interpreter, type system, optimizing compiler, and garbage collector. If you enjoy staring at assembly code, there will be plenty of that as well.

Discover how to create shorter simpler programs by modeling them as a circuit of intercommunicating processes.

Modern web applications and libraries have to maintain state, coordinate asynchronous events, and recover from failure. Over the course of development, the complexity of a program’s control flow graph can vary greatly from one program to another; in a disorganized program, complexity can quickly grow making the program brittle and difficult to maintain. Inspired by category theory, point-free, and functional reactive programming, this talk will present some ideas on how to describe a program as a circuit, and why it could help to minimize complexity over the program’s development.

Remember the time when Software Development Tools were very expensive
and only available to trained professionals? Can you imagine per-app
or per-user licensed Frameworks in today’s Web World? Join a journey
on how the Web and Open Source changed the Software Development Tools
Landscape; made them free and accessible.

This JavaScript library hopes to make 3D graphics authoring easy.
We have been working on it for more than two years now. Maybe it’s
time to stop for a day and show you where we’re at and what is
still keeping us busy.

As Brendan Eich put it: “WebRTC is a new front in the long war for an open and unencumbered web.” We believe WebRTC can democratise and decentralise tools for content creation and communication – for telephony, gaming, video production, music making, news gathering and many other applications.

In this session show you how to use WebRTC to build real-time communication into your web apps:

Not long ago, a small team set out to fix this by introducing
modularity and unit testing. Along the way, we developed an approach
that abandoned conventional MVC in favor of a functional style. The
rewrite was a success: we were able to improve every important metric
for chat, and we have continued to add features without causing
regressions. Come learn about how we did it.

You might think a robot that can play Angry Birds on a tablet is the most ridiculous idea you’ve ever heard of – and you’d be right. However, you can use that little ‘bot for automated testing of your app on any mobile device. You already write tests, right? So you need a robot! (You always wanted one, anyway; now you have an excuse to make one!) I’ll show you how to make it, and how to program it JS.

I work in my hidden laboratory on incredible machines that will help us improve our living standard. I aim to be the first scientist in the world who builds a JavaScript-powered Rube Goldberg machine for making breakfast eggs. My earlier inventions are “The unbelievable cat play-o-matic” and “The retrotirized Video-Tweet-Phone-Reader”.

In this talk, I will reveal my newest inventions and share their secret blueprints with the audience.

We’ll present a new method to load JavaScript written with CommonJS, AMD or any other module system in the browser that is fundamentally different from and often more efficient than the current state of the art.

What happens when you use CSS regions with Web Components? How about using CSS Variables? Let’s explore how Variables, Shaders, Compositing, Regions & Exclusions can work in tandem with Web Components to deliver superior experience for the user.

The story behind Google Docs Offline and some of the fantastic hacks put in place to make it work. We changed people’s mindsets to “think offline” while re-architecting the apps to not rely on the network. Moving an internet company offline involves some hard work and has some serious challenges (performance, cross-browser compatibility, platform bugs, etc).

Last year I took a fellowship inside the US government and spent most of the time trying to find ways to write JavaScript that fixed all of things we hate about government. Here’s the conclusion: You should start a company and sell your software to your government.

Ever wondered what’s really happening under the hood when you apply translateZ(0)? Feeling shaky about how/when pesky CSS style recalcs are slowing things down? Do intermittent page flashes, having to use setTimeout(0) to trigger CSS transitions/animations, or unreliable DOM timers ever get you down? If so, we’ll explain how all this black magic works and more through the lens of WebKit’s rendering engine. Warning: there might be a lot of blood, guts, and C++ code.

Expanding on the topic of my NodeConf 2012 presentation; I discuss the processes involved in prototyping black box devices with Javascript, Node.js, Beagleboards & Arduinos. We cover the basics of getting started with prototyping & development, and illustrate real-world applications. There will even be an interactive demo to keep things interesting. :)

In the book Bossypants, Tina Fey gives three rules of improv: 1. Always say yes, 2. Say yes, and, 3. Make statements. These rules are a damn good approach to dealing with the unexpected in comedy or anything else. Error handling in JavaScript, for example. The way JS deals with exceptions is already a little unpredictable - instead of fighting that, let’s take advantage of it to create better user experiences, more powerful services, and room for hacks and happy accidents.

Black magic, voodoo and David Blaine have nothing on iframes. iframes, for better or worse are used all over the web for all manor of dark arts. They’re capable of protecting your site from other people’s content, and equally capable of creating public APIs out of thin air.

Through developing JS Bin over the last 4 years, Remy has come to be very intimate with the iframe and it’s tricksey ways. This talk will share stories, tricks and upcoming new features of iframes.

You probably heard that JavaScript VMs are becoming faster with every day. But did you know that they have to consume additional memory to make your complex app faster? We are going to get our hands dirty and break down the overhead modern JavaScript VM optimizations are bringing with them. We’ll make sure that you can write your app to run blazingly fast without gobbling up all of your users’ RAM.

Low Level JavaScript (LLJS) is an experimental language that lets you write memory-efficient and GC pause-free code less painfully. The research goal here is to explore low-level statically typed features in a high-level dynamically typed language. It can achieve predictable performance. It can make writing code that interfaces with WebGL almost pleasant. It’s not pretty, but it gets the job done.

A: "Dammit, we can't do this on the web :("
B: "You know, it's called the open web - you can change it!"
A: "I can't just fork the web from GitHub and make it do the things I want."
B: "Haha, no, it's not that simple. But you can talk to some people and if they think your API makes sense, get a browser project from GitHub and they will help you to implement your new API."
A: "But then it's just in one browser, not the web?"
B: "You got to start somewhere."
A: "Right... Can you help me get going?"
B: "Sure!"

Implementing competitive printing support for PDF.JS is not possible with the current state of the web. Therefore, I started to work on some new mozPrintCallback API.

In this talk, I will share my experience with proposing a new API, how to implement it in a browser and how even hacking C++ code can be fun.

Data is everywhere! We build applications that collect it, and even better - other people collect it and give us access. But! Do we bring that data back to our apps? In this session, we’ll talk about patterns for integrating data into our client-side applications and sweep through a collection of exciting libraries that work with those patterns.

Imagine the future with flying cars, brain chips, JavaScript VMs everywhere. Would not it be great if you could hack on one (or even just read its source) without slogging through a swamp of C++ and handcrafted assembly? Welcome to the dreamscape of a compiler engineer, where you can dig into a JavaScript VM knowing only JavaScript.

A child starts learning to read and write at age 5. Why can’t they start learning to program then, too? I am making Isla, a first programming language for young children. The accompanying environment is called Storytime and lets a child use Isla to write text adventures.

I’ll describe the Isla compiler and how I implemented the lexer, parser and interpreter. I’ll describe the design of the Isla grammar. Why is there no punctuation? Why are expressions like sentences? How did I enable array and object assignments, function calls, conditionals and logical rules in baby talk?

Is it possible to make our programs more robust, easier to reason about and more enjoyable to write by carefully restricting our usage of the JavaScript language? You’ll hear the story of when assumption met a magic hat. We’ll get to know our heroes Assert and restrict mode, and if time permits we’ll pay a short visit to JSShaper - the world they live in. Let the journey begin.

Now that JavaScriptCore is as fast as V8 on its own benchmark, it’s well past time to take a look inside JSC’s optimizing compiler, the DFG JIT.

In this talk we’ll take a look at how the DFG works, what kind of code it does well on, and where it’s going. This is a talk for folks that like bits and compilers, but also for people interested in another engine for high-performance JavaScript.

I cofounded OkCupid.com back in 2003. It was my fateful decision to base our whole stack on a single-threaded event-based library written in C++. It sucked; our code was stuffed with callback spaghetti and pyramids of death. But all of that changed when in 2006, we wrote the “Tame” system for C++, which we presented at USENIX ATC in 2007. This new system was compatible with the old code, but drastically improved our productivity by allowing straight-line code on either side of an a network call, much like threads supported all along.

Most JavaScript and CoffeeScript systems work like OkCupid’s did in 2005. But two JavaScript systems I’ve written — TameJS and IcedCoffeeScript — change all of that. They bring the same language primitives to node.js and the browser that Tame brought to OkCupid’s C++ libraries. These primitives are more powerful than threads and more manageable than hand-rolled callback code. If you give them a chance, they will make your JavaScript projects cleaner, more manageable, more parallel and therefore better performing.

I’ve seen the future, and it’s not in that layered .psd your designer just handed you. As designers and developers, we build things. And we do it often. But we don’t build websites or apps. We build systems. Systems that evolve and grow with a company, its users, and both of their needs. The way we design and build these systems should reflect the living, breathing things we want to create and leave more room for them to grow. The question is how do we accomplish this with static assets?

The answer is we set them all on fire. And start in the future. We start in the browser.

We would like to present dart2js, our Dart-to-JavaScript compiler. We have implemented many optimization techniques and in this talk we would like to present some of them.
In particular we want to discuss tree-shaking, speculative optimizations, and local SSA-based optimizations. While our compiler is specialized for Dart, most of the optimization techniques could be adapted for other languages and are therefore interesting to anyone targeting JavaScript as a compilation target.

The Firefox desktop UI is powered by JS and Mozilla’s XUL platform, and in our first attempt to port Firefox over to Android, we used essentially the same architecture. However, drawing our own XUL-based UI killed startup time, responsiveness and memory use on Android, so about 10 months ago we decided start over with an entirely native Android UI.

We still use Gecko to render the same web experience you get on desktop, and a lot of the front-end browser logic is still written in JS, but we use a custom JSON message loop to communicate with a native Android UI written in Java and XML. Add-ons are an important part of the Mozilla story, so we also added JS APIs to allow add-on authors to manipulate this new native UI.

I’ll talk about the architecture of our app, challenges we faced, and how you can get involved with the project (including writing add-ons entirely in JS!).

Math: It’s certainly not something you expect to see at a conference about JavaScript, but even this far from its ivory towers it has an important role to play. Together we’ll build two categories and see how satisfying the Functor laws suggests a whole new architecture for jQuery that will help developers speed up their client side DOM manipulation.

Don’t worry, you don’t need to know any Math to understand and enjoy the talk, just some curiosity and a desire to make your JavaScript faster!

With the exception of some of the big players (google plus, facebook), the proper internationalization of a JavaScript application is almost unheard of. The tool chain to make this happen isn’t well-known and doesn’t even necessarily exist in some cases. There’s a lot to consider when internationalizing an app. Number and Date Formatting, Left-to-right display, pluralization and gender aware sentences are among them. The ES6 globalization effort may tackle some of the bigger problems (like collation), but we’re still on the hook to get these things right as we move towards catching up with the rest of the application stacks.

Functional programming is the current hype in software - however, maybe there is something to this whole malarkey. If you don’t know it, you should.
This talk discusses what functional programming is, and more importantly why you want to be using it in your day-to-day javascript programming.

Javascript is ubiquitous, but can it solve real though problems? The traveling saleman problem is a notoriously hard problem to do efficiently (I.e nobody knows how). In this talk we combine art and craft and put JavaScript to the test. We will let JavaScript solve a TSP problem which results in a rendition of the Mona Lisa.

Lines of code are spent. Writing maintainable software and combating technical debt requires constant vigilance and an uncompromising aesthetic affinity for small components that do one thing well. This talk will look at the shape of code ripe for modularization and exactly what steps are required to turn convoluted tangle of code into dozens of reusable sub–components suitable for publishing to npm.

Good programmers follow best practices; great programmers investigate them.

Many JavaScript sources proclaim (with miraculous certainty) that some tricky language features are anti-patterns that must be avoided at all costs, while offering little or nothing in the way of substantive evidence beyond alarmist warnings or references to their favorite gurus. We shouldn’t ask people to follow rules that we can’t explain or propose actions that we can’t defend.

This talk will demonstrate that, whether its double-equals coercion, iteration without hasOwnProperty, augmenting native prototypes or even fraternizing with the evil ‘eval’ and ‘with’, there is a time and place for virtually every feature of JavaScript and taking the time to study and understand their potential will enrich the programming experience, just as a broader vocabulary enriches the speaking experience. The talk will feature copius real life examples drawn from respected libaries and tools.

Have you ever wondered why developers tend to use jQuery and other JavaScript libraries while their goals can be easily achieved in plain CSS? Both CSS3 and future CSS specifications give us endless possibilities for styling, animations and selecting objects without unnecessary DOM manipulations. A how-to for JS avoidance.

On 4th June 1976, the Sex Pistols played Manchester’s Lesser Free Trade Hall. It was an event that changed the world forever. There were only about 40 people there, but those who attended were inspired to form their own bands, creating Joy Division, The Buzzcocks, The Fall and The Smiths. As these bands fade away, we’re long overdue for another such event. Programmers are artists, and JavaScript is the new Punk Rock.

My talk will show that JavaScript can be used to write and perform music using the wonderful Web Audio API. I’ll talk about why we should do this and why it’s the future of music. By the time the conference is over you’ll have burned your guitar, remixed a dozen tunes on GitHub, and started a JavaScript band that has its sights set on changing the world.

Many of us have heard about web components and shadow DOM elements as up-and-coming technologies for front-end development. They certainly sound cool, but what can they actually be used for, right now? At the time of writing this proposal, there aren’t a lot of good tutorials to get started using them available on the web. We’ll take a look at the proposed W3C spec and the current state of implementation (including libraries and polyfills for cross-browser niceness), but we’ll also go a step further and dive into the DOM with live coding to show what can be done with JavaScript to play with these components and how they can be used for rapid wireframe and prototype development.