SJ 2012 Buy your ticket! Follow @SwissJeese on Twitter
Tickets Schedule Location Freshjobs
Welcome talk10:00-10:15
Philipp Stucki (@_phst)10:15-11:15

JS1k: No Libraries Used

When writing code for our day jobs code size usually isn't what matters really. See what happens when code size restrictions are imposed and the power of commonly used libraries becomes unavailable as a consequence. What's left are the libraries provided by the browser itself. Unravel the secrets and techniques used to create graphics and sound in only a few bytes of JavaScript.
Martin Naumann (@g33konaut)11:15-12:15

Web components 101

Web components are an interesting set of standard proposals, promising to make web development more modular and speed up development.
In this talk, we will take a look at what web components are and how they work - including a live coding demonstration.
Lightning Talks13:45-14:30
Gregor Martynus (@gr2m)14:30-15:30

Offline First, Made Easy

Have you ever tried to send a tweet in the subway? Access your cloud-stored notes while your train enters tunnel? Tried to get a navigation route abroad?
We can't keep building apps with the desktop mindset of permanent, fast connectivity, where a temporary disconnection or slow service is regarded as a problem and communicated as an error. The rise of mobile devices don't provide that same level of quality and consistency, but at the same time drive the expectations of ubiquitous data, across all devices.
The good news is: all the technology is here today, there is no reason not to make your apps work offline. Neither are the problems unique to your application. Generic solutions like Hoodie allow developers to build excellent user experiences that deliver in the face of network interruptions.
Today's apps should work offline per default, not as an exception. This talk explains how.
Gonzalo Casas (@gnz)15:30-16:30

Programming the Internet of Things with Javascript

The Internet of Things has been mostly restricted to low-level programming languages and those mastering the dark wisdom of micro-controller programming voodoo. So far.
But things are about to change, there are a few initiatives set out to lower the barrier of entry into this fascinating world, and put the power of programmable tiny devices into the hands of Javascript developers around the world.
The goal of this talk is to give people a walkthrough on the basics and tempt them into trying out new things.
Coffee break16:30-16:45
Ivan Krechetov (@ikr)16:45-17:45

From Gouda callbacks to Appenzeller CSP:
a quick survey of asynchronous programming models

JavaScript has brought asynchronous programming into the mainstream. Front-end developers have been writing DOM event- and XHTTP response handlers for ages, reaping the benefits of parallel computing, without getting into the horrors of multi-threading with shared memory. Single-threaded event loop with asynchronous callbacks is in the heart of Node.js, showing a mind-blowing performance in IO-heavy applications on the server side. At the same time, JavaScript community has coined the term “callback hell”, which shows that things aren’t quite that nice and happy under the roof of event loop programming model. This talk is about the abstractions and tools for working effectively with async code on JS-based platforms.
Philip Hofstetter (@pilif)17:45-18:45

WHAT just happened?

The modern web is real-time. Stuff happens everywhere; not just on the client, but also on the server. A modern web application must be able to not just react to user interaction on the frontend, but also to events that happen on the server, be it other users collaborating on the same document or be it the result of some background operation becoming available.
Modern browsers support WebSockets, Server-Sent-Events as to means to work with that and if you need to support older browsers (and IE), there's even more solutions to consider.
In his talk, Philip will discuss the various solutions, talk about race conditions and will walk thorough a very small and lightweight node.js application and a small piece of frontend code that will allow you to work with events happening on the server as if they were traditional frontend DOM events.