Video

Don’t tell your boss, but I want you to make a useless art project–because it’s actually pretty useful. Why? Committing to uselessness is a freeing experiment. As professionals, we tend to focus on the end result instead of the process, and that’s not healthy. Embrace the creative process (iteration and experimentation) on a project and see where the path takes you.

“Inspiration is for amateurs. The rest of us just show up and get to work” - Chuck Close

Video

Low Level JavaScript insights from the JIT compiler perspective. From Garbage Collection and Tracing algorithms to callsite analysis, native data types (Array, Object, Function, Function templates) and their implementations, unboxing and hash optimizations, fake operator overloads, ASM branches, branch prediction on the CPU and Hidden Classes in V8 to highlevel usage examples inside game engines and how these can be optimized.

Video

Web technologies have become the default way to develop data visualizations: they are easy to use, convenient to debug and work across all kinds of devices. And thanks to ever-faster smartphones even they have become a valid platform for web-based visualizations - but creating something decent for them requires a whole new set of skills.

In this talk, I will present a quick run-through of all the relevant aspects of mobile web-based datavis:

• What graphics technology (Canvas, SVG, WebGL) to choose?
• How to include all the neat HTML5-supported sensors to do cool stuff (GPS, device orientation)?
• What amazing things can be done with multi-touch input?
• What changes for information and chart design?
• How to best debug mobile visualizations?

Video

Angular, Ember, React, Backbone, Spine…Without a doubt, client-side MVC frameworks are on the rise. But, did you know that without extra care, many people won’t be able to use our web applications? This talk will highlight the accessibility challenges with JavaScript MVCs and propose solutions to make our apps more accessible to keyboards and assistive technology, including focus management, ARIA live regions and JavaScript testing.

Video

Whole new worlds come into life when the creative coding and technical madness of the Demoscene meet the breadth of optimization techniques of the web platform.

In this talk we will step back from our day job, twist best practices, abuse JavaScript and web browsers, use good old smoke and mirrors to create a monster Audio-Visual demo in a handful of bytes.

Why go to such length? Because it’s damn rewarding to create these small pieces of art! Try.

Video

Games in the 80s and 90s redefined the relationship between a user and a computer. Realtime, offline-first networking, fluid graphics, and physics-based animations posed incredible development challenges. Overcoming these challenges introduced a whole class of elegant techniques for immersive user experiences - that most JavaScript developers have never heard of!

My talk will show that normal JS apps will soon rely on game programming techniques every day. You’ll be amazed at how many libraries you’re using are already based on basic game-loop architecture. Finally, you’ll leave ready to push your own apps forward with a little bit of gaming magic.

Video

Look at the apps on your homescreen. Why are they native? Why aren’t they just on the web? Its usually some combination of push messaging, background sync, offline & performance.

When native has something the web doesn’t, we should consider it a bug. Let’s have a look at the fixes, focusing on the ServiceWorker.

Video

JavaScript programmers like to use words like, “event-loop”, “non-blocking”, “callback”, “asynchronous”, “single-threaded” and “concurrency”.

We say things like “don’t block the event loop”, “make sure your code runs at 60 frames-per-second”, “well of course, it won’t work, that function is an asynchronous callback!”

If you’re anything like me, you nod and agree, as if it’s all obvious, even though you don’t actually know what the words mean; and yet, finding good explanations of how JavaScript actually works isn’t all that easy, so let’s learn!

With some handy visualisations, and fun hacks, let’s get an intuitive understanding of what happens when JavaScript runs.

Video

You thought cross-browser design was tricky? What if you had to develop for ten or twenty years in the future, when we can no longer assume displays will be rectangular, flat or even completely unobstructed? Our screens are changing, and BBC R&D are anticipating and prototyping user experiences for technology that hasn’t even been invented yet. From wearable tech to electronic wallpaper, this is the ultimate evolution of responsive design. Find out how we’re using JavaScript to push it to its limits.

Video

