pre-release: Nodevember meeting announcement

Please take a moment to review your details and reply with OK or edits.
Subject and below is what will go out and also will be used to title the videos.

Subject: 
ANN: Nodevember at Collins Auditorium Sun November 20, 8:45p


Nodevember
=========================
When: 8:45 AM Sunday November 20, 2016
Where: Collins Auditorium

http://nodevember.org

Topics
------
1. Immutable Apps
Lee Byron

One of the greatest challenges of building a rich UI is keeping track of all that is changing: incoming touch and mouse events, new data from your servers, animations, and more. Here we propose a new way to tackle this challenge that is as old as computing itself: don’t let anything change in the first place. Come learn about how to build rich and highly performant UIs without losing your sanity by leveraging the principle of immutability and the optimization techniques it enables.
 recording release: yes license: CC License  

2. Simplify State Management with Redux
Jonathan Kemp

Managing state in web applications is increasingly difficult. Redux simplifies state management by restricting how data is updated in web apps. These restrictions make it easier to manage data changes and enable powerful developer tools. In this session, we'll look at how data flows in Redux applications and the role functional programming plays using a real world application built with React and Redux.
 recording release: yes license: CC License  

3. Escape Room: Children's Holiday Edition
Ben Acker

Combining technologies to provide a fun puzzle solving experience for children.
 recording release: yes license: CC License  

4. How to Accelerate Digital Transformation: @WalmartLab’s Migrated to React and Nodejs in Less Than a Year
Alex Grigoryan

The story of how @WalmartLabs successfully migrated to React and Nodejs with efficiency and speed. At the end of this talk, you should be able to make your own successful strategy to transform your technology stack quickly and successfully.
 recording release: yes license: CC License  

5. We need a better way to test
Kevin Lamping

Testing can be a real pain! Isn't it good enough that it looks fine in Chrome? Should I really have to test the login page for a change to the contact form?

As a front-end dev, I've lazily assumed that testing is the realm of QA. Sure, I'll begrudgingly check my site in IE to see how much repair it needs, but I confess to cutting corners when testing and saying "That shouldn't break anything..."

This worked okay while I was building small sites, but now that I'm working with multiple teams on large projects, cutting corners doesn't work. The edge case always comes in to play and things that probably won't break do.

Instead of getting bogged down manually testing my site in browser after browser for every change, I decided to get smart (i.e. lazy). Using a combination of Visual Regression Testing and Functional Testing, I've automated my UI testing using simple NodeJS scripts.

This talk will cover a real-world implementation of browser testing using WebdriverIO and WebdriverCSS. We'll cover all the steps to get started writing automated browser tests, so that you can make changes with confidence.
 recording release: yes license: CC License  

6. Framework-Independent JavaScript Components
Elijah Manor

Have you ever wanted to reuse code across your web applications, but your code was written exclusively for one library or framework? You may have encountered this when you wanted to use a jQuery plugin, Angular directive, React component, etc... and realized it was tightly-coupled to a specific framework that you weren't using.

In this talk we will re-write a jQuery plugin with plain JavaScript that can be used in many different client-side frameworks. Along the way, we will address various design patterns and identify potential caveats as we build our component. Once we've created a reusable component, we will create adapters for specific libraries and frameworks such as jQuery, Angular, React, Ember, etc.

A reusable component simplifies unit testing, enables you to share code across projects that use different frameworks, enables compatibility for future frameworks, and expands your potential user base if you decide to open source your project.
 recording release: yes license: CC License  

7. The Starter Kit Manifesto
Cory House

You know minification, linting, testing, bundling, cache busting, transpiling and so on are important. But does your team do all this consistently? Likely not. That's why every team needs a starter kit. Let's discuss why it's so critical, and what belongs in the box.
 recording release: yes license: CC License  

8. Building Slack Bots for Fun and Profit (or at least fun)
Cole Furfaro-Strode

I’ve built a lot of Slack bots, some of which we use every day at [SparkPost][1] to [keep us productive][2], some of which, let’s be honest, are for my own [enjoyment][3]. My favorite thing about Slack bots is they are easy to build and entertaining, which makes them a great playground to learn more advanced engineering concepts. In this talk I’ll teach you how to build a Slack bot, how the [Skellington][4] library can make this process even easier, and how building your bot will secretly teach yourself continuous deployment.

