You are viewing details from a past event. Please check our upcoming event schedule if you are looking for current content.

Tim Berglund

VP Developer Relations at Confluent

Tim is a teacher, author, and technology leader with Confluent, where he serves as the Vice President of Developer Relations. He is a regular speaker at conferences and a presence on YouTube explaining complex technology topics in an accessible way. He tweets as @tlberglund, blogs every few years at http://timberglund.com. He has three grown children and two grandchildren, a fact about which he is rather excited.

Presentations

Mastering Tech Leadership in 60 Minutes

8:30 PM MDT

If only it were so easy! Leadership is a thing into which many find themselves thrown, and to which many others aspire—and it is a thing which every human system needs to thrive. Leading teams in technology organizations is not radically different from any other kind of organization, but does tend to present a common set of patterns and challenges. In this session, I’ll examine them, and provide a template for your own growth as a leader.

We’ll cover the following:
The relationship between leadership, management, and vision
Common decision-making pathologies and ways to avoid them
Strategies for communication with a diverse team
The basics of people management
How to conduct meetings
How to set and measure goals
How to tell whether this is a vocation to pursue

No, you will not master leadership in this short session, but we will cover some helpful material that will move you forward.

Event-Driven Architecture Done Right: Deep Dive

5:00 PM MDT

Event-driven architectures are not new, but they are newly ascendant. For the first time since the client-server revolution of 40 years ago, a new architectural paradigm is changing the way we build systems. Apache Kafka and microservices are at the center of this movement.

In this workshop, we’ll discuss the issues that arise turning a monolith into a set of reactive services, including issues like data contracts, integrating with the systems you can't change, handling request-response interfaces, and more. We'll also discuss common infrastructure choices like Apache Flink and Apache Pinot. Hands-on exercises will focus on understanding your organization's data and forming a plan to refactor that monolith that seems like it will never go away.

An Introduction to Apache Pinot

8:30 AM MDT

When things get a little bit cheaper, we buy a little bit more of them. When things get cheaper by several orders of magnitude, you don't just see changes in the margins, but fundamental transformations in entire ecosystems. Apache Pinot is a driver of this kind of transformation in the world of real-time analytics.

Pinot is a real-time, distributed, user-facing analytics database. The rich set of indexing strategies makes it a perfect fit for running highly concurrent queries on multi-dimensional data, often with millisecond latency. It has out-of-the box integration with Apache Kafka, S3, Presto, HDFS, and more. And it's so much faster on typical analytics workloads that it is not just a marginally better data warehouse, but the cornerstone of the next revolution in analytics: systems that expose data not just to internal decision makers, but to customers using the system itself. Pinot helps expand the definition of a “decision-maker” not just down the org chart, but out of the organization to everyone who uses the system.

In this talk, you'll learn how Pinot is put together and why it performs the way it does. You'll leave knowing its architecture, how to query it, and why it's a critical infrastructure component in the modern data stack. This is a technology you're likely to need soon, so come to this talk for a jumpstart.

Building a Real-Time Analytics Database: a Choose Your Own Adventure Journey

10:30 AM MDT

Have you ever stopped to think about how to build a database? The thing is, there isn't just one way, as we can see by the massive number of data infrastructure options we have to choose from. It's a nonstop series of tradeoffs, each motivated by the constraints the database wants to satisfy. An in-memory transactional database would be one thing. A general-purpose, single-server relational database would be another. A low-latency, horizontally scalable analytics database would be…the journey we're going to take.

In this talk, we'll start by picking a data model, make decisions about serialization and storage, choose indexing strategies, pick a query language, and figure out how to scale, eventually ending up with something that looks remarkably like Apache Pinot, a real-time analytics database. Pinot was built on a journey like this, always optimized for ultra low-latency, user-facing analytics at scale. In the real world, Pinot is used by applications like LinkedIn and UberEats to expose the state of the system not just to internal decision-makers, but to the users of the system itself, including all of us people who consumers of analytical queries. By focusing on the internals of Pinot and the tradeoffs made along the way to build a database of its kind, we'll see how it enables a new class of applications that every user of a system into a decision maker.

Books

Building and Testing with Gradle

by Tim Berglund and Matthew McCullough

Build and test software written in Java and many other languages with Gradle, the open source project automation tool that’s getting a lot of attention. This concise introduction provides numerous code examples to help you explore Gradle, both as a build tool and as a complete solution for automating the compilation, test, and release process of simple and enterprise-level applications.

Discover how Gradle improves on the best ideas of Ant, Maven, and other build tools, with standards for developers who want them and lots of flexibility for those who prefer less structure.

  • Use Gradle with Groovy, Clojure, Scala, and languages beyond the JVM, such as Flex and C
  • Get started building a simple Java program using Gradle's command line tooling and a small build script
  • Learn how to configure and construct tasks, Gradle's fundamental unit of build activity
  • Take advantage of Gradle's integration with Ant
  • Use Gradle to integrate with or transition from Maven, and to build software more cleanly
  • Perform application unit and integration tests using JUnit, TestNG, Spock, and Geb