The apple always falls down attracted by the gravity of the earth. It’s the law of physics. The function is never inlined if it’s source is bigger than 600 characters long. It’s a heuristic - a physical law of our dystopian cyber-world confined inside a JavaScript Virtual Machine.

Ever wanted to rebel against the sad immutability of the physics? Lets try to make functions fall upwards and inline all the apples.

In an ultimate attempt to create a space-time paradox that will rip our universe apart we will look at Java programmers implementing JavaScript on JVM through invokedynamic and then will implement invokedynamic in a JS VM instead.

The true freedom is just one heuristic away.

Video

The web as it appears today consists of apps, rather than hypertext.

Recent additions to HTML5 APIs and the web application landscape raises the stakes for browser security: The attacker may now easily shift their target to active browsing sessions rather than the underlying operating system.

This talk covers the browser security model as it currently stands in modern user agents. After discussing legacy as well as recently added features, it will also present some expected enhancements in the browser security landscape. Following this overview, common bypasses and shortcomings of these security mechanisms will be discussed.

Video

Firefox OS is marketed as an OS for mobile phones. Cool. But what if we do one step back and omit the UI layer. Then a Firefox OS phone is a handset that’s cheaper (25$) than a bare-bone Raspberry Pi, that includes a ton of sensors, GPS, network connectivity, a battery and a screen. And on top of that it’s running the Gecko render engine that has APIs to access all that goodness. It’s time to take some phones apart, start hacking and roll our own OS on top of Gecko. Internet of things FTW!

What about a Firefox OS based doorbell system over bluetooth? A jacket tracker with GPS in case you go out and your jacket gets jacked? A small device that tracks how much you drink during a party? Home surveillance using a network of phones and a bluetooth speaker for an alarm? In this session we’ll see some crazy hacks, and you’ll should be all set to start hacking yourself!

Video

This presentation explains the various ways in which JavaScript relies on Unicode, what the consequences are for JavaScript developers, and how ECMAScript 6 will make our lives a bit easier in this regard.

First off, the basics of Unicode are explained. Once that’s out of the way, I’ll talk a little bit about different character encodings, only to determine the character encoding that JavaScript uses internally.

Then we’ll explore the various consequences of JavaScript exposing “characters” according to UCS-2/UTF-16, and I’ll explain why it can be problematic.

Finally, I’ll present robust ECMAScript 5-compatible workarounds to the issues encountered, and explain how ECMAScript 6 will make it easier to support full Unicode in JavaScript strings and regular expressions.

Video

What is type coercion? When can it be useful? What happens when we choose to use == over ===?

JavaScript is a polarizing language, said to be full of “good parts” and “bad parts”. JavaScript’s type coercion is often bemoaned—one of the common “gotchas” for newcomers to the language. In this talk, we’ll unravel the complexity of type coercion and define a set of simple rules to make our lives easier. No more #@^%’s.

Video

With the web slowly maturing as a platform the demand for cryptography in the browser has risen, especially in a post-Snowden era. Many of us have heard about the upcoming Web Cryptography API but at the time of writing there seem to be no good introductions available. We will take a look at the proposed W3C spec and its current state of implementation, talk about the good parts and the pitfalls to avoid. I will share my vision of a simpler and safer NaCl-inspired API, and hopefully leave you excited about experimenting further with cryptography in the browser.

Video

Everyone knows that Web Components are the future, right? Or maybe you think that a well-written Angular directive has everything you need. Or, perhaps, you think that there’s no such thing as a well-written Angular directive and so you’ll stick with your Ember components thank-you-very-much. Then again, once your brain is thinking in React, why would you use anything else?

This talk is about the reality of component-based web development, told through the frivolous pursuit of a more awesome IMG tag for animated GIFs. It’s a not-so-serious window into a terribly important debate about better encapsulation, reuse, and happiness in our front-end lives.

We’ll talk about:

