Our Sessions
Opening Remarks Thursday 8:00
Thursday 8:30
Where The Web Is Going
Room 2201

The web is a strange place with many standards and browser vendors that all have to come together to make something useful. This talk looks at what's next for web technologies including ECMAScript 2016, Service Workers, the Fetch API and HTTP/2. It then looks at how these standards come about and which groups set the direction. We'll discuss how the W3C, WHATWG, ECMA TC39, and IETF work together (or don't) to push the Web forward. You'll leave this talk better prepared for the web of tomorrow.

Tools and Strategies for Consuming APIs
Room 2202

Consuming APIs for web applications has become an essential skill set as the number and variety of available APIs increase. They offer opportunity to add value and functionality to our applications for which we do not have the expertise or time to build ourselves. Here, we explore different types of APIs and tools for working with each. We will look at helpful techniques and strategies for coding, logging and troubleshooting the integration of APIs. If you have never consumed APIs, this talk will give you what you need to get started. If you are already doing so, walk away with some new tips to make it easier. Code examples are in C#.

A #NoEstimates Playbook For Teams and Their Customers
Room 2203

Why use #NoEstimates? To provide better predictability, of course! So how does a software development team get started with using a “No Estimates” approach without scaring all the stakeholders away?

We will explore both the social and statistical reasons for the #NoEstimates movement. And then we will detail the necessary data and team discipline to employ a #NoEstimates approach to your team’s Agile planning.

Learning Outcomes: How to plan with yesterday’s weather. Focusing on the Why and the What improves customer collaboration. Creating options for your customer reduces the risk of uncertainty.

Simple Java Security with Apache Shiro
Room 2204

Apache Shiro is a powerful and easy-to-use Java security framework that performs authentication, authorization, cryptography, and session management.

This talk will provide a basic overview of how to secure an application using Apache Shiro and discuss the more common touch points such as: configuration, protecting paths/routes in web applications, using permissions vs roles, and integrating with a custom authentication source.

A Practical Approach to Using Graph Databases and Analytics
Room 2205

While graph databases have become a standard for social networking and recommendation engines, the practical use of graphs in other areas beyond consumer applications is rapidly growing. In this presentation with the support of case studies, we will explore how graph databases can applied to other verticals, such as logistics and healthcare, as well as a look at where graphs can leverage other data systems. The presentation will also cover the role of graphs in going beyond predictive analytics to providing prescriptive analytics incorporating decision and effects data.

Automate Your Life - Build a Bot Today
Room 2206

A chatbot can be a digital assistant, an automated service rep, an order taker, or even a chatty friend. If you need to simplify personal interactions, a chatbot can help. Chatbots are increasingly being used to manage complicated interactions, responding to texts, slack, twitter and many more. With the Microsoft Bot Framework, making your own bot is easy. In this session, we’ll look at what a bot is, how it works, and how to create your own.

What is Machine Learning?
Room 2207

Our lives are influenced by data and algorithms more than most of us realize. Movie and product recommendations, speech recognition, spam filtering, fraud detection, medical diagnoses, and even autonomous vehicles are all powered by machine learning, a subfield of computer science dealing with pattern recognition and artificial intelligence.

This session will introduce you to the field of machine learning and explain basic concepts such as supervised and unsupervised learning. It will also provide an overview of basic types of machine learning problems such as regression, classification, and clustering.

We'll cover one concrete example, which has become the "hello world" problem of machine learning: We'll train a neural network to recognize handwriting using the MNIST handwritten digit database. We'll leave out most of the math and focus on how machine learning works conceptually.

You'll come away with a basic understanding of what machine learning is and enough of an idea of how it works to decide if you want to learn more.

Taking a Gamble on F# : Implementing Blackjack
Room 2208

Have you heard a lot about about functional programming, and aren’t sure how to get started? Have you tried learning the concepts, but still having a hard time applying them to a real problem? Then this talk is for you!

In this presentation I’ll walk you through how to model the classic card game, Blackjack, using F#. Intended for developers with little to no functional experience, my talk will introduce you to the basic concepts of functional programming while applying them to Blackjack. By the end of the presentation, you’ll know the basic concepts and when to apply them.

Docker From The Ground Up
Room 2209

Docker is everywhere these days, but that doesn’t mean you’ve had time to sit down, dig in, and really understand it. If you’re still not clear on what containers are and what makes them so compelling, this presentation is for you. We’ll start from the beginning with some history on how containers were developed. I’ll draw clear distinctions between virtualization and containerization, and explain how they’re similar and why they’re different. I’ll then quickly move on to some practical exercises you can use to get familiar with Docker and start experimenting on your own. Attendees will quickly develop an understanding of what containers are, what Docker is, and how they can use containers for both software delivery and infrastructure.

“I can’t work on my phone” - desktop all the things
Room 2210

The web platform gets stronger every month. Bluetooth, offline capability and even virtual reality are coming into our browsers.

Does this mean that we don't need desktop apps anymore?

No, a big trend is happening in parallel. A new go-to platform to build desktop applications entered the stage – Electron.

Everything in Electron is built with HTML, CSS and JavaScript. Now frontend developers build almost everything with it. From small tiny apps solving everyday problems to full fledged IDEs – developers build tools for the environment they spend at least eight hours a day in: the desktop.

Let's have a look at how this works and what it takes to build a desktop app.

The Psychology of Developer Tool Usability
Room 2211

Have you ever watched the moon rise on the horizon and thought, "Wow! I've never seen the moon so big!" Sorry to tell you, but the moon isn't actually bigger. The moon has the same physical size the entire time in the sky, even on the horizon. What you are experiencing is a type of ocular illusion called the moon illusion. Google it!

Just like the moon illusion, there are other psychological traps we developers need to be aware of when writing dev tools. For example, color does not exist. There is no consensus what "red" actually looks like, because there's no way to compare our subjective experiences of what we actually see when the "red" wavelength hits our eyes. This is not a talk on proper UX design. What this talk will cover is what goes wrong cognitively when we try to design our own tools.

In 2015 I received my Masters degree in Human Factors (UX), where I built a Kinect application to study motor learning for a kinesiology professor. I was shocked to discover the usability issues in my own project's design, considering I had studied UX for the past 3 years. Based on this feedback, I hypothesized that developer tools have usability issues because we eventually convince ourselves at the subconscious level our design is correct because it is the ideal way for us to test the tools. We think "this design is the ideal way to use my framework!" But in reality, this design is really the ideal way for us to test our own UI or code.

This talk will cover the following psychological traps:

• Expecting users to see what is actually on the screen (i.e. perception vs sensation)
• Believing color actually exists in the world
• Assuming users will take care of any cleanup tasks (and it has nothing to do with laziness)
• Relying on user recall 
• Thinking all user errors are mistakes (there are 3 types of human error. Mistakes is just one type.)
• Being unaware of your own implicit knowledge bias
• Avoiding forcing functions 
• and more!

This talk will also offer suggestions to avoid falling into each of these psychological traps.

A Whirlwind Tour of Xamarin
Room 2214

Xamarin allows C# and F# developers to target multiple platforms with the language and tools they love. Whether you’re looking to build cross-platform mobile applications targeting iOS and Android or if you are hoping to build the next great Mac application, Xamarin has you covered. In this session, I’ll briefly cover where Xamarin came from (believe it or not it has been around since 2009!) and where it’s heading before launching into a tour of its features and workflows. I’ll show you how to use Xamarin Studio and Visual Studio to build iOS and Android applications. You’ll leave with enough knowledge to decide for yourself (or convince your boss!) that Xamarin is right for your project. Now that Microsoft has acquired Xamarin there’s no better time to learn this exciting technology.

Building Powerful Applications with AngularJS 2 and TypeScript
Room 2215A

Angular 2 is a JavaScript framework that helps you build rich, interactive Single Page Applications.

This presentation will cover the basics of Angular 2 and the advantages of TypeScript - a language that adds features to JavaScript, including strong typing. You will learn about data binding, event binding, routing, and observables.

Demos are a large part of this presentation.

Being a Cupcake in a Doughnut World: Understanding and Combating Bias
Room 2215B

Have you ever felt like you’re a cupcake in a doughnut world because everyone around you seems nice but you feel out of place for some reason. Or, do you feel like you’re a good person who is unaware of the negative ways that you affect people? Do you want to be better about creating an inclusive workplace?

Unconscious biases affect our perceptions, decisions, and interactions every day. They’re the biases that we don’t actively realize that we have. How do we address biases if we don’t know about them? YouTube, Snapchat, Facebook, and Google have all released products that were unintentionally biased – what can you do to prevent your team from doing the same thing?

This talk will give you a common vocabulary so you can speak to others about bias as well as recognize situations where bias occurs beyond sexism and racism to include invisible illnesses, religion, weight, etc. You’ll learn the consequences of bias, and how you can be more aware of all the bias around you that affect your team dynamics and affect the product that you are creating. We’ll discuss concrete examples of how can change the way you act today to actively work towards countering bias, and hopefully together we can make the tech world a better place to work!

What's Awesome in C# 7 and Visual Studio 2017
Room 2215C

Tired of those boring What's "new" in this or that talks? Me too. Sure, the AWESOME things we'll cover here are new, but they're more than just new - they're going to make you a more productive programmer. How cool is that? In this session, we'll dig in to the things that make C# 7 the best version of the language yet, and examine some of the features in Visual Studio 2017 that you won't know how you lived without.

Thursday 9:45
The Modlet Pattern: A better way to organize your front-end code
Room 2201

Modules, components, micro-services… all the modern trends in web development are about breaking things up into encapsulated, self-contained units of functionality, and there are great reasons for this: it helps simplify your mental models, makes things easier to maintain and eases future evolution of the system.

Yet when it comes to our code organization, many projects still organize their files and directories based on file type. What about “componentizing” our source files? Learn about The Modlet Pattern, a dead simple idea about co-locating related files, that has huge benefits, along with tools that support the pattern.

Continuously Delivering Infrastructure with Terraform and Packer
Room 2202

In this talk Paul will demonstrate how to use HashiCorp's Packer and Terraform to setup continuous delivery in everyone's favorite cloud environment. By the end of the session you will have learned how to setup Packer builds to create AMIs, how to use Terraform to deploy your AMIs, and a bit of extra polish to make it ready for production. Following this you will be able to build a safe, controlled continuous delivery pipeline using open source tools.

Don't Refactor. Rebuild. Kinda.
Room 2203

Each and every time, the situation is the same: a big, messy codebase, few (if any) tests and many production issues. It’s no accident that, when he joined what would be the first XP team, the first thing Kent Beck said was: “Let’s scrap it!

Even with a world class team, these problems can be almost insurmountable. And we don’t usually start out with world class teams. Learning all the XP practices is hard enough without a Big Ball (of Mud) and Chain holding you back.

So maybe we should rebuild. But the Agile way: incrementally, iteratively, and with close involvement from the business.

Using examples from practice, I’ll show that:

  • We can set up a clear, loosely coupled architecture around the existing system, so we can replace parts while its running
  • We are then free to use all our modern practices for the new parts, and start Continuous Delivery from the first sprint
  • We can closely involve the business to surface the actually needed functionality, and build up Living Documentation in the process
  • We can get even an inexperienced team using and accepting practices such as TDD and ATDD quickly
What's New in Java 9?
Room 2204

Java 9 is on the horizon and will bring many new changes and features, none bigger than jigsaw, which introduces modularity to the Java. Java 9 isn't all about modularity however, plenty of other new features are coming along that will improve performance in production, help make your applications more secure, some quality of life improvements, and a couple of other cool new tools like JShell.

Azure 101
Room 2205

Microsoft's cloud offering has exploded. With all the new product offerings coming out daily, let's make sense of all the lingo and which products should be used and which ones should be avoided. We'll review the old, the new, what's in preview, what preview means, and where you want to position yourself and your company.

A Primer on Neural Networks
Room 2206

#A Primer on Neural Networks

I'm sure you've at least heard about neural networks, but maybe you wonder what exactly is a Neural Network. This talk will take you gently into the machine learning branch of statistics with neural networks. With examples and simple breakdowns about the math involved that anyone can follow.

Topics and Demos Include:

  • What is a Neural Network?
  • What makes them so powerful?
  • How are Neural Networks being used in the field?
  • What is an activation function?
  • What is Gradient Descent? ^ An Intro To Tensorflow
  • Demo: XOR Gate
  • Demo: Image Recognition

To follow along with the talk the only math you will need to know are the basics: Add, Subtract, Multiply, Divide, Average, and Sum. Everything else very easy to follow.

Data Visualization 101 - Create Reports to Impress Your Boss
Room 2207

Graphs and charts can condense a million data points onto a single screen or a single piece of paper. They can inform, they can mislead, they can tell a story. What do your reports say about your business?

In this session, we'll go over

  • The pros and cons of 11 different chart types
  • Common ways people miss important insights by aggregating data in the wrong way.
  • Eight specific things you can do to kill the junk that is obscuring your data

This session is platform agnostic. Your reports can be created with ANY software or libraries (Excel, Infragistics, HighCharts, etc) . It does not matter, all of the information will be applicable to your reports.

A Developer's Journey From OO to FP
Room 2208

Learning a new paradigm is one of the more difficult things to do in software development. So why would an object oriented developer of 10 years suddenly decide to make the drastic switch to functional programming? In this talk I’ll show you why I started looking for other ways of writing software and why the switch wasn’t as sudden or as drastic as it may seem. We’ll start our journey with C#, discussing SOLID principals and the use of IoC containers. Then we'll discuss problems with code bloat and how we can minimize them by writing code that stays on the happy path. We’ll finish up with some anecdotal results of switching to FP and some resources to help you on your journey.

Using Visual Studio Team Service for a Kickin' CI Pipeline
Room 2209

Looking to step up your DevOps game? Visual Studio Team Services (VSTS, or visualstudio.com) is a tool for teams that gives you everything you need all in one place to help manage your software process. From work item tracking to kanban boards, to private git repos, it has it all. In this session, we'll look specifically at some cool continuous integration (CI) and continuous deployment (CD) scenarios and I'll show you how to implement them in in VSTS. We'll look at building in the cloud, building for mobile, and building on-premises. We'll also look at different deployment scenarios you might face and how quickly and easily VSTS can help you.

Smaller Not Taller: Defeating the Mobile Application Architecture giant
Room 2210

Making the right decisions for a mobile project can be a very involved process of trial and error before you find a good fit. Wouldn't it be nice if you had a map? In this session we will compare frameworks and approaches based on the kind of mobile project you are doing, and walk through what the actual code looks like to accomplish basic tasks for each one. We will cover native, hybrid and mobile web approaches for enterprise-level solutions.

PHP Authentication, Lessons Learned
Room 2211

Just about every website out there has some sort of authentication. We sign into accounts everywhere, from your social media profile all the way to your bank account. Brian will share what he has learned through the years about authentication in PHP. Giving real life examples of the ugly authentication that he started with, which you may have as well, through what is now the best practices of authenticating your web applications.

Software Without Managers
Room 2214

As a middle manager in a large software company, I faced difficult organizational challenges. It’s a common problem. Peer organizations change. Company strategies change. Projects change. Projects cross department boundaries. Don’t forget that organizations are made up of people, and people dynamics are inherently complex. What is a department head to do?

Why not give up altogether and let the organization figure it out for itself? Can any single human being meaningfully solve these problems anyway? That single human being is often many steps removed from the actual problems, so wouldn’t it make more sense for the people that are next to those problems to do the solving?

Sounds like chaos, doesn’t it? It definitely could be, but what if we establish a framework to allow for orderly changes by everyone--not just managers. Holacracy is a framework that does just that.

It may sound radical, but didn’t self-governing sound radical 250 years ago? Surely self-management’s time has come. Holacracy is boot-strapped into a company when the CEO signs a “Declaration of Adoption” thereby ceding his/her authority into the Holacracy Constitution (which happens to be in GitHub). All employees fill Roles in the company, and those Roles are organized into Circles. Every Role and Circle has clearly defined purposes, accountabilities, and domains. But this is where the real magic happens: the people filling those roles get to redefine those Roles and Circles and how they are organized based on a strict Governance process defined in the Holacracy Constitution--no managers necessary!

Mylo started its journey to Holacracy at the beginning of 2017. Come and learn a little bit more about Holacracy and what we’ve learned on our implementation journey.

Deconstructing TypeScript’s Type System
Room 2215A

TypeScript isn’t just a strongly-typed replacement for JavaScript – it’s a full language with lots of modern features, including a cutting-edge type system. This awesome type system is often overlooked in favor of other features such as decorators and async/await, but is one of the best reasons to use TypeScript.

In this session, Spencer will discuss the advanced type features of TypeScript, including intersection types, type guards, nullable types, type aliases, string literals, and discriminated unions. We’ll also discuss ways to take full advantage of TypeScript’s compile-time checking to ensure your code is clean and safe.

The Developer’s Guide to Learning Effectively
Room 2215B

The ability to learn things is an essential part of the developer’s toolkit, which is only getting more important as we march into the future. New technologies and new tools are released constantly - there will probably be at least one new Javascript framework released just in the time it takes you to read this abstract. Even if you’re on a fixed tech stack on a long-running project, you need to evaluate and adapt to new versions of your tools and new software idioms as they're released. The thing is, we’re never really taught how to learn things - we’re expected to just figure it out ourselves. It is my opinion that this is Really Terrible.

If you share that opinion, do something about it by coming to this talk! We’ll cover the types of learning and how to find which ones work for you. Do you wonder how learning a new framework is different than learning best practices for that framework? We’ll discuss that, too! We’ll also talk about the neuroscience of learning, how your brain connects cause and effect, the tricks your memory plays on you, and more. By the end, you’ll hopefully have the tools you need to learn anything efficiently and effectively.

Clean Code: Homicidal Maniacs Read Code, Too!
Room 2215C

If we need a comment to explain the code, we need to rewrite the code. Think about the next developer to maintain the code. There's no such thing as a write-once application. The world is constantly changing, and our code needs to change with it. To keep code readable and maintainable, we'll use techniques such as intentional naming and method trees. Now, imagine he's a homicidal maniac who knows where you live.

Thursday 11:00
From Monolith to Microservices with NodeJS
Room 2201

Are you bogged down by a complex, monolithic web service that has taken on a life of its own? Not sure where to start untangling the spaghetti in your kitchen sink of an application? In this session, we'll break down a real example of a "macroservice" and use TDD to carve a path leading to independent, concise microservices. Our case study will convert a .NET API to a collection of NodeJS APIs. Regardless of language and platform, you'll come away with architectural approaches that can be used to chip away at some of the most daunting web service conundrums and increase the flexibility of what you can build and do in the future.

LINQPad: More than a Scratchpad
Room 2202

Wait. What? A talk on LINQPad? Isn't that just the .NET scratchpad thing? How can there be a talk on that? Well, LINQPad may often be referred to as the "Ultimate Scratchpad for C#, F#, and VB" but chances are that if you've used it you weren't using it to its full potential. LINQPad is chock full of hidden features that on their own don't amount to much but taken together can truly boost your productivity. Whether you're exploring a problem space or simply want to query some data LINQPad is a great utility and this session will help you get the most out of it by introducing important features like password management, caching, output customization, and much more.

Blending Product Thinking with Architecture
Room 2203

Too much design up front and you are bumping into the design all of the time (and losing time). Not enough design and your system can crumble in reality. How do you blend architecture so you have the right decisions at the right time, and give them enough due dilligence? How do you embrace cloud and microservices and not risk getting into different failure scenarios or overly complicated maintenance and ripple effects?

In this session we will walk through visualizations that help teams blend product thinking with architecture. Along the way, we will look at microservices and domain modeling as well as chaos engineering and fault tolerance - blending all of these into a context that is consumable by all and gives the right emphasis at the right time.

Leave this session with simple visualizations and approaches that you can apply immediately to start blending product with architecture, especially if you are looking to run in a cloud world.

Introduction to Java Web Security
Room 2204

As a developer it is your responsibility to protect your users’ passwords and data, ensure the integrity of your data, and prevent your systems from being compromised. But where do you get started?

This course looks under the covers of a simple Java web application to demonstrate Java code that implements authentication and authorization, along with defensive measures based upon the OWASP Top 10 list of security vulnerabilities.

Along the way popular libraries will be explored including:

  • Apache Shiro
  • Bouncy Castle
  • Jasypt

By the end of this session you should understand how to get started with web security in Java, know what tools are available, and be aware of resources you can use for self-study.

An Introduction to Azure Service Fabric
Room 2205

Ever wonder how Microsoft builds highly distributed services like Azure DocumentDB, Azure SQL DB, or even Cortana? Each of these services has a specialized purpose, but they share the need to be highly scalable, reliable and have extremely low latency. Azure Service Fabric is the platform under all of them, and it is purpose-built to solve exactly these challenges. More importantly, it is now available for you to build your own highly-scalable, reliable, low-latency services on top of!

Come see how Azure Service Fabric fits into the myriad of compute options offered by the Azure platform and if it is a good fit for your solutions. We'll look at how you can build either stateful, or stateless, microservices using this platform and how it differs from Azure Cloud Services.

Getting Started with VueJS
Room 2206

Creating large, monolithic SPAs is all the rage, not all solutions need a single page application. I found that improving parts of my web projects with islands of functionality was better in many cases, but the complexity of Angular and my hatred of .jsx made me yearn for a modern framework that is simple and straightforward. That’s where VueJS came in and saved the day. In this talk I’ll build a simple page using VueJS and then talk about using it is larger projects without having to use bundling and transpilers if you don’t want to.

Machine Learning with R
Room 2207

R is a very popular open-source programming language for machine learning. Its interactive programming environment and powerful data analysis capabilities make R an ideal tool for machine learning. This session will provide an introduction to the R programming language using RStudio. In addition, we will demonstrate how we can use R to train a series of machine learning models. Finally, we’ll learn how to deploy these models into production to make predictions given new data.

Let’s Get Functional with Elixir!
Room 2208

Are you intrigued about functional languages? Have you thought about checking out what’s so important about functional programming only to get scared away by the talk of lambda calculus and monads? Do you struggle to see why you’d use a functional language? This talk will cover a newer server-side functional language called Elixir. It’s designed by former Ruby developers so it has an emphasis on readability and developer satisfaction but still has the benefits of functional programming such as immutability. Additionally, Elixir excels in concurrency, which causes nightmares in some languages.

By the end of the talk, you’ll understand some of the core concepts of functional programming, as well as some of what makes Elixir unique. As a result, you’ll have a better understanding for the types of problems that functional programming can help you solve, and you’ll be ready to install Elixir and start writing code in a functional style.

"Doing DevOps" as a Politically Powerless Developer
Room 2209

DevOps. So hot right now. So hot your managers have jumped on the buzzword bandwagon and have told you to "make it happen", but also not to subvert the company change process. You can do that, right?

As tech professionals, we know you can't just exchange cash for DevOps, but how can you convince the higher-ups? Particularly when upper management won't let go of the perceived safety of a slow-moving product delivery cycle.

This talk looks at the realities of implementing DevOps in an organisation that is resistant to change. We'll discuss the levels of technical and cultural change that you absolutely need, the barriers that commonly get in the way, and some techniques to get around them. Expect subtle and possibly even underhanded tips to get things moving in an environment that just wants to use the word "DevOps" without making the necessary changes.

Mobile Development For Web Developers
Room 2210

Mobile application development does not need to be difficult for us Web Developers. No longer do we need to learn a whole slew of new programming languages to create a mobile application. We can use our existing skills and create mobile applications with Html, JavaScript, and CSS. Then deploy to Android and iOS devices using a single code base that looks, feels, and performs like a native mobile application.

Apache Cordova enables the packaging of our web code into the mobile application that we will deploy to the App Stores but it does not include a UI framework. For the UI framework, we will be using Ionic framework. The Ionic framework takes the worry out of making the UI look, feel and perform correctly on the slew different Apple and Android devices that your users will have. It allows you to focus on your business logic and not the underlying infrastructure. Your time to market will be greatly reduced.

In addition to the free, open-sourced framework, Ionic also has a slew of highly useful cloud based tools that you can pay for it you need them such as Push Notifications, User Authentication, Native Builds, and Live Updates. Push Notifications allows targeted pushes and custom scheduling to improve push notification engagements. User Authentication provides a single authentication solution with email & password authentication, as well as third-party providers like Facebook, Twitter, Google and more. Native Builds turns your code into the native app binaries for the Apple and Android with a single command. Finally, Live Updates gives you the ability to push updates and UI changes to your user immediately without going through the app stores.

In this talk we will dive into what it takes to get started, look at the features of the Ionic framework and finish off by creating a sample application with the Ionic framework. You will walk away from this talk with all of the tools that you need to deliver your first mobile application

HoloLens Mixed Reality for Fun & Profit
Room 2211

What innovations are the current generation of mixed reality devices capable of providing? Lets explore what a commercial augmented reality solution might look like using the Microsoft HoloLens and how you can get started building real business solutions.

The Importance of Selecting the Right Recruiter
Room 2214

Adaptive Solutions Group was founded on the premise that our consultants are treated as people - not commodities. Selecting the right Recruiter for your job search is an extremely important decision. With an estimated unemployment rate of less than 2% for IT professionals in Kansas City, skilled people are in high demand. When the demand pendulum outweighs supply, it can lead to a frantic pace which can adversely impact the service you are receiving and negatively impact your career search. We will walk you through the process of how to select a Recruiter that will represent you the best. We will share with you the traits of a good Recruiter and give you some ideas to think about when making your decision. This advice should help you avoid some frustrations and aide you in your career search.

Using Webpack to Streamline Modern Web Application Packaging and Deployment
Room 2215A

We will demonstrate how to get started with WebPack within the context of a modern web application and how to configure it efficiently to bundle and serve any content you need efficiently and “on demand”. This allows developers to efficiently organize their content together and easily have it sent to the server as needed by a particular area of the application.

We will demonstrate how to configure Visual Studio to efficiently work with WebPack and discuss best practices for utilizing it with modern frameworks such as Angular2 or React. Attendees will also be pointed at a number of great resources to help them better understand and utilize WebPack in their own projects.

Health: The Most Important Dev Tool
Room 2215B

Working in the tech industry often involves spending long hours sitting down, staring at a screen, consuming copious amounts of pizza and caffeine. The work is mentally demanding and can be stressful. In the rush to get everything done, it can be easy to neglect our health. But a healthy body and mind are necessary for effective performance. Based on HR training, research, and personal experience, this session provides realistic suggestions for managing your well-being at work. It covers the connection between physical and mental health, as well as how to discuss these topics with your employer. You’ll leave with a better idea of how to take care of yourself and be a happier, healthier, more productive person.

Modern day C# development in Visual Studio 2017
Room 2215C

Did you leave .NET? Maybe it’s time to see what’s been happening while you’ve been gone. In the context of a .NET Core (the new high performance, cross-platform, OSS stack) app see improvements in setup, project management, editing, refactoring, debugging, and testing using Visual Studio 2017!

Lunch 12:00 - 1:00
Thursday 1:00
Not Just My Opinion: The Psychology of Good Design
Room 2201

Have you ever heard the phrases “beauty is in the eye of the beholder” or “I like what I like” when someone is dismissing your design? Too often good designs are dismissed for aesthetic differences instead of appreciated for its intrinsic value.

Many features of good design are objective, not subjective, and can be either qualified or quantified with predictable results. Together we will delve into the psychology, physiology, and mathematics of design principles for two key purposes:

  • Validating our designs
  • Convincing others of the value and validity of our designs
Web Components: Lego bricks of the web
Room 2202

Writing the same login form over and over again? Web components offer a modular approach to creating reusable UI widgets. Ditch large, complex frameworks and drop these lightweight building blocks into your site. We will show you how to build custom elements and introduce you to the existing elements and tools available from Google’s Polymer Project.

Making the Unstable Stable - An Introduction to Testing
Room 2203

Does it always seem like bugs you’ve fixed keep coming back? Does it seem like when you fix one bug, two more crop up? What if I were to tell you there’s a better way?

In this presentation, we're going to explore how to make a code base more stable by using automated testing. To start, we'll explore the business case of why you should be writing tests by comparing three different companies that had different ideas when it came to testing and what the outcomes were. From there, we’ll look at the fundamentals of testing by talking about the pros/cons of unit, integration, and UI testing. Finally, we’ll look at some resources to learn how to write tests.

Intended for developers who are new to testing, by the end of this presentation, you will understand why you should write tests, and will have the concepts and tools to get started.

12 Factor Application Development
Room 2204

Today's modern systems have global reach, and as such public, private, and hybrid clouds are the place to deploy your applications. The issue with many of these solutions, however, is that many parts of application development that work on big iron servers are no longer in play. Limited if any file systems, distributed backing resources, and complex team locations and structures need a newer way of doing things. 12 factor applications, or cloud native applications attempt to bring agile development and cloud resources into coherence.

This presentation will focus on the twelve distinct components, workflows, and techniques for cloud based application development. It will be language agnostic, and instead focus on the principles behind the actual development.

Refactoring Towards Distributed Systems Resilience
Room 2205

It seemed like an easy feature to implement, a checkout page to place an order. But this payment gateway has a simple API, so we added that. And this email service provider makes it possible to send an email with one line of code! Finally we can notify downstream systems via a message queue. The code looks simple, 6 little lines of distributed systems code.

But those lines hid a dark secret that we only found after launching. Customers complained they didn't get their email. The back end system wasn't getting updated from our messages. And by far the worst of all, customers complained they saw an error page but still got charged!

Clearly it wasn't as easy as calling a few APIs and shipping, we actually need to worry about those other systems. In this session, we'll look at taking our 6 lines of distributed systems fail, examining the inevitable failures that arise, and possible mitigating scenarios. We'll also look at the coupling our code contains, and the ways we can address it. Finally, we'll refactor towards a truly resilient checkout process that embraces, instead of ignoring, the fallacies of distributed computing.

Demystifying CORS: It's Simpler Than You Think
Room 2206

CORS stands for Cross-Origin Resource Sharing. But what does that really mean? In short, any time a client-side application running on one site requests a resource (image, script, json file, etc) from another site, that request is cross-origin.

As web applications become more complex, a growing percentage of traffic between sites stems from one CORS request or another. Almost any developer working today has dealt with CORS at some point, or will in the future. In many cases, CORS “just works” without any thought from the developer. But in more complex cases, it’s easy to fall into the trap of copying a server config or chunk of JavaScript without truly understanding the interaction between the client and server.

This session is intended to help developers understand exactly what CORS is and how it works. We’ll talk about some reasons that CORS is a crucial part of the modern web, what it enables, and some things that it can’t do. Ultimately, we want to pull back the curtain and reveal the truth behind CORS. It is a simple, powerful tool that helps developers build better and more robust applications.

MongoDB Aggregation like a Champ!
Room 2207

This session is all about the aggregation framework in MongoDB. It explains the pipeline architecture, major operators and how to put it all together. Also covered will be new operators in MongoDB 3.2 , and what to do about joins! If you are still exporting data just to do dig into your data or do aggregation, there’s a much better way!

SEO for Developers
Room 2208

You built a great website! Your stakeholders love it! Fast forward a month and now the people who were singing your praises are complaining that there's no traffic and no one can find the site. What do you do? How do Google rankings even work? Search Engine Optimization (SEO) starts with some basic principles that can be built into the website from the beginning. Come learn basic tips that will give you a leg up on your competitors and drive traffic to your site.

Building for Alexa with Web API
Room 2209

Amazon Echo, Amazon Tap and Echo Dot have brought voice interfaces to life for the home. We will discuss ways to integrate your existing software or database into an Alexa Skill, allowing for voice-activated, meaningful interaction with a user. Using this SAAS approach, with Web API hosted on Azure can make this process easy for rapid prototyping. We will build and deploy a skill that you can use immediately with your Alexa enabled device, and discuss the challenges of the publishing journey to get in Alexa's Skill Store.

Writing Party Games with Chromecast
Room 2210

The Chromecast, an underpowered computer running the Chrome browser, is often underutilized as a gaming device. This talk will teach you to write a party game, leveraging your guests’ phones as game controllers and your TV as a game board, using only the HTML, JavaScript, and CSS. No app required.

With the advent of the Cast SDK v3, writing Chromecast apps is easier than ever, no longer requiring anything more than calling a few JavaScript APIs to initialize Chromecast devices. This means that we can deploy Chromecast apps to static servers for ultimate ease-of-use — lowering the barrier to write party games similar to paid games using jackbox.tv. We’ll cover the Cast SDK v3 and use it to write a rip-off of a popular party game that’s sure to be a hit at your next party.

Fail Faster: Quick UX Design Techniques to Drive Toward Success
Room 2211

Learn simple yet paradigm shifting design techniques from Senior UX Professional Ash Banaszek. This talk comes from hearing folks exasperated from making their project deadlines and budgets, only to fail with users upon launch. A lot of times, this has to do with missed requirements and a stubborn conviction to stick to a plan even if the design is untested. Ash will share with you the design techniques used to create effective user interfaces through sketching, mind stretching, and iteration. Further, you'll learn how to conduct black hat sessions to shake out missed requirements, mismatched UI expectations, and get much needed buy in from project stakeholders.

With a world that wants everything faster and faster, Ash will give you simple techniques that make a big difference; thus enabling you to think through multiple solutions, get yourself un-stuck from a single idea, iterate on your designs, and rally your team around this process.

Ready, get set, FAIL!.. The faster you fail, the faster you can succeed.

The Two Question Code Quiz: How to Interview Programmers Effectively
Room 2214

First thing I do when walking into an interview is to see if there’s a whiteboard hanging on the wall. If there is, there’s a good chance somebody’s going to ask me to write code on there, and nobody’s gonna get any useful information out of the experience. Either way, there’s a good chance somebody’s going to ask me to tell them about a time I handled a difficult situation, and maybe even how I’d move Mount Fuji.

This is a session on how to have meaningful technical interviews and really learn if a candidate will be good for you team, hard skills and soft skills. I will also give away the two question code quiz, explain why these two are valuable, and how to administer them well.

JavaScript Futures: ES2017 and the Road Ahead
Room 2215A

Development teams are now using the exciting—and extensive—new JavaScript features available within ES6. Yet, as adoption has spread and projects have adapted, the language continues to evolve and expand under Ecma TC39. Last year, two features were quietly added for ES2016. In January, the committee marked another handful of improvements final for the release of ES2017.

One thing is certain: the JavaScript community is not slowing down! Investigate the new and proposed features of JavaScript. Understand the ES.Next maturity stages and the TC39 review process. And most of all, become empowered to prepare for what lies ahead.

5 Tips for Cultivating Emotional Intelligence
Room 2215B

Learning to manage our state of mind in the workplace is an acquired skill. While stress in the workplace in unavoidable, it is possible to cultivate Emotional Intelligence (EQ) to manage our state of mind. Practicing EQ helps us identify and eliminate stressors in our lives. Awareness of self and awareness of others strengthens personal and professional relationships. When we understand the motivations of ourselves and the perspectives of others we form deeper connections. In this presentation, learn five tips for cultivating Emotional Intelligence in the workplace.

OWASP Top 10 Vulnerabilities & ASP.NET
Room 2215C

The Open Web Application Security Project (OWASP) Top 10 list are the most commonly exploited security threats found on the web today. Securing your applications & clients against them will go a long way towards mitigating any security risks and protecting your application from these threats. In this session, we’ll go through each of the top 10 vulnerabilities showing you the vulnerability in action, what the impact is going to be, how to detect it and most importantly how to fix the problem. Code samples will be freely available and we’ll examine the vulnerability in both MVC/WebApi & Asp.net web forms applications.

Thursday 2:15
Climbing Data Mountain: Web Based Data Visualizations in NVD3.js and D3.js
Room 2201

We are sitting at the foot of a proliferating pile of data. Making sense of it is a herculean challenge, but there are significant spoils for those who are up to the task. One of the tools at our disposal for making sense of large quantities of data is data visualization. In this talk, we're going to use web based tools to build amazing visualizations.

We'll begin by looking at data visualization best practices. Next, we'll look at some of the different ways you can visualize data on the web. Then we'll build charts with NVD3.js. An easy to use tool that supports most charting scenarios. After that, we'll build complex interactive data visualizations with D3.js, the ultimate visualization power tool.

After this talk, you'll have a whole new set of tools to climb to the peak of your own data mountain.

Make Your Site Move With CSS
Room 2202

The web has come a long way since HTML 1.0. Today there are many different ways to make your site interact with your users. From lite weight options to replace images and some common JavaScript to adding engaging movement, CSS has become a great tool for simplifying and even speeding up your site. Come to this session to see simple ways you can make your site move when you just add CSS.

Agile: You Keep Using That Word...
Room 2203

Much like the DOTCOM boom when everyone declared themselves a programmer, once David Norton (Gartner Research) declared agile mainstream on August 26, 2009, you can’t throw a stone without hitting someone who claims to be an Agilista. From the proliferation of “agile” frameworks and certifications, to all of the people who decided to hang out a shingle as a coach, it can be hard to remember what is the essence of being agile. In this talk, I remove the fluff and hyperbole, and get down to the roots of what it means to be agile.

Securing Java Microservices with Java JWT
Room 2204

"Microservices are awesome, but they're not free" - Les Hazlewood, CTO Stormpath

This is a popular talk that I gave during my motorcycle road trip up and down the east coast. While I work for Stormpath, there are no Stormpath dependencies in the code. It's an example that uses Spring Boot with Spring Security and the open-source JJWT.

In the first part of the talk, I introduce JWTs and their utility by replacing the default CSRF functionality in Spring Security with a custom one that uses JWT. It demonstrates how, in addition to doing a "dumb" equals match for the submitted token and the one on record, a JWT can be inspected for expiration. This makes it so that you can have a form, protected by CSRF, that must be submitted within a certain period of time.

In the second part of the talk, I have a Spring Boot microservices example. I run two instances of the example and demonstrate how they initially do not trust signed JWT messages between each other. I then discuss how to establish trust between these microservices (by registering the public keys of each with each other) and then show how they now will trust messages. Finally, I talk about and demonstrate a more modern approach to microservices using Kafka messaging as the backbone rather than HTTP.

Here's a blog post I wrote on the subject as well.

Being Efficient with Azure Automation
Room 2205

Individual humans do not scale very well. Let's face it, we can barely multitask. So with Cloud Computing how do we keep up with the growing demand for maintenance tasks for these "infinitely scalable" assets? The answer is automation.

Azure Automation is a highly available automation service which helps you "Automate all the things". Anything from deployments, to monitoring to maintenance tasks can be set up using this reliable workflow execution engine. This presentation covers the fundamentals of the Azure Automation service and provides some insights into how to leverage it with your own solutions.

Code Archaeology
Room 2206

You inherit some code, but where to begin. If you are going to have a long-term relationship with the code, you may be ready to set up DevOps infrastructure, build, and test. If the code is modern and well maintained, this process can be straightforward.

But, what if there isn’t a build environment. Or, what if the tools to build the code no longer exist?

We’ll use simple tools like text editors and spreadsheets to build some simple visualizations that can help you:

  1. Build a map for a large, legacy code base
  2. Create compelling visuals without drawing
  3. Explain a roadmap to bring the code back under development control
Towards Elastic Scalability
Room 2207

This session introduces the various things that can cause a system or application to not support an elastically scalable environment. It then details various ways to overcome those to architect and implement systems or applications that and be deployed and fully support elastically scalable environments.

C# without nulls or exceptions
Room 2208

Sir Tony Hoare, the inventor of null, has called it his billion dollar mistake. "The Pragmatic Programmer" says that exceptions are "a kind of cascading goto", which Edgar Dijkstra famously considered harmful. With so much of C# and the .Net framework built on these two concepts, code can quickly become littered with null checks and tightly coupled with exception catching. This talk is all about showing ways of writing and thinking about C# that can greatly reduce or remove null checks and exceptions. We'll delve into why null is so dangerous, and see how code relying on exceptions can become entangled. Then we'll see why an alternative approach produces code that has fewer defects, is more modular, is easier to test, and is easier to debug.

Packer: Declarative, Deliverable Infrastructure
Room 2209

Packer is a very cool little image builder from the makers of Vagrant. Using Packer, a single JSON file and one command will take you from an OS disc image to a fully provisioned desktop or server image. I’ll demonstrate using Packer (with a few of its friends) for fun and infrastructure profit.

We’ll review the key elements of a Packer build: Templates, Builders, Provisioners, and Post-Processors. I'll demonstrate the code and execution for each, and show how tools like Chef and Puppet can be used to provision software on a new image. I’ll also demonstrate how to using Jenkins to automate the build and deliver a complete image that is ready for use.

Creating a Mobile Experience for an Existing Modern Application
Room 2210

A significant number of developers today spend their time on maintaining and/or extending existing application platforms. Often, they are tasked with building a mobile application that is intended to integrate well with existing infrastructure and provide a rich mobile experience. In this session, we will leverage your existing skills and build a cross platform mobile application that is well integrated (security, api, data, etc.) with an existing modern application platform using Xamarin.

Git Scenarios: How Do I Fix That?
Room 2211

Have you ever wondered how to get out of a bad merge? Have you ever gotten stuck trying to push your changes? Git is a wonderful and empowering tool, but it's not your father's version control system. Bring your Git questions for this no-slides demo of Git command line and GUI tools. We'll harvest your curiosities, add in some common concerns, and run through these scenarios together. Have an open-source project you're stuck on? Bring the GitHub URL, and not only will we discuss it, I'll submit a pull request with the changes we build.

Have Your Best Season Yet: Becoming a (Microsoft) MVP
Room 2214

Learn how following your passion and deepening your technical area of focus can help you create a wide-sweeping impact and how you can be awarded as an MVP! The MVP community is comprised of over 4,000 MVPs worldwide, and offers you a rich and diverse network of talented tech experts who can help you learn new skills and advance your career. As an MVP, you also gain insider access to Microsoft product development teams, and a plethora of other benefits. Come join the discussion and learn how to reap the rewards of your best season yet!

I delivered this talk at CodeMash in Sandusky, Ohio, and had a panel of 7 MVPs speak for part of the session to educate attendees on how they can be awarded in the future. Many of the attendees noted on Twitter that this was their favorite session of CodeMash. Attendees have appreciated the transparency and awareness I bring to the MVP nomination process through this talk. It is also a great way for attendees to meet Microsoft MVPs and make connections with other community leaders since much of the talk is driven by questions from the audience. This talk is ideally suited to community leaders and those active in the community (speakers, bloggers, etc), but is also suitable for attendees who are new to the community and looking to build connections to widen their impact.

I keep things fun by bringing candy or a small giveaway to encourage participation and to keep people bright eyed in the event that the talk is scheduled after lunch.

Task processing, APIs, and Big Data and in JavaScript: actionhero.js
Room 2215A

There's tons of options for doing data processing in other languages like Java and Python. With actionhero.js, you can use Nodejs's event loop model to create a scalable and cohesive API for processing and serving large amount of data. From the actionhero.js documentation, here's a quick synopsis of this great framework: "actionhero.js is a multi-transport API Server with integrated cluster capabilities and delayed tasks. The goal of actionhero is to create an easy-to-use toolkit for making reusable & scalable APIs."

In this session, we'll use actionhero.js to build some examples, with lots of code, to demonstrate the capabilities of this framework. We'll consume some data, do some task processing, then access the data via an API. We'll use Websockets along with standard HTTP to build a real-time, web-enabled, application.

What I've Learned From Interviewing Over 200 Developers
Room 2215B

If you do anything for long enough, you'll eventually figure out how to do it pretty well and learn some tricks and lessons along the way. Interviewing software developers in not an exception.

During the course of doing more than 200 interviews over the course of more than a year and a half and getting them to share stories, experiences, insights, tips, and tricks, I have been exposed to a great deal of wisdom and inspiration.

Find out some of the key takeaways from a project unlike anthing I've tackled before and walk with me through a journey of learning on my path of sharing audio interviews.

Modeling Settlers of Catan with Degrees of Freedom
Room 2215C

In any mathematical model, we identify equations and unknowns. The difference between those two tells us the number of degrees of freedom in the system. Once we know the degrees of freedom, we can identify the independent variables and the dependent variables.

We'll build mathematical models for three popular games:

  • Bowling
  • Dungeons and Dragons
  • Settlers of Catan.

We'll find bugs caused by allowing too many degrees of freedom. By eliminating those extra variables, we will fix the bugs. This will give us the skills we need to easily model any business system.

Thursday 3:30
Load ES6 Modules Like a Boss with SystemJS and JSPM
Room 2201

The ES6 JavaScript standard brings modules to the masses, but the process of bundling and delivering those modules in today’s browsers still requires a separate loader. Learn how SystemJS was built from scratch to support this format, and how JSPM will change the way you manage your code.

Storming Your Mind
Room 2202

LEGO Mindstorms seem simple -- I mean, they’re made by LEGO and designed FOR KIDS -- but, like other visual and non visual languages, even the simplest of tasks require lines and lines of clean and organized code to achieve a high success rate. This talk will teach attendees how to complete useful and reliable Mindstorm tasks such as line-tracking and wall-following.

Replacing Your Backlog With Experiments
Room 2203

Of the original XP practices, the one that seems the most difficult to get right is the on-site customer. In the original XP team, this was an actual end-user of the, internal, system that was being built. How did the Product Owner turn into a project manager simply working down a long predefined backlog?

The Product Owner role quite often devolves into a step in a waterfall process. A gateway, or proxy, sometimes a firewall, towards the rest of the organisation. But customer feedback is a fundamental basis of any Agile process.

In this talk, I’m proposing that the common way of working down a backlog of user stories is at best a crutch, and prevents organizations from benefiting from even the most highly performing teams. We invest in getting our development organizations as Agile as possible, but never fully capitalize on the opportunities that gives us.

I will discuss how we can use clear goals, captured in actionable metrics to guide our teams in growing the software necessary to reach those goals.

I’ll show how to get development teams to demonstrate their progress based on business metrics, not just features completed. To strategically align development with the rest of the company. And how this allows you to optimally use the brightest minds in your organisation for innovation.

Jenkins: The Lost Levels
Room 2204

I've spent many years looking at Jenkins as a single dimensional tool. While it's always been very useful to me, it was a one trick pony. Just a dumb task runner that I could use to build and run my tests. It turns out, Jenkins has hidden levels of complexity. If you open up those levels Jenkins can help you accomplish a lot more.

In this talk, we'll explore patterns for CI and deployment pipelines enabled by great plugins that were recently added to the standard Jenkins distribution. It's not an exageration to say that the discovery of these patterns spawned a eureka moment that represents one of the most exciting days of my career. I hope you will walk away from this talk seeing Jenkins in a comlpletely new light.

Kick your server to the curb with OpenWhisk
Room 2205

As a term, "serverless" can be as confusing (or misleading) as "cloud" - what does it actually mean and what are the benefits a developer can reap from going serverless? In this talk, I'll explain what serverless means to me. I'll explain where it makes sense to consider serverless as well as when it does not.

I'll then demonstrate IBM's open source offering, OpenWhisk, and show how to work with to build serverless components with JavaScript. I'll show as much code as possible in the time given and will most likely have numerous demos with cats in them.

I'll also cover Visual Studio Code integration and show how to debug your serverless code on the fly as well.

Write Code For The Future You
Room 2206

How many jobs will you have before you retire? A typical worker in the United States switches jobs every 4-5 years; in the tech industry stays are even shorter. Due to this software developers are guaranteed both to work on someone else’s code and someone will work on our code. To survive, it is critical you continue to add value by improving the quality of the code you write and/or maintain in your job as a software developer. In this session, we will define what it means to improve the quality of the code and give you practical steps towards improving it every day.

Understanding Consensus using Go
Room 2207

A Distributed System is one which appears to the clients as if they are interacting with a single, reliable state machine, even when some of the servers in the cluster fail. A master slave replication model is not a distributed system.

In the first part of the talk, we will explore the problem of consensus in asynchronous systems. The solution to the problem is the lynchpin for popular services like Zookeeper, Cassandra, Solr, Hbase etc,. This is an important problem because the nodes in a distributed system are subject to failure. There are different kinds of failure that one needs to account for, fail-stop, fail-recover and byzantine failures.

We can define consensus as a set of nodes agreeing on something, such as a database value, a decision, synchronizing clocks etc,. The solution to the problem has to satisfy three properties

  1. Agreement - All the nodes must agree
  2. Validity - Decided values must be proposed by the nodes
  3. Termination - All the nodes must eventually decide

Let us go through the proposed solutions to this problem.

Single commit scenario:

  1. All the nodes commit a proposed value and provide an acknowledgement.
  2. This fails because of how easily the nodes can be out of sync and how the system grinds to halt when even a single node fails

The single commit scenario uses just the main process for entire duration of execution. All commits are handled in sequence. We do not need any advanced techniques for this case.

Two Phase commit scenario:

  1. Here there are two phase, the propose and accept phase.
  2. Proposer proposes a value and when all the nodes accept, the proposer sends a commit message to agree upon the value. If even one node rejects the proposal, we cannot proceed further. And there is no way to undo changes committed on certain nodes.
  3. Also, we will explore the scenarios for failure

Code The two phase scenario builds on top of previous code and extends the same by voting before committing.

Three Phase commit scenario:

  1. Here we expand the commit phase to two more parts by adding a 'Prepare to commit' phase.
  2. Because of this extra phase, we can undo from any accepts we agreed upon previously.
  3. This solution fails when encountered with network partitions.

    Code In the three-phase scenario, we introduce how Goroutines can be used to handle multiple proposals/prepare to commit and commits


  1. Paxos provides a solution to this problem by introduction the concept of ordering the proposals and considering a proposal accepted when a majority of the nodes accept.
  2. It introduces the terminology of Actor, Acceptors and Listeners.
  3. We explore how the ordering is achieved, and programmatically deconstruct the lifetime of a proposal
  4. We then verify that Paxos meets all the conditions we have set

Code In introducing Paxos, we examine how channels make our life easier by coordinating the communication between the multiple Goroutines our system spins up.

We also introduce a chaos monkey program to simulate the failure scenarios our solutions face.

Hopefully this talk will expose the audience to one of the primary underlying concepts for distributed systems and show how Go as a language is well suited for building systems of this sort.

Outline for the talk:

  1. What is consensus and Why is it important??
  2. How do you define consensus is achieved in a distributed system?
  3. Explore a single node system where consensus is trivial to achieve
  4. Define a distributed system and explain various points of failure and the types of failure.
  5. Define a multiple node system and explain how a single commit scenario will fail. Demo such system and the failure case. Explore how trivially such a system could be built with Go.
  6. As an improvement on the previous solution, explore the two phase commit. Demo the system and the failure case. Expanding upon the code built in the previous solution build a two phase commit system.
  7. Propose the three phase commit and demo the shortcomings of this solution. Extend the existing code to be used for the three-phase commit scenario by introducing Goroutines.
  8. Present the Paxos solution. Extend the code base to use Channels to solve the problem. Examine fun stuff like sending channels over channels and such. Cover all the failure scenarios and examine how Paxos satisfies all the conditions we set out at the beginning the talk.
Clojure spec: Expressing Data Constraints without Types
Room 2208

Clojure programs are built from a small number of generic immutable data structures combined with a large number of pure functions that manipulate these generic data types. The Clojure development experience is characterized by a rapid, dynamic, and interactive REPL-driven experience.

Clojure’s new spec library enhances Clojure by providing a system for stating concrete declarative specifications for your data and functions. Because the specifications are based in the same language as the program, they are very expressive.

Specs are fully integrated with Clojure and can be used within your programs for validation, documentation, destructuring, instrumentation, data generation, and automatic generative testing. Unlike types, specs can be added iteratively or selectively to some or all of your program – it’s up to you when and how much to use.

Enter the Dojo - Growing DevOps and Agile Practices that Stick
Room 2209

Teams learn best as a team and when they can immediately apply those learnings in their context. Enter the dojo - an immersive, learning environment where whole teams come together to build their product using new practices and skills.

In this session, we will frame the need for dojos. From there we will walk attendees through the dojo format, including things they need to think about when creating their own. We wrap up with simple calls to actions for people to take to bring learning forward.

Hands Free Mobile UI Testing
Room 2210

Testing your mobile app against the sea of mobile devices can be daunting. Just testing with the popular devices of the last few years can be cumbersome and expensive. Not to mention the wear and tear on your thumbs with all that tapping and swiping. Wouldn't it be great if you could apply the same skills and practices you've honed implementing unit testing of your app logic to the testing of your UI? I've got great news, you can! We'll explore how you can get started automating all that tapping and swiping today in your existing mobile apps and plan for it moving forward. We'll also see how those tests can be applied to online services with thousands of devices waiting to run your app.

The Impostor Syndrome Walkthrough of GitHub
Room 2211

As a long time Windows user and .NET developer, I’ve challenged myself to level-up my skills using Git and GitHub. As an industry, I feel we provide great content for beginners and for experts, but how do we target content for people in the intermediate category? To answer this question, I'm going to blog every. single. day. in 2017 about something new I’ve learned about using Git and GitHub. I’m hoping that showing my day by day progression can help others who are in similar situations, i.e. trying to reskill after years of industry experience.

I've been calling this guide "a penultimate guide" because I don't know what I don't know yet. I don't know which tips will be the best ones for an ultimate guide to Git(Hub). However, by the time KCDC rolls around, I will be more than half way through the Git(Hub) Tip of the Day series. This means I'll be half-way to an ultimate guide for intermediates leveling-up their skills to more advanced topics. This talk will cover the best of the best tips for this half-way point.

Teaching Kids Programming
Room 2214

In this session, attendees will learn about tools that teach computer science fundamentals in ways that are accessible to children as young as 2. I will demonstrate hands-on, offline toys such as Code-a-Pillar, Code Mouse, and Ozobot, and I'll also go through online resources such as code.org, Code Combat, Khan Academy, and many others. I will share may experiences of teaching kids programming both in my own elementary computer science classes as well as with my own children.

Up and Running with Progressive Web Apps
Room 2215A

The web is the most powerful and ubiquitous application delivery platform in the world. And yet, in recent years it’s become an underdog, overshadowed by native applications brokered through costly app stores. But the introduction of a set of new technologies, which when used together, supercharge existing web applications into powerful "Progressive Web Applications" have the web poised to steal back the spotlight it so rightfully deserves - and engage users more deeply than ever. Come to this session to learn the fundamentals of Progressive Web Apps, and how to turn your standard web app into something that's installable, works offline and can more deeply engage users via push notifications with nothing more than a browser and your existing web development tool set.

Why Aren't There More Women Developers?
Room 2215B

I have been asked this question more times than I can count in the last few years. In the last few years, I have also typically been the only female developer at the companies I worked at. What's the deal? In 1984 women were at an all-time high for enrollment in Computer Science, at 39%. We've seen a steep drop since then. There's a lot of speculation as to why and I'll highlight some reasons for you, but if we want to solve the diversity in tech problem we'll need to stop speculating and take action. I will highlight programs that are working towards gender balance in technology and talk about how to bring them to your community and workplace, as well as explain how to make an impact at a personal level through mentoring and advocating.

Getting pushy with SignalR and Reactive Extensions
Room 2215C

As our systems increasingly demand more real-time updates, we need better ways of working with these live streams of information. Traditional pull models fail to provide the real-time responsiveness and scale needs that modern systems expect. Moving to a push model allows us to scale easier and react to new data as it becomes available. SignalR facilitates push notifications over HTTP to a variety of clients. The Reactive Extensions were designed to allow for asynchronous LINQ over push based collections. In this talk, you’ll see how the synergy of these two technologies merge to make otherwise difficult tasks, a push over.

Friday 8:30
Let's Build A Game! An Introduction To Phaser.js
Room 2201

Have you ever wanted to create a video game? Do you have JavaScript skills? Then you have everything you need to get started! In this talk we'll create a complete game from scratch using Phaser.js, a JavaScript framework for building browser based games. Attendees will learn everything they need to know to start building their own games with Phaser.

Demystifying Dependency Injection
Room 2202

What is Dependency Injection (DI) and why should you care? Come learn what DI is and how you can use it to keep your apps loosely coupled and test friendly. We will examine why you should avoid tight coupling and how you can avoid it using different methods of DI. After looking at the basic patterns, we'll take a look at a few different DI containers and see how they do their magic to make us better programmers. Come discover why DI makes life better.

The Saboteur in Your Retrospectives: How Your Brain Works Against You
Room 2203

You’ve bought into the Agile process. Your team is grooming its backlog, keeping its work-in-progress low, and focusing on delivering value to the users. But when you all sit down for a retrospective, there’s something working against you - your own brains. Using unconscious shortcuts and hidden heuristics, they can lead your team down a path to the worst result possible: wasting time!

You don’t have to take that lying down - you can fight back! Come learn about how your brain interprets cause and effect, the ways in which it wants to think of things as narratives, and all the tricks it does to save itself from having to think. You’ll learn how to maximize your time as we cover ways to focus your retros on what matters, talk about how to avoid getting trapped in the blame game, and discuss the value of perspectives.

Kotlin: JVM Superpowers
Room 2204

Kotlin is a relative newcomer to the pantheon of JVM bytecode-compatible languages. Joining veterans like Groovy and Scala, it takes a fresh approach that avoids a lot the annoying aspects of Java while providing the power and flexibility of its siblings. But it has a secret superpower - Kotlin can compile directly to both Java and JavaScript.

In this talk we'll do some brief overview of Kotlin syntax and capabilities before diving into a start-to-finish example of Kotlin in action in a client-server application. Shield your eyes from the superior syntax, reminisce about how you used to live in fear of NullPointerExceptions, laugh about all those times you had duplicate the same utility functions in Java and JavaScript.

This talk is geared towards current Java developers, so some knowledge of the current state of JVM languages will help.

Making sense of out of order processing
Room 2205

In 2008 some researchers proposed the concept of Out of Order Processing (OOP) at VLDB as an alternative to In Order Processing (IOP), proposing a methodology to reduce resource requirements and improve performance. Today with most distributed systems the concept of OOP is no longer optional and almost of a fact of life due to current architectures, failures, or simply the result of living in a physical world. While OOP improves the performance of distributed systems it does not however make the developer’s life easier trying to reason about the complicated data processing situations that have to be handled. Defining types of ordering, some basics of order theory, and common ordering guarantee terminologies in distributed systems will help to lay a solid foundation for engineers trying to reason about out of order data. After laying the foundation for why a developer might want to take on out of order processing or is forced to the talk will then cover few techniques for dealing with out of order data such as watermarks, slack, windowing and other techniques.

Cognitive services, next step in creating our robot overlords
Room 2206

When I was a 10 years old watching sci-fi tv shows, I thought how hard could it be to make a “Robbie the robot”, . As I got older, I realized how hard this stuff really is. Thanks to a lot of hard work by lots of smart people, the creation of not only Robbie, but our robot overlords is easier than ever. You don’t believe me? Well, come to my talk where we will go over how easy it is to utilize Cognitive services. We will show you what you need to get started. How to incorporate speech, image, and facial recognition into your current application. As well as, how you can go about training this power to your specific needs.

Handling Billions Of Edges in a Graph Database
Room 2207

The complexity and amount of data rises. Modern graph databases are designed to handle the complexity but still not for the amount of data. When hitting a certain size of a graph many dedicated graph databases reach their limits in vertical or, most common, horizontal scalability. In this talk I'll provide a brief overview about current approaches and their limits towards scalability. Dealing with complex data in a complex system doesn't make things easier... but more fun finding a solution. Join me on my journey to handle billions of edges in a graph database.

TechHappy: Hacking Positive Communities
Room 2208

TechHappy is a talk inspired by the modern workplace - where we live to work, and where our current leaders create a culture of anxiety and an unhealthy level of competition. Leadership is not limited to bosses - we are all leaders, and we play many roles as leaders. We lead user groups, conferences, church groups, boy/girl scouts, sports team, and even our own families. As leaders wearing many different hats, it is imperative that we learn strategies to lead our teams through positivity - a proven method that encourages collaboration, balance, and productivity.

In my talk, I guide attendees through three positive leadership strategies they can "hack" today: resonant leadership style, the "yes and" approach, and flow state. During the presentation, I share examples of how positive leadership has impacted my life, and how I implement the strategies I discuss in my everyday life. Attendees will leave the talk eager to learn more about positive leadership, and I have a list of resources I share at the end. To keep things fun, I leave attendees with a parting gift - a small container of Play-Doh as a reminder to keep positivity and levity in their lives.

DevOps with Terraform, a Deep Dive
Room 2209

Terraform, by Hashicorp, is one of a few tools core to the DevOps practice at Stripe. Terraform provides a powerful declarative programming language and runtime model tailored specifically toward the deployment and management of cloud resources. With Terraform, developers are able to quickly add or modify servers in the network, add new load balancers and DNS records, and, because it’s all in code, they could even rebuild the whole network from scratch on a moments notice.

This talk introduces several patterns for working with Terraform. You'll leave this talk prepared to provision servers with configuration management systems like Ansible or Chef, to modularize your infrastructure deploys, to maximize uptime through rolling deploys, and to effectively use Terraform in a team setting. This talk assumes some basic knowledge of cloud infrastructure.

Become a Remote Working Pro
Room 2210

There is no doubt about it, working remotely can be an amazing experience – no commute and wearing pants is optional! Of course, it’s not all rainbows and unicorns since there are challenges to overcome and of course work to be done. This interactive session will answer questions like, “how can I convince my boss to let me work remotely?”, “how can I make sure they don’t forget about me once I start working remotely?” and many more. It will equip you with the tools and techniques for being a successful remote team member.

The Importance of UX for Developers
Room 2211

As developers, we sometimes struggle with understanding why users have a hard time using the applications that we develop. What makes it harder is that we don't realize when the user's experience with our app starts and when it stops - it isn't just about when they are using the apps. In this talk, we look at what makes up UX and some of the tools that we can use to develop better user experiences in our applications for our users.

Architecting the Future: Abstractions and Metadata
Room 2214

Kubernetes and Docker are two of the top open source projects, and they’re built around abstractions and metadata. These two concepts are the key to architecting in the future. Come with me as I dig a little deeper into these concepts within k8s and Docker and provide some examples from my own work.

React/Redux Development -- Where Do I Put the Application Logic?
Room 2215A

You've settled on the React/Redux technology stack, and you're happily dispatching events, writing reducers, and hooking up reusable components. But then you hit a snag: you need to add internal analytics to your single-page app, or debounce button clicks, or track the number and state of all your pending async requests. You need to add some application logic -- workflow with side effects that make your action processing more complicated than simply dispatching an event and running a pure reducer. The code is easy to write, but where do you put it? And how do you ensure that you aren't breaking powerful Redux features like hot reloading and time travel debugging?

In this talk you will learn the different options for locating business logic in a React/Redux application. We'll lift up the hood on the React/Redux processing model and discuss approaches like the popular but sometimes confusing redux-thunk through newer options like redux-saga, redux-logic, redux-observable, and more. By the end of this talk you will thoroughly understand the advantages and tradeoffs of the major tools and techniques for implementing application logic in React/Redux, and you can make your choice with confidence!

The Kids Are Going To Be 200 OK
Room 2215B

Talking to adults about security culture is only a small part of the problem. We really need to be thinking about how raising and mentoring the next generation is our way to change culture. We are at a crossroads where we can either teach children that their only safety lies in compliance and censorship, or we can give them tools and mental models for how to stay (reasonably) safe in an unreasonable world. If we could get even a small percentage of children to spread ideas about psuedonymity and data protection to their peers, we would be changing the future of educational, corporate, and government responses.

As security professionals, we spend a lot of time educating adults on how to be safer, how to protect themselves, how to be security aware. But if we really want to change the culture, we have to start earlier. We have to teach kids what information they should never give out. We have to give them methods to evaluate the truth of what they are reading. And we have to prevent them from becoming the next generation of jerks.

This talk is not about net nannies, monitoring your router traffic, or behaving like a security organization in your home. It's about genuinely teaching new humans how to behave in an environment we had to figure out the hard way.

It'll be about

  • troll-proofing your kids (I/O)

  • privacy and autonomy

  • identity and sharding

  • optimism

  • information jubilee

  • and how kids are like automation scripts.

Information security as a life practice is not something we're taught, it's something we have absorbed in our time in the industry. How can we distill all that life-experience into something that we can teach and pass on? This talk is for everyone with a n00b in their lives, or anyone who isn't sure how to keep themselves safe(ish).

Never RESTing - RESTful API Design Best Practices Using ASP.NET Web API
Room 2215C

Designing and building RESTful APIs isn’t easy. On its surface, it may seem simple – after all, developers are only marshaling JSON back and forth over HTTP, right? Believe it or not, that’s only a small part of the equation. There are many things to keep in mind while building the systems that act as the key to your system.

In this session, Spencer will delve into several best practices to keep in mind when designing your RESTful API. Attendees will learn about authentication, versioning, controller/model design, testability, documentation and change management. This session will also explore the do’s and don’t’s of RESTful API management so that you make sure your APIs are simple, consistent, and easy-to-use.

Examples will be done using ASP.NET Web API and C#. However, this session will benefit anyone who is or might be working on a RESTful API.

Friday 9:45
Progressive Web Apps Are the Future
Room 2201

Web applications are going to take the native app stores by storm in 2017. Progressive Web Apps (PWAs) are web applications that work seamlessly for every user on every device, and they are ready to change the way we build and deploy our software. Each PWA is an application that works online or offline, on old devices and new, and that users can install just like a native app on your device. This talk will cover PWAs and the technologies that make them possible: Service Workers, Fetch API, and Web App Manifest. You'll leave this talk ready to create new PWAs and add native-like experiences to your existing apps.

Abstraction: Enough is Enough
Room 2202

If the hardest part of software development is coming up with good names, then the second hardest part is finding good levels of abstraction. This talk will lay the groundwork for identifying what areas of your application should be more abstract, which should be more concrete, and why it even matters. We will work through a real-world identifying useful and useless abstractions along the way. By the end of this talk you’ll be able to answer this the tricky question: "How much abstraction is enough?".

Trust, Just Culture and Blameless Post Mortems
Room 2203

What is it to have a Just Culture? What is a mistake? What is a incompetence and malevolence? Who decides?

I will go through a few fictional parallel stories of a software development team and the decisions they make. The same people with extraordinary talent can have very different outcomes. I assume we all want to have a strong learning culture, and the reasons we don’t are simple. Ways to overcome from many of our failures to create a just culture can be found from the teachings of Sidney Dekker on Just Culture.

A learning culture is one that can be collectively reflective and honest with one another. Holding regular postmortems can greatly raise the knowledge and morale of the team if done properly.

Unbreakable. Perfect: The Craft of Code
Room 2204

The best welders create seams so perfect that flaws cannot be detected even by an X-ray. Most welders will never get there. Code is no different. Do you write code that ‘works’ or code that is crafted so perfectly it will never show a flaw? We will explore timeless principles that make great code: recognizing code smells, writing for testability, keeping things simple and clear. Many of these ideas were written down decades ago, but are still ignored. The most important first step is viewing code as a craft, something that is done for it’s own sake rather than something hacked out to solve a problem. Syntax, languages, frameworks all fade away. A mindset that is focused on craft will never fail.

Building an Alexa skill with ASP.NET Core and AWS Lambda
Room 2205

AI is expanding more into our daily lives, and devices and agents like Siri, Cortana, Amazon Alexa, and Google Home are gaining huge traction in homes and phones around the globe. What better way to embrace our AI overlords than to build your own Alexa skill?

Learn how to use open-source tools and ASP.NET Core to build an deploy a custom Alexa skill. The project will utilize AWS Lambda for friction-free deployment and scaling. A live demo will be included!

Bot chat: Creating your first Slack bot
Room 2206

Learn how to create a bot for Slack, the cloud-based team collaboration tool. In this session, we'll develop a JavaScript-based bot for Slack and show how to integrate it into your Slack team.

Evolve with Genetic Algorithms
Room 2207

Artificial Intelligence can be an intimidating topic to approach. You might be thinking that it's a topic perhaps better handled by academia or tech giants like Google.. Nonsense! Genetic Algorithms are an example of Artificial Intelligence that is easy to learn and easy to implement on your own. And you don’t even need to know Calculus!

I’ll begin this talk by explaining Genetic Algorithm basics and throughout the talk I’ll show demonstrations that progressively increase in complexity. In doing so you’ll understand the types of problems a Genetic Algorithm is suited for and their full potential will become apparent. By the end of this talk you’ll be armed with the knowledge to evolve your own solutions.

Computer Science: The Good Parts
Room 2208

If you're like me, you became a professional developer without studying computer science. Then I learned that I don't need a 4-year degree to learn and benefit from some of the best parts. Maybe you've seen jargon like "Big O Notation," "binary trees", "algorithms", "map-reduce", or the "Turing test", but have been afraid to ask what they were, hoping they don't really matter. But did you know that these concepts are responsible for Mars rovers, self-driving cars, mobile databases, our air traffic control system, and and even how we elect presidents?

Whether you're building a web application, a mobile app, or learning a new programming language, understanding a few fundamentals of computer science can be inspiring and energizing. We could all benefit from leveling up our game when it comes to writing functions, designing algorithms, and recognizing patterns.

Best of all, computer science isn't really about 1s and 0s. It's a storied, lively tradition of men and women who have dedicated their energy to making the ideas computation and technology for the benefit of everyone on the planet.

In this beginner-focused talk, I will present some simple and very practical ways apply the "good parts" of computer science to your next web app, mobile application, or open source project. Along the way, we will meet people like Alan, Grace, and Margaret, whose shoulders we stand upon today.

Brownfields DevOps in Practice
Room 2209

Are you ready to continuously deploy every commit to production and deploy 25 times a day? Can your operations team tear down and spin up VMs and containers for your app like they're nothing? Can your company track production usage and toggle features at the whims of the marketing department? No?

We all know it's not quite that easy. You can't take an existing house-of-cards monolith and just start treating it like a unicorn, as much as everyone would like to. But as a developer, you can start to make practical inroads, and you can do it now.

This talk looks at DevOps culture from the point of view of a developer - how code changes can affect the agility of your organisation. We'll discuss architectural changes, design techniques, deployment pipelines, and how to make large changes safely. Developers at any level will leave with some practical ways to support your company's DevOps efforts and start working better with your ops team.

A Modest Introduction to Swift
Room 2210

Swift was originally released in 2014, and Open Sourced by Apple in late 2015. The Open Source release generated an explosion of community interest and support, resulting in ports to other platforms and significant language changes. Swift version 3, which reflects the results of much of this work, was released in September of 2016, bringing with it some significant refinements to the core language and a new package manager.

Swift is a multi-paradigm language, supporting imperative, functional, and object-oriented programming styles. The language is strongly typed but has extensive support for type inference and substantial tooling available in XCode to identify and in some cases automatically fix common programming errors. Swift uses a memory management strategy called automatic reference counting (ARC), freeing programmers from the tedium of manually managing memory allocation. This combination of strong typing, maximal type inference, automatic reference counting (ARC), and excellent tooling results in an experience that can be described as "the Macintosh of programming languages".

This talk will present some of the history of the development of Swift with emphasis on how the Open Source release of the language kick-started activity, review the basic syntax of Swift (with comparisons to similar languages that attendees may be more familiar with), and describe what tools are available to help learn the language, including XCode, the Swift REPL available from XCode, and the new Swift Playgrounds for iPad that debuted with Swift 3 and iOS10. After attending this talk, an attendee with no previous Swift experience will understand exactly why they should be excited about this relatively new programming language and be up to date on exactly what they need to do to dive into Swift coding for themselves.

Hacking Wordpress - A Primer for PHP Programmers
Room 2211

I spent most of my career writing large custom in-house solutions. To me, WordPress was the software I used to run my blog, nothing more. Suddenly I found myself doing WP consulting as well as inheriting the php[architect] codebase which is completely built on top of it! I was then amazed as I dove in, at just how easy it is in WP to build any custom functionality/pages that you need via a simple API. Come learn in this session just how easy it is to build custom functionality into WP and use it as an application development framework.

You will need to know basic PHP syntax to join us, as I won't be covering "How to code in PHP", but assuming you know PHP, I'll be showing you how to make WordPress bend to your will.

Building Next Generation Analytics Applications with Birst
Room 2214

Birst, an Infor Company, is a pioneer of cloud-native, business intelligence (BI), analytics, and data visualization. Creating a great analytic product means much more than white-labeling a set of dashboards. To roll out analytics across a broad user base, you need a platform that lets you define a single, repeatable process for all your users. In this session we will review:

• Scenarios in which you can leverage Birst Networked Analytics to create analytic applications for your internal and external users

• Ways to save time and resources and avoid physically recreating metadata, data integration and BI

• A demo of these capabilities that showcase Birst in action

Birst provides a unique, comprehensive platform for sourcing, refining, and presenting standardized data insights at scale to drive business decisions. Come see for yourself.

Patterns for Reusable JavaScript Components
Room 2215A

Today's popular JavaScript frameworks offer powerful models for creating components. But are you designing your components for reuse? Whether you're working in Angular, React, Knockout, Ember, or native web components, there are universal principles to consider for creating truly reusable components. This session explores the hard lessons learned from publishing a suite of reusable JavaScript-based components at VinSolutions. It's time to stop reinventing the wheel!

Career Growth Questions You're Afraid to Ask
Room 2215B

There are so many job opportunities out there for technical professionals. Some even sound like super exciting things you’d like to do! How do you know if they’re actually right for you? Even if you’re not actively seeking a job, this is an important question that we all need to answer. Drawing on real-life examples, this session will walk you through the career change and opportunity evaluation process. It will cover topics including benefits questions, intellectual property concerns, and assessing company culture. Most importantly, it will help you identify your career growth priorities and whether that seemingly shiny new opportunity meets them.

Getting started with Entity Framework Core
Room 2215C

With the cross-platform version of .Net, Microsoft has had to rewrite many of the core components that we have come to depend on. In this session, you’ll learn how to get started using EF Core and how to handle the changes.

Friday 11:00
Sawing Through console.log
Room 2201

For better or worse, logging is the cornerstone debugging technique for Node.js applications today. Some devs love it, others hate it, but no matter what your opinion, this session will show you how to improve your debugging techniques. We'll cover several libraries and tools that can enhance your debugging, log writing and viewing experience, and ultimately help you catch more bugs, more quickly, with less splinters. Let's sharpen some saws!

Fluent API Design in C#
Room 2202

There is a profound expressive power in using a fluent API over typical object-oriented code. Well-designed fluent APIs allow you to weave clauses and phrases together with ease, enabling you to express complex concepts in a concise, readable way. We're all accustomed to using fluent APIs in C#, but if you've ever tried to design one yourself, it's quite challenging.

This session will give you a primer into how to conceive, design, and build your own fluent APIs. We'll identify design patterns that are common in fluent APIs. I'll arm you with some design tools and strategies to make sure that your own designs are easy to use and hard to break. I'll also help you understand how to leverage the .Net type system and C#'s type inference rules to simplify the syntax that your APIs users have to write.

Come and learn how to blend language arts and technical design together to craft your own powerful abstractions in Fluent API Design in C#.

Agile Metrics That Matter
Room 2203

When it comes to development methods, lean and agile have clearly taken the lead. In the spirit of Kaizen, this session will take a look at the measures we can glean from agile teams, why the are relevant and interesting, and how we can use them to help our teams get even better.

Services Assemble! Apply MVP Principles to Create Cutting-Edge Microservices Without Chaos with Spring Cloud/Netflix OSS
Room 2204

In this session, learn how to use proven patterns & open source software to rapidly build a robust portfolio of microservices that provide a solid foundation for your dynamic and growing microservice architecture. This session addresses vital points such as:

  • Configuration services
  • Microservice registration and discovery
  • Circuit breakers for graceful degradation
  • Load balancing and intelligent routing
  • Asynchronous messaging

Additional topics discussed include logging & tracing, testing approaches, and migration patterns.

The presenter will demonstrate how to develop & effectively manage microservices using OSS tools employed by Netflix to keep movies streaming globally 24x7.

Lightweight Pub/Sub for Web Applications using MQTT
Room 2205

MQTT is an extremely lightweight publish/subscribe messaging transport. It is commonly used as a machine-to-machine connectivity protocol for IoT devices, and usually runs over TCP/IP using sockets. But, recent efforts have implemented the protocol in JavaScript using web sockets, making it possible to use MQTT from within a web browser. This session will introduce the MQTT protocol, discuss various brokers, talk about messaging and Quality of Service, and provide examples of how to use Pub/Sub to enhance your web application and interact with IoT devices.

Hacking for Fun and Profit
Room 2206

Cybercrime is at an all-time high and has no signs of slowing down. And yet, the profile of the average hacker is still not that much different from Matthew Broderick in WarGames or Robert Redford in Sneakers - they're just doing it for the lulz.

Find out what motivates people to hack, what it takes to become a Certified Ethical Hacker, and who is hiring hackers today.

Data Science for Developers: The Big Picture
Room 2207

Data Science is the practice of transforming data into actionable insight. This set of skills is currently in high demand and commanding significant increases in salary, as data science is fundamentally changing the world around us. Unfortunately, most developers have not yet learned this valuable set of skills.

In this session, you will learn what data science is and why it’s important. In addition, you’ll learn what you need to know, as a developer, to prepare for our new data-driven economy. Expect to learn about the Internet of Things (IoT), Big Data, machine learning, and how they are converging to create fully-autonomous intelligent systems.

Microservices: Lessons from the Trenches
Room 2208

Microservices are the rage, but are they really the next evolutionary step in architecture or simply a repackaging of stuff we should already be doing? This session looks microservices beyond the hype and breaks down the architecture using real world problems.

Rather than focus on the purist viewpoint, this session takes a pragmatic focus, with a focus on what has proven successful in the real world. Taken from various clients, the talk covers the spectrum from green field implementations to legacy modernization.

The sessions begins with a purist viewpoint of microservices, focused on Martin Fowler’s article on characteristics of a microservice. It proceeds to break down some of the myths surrounding the benefits of microservices to give you a proper view of when microservices will benefit. It then moves to some pre-requisites you should have in place for a successful implementation, and ends with some real world scenarios from work with numerous clients across the country.

Session includes

  • Foundational topics necessary to implement microservices
  • Dispelling myths about microservices
  • Basics of the microservices architectural style as they apply to real world problems
Bringing Ingenuity Back to Engineering
Room 2209

Developers, do you have innovative ideas that go unheard? Product Owners, does it feel like the solutions you deliver lack ingenuity? We have agile stories, empowered teams, and the latest in technology and yet we all know we could be doing better, we just don’t know how to unleash the fury. A surefire approach you are afraid to try is ShipIt Days.

ShipIt Days are an approach and a mindset to allow your team the opportunity to capitalize on innovation and their natural desire to do good things. Inspired by Google’s 20% time, 3M’s 15% time, and Atlassian’s ShipIt Days, we have been putting a new spin on this “free time” concept for years to deliver innovative, motivated and sustainable results.

In this crash course, we will cover the What, How and Why of ShipIt Days. Our goal is to arm you with the tools and enthusiasm to fight for these activities on your teams. From communicating the idea to practical applications we offer you our real world experiences and the approaches we have successfully used on our projects.

If you’re a developer, project manager or product owner this talk is for you.

Developing Multi-sensor for Authentication on Mobile Devices
Room 2210

Most mobile devices support a myriad of sensors (gyroscopes, accelerometors, magnetometers, front and backward facing camers, wifi and bluetooth transmitter, just to name a sample). Output from these sensors can be combined such that they can identify a unique users and generate a password for that user. We discuss an our approach to such sensor fusion that generates a secure key, thus eliminating the need for passwords. The key generated meets all financial institution requirements for accuracy. We also discuss technical and ethical issues associated with this type of data collection and offer an opinion as to how this functionality will evolve

Jewelbots: How to Get More Girls Coding!
Room 2211

Girls just wanna have fun … coding their own programmable jewelry! Jewelbots are the latest in wearable tech with a great feature - they allow you to write your own code. This live demo of programming with Jewelbots will introduce you to the Jewelbots API, highlight fun projects, and talk through tips on teaching and encouraging young women in tech. Loops are easy to understand when accompanied by color coordinated led lights!

IoT Validation
Room 2214

The Internet of Things has spread to many parts of our lives. From houseplants to ice machines, from fitness bracelets to fish tanks: it's everywhere. It's also a great medium for engaging, interactive artwork.

Hacking around with IoT stuff is lot of fun, but it also brings new challenges for us software developers. Early validation is critical. You need to be confident that your plan is going to work before you order 1000 printed circuit boards.

In this talk Jen will show you her favorite recipe for prototyping IoT gadgets and blinky LED artwork. It combines Arduinos, Raspberry Pis, NodeBots, and Firebase to yield a forgiving and easy to develop upon IoT platform. Then she'll prove it's quick by building a project on stage, from circuit to code.

Reactive Programming with RxJS: A Beginner’s Perspective
Room 2215A

Why beginners should train yourself to do reactive programming in your first months of learning. As a beginner, you don’t have a set way of programming, and adopting a declarative functional style will help you prepare for the future of reactive programming. Learn the importance of RxJS, simple implementation, and how to think reactively.

  • Why reactive programming is the way of the future
  • What is in store with TC39 specs and reactive programming
  • How various frameworks like ember, angular, react, vue implement reactive programming
  • Simple implementation demonstrations of RxJS, a popular library for reactive programming
  • Use cases in large companies for reactive programming
The Developer’s Guide to Promoting Their Work
Room 2215B

A few years ago, I had an idea to make the web better. It was going to be great, and I had the team to build it. Nine months of late nights and lost weekends later, we launched it! The problem: no one cared.

A brilliant project isn't enough. I had to spread my vision, which was difficult for a developer like me. I learned quickly that even the best ideas needed to be sold. I had to build an audience, tell a story, and win over customers. Join me for a developer's guide to marketing. I'll share hard-fought lessons on page design, social networking, advertising, and analytics that will help you bring your ideas to the world.

An insiders look at the C# language: present and the future
Room 2215C

Get the inside scoop on new features in C# 7, and thoughts about where the language is headed from a member of the Language Design Team. In this session, Kevin will demo language features in C# 7 like tuples and pattern matching, then provide a sneak peek into where things are headed for C# 8.

Lunch 12:00 - 1:00
Friday 1:00
I Promise to Give You a Callback: Working with Asynchronous JavaScript
Room 2201

Client-side JavaScript development has become more and more popular over the past few years and shows no signs of slowing down. Many developers are making their way from being focused on more traditional platforms like Java and .NET and are learning how to write great front-end applications with JavaScript and frameworks like Angular, React or Aurelia. As many of these developers begin writing more and more complex JavaScript. They are finding that, in many areas, JavaScript is like nothing they have worked with before. One of those areas is asynchronous programming. Many developers find asynchronous programming intimidating, but JavaScript is so dependent on it. The good news is that it’s easier than you think it is.

In this session, you’ll learn why asynchronous development is so critical to creating a great JavaScript application. You’ll learn how concurrency works in a little differently in JavaScript then you might be used to, and see some patterns to help you deal with even the most complex asynchronous situations. You'll see that asynchronous JavaScript is an easy and effective way to create great and responsive JavaScript applications.

Web API Tips, Tricks, and Best Practices
Room 2202

Web API is the RESTful API framework for ASP.NET. With services becoming an increasingly important part of all kinds of different applications, getting better at implementing this layer of an application is becoming critically important.

Join me while I walk you through some of the coolest, most practical and useful things I've learned while developing services using Web API and ASP.NET. We'll look at amazing nuget packages that save you lots of time and effort as well as patterns and anti-patterns for great REST services. My goal is that everyone walk away with a few new things they can use to develop a better servicer layer using Web API.

How to go from Developer to Stakeholder
Room 2203

Technology is everything these days, and your skills as a developer are in high demand. How can you leverage your unique skill set and understanding of technology to climb the ranks in your company beyond "just a developer?" I will tell my story of going from underpaid full-time developer, to broke freelancer, to entrepreneur and finally to partner and CTO. More importantly, I'll tell you what I learned along the way about the art of persuasion, transparency as a trojan horse, indispensability, confidence, standing your ground, and ultimately how to be treated and respected as a leader and not an employee. Disclaimer: I cannot confirm or deny that I have a problem with authority and a thirst for power.

This Old Java App
Room 2204

You get told you have a new project, something you've heard about but someone else always took care of. Well, someone else is gone and it's your turn now. It's dropped in your lap and you don't know which way is up, how the project actually works, why they made their decisions at all, let alone how to actually manage any changes in this project.

This talk will give you an idea how and where to start -- and how to keep your sanity. Maybe you will be the hero after all.

The examples will be in Java but the ideas are the same, regardless of platforms.

Intro to OAuth2
Room 2205

In this presentation we’ll discuss how OAuth is being used with both Authentication and Authorization. We’ll discuss who is using OAuth and how they implemented it. Using a light board controlled by a Raspberry Pi 3, we’ll look at how to get started writing your own applications using OAuth.

Continuous Delivery in Azure - Beyond Right-Click-Deploy
Room 2206

All those Azure demos look great, get up and running in seconds, never leaving the comfort of your IDE! But real life is more complicated. We have a mix of VMs, databases, web sites, and of course someone is playing around with microservices and App Fabric. Deploying from Visual Studio was easy at first, but now carpal tunnel is setting in.

There are better ways! In this session, we'll take a complex Azure deployment and introduce automated builds, packaging, deployments, an entire continuous delivery pipeline. We'll also look at Azure Resource Manager, converting our topology to infrastructure-as-code, providing even greater insight and control over our deployments. Finally, we'll look at more exotic deployment scenarios such as blue-green deployments and feature flags for a first-class deployment experience.

I Have ADD and So Can - Ooh, Shiny!
Room 2207

Neurodiversity is the hidden diversity on our teams. Unlike obvious external markers, mental and personality quirks or invisible disabilities are not always easy for us to remember or adjust for. But sometimes diversity in this area is as important as any other.

How can you remember and honor that your team members are all experiencing slightly different realities? How can those different realities make your product and team stronger and more effective?

Come listen to me talk about my own invisible neurodiversity and what it has taught me about being a good team member and becoming more effective because of who I am, not in spite of it.

How many times have you gotten fired? Told you're not living up to your potential?

A lot of smart people don't look great when you rate them on measures that are better at determining focus than actual capacity. I'm one of those people. I score great at tests and terrible on anything that requires me to keep track of pieces of paper. We carry these traits into our professional life, so how can we work with ourselves and each other in a way that honors who we are while also getting some work done?

This talk has a grounding of statistics and theory of neurodiversity, and then we go into some concrete actions teams can take to make sure tehy are not a monoculture mentally, as well as worknig to diversify themselves in more visible ways.

Functional Programming for the Dis-Functional
Room 2208

Functional Programming has been all the craze lately. Immutable data this. Curried function that. But what does all of this mean? In an industry dominated by Object Oriented Programming how does one code functionally? In this talk you’ll learn what Functional Programming is all about and I'll demystify many common concepts ranging from pure functions to currying and composition.

Creating a Culture of Learning & Experimentation; Succeeding in a world of CD & DevOps
Room 2209

Continuous Delivery (CD) and DevOps are two industry buzz words today, which everyone is aiming to adopt. However, both are changing as fast as we can learn about them and the adoption of these extends beyond just tools and processes. They require a fundamental shift of mindset, where learning and experimentation become part of the daily vernacular and are ingrained in everything a team or organization does.

In this talk, we will drill into how to create a culture of learning and experimentation. We will discuss the value of holding hackathons, logistics and key things to include in them. Value Stream Mapping is another concept we will talk about and the goal of making it a regular activity as well as starting the concept of holistic Team Health i.e. getting beyond quality metrics to look at delivery and team perception. To make these successful, you will need a coaching center of excellence to not only help coordinate, but also to have the ability to act as (internal) consultants to different teams within an organization.

Throughout the talk, we will tie each of the ideas back to how they enable us to succeed in the ever changing worlds of Continuous Delivery and DevOps. The goal would be for the participants to walk out of the session with a roadmap to achieve a culture of leaning and experiment, including ideas they can implement immediately and ones that would require a longer investment.

SQL Anti-patterns
Room 2210

Anti-patterns are common methods to solve problems that are non-optimal, counterproductive, dangerous, or all three when implementing. SQL has lots of examples of these such as allowing SQL injection and possibly exposing your entire database to intruders; using incorrect NULL logic and returning unexpected results; and using indexes poorly and getting no benefit or even slowing your queries down.

Don't make the same mistakes as I have! Come join the speaker as he discusses what he’s done himself (and seen others do) in the past while working with databases for 25+ years so you can avoid them.

Reverse Engineering a Bluetooth Lightbulb
Room 2211

I recently made build lights for the company I work for and my home office. They integrate with TeamCity and indicate when a build is running and success/failure of all the tests. In this session, we will reverse engineer a bluetooth light bulb’s protocol, learn how to have an Intel Edison communicate with the bulb, and by the end you too will know how to make your own build lights! Please note that this talk will be highly technical. We will be discussing low level details of bluetooth communication, protocol analysis with Wireshark, sniffing bluetooth packets, etc.

Hello, Computer! Play me some Bach!
Room 2214

Join us for an introduction to voice based computing and the possibilities it opens! We’ll look at some of the voice technology on the market and then walkthrough setting-up a new skill.

JavaScript Tests in Node, the Browser, and CI
Room 2215A

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.

Public Speaking without Barfing on Your Shoes
Room 2215B

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.

DI Why? Getting a Grip on Dependency Injection
Room 2215C

What is Dependency Injection? And why would we want to use it? That's what we're here to answer. We'll start by looking at the problems caused by tight coupling. Then we'll use some DI patterns such as constructor injection and property injection to break that tight coupling. We'll see how loosely-coupled applications are easier to extend and test. With a better understanding of the basic patterns, we'll remove the magic behind DI containers so that we can use the tools appropriately in our code.

Friday 2:15
Learning Aurelia
Room 2201

Angular 2 and React aren't the only choices when it comes to building front-end web applications. Aurelia is a relatively new player, but certainly one to be taken seriously. It places a strong emphasis on convention over configuration allowing you to spend more time writing your core business logic, and less time writing repetitive framework code. Aurelia has a powerful routing engine, excellent two-way binding system, and is extremely flexible when it comes to the language you choose or the front-end build system to integrate with.

In this session, I'll go over everything you need to get started building apps with Aurelia. I'll be using TypeScript and ASP.NET Core on the back-end, but Aurelia will fit nicely in to many other scenarios as well.

Create Custom Action Filters in ASP.NET MVC
Room 2202

Action filters are used to inject logic before or after an action method on a Controller. Become familiar with the built-in filters available in the MVC framework, then move on to creating your own custom action filters. Learn when and why to use them and how to implement them.

Stop the Iteration Bait and Switch
Room 2203

Have you ever worked on an agile project where you were pressured to get something out the door? Maybe you were told “it doesn’t have to be perfect,” “this is agile,” or “we will iterate on it.” The next thing you know you have a handful of half-baked features shipped, mountains of features ahead of you, and nowhere in sight is that promised opportunity to iterate.

Agile has the good intentions of encouraging iterative and incremental development but how to accomplish that can feel far from intuitive. Without understood practices, iteration doesn’t occur and the product ends up shipping as is. In this talk a pragmatic duo will breakdown what it truly means to build a product iteratively and incrementally. We will share how we have approached these problems by deconstructing a product roadmap with you and showcasing real examples from our experiences. Join us and learn how you can start iterating on your projects today.

This session is targeted not only to product owners and management, but also developers. It takes the engineers to capitalize on these approaches.

Better testing with JUnit 5
Room 2204

The latest in the venerable JUnit suite, version five fixes many of the annoyances while modernizing and opening up the platform. This version improves JUnit testing to use the newest Java features like Lambdas, expands the ability to control and monitor the test lifecycle, and introduces new constructs to support Behavior Driven Development (BDD). In this session you'll learn how to use all of these features as well as how to get them up-and-running alongside your existing test suite. We'll also talk about how you can write custom test engines to extend the capabilities of your tests.

This talk focuses on improvements relative to the current version of JUnit so experience with the platform will help, but beginners to Java testing are welcome.

Hardware store doesn't have the part you need? 3D print it! I will show you how.
Room 2205

I know you have seen 3D printers online, in a store display, or maybe a friend just can’t stop talking about them. Are they just a fad, or worth investing your time to understand this technology. Should you build your own, or buy? How do these things really work? Do I really need to know what a hotend is, and why would I ever want to extrude something? These are valid questions, and I have the answers. I will have live demonstrations of two different types of printers, and go over everything you need to know to get going in this fast paced addictive technology.

Adding AI Smarts to your Software Solutions with Microsoft Cognitive Services
Room 2206

In all its previous hype-cycles, Artificial Intelligence (AI) repeatedly fell far short of its promises. Computers were underpowered and consuming AI was too complicated, leaving its benefits unapproachable to all but a small group of experts. But now advances in Machine Learning coupled with the scale of the Azure Cloud bring us Microsoft Cognitive Services, a collection of purpose-built capabilities based on AI and Machine Learning that make it possible for developers of all backgrounds to easily enrich their own projects with these powerful capabilities.

In this talk we’ll explore the universe of Microsoft’s Cognitive Services and understand how to use them in your own software projects. We’ll explore services for Facial Recognition, object detection, Natural Language Processing (NLP), as well as Topic Extraction and Sentiment Analysis. We’ll apply these services to various media types from still images to video to text to discover how easy it can be to bring the power of AI and Machine Learning into your own software systems.

Crafting Innovation
Room 2207

In this session, we will examine the notion of 'innovation' with the goal of enabling new ideas within your team. This starts by challenging the concept of what innovation means and where new ideas originate. Techniques will be offered for building a culture of innovation which include: how to curate ideas, inspire teams, build innovative mindsets, create better processes and deal with change. By the end of the session, attendees will gain new strategies that foster an environment of empowerment, creativity and collaboration.

Intro to Rust: Writing Safer, Faster, and Highly Concurrent Code with Rust
Room 2208

Rust is an open source "modern systems programming language focusing on safety, speed, and concurrency". It was originally developed by Mozilla as an open-source project, and is now used widely across the technical community within the current Firefox by Mozilla, Dropbox for their file storage layer, the Node.JS package manager, NPM, for providing highly available packages, and Postmates for writing system daemons (see https://www.rust-lang.org/en-US/friends.html). In this talk, we will explore the fundamentals of Rust by writing a few programs designed to illustrate its features. We will also explore the novel primatives it provides, such as assigning ownership to data and variable in your code and the process of borrowing data, which sets it miles above the languages it is replacing such as C and C++. Finally, we will look at the many possible real-world uses of the language by discussing some areas in which you can incorporate it into your current software at work and in your side projects.

Tentative Outline:

  • Hook
  • What is Rust?
  • Why Rust?
  • Intro to the Speaker
  • Goals of Rust as a Programming Language
  • Benefits, Drawbacks, and Optimal Use Cases
  • 3 Example Programs (< 50 lines each, relatively simple, but highlighting safety, speed, and concurrency)
  • Highlight the uses of Rust in the Real World (NPM, Mozilla, Dropbox, and ORNL to name a few)
  • Live Demo: Writing a Simple Web App in Rust in 5-10 Minutes
Continuous Deployment Pipelines with Jenkins
Room 2209

Cloud native development and pipelined deployments are like a PB&J. They're both good on their own but the real magic happens when you put them together. This talk will focus on pipelined deployments with enough technical detail to get folks started on their own pipelines.

Pipelines offer a lot to the developer and the business:

  • make production deployments a business-as-usual affair
  • pipeline as code allows the pipeline itself to be a reviewable artifact
  • make deployments fast enough for microservice development
  • increased speed to market
  • increased developer productivity but sadly less of this
  • run unit and integration tests on every commit
  • deploy every commit if you want
Effective Data Visualization
Room 2210

We spend much of our time collecting and analyzing data. That data is only useful if it can be displayed in a meaningful, understandable way.

Yale professor Edward Tufte presented many ideas on how to effectively present data to an audience or end user.

In this session, I will explain some of Tufte's most important guidelines about data visualization and how you can apply those guidelines to your own data. You will learn what to include, what to remove, and what to avoid in your charts, graphs, maps and other images that represent data.

User Experience at Every Level
Room 2211

User Experience is included at every level of business. This can be seen in the culture of a company. Through the content, products and services that the employees create, the company engages with its consumers. User experience is integrated into every touchpoint of a company's infrastructure when people engage with a brand. Learn why it's important to have a Generalist on the team to oversee the User Experience for a company at every level of its processes, including: hiring, design, development, advertising and marketing.

Scaling your culture to handle team growth
Room 2214

It's easy to to keep things fun and working smoothly when your team is small. When your team triples in size, your processes break down. People start stepping on each others' toes, changes stop getting documented, knowledge gets collected into silos, and it can become difficult to get things done. This talk will go over the lessons I've learned at EquipmentShare as we grew from a solo developer to a team of 30 in 2 years.

Build a JavaScript Dev Environment in 1 hour
Room 2215A

There’s a staggering number of decisions to make when setting up a JavaScript development environment. In this rapid fire one-hour session, let’s cut through the noise and build a powerful, rapid feedback development experience. Whether you work in Angular, React, Node, or the long list of alternative JS technologies, this session is for you. After less than an hour of work, we’ll run a single command to lint, bundle, minify, run tests, open the browser, and display our app. We’ll check a single command line to see feedback on all of this goodness. And every time we hit save, this wild circus will fire off automatically, hot reload our app, and report the status. If you’re writing JavaScript with plain old script tags, get ready to be floored. The future of JavaScript has arrived and I have great news: The pain is over.

Shaving the Golden Yak
Room 2215B

Programming is a series of frustrations. Everything we do, we could do better or faster if we only had our tools set up just so. If our error messages were a little better, our code a little cleaner, our tests a lot wider. How do you balance the work you're supposed to be doing with the work that makes your work, work? Dive into the yak stack with me. I'll get bored with writing code, and write code to write code for me, and then write code to make that easier. Somewhere down here is the golden yak, the one with secret wisdom engraved on its skin.

This session will give you reasons to spend time smoothing your development experience, and clues for where to spend that time in ways that help your whole team.

Developing ASP.NET Core in VS Code
Room 2215C

Microsoft’s biggest web platform is now open source and cross platform. Most of the demo’s shown are using Microsoft’s flagship Visual Studio product. In this talk I’ll show you how to use their lighter weight (but cross platform) Visual Studio Code to build a sample ASP.NET Core project. You’ll learn both ASP.NET Core as well and Visual Studio Code.

Friday 3:30
Decrease your conversions – common ways to lock people out
Room 2201

Building products for the web means building products for everybody. We spend hours and hours on optimizing user flows, tweaking designs and A/B testing the heck out of everything. The problem is that we as developers, product owners and designers often think about the targeted customer under optimal conditions and ignore minorities.

But what about people not having the latest high-end mobile device, not browsing with a solid 4G connection? But what about people accessing the web with assistive technology? And what about people with dyschromatopsia?

This list is endless!

In this talk, we will take a look at common problems of the web today and demonstrate how we can make it a more welcoming place. And hopefully we’ll rethink the creation of a bloated inaccessible website with way too low contrast ratio the next time because the web is for everybody.

Unit Testing Strategies & Patterns in C#
Room 2202

Testable code is a widely advocated industry standard but the barrier to entry is incredibly high. In this talk, we'll go over not just how to unit test your code using MsTest, Moq, & AutoFixture but the patterns & processes to ensure your code can be unit tested. We will touch on the basics of dependency injection and common patterns such as avoiding the use of static classes but also more advanced topics such as SOLID design principles and how they relate to testing.

We'll give the attendees a wide variety of examples on how to test common C# projects such as web api and console applications and different scenarios such as how to test databases and external method calls. Many real world tips & tricks on dealing with common patterns and scenarios will be included to make your life easier. Most importantly, attendees will be given a good idea of how to start testing, how to measure the effectiveness of their tests, and what not to test.

The Team, The Team, The Team!
Room 2203

“The team, the team, the team” were the words used by Hall of Fame, University of Michigan coach, Bo Schembechler. He also mentioned that no one person is more important than the team. These words are extremely important to remember, as they not only apply to a sports team, but to any group of people working together as a team, regardless of the scenario. You can take a team of All Stars, but until they start functioning as a team, they will not be successful. High performing teams will always deliver great solutions.

In this talk, we will expand on the concept of a team and hone in on the process of creating a team culture that fosters innovation, collaboration, continuous learning and trust. We will use Tuckman's four levels of group development as a guideline to talk through what you can do with a new team to take them from Forming to Performing. We will also discuss the 4 C's a [sports] team captain must embody to lead their teams and how they are applicable in a software development environment to build successful teams.

DevOps ​And Microservices Live!
Room 2204

Many Microservices presentations simply talk about the benefits and design patterns of Microservices through bullet point concepts, diagrams, and discussion. In contrast:

This presentation will demonstrate an actual Microservices application implementation, with a live showing of a durable, stable, and elastic Microservices platform automated with DevOps tooling.

The following features will be demonstrated: Scaling a Service, Continuous Deployment of a Service (adding new features, fixing bugs), Containerizing a Service With Docker, Monitoring Circuit Breakers Under Load With Hystrix, Handling Open Circuits, Log Aggregation, Container/Service Orchestration, On-Demand Resource Allocation, Routing & Orchestration, and more.

The reference Microservices application is implemented using a single-page application (Angular SPA) UI, Spring Boot, and Netflix OSS frameworks. The DevOps SDLC environment will utilize Docker, Maven, G​it, and Jenkins. It will be configured to provide a continuous delivery mechanism to a cloud-based infrastructure. Other infrastructure options such as cloud or on-premise cloud environments will ​also ​be discussed.

The goal in this presentation is to show you what can be accomplished by utilizing a Microservices architecture. In addition to purposefully making errors (and showing you why they happened & how to avoid) we assess the pros and cons, to help the audience to better understand if this architectural approach is a good fit for their application development needs.

Querying NoSQL with SQL: HAVING Your JSON Cake and SELECTing it too
Room 2205

Until recently, agile business had to choose between the benefits of JSON-based NoSQL databases and the benefits of SQL-based querying. NoSQL provides schema flexibility, high performance, and elastic scaling, while SQL provides expressive, independent data access. Recent convergence allows developers and organizations to have the best of both worlds.

Developers need to deliver apps that readily evolve, perform, and scale, all to match changing business needs. Organizations need rapid access to their operational data, using standard analytical tools, for insight into their business. In this session, you will learn the ways that SQL can be applied to NoSQL databases (N1QL, SQL++, ODBC, JDBC, and others), and what additional features are needed to deal with JSON documents. SQL for JSON, JSON data modeling, indexing, and tool integration will be covered.

Architecting IoT Data Ingestion with Azure Data Services
Room 2206

Learn about the Azure Data Services available to process device data, from ingestion and analysis to reporting and responding to events. With the explosion of devices capable of capturing sensor and other types of information there is a real need to be able to ingest and process data real time. Microsoft's Azure cloud platform provides a number of services that simplify this process. This presentation will explore the data services, understand the choices between them and show real guidance on how to architect an IoT ingestion system in the cloud.

Designing for Mixed Reality User Experiences with Microsoft HoloLens
Room 2207

What is Mixed Reality and how does it differ from Augmented or Virtual Reality? What is the hype around Microsoft HoloLens, or for that matter, what is it? How do you break free from the limitations of 2d design to create a compelling 3d experience? How do we reduce cognitive overload, especially when apps interact? This interactive and entertaining session will answer these questions and focus on design concepts and terminology to help you tackle this new and exciting frontier. We’ll explore considerations needed when working with gaze, holography and mixed reality. A new medium brings with it a new palette, new design possibilities, new composition methods, and an invitation to create defining new experiences. We'll learn how all of those can be pulled together in an amazing set of Design Patterns. And you’ll also see a demonstration of Microsoft HoloLens with the ability to see what the user is experiencing. Fun for all!

Little Mistakes That Cost Big: Lessons Learned In Providing Open Source Software
Room 2208

Let's get real and talk about bad code, bad feature decisions, and embarrassing moments -- in the hope that you will make smarter decisions. Three million downloads, 90 releases; it's been a roller coaster and boy have we've learned a lot about providing plugins to the WordPress community. We'll talk about some particularly bad coding mistakes, unreadable coding practices, managing changing feature sets & community expectations, and touch on a couple of strategies that we've used to turn things around, increase our footprint and nearly double our main plugin's rating. Some of this talk will be very technical, some not at all.

"Serverless" Event Driven Architecture
Room 2209

Over the last two years, "serverless" applications have become more popular - the prospect of not having standing infrastructure to maintain is compelling, especially for systems which are transactional and event-driven in nature. In this talk we'll look at real-world examples of how this plays out.

We'll go through the following:

  • The 'function-as-a-service' execution model as it applies in AWS lambda
  • When and when not to use this model, and how it maps onto other concepts such as domain driven design, CQRS and event sourcing
  • How to build functions using a variety of different languages and platforms
  • Deployment techniques
Preparing SQL Server to be Hacked
Room 2210

They are going to get in. This session talks briefly about how they get in. But they are going to get in. It talks a little about security best practices. But one little mistake by anyone and they are in. How will you know they’re in? How will you know how they got in? What do they want? How will you know what they’re doing? How will you know if you’ve kicked them out? This session will focus on the type of logging and tripwires you’ll need to respond to a breach of your SQL Servers. It includes a mix of technical solution and process recommendations based on actual incidents.

Open Source Game Development in C#
Room 2211

With so many frameworks to choose from, aspiring game developers are often overwhelmed with options. In this session we’ll explore the decisions that go into objectively choosing the right framework for your project. Next we’ll look at a game engine named Duality: a flexible and open source framework for developing 2D games in C#. I’ll show you the basic constructs of game development and walk you through creating a simple game in Duality.

IoT with the ESP8266 and NodeMCU Firmware
Room 2214

Espressif makes a highly integrated SoC known as the ESP8266-EX that combines a microcontroller with a Wi-Fi stack on the same silicon. This chip, combined with flash memory and an antenna, is sold as a FCC/CE-approved module for under $3. Breadboard-friendly DevKits that combine the module with USB serial port and power components are available for under $7.

We will explore how to write software for this tiny platform, primarily focusing on the use of an open-source firmware known as NodeMCU. Using scripts written in Lua, we’ll see how to connect to a network, read data from other devices and sensors, and communicate with services on the internet—the types of activities that a tiny Thing would need to do!

StealJS: The future of JavaScript modules and dependency loaders
Room 2215A

ESModules have been in the JavaScript standard for almost 2 years now, and browsers are finally dipping their feet into the problem of how to get JavaScript modules to the browsers.

Today, you may use webpack, browserify or some other bundler to package up your JS for the browser, but let me introduce you to StealJS.

StealJS is super easy to use, but also supports a ton of features including supports for any module format (AMD, CommonJS, UMD, and ES Modules), bundling, advanced code-splitting, npm modules, hot-module swapping, asset loading, preprocessors, babel transpiling and more.

Badass 101
Room 2215B

Would Chuck Norris ask you to come hear him speak at a conference? No, he wouldn't. He would TELL you that you're coming, and then roundhouse kick you in the face if you gave him any more lip. "What would Chuck Norris do?" is a philosophy this session will cover in depth. Other topics include: badass vs a-hole, human duck typing, the art of [not] caring, instrumentality, and what your facial hair says about you. You won't learn any new code in this session, but you might unleash a Pandora's box of awesomeness that will change the way you interact with your coworkers forever.

Beyond Patterns: Functional Programming and the Nature of Order
Room 2215C

Design patterns have been a part of the vocabulary of software engineering for some time. The patterns community in software development drew inspiration from the work of architect Christopher Alexander, at the UC Berkeley Center for Environmental Design.

Alexander's work throughout the early years of the 21st Century, however, has shifted its focus to more fundamental levels of architecture and aesthetics, looking beyond patterns to The Nature of Order. The renewed focus is on the properties and transformations that underlie both aesthetics and functionality.

This talk describes an understanding of the craft of software design that takes its inspiration from The Nature of Order as an earlier generation did from A Pattern Language.

We will introduce the concepts of centers, of fundamental properties, and of their corresponding transformations, and explore something of how these concepts are used to construct functional software fully adapted to its requirements, but with the flexibility to gracefully adapt to changing circumstances.

The Nature of Order's emphasis on structure-preserving transformations holds a thematic correspondence to the functional programming paradigm, allowing us to illuminate this understanding through examples in the Scala and F♯ programming languages.

Closing Remarks and Prize Drawing Friday 4:30