Sessions at JSConf EU 2010 on Sunday 26th September

Software development is hampered by a specific set of design mistakes that were made in the first programming languages and repeated in everything that has been done since. And, somewhat miraculously, JavaScript is going to make it right, radically transforming the way we write applications. Again. In the Loop of History, it has all happened before, but it has never happened like this.

Plugin-independent client side data storage, like HTML5 powered localStorage or IndexedDB, is becoming more relevant every day, though it had been there for ages. In fact, IE 5.5 was the first browser to offer data persistence in other forms than cookies. However, today, as we are online most of our time, handling offline situations has become important for many web apps. And for mobile dev, storage is crucial: You wouldn't want to pull some hundred k of data via a slow connection again and again.

"This talk will take a tour around existing client side storage mechanisms. We'll start with cookies and see why it's a bad place to stay. Then we'll quickly move on to the good neighbours, visiting ancient places as well as futuristic ones and investigating their ins and outs. And we'll also stop by the frameworks/wrappers that give easy access to them. To make things more interesting, we'll then board a submarine and dive into the crazy world of mobile devices, it's special demands and see what options exist over there. Finally, we'll have a look at performance and security concerns. Don't forget your towel!"

HTML5 and friends have been getting implemented in browsers at an impressively quick pace. But that leaves us as web developers wondering, "Great, but how am I supposed to build cross-browser applications with these features when I still have to support IE".

We'll take a look at what the landscape of implementable features are, detailing best practices of implementation and fallback solutions where appropriate. For example, how do you pair WebSockets with a standard comet stack and what do you have to watch out for.

We'll also review your available feature set if you're only targeting webkit mobile, or if you've already given IE6 the boot.

The data will be up-to-the-day accurate, covering all major browsers and filled with best practices from topic experts.

JavaScript was made for the web of yesterday, but the web has changed significantly in the past decade and therefore the requirements of a JavaScript for tomorrow. I'm a JavaScript hacker and its in the nature of hackers that having a better language tomorrow isn't fast enough for us.

Let me show you how to deal with the flexibility of today's JavaScript implementations to make things, which you may haven't seen before running in a Browser but will definitely become needed parts for the future of web development. This will be about shifting bits and bytes, misusing native file formats, overloading operators, uncommon using of getters/setters and some more evil JavaScript hackery.

After last year's standing ovations performance, he is back. His last talk's video was viewed 12 thousand times. We're excited what will happen this year.

Node.js presents the same non-blocking, single execution stack programming model of client-side Javascript. However, Node is arguably aiming at more complex problems than browsers have faced: massively concurrent servers that may shell out to many different processes, that might need to execute many sequential file system operations. Can this programming model support such systems or does the code degenerate into a spaghetti of callbacks? This talk will present an emerging set of patterns being used in this new domain.

(fab) is an HTTP framework for that eschews the conventionally muddled web stack of middleware, routers, and handlers for a cleaner, more functional approach. By stressing convention over code, (fab) enables any web app to be recursively composed of other web apps, using a chained pattern that enables the full power of javascript but the simple readability of a site map. In this presentation, Jed will show you how to use (fab) to get up and running with your own reusable apps on both the client and server.

Mobile applications are a huge trend at the moment. But there is one major drawback: You need to develop them from scratch for every-single-platform. That hurts. Web technology seems like a natural choice to develop cross platform and fundamentally increases efficiency during development. This talk is about the richness of Unify applications, the focus of the project and our future plans.

Sever Side JavaScript (especially Node.js) is a hot topic right now, but we are still figuring out what good SSJS code looks like. It isn't enough that we can write JavaScript on the server, or even that it is well written JavaScript. It's essential that we write maintainable JavaScript for the server environment. This talk will examine different coding styles for event driven, non-blocking SSJS and which styles are most successful.

We'll take a look at strategies that other languages and frameworks with similar attributes such as Clojure, Erlang, Python/Twisted and Ruby/Event Machine use. From these languages we'll take a look what has worked well and what hasn't. We'll explore how these models can apply to JavaScript to create patterns that can be used to make code more maintainable.

Since JavaScript is already an event driven language there is already a lot of support for events, and developers are used to developing code with the event driven browser. However, how we use these features on the server with it's additional freedom can either help or harm the long term use of our code. One of the obvious code defects created by poor use of the evented model in JavaScript is Pyramids. Pyramids are huge chains of nested, dependant anonymous callbacks piled one on top of another until you end up with a pyramid of code, left to right. Pyramids are one of the first, obvious, mistakes people tend to make when beginning SSJS. We'll also discuss some of the less obvious ones and explore ways of avoiding them.

The realtime web is right around the corner, and JavaScript is here to help, both on the server and the client side. The WebSocket protocol promises to solve the problem of bidirectional communication once and for all, but can we leverage it today?

Socket.IO provides an API that enables WebSocket for every browser (IE5.5, IE6, IE7, IE8, Safari, Chrome, Firefox 3-4, Opera 10) and multiple mobile devices (including the iPhone and the iPad).

I'll talk about how you can get started using Socket.IO today, how people are using it in production environments, and how to create realtime web applications with just a few lines of code.

We're really proud to have a large number of Bespin devs at JSConf.eu. Three of them will give us a heads up on their work:

The Mozilla Labs Bespin project has created a customizable code editor that's built on the HTML5 capabilities present in the rapidly expanding list of "modern browsers". The project has evolved to support the notion of "coding in any cloud", as it's easy to build an editor to include in your own web applications. You can use Bespin in bookmarklet form to improve the editing experience at any site you visit. Finally, the JavaScript-based desktop and server packages allow you to edit code on your local machine or in your own, personal or small group cloud.

In this talk, the Mozilla developer tools team will run through what Bespin can do for you, how you can customize it and where the project is headed.

The term "Semantic Web" has been around forever (well, almost, at least in Internet terms). This talk will provide an introduction to the Semantic Web as it evolves these days, with a strong focus on how to make use of semantically enriched data with JavaScript. We will show real world state-of-the-art examples, and also give an outlook on bleeding edge research on the topic, e.g. the JavaScript RDFa DOM API.

Meet the person that made deep linking into things that used have no URIs possible:

"Do you want to take your AJAX powered website to the next level by making it easily accessible through deep links? And how about making all the dynamic data available to the major search engines? Come and learn more about all the existing and evolving techniques, the best practices and details that you should have in mind."

Have you ever wondered if we could use JavaScript to do the following?

$("livingroom").bind("motion", function() {
$(this).find("lights").brightness("75%").dimAfter("120s");
});
Or did you dream about writing applications in HTML, JavaScript and CSS which could tell you how much you weigh or what the outside temperature is? What if we had a web-based interface to setup and program all our devices at home?

Well, your dreams are heard and finally, today we are able to do all this. In this talk we will walk through the implications of opening up the browsers APIs, explore real life use-cases and will demonstrate working examples which will show that JavaScript, HTML and CSS are the perfect tools to build interfaces controlling and reading hardware.

This presentation will highlight various options (like LinuxMCE, Arduino, Lego Mindstorms NXT) for programming hardware, along with a few pratical experiments like scripting a bluetooth-connected Wiimote, a web-enabled socket outlet and interacting with an Arduino board and sensors directly from an iPhone. Code and instructions for each experiment will be available later

CommonJS 2010 is moving beyond modules. Placing a hold on standards for IO, CommonJS discussions this year have focused on Binary data, Promises, Packages, and more. We've also moved away from ratifying particular proposals and more toward providing a forum for thoughful design. Join Kris for a pointed presentation on the state of CommonJS: what's done, what's being debated, and what needs to be done.

Building browser extensions is now easier than ever. Jetpack, Chrome and Safari 5 combine open web technologies with a few special APIs and clever design, opening up extension development to any web hacker.

In this talk we'll build a few simple extensions for Chrome, introducing the main concepts in their extension system. We'll compare and contrast with Jetpack and Safari 5. Expect working code and a energetic presentation!

With all the talk and hype over server side platforms and technologies, somehow we've been neglecting the most ubiquitous and widely used javascript platform - the browser. Differences aside, the web browser and the desktop are becoming more and more entwined and just generally faster. Now is our chance to make web applications that surpass the usefulness and awesomeness of desktop counterparts. Sure, there are technologies that allow you to bring desktop style code to the web. With Sammy.js, I'm more interested in creating web style apps that can compete as desktop experiences. Sammy.js is a very simple framework for organizing browser based javascript applications. Despite its size, when combined with other cutting edge technologies, (CouchDB, other RESTful DB's, Comet) it becomes a very powerful way to write entirely front-end, entirely JavaScript applications. I'll walk through the basics of Sammy, show some cool examples of Sammy in production, and talk about new features and technologies that make this all a pretty exciting time to be writing JS.

I will talk about the different aspects, approaches and tools for testing javascript applications (web and offline, server and client side). There's much more you can do in testing than just writing a bunch of unit tests. To be confident in the code you write you also need to test the interactions between different modules, sometimes even integration with other services. Let me show you how.

If you are talking hardcore-JavaScript there simply is no way around John (If you don't believe us check this out and understand why this is cool and fundamentally changing JavaScript):

'All the major libraries have ended up looking like jQuery. Now they just bicker about who is the fastest. Library authors stopped innovating 2-3 years ago.' - Dean Edwards
FuseJS is a new JS library that is bringing innovation back, solving problems thought unsolvable and challenging the JS status quo. I will give a brief history of FuseJS and discuss some of the areas FuseJS is innovating including sandboxed natives, event delegation, memory leak plugging, element cloning, feature testing/detection registries & profiling, API design, and customization.

In this talk Stoyan will share bits of his forthcoming book "JavaScript Patterns" (published O'Reilly) focusing on performance. How do we evaluate and measure performance and patterns to improve and write high-performance JavaScript.

Despite being around and prevalent for over 10 years, JS has only recently come to enjoy a focused community. We pull from all ends of the technology spectrum, we do amazing things, and most importantly we JSConf. That all said, we need to make a commitment to growing the community in the right way, with the right blend of inclusivity and awesome. It is our charge to ensure that the world sees JS as a viable option and more importantly a vibrant and welcoming community. Despite our preference in library, despite our preference in framework, there has to be one unifying thing that brings us together - and it can't JUST be a common hatred for IE6. I opened the doors to something important with the first JSConf, and with this talk I am starting the discussion for what the JS Community is, means, and how we want it to be viewed. Unlike any other programming language, our community is completely homegrown, organic, and driven by grassroots efforts like JSConf (eu|us). It is up to us, developers, to do something amazing here and it would be our folly to not learn from all other language communities, else we are destined to become like them.