[1]:https://developers.sparkpost.com/
[2]:https://github.com/SparkPost/community-bot
[3]:https://github.com/colestrode/marky-markov
[4]:https://github.com/colestrode/skellington

 recording release: yes license: CC License  

9. A Real-World JavaScript IoT Solution
Garth Henson

As many enterprise organizations can attest, meeting space is a premium within offices. Here at Disney in Seattle, it is no different. Managers were reporting wasting in excess of 15 minutes per day just walking the floors looking for available meeting rooms in which to have a short, impromptu meeting with an employee. Calculate that wasted time across the breadth managers within our office, and we are talking about a measurable organizational expense! Looking for "unbooked" rooms is not sufficient, since there are some "un-bookable" rooms, and there are also those fiends who will book a conference room and then not actually hold their meeting (or end it early). We had no way to identify these situations without walking the floor, hunting for empty spaces.

To combat this problem, we build a solution that I would love to share with you. By connecting a PIR (Passive Infrared) sensor to a Raspberry PI, we are able to monitor for activity in a single room. This device is then able to broadcast a state change (from available to occupied or vice versa) over a web socket to which it has connected. In order to surface the availability of the rooms, we have a web interface that subscribes to the web socket and visualizes the current state of all rooms in our building. By displaying this web interface on public panels and making it available for employees to view on mobile devices, we have been able to significantly reduce the time it takes to find an available meeting space.

In this presentation, we will look at all layers of the project from the high level architecture to the multiple layers of JavaScript used: from the DB layer with MongoDB to the server with NodeJS and the client with AngularJS and mobile with Ionic.
 recording release: yes license: CC License  

10. Why We Do What We Do
Aria Stewart

Our community is huge, spanning not just the country but the whole world. It's easy to get wrapped up in our own local meetups and companies and the fashions of the minute and forget that all kinds of people from all kinds of places get into the tech industry and the tech parts of other industries and we all do what we do for a many different reasons. I interviewed all sorts of people from all over the United States and let them tell me why and what they do.
 recording release: yes license: CC License  

11. Staying Sane (dot) JS
Sergio Cruz

Developing apps with JavaScript is fun and scary in this day and age. It feels like every application we write will outlive the libraries used to write the app in... and that's not a fun feeling. Sometimes we get the impression that anything written in JavaScript today is so volatile because smart people will come up with smarter ways of solving problems, that will render solutions I write outdated about two minutes after writing it.

This issue was especially brought to life when I started working at Code School. How is it possible to prepare teaching materials that might be outdated by the time they get released? Turns out there is a way and I am here to prove to you that the JavaScript language and ecosystem is still a safe bet. Although there are parts of the ecosystem changing all the time, there are techniques we can use to prepare for those changes without having to rewrite whole apps over and over again.

Beginner & more advanced developers alike will draw value from this talk, as it will teach both of these groups how to collaborate in a productive manner when architecting and writing apps while getting ready for the unknown future.
 recording release: yes license: CC License  

12. ​Overcoming the Challenges of Mentoring
Kim Crayton

​There is an ongoing mantra within the developer community: that there are far more jobs available then programmers to fill them. Which should be an indication as to the wonderful potential for both business and those learning to code. Yet what often follows such statements are not words of joy but rather a list of frustrations related to the difficulty in finding and retaining enough skilled developers to fill these positions. 
The challenge is not in the number of newbies entering the field but the number who leave because they are not able to bridge the divide between bootcamps, online tutorials, books, videos, etc. to an employable developer who is able to contribute to the team. 
Kim has years of experience working with learners of various ages in helping them develop the skills they needed to be successful at whatever their chosen goal. She understands that for businesses to be successful, they must develop more effective and efficient ways of recruiting and retaining developers in order to meet organizational benchmarks. 
The developer community is a overwhelmingly generous one and a well designed mentoring or apprenticeship program could be one answer that business leaders and newbies are looking for.

