Painting by functions: Rich WebGL widgets with functional rendering

An evolutionary tale, beginning at the birth of the original graphics APIs - caught between the functional and imperative worlds. Low level, and difficult to learn, but lighting-fast and capable of spectacular results. You'll see:

• The original, horribly stateful, OpenGL API
• ...and the GLSL shaders that run on top of it: functional, and powerful, and often beautiful.

OpenGL then spawned its JavaScript-enabled offspring, WebGL: impressive, but built on an arcane and unwieldy paradigm. It's available in all modern browsers - desktop and mobile - yet lies mostly dormant thanks to its stateful and scary API. But hark! The slow but unceasing rise of functional and reactive programming is the missing link - transforming WebGL into a slick and user-friendly powerhouse. You'll see:

• the stack-gl manifesto (and its core modules)
• gl-react and gl-react-native: adding stunning effects in a declarative manner
• UI widgets and components that are not possible with HTML5 Canvas and friends.
• ...all while wrangling it all with Rx.js streams.

Building Your Own Internet of Things: How to Connect All of Your Stuff to the Interwebs

There are two prevailing attitudes towards the future of the Internet of Things. It will be awesome or it will be terrible. Either our devices will accommodate us more and more, or instead they’ll reveal all of our secrets to the their corporate overlords. This talk will help the audience inch us all closer to an awesome future by enabling them to build their own Internet-connected devices or at the very least understand enough about existing IoT products to maintain a critical stance. The audience will learn how to use JavaScript, off-the-shelf hardware, and a bit of tape to connect everything they own to the Internet, things like t-shirts and dogs. I will be using an art piece I made, Plant-Bot, as a jumping off point. Plant-bot is a needy house plant that can only talk to people via text message (it doesn't have ears or a mouth), in order to get what it wants (often water). Using Plant-bot as an example, the audience will learn the basics of adding "senses" to their objects, a connection to the Web, and a way for the object to interact with its surroundings.

A cartoon guide to the wilds of data handling in React

I'm going to walk you through the wilds of data handling in react. I say “the wilds” because when you first look at the landscape, it seems to be overflowing with an untamed profusion of different options. It's hard to figure out why you might want to use any one in particular.

When you look closer, you'll see that it's actually easier to navigate than you might think. You just need a good guide.

Good Tech for Hard Places: Fighting Ebola with Javascript Offline Apps

On 23rd July 2014, the first case of Ebola was reported in Nigeria, home to a small NGO working at the intersection of tech and public health. By then over 1000 cases had been reported in Guinea, Sierra Leone and Liberia. This is a story of how we use JavaScript to fight the Ebola outbreak. It’s also a story of building good tech for hard places, where a stable internet connection is rare and emergencies are real. There are a lot of awesome technologies (e.g. CouchDB and PouchDB) out there to help you build offline applications. There is also no shortage of beginner level online tutorials to show you how to do a quick and nice first prototype, but as in any new field there is not so much documentation available to help you solve the problems you’ll find when deploying your offline applications to be used in the “real” world. This talk will present some of these problems as well as the solutions we came up with, including some open source tools developed by ourselves.

Conquering Fears

Conquering fears of inadequacy while enabling people to write dope poetry with each other. Basically, the struggles of working on a project alone, how to combine your interests to make something interesting for you to work on, and how to execute and spread the word.

JSConf History

I’d like to recap the history of JSConf and all the events it helped spawn since its inception by Chris and Laura in 2009. I plan to solicit quotes and soundbites from JSConfs & Family-events around the work that reflect on the influence of JSConf US and the subsequent success of the local conferences. Expect teary moments.

Multiplayer WebVR - Virtual Reality using Oculus Rift and Google Cardboard and WebRTC

Virtual Reality using Oculus Rift and Google Cardboard and WebRTC, let's do this!

Change the World With the Peer Web and Thali

How we can use JavaScript on our devices such as phones to change the world. From enabling those who don't have reliable internet or phone service to still be able to communicate, to protecting those in danger and protecting their identity. This all can be accomplished with the Thali Project, bringing back the peer web with our devices.

5 Years of Bacon: Every single thing I've learned since JSConf 2010

I don't want to just reprise the "BACON" talk - I'd like to talk about everything I've learned in the past 5 years (which is a lot) and includes insights on running and growing a team, starting a family, going deep into passions and more.

JSConf changed my life

I'm going to talk about how JSConf changed my life, and changes the life of those who I meet. When I first went to JSConf I didn't even go to JSConf. I went to ScurvyConf in 2010 and it inspired me. You can check the WHOIS for nodejitsu.com and you can see that it was registered on April 19th, 2010, just a day after the event. Over the years JSConf continued to inspire me so much that I started EmpireJS and now EmpireNode. These events themselves have spawned other amazing stories.

Building BoroJS

This week may mark JSConf's last call, but the local communities it inspired are just getting started. In this talk, Jed will share lessons learned from joining New York's JavaScripters to create BoroJS, one of tech's most vibrant local communities.

OMG Streams!

There’s a data structure that essentially makes you a wizard and that data structure is streams. In this talk, you’ll learn more about the best data structure you didn’t know enough about and how to leverage its power in JavaScript. Expect to learn about IO streams, generators, and the latest developments in the awesome awesomeness that is streams.

The toxic side of free. Or: how I lost the love for my side project

This is a 5 part story about (my side project and attempted full time project in 2014) "JS Bin" and the abuse that it's suffered over the last 7 years of being an open project. The stories include tales of spam, abuse from registered users and the impact on personal life, dealing with the process of taking money, and the pain (oh...the pain) and finally police involvement (from a casual planned DDoS, child pornography and terrorism). In each section, I've tried to end on a positive note (but it's not terribly technical) even though the actual content is fairly negative and dark at times. It's an extremely personal story, but there's way too much "hey, my project is awesome, who want's a high-five?!" - this is very much the antidote!

Building Interactive npm Command Line Modules -- All The Things

Here you are coding away, when you realize you're in desperate need of a quick shell script to get your project cleaned up. You're standing at a fork in the road: Bash or Node? You choose the road less travelled by (for some reason) -- Node. I congratulate you on this decision. You've written it, you may have published it, and it certainly works. But what now? Is this all a command line module Node is good for: a project clean up and some data manipulation? Let's take it a step further. Let's make a command line module that's more than just your compiling script. I am, of course, talking about making it more interactive. In this talk I want to take you on an adventure that will require cunning, bravery, and maybe some magic. We will walk through obtaining and parsing data, using Node's process functions, and finally improving the module's user experience.

The Browser Isn't Feature Complete

With the rise of native apps, native wrappers, and even standards development, the browser has taken on a more behind the scenes role in web page delivery. I’ll be discussing the implications of this, and a framework for thinking about the role of the browser in the next generation of web applications.

Internet of Cats

Ever lose out on a good night's rest because your pesky cats keep waking you up at 4am for food? Rachel has. Many times. For her first project using node, socket.io, microcontrollers, and johnny-five, Rachel built a web-based feeder that delivers tasty cat chow on a configurable schedule or when triggered remotely. She'll walk you through her learning process with utilizing new tech for the first time and get you excited about trying your own projects so you can take the first steps to putting your work out and contributing to the open source community.

Controlling the NES with Javascript

We have built a system that uses javascript to manipulate the physical RAM of an NES (Nintendo Entertainment System) while it is running, to arbitrarily read or write system memory. This enables new cheat codes, wacky ways to play games, investigations into how games work, and the ability to create external visuals from a game's data, such as collision detection or advanced HUDs (heads-up displays). Using a video mixer, we can even combine views to make augmented games. Our system has an easy to use interface, allowing the creation of javascript code to control game memory, and these scripts can be used without modification in an NES emulator that has had nodejs embedded into it.

We are Hacks and Have Been Stealing Code for Years: A Time-Traveler’s Guide to Leveraging Community Code

In this talk, Glen Goodwin and Todd Gandee will walk back from the present day to the “ancient” past of Babbage and Lovelace discussing how the act of “creative borrowing” influences learning and understanding for computer programmers; how we learn by observing and deconstructing the work of others to make it our own. This includes an examination of past and current models used for “stealing” the (mostly) freely shared knowledge and past work of others like Github, StackOverflow, View Source, and Byte Magazine. Our talk emphasises the importance of inclusive conferences like JSConf in the growth of junior and senior software engineers. Programmers’ tools of today illustrate the apprentice/mentor relationship more akin to the arts than engineering.

JS on Pebble, Pebble in JS

What if you could run JS directly on the Pebble Smartwatch? What if you could run Pebble apps directly in the browser and program it with JS? There are a lot of interesting projects that deal with embedded devices and C/JS interoperability such as Espruino, JerryScript, Emscripten, or cheerp - let's do it all and see what happens to real firmware and real watches.

Open Source is Hard

Many of you contribute to or run open source projects so let's have a discussion about the difficulties you face. Brian LeRoux and Kris Borchers will lead a discussion around the difficulties of running open source projects and how things like open foundations, open governance and collaborative ecosystems currently help ease that burden and will look for thoughts and perspectives about what more they could do for your projects.

Philosophy and JavaScript

Philosophy has been around for orders of magnitude more time than JavaScript, but they both turn out to be similar in interesting ways. The goal of this talk is to figure out if we might be able to glean anything practical from comparing them, especially to soothe the mind of the old and tired developer who is still excited in building things, but has a major case of framework fatigue. Both JavaScript and Philosophy seem to be in a constant state of flux. Both have had trendy ideas that become the next bandwagon for folks to jump on. Both have personalities for people to laud and rally around. Both are used to build little ecosystems that become popular for a time, and then seem to fade out into obscurity. Both have ideas that are ancient but may still be surprisingly useful. Yes, we are developers, but more importantly we are human beings. As human beings, how are we supposed to deal with this impermanence and change? How are we supposed to approach our work if we know it will be torn down soon in the years to come? What should our attitudes be so we can not go completely crazy?

Untitled

Modern Websites for the Modern Web

It seems like new APIs for the web are released every week. It would be cool to be able to use them, but if you need to make websites for the average user, you won't be able to use them for years - right? Wrong. Patrick Kettner, the lead developer on Modernizr and PM for Microsoft Edge, will go over how creating feature rich and super fast front end applications, integrating over a dozen cutting edge web features, all while supporting even the oldest of web clients.

HTTP2 Push and WebPush

Using HTTP2 Push to syndicate all the things, with WebPush spec and a resource-oriented implementation.

Atomic Components - Managing Dynamic React Components using Atomic Design Principles

Designed by Brad Frost and Dave Olsen, atomic design is a wonderful “methodology for creating design systems” backed by Pattern Lab with five distinct levels or ‘building blocks’, which, when combined, create semantic, contextual relationships between interface objects. We’re going to explore how these organizing principles are a natural fit for building interfaces in React, and how with a few tweaks we can begin to contextualize entire interfaces semantically and intuitively.

Treating Framework Fatigue With JavaScript

Do you suffer from Framework Fatigue? With so many new frameworks and libraries appearing on the scene, and disappearing just as quickly, you’re not alone. Symptoms include confusion, ambivalence, skepticism, and a reduced capacity for hype and marketing lingo. Talk with your mentor today and ask if JavaScript may be right for you. JavaScript is the basis for many popular web frameworks and libraries, and learning its nuances may help to reduce the symptoms of Framework Fatigue, and better inform your decision whether or not to use the Right Framework™. Side effects may include: language-level skills, increased confidence, better problem solving ability, and knowing what “this” is. Occasionally, JavaScript users have reported a desire to write their own framework or abandon frameworks altogether, although this is rare. This talk will focus on the importance of a solid JavaScript foundation - especially with enhancements introduced in ES 2015 - before diving headfirst into the newest fashionable framework. Too often, strong developers come to the table with a golden framework hammer, and soon everything looks like a nail. A strong grasp of the JavaScript language and its host environment can help better inform you of the hows and whys of a given framework design, while making your skills – and your code – more portable between frameworks.

JavaScript in Space, or There and Back Again

Somewhere in the middle of the Mojave desert, a group of engineers try to launch a JavaScript-powered weather balloon to the edge of space. Along the way they learn about ham radios, explosions, and THE POWER OF FRIENDSHIP.

Debugging Impostor Syndrome

Impostor syndrome is rampant in our industry. I'll introduce the topic and share tips and techniques I've gathered over the years for dealing with the day to day challenges.

Knock, knock, who's there? Designer.

Designer, who? Uh huh. That's how it can feel sometimes for designers sitting on the sidelines of the dev process. ​ I'll share some insights on how to encourage and welcome your designers into the dev process to build more thoughtful products. The reality is that it's not difficult to do, but it is hard to do it well. This talk will share how we do it at bitHound and cover topics such as: ​ - How to plan sprints to include design - How to use Pull Requests to keep everyone on the same page - The old-school tool that works surprisingly well - Whether or not there is such a thing as too much crossover - And... why JavaScript is the perfect language to help bridge the gap.

i18n via Front-end & Back-end JS

Critical for accessibility and an open web, internationalization (i18n) is a highly important yet missing feature in many web applications today. While this process has been cumbersome in the past and options limited, this is not the case in today's development space. This session will cover the principles and implementation of i18n standards using both front-end and back-end JS tools.

Make the web great again

This talk will present a new perspective into what makes many websites slow and how to fix it.

Emulating printers

How to get into trouble emulating a printer using noting but Node.js

I'm not qualified to run a software company, AND SO CAN YOU!

Careers in open source software.

High Performance Apps with DoneJS

This sentence is wasting your time before you get to useful information. How annoying is that? Annoyed is how your users feel if they can’t see their content immediately while too much JavaScript and CSS downloads too slowly. This talk shows how the recently released DoneJS framework makes it easy to build fast single page applications that are: - server side rendered - progressively loaded - use content delivery networks We will discover how DoneJS solves these problems while building a simple real-time chat application. As a bonus, I will show how to build the chat application to a mobile and desktop application so all three versions of the app can chat together. If we have time, I might even turn on worker thread rendering.

Faster filtered arrays in CanJS

Almost every JS application today - even TodoMVC - has a "Filter by" feature requirement. Unfortunately filtering an array is an O(n) operation - meaning every item in the array needs to be evaluated. This is true regardless of whether an item in the filtered array is added, removed, or changed. Add to that the overhead of DOM manipulations and repaints and you'll find that filtering a DOM bound array is a costly operation. Can we break through the O(n) barrier? Join me to learn how and why the CanJS team set out to beat the "O(n)" speed limit imposed by filtered arrays and what we've learned since.