Matt Claypotch (POTCH) - @potch

Call My User Agent

Most developers only think of the term "User Agent" in terms of the (quite messy) User Agent string that browsers send along with their requests. But before the alphabet soup of "User-Agent:Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36", there was a different idea: What if software could act as an agent- an intermediary ambassador to help digest a connected world of information and protect our interests? After 20 years, these ideas are starting to return. Voice assistants, reader modes, and rich metadata allow browsers and other internet-connected devices to guide us online. Find out how the has moved past a scrolling rectangle, how browsers are taking a more active role in our online experience, and how you can join the party.


Dustin Getz - @dustingetz

What would happen if REST were immutable?

Full stack immutability from database to UI. Solving the object relational impedance mismatch. Relational vs graph. Immutable timeseries database. Backend-for-frontend (anti)pattern. Business logic code sharing across browser and backend. Relational queries in the browser. Removing the backend entirely. ui :: timeseries -> html. Reactive queries. Tree vs Graph as a UI state model. Datascript. Removing async from UI and service development. Why the failure of hypermedia in the 2000s is caused by I/O and mutable state. Why 2010-era "REST" sucks, and how to fix it with an immutable architecture.


dustin getz - @DUSTINGETZ

Workshop: Intro to ClojureScript

We will code a little browser app in ClojureScript and explore simple functional programming techniques for building web applications.


Kevin Hoyt - @krhoyt

Workshop: Machine Learning for JavaScript Developers

It has been suggested that in the future, developers will not so much program computers, as they will train them. Machine learning is having a broad impact across all industries, but what does it mean, and how does one use it in an application?

Join IBM Developer Advocate, Kevin Hoyt, and IBM Watson, to learn a brief history of machine learning, common features of machine learning, and how to leverage those features in the browser, on the server, and on IoT devices, all with JavaScript.

Coverage will include:

- Speech-To-Text
- Text-To-Speech
- Conversational Dialog
- Visual Recognition
- Translation
- Concept Extraction
- Tone Analysis
- Personality Insight
Get ahead of the curve with what venture capitalist firm Andreessen Horowitz calls a fundamental technique that is expected to be in products.


Nate Abele - @nateabele

Functional Reactive Systems

The Holy Grail of single-page applications are 'always-on' interfaces that continuously respond to user interaction and real-time remote data, but managing complex UIs gets messy in a hurry. We'll talk about the principles of functional reactive programming (FRP), and how they can bring reliability and sanity to your architecture & development process.


CF Grugan - @che_effe

Building an Alexa Clone in Node JS

Using intel Edison, IBM's Watson and our local hero Duck Duck Go, I'll show you how you can create a lightweight and fun voice controlled personal information lookup assistant.


Ken Rimple - @krimple

React and Friends - Orienting yourself in Facebook's component API

So all of your friends in the JavaScript front-end community have been talking about React. Some have been moving from other APIs and frameworks headlong into using React for writing their user interfaces. But what is it, and how do you stand up an application?

This session will give you an orientation into the React component API, which is used by Facebook and Instagram to run their web applications.  We'll review a React application, and show you the various decisions you need to face, such as state management, component composition, and how to deal with event handling. We'll then discuss topics such as JSX and the Virtual DOM, and explore the reasons many developers have been placing state in APIs such as Redux instead of holding it in the React components themselves. We'll wrap up with a discussion of the router and how it can be used to navigate between the views of an application.

We'll provide instructions for setting up the sample shortly before the class at, so browse there just before the conference and download the sample code and follow the setup instructions.


Nathan Lilly - @nelilly

Accessibility and JavaScript

How to enhance your applications accessibility with JavaScript, and how to not break accessibility in the first place.


F.M. Bonnevier - @FMBonnevier

Javascript: The Darkside

Javascript: The Darkside will offer a survey of Javascript-based attack vectors, a discussion of the ways in which some applications (eg. Rails) provide ways to prevent these attacks (mostly XSS), and how to continue to be security-minded developer when using client-side technologies.   These past two years we’ve seen “The Great Cannon” DDoS Github, Magento fall victim to a XSS attack, ransomware use Javascript as a delivery mechanism, and a developer remove a single dependency library from NPM disrupting many popular applications.  By cultivating an awareness of the nefarious ways Javascript can be used we all become better developers and contribute to building a safer Web.