- The business costs associated with corporate hiring managers inability to recruit and retain skilled workers to fill current and future entry-level positions are increasing (Queen, 2014). 
- 89 percent of organizational leaders stated that they are having difficulties filling open positions, which is causing them to either turn down orders, miss key deliverable deadlines or hire individuals from outside of the United States (Aho, 2015). 

Aho, K. (2015). The robotics industry: creating jobs, closing the skills gap. Techniques, (7), 22. Retrieved from https://www.acteonline.org/techniques/#.VpMcQq6rR0s

Queen, J. (2014). Hire power: to close the skills gap, states are teaming up with industries that need, but can't find, qualified workers. State Legislatures, (8), 16. Retrieved from http://www.ncsl.org/bookstore/state-legislatures-magazine.aspx
 recording release: yes license: CC License  

13. Fun and games with node.js!
Rachel Simone Weil

Fun, games, Javascript! Hooray! With the meteoric rise of node.js, there lies great potential to bring new people and perspectives into the wonderful world of coding. But for absolute beginners, the learning curve and installation process can be daunting. How can we draw in beginning coders and keep them engaged, even when the going gets tough? In this talk, Rachel Weil will describe how to apply node.js to the development of fun games, toys, and web apps that will inspire, engage, and motivate new coders. Weil will describe a few of the fun node.js projects she's built, such as a Twitter client for the 1980s NES game console and a machine-learning powered "Deal with It" meme-generating app. The discussion will then focus on using fun and games to bring in and retain new developers.
 recording release: yes license: CC License  

14. Lessons learned prototyping a wearable for rock climbers with Node
Aaron Larner

As a kid my life was very scripted. Wake up, eat breakfast, go to school, come home, do homework, eat dinner, watch TV, rinse and repeat. As children we don't have very much power to influence the world around us, which is why I fell in love with programming. It gave me ultimate control over a virtual space of my making, where I could create almost anything that I could imagine. Fifteen years since I first learned to code in BASIC, aspiring developers and seasoned professionals alike now have the power to influence not just virtual spaces, but also the physical world.

At the beginning of 2016 I set out to learn how to apply my existing programming skills to hardware. I toyed with Arduino, Raspberry Pi and an AR Drone before I ultimately settled on the Tessel 2 as a way to bring what was in my imagination into the physical world.

My goal was to create a wristband for rock climbers to automatically track stats, progress and injuries. To create the wristband I would need to use RFID, Blue Tooth Low Energy, and of course, JavaScript.

In this talk I'll share what I learned while prototyping the wristband using Node. I'll give an overview of the landscape for prototyping hardware projects and explain why I settled on the Tessel 2 as my micro controller of choice. Then I'll describe the process I went through to build the prototype, including the steps I took, the challenges I faced and how I overcame them. Finally I'll show a demo of the product and discuss next steps for improving the form factor and bringing it to market.
 recording release: yes license: CC License  

15. Building Bots with Node.js on Microsoft Bot Framework
Sarah Sexton

Learn how to create your own conversational Bot and publish it online with continuous deployment. Follow me on my personal journey through downloading the tools, building a bot, publishing to Azure, registering, and watching it come to life on a web app service shared with the rest of the world. Attend this presentation to see how you can incorporate MS Bots into a new interactive conversational utility for the next web application generation.
 recording release: yes license: CC License  

16. Universal Apps: Lessons from the trenches
Jonathan Creamer

There's no question that Universal Apps are one of the most widely talked about ways of building modern web applications. There are countless starter kits, boilerplates, generators, etc etc, so trying to pick and choose what to use in your own Universal App is a daunting task. Most every kit starts with React at the bottom, but from there where do you go?! So many options is both a blessing and a curse for the modern web developer. How to manage application state? Container components? Client side routing? Back end tools? Babel? Typescript? OMG. 

Thankfully after months of researching and building, this talk will cover many lessons learned on the best ways to get started building Universal Apps. How to manage state with redux, how to set up your back end with express to render React on the server, as well many pro tips picked up along the way.
 recording release: yes license: CC License  

17. Dockerized Node Application Pipeline. Docker/Drone/Rancher Oh My!
Jason Greathouse

How LeanKit uses Docker to build, test, deploy, promote and run our Node Microservices.

