7:30am - 9:00am


9:00am - 9:15am

Opening and Announcements

9:30am - 10:15am

Designing Code

Matt Clough (Mobelux)
Blue Ridge AB

It can be daunting to start putting code to editor for software of any size, whether it's an entire project or a single function, and it's easy to get overwhelmed or hopelessly mired in a never-ending pit of dependencies, and sometimes the finished product ends up feeling like a disappointment when viewed alongside your original vision. So what goes into writing good software, and where does one even start? A popular mantra in writing is to start at the end, and code-among other things-is no different. In this talk we'll explore why coding is creative, how code can be "designed", and some techniques for actually designing code to try to eliminate frustrating obstacles and make your vision a reality.

Technical Debt in Space

Jesse Warden (Capital One)
Blue Ridge C


Building software that works in the real world is hard. Making it work in space in reasonable time frame is harder. Come learn about the history of software development for spacefaring vehicles, specifically all the things that went wrong and what we learned from those failures.


Software is hard. Things can wear on the soul after awhile and make question why are you even trying. Having context around what it took to build space rockets can make you feel a lot better about yourself, and the industry. It also helps frame that what you are working on may not be as catastrophic if you have a bug which helps you relax more.


Some of the most advanced software engineering takes place in enabling rockets, spacecraft, and satellites to work. The failures in such work are expensive and deadly, while the successes are history changing. Since the 1950's, software has powered the various space programs in the US and Europe. The inventions and ideas and failures have helped shape the ideal software development practices and methods today. Some we do, some we don't.

We'll cover 5 US missions and 1 Europeon mission that had horrible failures in software. What the mission was attempting to do, how & why it failed, and what we learned.


Apollo 11, sending men to the moon to walk on it, then return them safely, ran into software problems during landing. How did it not crash?

Mariner 1 was a Venus fly by sattelite that blew up on the rocket 2 minutes after take off. Why did it have eratic flight patterns after copious testing?

Saturn V was the main rocket to carry men and equipment off earth and to the moon, but was insanely complex to build for the time period. How did it get built so fast yet to screw up?

Mars Climate Orbiter flew too close to Mars' atmosphere and disintegrated. It made it all the way the Mars, why did it then crash?

Ariane 5's maiden flight ended in eratic flight over the water vs. space and blew up. It was a 5th version of an amazing rocket, why did it fail so spectaculary?

Space Shuttle Challenger on it's 10th flight broke apart 73 seconds into its flight, killing all seven crew members. Why did we do to prevent such horrible incident from happening again?

E2E Testing with Cypress

Don Denoncourt (Simple Thread)
Blue Ridge DE

Introducing Cypress, a game changing user interface and acceptance testing tool
Cypress supplants clunky tools like PhantomJS, Selenium, and Protractor.
Cypress is free for open source projects and many of its tools are open source with constant improvements in its roadmap
Cypress runs in the browser. It is a JavaScript-based simple syntax that is RSpec-like.
Watch Don as he installs Cypress and begins writing tests in under 5 minutes
View demos on cool features like:
stubs and fixtures
form submission and AJAX request waits
video recordings with snapshots of each test
two modes: interactive console and headless
everything runs as 'promises', which removes asynchronous issues common with JavaScript development
See an Overview of Cypress's simple RSpec-like syntax
Structure: describe, context, it
Assertions: should, expect
Hooks: before, after, beforeEach, afterEach
Development: skip, only
See how Cypress works with Continuous Integration services
Listen to proven Rails testing strategies
And, finally, receive quick-start tips

10:30am - 11:15am

Learn Redux by writing redux

Matt Crowder (Walmart Labs)
Blue Ridge AB

Attendees of this presentation will learn how to write their own global state management library (redux), which will then help them understand how redux works and how they can use it. We will write a third party middleware library (redux thunk), higher-order-components (HOC) that connect to the redux store, a way to subscribe to the redux store via componentDidMount, a way to unsubscribe from the redux store via componentWillUnmount, and ensuring that no unnecessary re-renders occur via shouldComponentUpdate, a React context provider, and a React context consumer (the HOC).

Serverless Javascript

Meggie Ladlow (United Income)
Blue Ridge C

