-
"Did you get my message?" - A comparison of several modern messaging platforms
A programmer looking for a flexible messaging solution is faced with many questions and tradeoffs: What tool will offer the best performance? What will give the best flexibility and extensibility? Do I need a persistence layer or a cache?
Depending on the specific application area and the structure of the data being transmitted, the requirements will be different: for example, an electronic options trading engine has different needs from a SaaS web application.
This talk will compare a variety of contemporary messaging solutions and the benefits and tradeoffs involved:
- Kafka offers a persistent datastore and a clustering solution based on a "pub-sub" (publish-subscribe) architecture;
- RabbitMQ is a message broker that implements the Advanced Message Queueing Protocol;
- ZeroMQ implements a brokerless architecture that provides a socket-like abstraction to enable a variety of possible message distribution patterns.
And finally: what do you gain and what do you lose from rolling your own simple messaging solution? Under what circumstances is the DIY approach the best one?
This talk offers a fast tour through a variety of messaging technologies and compares the pros and cons of each technology. Examples are shown in Python to favor simplicity and brevity of presentation over implementation details. -
12 Factor Apps Mobile Edition
Modern mobile apps have progressed beyond the basic set of a few screens calling into a REST service. They’re big and complicated and live long lives. If not done well they can become maintenance nightmares or worse yet, open up security risks to your backend infrastructure. Inspired by the 12 factor app set of guidelines and iOS-factor.com this talk takes a hard look at the bad practices we use today in mobile development and talks about what we should be doing instead. Whether you’re responsible for writing Android or iOS apps this talk will help you level up your app and maybe even prevent you from accidentally DDOS’ing your backend services.
-
12 skills every rookie programmer should have, but often don't
12 skills every rookie programmer should have, but often don't
Students coming out of college, or the newly popular coding bootcamps, are eager to get working in the business world of programming. Unfortunately, many college programs and bootcamps are leaving students ill-prepared for life in the working world of computer professionals.
In this talk, I'll present a dozen areas of knowledge that every programmer should know, but may not have learned, or learned with enough depth. We'll cover techncial skills like SQL and regular expressions, soft skills like working effectively with other coders, and everything in between.
If you're looking to make the leap into the world of programming, or to make your first big move to the next job, you'll learn where you should beef up your skills to make sure you can hit the ground running. -
7 Languages in 7 Hours Part 1
Hands on experience in seven different languages, ranging from object oriented to functional, from the cozy and familiar to the eye squintingly terse and foreign. You'll work through a familiar kata in each of them, showing you how to approach an entirely new language. You'll learn about the strengths and weaknesses of each language out in the real world. You'll also see how each
language's quirks can teach us ways to improve the code we write every day.
You may not come out of this precompiler an expert in all of these languages, but you'll have learned a lot about how to get started with a new one. You may even discover a new passion! At the very least, the next time a new language comes along, you'll have the tools you need to tackle it, and enough knowledge to help you push past the "what is this syntax even doing" barrier.
Languages: Ruby, Clojure, Haskell, Rust, Elixir, Go, Elm -
7 Languages in 7 Hours Part 2
Hands on experience in seven different languages, ranging from object oriented to functional, from the cozy and familiar to the eye squintingly terse and foreign. You'll work through a familiar kata in each of them, showing you how to approach an entirely new language. You'll learn about the strengths and weaknesses of each language out in the real world. You'll also see how each
language's quirks can teach us ways to improve the code we write every day.
You may not come out of this precompiler an expert in all of these languages, but you'll have learned a lot about how to get started with a new one. You may even discover a new passion! At the very least, the next time a new language comes along, you'll have the tools you need to tackle it, and enough knowledge to help you push past the "what is this syntax even doing" barrier.
Languages: Ruby, Clojure, Haskell, Rust, Elixir, Go, Elm -
7 Reasons why your microservices should use Event Sourcing & CQRS
Event Sourcing & CQRS offers a compelling and often controversial alternative for persisting data in microservice systems environments. This alternate approach is new for most of us, and it is justified to have a healthy level of skepticism towards any shiny new and often over-hyped solution. However, what is interesting is that this is so new that even the champions and evangelists often overlook the real benefits provided by this new way of capturing and storing data.
In this talk, we will look at 7 of the top reasons for using Event Sourcing & CQRS. These reasons covered go beyond the often referenced benefits, such as event stores are natural audit logs, or offering the ability to go back in history to replay past events. The primary goal of this talk is to flip your view from limited to no use of ES & CQRS to an alternate perspective of what you give up when you elect to not use it as the go-to persistence strategy. -
A Better, Faster Pipeline for Software Delivery
The software delivery pipeline is the process of taking features from developers and getting them delivered to customers. The earliest tests should be the quickest and easiest to run, giving developers the fastest feedback. Successive rounds of testing should increase confidence that the code is a viable candidate for production and that more expensive tests—be it time, effort, cost—are justified. Manual testing should be performed toward the end of the pipeline, leaving computers to do as much work as possible before people get involved. Although it is tempting to arrange the delivery pipeline in phases (e.g., functional tests, then acceptance tests, then load and performance tests, then security tests), this can lead to problems progressing down the pipeline.
In this interactive workshop, you will learn how to arrange your pipeline, automated or not, and so each round of tests provides just enough testing to give you confidence that the next set of tests is worth the investment. You'll explore how to get the right types of testing into your pipeline at the right points so that you can determine which builds are viable candidates for production.
Attendees should be at least roughly familiar with their current delivery process, or at least have a process in mind. No prior knowledge of DevOps, continuous delivery, or automation is assumed. -
A Crash Course in Video Game Pyschology
Why do people play games, anyway? Are video games helpful or harmful? How do video games affect our social lives? What makes a game's design good, or bad? These are just a few of the topics that fall under the large umbrella of video game psychology. I'm both an avid gamer AND a psychology nerd, and I want to share what I've learned about the psychology of video games. I believe that understanding more about how and why people play games makes for better games.
-
A Hands-on Intro to Containers
Containers are one of the hottest technologies in our industry today. They are like virtual machines but smaller and faster. They can provide on-demand, disposable test environments that start quickly, repeatably, locally or in the cloud. When you want, you can tear down the environment and recreate a pristine copy within seconds. And since the process is automated, anyone on the team can use the same commands to get their own test systems. Then, when you finish testing, those containers can be deployed directly into production. At each stage, the environments for development, test, and production will all look and behave the same.
This workshop is a hands-on introduction for anyone interested in learning about containers in general and more specifically Docker–you will need your laptop. You will walk through building docker containers, starting out simple but moving to more pragmatic setups. You’ll test those systems locally and in the cloud. As you iterate, you will build out tests and capabilities. And then Gene will show you how all of this evolves to a full-blown, production-ready setup. -
A Primer on Functional Programming
Functional programming languages are gaining in popularity. If you’ve worked in object-oriented languages, you might be baffled at how they work. Maybe hearing the word “recursion” makes you want to scream. Or maybe you’ve just heard the hype and want to know what the hype is about.
In this talk, we will briefly explain what functional languages are, and go into some examples of tasks that these languages are suited for. We will look at the major languages in use today and see how they work. We'll see some of the things they have in common, and the many things that make them distinctive. Finally, we’ll offer some suggestions on how to dive into learning these and using them on your own projects. -
A Slimy Adventure
Adventure into the exciting world of slime. Have you ever wondered the difference between fluffy and crunch slime? Learn about the chemical reactions and ingredients that create these versions of slime. Leave with samples of each to share your slimy adventures with all your friends.
-
A Swift Intro to iOS
With the introduction of Swift, iOS has become a friendly platform to get started in. From configuring your new project, to creating and manipulating views in Swift, we’ll cover everything you need to get started in iOS.
This will be a great talk if you’re new to development, new to iOS, or are just interested in the mobile development process. No previous knowledge required, if you’d like to follow along, please bring your Mac with the latest Xcode installed. -
Accessibility Testing Techniques for Designers and Developers
Most companies wait until late in the development cycle to add accessibility features to websites and apps. But the process of finding and fixing accessibility problems when the product's almost out the door can take a long time. It saves a lot of time and effort to test for accessibility as features are being designed and developed, because it's easier to make changes to a feature when it's still a work in progress. There are a lot of simple techniques and free tools you can use to evaluate designs and code-in-progress. In this session, I'll show some of the best tools and techniques my team and I use when we're designing and building web applications.
-
Accessibility: A Walk in Someone Else’s Shoes
Everyone talks about accessibility - or a11y - but how often is accessibility a primary thought during your development pipeline? How often is accessibility taken for granted? It’s easy to push it aside and say you’ll do it later or to forget entirely. It’s easy to drop a couple WIA-ARIA tags into your HTML and move on, but this doesn’t address many accessibility needs. When was the last time you used your website with your eyes closed?
Let’s do just that. Let’s try to navigate a website with a blindfold on. Let’s try to use a website without a mouse. Let’s try navigating a website with a visual impairment. And then let’s fix the problems encountered.
We will focus on experiencing website with two types of impairments:
* Visual impairments, such as color blindness, low visual acuity, and a complete lack of vision
* Mobility impairments, preventing users from using a mouse for input
These impairments of quite common and are simple to simulate using a combination of browser extensions and existing tools in your operating system. For each impairment, we will look at how the markup (both the semantic structure and the attributes), the colors and contract, tab order, and focus affect the experience. And for each issue we encounter, we will look at specific ways that experience can be improved.
Last, we will look at testing strategies to audit your code for potential accessibility issues, using extensions such as Google’s Lighthouse, Deque’s axe-engine, and others. -
AI Based Testing - The future of test automation
Artificial Intelligence and machine learning are advancing at a rapid pace. Companies like Apple, Tesla, Google, Amazon, Facebook and others have started investing more into AI to solve different technological problems in the areas of healthcare, autonomous cars, search engines, predictive modeling and much more. Applying AI is real. It’s coming fast. It’s going to affect every business, no matter how big or small. This being the case how are we as Testers going to adapt to this change and embrace AI? Also, in the era of where we want to automate everything, how is AI going to influence the way we do test design and automation? Come join this session, where I cover the basics of AI, discuss the key ways software testing can benefit from AI and the challenges involved in implementing AI based solutions. Attending this session will help anyone to get started with AI based testing.
-
AI for Earth: Innovations in Data Collection for Machine Learning
The AI for Earth program applies machine learning and data science to hard challenges in agriculture, water, climate, and biodiversity. The lifeblood that powers machine learning is data. Many AI for Earth grant recipients have developed innovative ways to collect data. I'll showcase the usage of UAV/drone imagery, camera trap data, simulation, crowdsourcing, and social media to gather data for some interesting machine learning problems in the conservation and sustainability space. We will cover the innovations in how data is collected, as well as the machine learning algorithms used to solve these challenges.
-
Alternative Device Interfaces and Machine Learning
In this presentation, we will look at the how users interface with machines without the use of touch. These different types of interaction have their benefits and pitfalls. To showcase the power of these user interactions we will explore: Voice commands with mobile applications, Speech Recognition, and Computer Vision. After this presentation, attendees will have the knowledge to create applications that can utilize voice, video, and machine learning.
-
Always Be Delivering
What do Facebook, Google, Netflix, LinkedIn, WordPress and Etsy all have in common? They are all well known IT organizations that practice continuous delivery and deployment (CDD). This helps them reduce the risk associated with releasing code, improve system resiliency, and reduce overall software development costs. At any point and often multiple times per day, they deploy the latest changes to their production environment with full confidence because their builds have been tested automatically. In this session you will learn how to continuously deliver with confidence. You will learn how to set up a development pipeline for a sample application. Step by step, individual tasks will be assembled and linked together to form a pipeline that takes a code change from source control all the way to a live production environment. But a pipeline is just the start. Along the way you will learn how you can use feature toggles, fast failures, small changes, and optimized tests to encourage a culture of CDD right now.
-
Android Jetpack - Make Better Apps
tl;dr - Make better apps faster with Android Jetpack.
I could explain Android Jetpack at a high level, but I'll let the Google marketing team take care of it:
"Jetpack is a collection of Android software components to make it easier for you to develop great Android apps. These components help you follow best practices, free you from writing boilerplate code, and simplify complex tasks, so you can focus on the code you care about."
Sounds great, right? But what exactly are these components? They're collections of libraries, separate from the platform APIs, which we can bring into our apps as we wish. Each component can be added separately as needed without worry about which version of Android our users are on.
We'll cover all four types of components (Foundation, Architecture, Behavior, and UI), discuss how we can use key components, and even go through an app made from the ground up with Jetpack in mind. -
AngularJS to Angular 6 Migration
This talk will walk you through the process of migrating your AngularJS app to Angular 6. Learn the preparation steps that are needed, what build and dev tools you might want to use, how to setup a hybrid app, and how to convert your ng1 components and services to ng6.
-
APIs on the Scale of Decades
"APIs are hard. They are pretty much ship now, regret later." -- Chet Haase.
What do Greek philosophy, early video games, and Japanese bullet trains tell us about how we should design our APIs?
Writing any old API is easy. Writing an API that can evolve to meet your needs over the coming months, years, and even decades; now that's hard. We'll look at some common practices and try to see where they go wrong, some misunderstood techniques and how to use them better, and some less common practices that might be useful.
Let me give you some good advice that'll help you evolve your APIs, and some big ideas that might provoke some interesting thoughts. -
Asynchronicity: concurrency. A tale of
When starting to dabble with Javascript, the biggest challenge for most developers is understanding how to deal with asynchronous development. During this talk, we will cover some of the different ways to handle async programming like callbacks, promises, generators, async/away and events. As we cover those, we will also plunge into some of the mechanics of the NodeJs engine, namely the event loop. Developers attending this talk will have a better understanding of asynchronous programming and will have a few new tools to their belt to tackle those issues as they come.
-
Augmenting Retro Consoles with New Hardware
In 1992, I got a Super Nintendo for my birthday. I still have it. In 1999, Nintendo stopped manufacturing of the SNES and accessories. My SNES still works, but the controllers are long dead.
This is the story of how I built replacement electronic guts that interface with the now nearly 30 year-old hardware, and the journey along the way. -
Automating the Software Delivery Pipeline: DevOps in the Real World
DevOps has been a buzzword for quite a few years. But to truly implement DevOps, an organization must be willing to blend the development group with operations. This is very difficult, as development tends to think in terms of backlog, but operations tends to think in terms of tickets. From experience, this purist form of DevOps rarely works. But there is one concept that seems to be universally accepted as a DevOps practice that can radically alter the effectiveness of your organizational software delivery: automating the delivery pipeline.
This session focuses on the idea of continuous everything, taken from years of experience consulting clients in building pipelines to support microservices architecture. The concepts and practices presented in this session are easily migrated to other architectural forms. In general, the session covers practices starting with “continuous”, including Continuous Integration, Continuous Testing, Continuous Delivery, and Continuous Inspection. While this content of the session is tool agnostic, you will be presented with a sample set of tools that you can use to automate different portions of your software delivery pipeline, including Jenkins, Chef and Puppet, Bamboo, and Docker.
Topics you will learn include:
* How to build a toolkit for automating your delivery pipeline
* Sample roadmaps to get from zero to complete automation
* The importance of different types of monitoring
* Migrating to a DevOps culture -
Avoiding Landmines – A Tech Leader’s Guide for the Critical Decisions
As leaders, we face a lot of decisions that can make or break our teams and projects. We usually approach these decisions without training, and with no decision making framework to guide us. This does not work particularly well.
In this workshop, you'll learn a framework that will help you kick off your projects and get the early decisions right. You'll learn how to align your people, process, and technology with the needs of your projects, company and customers.
This highly collaborative workshop will challenge you with real issues faced by today's development teams, ask you to think through multiple decisions, and share your insights. You'll leave with the tools necessary to make good, situationally-aware decisions that lead to success. -
Be an A11Y with React
When discussing diversity and accessibility, frameworks are often used as scapegoats: “It’s too hard to do it with {{ framework_name_here }}”. It’s an excuse. Most modern frameworks are built with accessibility in mind, and implementing accessibility often takes no time at all. We will tackle some of the most common accessibility patterns using React, explore some libraries that make accessibility even easier, and testing tools and strategies to ensure that accessibility isn’t overlooked.
-
Becoming an Effective Mentor
Have you ever thought about becoming a mentor but didn’t know how to get started? Mentoring is a valuable tool for professional development that can result in positive outcomes for both the mentor and the mentee.
In this session, you will learn:
- How to identify the specific skills and strengths that you could potentially offer as a mentor.
- Strategies for how to build formal and informal mentoring relationships in the workplace.
- Best practices for communication in mentoring, including how to give constructive feedback and understanding the importance of of active listening.
- Strategies for overcoming common fears that might be preventing you from wanting to become a mentor. If you’ve ever considered becoming a mentor but felt that you didn’t have enough time, that you’re too much of a beginner yourself, or even that your communication skills might be holding you back, this session is for you. -
Begin Your Machine Learning Journey in the Public Cloud
Machine learning is a transformative technology that empowers you to unlock predictive insights from complex data. As this technology continues to evolve, the major public cloud companies are investing in new and evolving machine learning platforms and tools that enable developers to surface and integrate usable models while abstracting away much of the complex data science requirements of traditional machine learning programs.
In this presentation, we will explore the machine learning offerings from AWS, Azure, and GCP. We will focus on giving you an objective overview of the approach, strengths, and weaknesses of each individual cloud platform. By the end of the session, you will understand the best ML cloud platform for you based on your technology needs, sophistication with machine learning algorithms, and your desired target for surfacing your insights.
Prior experience in machine learning is not required. -
Best Practices for Robust API development in ASP.NET Core
This workshop will walk developers through the design and implementation of a robust API layer using Visual Studio 2017, C#, and the ASP.NET Core stack. Today's client-centric architectures frequently involve a mix of UI frameworks such as Angular, React, or even native mobile apps targeting iOS, Android, or Windows devices. One common requirement for each of these modern application frameworks is the need to communicate data back to the server via an easily accessible API layer. As developers who frequently work on both the API and the client, the overall development process needs to support the ability to quickly add code to both layers and to have an efficient debugging experience.
This class will walk all attendees through designing such an API on the Microsoft stack that is flexible, easy to debug, easy to extend, and supports a number of advanced features commonly required by today's architectures. As the class progresses we will work through the full implementation of a secure API that demonstrates a wide variety of real-world scenarios. We will discuss and demonstrate a clean, back-end architecture isolating all data access into an organized repository layer utilized by higher-level business services. We will also demonstrate how this API can be utilized across a number of UI frameworks including an SPA written in Angular and a cross-platform mobile application developed in Xamarin. The focus will be on setting up an efficient development process between these clients and the API. All students will be encouraged to implement all features locally and the overall content will be presented in a very "hands on" manner. All code and sample projects will also be provided via a public GitHub repository so that attendees can leverage the core concepts in their own projects upon completion of the course. -
Best Practices for Robust API development in ASP.NET Core (Part 2)
This workshop will walk developers through the design and implementation of a robust API layer using Visual Studio 2017, C#, and the ASP.NET Core stack. Today's client-centric architectures frequently involve a mix of UI frameworks such as Angular, React, or even native mobile apps targeting iOS, Android, or Windows devices. One common requirement for each of these modern application frameworks is the need to communicate data back to the server via an easily accessible API layer. As developers who frequently work on both the API and the client, the overall development process needs to support the ability to quickly add code to both layers and to have an efficient debugging experience.
This class will walk all attendees through designing such an API on the Microsoft stack that is flexible, easy to debug, easy to extend, and supports a number of advanced features commonly required by today's architectures. As the class progresses we will work through the full implementation of a secure API that demonstrates a wide variety of real-world scenarios. We will discuss and demonstrate a clean, back-end architecture isolating all data access into an organized repository layer utilized by higher-level business services. We will also demonstrate how this API can be utilized across a number of UI frameworks including an SPA written in Angular and a cross-platform mobile application developed in Xamarin. The focus will be on setting up an efficient development process between these clients and the API. All students will be encouraged to implement all features locally and the overall content will be presented in a very "hands on" manner. All code and sample projects will also be provided via a public GitHub repository so that attendees can leverage the core concepts in their own projects upon completion of the course. -
Better Names for Better Code
As developers we spend much more time reading code than we do writing it. It’s important that our code conveys its meaning clearly, not just to the computer but also to other developers. When our code is full of names like doStuff and temp1 it can be hard to figure out what’s going on. This can cause confusion which leads to bugs and delays.
In this talk you’ll see concrete examples of how poor naming can cause big problems. We’ll then fix these issues while introducing tips for quick and effective naming. By the end you will have a clear understanding of what makes a good name, and how to improve your own code. -
Build a Binary Clock with a Raspberry Pi Zero Workshop
Have you ever wanted to be the geekiest kid around? This session will earn you the crown. In this session, you build a clock that likely only you can read because it will display the time in binary (1s and 0s or on and off). You will learn how to control LEDs using a Raspberry Pi Zero. Along the way you will learn a little programming with Python to determine the time and control the LEDs. But of course, you will also have to learn to read binary.
-
Build Your First Design System
Are you considering a design system for your organization? Design systems have grown in popularity over the last several years because of their utility in helping organizations maintain good UI standards and consistency, but they require forethought and planning. In this pre-compiler, you’ll learn about many of the challenges and considerations that go into building a design system. Then, you’ll get your hands dirty building a starter design system using a Node-based build system called Drizzle. You’ll start with an existing website of your choice and learn to extract re-usable patterns to include in your design system.
Your workshop hosts, Kasey Bonifacio and Nathan Rambeck of Sparkbox, have helped many clients build design systems for their organizations. During this half-day workshop, they will walk you through the following:
- Evaluating your design system needs
- Challenges to consider when building a design system
- Install Drizzle
- Build a color system
- Build a typography system
- Build some layout utilities
- Build a button component
Requirements
- Laptop running macOS 10.8+, Windows 7+, or some modern version of Linux
- Node.js v6 or higher
- Code Editor -
Build your own A.I. powered robot - Part 1
The need to jump on the AI track is more relevant than ever. With the commodity of hardware and the computing power of the Cloud, Artificial Intelligence is at our fingertips and waiting to be implemented in new innovative solutions.
This workshop gives a quick start in the world of AI by combining Windows IoT, a Raspberry Pi with some sensors and the power of Microsoft Cognitive Services.
You will learn how a Raspberry Pi works, dive into topics like face identification, language understanding and how to train your own vision model.
The workshop is very hands-on and at the end you have made a robot that can talk and uses its vision and ears to interact with its surroundings. The bot will run on a Raspberry Pi powered by Windows IoT. The bot will be able to see, hear and talk using different Cognitive Services.
What you will learn:
• Windows IoT
• Raspberry PI with sensors
• Face detection API
• Language Understanding
• Custom Vision
After the workshop, you know what Cognitive Services are and have hands-on experience implementing them in a program. You can connect sensors to the Raspberry and use their capabilities in your programs.
Who should attend:
This workshop is for you if you:
• Want to learn what all the different Cognitive Service are and how to use them.
• Learn about the Raspberry Pi works and write software for it.
• Play around with hardware and like connecting wires and sensors
What to bring:
Bring your laptop running the latest Windows 10 and Visual Studio 2017. You will need an Azure subscription to activate the Cognitive Services APIs, if you don’t have one please create one before the workshop.
Read this before attending: https://github.com/hnky/Workshop-AI-Pre
The AI revolution is coming, and you can be part of it! -
Build your own A.I. powered robot - Part 2
The need to jump on the AI track is more relevant than ever. With the commodity of hardware and the computing power of the Cloud, Artificial Intelligence is at our fingertips and waiting to be implemented in new innovative solutions.
This workshop gives a quick start in the world of AI by combining Windows IoT, a Raspberry Pi with some sensors and the power of Microsoft Cognitive Services.
You will learn how a Raspberry Pi works, dive into topics like face identification, language understanding and how to train your own vision model.
The workshop is very hands-on and at the end you have made a robot that can talk and uses its vision and ears to interact with its surroundings. The bot will run on a Raspberry Pi powered by Windows IoT. The bot will be able to see, hear and talk using different Cognitive Services.
What you will learn:
• Windows IoT
• Raspberry PI with sensors
• Face detection API
• Language Understanding
• Custom Vision
After the workshop, you know what Cognitive Services are and have hands-on experience implementing them in a program. You can connect sensors to the Raspberry and use their capabilities in your programs.
Who should attend:
This workshop is for you if you:
• Want to learn what all the different Cognitive Service are and how to use them.
• Learn about the Raspberry Pi works and write software for it.
• Play around with hardware and like connecting wires and sensors
What to bring:
Bring your laptop running the latest Windows 10 and Visual Studio 2017. You will need an Azure subscription to activate the Cognitive Services APIs, if you don’t have one please create one before the workshop.
Read this before attending: https://github.com/hnky/Workshop-AI-Pre
The AI revolution is coming, and you can be part of it! -
Building a better audit log
Developers know that adding logs helps with debugging, but there’s more to logging than just dumping out data to find a bug. A good audit log can also help detect malicious activity, or provide evidence during an investigation.
Unfortunately, many application logs do not provide the details that are helpful for tracking down security issues. This session presents a good set of guidelines for logging so that application logs can address security issues, and also touches on relevant regulations that specify what should, or should not, be included. -
Building A Highly Scalable Service that Survived A Super Bowl
Would you bet your career and your company's reputation on a technology you've never used in front of 110 million people tuned into a Super Bowl commercial? Well, I did. And I was a nervous wreck! We were launching a new product during a commercial at the Super Bowl 302 days away, and I was betting everything on a technology we had never used in production. I spent countless nights wavering back and forth thinking about the millions of dollars and hundreds of thousands of person hours that were on the line. Everything was resting on the shoulders of this one web service that had to handle the excessive load placed upon it when our commercial aired. The technology chosen was Erlang, a mystical, functional, dynamically compiled language that was very foreign to this eight-time Microsoft MVP. This is a story about picking the right tool for the right job, exploring other possibilities, and the difference between playing with technology and putting it into production. As a noted storyteller, I'll take you on the journey of:
*how we stumbled upon Erlang during our dedicated innovation time
*what made it so special that we were willing to take such a risk
*what we learned along the way
*how it performed
*and would we do it again
If you love a great technology story, I hope you'll join me for this tale of how this web service, built in unproven technology to us, survived Super Bowl Sunday. -
Building a Production-Ready React Native App
React Native makes starting a mobile app remarkably simple, but a lot of complex problems lie between generating an application and building something production-worthy. Things one might take for granted in other front-end environments, like navigation and unit testing, are surprisingly difficult in the React Native world.
In this session, we'll tackle the hard problems of React Native head-on. Attendees will learn not only how to bootstrap a React Native app, but also how to write an application that can scale and truly succeed in the app store. We'll focus on modularization, navigation, animations, and testing, and we'll also dabble in writing our own native bridges as well as discovering some of the coolest tricks in the React Native world. At the end of it, we'll have the first few screens of something that could be a real application - not another todo list! -
Building An AppSec Program From The Ground Up: An Honest Retrospective
This talk will cover the lessons learned from a 2-year journey starting an appsec program at a small-medium sized DevOps driven company that previously had no security program. This will be an honest look at what worked, what didn't work, as well as a follow-up analysis. There will be plenty of stories, common sense perspective, as well as discussion around goal-setting and execution. This will be the talk I wish I had two years ago when I was starting this adventure.
From this talk, you'll walk away with:
* honest assessments of "best practices" and how they apply to security in DevOps environments (and a call to action to think critically about best practices!)
* recommendations of how to setup a DevOps oriented security program
* practical ideas on where to spend time and what to delay
* some entertainment at the expense of some of my failures in learning these lessons -
Building Blocks for Beautiful Cross-Platform Applications!
Tired of writing two separate codebases for your mobile application? Flutter is a framework for building mobile applications that can run on Android and iOS with one codebase. It offers an excellent developer experience with a speedy subsecond hot reload to iterate quickly in development and provides a great way to build a polished application that runs on both major mobile platforms. In this session we will go over: setting up the Flutter toolchain, building a UI component, and retrieving data from the network.
-
Building Letters for Livia in an Hour
When a friend texted me asking if I could build an app for him, I assumed he had a business opportunity in mind. Instead, he shared with me how a friend's daughter had just come out of a coma, and only had control of her eyes. They currently had no way to communicate beyond yes and no, and were struggling to find a way to spell out words. Despite having only used Vue.js for a few months, I was able to build a very simple app to allow them to communicate words and feelings. In this session, I'll explain how I created the app and deployed it to Amazon, enabling them to use it about an hour after the request.
-
Building Mobile Applications with the Ionic Framework
Have you wanted to start developing mobile applications, but have found that selecting the right technology, framework, and language is overwhelming? Ionic provides a framework that allows developers to build applications using familiar web technologies in order to produce a native application experience for iOS, Android and Windows Phone. Unlike other frameworks that can be extremely expensive, Ionic is completely free and backed by a vibrant community of millions of developers who have used Ionic to build more than 5 million apps. This talk will provide a brief introduction to Ionic and will look at how to get started developing, testing and deploying your apps. We will also look at how to take advantage of native phone services using Ionic.
-
Building Products Sustainably with Resilient Teams
Building teams is a fundamental requirement for building and running large applications. Employee retention is one of the most significant challenges that management experiences, often because of balancing engagement against burnout. Yet, our companies need to keep running their existing services, while building new features.
Leveraging his many years in Operations Engineering and running Product Teams, “Waldo will cover the ways that organizing around product teams rather than functional roles will:
- keep people engaged with a high degree of ownership,
- prevent burnout, attrition, and feelings of disempowerment by keeping authority aligned with responsibility,
- allow the company to make informed decisions when new features may be built and run,
- enable the company to determine when more capacity needs to be added to teams,
- prevent applications from becoming orphaned or “Legacy”.
You will learn why organizing around job function rather than products causes more problems than it solves, as well as some of the pitfalls that must be negotiated or avoided when making a transition to a product-oriented structure. -
Building Reusable, High Performance ETL Systems
Batch systems for processing Extract-Transform-Load (ETL) jobs are common at most business-to-business companies. In this talk, we will cover our approach for handling these processes using a variety of open-source .NET libraries (including a demo). We will cover common pitfalls we have run into while processing 100+ different file types, and how we were able to automate these processes end-to-end using a highly configurable service-oriented system.
-
Building Your First React App
In this full-day workshop, you’ll learn how to build a single-page app with React. We’ll discuss the fundamentals of React development, the “React” way of building apps, and suggestions for writing maintainable React code. You’ll get hands-on experience with JSX, React Router, several methods of managing state, and testing tools like Jest and Enzyme.
We’ll be creating an app to manage all the adorable kittens in our lives. The React landscape is extensive, and we can’t cover it all - but you’ll leave this workshop feeling confident to build your next app with React.
This session includes a healthy balance of instruction and hands-on activities. We’ll cover a broad variety of topics required to build a React app:
* React fundamentals
* Modern features of JavaScript that ease React development
* The ‘Component’ mindset
* JSX, a strange-looking hybrid between JavaScript and HTML
* Verifying component inputs
* Styling React components
* Routing
* State management
* Automated testing
* Best practices
Experience with HTML, CSS, and JavaScript is required. You’ll need Git v2.15.0 or higher, NodeJS v8.9.4 or higher, NPM v5.6.0 or higher, and a text editor of your choosing.
A URL with specific prerequisite instructions and code/instructions for the exercises will be provided prior to the event. -
Building Your First Video Game with Bloxels.
Do you want to build a fun game that you can play on your device? Do you want to create your own artwork to add to the game? Then you ought to try out Bloxels.
Bloxels (http://home.bloxelsbuilder.com/) is a system that lets you create characters, obstacles, and backgrounds by laying out blocks in a grid. Then you scan your creation into your tablet and configure a game around what you created.
It is easy to get started with Bloxels, but you can build large games that are fun to play. -
Building Your First Voice Experience with Alexa
This workshop will dive right in to getting you set up and started building a voice-based experience with Alexa. You will leave this session with a working Alexa skill that you can customize and publish as your own.
We will cover topics around voice design best practices, voice interactions, persistence, and making calls to external APIs.
This session will be taught using node.js, but you don't have to have prior experience as a node developer.
PREREQUISITES
In order to get off to a fast start, please create accounts on both of these websites before the session:
Amazon Developer Portal - http://developer.amazon.com
Amazon Web Services - http://aws.amazon.com -
Building Your Team to Last
Hiring and onboarding new team members is an expensive and risky process. It's crucial to hire people who mesh well with the existing team and get them up to speed in a timely manner. Balancing this while minimizing the initial impact on productivity is often a challenge for even the most experienced lead developer.
This talk will cover some tips on building your successful team. We'll discuss:
* How to choose the right types of people to add to your team.
* How to onboard and mentor your new team members, including patterns of ineffective mentoring and why they're harmful to the team.
* How everyone can benefit from bringing on junior developers and interns the right way.
By the end, you'll see how your whole team will benefit from these strategies. -
Can DevOps and Security be Friends?
Security for DevOps is only getting more complicated. 2018 saw a whole new class of CPU vulnerabilities, not to mention an explosion of hosted cloud infrastructure options. How should DevOps folks address security concerns while also, y'know, doing all the other things their job requires?
In this talk, we'll go over how to think about securing infrastructure more like a cool-headed economist and less like Chicken Little. We'll go over threat modeling and how to make pragmatic tradeoffs when cloud infrastructure security configuration is limited. We'll also go over how to measure progress (if you aren't into that sort of thing, your boss might be!) Lastly, we'll take these techniques and apply it to another 2018 darling, Zero Trust Networking, and separate the hype from projects that can make you more secure while decreasing operational toil. -
Charting a Course to Your Dream Job
As a technology professional, your career path can and probably will take many directions. The challenge is determining which directions are right for you. Are you no longer learning or growing at work? Do you want to change jobs but don’t know where to start? Do you feel stuck on a narrowly-defined path that doesn’t excite you? Whether you're just starting out or are the most experienced person on your team, this workshop will help you determine what's next in your career.
Through a series of guided exercises and discussions, you’ll examine your technical and professional strengths, preferences, and dislikes. You’ll reflect on your values and how they apply to your career. Along the way, discover how to do more of what you enjoy at your current job. Finally, you will learn about finding new opportunities with your employer or whether to seek something entirely new. Though you may not leave knowing exactly what you want to be when you grow up, you will leave with a clear plan for getting closer to that dream job. -
CircuitPython/MicroPython - How to get started
CircuitPython/MicroPython is a complete reimplementation of Python that runs on small devices like microcontrollers. It enables the building of cool stuff - like Internet of Things devices - by combining existing Python knowledge with a little bit of hands-on hardware hacking. How it works, how you can try it out, and how you can use it!
-
Climbing To The Top Of The Mobile Testing Pyramid
Planning to test a mobile application can be quite a confusing time. Real devices? Shrunk down browser? Device hardware? Using the mobile testing pyramid to guide our testing efforts allows us to be more efficient about our testing (and maybe development) efforts. In the end, all of our focus on making sure we get a quality product to our customer’s hands should be our top goal. We can all efficiently achieve that by using the mobile testing pyramid.
My hope is that with the real life examples in this talk of how we have used the pyramid, you will be able to walk away with a better idea of how to be more efficient at the different levels of the mobile testing pyramid. -
Code Checkup: Tools to check the health of your code.
Over time even the simplest project can grow into an unwieldy beast. Features are added and removed. Developers come and go. Using static analysis tools we can get an idea about what challenges are in store for us.
We will discuss how ReSharper, SonarQube and other tools can be used to expose any issues that may exist in our code base. This can help provide a fresh set of (computer) eyes to help keep your code base healthy. -
Code Reviews: That's a Great Idea!
We all know that code reviews are beneficial. We’ve been told time and time again that they should be part of our development process. But – like most best practices – a practical implementation is challenging (and time consuming). Your team is convinced they are a great idea. You’ll have an opportunity to squash bugs in the least costly of development times, learn new things from your talented teammates, and build a stronger foundation of trust. Awesome. Everyone is on board. But now what? What tools are out there? What are you actually looking for? How often should the reviews happen? In this talk, you’ll get a practical guide to making code reviews effective. Whether you’re the reviewer or reviewee: there are ways to make sure this really is a great idea.
-
CodeMash CryptoParty
Some people like to say that seeking encryption, security, and privacy only shows that you have something to hide. This is a snide remark, uttered only by folks who historically partake in great privilege. Those who have never once found themselves considered the “other”. To the contrary, we are all considerably more secure in our affairs, not just from the threat of oppressive, authoritarian governments, but from criminals, oppressive employers and partners, with proper application of strong encryption and privacy tools.
CryptoParty is a global, decentralized movement to inform folks about general security and privacy practices. These sorts of practices are generally applicable and valuable to folks looking to protect themselves from invasive mass surveillance and hackers. Beyond general privacy, and with current events what they are, there are a lot of folks looking to organize, protest, and participate in acts of resistance. Here, we'll learn these encryption and privacy basics along with how and when to apply them.
Come with your devices ready to install some tools and practice online privacy. -
Collaborate on your LEGO(R) vision
LEGO(R) sets are amazingly fun to build, but who has attempted to build a complete set without looking at the instructions? In this session, the kidz & adults will form teams and try to build one of sixteen different Creator sets without the instructions. Only one person from each team will be able to see the finished picture before the team starts building. That person must share their vision with the team, who will attempt to build the LEGO(R) set as close to the instructions as possible without peeking. The groups will learn different ways to collaborate during the session to build the most accurate Creator LEGO(R) set.
-
Collaborating on Infrastructure as Code with Terraform
Capturing Infrastructure as Code is great, but the real power lies in collaboration and reusability. This talk shows how open source tools like Terraform allow us to apply existing technologies and techniques like CI/CD, code review, Pull Requests, and more to Infrastructure as Code.
This talk is about stealing… it’s about stealing the existing technologies, practices, and workflows that application developers have had for years and applying them to the operations space using Infrastructure as Code.
The two primary components of the talk are:
1. What is Infrastructure as Code?
2. How does the free and open source tool Terraform enable new workflows using IaC?
Topics include:
- Using Terraform to provision cloud resources
- Collaborating on Pull Requests and code reviews
- Automatically testing infrastructure changes
- Pushing infrastructure changes as a result of a git-merge -
Collaborative Contract Driven Development
You are transition to microservices, you have remote teams, you are wanting to update existing services, you are doing all three. The consistent theme in all of these needs is that they require collaboration across teams and concerns. A common problem however with collaboration is that there is often a lot of wait time. Team A needs for team B to implement and deploy a service, update a service, or figure out why a service isn’t working correctly, this can be a very frustrating process and instead of collaborating you feel like you are competing! There is a better way though and that is with contract driven development!
In this presentation we will learn about the goals and processes behind contract driven development. Once we have the underlying principles figured out, we will switch to the practical and look at using Spring Cloud Contract to write contracts. Spring Cloud Contract offers several approaches for writing contracts and we will cover them so your organization can choose which would be the best fit. If you have been frustrated by wait times from with working other services and teams, then this will definitely want to attend this presentation! -
Comments are Useless and Other Controversial Opinions About Code
Almost all of us have at one point learned a Bad Coding Habit™ that is so ingrained into our processes that we don't even realize what we're doing. In this interactive session, a member of the audience will drive the speaker's laptop as we examine a piece of Poorly Written Code and challenge the habits used to write the code. We will address perceptions on why developers like to rely on comments and give suggestions for how code can be refactored for comments to be removed. By end of the session we will have Well Designed Code that will challenge perceptions on how to write Good Code and help improve overall Code Quality and Working Habits.
-
Common Characteristics of the Greatest Developers
This session takes a deep dive exploration into the common characteristics of the greatest developers of last century. As well as learning who the best of the best are, you can expect to cover a wide range of topics, from old school habits, to new school tricks, from wacky hacks, to vetted practices. Plan to leave with some new found insight into aspects you can put directly into your own work, all in hopes that you too can become one of the all time greats.
-
Connect Data and Devices with Apache NiFi
Apache NiFi is an easy to use, powerful, and reliable system to process and distribute data. It comes with a wonderful management UI, a large marketplace of standard Processors, and a great Open Source Community behind it. This session will show you how to move data across servers & networks. It will show you how to manipulate data, enrich data, and stream data through custom enrichment processors.
The talk is designed to walk you through the NiFi basics, while showing practical examples you can follow-along with. The examples will include showing how to perform data manipulation using a custom java processor, the ExecuteScript processor, with JavaScript and Python, and the JoltTransformData processor. Finally, it will show how you could prototype a REST service with Standard Processors! There will even be a light-bulb flashing from things happening in NiFi. -
Connected Data & the Graph Database landscape
In this talk, we'll review reasons why you should and should not use graphs, graphs in context of NOSQL as well as review the most popular graph database options.
Graph databases are the fastest growing and evolving category of database systems. Why have graphs grown so fast in popularity? First, they are designed for modeling data architecutres when working with highly connected data and can offer superior performance for analyzing highly connected data, especially in real-time. They also offer significant flexiblity and support on-the-fly, frequent schema changes, which is great for managing constantly changing data architectures. This talk will review the graph landscape and provide an overview of many options, specifically:
- Graph Database Use Cases
- When not to use a Graph Database
- Graph Databases in the NOSQL world
- Pros & Cons of Graph Database options, including: Arango, Cosmos DB (Azure), dGraph, JanusGraph, Neo4j, Neptune (Amazon), Spark + GraphX -
Continuous Delivery requires radical changes for testers
What does testing and quality look like in a Continuous Delivery world? Who does what and how? Is there still a need for testers or do developers do all of the testing? Is it really possible to achieve quality when you deploy to production many times each day? What should testers do when there is no time for a “testing phase”? These are some of the questions many in the testing community ask as the software development industry moves toward this new paradigm of design and delivery.
Continuous Delivery is a radical change in the way we build and deliver software and it requires a radical shift in the way we thing about and achieve quality. Join this veteran Agile coach as he shares his experience. In this presentation you will learn what has worked for several large organizations that have made the transition to this new approach.
Join Cheezy as he walks you through his Continuous Delivery World. He will start by building a definition of Continuous Delivery and explain why a company would want to go through such radical changes. Next he will walk through in detail the three fundamental areas within an organization that must change – Development, Operations, and Product Management. Not only will he talk about the details of those changes, he will give you the tools necessary to build your own roadmap. Finally he will talk about organizational changes companies can introduce that will make it easier to achieve this goal. If you are curious about Continuous Delivery or are in the process of adopting this advanced form of Agile this is one talk you will not want to miss. -
Convergence of Front-end Technologies
Helping determine best practices as a suckling apprentice was a daunting task. Thankfully, somewhat recent developments in the mobile and web space has made this task not only manageable but exciting! In the last couple years iOS, Android, and some parts of web ecosystem look to be converging to a similar set of best practices and technologies that will make multi-platform development efforts easier than ever.
-
Corporate Single Sign-On: Building an OpenID Connect Provider in .NET with IdentityServer
Often, companies have dozens of internal applications, all tied to managing the business. Authenticating users, managing user access, and protecting data endpoints separately can be a complete mess, but external single sign-on systems like Facebook Connect or Google aren’t always an option and commercial systems are expensive. Instead, you can build your own! In this workshop, you can learn to build your own single sign-on systems using IdentityServer, a trusted library that implements OpenID Connect and pairs well with the existing .NET identity elements that you know and trust. Through an in-house effort, you can have your own single sign-on system to manage users, protect data, and eliminate the mess.
Topics
- An introduction to OpenID Connect
- Building an Identity Provider with IdentityServer and OpenID Connect.
- Authenticating users: Building independent web applications authenticated by the Identity Provider.
- Authenticating users: Building independent native applications authenticated by the Identity Provider.
- Protecting data: Building data endpoints and APIs protected by the Identity Provider.
- Protecting data: Managing user identities and personally-identifiable information protected by the Identity Provider.
- Authenticating services: Building offline services and jobs that need to access protected data.
- Managing applications, users, and requirement changes within the Identity Provider.
Requirements
- Familiarity with .NET, ASP.NET, and C#.
- Familiarity with ASP.NET Identity.
- Your own laptop with the latest version of .NET Core SDK and an editor/IDE of your choice. -
Crafting Chainmail
Have you ever wanted to learn the fundamentals of making chainmail? In this Divez lesson, we will learn to weave 4-in-1, Byzantine and Persian 6-in-1. You will learn why Aspect Ratio and wire gauge are important considerations in making your chainmail. We will also delve into the history of each type of chain mail weave and why they were used in different parts of the world. At the end of the lesson, you should have a finished piece of chainmail, either a bracelet, a necklace or simply a large square. We will be using a variety of anodized aluminum that is very colorful and easy to work with.
-
CSS !important
A clean, functional User Interface can be a major competitive advantage. CSS is the core technology used to build UIs for the web. In this talk you will learn how to set up your web project with clean, concise, maintainable stylesheets. We will cover:
- Cascading
- Specificity
- Pseudo elements
- Semantic class names
By learning how to minimize the overlap between HTML, CSS, and JavaScript you will improve the readability and maintainability of your code and make it easier to follow accessibility guidelines.
This talks focuses on the structure and architecture of your CSS and does not deal much with visual design topics -
Data management in a Microservices world
Microservices with their decentralized nature strive for scalability, autonomy and flexibility for modern applications. But it always gets tricky when it comes to the data. "Code is easy, state is hard" is the motto often used. Naturally, a lot of Microservices architectures do not speak of the data aspect, leaving it up to you to figure it out.
From an academic standpoint, microservices should be completely decoupled and isolated, while from a data management academic point of view, all data should reside in one place only. Both are mutually exclusive, academically. In a practical world, both have to work together and meet somewhere in the middle.
In this session, you will learn how to apply data management approaches to a Microservices environment. You will get to understand where the synergies between the two lie and how to avoid common pitfalls, so that you can apply the best of both worlds in your next application design yourself. -
Data Science: Zero to Hero
As companies, like Microsoft democratize artificial intelligence, so AI and machine learning becomes more the domain of the software developer, but how much do you really know about this subject, a subject your boss is soon going to expect you to be proficient in?
In this day long, hands on session, we'll take you from zero to hero in machine learning. Starting with the basics of statistics, finishing up with neural networks and visiting all points between, by the end of the day, you'll know all you'll need to integrate AI into your products and your enterprise. -
Database Continuous Delivery & Your Salvation!
Continuous Integration & Delivery isn’t a new concept. Application Developers have been doing it for quite a while and now it’s time for Database Professionals to catch up. Whether you are a database administrator, database developer, or even an application developer, database continuous delivery can help you find your salvation. I'll show you how to apply these concepts to areas of security, collaboration, testing, support and deployments. We will look at what continuous delivery means, demonstrate some tools that can help you easily get it into place, and dive into why it’s important.
-
Database DevOps with Containers
Unlike CI/CD pipelines for applications, we can't just delete the database and pop up a new one with each new version. Let's start with the production database, and get SQL Server content to developers in containers, and then flow schema and lookup data back into production with migration tools. You can bring the reliability and automation of CI/CD pipelines to Database DevOps with containers.
-
Debug Like It's Your Job
Being a developer is not just about writing code - that code must actually work and figuring out why it doesn't is a different mindset than writing it. Debugging is not a prescribed recipe, it is a necessary skill for any developer. While this ability is inevitably gained through experience, there are tips, tricks and techniques you can learn to level up your effectiveness as a programmer right now.
For the novice, student or new-grad, this session takes you through the most common things you don't know yet.
• how to use breakpoints effectively (there's more to it than you think)
• what the heck step-into, step-over and step-out do
• how to view and manipulate runtime state
• how to use your environment's interactive terminal to interrogate your program
• what the stack is and how it contains a wealth of information
• the importance of Known Good Values (KGVs) in isolating a problem
• knowing where to start by being a good investigator
This session saves you from all those stackoverflow.com downvotes and "did you even debug this?" comments. Bring a laptop and play along! Your browser tools are enough to try out many of the presented concepts. -
Debugging and Monitoring Applications in Production
Applications behave differently in production than they do on developers' machines. Figuring out why is a challenge. I'll demonstrate a suite of tools including a Debugger, Error reporting, Uptime Monitoring, Alerting, Tracing, Logging, and dashboards that enable you to understand how your application is behaving and why. These tools are parts of the Stackdriver suite: https://cloud.google.com/stackdriver/. They can be used in Google Cloud, AWS, private clouds, or wherever you run your code.
-
Debugging the Internet of Things with Traces
Building IoT products is hard.
There’s spotty internet connectivity, limited physical access to devices, and the added complexity of software across cloud and edge devices.
In this talk, we’ll explore distributed tracing, a new tool for debugging complex systems. We’ll see how distributed tracing can be especially useful for debugging the complex environments found while building IoT products.
We’ll show how distributed tracing lets us view our real traffic, in production, and quickly diagnose errors at any point in the request flow, whether it’s in the cloud or on our edge devices. You’ll come away with an understanding of how to incorporate traces into your software, and how tracing radically simplifies the process of debugging applications across connected devices. -
Deep Learning like a Viking - Building Convolutional Neural Networks with Keras
The Vikings came from the land of ice and snow, from the midnight sun, where the hot springs flow. In addition to longships and bad attitudes, they had a system of writing that we, in modern times, have dubbed the Younger Futhark (or ᚠᚢᚦᚬᚱᚴ if you're a Viking). These sigils are more commonly called runes and have been mimicked in fantasy literature and role-playing games for decades.
Of course, having an alphabet, runic or otherwise, solves lots of problems. But, it also introduces others. The Vikings had the same problem we do today. How were they to get their automated software systems to recognize the hand-carved input of a typical boatman? Of course, they were never able to solve this problem and were instead forced into a life of burning and pillaging. Today, we have deep learning and neural networks and can, fortunately, avoid such a fate.
In this session, we are going to build a Convolution Neural Network to recognize hand-written runes from the Younger Futhark. We'll be using Keras to write easy to understand Python code that creates and trains the neural network to do this. We'll wire this up to a web application using Flask and some client-side JavaScript so you can write some runes yourself and see if it recognizes them.
When we're done, you'll understand how Convolution Neural Networks work, how to build your own using Python and Keras, and how to make it a part of an application using Flask. Maybe you'll even try seeing what it thinks of the Bluetooth logo? -
Design for inclusivity using Conversational Chatbots
Have you ever wondered what it would be like to be visually or hearing impaired and how that would affect your daily interactions? Why not build products that would provide a better user experience for wider range of customers? With the big Chatbot revolution, Bots are everywhere and are changing the norms of human-computer interactions. Chatbots provide the perfect opportunity for business to attract/retain customers, drive up user engagement and make brands more inviting.
In this session let's build an Alexa skill and a Lex chatbot to make a sample website accessible to everyone. The goal would be to use Lex as a website companion to help everyone navigate all of the website's content. Let's design voice commands that read text from website, make phone calls and display query results making it possible for every type of user to use the site.
You will leave this session with an understanding of how to integrate conversational user interface in products you build to achieve better user experience for ALL! -
Design Thinking for Developers
Software is eating the world, but do engineers have the knowledge of the stakeholder's domain to bear the responsibility of transferring domain knowledge to software? The Rosetta Stone of software is to have a domain language that clearly communicates in the language of the field, but developers struggle to get past communication problems:
- Misunderstood requirements.
- Lost context over time.
- Code that does not capture intent properly.
- Unintended consequences of poorly modeled data.
Our workflows and structures create communication barriers we must break down in order to move our implementations closer to their domains. As developers, our goals should include moving code closer to the vocabulary of the domain. This requires understanding not only the problem being solved by a feature but also, more broadly an understanding of the field we are working in.
Design thinking offers a toolset for gathering insight into the domain that can not only help engineers understand a user's problem more fundamentally, it can also offer byproducts such as:
- Providing a better understanding of the entire domain.
- A clearer path to a domain language.
- Understanding problem nuance.
- Gaining lessons learned of the user.
This workshop walks users through a design thinking exercise with an emphasis on being the engineer in the room. We will break into groups and follow a process of exploring the problem space, make CodeMash better for volunteers and attendees. The workshop will be focused on user interviews, capturing vocabulary, ideation techniques, prototyping and user validation. The outcome is a better understanding of how to capture value from these types of session that lead to the development of domain-centric data structures, domain languages, better DB structures, and clearer documentation with more user validation and better long-term understanding of the code base and product. -
Desktop Applications in Electron
While most of the world has gone mobile, there is still a time and a place for desktop applications. This course will focus on utilizing those web skills with a foundation in HTML, CSS and Javascript to build cross-platform desktop applications ready for enterprise deployment. We will setup the development environment, add the appropriate packages and even build a deployment package. In the end you will gain a good understanding of the inner workings of applications such as Slack, vscode and the Atom editor.
-
DevOps - Philosophy vs Practice
Many of our conversations on DevOps revolve around tools and practices - but very few address the where the two meet.
We can talk about monitoring, analytics, alerting, on-call and the philosophies surrounding them, but how do we bring the two worlds together?
This talk will focus on successful setups and all the parts and tools that go into it. How do we make sure we have everything we need for our organization. We’ll also discuss how to get the buy-in needed from your team to make it work. -
Digging Into your APIs with Exploratory Testing
Much of exploratory testing tends to concentrate on the client UI. But the same strategies that work well at the UI level can also be applied to the web services and APIs that power your application. By exploring your APIs you can find critical bugs earlier in the development cycle, gain a deeper understanding of how your application or feature works, and have greater confidence in your UI level testing, knowing that the services underneath are solid. The workshop will include multiple activities using Postman and other tools so that attendees can gain confidence in their ability to test web services.
-
DISCovering your team: A Guide to Effective Communication
Every team is made up of different personalities. Often times these differences make collaboration difficult, but they don't have to. Knowing your personality type and the personalities of your team and adjusting your behavior based on your audience can go a long way to make your team a cohesive unit. Let's explore DISC profiles, learn what they are, how to identify them, and what to do with what you've learned to make your team effective.
-
Domain specific languages: Don't be scared
Domain specific languages make hard to express, complex, and always changing business problems disappear! Done correctly you can turn ever-changing-requirements directly into the program. A quick intro on parsing, lexing, and abstract-syntax-trees. Then practitioner tips on execution from at home toy to full system at billions in volume. You'll leave with confidence on where to start to solve problems in ways that can change how companies function.
-
Don't Rewrite, React!
The gorgeous, beautiful, gynormous, living on outdated technologies legacy application. We've all worked on at least one. We love to hate it and dream of rewriting it. It doesn't take long until we are in a hard sell to our manager to ditch the legacy app and bring in the latest framework hotness.
But we overlook what we will be losing...years of code, untold amounts of business logic, depths of the application with git blame dates measured in years. A rewrite can be an undertaking that may never get fully completed but will sink a company.
Enter React.
Sure, React does a great job starting with create-react-app, but what it does extremely well is tying into existing applications so that you can slowly convert legacy apps to the new JavaScript landscape. No rewrite, no stop of feature development and all the benefits of working in ES6.
In this session, we are going to talk about why we instinctively reach for the "rewrite" solution and look at some legacy Rails app that faced distinction. Then we will talk through what React is, what it can do, how it is so beneficial and give you the tools to leave and start converting your app with React today! -
Embrace your Legacy… Code
What is your reaction when you hear the words “legacy code”? If it’s to run away screaming, you are not alone.
Developers often tend to focus on the negative aspects of legacy codebases. We think of legacy codebases as boring, outdated, difficult to work with, and overwhelming, and we overlook the opportunity to learn from them. These codebases are full of valuable knowledge and they can teach us to be disciplined, empathetic, and persistent.
In this talk I will share ways to approach legacy code with a more constructive attitude and focus on growth. We will also look at techniques to help us better understand and improve our legacy codebases.
It’s my hope that you’ll leave feeling excited and empowered to discover the hidden gems that your legacy codebase has to offer. -
Enhance Your Career with a Mastermind Group
What do King Arthur, Franklin D. Roosevelt, Andrew Carnegie, and Napoleon all have in common? Each of them belonged to groups called Masterminds, or brain trusts. The term was originally coined back in 1937, but the concept has survived the test of time. By surrounding yourself with like-minded individuals, each coming into the conversation with their own thoughts, perspective, and motivations, the overall group can lift themselves to a higher level. You don't need to wear a crown or command an army to be in a mastermind group. Average people every day meet and discuss their careers and personal lives within constructive, judgement-free zones.
Do you find yourself going to work each day without direction? Do you feel like you are the only person in the world with the problems you're facing? A mastermind group would help you push forward. This presentation will discuss how to join or organize a mastermind group, including meeting structure and timing. What are the do's and don'ts? How can every member benefit? Come learn and take your career to the next level. -
Entity Framework debugging using SQL Server: A Detective Story
What happens when the code for your Entity Framework LINQ queries looks good, but your app is very slow? Are you looking in the right place? Don’t be afraid to start looking at your database. Knowing how to investigate and debug what your LINQ queries are doing in SQL Server is as important as the actual LINQ query in your .NET solutions. We will be looking at database server configurations, using MSSQL database profiling tools and understanding Query Execution Plans to get the most out of Entity Framework. In the end, learning to be an Entity Framework detective will make your project sound and snappy.
-
Esoteric Programming Languages
Most of the time we program in modern languages like Ruby, Python or C#. However, there are a plethora of languages out there that are strange, odd, and/or just plain funny. In this talk, I'll go over a number of esoteric programming languages such as Whenever, Befunge, and LOLCODE. Come with a sense of humor!
-
Everyday Animations in Android
Animation is often seen as a nice-to-have or gratuitous in software projects. In truth, animations actually exist to improve an app's user experience. Animations help users understand state changes, guide them to notice meaningful information, gather focus to a required action, or express relationships between UI elements. This session examines traditional techniques using property and drawable animations, as well as the new MotionLayout introduced at Google I/O 2018. These techniques can expand content, display state, move elements, and highlight important controls. Properly executed animation effects are applicable to buttons, lists, and images in any Android app, taking an app's user experience from good to great.
-
Expand Your Testing with Virtual Services
Don’t let incomplete services or 3rd party dependencies slow down your test game – with virtual services, you can keep on testing! Learn about the many options available for service virtualization and how you can implement them in your own test routine. Whether you are writing automation or exploring a new service, virtual service tools are an invaluable addition to your testing toolbox.
-
Experiencing A11y
Accessibility has become an increasingly common buzzword for tech companies, but what does it mean? And how does it affect the software we build? In this workshop we will deep dive into the world of accessibility. We will discuss and experience what it means to be users of varying levels of ability. We will get hands on experience using adaptive technology such as screen readers, foot peddles, switches, and accessible keyboards. In addition, we will explore designing, writing, and testing software with all user ability levels in mind. This workshop will be hands on, writing and testing code. This session is open to attendees of all skill levels whether you write code or not!
In this all-inclusive experience we will learn:
- Diversity of disabled users and user personas
- Experiencing the web as a disabled user
- Experience using adaptive technology and input devices
- Designing and programming with accessibility in mind using a light weight angular solution available on GitHub
- Open source testing tools and techniques for web accessibility -
Exploring reactive programming in Java
When Java 8 was first introduced, it revolutionized the way Java applications were written by providing the core constructs for asynchronous programming and handling data streams. With Java 9, 10, and 11, these capabilities were extended to the level that allows us to write truly modern, reactive applications with the JDK.
In this live-coding session, we explore JDK 9-11 features enabling all the aspects of reactive programming - updates to the Stream and CompletableFuture APIs, Reactive Streams publish-subscribe framework, HTTP/2 client, and more. -
Extreme Performance Architecture
High performance can be achieved by micro-optimizations and a lot of minutiae, but to get to the extreme you need to architect your solution properly. In this talk, we'll discuss how the architecture of the solution impacts its performance, how to architect for extreme performance and the impact it has on day to day coding.
We are going to execute complex distributed map-reduce queries on a sharded cluster, giving you lightning-fast responses over very large data volumes. -
Finding your place in the Cosmos: When and why you should consider Azure Cosmos DB.
Azure Cosmos DB gives you exciting new ways to access your data. You have new storage paradigms. You can connect to it from your C#, JavaScript, Python, or Java application. You can write stored procedures in JavaScript. You can easily integrate with Azure Functions. You get all of this with incredible access speeds.
In this presentation, you will learn what you can do with Cosmos DB. You will learn how you can benefit from the new storage models that Cosmos DB provides. You will learn about the various options for storing and retrieving data. You will be shown what SDKs are available. Most importantly, you will learn when and why you would want to consider using it. -
Flutter for Android Developers
Mobile users expect their applications to have beautiful designs, smooth animations, and exceptional performance. Accomplishing all three tasks at the same time using conventional Android development tools has traditionally been difficult.
But not with Flutter, Google's unique mobile UI Framework which helps developers quickly and efficiently build native apps for both IOS and Android.
In this talk, we will examine Flutter from an Android developer's perspective. I will showcase the differences in architecture when building applications in Flutter verses traditional Android. I'll showcase Flutter's UI Widgets and how they differ from Android Views. Lastly, we will talk about when and why you would choose Flutter over the Android SDK. -
From Average to Awesome In a Few Short Years
I graduated college as a C-average student - I just wasn't very ambitious. My first few developer job interviews that following summer were hard lessons in rejection. I had no idea where my career was going. Times change. Today I am a lead engineer at a major consultancy, work with Fortune 500 companies, make six-figures, and live debt-free (I also speak at conferences, mentor fellow developers, and travel the country).
What happened?
How did I go from average to awesome in a few short years? The path of self-improvement is full of challenges, but challenges bring opportunity. I learned to embrace opportunity, navigate around obstacles, and learn from mistakes. This session will highlight real tips and advice for setting proper goals and how to measurably progress towards them. Let my stories, lessons, and experiences inspire you to achieve real goals and be your very best, even if "imposter syndrome" is your middle name. -
From Zero to Serverless
So many times our customers need a simple routine that can be executed on a routine basis but the solution doesn’t need to be an elaborate solution without going the trouble of setting servers and other infrastructure. Serverless computer is the abstraction of servers, infrastructure, and operating systems and make getting solutions to your customer’s needs much quicker and cheaper. During this session we will look at how Azure Functions will enable you to run code on-demand without having to explicitly provision or manage infrastructure.
-
Fun Things To Do With Alexa
This session will introduce KidzMashers to Alexa, and show them some of the cool things they can do with just their voices. We will have devices to play with, tons of things to try, and an interactive game they can try.
-
FUN WITH STICKS!!!
This will be a fun and creative session where you build things with popsicle sticks!! Build a bridge! Build a building! Build a Jellyfish! Build anything you like! And these projects don't require glue, so no drying time, and all the parts are reusable. Every child will receive a kit with sticks, nuts & bolts, and instructions on how to build 3 different projects. All ages welcome, children under 5 may require assistance. And yes, you get to keep what you build! Come and have fun with sticks!
-
Gathering Insights from Audio Data
Data comes in many shapes and sizes. In this session, we’ll look into the process of converting audio files into valuable data. We’ll go over the different types of audio formats and how format and type of audio plays a role in the quality of the outcome. We’ll go over different transcription options available today and provide a demo of converting audio data into text. We’ll review ways of storing and searching text data at scale using open source tools and Natural Language Processing (NLP) techniques. Going further we’ll explore different techniques for building machine learning models on the transcribed text data. You’ll leave this session with a firm understanding of how-to take audio data and convert it into actionable insights.
-
Generate data for 10,000 unit tests
Unit tests validate one example at a time, but what if you didn't have to think up dozens of unique examples and write them by hand?
Generative testing can help, whether you wish you had 100 monkeys to drive your web application, 10 million example transactions for load testing, or you want to gain confidence in your software without writing hundreds of example scenarios.
You will leave this session with a new "thought tool" to identify useful properties to validate, and ideas for testing some "tricky" properties, and an intuition for when to use generative testing vs. example-based unit tests.
Attendees follow design and validation of a team-based gratitude tracker through examples of generating "synthetic thank you notes" for testing, property testing the implementation, and model-based testing the awards system.
Examples in C# and Clojure. -
Generating Fractals in the Browser With Rust and WebAssembly
WebAssembly is a low-level instruction format designed to be a compilation target for systems programming languages such as C, C++, and Rust. Code compiled to WebAssembly executes at near-native speeds, allowing developers to write performance-critical parts of their JavaScript application in a lower-level language for a significant performance boost.
Rust is a safe, concurrent, and fast programming language developed by Mozilla. Designed as a practical replacement for C and C++, it's used in production as a part of Firefox's rendering pipeline. Other users of Rust include Figma, Deliveroo, and Microsoft.
This talk is about building an application that renders a Mandlebrot fractal in the Web browser. The user interface for the application is built with regular ol' HTML, CSS, and JavaScript, and Rust is used for generating the fractal.
Here is an outline of the talk:
- What is the Mandlebrot set?
- What is WebAssembly? What is it good for?
- What is the browser support for WebAssembly look like?
- What is Rust? Why use Rust for anything?
- How does Rust compile to WebAssembly?
- How does code compiled to WebAssembly interact with JavaScript?
- Hands-on demonstration, generating a fractal using Rust code
- Can an entire Web application be built with Rust?
Attendees don't have to be familiar with either Rust or WebAssembly to attend this talk. -
Get Creative with Duct Tape!
Duct tape is super-sticky, flexible, and waterproof, and can be used as a quick fix for just about anything that’s broken. It’s even been used to repair spaceships! But, it also can be used to make art. You’ll learn briefly about the science and history of duct tape before we turn you loose to build your very own duct tape creation. Create a hat, shoes, flower, bird, or wallet, or just about anything else you can imagine with duct tape. We will supply ideas, how-to’s for several common projects, scissors, and tons of duct tape. You just bring your creativity! All ages welcome, though younger children should have a parent or older sibling to help them with scissors... and keep them from getting stuck to anything.
-
Get More Miles Out of Your Legacy App!
Reinvigorate your legacy applications without costing a fortune with Vue.JS. Many front-end frameworks require some heavy lifting to get started and that is especially true in a legacy application. Using this low barrier to entry framework allows developers pick and choose when to use it on a page by page or a component by component basis. In this talk, we will discuss several ways to tackle those legacy applications, tips on what are good things to start with, and how to migrate to a fully Vue'd front-end.
-
Get Up and Running Quickly With Vue.js
Whether you are enhancing a legacy application or starting a greenfield project, Vue.js can help reduce your development time. Vue.js a very lightweight and fast JavaScript framework that makes it ideal for modern applications - from using it as a library to create some enhanced features in your existing applications, rapidly prototyping a proof of concept, or using it as complete SPA framework in order to create fast, scalable solutions.
In this session, we will show you how to get started with Vue.js - both as a library and as a framework. You will also get a chance to learn how to quickly scaffold out projects using the Vue CLI and UI tool. -
Getting started in security with the OWASP ZAP HUD
The OWASP Zed Attack Proxy (ZAP) is one of the world’s most popular and best maintained free and open source security tools. It has a powerful desktop UI, a highly functional API, and is used by everyone from people new to security, including developers and QA, right up to professional pentesters.
The new ZAP Heads Up Display (HUD) interface overlays data and controls for ZAP over the web based application being tested.
This allows users to benefit from ZAP data and functionality without leaving their browser.
This makes it much easier for newcomers to get involved in security testing as well as allowing experienced pentesters to focus more on application level vulnerabilities instead of focusing on their security tool.
In this talk Simon will explain how you can get started in security using the ZAP HUD. He will demonstrate its current capabilities, explain where it’s heading and will also give an overview of how you can use ZAP for automating security testing. -
Getting the most out of your next generation JVM testing framework
With the rise of newer JVM languages like Groovy and Kotlin, feature-rich test frameworks emerged. The test framework Spock became a welcome alternative for many projects fearless to adopt Groovy as part of their polyglot software stack.
With the first GA release of JUnit 5 in September 2017, the JUnit team brought real innovation to the established space of testing JVM code. Not only is the release packed with new features comparable to the ones provided by Spock, JUnit 5 also serves as a platform for launching other test frameworks on the JVM.
This demo-driven talk compares typical testing usage patterns and features available for JUnit 5 and Spock. You'll leave with a firm understanding of the benefits and tradeoffs delivered by both test frameworks. -
Getting Unstuck
You’ve followed along with the docs. Everything seems like it should be working. You’ve looked over this code 20 times, but you can’t figure out why it’s not working. You’re frustrated, and you’re ready to give up.
Even with the simplest of problems, we can get stuck. It happens to all of us - to new hires and senior engineers alike. The key to success as a developer is knowing how to get yourself unstuck.
We’ll look at several strategies for breaking through when it seems like you’ve hit an impenetrable wall. These strategies will help you understand, explain, and isolate the problem. Most importantly, they’ll help you move on.
Getting unstuck is a skill. This session will help you sharpen that skill, and prepare you for the next time you hit a wall. -
git gone wild: how to recover from common git mistakes.
"Oh no! I just typed something into git and now my work is gone! Ahh!"
Don't panic. Contrary to popular belief, git is one of the most non-destructive version control systems available. When used right, git
never loses any data, and even when misused, chances are very high you can still recover.
This talk will present turn-by-turn directions on how to recover from a wide array of common git mistakes, and also provide some workflows
to minimize them.
Examples include, but are not limited to:
* Changing spelling errors in commit messages.
* Split commits into multiple commits with logical separation.
* Combining multiple commits into one.
* Resetting the base commit when you accidentally branch off of the wrong branch.
* Recovering from merge conflicts.
As well as more advanced topics, such as:
* Extracting parts (e.g. sub-directory) of a repository as a new repository.
* Merging multiple repositories into one while retaining version history.
* Removing confidential data accidentally committed. -
Give Feedback Fearlessly: Workshop
For many of us, it’s hard to speak up when we notice our teammates struggling. We don’t want to hurt anyone’s feelings or make things awkward. Sometimes it just feels like too much work to organize our thoughts into a coherent message that could help someone who’s falling behind move forward. Even knowing when it’s time to draw attention to a problem can be challenging.
We’ll start the session by covering our bases. When should we address uncomfortable situations at work? How can we keep personal feelings from derailing the conversation? And what happens afterward? Can we evaluate the effectiveness of our feedback? How can we move forward, growing as a team? We’ll answer these questions as we begin to build the skills necessary to provide teammates with specific, actionable feedback. Participants will receive a reference sheet to help them remember these techniques and work through difficult conversations in the real world.
Several sections of the workshop will involve hands-on role-playing exercises. Participants will be broken up into small groups and given several scenarios to work through. Each scenario will outline a challenging situation from multiple points of view to help participants further explore the techniques and principles covered in the lecture portion of the session. -
Gradle with Ketchup
Gradle is yet another build tool that leverages other frameworks like Ant and Maven. It expands the lifecycles and allows extensions. Join this session as we see how Ketchup was added to the the receipt (ok, Kotlin is a Polish Ketchup) to extend the script by adding things like static type checking and a cleaner Domain Specific Language (DSL). The attendee will leave knowing the latest features of Gradle, how it can improve building in a CI/CD environment, and how Kotlin can improve on the lifecycle by providing easy customizations.
-
Great Ball Contraption Workshop
What do you get if you take LEGO soccer balls, a simple set of instructions, a provided LEGO model kit, and put it all together? A Rube Goldberg machine entirely from LEGO! Together we will build modules for a Great Ball Contraption and then line them all up to pass along the soccer balls. Let's set the first KidzMash GBC record together, while learning and playing with LEGO.
-
Handling Angular 2+ Forms Without Losing Your Sanity
“Why’d you have to go and make things so complicated?” - Avril Lavigne, implementing Angular 2 forms in 2018
Forms are such a basic part of web applications; how did they get so complicated? This talk will walk through Angular 2+ template driven vs. reactive forms and use cases for their implementation, basic & more complex form-validation, & custom component implementations like typeahead and date-pickers. This talk will also include some useful workarounds for those more complex PITA requirements that always seem to pop up in projects. -
Hardware is from Mars, Software is from Venus
MARS (hardware device): Don’t offer unsolicited signals to Martians because hardware would go crazy and might even keel over and die. Don’t try to change hardware’s behaviour without proper invitation.
VENUS (software programming): Don’t close yourself off to Venusians, just give support (and a hug) and let software talk early and often. Don’t try to make her do things your way or you will never get in the hands of your desired end user.
Solutions and advice can be given: it’s just a matter of timing and approach!
This talk will review the challenges in communication, development cycles, and dynamic behaviors when developing embedded systems. It will also give tips and and clues for optimal language and communication channels between people (hardware/software engineers) and devices (hardware/software). -
Have Some Cake With Your Frosting: Testing Both the UI and API Layers
Web services and APIs make up a huge chunk of the code in the applications we test, but either we’re not aware of the APIs or we’re asked to focus on the user interface instead. But those APIs are where all of the business logic for the application is exposed, and can hide some pretty nasty bugs. Web services and APIs can be tested in isolation, but they can also be tested in combination with the UI. Understanding how the UI and API work together can make it easier to troubleshoot when things go wrong from the UI. Having this understanding can also create a more complete picture of the application under test.
In this workshop, we will cover:
Why web services and APIs are important to test
The differences between common types of web services
How HTTP Response Codes fit in to your testing
How familiar UI tests translate to API tests
How to use Postman to test and share tests with your team
How to find the API calls your UI is making -
Have Your Pi and Eat It Too: .NET Core on Raspberry Pi
Is .NET your jam? Are you berry interested in development on Linux? Think developing code for IoT devices is just Pi in the sky? In this (hopefully) pun-free (but not FUN-free!) session, you'll watch Pi-eyed as we demonstrate the possibilities of .NET Core, including ASP.NET Core and Web API, on a device the size of a credit card!
You'll learn:
* How to configure your Raspberry Pi for .NET Core
* Building, deploying, and running .NET Core apps on Raspberry Pi
* Accessing the hardware of the Raspberry Pi from .NET Core code -
Hey, You Got Your TDD in my SQL DB!
When should we test our data? From an application development perspective, a unit test against a database isn't a unit test at all. Which makes sense -- connected systems introduce overhead and dependency, both of which reduce stability and decrease productivity during test-driven development (TDD). But if we wait for integration testing, critical functionality can get missed. In this session, we will discuss strategies for filling the data testing gap, directly within a Microsoft SQL Server environment. If you do a lot of work in T-SQL but aren't familiar with TDD, you'll learn the why and how of test-first development. If you're accomplished with unit tests, but never tried them in your database, you'll learn how to apply familiar concepts like setup, mocking, and assertion. We'll spend most of our time walking through a solution based on a real-world project, specifically using the open source tSQLt database unit testing framework.
-
Higher-Order Promises
A JavaScript promise is a handy container for a value you expect to get later. But a promise is also a value itself, and you can do some useful stuff just knowing you have a promise.
We will talk about writing better handler functions to pass into `.then()`, how and why you might want to write higher-order `async` functions to generate promises, and aggregating multiple promises beyond `Promise.all()`. -
Hold Up, Wait a Minute, Let Me Put Some Async In It
The introduction of async/await to C# has irrevocably changed how .NET developers created their applications. But what about older applications? How can they get the async goodness?
In this code-heavy session, we'll take a "older" .NET web app which has no asynchronous code and slowly refactor it into a modern async app. Along the way, there'll be discussions what practices we need to be aware of, such as "async all the way down". This session also demonstrates when async/await is NOT needed, as well as when it is.
Async/await is wonderful, but it's not a cure-all. Let's take an old app, put some async in it, and see how it all comes together. -
Hotdog Not Hotdog: Xamarin Android Things Primer
We will cover the Android Things platform. Android Things lets you build Android apps that run on devices like a Raspberry Pi using all of the great tools already available and familiar to Android and C#. We’ll cover the basics of getting started with Android Things platform and how any developer without electronics experience can build IoT apps with Android Things using C#. This discussion will be a deeper dive into how you can use the Android Things SDK to build apps that interact with the real world. Expect to see live demos on devices all using Visual Studio. We’ll cover how to deploy a simple Xamarin.Forms apps. Read and write sensor data. Run a Machine Learning custom image recognizer using Tensorflow on Android Things. Attend the presentation and see how we can use Android Things for our IoT Edge scenarios.
-
Hotness === Serverless - Learn how to harness the power of Lambda's in AWS
The Cloud is all the rage these days and Serverless is one of the driving forces behind the Cloud.
Have you heard about Serverless technologies but are still unsure what they are? This session is for you. We will explore how AWS Lambda's allow you to harness the power of the Serverless Cloud.
We will go A to Z in our journey and by the end of this session you will know how to code, debug, deploy and harness the power of Servless technologies like AWS Lambdas. -
How a PoC at home can scale to Enterprise Level using Custom Vision APIs
It all started with a DIY project to use Computer Vision for security cameras at home. A custom Machine Learning model is the core component used to analyze pictures to detect people, animals and more in a house environment. The AI processing is performed at the edge, in dedicated hardware and the collected information is stored in the cloud.
The same idea can be applied to several CCTV scenarios, like parking lots, train stations, malls and more. However, moving this into enterprise scale brings a set of challenges, which are going to be described and explained in this session. -
How do you change the world? By developing future women leaders
Change begins at home. Many first generation disadvantaged immigrants to this country do not attend college, which means their children do not have adequate guidance on pursing higher-level education. The community can come together to provide help to these children with code camps. This past summer, a Young Women in Tech code camp was held in Columbus for members of the Bhutanese-Nepali Refugee Community. More than a dozen experts in technology volunteered to teach girls aged 13-17 about computer programming, accessibility, user-centered design processes, cyber security, Photoshop, software development and desktop management. The volunteers taught the girls about the extensive career options within technology, with each volunteer focusing on their respective area of expertise. The training was supplemented by college admissions officers providing education guidance and a course on resume building. The entire camp was sponsored by a local community college with financial support for meals, equipment, and clothing provided by local businesses.
In this session, the audience will learn how to uplift the next generation of leaders through supplemental training opportunities outside of school. The audience will be shown how to organize a code camp locally, from securing facilities for training, to financial support, to soliciting volunteer teachers in technology. -
How not to be the best app no one uses: Effective Onboarding for fun & profit
You've made a brilliant application - perhaps a new startup or a new major initiative within your enterprise. For it to be successful you need to get people from interested to effective before they lose interest.
Without effective onboarding built into your app users will not stick with it long enough to discover the great features you've built.
In this talk we'll dig into what it takes to design and optimize an effective onboarding process and equip you with a strategy for making incremental investments that can be fit into your development project. -
How to Keep up with Technology: a Systems Based Approach
Keeping up with technology can be an overwhelming task. In this session, we break the problem down into the core components of any system: inflows, outflows and buffers. We look at the two ways that our knowledge atrophies and the 3 currencies we can spend to get new knowledge.
-
I'd Hire more Women if they Would Apply!
Maybe you’re the one that’s not really trying? Are you sending signals that say “Dudes Only”?
As a Chapter Leader of Girl Develop It (GDI) I have had numerous companies ask me why can’t they get women to apply to their openings. They want to diversify but have a “pipeline” problem. My experience as a woman in tech and helping women enter the tech field through GDI tells me otherwise.
In this discussion we’ll consider the some of the common reasons women might not apply to certain companies and or job postings, examine some of the “red flags” you might not realize you are waving and explore ways to make the hiring process more inclusive. -
If Your Tests Could Talk
Test Driven Development (TDD) has failed! Tests are hard to write, run slowly, break easily, are hard to understand, take a long time to write and are a pain to modify! If any of this sounds familiar, your tests are trying to tell you something. But what are they trying to say? Sometimes it's as simple as telling you when to extract a new abstraction or to decompose a function. Other times the message can be less obvious, like telling you your code is too tightly coupled or that responsibilities have been assigned incorrectly. Sometimes they can tell you it's time to back up and rethink your design. Come explore these and other sources of trouble with test driving code. If you have been burnt by TDD in the past, this may be the perfect opportunity to try it again armed with a clear set of guidelines to interpret the feedback from your tests. Your tests are already talking… find out what they have to say!
-
Information Architecture For The Soul
Do you find that it’s often harder to avoid building the wrong thing than to build the right one? You want to build the best software you can, but between deadlines, changing priorities and warring clients, it can be difficult to know which features to fight for; and which to let fall to the floor.
In this session we will discuss the strategies and decision making that goes into the Information Architecture of the modern MVP.
You will learn how to use data, user research, and experience to create software that delivers the most value to your users; while keeping your stakeholders happy. -
Insight from the Crowd
If you could ask the entire internet a question, what would it be? What if you could put it to work for you? Crowdsourcing breaks down task or problem with the added advantage of its capacity for scaling up. This talk will feature challenges and considerations for gaining new knowledge and evaluating opinions generated by an anonymous web-based distributed network of individuals. We’ll go into a deep dive into the types of crowdsourcing approaches as well as design paradigms for cost-effective, efficient, and reproducible crowdsourcing initiatives.
-
Intro to Progressive Web Apps
What’s a progressive web app (PWA)? Should you turn your site into a PWA? Does it replace the need for a Native Web App? Do PWAs work offline?
This session will provide answers to these questions and show you how to create a reliable, fast and engaging PWA. We’ll work through enabling a web app for ‘Add to Home Screen’ support by creating a web app manifest and service worker. Next, we’ll leverage the service worker to optimize loading of images for different devices and network speeds. We’ll wrap up with pushing a web notification to our new PWA. -
Introducing Juvet: Building Bots in Elixir
There is another massive shift happening with how we interact with companies through software. Users feel comfortable naturally talking with their applications through chat bots. Chat is the next generation of the user interface.
Companies like Slack, Facebook, WhatsApp, and WeChat have some of the most popular apps in the world and they are all betting on a messaging interface.
Elixir is the perfect language and ecosystem for building bots and for conversational interfaces. In this session, we will see how we can build scalable, realtime web applications (or “bots”) using a new library Juvet and the Slack API. We will see what a good bot architecture looks like and how we can integrate with existing artificial intelligence services to make our bots smarter. -
Introduction to Game Development with Unity Part 1
You want to make video games with the Unity game engine? Let’s make video games with the Unity game engine! In this session attendees will build a 2D Platformer game (full of traps) from start to finish. Covered is a hands on approach to the construction of game systems from assets. Audience members won’t be watching, they’ll be doing. The end product will be a complete video game playable on desktop, web, or mobile devices. This is all new content showing you how to use the latest features of the engine. Even if you attended previously there will still be plenty of new things to learn! (this is a full day session and will be continued in the afternoon Part 2)
-
Introduction to Game Development with Unity Part 2
You want to make video games with the Unity game engine? Let’s make video games with the Unity game engine! In this session attendees will build a 2D Platformer game (full of traps) from start to finish. Covered is a hands on approach to the construction of game systems from assets. Audience members won’t be watching, they’ll be doing. The end product will be a complete video game playable on desktop, web, or mobile devices. This is all new content showing you how to use the latest features of the engine. Even if you attended previously there will still be plenty of new things to learn! (Requires attendance of the Part 1 morning session)
-
Is AI right for me?
Artificial intelligence (AI) has become a form of Swiss Army knife for the enterprise world. If you have a data problem, throw some AI at it! However, this mentality can lead to wasted time and money going down the path of implementing a heavy-handed solution that doesn’t fit your business problem. Navigating the waters of AI, machine learning and data analysis can be tricky, especially when being sold by the myriad of data science and AI companies offering solutions at the enterprise level. But fear not, some simple guidelines can help. In this talk, I will present a basic rubric for evaluating AI and data analytics techniques as potential solutions for enterprise business problems.
-
It's Only Rocket Science!
3,2,1, Blastoff! Rockets have been used to make advancements in science for years, and have fascinated people of all ages. But if you aren't a scientist, it's pretty hard to understand how they work. Rachel (age 13) and Nathan (age 11) will lead you in exploration of Newton's Third Law with hands-on experiments showing how rockets really work. If you have ever wanted to know how to fly a rocket, or how physics work in outer space, then this is the talk for you!
-
It's Sedimentary, My Dear Watson: Finding Fossils Near You
We've seen fossils in museums, movies, and on tv. But did you know you can go hunting yourself for fossils? The Kalahari used to be part of a prehistoric sea and there are a lot of places to find fossils throughout Ohio and the surrounding states.
This talk will explore how to find fossils, where to look, and what to look for when hunting fossils. It's not Jurassic Park, but you can find the remains of prehistoric creatures of your own! -
Jump Into JSON. Rush Into REST.
Everybody needs a quick quick catch-up on technology at one time or another. Perhaps you’re new to modern development, or maybe you’ve been too focused on your projects that you haven’t been able to come up for air. During the conference you will see the terms REST, API, and JSON in many of the session abstracts. Regardless of the topic - front end, back end, desktop, web, mobile - these concepts are becoming a part of your world very quickly. They play an increasingly-significant role in your current work and - very importantly - in your next job search. However, they are not complex concepts, and this session will quickly bring you up to speed and help you prepare for your next project as well as many of the other sessions you will attend at CodeMash.
This will be a language-independent and platform-independent jump-start into the concepts of REST, JSON, and APIs. We will walk through their meaning, their implementation, and how they’re used. You will see them in action during the session, and even after we leave the room on our way to snag more vendor swag, this session continues to work with you. Throughout the conference and the weeks following, you will have access to a simple server-side API against which you can make requests as you play with your own client side code, and you will be provided with a client from which to send requests as you play with your own server-side code. -
Just because you can do something, doesn't mean you should!
With all the advances of technology, sometimes our abilities to access data far exceeds guidelines that have been set for what we should or should not do as we develop applications. Where do the boundaries of what we can do cross the line of what we should do? What responsibility do we have towards the users of the applications that we create?
Quite often the average user of web and mobile applications do not understand privacy policies, have no idea why the application needs certain information (sometimes it doesn't!), and are afraid to not give permissions because the app might not work. They also often have no idea how dangerous it can be to have all their information out there.
Some professions have a governing agency to enforce compliance to an ethical standard, but there is no governing agency over software developers. Does this mean we have no responsibility to be ethical in the software that we create or do we need to hold ourselves to some standard? And what would that standard be? With new innovation such as drones and autonomous vehicles, it seems more important than ever to consider ethics in software development.
This talk would not provide definitive solid answers to these questions because there is so much gray area in ethics, but it is more to get people thinking about what responsibilities we have as developers to the users of the software that we create. -
Kafka the hard parts.
Kafka has become a go to tool for a number of operations. Whether its stream processing, log aggregation, micro service communication, or simple queuing operations Kafka can fit the bill.
But adopting Kafka can bring along a number of challenges such as monitoring and alerting, data consistency, messaging guarantees, and capacity planning.
In this talk we'll discuss the hard parts of adopting any streaming technology and describe solutions for each. Specifically we'll talk about how to do monitoring correctly, how to use Kafka's consistent ordering to your advantage, how to choose message delivery guarantees, how to properly handle errors, and the benefits of immutable data and functional programming when dealing with large scale processing systems. -
Kotlin in Android: Learnings from 3 years in production
While Kotlin is quickly becoming the language of choice for native Android development, as with any new technology, it has a learning curve of its own. Having shipped Kotlin code into production since well before Kotlin 1.0, the team at Expedia has learned quite a bit about working with this language over the years. There a plenty of highs, some lows, and tips for those looking to get started.
-
Kotlin, Going Native & Beyond
Cross platform mobile solutions have traditionally meant a good enough fit on one platform and a square peg in a round hole for all of the others. Yet the pressure to stop writing the same app twice on two platforms is constantly coming down from management. How can one code base be shared between two platforms without dropping down to the lower levels of C/C++ or going down the dark and twisted path of Javascript?
In 2011, Jetbrains, the company behind IntelliJ and other tools popular with developers released the first version of the Swift like language known as Kotlin. Since then Kotlin has grown in popularity and features becoming a first class supported language on Android even. In mid 2017 Jetbrains brought Kotlin out of the JVM/Android world and released a Kotlin compiler front end for the same compiler infrastructure that Objective-C and Swift use, LLVM. Now today, it is possible to write code in a high level and type safe language geared toward developer productivity that works the way the host platform works.
Attendees of this talk will learn enough about Kotlin to see why it is a compelling language and how to write code in said language that can be simultaneously compiled to both an Android library and native iOS framework. Thus attendees will have gained the power to make management happy and hold onto that last thread of sanity. -
Kubernetes hands-on (Workshop)
Kubernetes is how you run Docker in production. Bring your laptop with Docker for Windows or Docker for Mac edge version installed. We'll walk through getting a K8s cluster fired up on Docker-Desktop, minikube, and on Azure. You'll be hosting Docker containers in development and production in no time. We'll dig deep into:
- A quick tour through Docker concepts
- The components of a kubernetes cluster
- pods, services, deployments, and replicas
- ways to scale and expose/isolate your containers
- public and private container registries
- stateful containers
- promoting from development to production
- Azure Container Service (AKS)
- Best practices for building at cloud scale
- Tips & Tricks for leveraging Docker and Kubernetes
- When not to use Kubernetes
We'll look at the commands and ecosystem around building infrastructure as code, local and cloud clusters, and best practices with containers. Come see why devs and ops love Kubernetes. -
Leadership Guide for the Reluctant Leader
Regardless of the technology you know, regardless of the job title you have, you have amazing potential to impact your workplace, community, and beyond.
In this talk, I’ll share a few candid stories of my career failures… I mean… learning opportunities. We’ll start by debunking the myth that leadership == management. Next, we’ll talk about some the attributes, behaviors and skills of good leaders. Last, we’ll cover some practical steps and resources to accelerate your journey.
You’ll walk away with some essential leadership skills I believe anyone can develop, and a good dose of encouragement to be more awesome! -
Learning the Three Types of Microservices
Microservices is a popular, but vague term. And -- it turns out -- definitions of microservices can vary, depending on what you want them to accomplish and how you want them to communicate with each other. So, just what are the three types of Microservices, what makes them unique, and when do you deploy each of them?
In this wide-ranging talk, you'll learn the difference between Stateless, Data-Centric, and Aggregator microservice models, how to identify which one you need to build, and the challenges to keeping each of the up and running in a complex distributed system. You'll also learn how to apply Nygaard's Stability Patterns (from his book, "Release It!") to ensure your Microservice components are stable and resilient throughout the software lifecycle.
Whether you are new to MIcroservices or a veteran, a software developer or enterprise architect, this talk will help you get a handle on how to design and build successful Microservice components for you organization. -
Learning to Fly with Paper Airplanes
In this session, we will learn about the basic forces that allow planes to fly, facts about paper airplanes, and demonstrate many different airplane designs. Most importantly, we will learn two airplane designs that are easy to make and fly very well. We will finish with a competition to see whose plane can fly the farthest, with some special giveaways for the top three winners!
-
Let’s Play A Game! Computer Hacking and Capture the Flag
Have you ever wanted to know how computer hackers are able to get into systems and find out things that they are not supposed to know? If you think you have what it takes to go head to head against other teams to see who can use their computer skills to attack a system then this is the session for you.
Step up to the challenge of breaking into a system to steal passwords, get administrative access and get yourself some free (virtual) goodies. You will be racing against the clock and against the others to see who can get the farthest in solving computer security challenges as you work to own a system.
Ages 13(ish) and up, black hoodies not required. -
Making and Baking an Application Security Department
Houston, we have a problem: we need more application security professionals. There is a lack of talented folks that can test, document and train developers on how to fix web and mobile applications for security vulnerabilities. Verizon’s estimates of 86% of 2017 breaches are caused by an application security component. This is a problem we must solve.
Bill and his team have been researching and experimenting on ways to solve the application security talent shortage. During this session, Bill will explain what they learned by teaching students of different experience levels. He will answer questions like: "Who should I start with?" and "What do they need to know to be effective?" as well as what tools are most appropriate for them to learn. -
Management 101 - The Hard Parts & Great Parts
Deciding on a career path is one of the most challenging and frequently delayed decisions facing engineers. This session will cover a three year management journey, starting on day one and ending today. A journey described as "a trial by fire", "thrown into the deep end" and "successful".
How do you respond to unexpected events in someone's personal life (e.g., "my wife left me last night")? What are the worst parts of management? What are the best parts of management? What tools will help a new manager? Find out the answers to these questions and more.
You'll leave this session with a much better understanding of what it means to be a successful manager and if it's right for you. You'll also leave with some tools to help you should you decide to make the leap. -
Mastering the Art of Mobile Testing
According to the 2017 U.S. Mobile App Report by comScore, mobile web apps have 2.2 times the number of monthly visitors than native mobile apps. This number is expected to grow as consumers are more resistant to downloading apps, increasing the demand to also develop and test progressive web applications. Finding an ideal test automation solution to conduct native mobile and mobile web applications, as well as back-end and front-end mobile testing is a top challenge many software testing teams face today. Join SmartBear's Akshita Puram to learn what's important in a successful mobile application testing strategy. She provides a walk-through of automation frameworks as well as a demo for back and front-end mobile testing.
-
Material Design won't rescue bad UX
Design languages, like Material Design, are a great way to ensure consistency and best practices in your UI. But adhering to a design language won’t result in a good experience if you violate the heuristics of good design, build an experience that doesn’t match the user’s mental model, or complement the work users need to do. In this session, learn best practices for using design languages and the common UX mistakes developers make and how to avoid them.
-
Megahertz, Gigahertz, Registers and Instructions: How does a CPU actually work?
For decades, we’ve been creating ever higher abstractions between ourselves and the computing hardware we’re programming, but in the end whether you’re writing JavaScript, Haskell, or Python it all comes down to 1’s and 0’s running through hardware patterns that were well understood twenty years ago.
We’ll walk through the fundamentals of how CPU’s “think” in an accessible way (no engineering degree required!) so you can appreciate the marvel that is the modern CPU be it in a server data center or your fridge at home. You’ll learn how a CPU turns the code we feed it into actions, what’s the big difference between an ARM and an Intel processor, how CPU’s constantly optimize work for us, and where is it all going for the next few years.
Finally, we'll show how Meltdown and Spectre take advantage of CPU internals to expose data and why this class of security problems are going to be a challenge to the next generation of CPU's. -
Metaprogramming in .NET
Metaprogramming...it’s a term that may come across as abstract, nebulous, or just downright scary. In this session, we’ll break down what metaprogramming is and why it’s relevant to know. You’ll also see the tools and frameworks you can use as a .NET developer (such as Reflection and the Compiler API) to make your programs simple and elegant.
-
Microservice Resiliency with Eureka and Hystrix - Java/Spring Edition
Large scale applications based around a microservices architecture must accept an unfortunate reality - things can and will go wrong. Additionally, today's cloud based deployments virtually guarantee that services will not have static addresses in the network. So building systems that rely on microservices can be a challenge.
Fortunately, some good patterns have emerged in the form of circuit breakers - for dealing with failure, and service discovery - for dealing with network changes.
In this workshop, we will explore service discovery and circuit breakers using the Spring Cloud Netflix library which implements Netflix Eureka for service discovery and Netflix Hystrix for circuit breakers. -
Microservices Orchestration using Istio Service Mesh
If you are migrating your apps to a cloud native architecture in your organization, microservices governance & orchestration becomes very critical for a successful transition. This is where Service Mesh and Sidecar design patterns can help so you don't have to develop a microservices orchestration solution from scratch.
In this presentation, I'll discuss the service mesh based cloud native architecture and go over the current landscape of frameworks and technologies. I'll focus on Istio, which is getting lot of attention in this space.
Outline:
Microservices Governance
Deathstar Architectures
Service Mesh
Sidecar design pattern
Service mesh frameworks
Sample application demo
Conclusions -
Modern 2FA in ASP.NET Core
For many years SMS was the industry’s go-to method of implementing two-factor authentication. But in recent years several high profile attacks have occurred in which attackers have taken advantage of flaws in SMS. In this session I will show you why current 2FA implementations using SMS are inadequate and what other options exist. I’ll also show off some modern software and hardware authenticators and then dive into some code showing how to integrate them into ASP.NET Core. Finally, let’s geek out about the future we all need: a future without passwords.
-
Modern Identity Management (in the Era of Microservices and Serverless)
If you believe that Identity Management (IdM) is just related with the Authentication and Authorization processes, this is a talk for you. IdM is an umbrella term for all of the core logic around identity. That means manage provisioning (assigning identities to user), account management (maintaining those identities), identity governance (assigning them to groups and roles and adjusting permissions as needed), authentication, authorization, identity federation (ensuring users can use the same identification data to access resources on related domains). A login is more than a Single Sign On, we can use Passwordless, Federated Identity (FB, GitHub), Multifactor Authentication.
The main purpose of this talk is gain an in-depth knowledge of those terms, in addition explore some PaaS, that can help to achieve all that in our projects easier and faster. -
Mommy, where do new programming languages come from?
A medley of programming languages can found in use today: Python, Javascript, Go, C++, even Haskell, but where did they come from? Time to go digging through the history books!
This is a comparison of the birth and evolution of seven different languages. Some languages such as C++ and Java share a common ancestry and are semantically very similar. Others, such as Haskell and Ruby are more distantly related. We’re going to go back to the beginning of programming languages and see how they evolved into the languages of today. We’ll learn more about the strange and twisted heritage of: C/C++, Java, Python, Ruby, Javascript, Go, and Haskell, with a few shoutouts to others. -
My users posted what?
Have you ever tried to build a system to categorize text, images, or video as “offensive”? What about combinations of those three? With “memes” today, they have both images and text. Video can have all three. Somehow you are expected to grab a text scanning engine, have a way to analyze images for “adult” content, and scan all of that in a video stream. The problem has been around a while, and many have tried to solve it. Most of the solutions so far have been slamming together various bits of software packages and a lot of work to get them all to work together. Come to my talk and let me show you a first class method to attack that problem with code, machine learning, and the help of the almighty cloud. Not only will I demonstrate how to programmatically configure and control the content, but also how to include a human in the process for the more difficult decisions. I will have code demonstrations and a ton of fun talking about how to deal with folks like myself that sometime cross the “line”.
-
Notebooks are still cool...with Jupyter
Whether you’re coding in Python, R or even JavaScript, Jupyter is a tool you should consider for your toolbelt. Jupyter notebooks provide a platform for data scientists and engineers to rapidly prototype, experiment, and share their findings with each other. Come and learn about how you and your team can leverage Jupyter notebooks, the recently released JupyterLab (Feb 2018), or the collaborative JupyterHub. You’ll leave this session with a better understanding of what you can do with Jupyter notebooks as well as how to run Jupyter notebooks on your local system or your favorite cloud service.
-
Operationalizing containers at scale
Containers have rapidly evolved in the past few years supporting improved development practices, continuous deployment pipeline etc. However not all organizations have the level resources that large IT organizations such as Netflix, Yelp or Spotify can summon to execute containers at a scale.
This talk will dive deeper into the challenges that organizations with a legacy application portfolio, monolith architecture face in managing containers at scale. Challenges such as the need for additional system administration, management, security, governance and more importantly cultural transformation. Further, we shall delve into container platforms, Platform as a Service (PaaS), Containers as a Service (CaaS) etc. and leave the participants with a decision guide in choosing the right technology for their organization. -
Patterns and Architectures Beyond Microservices
Have you slayed the monolith and are ready for more? Learn patterns and architectures that move beyond simple microservices to solve problems of resiliency, security, scalability, responsiveness. Understand the new class of issues that come with distributed systems like microservices. We explore modern patterns like CQRS, sidecars, probabilistic development, code as documentation and others. You will be able to see past the monolith and understand the new problems and patterns that help in modern distributed systems.
-
Pivot: How to proceed when things don't work out
Have you ever failed? Have you ever given your all and it still didn't work out? Whether rooted in mistakes, malice, miscommunication, or mere randomness of the universe, sometimes you just need to pivot. In this soft skills session, we will discuss how to handle it, how to learn from it, and how to carry on.
-
Post Mortem: Dealing with Failure in Development
The world of medicine has a process for reviewing failure and looking for ways to prevent it from happening again. Failure is all to common in development, whether you are building a traditional waterfall project or using the newest agile techniques. In this talk we'll discuss how to apply what the medical community does to our projects and sprints. We'll look at common causes of failure that apply across projects, how failure effects developers and changes team dynamics, and ways to learn from failure to prevent it happening again.
-
Power BI Custom Data Connectors - Your Data, Delivered!
Your company uses Power BI for many projects and reporting needs, and often you're the one who finds, gets and cleans the data in order to make it useful. Wouldn't it be better if you could create a plugin for Power BI that would enable them to import the data, pre-cleaned and ready to use?
This session will start with an overview of the Power Query (M) language used within Excel, Power BI and SSAS. From there I'll demonstrate how to use the Power Query SDK with Visual Studio to create a new plugin for Power BI Desktop, touching on what additional features are only available through Custom Data Connectors. I'll code an end-to-end example that pulls data from an external web service, adding features like custom authentication and navigation tables to make the data easily accessible to users.
You'll leave this session with enough knowledge to create your first connector and solidify your superhero status in a data-hungry world. -
Practical Steps to Modernizing Legacy Applications
And then one day it happens. The code you trusted for years lives beyond its useful lifetime and you have to send it off to retirement. In some cases, your application becomes obsolete because the technologies it is built on are no longer supported (can anyone say Silverlight? Mainframe?) In others, the application was simply built using the wrong principles, even if it was built on bleeding edge technology. In each case, the application is amassing technical debt and there is no joy for the developers building and supporting it.
This session was originally envisioned through experiences modernizing mainframe applications. It was realized through frustration dealing with modern .NET applications built on unsustainable principles that required major surgery.
In this session, you will learn
* Why refactor over rebuild works as a rule
* When you should pitch the rule and choose to rebuild
* How the strangulation pattern works to reduce risk during modernization
* Why automated testing is critical to success -
Premise: Promises
The promise construct has been around since the late 70‘s, and iOS has had libraries for promises since at least 2015. Still, it seems like Swift has been slower to adopt promises than other languages. Promises can make tangled networking code more readable and can simplify complicated API business. Let’s take a look at how a tangle of calls to separate API’s, some using information dependent on previous calls, can be simplified into a series of promises fulfilled or rejected. We’ll investigate how promises can make unit testing easier, the pros and cons of various promise frameworks for Swift and of the promise pattern itself.
-
Puppets are AWESOME
Mahna-mahna, do do do-do-do! Puppets come in all shapes and sizes and styles, from shadows to socks to marionettes and more. Puppets can be found all over the world. And the best part is there is no limit to what they can do - just your imagination. Together, we will look at the unique history of puppets, learn about the different styles of puppets, and ways you can build your own. Then, at an Open Space after the class, we will have supplies to build your own puppet to take home with you!
-
React Native and Expo: Native Apps without the Native Pain
Native iOS development requires cool languages, like Swift... that you’ll never use anywhere else. The development environment is painful: build tools straight out of the 80's, certificate hell, TestFlight weirdness. And Android development may be even worse! React Native uses tools and languages you already know—JavaScript and React—to build native apps that use real native components. Meanwhile, Expo is a cloud-based app building service that eliminates just about all the native pain points not addressed by React Native itself. Just upload your code and out comes a signed native binary that even supports OTA updates without the App Store. There’s no need to ever touch an Xcode or Android Studio project. You’ll learn the core concepts behind React Native and Expo, peek under the hood of a live example wired up to data and navigation, and see how to build a store-ready app in just a few simple commands.
-
React: The Big Picture
You've heard of React, but is it right for you? In this session, you'll learn why React has become so popular. Next, you will learn the tradeoffs inherent in React's design. Finally, we will explore some drawbacks to consider. After this session, you'll have a clear understanding of React's core use cases, advantages, and drawbacks so you can make an educated decision on whether React is right for you.
-
Real Pirates Seek the C!
I want you to experience the joys of the C! I'll help you get your C legs with simple tricks to make this venerable language work with the latest trends in programming. Simple project setup using Make and CMake. Functional programming. Test Driven Development & Automated Testing. Programming to interfaces. Design patterns. REST clients and servers. IoT. Cloud computing. I'll help you throw off the chains of Enterprise development, hoist the Jolly Roger, and deliver results faster, using fewer resources with this venerable, modern language.
-
Rekindle Your Love - Avoiding Burnout In A Fast Paced World
Burnout is real. You may wish it wasn't or think it could never happen to you. But the truth is that burnout can happen to even the most dedicated, driven, and passionate people. The good news is that you can learn to control that dreaded beast before it has a chance to ruin your career.
Did you dream of changing the world someday? Creating a beautiful future where you are loved because you made people's lives better? As the years ticked on (tick-tock, tick-tock) your goals got lost. The beautiful future you dreamed of got lost in countless meetings, deadlines, stories and bugs. So many bugs! The excitement became "just a job". Rekindle the romance and find that excitement again. Take the journey of a lifetime towards the beautiful future you imagined. In this talk you will learn: How your past is affecting your performance today, the importance of maintaining a balanced life, and how to achieve the satisfaction you long for. -
Remove The Roadblox With Roblox Game Making 101
Roblox is the super cool multi-player game. It’s like Minecraft and building Legos combined into one. You can create an account and play games other people have created, or you can build your own game using Roblox Studio.
When you build a game in Roblox Studio you get to use your imagination to create any kind of virtual environment and game. Once you publish your game you can then have all your friends join your game and play together.
I’m going to show you how to play Roblox, how to use Roblox Studio and walk you through steps to create your own game!
This session will be hands-on so bring a laptop and a mouse to help you become a Roblox building master. -
Revisiting SOLID - Making the 5 principles easy enough to implement
Can you explain what all five principles in SOLID do? The purpose behind SOLID was to encourage writing loosely-coupled, extendable, predictable applications that were easier to test and easier to upgrade over time. Does that describe the applications you work on? If not, this session is for you. This session takes a practical look at the SOLID principles to see how they can be applied to new and existing applications to make them better over time. You will leave this session with a deeper understand of the practical ways to implement SOLID, as well as all source code for the session.
-
Rock-Solid Components with Typescript and GraphQL
Most recent javascript frameworks bring a solid component model to modern web development, but how can you guarantee that your components work correctly? In this session, you learn how the features of Typescript can be leveraged to bring clarity and dependability when constructing components with React. Using Typescript can help to catch errors early in the development life-cycle. GraphQL and its type system can ensure confidence in your components while fetching remote data. This comprehensive approach ensures that your components behave as you expect, and allows you to eliminate run-time errors. Learn how using types can keep your users happy!
-
Scenario Testing for Teams
Full regression as a release testing strategy might be useful for shaking out a lot issues in the product prior to release, but it is an extremely expensive exercise and does not guarantee that the highest priority issues are discovered. If the success of your release is reliant upon the experience of a target user in a target market, a list of 100 minor issues that user would not care about is not valuable. Pressing every button in the product to produce that list is not practical. One alternative strategy for release testing is scenario testing: a powerful exploratory technique that uncovers bugs that users care about.
In this experience report, software tester Sydney Frandsen will discuss how TechSmith's Camtasia team revamped their pre-release team testing from a spreadsheet-based checklist of functional regression tests to a scenario-based activity that shook out issues most impactful to their customers. By focusing on the workflows heavily trafficked by target users, the Camtasia development team was able to identify the issues that truly needed addressing before their release. Sydney will present the value of scenario testing as it relates to release testing, how she demonstrated and maximized test coverage using this technique, and battle-tested techniques that any team could use to make whole-team scenario testing both fun and productive. -
Securing Your API Endpoints - A Practical Authentication Guide
It's never been easier to expose services over HTTP. It's also never been easier to inadvertently expose security holes via those same services. This session is designed for any developer or architect that wants a conceptual overview of API security without getting into the weeds of cryptography or complex authentication frameworks. You'll learn about OAuth, API Keys, HMAC, JSON Web Tokens (JWT) and more. Don't worry if those things sound foreign; they'll be explained in a clear, practical way so that you’ll be able to choose the appropriate tool for your specific needs.
-
Seeking the holy Graal
Have you wished your Java program would run faster? Maybe you were seeking a JVM based scripting language to perform as great as Java ? Wouldn't it be cool if you could transpile your polygot language to native binary? Then you might have just found the holy grail. Wait the spelling is misleading, but the results are not, introducing GraalVM. This is a universal virtual machine that can take any JVM language and convert it to a faster bytecode embedded in the JVM, or compile via LLVM to a native application. Examples will include Java, JavaScript, and Kotlin. The attendee will leave this session understanding how to get started optimizing their Java applications as well as how any JVM based scripting language can gain native speeds.
-
Serverless security: defence against the dark arts
Our serverless applications are more secure by default, since AWS has taken over the security of both the infrastructure as well as the operation system. Known vulnerabilities such as spectre and meltdown are patched without us having to lift a finger.
But there is still a large attack surface in our application code, and the OWASP top 10 list is as relevant as ever. Attacks such as SQL injection and cross-site scripting (XSS) can still plague us, and our dependencies can be compromised to steal sensitive data.
Join us in this session as we discuss many of the security risks that serverless teams still have to face, and some of the leading practices to make your serverless application more secure. -
Serverless? How About VENDORLESS?!
Serverless computing -- they’re functions, but that doesn’t sound as provocative -- is here to stay. Some people even think it will take over and be the future of computing. But there’s one problem: Vendor lock in.
Azure Functions, AWS Lambdas, Google Cloud Functions … they will all meet your needs, but do you really want to put all your proverbial computing eggs into one vendor basket? Also; what if you just want to learn (“play around with”) functions without spending money?
Enter OpenWhisk, the open source serverless (“THEY’RE FUNCTIONS!”) computing engine that runs anywhere: Azure, Amazon, Google, your hosting platform of choice, or in-house. Or everywhere. Your choice, you decide, you are in control.
This session will demonstrate how one code base -- no matter the programming language! -- can run on any platform, avoiding vendor lock in and putting you back in control of your cloud native development. -
Service Blueprints: How the (User Experience) Sausage is Made
What constitutes user experience? It is not simply a collection of technology capabilities. The experiences of users and customers are created by an ecosystem of people, products, platforms, infrastructure, etc. When designing and creating experiences, the whole ecosystem must be considered including the way that ecosystem affects and changes human behaviors.
Service blueprints, a service design technique, can be an important tool for illuminating and making design decisions in the context of the whole value network. By understanding the value network, even teams several steps removed from customers can orient themselves towards great user experience. -
Service Workers in the Wild
Ever wanted to make the internet work offline? This will serve as a gentle introduction to Service Workers, the Cache API and how we leveraged both to save bandwidth and improve reliability when we deployed dozens of interactive outdoor kiosks with a web-based OS. We'll discuss some of the gotchas, challenges and how you can start using Service Workers in your own apps today.
-
Side Project Adherence - How to stick with a side project.
Scott will be talking about how he stuck with his side project for over 5 years and how it helped him land and keep a job as a software developer.
Establish incentives, figure out your why, set goals, get organized and be relentless. Or if thats not important to you, dont do that. Figure out what you want to do and attack it with 110% of your energy and passion. -
So, You Want to Be a Game Designer? – A Board Game Jam
Have you ever been curious about how to design a game? Or maybe you would like to make games when you grow up? If yes, then here's your chance to learn about how to take your ideas, discover what makes them "fun", and work in teams to create a board game prototype in just a couple of hours.
In this KidzMash Divez session, participants will learn the basic principles of game design and development by collaborating in a board game jam. Game jams are quick exercises to experiment with ideas and build a playable board game prototype. Participants will work in teams to brainstorm their games before they create the rules, artwork, and playing pieces for their prototype based on a common theme. As they work together, attendees will experience how development teams are structured, learn about play-testing and iterating on ideas, and setting achievable project goals. The overall experience will be a friendly, guided introduction into the steps for developing an idea into a product within the context of creating a physical board game.
Limit: 30 participants, ages 12 – 17, materials will be supplied, no electronics necessary. -
Space Mission #251: Colonization
Attention all registered kidz. Multiple habitable planets have been detected in the far reaches of space. Mission Control needs you and your teammates to design the spacecraft, pilot it to your destination, and create a safe and controlled environment for the colonists to live on. You will race against the clock (and other teams) to set up your colony and eventually face ‘The Unknown Variable’. This simulation will not only put your problem-solving skills to the test, but build your teamwork and leadership skills as your team strives to be known as the best explorers in the galaxy. If you wish to compete in this activity, or want to have fun, please report to the assigned room at the registered time. Over. (Recommended for explorers ages 5 and up.)
-
Spring-loaded GraphQL
What if you could update the structure of the JSON payload you receive from you backend without having to update all the controllers, DTOs, services, and SQL queries? This is the promise of GraphQL--an alternative strategy to traditional REST APIs that allows client code to specify exactly what data it needs. This session will offer a nuts-and-bolts exploration of how to quickly implement a GraphQL API within a (Java) Spring app using the Spring Boot GraphQL starter. Real-world considerations such as testing, performance, and security will also be discussed so that attendees will leave well-prepared to start writing their own GraphQL endpoints.
-
Stargazing
Shoot for the stars! Learn about astronomy and assemble your own portable mini domed planetarium with common, everyday item like cardstock. We will use a bright LED bulb to be able to project the stars from your planetarium onto the ceiling. We will also point out the major constellations found on your planetarium.
-
Successful Integration Testing in .Net
In the very early days of Agile development and Test Driven Development, we strove to structure our code such that we could write isolated unit tests with little or no coupling to infrastructure. Great, and it helped, but frequently that led to more complicated code internals and you still had issues from interactions with said infrastructure. What if instead, we could more effectively do quick, reliable integration testing? Could that simplify some of our code -- especially when combined with microservice architectures? Do we need to reconsider where our efforts go in the old "testing pyramid?" How does ASP.Net Core support far better server side testing than previous versions? Where does HTTP contract testing fit in? Can Docker help us out? Should we pursue other techniques besides just trying to use Selenium? What about using alternative NoSQL style databases? Or if I'm stuck with relational databases, what can we do to soften the aggravations?
I'll try to address all these questions and tackle automated testing best practices in this workshop. -
Sustainable Styles: Fundamental Principles of CSS Architecture
CSS is easy, right? Yet why is it that every project’s CSS styles seem to get out-of-control and frustrating so quickly? The global nature of CSS allows tremendous flexibility, but without a plan and enforced structure, styles get out of hand. In this session, learn how to reign in the global nature of CSS by following a series of foundational principles that will allow your team to collaborate on styles in a structured way that is easier for everyone to understand and prevents the oh-so-often collision of styles. You’ll walk away with more insight on:
- Naming CSS classes
- 7 types of CSS rules
- Leveraging key features of Sass for code simplicity
- Strategies for code organization and source ordering
Once you understand and implement these principles of CSS architecture, creating or changing styles in your project will no longer be the terrifying proposition it once was. -
Systems Thinking for Kids
What are the best feet in the world? The fast feet of a cheetah? The giant feet of an elephant? What about the best arms? Best legs? Best head? What would a creature made up of all the best parts look like? Probably more like Frankenstein's monster than any finely tuned machine.
During this session, kids will learn about systems thinking by working in small groups to draw very surprising (not very practical) creatures. -
Talking Cars: From Can't to CAN
Talking Cars: From Can't to CAN
Modern vehicles are critically vulnerable. They rely on many electronic computers and sensors which communicate by broadcasting critical information over many Controller Area Networks (CANs). Previous research has shown that a vehicle’s network has dangerous implications—hackers can collect data from remote vehicles and even disrupt vehicle control. Despite the relative simplicity of the network, there is a steep learning curve which can serve as a barrier of entry for would-be researchers and developers. Moreover, many interfaces and tools to communicate with a vehicle’s CAN are expensive and difficult for a novice to use. In lieu of traditional interfaces, many developers opt for the do-it-yourself route and build their own devices with clever programming and a single-board computer. This pre-compiler will focus on the nuts-and-bits of CAN including construction of an automotive Raspberry Pi interface which will be used to read, inject, and analyze the properties of a vehicular network. Attendees will get hands-on experience building the interface and interacting with automobiles, starting with physical construction of the device up to implementing basic CAN functions with Python libraries. After the workshop concludes, attendees will have the option to take their Raspberry Pi interface home and begin exploring their own vehicles!*
*Requires ticket/waiver. Not held responsible for bricking, DMCA violations, or accidents. Void where prohibited. -
Team Happiness for Fun and Profit
Employers woo developers with ping pong tables, free lunches, and beer taps. But it's still rare for employees to stay in a job for more than five years. So what can we do to make our work life better, and reduce employee turnover? In this session we will talk about:
* Tips for self-care that I've found useful.
* What you can do to make your work more rewarding.
* Steps your company can take to reduce employee turnover.
* How to care for your team. -
Testing Like You've Never Tested Before (Because You Haven't)
Testing software in an automated fashion is one of the best ways to guarantee quality, reduce bugs, and prevent regressions in our code, and is a prerequisite to operating in a Continuous Integration environment. Unfortunately, the most difficult parts of testing come right at the beginning: scaffolding a test suite and writing our very first tests. For those who are new to automated testing, these hurdles can prove overwhelming.
This talk covers the fundamentals of testing, in a beginner-friendly way. We'll discuss how testing makes software better, the various levels of the Automation Pyramid, how to scaffold some basic unit and integration tests, and discuss the characteristics of great tests. -
The Actor Model and why you should be using it
You are probably familiar with the object-oriented and functional programming paradigms, but what about the actor model? The actor model is designed for concurrent programming and is an easy way to create systems that do many things at once. For example, the actor model is an excellent way to implement IoT (Internet of Things) applications or take advantage of the processing power of multiple CPU cores. Actors provide a natural way to model and reason about concurrent systems, especially for developers working in object-oriented languages. In this session, you will learn the fundamentals of the actor model. You will learn how actors work, communicate, and act as state machines. You will see how groups of actors cooperate in distributed, scalable, and fault tolerant systems. The session will include code examples in Akka.NET, which is a toolkit for C# and F#. At the end of this session, you will know the strengths and weaknesses of actor systems, and when they may help you solve a problem.
-
The Admiral's Language of Choice
Most of us know about Admiral Grace Hopper. She is rightly recognized as a pioneer in computer science and innovator of the compiler many of us depend on today, yet deriding one of her most-lasting impacts, COBOL, is fashionable. Go on a journey starting with the landscape of computing that led to the creation of the first machine-independent programming language and see the language constructs that enable its most common platform, the mainframe, to process 2.5 billion transactions a day. Walk away having seen actual COBOL code and maybe an appreciation for why so much of it still runs our world every day.
-
The Agile DBA: A Guide To SQL Server DevOps With SSDT
Whether you are the DBA for an Agile, Sprint-based team, or a Developer with DBA responsibilities, you may feel like the development bottleneck at every turn. You’ve stuck with the existing processes and tools because it’s what you know. After all, “If it ain’t broke, don’t fix it!” Right?
I have good news! With only a few new skills and free tools from Microsoft, you can join the Agile & DevOps revolution to help accelerate your team, product, and data infrastructure.
In this session I’ll use the newest version of SQL Server Data Tools (SSDT) to model an existing database and then demonstrate each step from modification to a working, automated deployment. By the end of the session, you'll see how continuous integration and deployment (CI/CD) can revolutionize your SQL Server database development.
After seeing the possibilities, you'll be ready to change those old processes. And in no time at all, you’ll be the talk of the team as they try to keep pace with you!
This talk is applicable to both SQL Server DBA's and Full-stack .NET devs that use SQL Server as their data platform. -
The Alchemy of User Experience
al-che-my (noun) : any magical power or process of transmuting a common substance, usually of little value, into a substance of great value. The goal of the alchemist is to produce a Master Work by steadily improving the mind and the body. When seeking the best outcome in UX, there is hardly a difference. We'll explore the practice of using cyphers such as the Gestalt principles of design and the transmutation of base concepts like the Golden Ratio, and place what we find in our crucible of rapid prototypes. We'll consider what emerges as prophesied by agile usability testing and with some luck find the Elixir of Life contained in the UX Philosopher's Stone - a collection of tools and techniques for practicing UX Alchemy. One lucky apprentice will leave with a copy of Illuminate by Nancy Duarte.
-
The Automation Firehose: Be Strategic and Tactical
The widespread adoption of test automation has led to numerous challenges that range from development lifecycle integration to simple scripting strategy. Just because a scenario CAN be automated does not mean it SHOULD be automated. Teams that adopt automation often rush to automate everything they can -- the automation firehose. For those scenarios that should automated, every team must adopt an implementation plan to ensure value is derived from reliable automated test execution. In this session, the audience will learn how to automate both strategically and tactically to maximize the benefits of automation. Entry criteria will be demonstrated for automation in the development lifecycle along with a set of checks to determine automation feasibility & ROI.
-
The Great Gatsby: Building Fast Static Sites in React
There are a lot of choices when building static sites. A new rising star is Gatsby: a static site generator built in React. You'll learn about the benefits of static sites in general and what makes Gatsby a compelling choice. Once we get over some hurdles with React we'll dive into topics such as data fetching from static files and CMSes like WordPress and Contentful, styling with styled-components, and continuous deployment with GitHub to Netlify and Amazon S3. You'll walk away with all the knowledge you need to build a site that feels almost instantaneous to your users and costs practically nothing to host.
-
The OWASP Proactive Controls 2018
The OWASP Top Ten Proactive Controls 2018 is a list of security techniques that should be included in every software development project. They are ordered by order of importance, with control number 1 being the most important. This document was written by developers for developers to assist those new to secure development. Topics will include:
1) Define Security Requirements
2) Leverage Security Frameworks and Libraries
3) Secure Database Access
4) Encode and Escape Data
5) Validate All Inputs
6) Implement Digital Identity
7) Enforce Access Controls
8) Protect Data Everywhere
9) Implement Security Logging and Monitoring
10) Handle All Errors and Exceptions
This talk is made for those new to security and secure coding. -
The Perimeter Has Been Shattered: Attacking and Defending Mobility and IoT on the Enterprise Network
Mobility and the Internet of Things (IoT) have disrupted the corporate enterprise network on the scale that PCs disrupted mainframes in the 1980s. Yet most enterprises continue to approach security as if though there is still a hard perimeter with nothing but corporate-owned end points running against internal applications. Mobility, however, means employee-owned end points connecting over public carrier networks to cloud applications. Traditional perimeter security simply doesn’t address this.
From mobile-based phishing to Bluetooth-based attacks, mobile and IoT have fundamentally changed the threat landscape. In this talk we will look at the modern threat landscape, the security controls currently available on the market (such as mobile threat defense and mobile application management), and provide real world examples of how they fall short under simulated attack. Finally, we will look at practical ways to improve enterprise security around mobile and IoT as well as cause the defensive products to evolve to be more robust. -
The Pi, Python, & Paintball? Innovating with Affordable Tech!
What do you get when you mix a handful of RaspberryPi's, Python, Paintball, and a little innovation? Come to this talk and find out! We'll take a look at a RaspberryPi project that was created to aid a nonprofit as a case study of the amazing opportunities that exist for anyone with the passion to innovate. This project uses affordable maker tech to build a distributed game management system with text to voice capabilities, synchronized countdown timers, remote picture taking, and much more. All in portable boxes that hang in trees. We'll talk about the hardware, the software, and most of all the learning required. All while exploring what's available in this amazing age of innovation! We'll cover topics like communicating across distributed IOT devices, event based programming, building a network in nature, scripting pi builds with ansible, and one developers intrepid journey into electronics.
-
The Pragmatic Guide to Web Application Security
As a developer, your customers expect a constant stream of shiny new features. While it's important to deliver business value, there's more to building a web application. Keeping your apps secure is vital to the health of your company. It seems like there's a new story every week of a company that failed to secure their data. A security breach resulting from your faulty code is the ultimate career limiting move. Your beautiful application isn't much use if it can get hacked by a bored teenager.
In this talk, you'll learn how to secure modern web applications. You'll about how to examine the data flows of your app to find security flaws before you write a single line of code. You'll learn how to attack your own web app to find security vulnerabilities. Finally, you will also learn how to secure the different layers of your application against common attacks. By the end of this talk, you will be well on your way to keeping the bad guys out of our app. -
The Reality War
In the past, the power of augmenting reality has only been available to a few like Thanos, but no more! Since the release of ARKit on iOS, there have been thousands of apps developed providing augmented reality experiences. But what can you do with this technology? If you're not a native mobile developer, what are you to do? This crash course in Augmented Reality will walk you through multiple libraries across multiple platforms including iOS, Android, and Web. Come take a journey through the different realities we will create. And you don't even need an Infinity Gauntlet.
-
The Science of Testing
In the past decade the software development paradigm has shifted to “deliver fast” -- with concomitant frameworks and methodologies to support that emphasis – but without proper consideration of quality. So most teams end up failing fast and hard when development continues beyond a shaky foundation. To bring about positive change, we must improve both our knowledge base and our processes to achieve quality delivery without disturbing the bookkeeper’s project delivery timelines. Lessons learned from a career in research science can be applied to QA, with parallels to industry product quality models. Testing techniques and product delivery processes from research science will aid not just testers but the entire team in delivering quality software. More than just day-to-day team activities and testing tools, the science of testing is about the pursuit of knowledge and understanding for its own sake. Testers should foster their skills in the community with professional development activities. Those in attendance will learn about the successes and failures of applying a scientist’s approach to testing software, from the “publish-or-perish” mindset of science to “deliver fast” in IT.
-
THE STORIES OF THE MOST INFAMOUS BUGS
Whenever we write code we eventually make mistakes and have “bugs”. We employ many techniques including testing and reviews to avoid them but some mistakes still make it into production.
The topic of famous bugs in history has intrigued me for a very long time and it is a subject I enjoy researching. In this talk we will explore 5 of the most famous bugs, their consequences and what we can learn from them:
Why the Mars climate orbiter did not orbit
How the Ariane-5 rocket was lost
Waiting for the long distance AT&T call
How the world didn’t end in September 1983
The fatal Patriot missile miscalculation -
The Two Question Code Quiz: How to Interview Programmers Effectively
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. There's also 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 your 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. -
The Well Architected Automation Framework
Test automation talks tend to focus on dealing with flakey tests, reducing runtime, etc. even after most of those problems had credible solutions 5+ years ago. What doesn’t get discussed at automation events is where their automation is run and how that has just as much an impact on the success of the automation project. It also would comfortably place money on the table that an incorrectly configured automation environment is responsible for at least one major privacy breach – and will be again in the future. Do you want to responsible for a GDPR penalty? I don’t… This talk introduces AWS’ ‘Well Architected Framework’ as a reference on how to bring Security, Reliability, Performance Efficiency, Cost Optimization, and Operational Excellence to your automation infrastructure.
Disclaimer One: This talk will use AWS terminology, but the concepts will apply to all cloud providers.
Disclaimer Two: I don’t work for AWS, I just find their framework useful. -
Threat Modeling Workshop
Threat modeling is a way of thinking about what could go wrong and how to prevent it. Instinctively, we all think this way in regards to our own personal security and safety. When it comes to building software, some software shops either skip the important step of threat modeling in secure software design or, they have tried threat modeling before but haven't quite figured out how to connect the threat models to real world software development and its priorities. Threat modeling should be part of your secure software design process. Using threat modeling and some principals of risk management, you can design software in a way that makes security one of the top goals, along with performance, scalability, reliability, and maintenance.
Objective: In this workshop, attendees will be introduced to Threat Modeling, learn how to conduct a Threat Modeling session, learn how to use practical strategies in finding Threats and how to apply Risk Management in dealing with the threats. Depending on time, we will go through 1 or 2 Real World Threat Modeling case studies. Finally, we will end the day with common gotchas in Threat Modeling and how to watch out for them. -
Time Management for the Distracted Developer
I am a distracted developer. I've had Attention-Deficit Hyperactivity Disorder (ADHD) my entire life. I've also been a programmer professionally for 10+ years and I've always been... was that a butterfly? It sure was pretty. I wonder what species it is? I should go find out... but I also needed to submit those change requests and oh wait here's that TODO list I misplaced yesterday, need to investigate that...
Wait, what was I doing again?
Programming being a mentally-intensive occupation, it's quite easy to get distracted and lose the focus that is so critical to good development. This session will cover a bunch of tips, trials, failures, and successes I've picked up during my career as a distracted developer, including different focus techniques, structures which can improve time-management skills and an overview of the various methods used to redirect distracted individuals and help them focus. If you find yourself easily distracted, even if you don't have a medical condition like I do, you'll find something to use in this session.
Distraction is the enemy. You can't beat it forever, but you can ward it off. This session will show you how. -
Towards a responsible Internet of Things
More and more aspects of our lives are becoming connected to the internet. While today they tend to be large, expensive, or otherwise visible and consciously acquired, in the near future these devices will be ubiquitous, pervasive, and if we're not careful, invasive.
There are many (https://iotmark.wordpress.com, https://www.thingscon.com/iot-trustmark, https://www.bvdw.org/presse/detail/artikel/digitalbranche-befuerwortet-datentransparenz-bei-iot-geraeten/ etc) efforts underway to find a framework to enable consumers to better understand what exactly they are getting when inviting these connected devices into their homes. What data is being collected? What happens if the company goes out of business?
This talk is an overview of the current thoughts and best practices that should be considered while designing a connected device (or service based on connected devices), and is appropriate for everyone from consumers to interested practitioners. -
TypeScript for C# Programmers
TypeScript is a powerful language but introductory courses are often targeted at JavaScript programmers. The truth, however, is that TypeScript is very close to C#, and with just an hour's overview you can be highly productive writing in this powerful programming language for the web.
-
UI Tests Are Fun to Write (If You Write Them Right)
Automated browser tests can be a nightmare to write and maintain. Unlike unit tests they’re tough to set up, slow to run, make permanent changes to data, and they’re incredibly brittle. Even a tiny CSS change can result in cascading failures!
You can’t ignore these issues, but you CAN design around them by adopting a few key patterns and techniques. Data creation helpers let you construct intricate data graphs in one line of code. Page Objects abstract away tedious browser automation code and make tests resilient to changes in HTML structure. You'll also see some anti-patterns that are definitely NOT fun to write. Developers will leave this session prepared to inject some newfound joy into their UI testing efforts. (Some examples use WebDriver, although the session is largely test tool agnostic) -
Understand your brain to build better visualizations.
No one questions that data is vital to application development, our teams spend untold hours obsessing about data structures. We build useful data layers and strive to eliminate processing roadblocks so that our data services are fast and fluid.
Do you spend that much effort on the visual portrayal of the data? If not, why not?
At some point in the data analytics cycle you need to show results to the stakeholder. That’s when choosing the correct visual representation of the data becomes vital. Do it wrong and the data is merely wrapped in pretty graphics; do it right and the user perceives their information in clear and meaningful patterns.
This fast paced and entertaining session starts by looking at how your brain and optical system perceive data. This session explores the overall visualization concepts that make data easier to grasp. Do you know the best way to show data to your users, so that the information is clear and understandable? Come to this session to learn how to make your data shine. -
Unit Testing in Sass
Remember that time someone on your team removed some questionable Sass, only to result in a broken UI? If this scenario sounds familiar, then Sass unit testing is for you! In this session, you’ll learn how unit testing is applied to Sass, how it can benefit your large project, and how to set it up in your own codebase. Lindsey will share her experience of unit testing an enterprise-level design system and how it has prevented unexpected UI changes.
Consider this session if:
- You work on large projects heavily relying on a consistent UI, such as a design system
- You are passionate about code quality and testing
- You’ve worked with unit testing before and you’re curious to know if it could translate into a styling language -
Unraveling Realities: Building HoloLens Apps With Unity & C#
As the universe of immersive technologies expands, it's easy to get overwhelmed and sometimes confused not only by device choice and experience, but also by terminology. In this session, as we discuss virtual, augmented, and mixed realities -- what they mean, how they're used, and where they overlap -- you'll discover how to build your own personal reality for HoloLens, the wearable, self-contained, holographic computer. You don't even need a device to get started! Create an experience in the Unity 3D engine, which supports C# for programmatic manipulation of objects. We'll then step through the process for building Unity projects as Universal Windows Platform (UWP) solutions, maintaining them in version control, and deploying them for testing to the HoloLens emulator in Visual Studio.
-
Up & Running with Graph Databases
This tutorial will include a mixture of theory, hands-on coding, and take home examples with a sample graph database. It will also build an understanding and provide use cases for graphs. While we will use Java in the tutorial, attendees will also be provided with PHP, Python and Ruby examples.
A summary of what attendees will learn:
- An understanding of graph databases
- Setting up, configuring and optimizing a graph database
- Introduction to data modeling with Graph databases
- Connecting to the graph and CRUD operations
- Building a graph enabled application -
User-Story Driven Threat Modeling
Threat modeling is a way of thinking about what could go wrong and how to prevent it. When it comes to building software, some software shops either skip the important step of threat modeling in secure software design or, they have tried threat modeling before but haven't quite figured out how to connect the threat models to real world software development and its priorities.
Threat modeling should be part of your secure software design process. In this session we will look at some of the latest advances in threat modeling integrated with Agile Development processes by using User Stories and Abuser Stories. This process is iterative and meant to keep step with Agile Development practices. By enumerating Threats against User Stories / Abuser Stories, you are not threat modeling an entire/massive system, but going granular by enumerating threats against relevant user stories. Finally, you will see how this process facilitates the creation of multiple segues into Security Test Cases and Mitigation Plans. You will see how this process works with an automated approach to security test cases. -
Using Javascript to draw an animated Poké Ball
In this hands on session the kids will create an animated Poké Ball using Javascript. We will explore basic drawing functions and put them together to form a Poké Ball. We will then animate the Poké Ball opening. Finally we will add a surprise inside the Poké Ball!
-
Versioning 1.0.1
Versioning remains one of the trickiest and under-discussed aspects of software development. Shipping 1.0 of a library or framework can be easy compared with shipping 1.1 and worrying about your existing users. "But semantic versioning!" you respond... yeah, not so much. It's easy to say "No breaking changes within a major version" - but what does that mean, exactly? And what does shipping 1.1 or 2.0 mean for anyone who depends on your package? How can we avoid an impending versioning apocalypse?
This talk will use C# and .NET for concrete examples, but the questions raised are applicable - with potentially different answers - to all platforms and languages. -
Wait, CSS Can Do That?!
For most programmers, CSS isn't the first language learned. Nevertheless, when you pick CSS up, it's easy to get the basics (selectors, layouts, positioning, etc.) and easier to loathe. In the end you'll probably reach for Bootstrap to make your site responsive (like everyone else's) and jQuery to add some pop animation.
This session demonstrates ways CSS can help you achieve the same outcome without the extra libraries. At the end you'll learn how CSS Grid & Flexbox is used for site layouts, and how CSS by itself can produce purposeful animations. For each of these topics, we'll cover the underlying concept, how it is implemented, and where to go when you're in need of troubleshooting. -
Wait...My Mobile App Needs to Be PCI Compliant!??
Many folks think mobile apps don’t need to be PCI (Payment Card Industry) compliant – but that’s true. So why do delivery teams think their apps are out of PCI scope, even when the app accepts card payments? Well, unless you dig through pages of documentation, understanding the relationship between PCI compliance and mobile apps is quite difficult.
This talk discusses the history of the PCI Data Security Standard and what PCI “compliance” means, particularly when looking at mobile apps. (Specifically – apps that run on consumer devices and do NOT use a hardware accessory with a validated Point-to-Point Encryption solution.)
Attendees will walk away knowing why their delivery team should keep PCI compliance top of mind when developing mobile apps. Furthermore, they will have a list of actions their team can take to ensure their development process aligns with the PCI Data Security Standard. -
Webpack Encore: Webpack your App and Love it!
Adding Webpack to your application will absolutely *change* the way you develop your frontend. But... getting a pro Webpack setup is a *lot* of work: handing CSS, minification, versioning, source maps, code splitting & a lot more! Wow!
Say hello to Webpack Encore: a Webpack configuration helper to give you an awesome Webpack setup in minutes. In this talk, we'll learn what Webpack does, then get a fully-functional build system in just a few lines with Webpack Encore. Need React support? Sass? VueJS? Just enable the features you need. The best part? You're still using native Webpack behind the scenes: no magic. And, you can add *any* custom config you need.
Go Webpack go! -
What are Observables and why should I care?
Learn about the next generation of asynchronous abstraction: Observables. Born of a cross between the Observer & Iterator patterns, observables are being used from Angular to the data teams at Netflix & Microsoft. Start at a high level, learning why observables stand out among the many asynchronous abstractions available to the developer. Then, learn how to conceptualize event streams as simple observable flows when tackling typeaheads on the frontend. Finally, enter the world of machine learning and see how observables can be used for stream processing. Walk out with the confidence to harness the power of observables to straighten out your asynchronous apocalypse.
-
What is a Command Bus?
There has been a lot of buzz in recent years around the concept of a command bus, but if you've never used it before it can be intimidating. During this talk we will break down the basic concepts, build our own command bus, discuss pros and cons, and review different frameworks that make this work easy. By creating our own command bus we can see exactly what it does and how it works so that it will no longer be a black box. This will give you a practical introduction so that you can get started implementing this in your apps today.
-
What's All The Fuss About Serverless?
Dude, where's my server?! The word 'Serverless' can be a bit misleading, but this architecture style has exploded in the tech industry and offers a myriad of unique benefits. Unfortunately, real comprehension of this concept has been abstracted away just as much as our server—turning the word 'Serverless' into little more than marketing jargon. In this talk we'll define Serverless, work through a sample, discuss the benefits / compromises, go over real-world use cases, and examine the Serverless economy.
-
Why are we talking about XSS in 2019?
Why are we talking about XSS in 2019?
We're unfortunately still talking about client side script injection or Cross Site Scripting (XSS) in 2019 because it's painfully difficult to defend against XSS even to this day.
This talk is a fundamental technology update on how developers build and secure web user interface code. We'll address new defensive strategies such as modern JavaScript framework defense in Angular, React and other frameworks. We'll also look at how CSP deployment has changed in the past 7 years illustrating the progressive use of content security which supports CSP v1, v2 and v3 concurrently. We will then look at advances in HTML sanitization on both the client and server side as well as focus on sanitizers and defensive libraries that have stood the test of time in terms of maintenance and security. We'll also look at interesting design topics such as how HTML injection is still critical even in the face of rigorous XSS defense and how HTTPOnly cookies are largely ineffective. This talk should help developers and security professionals alike build a focused and modern strategy to defend against XSS in modern applications. -
Xamarin! Build native iOS and Android apps with .NET
Xamarin makes it possible for .NET developers to build native mobile apps for iOS and Android with C# (and F#)! In this talk I will show how you can leverage your .NET skills and tools (like Visual Studio) to tap into the wonderful world of native mobile development. You will learn how Xamarin works, how to use it, and how it can be combined with common patterns and practices to share code across iOS, Android and Windows.
-
Xamarin.Forms from Scratch to Store
In this full-day workshop, you will learn all you need to produce professional native iOS and Android applications using Xamarin.Forms. No prior mobile programming is needed, though a working knowledge of C# is required;
After attending this course you will know and be comfortable with setting up Xamarin on the Mac or Windows, creating pages with XAMAL (the markup language used with Xamarin.Forms), and laying out your pages with controls such as buttons and text entry fields and how to style your controls to achieve a professional and consistent User Interface.
You will understand the Model-View-ViewModel pattern and why it matters, and you'll work with grids and lists and learn how to bind data to controls.
You will then go on to more advanced topics, including converters and behaviors. You'll see how to store data on the phone, both in configuration files and in a SQLite database, and how to test whether you have a network connection and how to sync your data with a server when you are online. You'll see how to interact with the phone's hardware, and how to work with images.
Finally, you'll work with Microsoft's app center to get analytics and crash reports, and to build and distribute your apps. -
Your dreams don't work unless you do
Have you ever wondered what makes you tick? What are the different factors that elevates you to peak performance level and makes you an awesome developer/tester? I was curious about this and went through a journey of self exploration in the past several years. This journey consisted of me identifying different patterns based on my real life experiences developing/testing software, interacting with various people, reading books and doing a lot of research on productivity, mindfulness and self motivation and finally not watching television for 6 months in 2017. Based on this exploration, I realized that no matter who you are, where you are from or what you do; there are 3 key factors that makes people reach their fullest potential and make them a strong tester.
Come join this talk, where I share my real life story of how I stumbled into testing, how I did not have proper guidance and had to figure my way out of different obstacles both in personal and corporate life, how I started from being a nobody to who I am today, where I speak at multiple conferences, write for various magazines, mentor budding engineers, share my ideas via my youtube channel and built a strong professional network which has helped me become an influential person who can make effective contributions to the software community. I will share different tips, tricks and tools I learned throughout my career which can help anyone become a strong influential developer/tester. -
ZAPping Security Vulnerabilities in Your Development Pipeline
When your application has a security vulnerability, will you or an attacker find it first? Reviewing code and tracking down hidden flaws can be tedious and difficult. Let the free and open source OWASP Zed Attack Proxy (ZAP) help. This session walks through four ways to use ZAP: UI, command line, scripts, and automated development pipeline. You will learn how to attack a live application in all four ways, how to target specific areas of your application for heavier scrutiny, test for specific vulnerabilities, and incorporate ZAP with your development pipeline to automate the whole process including regression testing and report generation, so that vulnerabilities are discovered the moment they are introduced.
Session ListMatt Hopkins2018-10-08T11:39:40+00:00
Call for Speakers powered by Sessionize.com