Engineering the Future of Software
November 13–14, 2016: Training
November 14–16, 2016: Tutorials & Conference
San Francisco, CA

Speaker slides

Presentation slides will be made available after the session has concluded and the speaker has given us the files. Check back if you don't see the file you're looking for—it might be available later! (However, please note some speakers choose not to share their presentations.)

Big data architectures and enterprise/microservice architectures are slowly converging. Big data is transitioning to "fast data," emphasizing streaming over batch processing, while data processing is growing ubiquitous. Dean Wampler explores the SMACK stack—Spark, Mesos, Akka, Cassandra, and Kafka—and explains how it addresses the needs of both fast data and the enterprise.
Netflix is well known for championing the microservice model, but within the complex layers of dependencies is a hidden service: the caching layer. Scott Mansfield explains how the EVCache service fits into the Netflix experience and how it works in the dynamic cloud environment to provide fast and scalable application data caching.
JavaScript is replacing Java, Ruby, and .NET as the technology of choice for companies that want to build enterprise software faster and with fewer resources. Kurtis Kemple offers an overview of enterprise JavaScript applications at every level of the stack and discusses how to secure, integrate, test, store, monitor, and deploy them.
A redesign of the entire data platform behind Visa's business is underway. The Apache Hadoop ecosystem is becoming a staple of many of its solutions, requiring architects to evolve existing live applications as well as the processes and culture of engineering at Visa. Partha Saha explores Apache HBase adoption at Visa and discusses how architects are leading the way.
Serverless architectures, such as AWS Lambda, Google Cloud Functions, and Azure's Serverless Compute service, relieve you of hardware and scaling set-up concerns. Derek Ashmore explores AWS Lambda, comparing and contrasting it with Google's and Azure's offerings.
Although it's a classical approach, multitenancy at the application level comes with limitations in terms of processing isolation, efficient hardware utilization, and advanced per-tenant configuration. Mariana Cedica demonstrates Nuxeo's new container-based approach—powered by dynamic Docker containers, CoreOS, Fleet, and Gogeta—that avoids common issues with traditional multitenancy.
Dan Heidinga explains how a simple slogan revolutionized how IBM's J9 Java VM team creates the software that powers your Java applications and shares lessons learned from rearchitecting IBM's build pipeline around simplicity, in the process, becoming a key enabler for driving innovation throughout the product stack.
Data is available from an incredible number of sources in an endless number of formats. Data science deals with the extraction of valuable insights from this jumble in the form of attractive visualizations. Walking you through several examples using practical tools and tricks, Margriet Groenendijk presents a typical workflow that offers a basic introduction to data science.
Faraz Mohammed discusses lessons learned working with @WalmartLabs's internal open source software project OneOps.
DevOps and test-driven infrastructure radically shifted the way we develop and deploy applications and infrastructure. Compliance-driven infrastructure builds on the same foundation, incorporating compliance and security into the mix. Christoph Hartmann and Dominik Richter explore InSpec and explain how it enables you to easily incorporate compliance and security in your development workflow.
Baogang Song shares Pinterest's unique journey adopting Docker technology. Baogang highlights how Pinterest used Teletraan, its code deploy system, to safely deploy dockers in production with little effort and limited Docker operational experience.
The process of analysis and reasoning about a running system or designing for deployment concerns is very different from the process of synthesis and composition involved in writing application software. Badrinath Janakiraman explores patterns and lessons learned while deploying and maintaining distributed platform Snap CI.
Every retailer is grappling with the challenge of creating a seamless omnichannel presence. While most understand that omnichannel is a necessity, it’s extremely difficult to build the proper architecture to gather, exchange, and draw insights from raw data. Kyu Cho and Sajid Mohamedy share the five elements that retailers must put in place to ensure a seamless ecommerce presence.
Threat modeling is one of the best techniques for achieving secure architectures. However, introducing it on existing complex projects requires time that architects and developers may not have. Irene Michlin introduces a technique for performing threat modeling in ongoing projects without a prohibitive initial time investment.
What if we considered Mike Cohn's Testing Pyramid a strong statement about application architecture, not a test ratio edict? Could we explicitly design with testability in mind? Should we? What are the real benefits of popular approaches from the past decade, such as TDD, IoC, AOP, and MVx? Gary Pedretti explains how to bring all of these approaches together in a stable, rock-solid whole.
Yurii Rashkovskii shares a set of practical of approaches to designing event-sourcing-based systems, including a method of building the state of the world that uses a "lazy first" approach. This approach suggests that we don't know what the state of the world should include up front and therefore should defer this decision until the very end.
Microservice architecture brings freedom for developers, but building a sustainable microservice ecosystem requires holding microservices to high architectural and operational standards. Susan Fowler introduces a set of standards that apply to all microservices—standards that ensure microservice availability while preserving developer freedom.
Anthony Moralez offers a retrospective of a microservices application that his team built over the past year. You'll explore all of the key decision points and learn why the team chose the routes they did and why they might not choose them again if given a second chance.
Randy Layman looks at several members of the supporting cast that help to bring microservices to production readiness. Along the way, Randy talks about several patterns, including a pattern to clean data from inputs to help with PII and compliance concerns, patterns for request routing, and patterns around security.
Whether an organization is an established leader, or breaking new ground, the mantra is always that we need to move faster. And of course, we need to scale. Architectural and development practices abound that should get us there: agile engineering, microservices, DevOps and so on. But it is not just the our software that needs to scale, but also our approach to delivering it.
The container orchestration wars are upon us. A dozen container orchestrators vie to be the kernel of the modern data center. But can the warring parties come together on a standard interface for modern cluster operations? Karl Isenberg explores what these parties have in common and outlines what a common interface might look like for operating these distributed operating systems.
Research shows that 46% of deployed containers run for one hour and 27% run for about five minutes. In such a fast-paced, disposable computing environment, cloud operators struggle to keep their workloads and container environments under control. Giuseppe de Candia explains how to take the chaos out of these short-lived computing engines and the security implications to consider along the way.
Will Reactive programming be the default choice for modern apps? When would you want to use event emitters as opposed to event streams with operators? Luca Mezzalira answers these questions and more as he provides a detailed tour of frontend architectures, including where they've been and where we're headed.