I will show some of the tools we use to quickly deploy and sanely manage microservices in dozens of environments.

A walk through of our application pipeline
* Code commit to GitHub
* Drone CI build
* Publish to Docker Hub and Rancher-Catalog
* Deployment to Dev in Rancher
* Promotion to Stage, and Production

Followed up by quick tour of some of Rancher and some of it's features that we use to make this manageable 
* Rancher-Catalog
* Rancher metadata for service-discovery

 recording release: yes license: CC License  

18. Get started with ClojureScript  and Reagent!
Colby DeHart

ClojureScript is a dynamic, functional, modern language that targets JavaScript. Reagent is a lightweight ClojureScript wrapper for React which allows you to write web applications easily. Because concurrency and immutability are baked into ClojureScript, representing and manipulating data is fun and easy. Attendees will be walked through the basic syntax of Clojure, basic types, how to declare variables and functions, a few built-in functions like `inc`, `map`, and `conj`,  basics of functional programming in lisp, and how to create Reagent components. Then we will walk through managing state with Reagent's `atom`, and finally finish up by creating a fully functioning example of a multi-timer! JavaScript and React experience is suggested, but not required.

 recording release: yes license: CC License  

19. Graph Databases Will Change Your Freakin Life
Ed Finkler

# Graph Databases Will Change Your Freakin Life

