00:04:27
Yeah, absolutely. I think It helps us at first to think about this notion of an operations plane, a control plane, and a build plane as despite it being a little bit more academic of a philosophy we find in most maturing technology spaces that we do need a architecture around this.
And, I think, as we think about the modern data stack, and all the amazing innovation that's happened over the last few years. We've seen this massive surge, and I would contend sprawl at the same time of all these amazing tools and technologies without a well designed framework and architecture around this that pushes a huge amount of burden on engineers to then go and integrate and it feels oftentimes like we're all just writing a ton of code, connecting all of these various systems together, which feels very brittle and ends up us being a lot more around connection engineers versus actual platform and data pipeline engineers.
And so when we think about a framework, we think about it in this notion of operations, control and build. And really the important part here is when we think about a control plane. The evolution of most mature technology spaces and those that have something that's continuously running generally moves from an imperative world to a declarative world.
And if we think about Airflow, It is an imperative scheduler and an amazingly powerful tool and technology. But when we think about imperative schedulers, they generally operate on timers and triggers. But they're generally not overly intelligent tools. And when I say intelligent tools, they're very powerful, but they run code on timers and triggers and they produce side effects and they're unaware of the side effects that they produce. They just generally know that you run one task after the other is based on the dependency chain and the reason why that becomes very scary is the side effects of your code then have ripple effects across your ecosystem. And the thing that's driving and powering that is unaware of those side effects.
So it can't help you do anything about that, right? When you're writing a pipeline and you read some data and you write it somewhere else. It doesn't know the nature of that data. It doesn't know, it oftentimes doesn't even know that it wrote that data. That burdens on you as an engineer to track that and register it and trace the lineage and validate it, do all the other things.
What we see in rapidly maturing spaces, like for example, container orchestration with Kubernetes, you go from a simplistic scheduler based model, which is classically an imperative construct into what really is a context aware domain specific control plane, which is really fancy way of being like a really smart, badass scheduler.
And the idea behind that is when you can make that shift, you can move into a declarative model where that new model allows the system to actually understand what is happening. When you run code, what are the side effects of that code? What is it producing? What is the dependency chain? And as a result, then as a developer, we can lean on that automation factor for the control plane to do all the things that could break on us.
And instead we can get a lot higher productivity. We can pull ourselves out of the weeds. And so when we think about this notion of a control plane what it really amounts to is it is like a scheduler, but it's a declarative model. It tracks incredible amounts of metadata and it ends up becoming this metadata backbone and bus, and that's how it connects up to this upper level, this operations plane because everything we do on operations liability, costing, observability, et cetera, all taps into that same metadata but the power is on a control plane, you can now actually just lean on it to drive more of the activity and track the side effects and the operations, the metadata tied to that which really helps connect those 2 other planes.