• The surprisingly complicated logic involved breaking apart and manipulating GIFs
• Our ideal Component and how it beautifully hides this complexity
• The different goals, abstractions and constraints of Polymer, Angular, Ember and React
• The challenges involved in trying to write a component compatible with all of them
• What the future of developing reusable components might look like

GIFs have been a part of the Web since the very beginning, and epitomise the beauty of a simple interface for a powerful, flexible component. What better test for the imminent future of the web than to see how it tackles its past?

Video

The new HTTP 2.0 and QUIC protocols are coming!

HTTP 1.1 forced both developers and browser vendors to invent different tricks in order to make sites to load and run faster. HTTP 2.0 and QUIC will provide many significant improvements overt HTTP 1.1.

In this talk I will give an introduction to both protocols and emphasize why are they so important for the Web development workflow and performance.

Video

The hypothesis of linguistic relativity, also known as the Sapir-Whorf Hypothesis, says that the languages we speak influence the way we think. I argue that this applies to programming languages as well. However, key differences between spoken languages and programming languages enable us to adapt and shift our ways of thinking more fluidly as we learn new programming languages than as we learn new spoken languages. It is these same differences that we can and should leverage to both grow individually as programmers and further advance our favorite programming languages. JavaScript is in a particularly ripe place to take advantage of these differences, as it is such a popular and dynamic (literally) language with a strong culture of libraries, evolution, ease of learning, and community.

Video

2013 and 2014 has seen the rise of JavaScript parsers that generate a consumable AST (such as Esprima or Acorn) and static analysis tools that operate on that AST (eslint, esmangle, or escodegen, or graspjs). These tools all operate on the structure of JS but have to rely on the AST node type or full name to modify the underlying code. With type information, static analysis and refactoring tools could be made more powerful by being able to accurately refer to any JavaScript statement in the codebase.

In this talk I’ll show how to use declared and inferred type information to make JavaScript safer to use at scale (think prevent XSS) and how to use simple JavaScript templates to apply complex automated refactorings in minutes throughout extremely large code bases.

Video

GitHub project: http://github.com/onejs/onejs

What would the world look like when you can style UI with actual shader programs? The web could be 60fps on mobile, and we can start to imagine what lies beyond HTML and CSS

In this talk i will present OneJS, an open source JS superset with shader GLSL and reactive programming syntax. OneJS exposes the power of programmable GPUs to UI designers and programmers in a very accessible way.

Now the fixed functions encoded in CSS, Canvas or SVG are a thing of the past, and we can finally go beyond and explore.

Video

First I was afraid, I was petrified
Kept thinking I could never live without realtime interaction client-side.
But then I spent so many nights thinking how XML did me wrong.
And I grew strong, and JSON helped me get along
And so you’re back with no name-space
I just walked in to find no silos here ‘cause its all de-cen-tral-ized
I shouldn’t used that custom format
XMPP and JSON is the key
If I’d known for just one second interoperability wouldn’t bother me

Video

In two parts, I’ll share the story of how I transformed into a hirable web developer in just under one year while highlighting the ways people helped me to get to that point. I hope you’ll come away with ideas how you can make a difference in your own community. As Tal Ben-Shahar says, there is no more selfish act than a generous one, so this talk is really for your own good.

Video

Everybody loves the Gruntfile, except for those who have seen the True Path and are now creating everything in Gulp, except for those of us that simply don’t understand the fuss because Make has “done all of that for years”.

Make gets an awful rap for being obtuse and difficult to understand and this is often down to some common misunderstandings over what Make actually is. Most first attempts at using it (including my own) end up looking like badly written shell code.

Make provides a wonderfully declarative DSL for building projects; complete with all of the pattern matching features one is still waiting in vane for in some supposedly modern languages. I am here to demystify some of this and you will hopefully leave this room thinking “Wow, I didn’t know Make could do that…”

Video

I am writing in English and you understand me perfectly well. We share a grammar and, thanks to the internet, an ever-growing vocabulary.