Angular 2.0 - Ready or not, here we come!

Anybody who has attempted to follow the fast moving Angular 2.0 ABRC (that's alpha, beta, release candidate) train down the tracks has felt the following emotions: frustration, puzzlement, exuberance, and various forms of satisfaction.

When I elected to do an Angular 2 workshop for LibertyJS I'd assumed that this two years in the making new framework was ready and the release candidate was done. It was a game of conference chicken - with the team releasing breaking updates and the deadline slowly approaching. Would it make it out on time?

Guess what, folks? It's officially released now! Angular 2.0.0 (and now 2.0.1) are online, and so it's officially time to roll our sleeves up and start writing those awesome reactive single-page applications.

This workshop  will get you up to speed on writing a basic Angular 2.0 application - from building basic components and modules, to understanding the template expression and binding syntax, to handling forms, events and data using RxJS, to building services. Oh, and we'll spend a little time using the router to show several components. Along the way we'll discuss some of the debates and decisions that led to the newest API changes.

The workshop will be based on Angular 2.0.1. Instructions on setting up the lab for the course will be available at no later than Wednesday, September 28th, so check there to install the pre-requisites before you attend for maximum benefit.


Jonathan Belcher @belcherj

Workshop: Es-next Future Features of JavaScript, a Hands on Tutorial

A hands on workshop looking at each of the new features in JavaScript and their uses.


Ken Dale - @kendaleiv

Modern jQuery: Refactoring and Testing the Way Forward

Back in 2006 jQuery 1.0 was released. Today, jQuery is still used by a large portion of the web: 70% of the top 100k sites! Its sheer ubiquity is evident: Bootstrap v3's JavaScript plugins depend on it! jQuery's brilliant selectors, powerful Ajax calls, and how well it has abstracted away browser differences has enabled developers to move the web forward.

Together we'll explore jQuery in a modern light -- using modern JavaScript constructs and techniques to refactor jQuery code into a modular and well-tested application. If you can conquer pre-2000 jQuery spaghetti code, you can probably refactor anything!


Martin Synder - @MartinSnyder

Stop goofing around during build cycles with webpack HMR

There has been a growing number of JavaScript technologies (including ClojureScript and React) that have had the ability to hot-load changes into the browser while preserving the state of your application.  Webpack HMR implements those features in an agnostic way that can be used with any web application.  Learn how it works, how to use it, and a collection of webpack practices that makes it all easier to work with!


Chris Lorenzo - @chiefcll

Polymer in Practice

Are you looking to build a cutting edge responsive web app? Instead of using heavy frameworks, that take time to learn, maintain and replace, #UseThePlatform and leverage new web platform primitives to build a better web!

You’ll see how simple and elegant the Polymer library makes building web components. You’ll get to hear how Comcast is building its next generation single page apps using the latest browser APIs and Polymer’s building block model.

You’ll walk away from this talk with a peek at Comcast’s development environment and an understanding of what it takes to get a production app up and running with Polymer. In addition you’ll acquire some best practices on how to separate your UI from your backend, keeping your front end static and easy to deploy. Lastly, we’ll take a look at the resources available for you to easily get started with Polymer.


Dan GAUtsch - @iamdaninphilly

Everyone Needs Standards

My session will involve how you can standardize the way you write your code for easier maintainability and scalability. With the advent of so many new frameworks and ways to write code, we often forget how to keep our code consistent. Whether you are a part of a team, or working solo, bringing a set of common principles to your work is important so you're not leaving a mess for the next developer.

This talk will touch upon the entropic human nature when writing code and how to prevent it from happening. Without standards and best practices, code would not be written the same way. Standards and best practices bring order to something that is inherently entropic.

Tools that will be covered during this session will include, linters, jsdoc, and pattern libraries.


Lucas HRAbovsky - @__lucas

Using electron to bring web apps to the desktop at MongoDB

When I first started building the official UI for MongoDB, it was a web app built on node.js. After a few months of alpha testing, it still felt like it was missing something.  On a hunch, I started experimenting with electron from GitHub's Atom Editor team.  Electron allows for building desktop applications using JS, HTML and CSS. Within a week of experimenting, I found what had been missing from the web app experience. This has opened a whole new world of creative possibilities for me personally and I'd love to share my experiences.

I hope to answer a few questions in telling this story:

- What is electron and how does it work?
- What are the advantages of delivering desktop apps for JS developers?
- Why are desktop apps good business?

The UI for MongoDB (which I'll avoid talking about directly as much as possible) is now called [Compass](  I'm [@imlucas on GitHub]( My desk is in NYC, but most of the time I'm working from home in the Fairmount neighborhood of Philadelphia.


John Riviello, Silvia Moreno, Karen Damara, Chris Lorenz

@JohnRiv, @SilvsMoreno, @krdamara, @chiefcll

Polymer Workshop

JavaScript programmers are constantly debating what the next great framework will be. Rather than trying to keep up with the constantly changing JS framework landscape, learn how to #UseThePlatform and leverage Web Components so the code you write today will still be useful years from now.

Google's Polymer library is the tool of choice to build shareable, reusable Web Components that can function on their own or be used together to build entire web applications. With all major browsers actively building native support for Web Components, the standards that Polymer is based on will most likely be shipped in all major browsers within a year.

This workshop will quickly get you up to speed on this powerful web library. We'll start with a quick introduction to Web Components & Google Polymer before diving into hands-on coding exercises using existing Polymer elements as well as creating new elements. You'll learn how building an app with seemingly complex features like Offline-first support with Service Workers is simplified with the use of Open Source Web Components built with Polymer.


James sacra - @jsacra

Practical Implementation of Machine Learning

There's a lot of excitement about Machine Learning these days.  This talk is the abbreviated version of what it will buy you in JavaScript and a look at a couple of ways we can implement Machine Learning algorithms to assist users in web applications.  

This talk will focus more conceptually about practical ML and ways in which we can leverage this in JavaScript.  


Joe sepi - @joe_sepi

Quick and tasty APIs: just add data!

By taking a data driven approach, we can use, the open source Node.js library built on top of Express, to build out a full RESTful API in mere moments. If it's so fast and easy, what else should we cook up? How about relational data, remote methods and access control lists? Tasty, indeed!


Robert Smith - @smithrobs

Fahrenheit 735 for the JS foodie meathead

Like smoking meat? Enjoy working with JavaScript? Interested in BLE? Want a reason to mess around with all three at once? Check out (•the soon-to-be-available*) "Fahrenheit 735" - a node-based web interface for your BLE-enabled thermometer! We will dissect the app, discuss the thought process around reverse-engineering a simple BLE device, and maybe even trade some smoking diaries!


James Nylen - Github: @nylen

Building a web-connected kiln controller using Node.js

At our makerspace in Birmingham, AL, we acquired a kiln without a controller.  The existing solutions we were aware of had all the UX of programming a VCR, and I wanted to make something better.  Desired features:

- Web-connected; nice mobile-friendly dashboard with current status, temperature chart, etc
- Fast live updates
- Persistent data storage
- Read-only access via public internet
- Write access via the makerspace wifi network: turn the kiln on by setting firing schedules which the controller will follow


Ivana Veliskova - @ivanaveliskova

Entering the World of Javascript

I recently made a transition into the web dev world and have narrowed my focus on becoming good at javascript. This talk is about my journey into javascript and the resources that have helped me improve. I want to focus on how someone who is relatively new to the tech world can become a well rounded developer and what sorts of resources are useful.


Jason Cox - @jasocox

One Codebase to Rule Them All

By creating a responsive SPA and using Cordova, it is possible to create a web, mobile web, Android, iOS, Windows Phone, and Blackberry applications all with one set of code. By using this method, you can reduce the time it takes to reach the largest number of users possible with a minimal budget. I'll discuss many of the framework and library options, testing, and strategies.


Maurício Linhares - @mauriciojr

React Workshop

React workshop showing how to build a simple mint-like front end using React and NuclearJS. The goal is to show how to get components in place, the Flux model, immutable data and sending and receiving data to a server. There will be a pre-made restful service that is going to be used and students will work on the front-end alone.


Timothy Fluehr

Surfacing Customer Experience Data using JavaScript and the DOM

In all web properties both large and small there is a need to collect information on user behavior, performance, error handling, or for a variety of other reasons. In most cases all of this information is collected separately with specific implementations which often involves duplicated effort and/or an implementation geared to a specific provider which reduces maintainability and the ability to change providers.

This talk will show a way to collect any information in a human readable, maintainable way that allows for maximum flexibility. Various methods of defining and recording information into a structure defined through the W3C community group - will be shown as well as how to transmit that information to various services for analysis, with the ability to change services at will with no need to change any of your data collection.


Fawad Rafi

End-To-End Testing of Single Page Applications

Single-page applications bring a fluid user experience and responsiveness that are atypical for traditional, multi-page web sites. As a result, middleware (“server side”) is being used primarily as an API for a rich presentation layer (“client side”). This necessitates comprehensive automated testing of the presentation layer. While unit tests eliminate internal defects of an application, you also need a suite of end-to-end (or integration) tests to validate the application in its entirety. End-to-end tests take a “black box” view of the application and exercise its user stories from start to finish. This allows us to test the application in a real-world scenario and communicate with all its components such as external services, databases, network and hardware. Implementing end-to-end tests for a traditional, multi-page site is straight-forward because each page follows a linear lifecycle. But a single-page application contains multiple AJAX queries and does not load in synchronous, linear manner. This complicates end-to-end testing because we have to either wait for subqueries to complete or introduce arbitrary delay. This workshop explains how to overcome these challenges.


Thomas Boutell - @boutell

Object-oriented functional programming in JavaScript

JavaScript was designed from the beginning to permit more than one paradigm for implementing object-oriented programming. In this talk I'll explore the "self pattern," a frequently rediscovered alternative approach which yields substantial benefits in asynchronous, callback-driven code.

Methods can be freely passed as callbacks and can invoke other asynchronous code without unpleasant surprises, restoring the elegance of functional programming while preserving the extensibility and maintainability of object-oriented code.

Getting away from constant use of "bind" and/or ad-hoc closures inside each method reduces the cognitive burden on the developer. But what's the downside?

I'll look at the performance and memory use impact of stepping away from the "prototype" keyword, as well as the benefits

 I'll also examine how ES6 classes and arrow functions compare and interact with this option.

After exploring and implementing the self pattern directly, which requires no supporting framework, I'll briefly examine moog and moog-require, npm modules that extend the convenience of the self pattern and help revive the long-lost art of top-down programming.


Logan Crossan - @logan_crossan

TDD, Node, and Rapid Prototyping

I'd like to examine some of the differences between Node folks and people who use other backend technology in terms of testing -- I specifically want to look at the Node/Express community and the Ruby/Rails community. The Rails community values testing very highly, while many people I know from Node backends don't seem to place as high a priority on it. 

I also want to look at the differences between backend and frontend testing as a whole; in my experience, backend and full-stack engineers test their server-side code much more rigorously and more frequently than frontend developers test their frontend code. 

This is not a value judgement -- I'm interested in this topic from a mostly anthropological standpoint! I tend to advocate for testing code in general, and so I expect to have a slight pro-test bias. That said, I don't plan to make anyone feel bad if they don't test. I'm hoping to simply make suggestions for those who don't write tests or use TDD but would like to get started, and one of the ways I've found to do that is by rapidly prototyping.

I tend to work on small side projects and client work, so I'm almost always prototyping in some capacity -- I find that prototyping without tests is very helpful to get my head around the problem space and find out some pain points in my first implementation All the code I write to prototype the application is considered junk. Then, when I have a working prototype, I throw 100% of that junk code away and write my tests. Then I rewrite the whole application and make it presentable for other people to look at. That way I get a more complete understanding of the whole problem and some of the pain I'm in for when I start.