Schedule

• 8:15-9:15

  Registration & Breakfast

• 9:15-9:30

  Opening Remarks

• 9:30-10:15
  Keynote: Observability and the Glorious FutureCharity Majors, Honeycomb.io

  Distributed systems and microservices, automation and orchestration, containers and schedulers and multiple persistence layers oh my ... infrastructure today is a Cambrian explosion of complexity. How is a simple engineer to make sense of it all?? That's where the next generation of observability comes in: engineering your systems to be understandable, explorable and self-explanatory, with tooling that supports very high cardinality and dimensionality, unpredictable schemas, and makes social workflow a first class citizen. Let's talk about what modern tooling for complex systems looks like, and which of the old ways must die.

• 10:15-10:45
  State of State in ContainersRoss Kukulinski, kukulinski.com

  Application container technologies like Docker and Kubernetes have revolutionized the way in which developers can deploy and manage stateless applications. Containers are quick to launch and make efficient use of underlying compute resources. Orchestration engines like Kubernetes simplify the deployment, lifecycle, and scalability of applications.

• 10:45-11:05

  Morning Break

• 11:05-11:35
  Why we left MongoDBAntonio Chavez, Queue Technologies Inc

  Back in 2012 and 2013 MongoDB was the database of choice for many developers to start new projects, since it was the "coolest" database solution available. We’ll explore how a decision like that has an impact on startups, and why we decided to leave MongoDB for good and transition to a relational database.

• 11:35-11:45
  Joins Across Databases with GraphQLJonas Helfer, Meteor

  It is increasingly common for organizations to have a backend architecture powered by multiple databases / microservices. While this can help with scalability and fault tolerance, it introduces new challenges when we want to combine data from multiple services in a single view. in this quick talk, we’ll see how GraphQL can be leveraged to join data from multiple databases in a unified way.

• 11:45-12:15
  PostgreSQL: The Center of Your Data UniverseJoshua Drake, Command Prompt Inc

  Although there are still battles to be fought, the war has already been won. Find out how PostgreSQL answers all of your data layer needs. PostgreSQL is a one of the longest standing Open Source Database systems with legions of users leading the way to a sane, productive and performance driven data layer.

  This presentation will cover an overview of PostgreSQL technologies including:

  • NoSQL capabilities
  • Relational capabilities
  • Replication & High Availability
  • Features you can't believe you lived without
  • Community
• 12:15-12:25
  Surviving Failure with RabbitMQLorna Jane Mitchell, IBM

  On the internet, we should expect occasional failure. In this session, we’ll look at how to configure your RabbitMQ installation for different failure scenarios and what your options are in each case. Does it matter if a message goes missing? How about if the queue gets so full the server falls over? Come along and learn how to turn failures into measurable successes.

• 12:25-1:25

  Lunch Break

• 1:25-2:10
  Scaling Out SQL Databases with SpannerAmy Unruh, Google Cloud Platform

  This talk will give an overview of Cloud Spanner, Google's relational and scalable application database, which is now available as a managed service on Google Cloud. Spanner solves a long-standing problem for large-scale databases. Typically you could either pick a SQL system with nice consistency semantics, but complicated scaling; or you could use a horizontally scalable NoSQL system, but at the expense of transactional consistency that had to be handled in your application code. Cloud Spanner solves these problems. It scales horizontally like NoSQL systems, but it also provides the relational SQL semantics of traditional databases, and can be globally distributed while maintaining high performance.

  In this talk, we'll look at how Cloud Spanner evolved, how Google uses it internally, and how you can use it for your next project. In the process we'll talk about TrueTime, horizontal scale, and the CAP theorem. We'll show how to set up your first Spanner instance and database, look at best practices for scalable schema and query design, show some code, and give some demos.

• 2:10-2:20
  Building a Fintech Bot on Mongo and ElasticsearchEmile Baizel, Digit.co

  Digit's users engage with our service via the Digit bot, who answers questions as pertinent as `what's my checking balance` and `is my money safe` to more humorous ones as `tell me a joke`. After trying a couple of approaches, we landed on a solution that uses past user questions to help answer future questions.
  Our bot lives a dual life straddling Mongo and Elasticsearch, but on Elasticsearch is where the real fine tuning of matching questions to answers occurs. The raw content of questions and answers live in Mongo, and we use Node's event emitters to track updates and update Elasticsearch correspondingly.

• 2:20-2:50
  The State of Open Source Company ModelsChristina Keelan, Fly.io

  Recently, the company behind RethinkDB unexpectedly shut down. A couple of team members and community members got together and helped RethinkDB find a new home at The Linux Foundation. In this talk, Christina shares the experience of the company shutting down plus the current state of open source company models and suggestions for open source companies should they find themselves in a similar situation.

• 2:50-3:00
  Stream - Filter - Drain: A New ParadigmJohn Singleton, Watchful.io

  With the rise of consumer electronic devices and the IoT, there is a volumetric increase in not only the total amount of data, but the frequency at which it is produced. Traditional ETL data pipelines do not work at the pace of the real world, batch processing is slowing us down. Fast data refers to reacting to an individual piece of data in motion. We can now Stream our data at massive speeds and Filter on demand to be Drained into applications for real-time actionability. Watchful.io is a massive, real time stream processing tool that allows us to work with data at massive scale and speeds to simplify Fast Data architectures.

• 3:00-3:30

  Afternoon Break

• 3:30-4:00
  Speeding Up Slow Monoliths with Serverless Code and CachingJoshua B. Smith, IBM

  Not all RESTful backends are as fast as we want them to be. Since we can't own all of them, how can we speed them up? Creating data pipelines is a good way to change the data we get and caching is a good way to speed them up. However, who wants to run all that infrastructure just for a speed increase? Well, now you don't have. This talk will walk through using AWS Lambda or Apache Openwhisk to create stateless, serverless actions that are fast and cached with Redis. I'll cover some of the pitfalls of this approach as well as architectures that can help make it painless and inexpensive to maintain.

• 4:00-4:20
  All The DatabasesLoren Sands-Ramshaw

  Let’s do a live coding look at using GraphQL to provide an API backed by five different data sources. I'll start with what GraphQL is and the benefits to it over REST, and then I'll set up an app scenario, figure out what data we need and what our GraphQL query will look like, and then we'll fill in the backend code that makes database requests (GraphQL resolvers). Finally, we'll query the working database using GraphiQL, the GraphQL IDE.

• 4:20-4:50
  Data Streams with ElasticsearchSiddharth Kothari, Appbase

  Databases were traditionally designed to operate on CRUD apps. With the explosion of data in early 2000s, the whole NoSQL movement was born to allow web-scale CRUD operations. However with the emergence of the #realtimeweb, database designs find themselves broken yet again. IoT is fundamentally transforming the data processing needs from hours and minutes to mini and μ-second scales.

• 4:50-5:00

  Wrap Up

• 5:00-6:30

  After Party