Check Back Soon for Updates!
“Your airplane” – lessons learned from 50 years of aviation disasters
In this talk, we examine the failures of modern airline operations - from United Airlines flight 173 in 1978, to Air France flight 447 in 2009 and First Air flight 6560 in 2011 - and how the NTSB investigation and aftermath has dramatically improved flight safety. We take those lessons learned in disaster recovery and analysis, teamwork, task saturation, and systems design and apply them to modern software application and infrastructure architecture at scale to achieve higher availability, reduced errors, and more scalable systems.
Applied Distributed Research in Apache Cassandra
The popular nosql database Cassandra eschews a master/slave partitioning design in favor of a fully peer-to-peer model which makes it robust and scalable but adds significant complexity to some areas of its design. I will explain the challenges and successes Cassandra has had in creating lightweight transactions, materialized views, and strongly consistent cluster membership within this peer-to-peer paradigm.
Avoiding React Performance Pitfalls
When @WalmartLabs built Electrode, the React/Node.js application platform that powers the Walmart.com customer experience, performance was one of our primary concerns. React’s use of a virtual DOM and support for server-side rendering have earned it a reputation for speed, but in building our platform we encountered several unexpected performance bottlenecks. In this talk, we’ll discuss the problems we found and how we solved them.
Building a music synth with Angular2 and Observables
Angular 2 is a reactive application development platform that uses smart change detection and observables to communicate with streams of data. The RxJs library is embedded and used for activities like watching control inputs, dealing with WebSockets, and handling network responses. So what if we try to use Angular 2 to develop a synthesizer? The browser has a WebAudio API, even WebMidi and bluetooth, and if Angular is so good at reacting to events, why not stretch a bit and see what the platform can do? Ken will demonstrate how to tie together an on-screen touch keyboard, an Arduino with…
Read more »
Building Better Teams to Build Better UX
Today's business and technology leaders understand that a good user experience (UX) is a leading factor in product success and customer happiness. Popular dogma says that cross-functional, autonomous agile teams are the way to achieve great UX -- but this isn't always true. This panel of designers, developers, and tech leaders will discuss the sources of bad UI, what the biggest helpers and inhibitors are to successful cross-functional collaboration, and what leaders should (and should not) do to help.
Building data breach and subpoena resistant applications
Now is the time for a new approach to protect the covenant between an application’s owners and its users. Present threats are too numerous and varied and the battlefield too complex to defend with existing methods. In particular, technical defenses have limited effectiveness against non-technical attacks. The techniques presented here protect against attacks on all fronts, including from within where a privileged operator is compromised. Together, we’ll examine an application based on cryptography and messaging that sets a new expectation for data security.
Building for Operability: Stateful Applications in Containers with the Autopilot Pattern
Despite the hype, deploying and running these containers in the real world is still a challenge. Today's container frameworks force developers to compensate for many surprisingly restrictive operational constraints. Teams adopt containers only for stateless services, leaving behind many of their advantages in improving operability for the entire stack. The Autopilot Pattern is a powerful design concept to address these problems. By moving the responsibility for handling events such as startup, shutdown, scaling, and recovery from the framework into the application, we can build intelligent architectures that maximize developer flexibility and minimize the need for human operational intervention. Better still,…
Read more »
Clojure spec: Expressing Data Constraints without Types
Clojure programs are built from a small number of generic immutable data structures combined with a large number of pure functions that manipulate these generic data types. The Clojure development experience is characterized by a rapid, dynamic, and interactive REPL-driven experience. Clojure's new spec library enhances Clojure by providing a system for stating concrete declarative specifications for your data and functions. Because the specifications are based in the same language as the program, they are expressive and concrete. Specs are fully integrated with Clojure and can be used within your programs for validation, documentation, destructuring, instrumentation, data generation, and automatic…
Read more »
Ember and The State of Web Frameworks.
Stay tuned for session details.
Free as in Monads
What is the `Free`? Where did it come from? Why is it here? Why would anyone *really* care? In this talk, we will embark on an epic journey through a live editor buffer as we derive the `Free` monad from scratch for fun and profit in just a few dozen lines of code. And once we have it, we will see how easy to use and powerful it can be when applied to the right problems. When I was exposed to these ideas and abstractions, it forever changed the way I write software. If you aren't careful, it could do…
Read more »
Functions and Determinism in Property-based Testing
Property-based testing is as close to a panacea as we are likely to get in the software industry. Whether you're someone who loves writing tests or someone who finds testing tedious, identifying and testing the properties and invariants of your code can produce more useful (and more interesting) tests. This talk will briefly cover what property-based testing is and how to do it, followed by an in-depth look into how property-based testing actually works. You will leave this talk armed with an understanding of how the "magic" happens, and with the knowledge necessary to start hacking on a property-based testing…
Read more »
Getting Swifty: A Tale From the Front Lines of Breaking Changes and Legacy Code
Learning a new language is what we do as engineers. It’s fun, it’s reinvigorating, and it’s challenging. But it’s not often that you learn a brand new language and then implement it side by side in a code base with another language. Especially when the other language is sad because it knows you’e replacing it and it doesn’t want to play nice with the new guy. At URBN, we made a decision to write Swift for all new code even though Swift wasn’t (still isn’t) stable & several of our apps were 100% Objective-C. There were challenges, like learning a…
Read more »
GitHub’s GraphQL Future
Last year, GitHub embarked on a big change: they built a new API using GraphQL for both internal engineers and external integrators to use. In this talk, Kyle will share how GitHub chose GraphQL, how GraphQL differs from REST and other tech, how GitHub went about implementing it, and how they're using it production less than a year later. You'll leave with a working knowledge of GraphQL and the pros and cons of using it within your organization.
Infrastructure, Identity, and IoT
Collecting data to understand end users and intra-application communication is critical to a business. Not only does it help model growth, engagement, and scalability, but it is part of the foundation of application security. This talk focuses on the nuances of understanding what is interacting with your infrastructure. It will cover methods used to assess identity, methods used to obstruct fingerprinting and how fingerprinting and identity have been complicated by the availability of cloud resources and IoT devices.
Integration over Invention
One of the guiding principles of the Convox project is that you should always consume a service rather than running custom software. This talk will focus on how we use this approach to build Convox, the motivations behind it, and why you should delegate the bulk of your technology burden to focus on the things that matter.
Java Futures: Modules and More
What can Java 9 do for you? What can you do to prepare for it? How can you take advantage of the new features? Come hear highlights of some cool features coming in Java 9. We will do a deep dive into the new Java Platform Module System (project Jigsaw). We will also take a sneak peak from a JVM engineer’s perspective at some of the future Java projects currently incubating.
Java Performance Engineer’s Survival Guide
Managed runtime performance expert, Monica Beckwith will divulge her survival guide which is essential for any application performance engineer to get to the bottom of a performance issue. The presentation will provide a step-by-step approach to finding the root cause of any performance problem. Monica will walk the attendees through an example that will showcase a few performance tools and the performance process. Following the simple rules highlighted in the presentation and applying performance engineering patterns will make you and your stakeholders happy.
Java Puzzlers Next Generation: Down the Rabbit Hole
Baruch Sadogursky Developer Advocate at JFrog The more we work with Java 8, the more we go into the rabbit hole. Did they add all those streams, lambdas, monads, Optionals and CompletableFutures only to confuse us? It surely looks so! And Java 9 that heads our way brings even more of what we like the most, more puzzlers, of course! In this season we as usual have a great batch of the best Java WTF, great jokes to present them and great prizes for the winners!
Lean Analytics in the Real World
In this talk, Moore will share real-world case studies of how Lean Analytics helped RJMetrics, its partners, and its clients make smarter decisions at every stage of growth.
Loving Lean Layouts
Layouts are the foundation of Android UI, and while they are seemingly straightforward, understanding how to develop efficient layouts is sometimes less so. However, efficient, “lean” layouts can be vital to both user experience and app performance. This session examines the importance of lean layouts, tools for analyzing layouts and their performance, tips and techniques for making layouts leaner, common mistakes and misconceptions, and general good practices.
Makers and Menders: Putting the Right Developers on the Right Projects
When you think of a developer what comes to mind? A brogrammer living in San Francisco working 23 hours a day on the next Facebook? If so, you wouldn’t be alone. Like so many industries, software development is rife with stereotypes. And one that is particularly pervasive is the idea that all developers, if given the chance, would opt for a complete rewrite of an application. While it’s true that there are many software developers who do enjoy starting with a clean slate, there is also a group who loves working on making existing applications better. Rather than starting from…
Read more »
Managing The Reactive World with RxJava
The world around our programs are inherently asynchronous. RxJava builds on the primitives offered by the Java platform in order to model these asynchronous sources in an easy-to-consume way. This talk will be an exploration about how to think about these asynchronous sources, the tools that RxJava provides to handle them, and a look to the future of Java and how it will affect the library.
Moving Past the Scaling Myth
One of the biggest challenges in systems development is scaling. We want to scale vertically, horizontally, and organizationally. Sometimes we even want to scale our processes. Why is it so hard? In many cases, it is because we want to find structures that work well at all scales. When we can’t we call it failure and seek a different structure. In this talk, Michael Feathers will examine the notion of scale variant structuring and what systems design could look like if we dropped the assumption that that structural reorganization at different scales should not be necessary.
Operators Dilemma – Balancing Between Blind and Broke
The modern operator faces a tension between varying levels of blind and varying levels of broke. Operational Telemetry solutions at scale are some of the largest, most expensive yet mission critical systems that exist. This talk focuses on the strategy and use of multiple providers to provide a suite of cost-effective telemetry solutions that work together.
Perfections and the Business Cycle
Poet and critic Paul Valéry got to the heart of the relationship between art and business when he wrote, in 1922, “[For lovers of perfection], a work is never finished...but abandoned,” the act of abandonment being “the result of weariness or an obligation to deliver.” We software developers are, in the main, lovers of perfection--and we are subject to both weariness and pressure to deliver, forces that militate against at least some of our aspirations to perfection in our work. In one sense, software must be perfect--it must run flawlessly--or it is nothing. But practitioners of the art of programming…
Read more »
Scaling with Apache Spark (or a lesson in unintended consequences)
Apache Spark is one the most popular general purpose distributed systems in the past few years. Apache Spark has APIs in Scala, Java, Python and more recently a few different attempts to provide support for R, C#, and Julia. This talk looks at Apache Spark from a performance/scaling point of view and the work we need to do to be able to handle large datasets. In essence parts of this talk could be considered "the impact of design decisions from years ago and how to work around them." It's not all doom and gloom though, we will explore the new…
Read more »
Scio – Moving Big Data to Google Cloud, a Spotify Story
Stay tuned for session details.
Somm Architect – Building systems to age like wine”
Stay tuned for details
Starry Night with TensorFlow
Deep Learning has led to impressive results in image classification, but can also be used to explore new possibilities in art. In this talk, I'll introduce Deep Learning using examples in TensorFlow, and demo open source code you can use to train your own image classifier, and create your own artwork. At the end, I'll share my favorite educational resources you can use to learn more about machine learning, and of course all about TensorFlow.
The Dream of the 90s is alive in Haskell
Haskell, a language older than Java and Python, has only recently seen an uptick in commercial use. Why did it take so long? In this talk, we'll see how design decisions made almost thirty years ago are paying off, as well as tooling improvements that have made Haskell more suitable for commercial use. Seen through the lens of using Haskell at Helium, we'll also explore production software concerns like builds, deploys, monitoring, logging, and testing.