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 … Read More
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 … Read More
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 … Read More
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 … Read More
This talk will cover what makes a code metric valuable, when unmaintainable code may be preferable, and the number one thing that prevents most developers from maintaining quality code over time.
This session will show you a toolchain and immutable infrastructure principles that will allow you to define your infrastructure in code versioned alongside your application code that will give you repeatable configuration, ephemeral testing environments, consistent CI/CD environments, and diffable dependency transparency all before pushing changes to production.
Open Source communities have been pushing the state of art in containers, schedulers, and distributed systems in the last two years. The excitement in the community at the possibilities these technologies unlock is continuing to build. But, what are we solving for? How does this make your infrastructure better?
Recently, the Appium project, a large open-source application, decided to rewrite its codebase using ES2015, the newest version of JS. In this talk, I’ll tell the story of what worked and what didn’t. What were the goals of our rewrite and how did our choices deliver on those goals? Specifically, how did ES2015 and the “many modules” approach work for us?
This talk will begin by briefly examining what it means for infrastructure to be represented as code. We’ll examine some fundamental software components required for automating infrastructure using code such as GPG, package managers, SSL, and more. We’ll examine some interesting failure cases for these tools and how these shortcomings might make it impossible to truly represent infrastructure as code, for now.
When asked “What’s your architecture?” most people immediately respond with how their software is laid out and what their plans are for improving parts of it. Rarely does anybody really think through their team and organizational architecture, and even more rarely do people understand how that may fundamentally impact how the software gets written and the product that comes out at the end.