I am writing a new JavaScript program and the computer does not understand the words lodash, jquery or angular. I have to npm install and require these words, and while we’ve grown used to package managers and module systems I began to wonder: Can we do better?

What happens when words like lodash and fibonacci had meaning without a single require, git clone or npm install? In turn, what if every program you write instantly has a word for it that everyone can use?

Africa is rising. The population is booming and data visualization is handy in analyzing the opportunities in the continent. Most people access internet via mobile phones so web and mobile solutions that work across different platforms and form-factor devices are more effective. Since the internet is not always reliable we need to think about applications that can work seamlessly with or without internet access.

Video

Inside most of us there’s a befunge programmer who wants to come out. When doing day-to-day “serious” programming it is usually a good idea to keep them as firmly locked up as possible. Let’s ignore that instinct for a little while.

In this talk I’ll try to convince you why you should try writing a completely impractical interpreter of your own. I’ll also use terms like “lexer”, “tokenizer” and “parser” at their widest possible definitions.

Video

The introduction of the Web Audio API has enriched the web landscape enormously. It gives game developers the ability to add precisely timed, high performant sound effects and to create realistic spatialized sound landscapes. For many web developers it is the first time they encounter audio programming which leads to many interesting experiments when the world of web and audio collide. Traditional web developers start to become really interested into audio programming and educate themselves on the topic of synthesizers and audio effects. However, currently there are only few applications that try to create audio production or audio performance environments in the browser. In this talk I want to show how the Web Audio API can be used to create a collaborative music production environment similar to Garageband. Furthermore, I will do a live demonstration of a music performance setup which is inspired by The Glitch Mob’s setup (https://www.youtube.com/watch?v=9bXNo9MFXnU). Both demos will show how powerful the Web Audio API is and how important the web can become as platform for music production in the future.

Video

This talk aims to take you on a journey – from the days of the Easter Islands around 700CE, over the mid-15th century in England to Mars and rain forests of our days and finally to the future of Free, Libre and Open Source Software (OSS). On our way, we’ll take a close look at the culture in Open Source Communities, its status, relevance and why this culture is the key to building the future of OSS. We’ll think about the core values of Open Source, amongst them freedom, democracy and decentralization, take a look at software-development as an act of representation and find out why diversity (regarding gender, skills, ethnicities and ideas / backgrounds) and user-centered approaches will be core determinants when we want to build a future for Open Source.

This talk aims to encourage everyone of us to broaden our horizons when it comes to how far we can go collectively with all our Open Source projects when we’re thinking about their future, - and it wants to show how widening our communities, aiming for diversity and sustainability will enable us to build this future together.

Video

Enter the ever evolving world of peer to peer using Javascript. In this talk we will push the limits of what is possible today using BitTorrent, streaming, and Javascript.

There will be demos and MAD SCIENCE.

Video

Between Snowden’s NSA leaks prompting more secure communication and the rise of cryptocurrencies- software with secure cryptography as a core component is on the rise. Meanwhile, powerful applications written in JavaScript that render their UIs in a web browser are seeing unprecedented growth. However, if you ask most security researchers and developers about secure crypto in the browser, they’ll shake their heads skeptically. Reasons for this being: there are a lack of quality crypto primitives written in JavaScript that’ve been adequately reviewed and tested, JavaScript yields weak random number generation in all but the most recent HTML5 browsers, and secure key storage is difficult as the idiom du jour of web applications is to store user data on a remote server or in localStorage.

This talk will explore how Mailpile, a Free / open source email client, is not vulnerable to these security concerns by shifting the attack surface out of the browser while still being a web application with a friendly JSON API. The gain being developers can leverage modern JavaScript libraries to render beautiful interfaces, animate fresh user interactions, and create compelling data visualziations. Want to make a force-directed graph of your inbox? JavaScript makes it easy, all while being extremely secure.

Video

Firebug was initially written in 2006, and since then, it has transformed the way we create web pages. Before Firebug, debugging consisted mainly of inserting alert statements. Now we have an interactive console, breakpoints, DOM inspector, and live CSS editing. It seems a lot comparing to nothing, yet I think it’s only an inception.

My talk will shed light on how primitive our current tools are and how we can improve them. In addition, I’ll introduce new tools such as WebKit Timelapse, and share other tools used in different industries (like Game Development and VFX). I’ll highlight what we, web developers, can learn from them.

Video

On July 21st, 2007, 15 million people around the world took a break from their daily routine to read the final installment of J.K. Rowling’s best-selling Harry Potter series. Through this spellbinding story, Rowling crafted a global phenomenon, outselling every book in history with the exception of the Bible and Mao Zedong’s Little Red Book. What can the Harry Potter phenomenon, which was largely fueled by the Internet, teach us about JavaScript? More than you might think.

In my talk, I’ll highlight some similarities between the adoption of Harry Potter and JavaScript. The spread of both HP and JavaScript occurred at the same time in the late 90s, and each phenomenon had a role in shaping the other. I’ll also discuss how the magic of Harry Potter and its international fan following can inform the global JavaScript community. After the talk, you’ll understand the evolution of JavaScript from an entirely new perspective and you’ll be exposed to a few magical JavaScript APIs.

Video

Tired of spinning up servers and APIs for your web applications? Fed up with writing custom scripts to graph your metrics?

At the Guardian, we have built Web Components that fetch deployment and monitoring stats and pipe the data into customisable graphs, so that you can assemble live dashboards in plain HTML without having to write any JavaScript. By relying on open APIs and the AWS JavaScript SDK, the custom elements can run off static pages in your browser and talk directly to your monitoring APIs (Graphite, AWS CloudWatch, etc.) without any intermediate server.

This talk will demonstrate both the nascent world of the 2-tiered web architecture, which sees browsers directly access cloud services, and the declarative power of the Web, where rich functionalities can be obtained by combining simple Web Components.

Video

A local network of single-board computer running Node.js & providing an API to control different kind of devices: LED tower, LED displays & more. This network is dominated by one main computer & a web app running on Angular.js in the browser. Live Demo: Web App + Web Audio API + SoundCloud + Network of Devices = NERD DISCO!

Video

I’m not going to lie - building front end JavaScript applications can be hard. Why? Because state, that’s why.

When writing code for the client, we are almost entirely interested in how to best structure a would be mess of events and state. As our code base grows and the number of possible states increases, if we aren’t careful we can end up in the fetal position, alone and questioning our life choices.

In this talk we will take a look at some of the patterns we see being commonly applied in client app’s to see if the give us ways of handling state and state transition in a scaleable, maintainable fashion. Then we will take a look at some tactics you can use to help you better embrace both state and events, without sacrificing clarity in your architecture.

Video

We often talk about JavaScript as a ‘functional programming language’. This is mostly because it has first-class functions, but there is far more to functional programming than that. Immutable data, recursion, laziness, type systems and sophisticated static analysis are all tools in the functional programmer’s box.

Unfortunately, many of those tools are regarded as impractical, academic concepts of no use to real-world software engineers. But as you’ll find out, they’re based on quite simple ideas and you’re already using a few of them – you just don’t know it yet. And the ones you’re not using might inspire you to look at programming differently.

By consciously paying attention to these techniques, we can make our programs easier to understand, test and change, and we can even use them to make our computers solve more of our problems for us.

Video

The URL is universal in describing location within the web. Sadly linking within documents has been a start-stop process. The trusty Anchor tag is robust but very much a manual and time-intensive task. In publishing there is a huge level of complexity and over-head when you try to maintain unique anchor links when text is subject to change (developing stories, corrections, edits). As we see more single-page articles, especially long-form, this is a growing concern. Luckily there are number of flexible, fault-tolerant, dynamic solutions we can use and extend and have applications with annotation, commenting, sharing and highlighting.

Video

Data compression is an amazing topic. Even in today’s world, with fast networks and almost unlimited storage, data compression is still relevant, especially for mobile devices and countries with poor Internet connections.

For better or worse, GZIP compression is the de-facto lossless compression method for compressing text data in websites. It is not the fastest nor the better, but provides an excellent tradeoff between speed and compression ratio. The way Internet works makes it also difficult to use newer compression methods.

This talk examines how GZIP works internally, explaining the internals of the DEFLATE algorithm, which is a combination of LZ77 and Huffman coding. Different implementations will be compared, such as GNU GZIP, 7-ZIP and zopfli, focusing on why and how some of these implementations perform better than others.

Finally, we will try to go beyond GZIP, preprocessing our data to achieve better results. For example, transposing JSON.

Video

Modern JavaScript engines are able to generate very good machine code. Wouldn’t it be a waste to write in C those parts of the language that can be expressed in JavaScript itself? I will talk about how this is works in different virtual machines, and how this makes it a breeze to modify V8 in particular.

Video

JavaScript is the lingua franca of the web, yet it remains predominantly sequential and web applications until recently have been unable to utilize hardware parallelism. The goal of Parallel JavaScript is to change that. Parallel JavaScript provides web developers with a safe, high-level API that allows them to write applications that effectively utilize multi-core and SIMD parallelism as well as GPUs while preserving the programmability and portability of JavaScript. This talk will introduce the key design principles of Parallel JavaScript, the API itself and our experiences with implementing it. Finally I will show sample applications that highlight the leaps in performance that are possible. I will also briefly discuss the standardization efforts underway to make Parallel JavaScript part of ECMAScript 7.

Video

California ideology has undoubtedly changed the way the world looks at technology and business. Silicon Valley has spawned its own stepchildren in Europe like “Silicon Allee” and “Silicon Roundabout”. Lately, Silicon Valley has come under criticism for its ethics, social irresponsibility, hyper-capitalistic values, and spending millions of dollars funding apps like “Yo”. How did we get here?

My talk will give a brief history of Silicon Valley so we can learn from the past and create a new future. What can we learn from its roots in the LSD-dropping, commune-living hippies that set out to decentralize power and empower the individual?

Video

This is a talk about alternative ways to interact with smartphones and tablets.

Being equipped with an array of sensors (touch screen, GPS, camera, proximity sensor, gyroscopes, compass, microphone, accelerometer, and even a humitiy sensor), smartphones and tablets offer a whole new range of input options.

I’ll talk about how these new inputs can help improve and augment the current keyboard and swipe/pinch interaction paradigm. I’ll give examples of how the new interaction types can be implemented (some at a conceptual level, others more concrete). Demo-wise, I’ll also show you how a real-life search engine can be augmented for smartphone use.

In addition, I’ll show you how data from many of the sensors are accessible directly from Javascript and give some pointers to how to transform the raw data into more structured web app consumable input.

Overall, my talk is about how to move away from a text input based paradigm and how to establish new ways of interaction better suited to the new devices on their own terms.

Video

It’s quite likely that at the end of this talk, everyone’s going to be too terrified to fly home. This talk contains phrases like “In two minutes and thirty-one seconds, everyone on this plane is going to die.”. In the course of this talk, the horrific deaths of hundreds of people will be discussed, and we’ll look at what killed them in detail.

On the plus side, air crashes are the most well-investigated complex systems failures, and the lessons learned from these can be reapplied to coping with failure when it happens in the complex systems we build.

Also, they’re a lot more interesting than website outages.

Video

You’re finishing up the final bugs for your guaranteed AppStore hit, Asteroids: Totally Different This Time. Just before release, your crazy game designer partner has an epiphany: “What if… What if you were the asteroids, instead of the ship!? It will subvert the player’s every expectation since the dawn of gaming!”

Another programmer might despair: the glorious, deep and wide inheritance tree, ruined! The entire code architecture was founded on the player controlling just the ship!

But instead of despair, you remember that you focused more on the data and the systems that operate on that data, and are able to turn around the new version overnight.

Is this a dream? It might be. Let’s find out during this talk.

Video

On a dark and fateful day, Promises were adopted as the default asynchronous implementation in JavaScript, much to the chagrin of Node community and the church of small modules. So, we have callbacks, promises, generators? What about streams or even yet WHATWG Streams? What about events? What are we missing to make ourselves the most productive. This talk with deconstruct what we’re doing, how we’re doing it wrong, and have a rather opinionated way of how we move forward with sane async coding. Together we can build a better future, I promise!

Video

The road to JavaScript expertise is hard, but easy to forget. Let’s go back to the beginning and work our way to the top, reminding ourselves of the struggle (but ultimate triumph!) of how we become the incredible developers we know we are. We’ll talk about individual journeys, shared experiences, and the community that has brought us all together.

Video

I’ll explain how React is moving towards a minimal API surface area. Instead of providing many framework features, React is trying to utilize patterns, paradigms and JavaScript language features to accomplish the same tasks that other frameworks have dedicated APIs for.

We start out with higher order runtime features and then backport them to use ES6 language features and syntax. How does the JSX syntax extension fits into this model? I will also touch on the syntax proposals we and other framework authors are making to ES7 and future versions of JavaScript.

Video

When I became a developer evangelist in early 2012, I was told that an important part of my job was to support my developer community. This open ended mandate was both scary and exciting and I threw myself into the role, eventually getting involved in organizing meetups, hackathons, conferences and even a coworking space in my adopted home of Seattle, WA. However, earlier this year I started to experience severe burnout related to these activities and as I spoke to other organizers I started to hear similar stories. The number of developers worldwide is growing at a breakneck pace and we need many more people to jump in and help support the new members of our community. This talk is about the joys of getting involved but also how the things that you love can sometimes hurt you. I’d like to share a few things I learned recently about prioritizing people over projects that make contributing both more scalable and also much more rewarding.

Video

D3. NVD3. C3. Highcharts. And now, from Palantir, Plottable. There are seemingly innumerable Javascript charting libraries, all producing similar charts and often built on the same technologies. Why are there so many options? And why does it seem like more are coming out every day? We will explore the landscape of charting libraries, and explain why Palantir decided to write Plottable.js. We hope to figure out why there are so many of these things, and chart a course towards the One Library – to Rule Them All.

Video

Linino.IO is an ecosystem including open hardware and open software enabling the interaction between cyber world (the hacker’s space) and the physical world (the maker’s space). The speech will cover details on how to program sensors and actuators and integrate them into a cloud-based holistic framework based on Javascript and Node.js.

Video

Mainstream operating systems are bound by abstractions and design decisions largely made decades ago. Modern event-driven software doesn’t have a choice but to use less-efficient kernel interfaces. Internet growth brings new challenges for server software and kernel developers. These days we need to handle millions connections and packets per second. This talk tries to answer the questions: how can we optimize JavaScript server software stack to prepare it for such a high loads? And how does JavaScript kernel look like? I’ll also show Runtime.JS system that tries to rethink kernel design to improve security, reliability and performance of the system.

Video

Scaling Node applications from prototyping stacks to production can be very difficult as there is a big lack of conventions and best practices that work across companies and even communities. In this talk Tim will be showcasing his favourite 4 modules of KrakenJS – a thin convention layer on top of Express – which helped PayPal pushing out Node apps. Learn some key findings that PayPal made when working on Node and how we structured the introduction of it into our existing infrastructure. Being more efficient, needing less people working on projects and being way more responsive than classical apps Node and Kraken have become PayPal’s favourite stack.

Video

Common web frameworks make the assumption you are going to build against a Restful API, but what if your use case doesn’t fit with the Restful principles. How might you go about systematically designing a protocol between client and server? In this talk we are going to discuss how you can design and build an RPC style protocol and service layer that is flexible and extenisble enough to serve multiple cross platform clients and servers, growing with application needs whilst letting developers focus on building features instead of maintaining API boilerplate.