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.
Kevin Hoyt - @krhoyt
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?
Coverage will include:
- Conversational Dialog
- Visual Recognition
- 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.
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
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 http://chariotsolutions.com/libertyjs-2016-react/, so browse there just before the conference and download the sample code and follow the setup instructions.
F.M. Bonnevier - @FMBonnevier
KEN RIMPLE - @KRIMPLE
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 http://chariotsolutions.com/libertyjs-2016-ng2-setup/ no later than Wednesday, September 28th, so check there to install the pre-requisites before you attend for maximum benefit.
Jonathan Belcher @belcherj
Ken Dale - @kendaleiv
Modern jQuery: Refactoring and Testing the Way Forward
Martin Synder - @MartinSnyder
Stop goofing around during build cycles with webpack HMR
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](https://www.mongodb.com/products/compass). I'm [@imlucas on GitHub](https://github.com/imlucas). 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
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
Joe sepi - @joe_sepi
Quick and tasty APIs: just add data!
By taking a data driven approach, we can use LoopBack.io, 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
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
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 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.
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 - https://www.w3.org/community/custexpdata/ 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.
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
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.