In this talk I will begin by discussing what a serverless application is, how it differs from a traditional hosting model, and how it differs from running your application from a cloud server like EC2 (don't have to worry about keeping your OS/OS packages up to date, save money by having your code only run when needed, etc).

I'll continue with a case study how my company has deployed our application to AWS Lambda using the Serverless library. I'd also like to present some alternatives to the Serverless library. The case study will cover not only the initial deployment, but also how we later re-deployed our application to a new AWS account in a new region, and how easy it was to get everything online.

Key takeaways from the case study will be the components of a serverless application that I think are most important (build pipeline, deployment scripts), as well as how flexible serverless applications are - you can use them on any major cloud provider.

Testing microservices in Node.js

Justin Bachorik (Capital One)
Blue Ridge DE

Microservice architecture is becoming an increasingly popular choice among platform architects, and for good reason: when implemented correctly, it can increase team velocity, facilitate technological diversity, and enforce good abstractions. However, writing good tests for a microservice-based platform is often a tough task, due to the complexity of the interactions between services and of the system as a whole.

In this talk, Justin will present an introduction to microservice architecture, as well as an overview of the various types of automated test suites and their place in conventional application development. He will then discuss the role of each type of test in the context of microservice-based systems, and will close with a number of recommendations for writing efficient and effective tests. Along the way, Justin will highlight various JavaScript tools that are helpful when writing tests for Node.js applications and microservices.

11:30am - 12:15pm

Handling Angular 2+ Forms Without Losing Your Sanity

Jennifer Wadella (Kansas City Women in Technology)
Blue Ridge AB

"Why'd you have to go and make things so complicated?" - Avril Lavigne, implementing Angular 2 forms in 2018

Forms are such a basic part of web applications; how did they get so complicated? This talk will walk through Angular 2+ template driven vs. reactive forms and use cases for their implementation, basic & more complex form-validation, & custom component implementations like typeahead and date-pickers. This talk will also include some useful workarounds for those more complex PITA requirements that always seem to pop up in projects.

The Need For Speed: Measuring Latency in Single-Page Applications

Jordan Hawker (Twitch)
Blue Ridge C

This talk will introduce the hurdles of application performance measurement and why this topic is important. We'll compare & contrast multiple options, pointing out the pitfalls along the way. Finally, we'll touch on how to implement latency tracking using real-world applications and leave the audience with the tools to confidently gather the data they need to optimize their applications.

JavaScript Tests in Node, the Browser, and CI

Rob Richardson
Blue Ridge DE

Good software practices don't end just because you're building a thick client in the browser. The JavaScript community is a flourishing boutique of high-quality tools and techniques. We'll dig into some of the more popular open-source JavaScript patterns that have emerged from the Node community. We'll see mocha, chai, karma, phantom, and travis in action, look at some great techniques and patterns for browser development, and brush up on things that make JavaScript a phenomenal place to work.

12:30pm - 2:00pm

Lunch and Networking

2:15pm - 3:00pm

Data Visualisation with Vue.js

Callum Macrae (SamKnows)
Blue Ridge AB

Vue.js is the latest big front-end framework. It's blazingly fast, easy to learn, and a valuable tool to have in your arsenal. This talk will introduce Vue.js using a real life example: some basic SVG manipulation and data visualisation without using a library like d3 or Highcharts.

Meaningful performance metrics

Joshua Nelson (Atlassian)
Blue Ridge C

If you can't measure it, you can't improve it. But measuring load time is easy, right? "Load time" is now an outdated concept, as single page apps and rich progressive web app experiences take over the web.

We need better metrics to measure what our users are really feeling when they use our sites. Meaningful first paint is good, but how important is the first paint of many? And what is meaningful? I will introduce the state of the art performance metrics, and some new concepts that have worked for Atlassian, and how these tools have helped us improve our performance over time.

I will cover first meaningful paint, APDEX, and provide some guidance to the fuzzy areas, including "what is meaningful?" and all the variance that comes with caching and "warm" page transitions.

JavaScript Survival Skills

Becca Nelson (8th Light)
Blue Ridge DE

New technology fatigue is real.

In my first year and a half as a software consultant, I have worked on projects in Backbone, Angular 2, React, and Vue.js-and that's just the JavaScript frameworks. I have worked on front-end code and back-end code with dozens of different testing frameworks, libraries, and build tools. Needless to say, I am exhausted.

I know I am not alone in this, because the JavaScript world is always changing. Life as a perpetual beginner is both exciting and daunting, and it can supercharge imposter syndrome, especially for those of us who are new to the industry. In order to save us all, I have explored a few strategies for surviving the world of front-end development as a consultant, a beginner, or a frequent context-switcher. Let's talk about some of the pros and cons of micro architecture, web components, and framework-agnostic design patterns.

3:15pm - 4:00pm

The how's and why's of flexible React components

Jenn Creighton (ClassPass)
Blue Ridge AB

"Building React components is simple - until it isn't. Real world constraints can lead to large components that 'do it all'. Or near identical components with one or two changes. So how do we create flexible components without sacrificing readability and scalability? Jenn shares how she re-architected components to handle multiple use cases and increase engineer happiness. She'll breakdown the technical concerns for each component, the patterns she considered using, what didn't work and what did. You'll learn more than the "how" of component architecture -- you'll learn the "why"!

You'll get the most out of this session if you've written React components before. But even if you haven't, you'll walk away with practical patterns, tips and tricks for the future."

Outrun the 🐻! Performance Optimizations for Progressive Web Apps

Chris Lorenzo (Comcast)
Blue Ridge C

Struggling to get your website to load in less than 5 seconds on a mobile phone? Switching pages are a little sluggish? You’re not alone! Most web developers can build a responsive site, but fail to meet performance requirements for mobile. Using the latest PRPL pattern and Progressive Web API’s, you can provide a compelling alternative to native apps, as long as performance remains your top feature.

This talk will cover the architecture for Xfinity xFi, an enterprise PWA for Comcast, built with Google Polymer. We’ll then dive into the Chrome performance tools to optimize xFi loading time down by more than half. You’ll walk away knowing what it takes to create a successful PWA and how to find slow downs in your app startup.

Dr Iterate or: How I Learned to Stop Worrying and Love Higher-Order Functions

Tim Roberts (CircleCI)
Blue Ridge DE

_**The journey of a thousand miles begins with one step**_

Functional programming seems to be the coming paradigm for building software and for good reason. Stateless functions produce less bugs and help build modular, reusable code. But making the switch from OOP to functional can be a daunting task. Monads? Functors? Category Theory? What do any of these words mean and how can you actively apply them to the code-base you are currently working on or the project your team is starting?

The easiest way to get your feet wet into functional programming in JavaScript is the use of higher-order functions (reduce, filter, map, etc). From the basics of what the syntax is and how it is different than forEach to the power of stateless, composable functions, learning how and why to use higher-order functions will speed up the transition from OOP to functional. Learn how to use and chain together higher-order functions, building uber-microservices, refactoring along the way.

4:15pm - 5:00pm

UX for Developers

John Athayde (CargoSense, Inc. / Meticulous, LLC)
Blue Ridge AB

The goal of this talk is to give developers five solid techniques and concepts that they can implement as soon as they return to work. We'll start with a very quick level set of what "design" is and why the standard "designers hand off to developers" workflow is a mess. We'll then move on to discussing problem analysis and definition, sketching/crazy eights/six-ups, prototyping, user testing, and finally components and living style guides.

Build Chatbots People Actually Want to Use

Michael Szul (University of Virginia, School of Medicine)
Blue Ridge C

It's easy to build a bot; it's hard to build a useful bot. Chatbots have been circulating the buzzword bins for the last two years, and a day doesn't go by where you don't hear about some new chatbot being launched to support customers or processes. Now look at your phone. How many chatbots are you using? Go ahead. I'll wait. With chatbots, you can easily build a novelty, but without a clear plan and intuitive design, you might build something that works, but that nobody wants to use.

In this talk, we'll discuss what it takes to build a useful and compelling chatbot in JavaScript using the Bot Framework Node.JS SDK. We'll also discuss chatbot design, and some of the Node.JS tooling available for prototyping bots before you build them. We will then go over a "useful" chatbot application, and how it was built from end-to-end.

Async/Await Armageddon!

Bob Larrick (Demyst Data)
Blue Ridge DE

The asynchronous execution model of Javascript is notoriously difficult to get used to. Callbacks and Promises are not intuitive and we have all made silly mistakes trying to do things that should be simple. Even programmers with deep experience in other languages have been humbled by the strange and fearsome ways of Javascript.

Async/Await gives you the super-power of executing code synchronously in an asynchronous world. It is easy to use, available everywhere, and makes your code easy to read and reason about. If you are not already using Async/Await do yourself a favor and come learn how this simple and powerful technique can make your life better today!