Expert Talk: gRPC, Kubernetes & .NET

Join Mark Rendle, MS Dev Tech MVP, and Matt Turner, DevOps leader, architect, and engineer at Marshall Wace, in a passionate discussion about gRPC’s past and future and how it fits in with technologies such as .NET and service meshes. They get deep in the weeds on technology cycles while debating the future of infrastructure as a code and Kubernetes. And Mark has a brilliant idea on how to build an alternative to Facebook.

May 17, 2022

Optimizing Performance of Stateful Applications for Globally Distributed Users

Your application has users around the world, so why are you sending their requests across an ocean to a centralized database? What if you could deploy a database that is as globally distributed as your audience so that users’ data stays close to them for low latency while still enjoying strong single-copy consistency? In his talk, Ben Darnell will walk through recommended tuning optimizations that minimize latencies for a distributed customer base while maintaining security and reliability for mission-critical workloads. Best practices explored will include how to optimally place data to minimize latency, maximize fault tolerance, and meet business requirements.

Maximizing Java Application Performance with GraalVM

GraalVM is a high-performance virtual machine offering new optimizations for individual languages and seamless interoperability for polyglot applications. For Java, GraalVM lets you optimize different performance aspects including a choice between JIT and AOT compilation modes, employing diagnostics tools and selecting the best language libraries for the job. In this session, we'll go through optimization strategies for the most common cases, discuss their benefits and trade-offs, and see what the latest project updates, such as Java 11 support, offer for speeding up your applications. We'll also take a look at how to make real-world applications GraalVM-ready and at the ecosystem of frameworks and libraries that you can use with GraalVM.

HotSpot GCs meet the Four Corners of Performance

Rarely have Java performance presentations quantified how throughput, latency, footprint and CPU usage vary amongst GCs. This session is an illustration, with charts and data, comparing throughput, latency, footprint and CPU usage of the HotSpot JVM's GCs executing the same workload. Attendees will walk away from this session better informed when it comes to identifying which HotSpot GC is a better fit for their application based on what performance attributes are most important.

Profiling React Performance

This session looks at profiling React from various angles: 1) Profiling locally on your computer, using the new profiler in the React DevTools extension 2) Gathering profiling data "in the wild" using the (beta) Profiler API 3) Testing individual components continuously and in isolation, so to prevent regressions

Observability for Data Pipelines: Monitoring, Alerting, and Tracing Lineage

Data-intensive applications, with many layers of transformations and movement from different data sources, can often be challenging to maintain even after they are initially built and validated. To truly expand and develop a code base, developers must be able to test confidently during the development process and monitor the production system. Monitoring and testing data pipelines or real-time streaming processes can be very different from monitoring web services. Jiaqi draws on her experience building and maintaining both batch and real-time stream data pipelines to discuss how to leverage monitoring tools like Prometheus and Grafana to define and visualize metrics, how and when to alert on common health indicators, and how to gain visibility in monitoring not just the system health but the health of the data. General concepts she touches on include observability of pipeline health, interpretability of data results and building features into data pipelines that makes monitoring and testing just a little bit easier, such as the ability to trace data lineage and designing for immutable data.

Ask Me Anything

Ray: A System for Distributed Applications

Ray ([ray.io](https://ray.io/)) is a framework for scaling Python applications from single machines to large clusters. It is used in several ML/AI systems and production deployments. Dean will explain common problems in scalable, distributed computing, particularly for high-performance ML/AI applications that motivated that creation of Ray. You’ll see how Ray solves them for Python-based systems (and possibly other languages in the future). In particular, Ray supports rapid distribution, scheduling, and execution of fine-grained “tasks”, a more natural decomposition of work for many problems compared to coarse-grained decomposition. Sequencing of dependent tasks cluster-wide is also transparent and intuitive. Ray also manages distributed state using the popular Actor model, which is essential for the next generation of “serverless” computing, where these services are stateful. Whether or not you are a Python or ML/AI developer, the general lessons discussed are broadly applicable.

Drinking a River of IoT Data with Akka.NET

**No prior Akka.NET knowledge is required for this talk.** Draw from Hannes's extensive experience in .NET to **learn how you can make scaling smart devices much easier using Akka.NET.** You cannot develop a device any more without it connecting to something. These ‘smart’ devices all have one thing in common: they generate a never-ending stream of data. If you want to process all that data for 100, 1000 or 10000 devices, you can probably get by with a very simple web stack. But as soon as you want to scale to 1000000 or more devices, you are going to need a better strategy. Scaling software is always tricky. We have all been through this. You load balance your web farm only to find out that your database is a bottleneck. Or to find out you need to synchronize caches across your farm, etc. State is always going to be what is getting in your way. Akka.NET and its implementation of the actor model makes scaling a bit easier. Developing stateful, concurrent code becomes a breeze. And on top of that, scaling and resiliency are also more straightforward to do. But there are pitfalls as well. There is no free lunch!

Introduction to Real-Time Analytics with Apache Pinot

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

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.