Video Recording and Production done by JSConf
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
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!
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.
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?
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.
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.
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!”
There will be demos and MAD SCIENCE.
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.
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.
What is type coercion? When can it be useful? What happens when we choose to use == over ===?
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.
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.
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.
Ever wanted to rebel against the sad immutability of the physics? Lets try to make functions fall upwards and inline all the apples.
The true freedom is just one heuristic away.
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.
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!
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.
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
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…”
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.
Why go to such length? Because it’s damn rewarding to create these small pieces of art! Try.
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?
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.
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.
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.
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.
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.
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.
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.
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.
Tired of spinning up servers and APIs for your web applications? Fed up with writing custom scripts to graph your metrics?
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.
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.
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.
I am writing in English and you understand me perfectly well. We share a grammar and, thanks to the internet, an ever-growing vocabulary.
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?
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?
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.