## WTF is a graph database
- Euler and Graph Theory
- Math -- it's hard, let's skip it
- It's about data -- lots of it
- But let's zoom in and look at the basics
## Relational model vs graph model
- How do we represent THINGS in DBs
- Relational vs Graph
- Nodes and Relationships
## Why use a graph over a relational DB or other NoSQL?
- Very simple compared to RDBMS, and much more flexible
	- The real power is in relationship-focused data (most NoSQL dbs don't treat relationships as first-order)
		- As related-ness and amount of data increases, so does advantage of Graph DBs
	- Much closer to our whiteboard model
	- Answering questions you didn't expect


## Let's look at some examples
* A bit o' live code
* Based on OSMI mental health in tech survey graph

## How do we use this from a programming lang?
* Neo4j 3.x uses a RESTful API and a native protocol (BOLT)
	* All client libraries are wrappers for this
	* Show a couple code examples with popular wrappers

## Resources
* Graph Story
* OSMI Graph Blog
* Neo4j docs

# More Resources
- http://neo4j.com/blog/7-ways-data-is-graph/
 recording release: yes license: CC License  

20. Arts and Sciences: Programming Music on the Web
Calvin Bottoms

On April 16, 1975, at one of the first meetings of the famous Homebrew Computer Club in Palo Alto, California, Steve Dompier showed off a program on his Altair 8800 that played “Fool on the Hill” on an AM radio. Thus was born the art of home computer music. In this talk we will take a look at some of the tools currently available for coding music as well as a little history to see how we got here. We will walk through the process of developing a single-page app that will take some music markup, score it visually, and play it via MIDI, possibly with animated visualization. The tool stack will include ES2015, React, Node, Express, and Chrome’s implementation of the Web MIDI API.
 recording release: yes license: CC License  

21. The story of redux-logic, a new approach to organizing business logic with Redux
Jeff Barczewski

Like many of you, I was searching for the best way to build my JavaScript applications. How do I structure my code properly so my app can grow without being boxed in? I started experimenting to find the best approach to use for my Redux apps. There seemed to be a good sized gap between my ideal goals and the way others were doing things.

Was I doing things wrong or just misunderstanding the ideas? I explored further by reading blog articles, questions and answer forums, github issues trying to gain all the knowledge I could. It seemed like I was still missing something. The solutions people were leading me to were either lacking in capabilities or the resulting code was much too complex for my liking.

I wanted things to be simple and straight-forward so that any of my teammates could easily pick things up, understand, and be comfortable working with it. How could these solutions be the recommended ways to structure my code? Is there a better way?

After finally grasping the essence of what I was looking for and taking inspiration from existing projects, I set out to build that small focused library. I wanted to see if it might be possible. It seemed reasonable on paper, but would it work?

I share all the highlights of my journey and explain the simple inner workings of redux-logic. Everyone who attends will come out with a better understanding of business logic and how to apply it in Redux.

 recording release: yes license: CC License  

22. Exploring TypeScript
James Churchill

TypeScript, introduced by Microsoft in October 2012, is a strict superset of JavaScript that adds optional static typing and ES2015/++ language features such as classes, modules, arrow functions, decorators, async/await, and more. TypeScript’s static typing allows tooling to provide richer support for features such as symbol-based navigation, statement completion, and code refactoring. All of this together helps ease the development of JavaScript applications.

In this talk, we’ll start with a brief history of TypeScript followed by a series of interactive demos that will show you the basics of the language. We’ll also see how popular editors like GitHub’s Atom and Microsoft’s Visual Studio Code provide support for working with TypeScript.
 recording release: yes license: CC License  

23. This Is NativeScript
Burke Holland

[ Camera opens on Leonidas who has recovered from his death in the movie The 300 and is now a JavaScript developer. His greatest challenge is yet to come - he has been tasked with building a native mobile application ]

Native Developer - "Listen carefully developer: in order to build a truly native mobile application, you need to learn native languages. All these languages require is that you learn each and every one of them. A token of your submission."

Leonidas - "Submission. Well, that's bit of a problem. Also, NativeScript allows you to build truly native mobile apps with just JavaScript. Cross-platform as well."

Native Developer - "You're mad! No man! No man builds native mobile apps with JavaScript and no web view!"

Leonidas - "Madness... THIS. IS. NATIVESCRIPT."

Native Developer - “Whoa. Settle down. That meme is getting really old you know."

Leonidas - “Sorry, I got a little worked up. Let me show you how NativeScript lets you build truly native apps with JavaScript, but without being confined to a web view."

Native Developer - "Sweet! Let's sit right here on the edge of this bottomless pit and you can tell me all about it."


 recording release: yes license: CC License  

24. Public Speaking without Barfing on Your Shoes
David Neal

Sooner or later, we are called on to speak. Out loud. In front of an audience. We may have to present something to our team, our leadership, or even a larger group of (--gulp--) mostly strangers. Public speaking strikes fear into the hearts of nearly everyone... especially those of us who are very shy. Imagining people in their underwear does not help.

I have been speaking at conferences, user groups, and meetups for many years. However, as a shy introvert, this is not something that comes natural to me! If I can do it, so can you! In this fun and light-hearted talk, I want to share with you what I have learned from my hard-won experience. Introverts and extroverts alike will walk away with practical tips on preparing and giving effective presentations.
 recording release: yes license: CC License  

25. Beyond The Tab: Executing JavaScript Across Browser Contexts
Andrew Dunkman

Keeping JavaScript from interfering across tabs is great and all, but what about when a web application wants to share state without involving a server? This talk will cover both older as well as emerging web standards to share JavaScript context — between tabs directly and through background threads that are natively supported by browsers (SharedWorker and ServiceWorker). You’ll leave with enough knowledge to get started and enough wisdom to know when to use these tools.
 recording release: yes license: CC License  

26. Premature Optimization: Building in Scaling The Right Way Before You Scale
Jacques Woodcock

OOP, MVC, MVVM, microservices, single page apps, Docker and so much more. With all the focus on properly designed apps it can be hard to tell when you're setting up good patterns or just over optimizing. Let's talk about some optimizations that save time from the start.

This talk is based on many years of experience of doing projects of varies sizes, and the commonalities between the small and the big, all which helped me to lead a time to create a platform that is combustable to handle thousands of requests a minute. 

Some things we'll cover are:

- Dev-Ops optimizations
- Release flow optimizations
- Dependency management
- Config management
- Project Structure 
- Platform thinking vs App thinking
- Services and when to use them

You should leave with some good ideas and ways to tell if you're optimizing prematurely or if you're setting up a foundation for rapid development. 
 recording release: yes license: CC License  

27. Reasonable JavaScript
Preethi Kasireddy

In this talk, we’ll look at why JavaScript's versatility and easy of use makes it hard sometimes to write code that is easy to reason about. We’ll then delve into a specific set of methodologies and tools we can use to make our JavaScript code safer, more reliable and more predictable. With a little effort, it becomes infinitely possible to write JavaScript code that is easy to reason about.
 recording release: yes license: CC License  

28. The Accidental Noder
C J Silverio

How I tried to make a slow thing in my side project faster, accidentally learned node, and then accidentally ended up running engineering for the largest package manager on the planet, and what I learned along the way about javascript, programming, modularity, operations, and enabling all of you to write javascript while having ALL THE FUN.
 recording release: yes license: CC License  

29. npm run build
Ben Monro

This talk will cover the ins and outs of building a javascript project using nothing but npm & bash.  No gulp or grunt at all.  I'll cover linting, mocha tests, babel, webpack and more.  I'll also cover how to use npm for versioning, deployment, publishing to npm, dependency management.  I've been using npm and node for over 3 years and have worked with and without grunt/gulp and I'm MUCH happier with just plain old npm & bash as it is easier to maintain and follow.
 recording release: yes license: CC License  

30. From community manager to developer — my path to becoming an engineer.
christina keelan

TBD
 recording release: yes license: CC License  

31. 12 Reasons I Still Choose Ember.js
Ryan Tablada

Choosing a front-end framework can be a difficult and weighted decision. It is hard to see the viability of how it will effect your team and product over a long lived project. In this talk, I look back at how Ember.js unlocked awesome potential and productivity over the last three years and look into the future of the framework: highlighting how Ember.js has been a win for developers from junior to senior and even QA.
 recording release: yes license: CC License  

32. Jumpstarting Selenium Testing in Your Organization with Javascript, WebdriverIO & Cucumber
Josh Cypher

With modern software development moving at a rapid pace, automation engineers may find it difficult to keep up with frequent changes. But if parts of the testing process are incorporated into everyone's workflow, this creates the potential for automated testing to mirror software delivery.

My goal is to make software testing more accessible to entire product and engineering teams by providing familiar tools that allow individuals to easily contribute to the automation process.

For this talk, I will explore how we can meet developers halfway by using the javascript-based testing framework WebdriverIO, demonstrate how product managers can create living documentation and test cases using Cucumber, and talk about sharing page objects and testing libraries across multiple services using NPM.
 recording release: yes license: CC License  

33. Generating a new async workflow... with generators!
Jordan Kasper

Chrome, Firefox, Node - even Microsoft Edge - all of these have added basic support for generators, but this area of JavaScript is still shrouded in mystery and inexperience. Generators allow developers to write functions which can be paused and resumed at will. When used well, this can create much simpler asynchronous workflows and avoid callback hell without the need for complex structures such as Promises. In this session we'll dive into generators and the 'yield' keyword to show attendees what they are, and more importantly why they should care! We'll look at some use cases and see just how these structures can be used to solve problems. Coming out of this session, developers will have a greater understanding of this new feature in ES6/2015 and what's coming next!
 recording release: yes license: CC License  

34. Innovating is not about technology, but psychology.
Alyssa Nicoll

> "It is the recognition that well-read is not a destination, there is nowhere to get to and if there was somewhere to get to, you would need a thousand years to even think about getting there." -Linda Holmes

Many people strive to be “well-read” as developers or designers, they want to know & do it all. But why? All in the name of being “well-read”? All just to say “Yeah — I've done that”?

Why do we do what we do? Why do we try so hard? Why are we here, paying to be here, to listen to people talk? Maybe because we’re life long learners - we want to learn new things? Commune with our own kind? But why? Come examine our motives as developers, the pitfalls we fall into, and the cost of being great.
 recording release: yes license: CC License  

35. Responding to a Third Dimension!
Rebecca Poulson

Implementing interfaces in three dimensional space is the next great challenge for responsive design. This talk will start with an intro to the WebVR API and an overview of the current state of VR running in the browser. Then we'll dive into a discussion of example VR UIs. VR projects aren't meant to be viewed from one angle, so why should their interfaces be? Attendees will leave with a firm grasp of the possibilities and challenges faced while working on VR UIs as well as knowledge of tools and processes to get them up and running in this exciting domain.
 recording release: yes license: CC License  

36. Microservices! Containers! Node.js!
Wyatt Preul

(Needs description.) 
 recording release: yes license: CC License  

37.