Do you have data that you pull from external sources or that is generated and appears at
your digital doorstep?
I bet that data needs processed, filtered, transformed, distributed, and much more.
One of the biggest tools to create these data pipelines with Python is Dagster.
And we're fortunate to have Pedram Navid on the show to tell us about it.
Pedram is the head of data engineering and DevRel at Dagster Labs.
And we're talking data pipelines this week here at Talk Python.
This is Talk Python to me, episode 454, recorded January 11th, 2024.
Welcome to Talk Python to me, a weekly podcast on Python.
This is your host, Michael Kennedy.
Follow me on Mastodon, where I'm @mkennedy and follow the podcast using at
Talk Python, both on fosstodon.org.
Keep up with the show and listen to over seven years of past episodes at talkpython.fm.
We've started streaming most of our episodes live on YouTube.
Subscribe to our YouTube channel over at talkpython.fm/youtube to get notified
about upcoming shows and be part of that episode.
This episode is sponsored by Posit Connect from the makers of Shiny.
Publish, share, and deploy all of your data projects that you're creating using Python.
Streamlit, Dash, Shiny, Bokeh, FastAPI, Flask, Quattro, Reports, Dashboards, and APIs.
Posit Connect supports all of them.
Try Posit Connect for free by going to talkpython.fm/posit.
Posit Connect.
And it's also brought to you by us over at Talk Python Training.
Did you know that we have over 250 hours of Python courses?
Yeah, that's right.
Check them out at talkpython.fm/courses.
Last week, I told you about our new course, Build an AI Audio App with Python.
Well, I have another brand new and amazing course to tell you about.
This time, it's all about Python's typing system and how to take the most advantage of it.
It's a really awesome course called Rock Solid Python with Python Typing.
This is one of my favorite courses that I've created in the last couple of years.
Python type hints are really starting to transform Python,
especially from the ecosystem's perspective.
Think FastAPI, Pydantic, BearType, etc.
This course shows you the ins and outs of Python typing syntax, of course,
but it also gives you guidance on when and how to use type hints.
Check out this four and a half hour in-depth course at talkpython.fm/courses.
Now, on to those data pipelines.
Pedram, welcome to Talk Python to me.
It's amazing to have you here.
Michael, great to have you.
Good to be here.
Yeah.
Good to talk about data, data pipelines, automation.
And boy, oh boy, let me tell you, have I been in the DevOps side of things this week.
And I'm going to have a special, special appreciation of it.
I can tell already.
So excited to talk.
My good old, sis.
Indeed.
So before we get to that, though, before we talk about Dagster and data pipelines and orchestration more broadly,
let's just give a little bit of background on you.
Introduce yourself for people.
How did you get into Python and data orchestration and all those things?
Of course.
Yeah.
So my name is Pedram Navid.
I'm the head of data engineering and DevRel at Dagster.
That's a mouthful.
And I've been a longtime Python user since 2.7.
And I got started with Python like I do with many things just out of sheer laziness.
I was working at a bank and there was this rote task, something involving going into servers,
opening up a text file and seeing if a patch was applied to a server.
A nightmare scenario when there's 100 servers to check and 15 different patches to confirm.
Yeah.
So this kind of predates like the cloud and all that automation and stuff, right?
So this is definitely before cloud.
This was like right between Python 2 and Python 3.
And we were trying to figure out how to use print statements correctly.
That's when I learned Python.
I was like, there's got to be a better way.
And honestly, I've not looked back.
I think if you look at my entire career trajectory, you'll see it's just
punctuated by finding ways to be more lazy in many ways.
Yeah.
Who was it?
I think it was Matthew Rocklin that had the phrase something like productive laziness or
something like that.
I'm going to find a way to leverage my laziness to force me to build automation.
So I never, ever have to do this sort of thing again.
I got that sort of principle.
It's very motivating to not have to do something and I'll do anything to not do something.
Yeah.
It's incredible.
And like that DevOps stuff I was talking about and just, you know, one command and there's
maybe eight or nine new apps with all their tiers redeployed, updated, resynced.
And it's, it took me a lot of work to get there, but now I never have to think about it again,
at least not for a few years.
And it's amazing.
I can just be productive.
It's like right in line, in line with that.
So what are some of the Python projects you've been, you've worked on, talked about different
ways to apply this over the years?
Oh yeah.
So it started with internal, just like Python projects, trying to automate, like I said, some
rote tasks that I had and that accidentally becomes, you know, a bigger project.
People see it and they're like, oh, I want that too.
And so, well, now I have to build like a GUI interface because most people don't speak
Python.
And so that got me into iGUI, I think it was called way back when.
That was a fun journey.
And then from there, it's really taken off.
A lot of it has been mostly personal projects.
Trying to understand open source was a really big learning path for me as well.
Really being absorbed by things like SQLAlchemy and requests back when they were coming out.
Eventually it led to more of a data engineering type of role where I got involved with
tools like Airflow and trying to automate data pipelines instead of patches on a server.
That one day led to, I guess, making a long story short, a role at Dexter, where now I
contribute a little bit to Dexter.
I work on Dexter, the core project itself, but I also use Dexter internally to build our
own data pipelines.
I'm sure it's interesting to see how you all both build Dexter and then consume Dexter.
Yeah, it's been wonderful.
I think there's a lot of great things about it.
One is getting access to Dexter before it's fully released, right?
So internally, we dog food, new features, new concepts, and we work with the product team,
the engineering team to say, hey, this makes sense.
This doesn't.
This works really well.
That doesn't.
And that feedback loop is so fast and so iterative that for me personally, being able to see that
come to fruition is really, really compelling.
But at the same time, it's like I get to work at a place that's building a tool for me, right?
You don't often get that luxury.
I've worked in ads.
I've worked in insurance.
It's like banking.
It's like, these are nice things, but it's not built for me, right?
And so for me, that's probably been the biggest benefit, I would say.
Right.
If you work in some marketing thing, you're like, you know, I retargeted myself so well
today.
You wouldn't believe it.
I really enjoyed it.
I've seen the ads that I've created before.
So it's a little fun, but it's not the same.
Yeah.
I've heard of people who are really, really good at ad targeting and finding groups where
they've like pranked their wife or something or just had an ad that would only show up for
their wife by running.
It was like so specific and, you know, freaked them out a little bit.
That's pretty clever.
Yeah.
Maybe it wasn't appreciated, but it is clever.
Who knows?
All right.
Well, before we jump in, you said that, of course, you built GUIs with PyGUI and those
sorts of things because people don't speak Python back then, two, seven days and whatever.
Is that different now?
Not that people speak Python, but is it different in the sense that like, hey, I could give them
a Jupyter notebook or I could give them Streamlit or one of these things, right?
Like a little more or less you build and just like plug it in?
I think so.
I mean, yeah, like you said, it's not different in that, you know, most people probably still
to this day don't speak Python.
Yeah.
I know we had this like movement a little bit back where everyone was going to learn
like SQL and everyone was going to learn to code.
I was never that bullish on that trend because like if I'm a marketing person, I've got 10,000
things to do and learning to code isn't going to be a priority ever.
So I think building interfaces for people that are easy to use and speaks well to them is always
useful.
That never has gone away.
But I think the tooling around it has been better, right?
I don't think I'll ever want to use PyGUI again.
Nothing wrong with the platform.
It's just like not fun to write.
Streamlit makes it so easy to do that.
So it's like something like Retool and there's like a thousand other ways now that you can
bring these tools in front of your stakeholders and your users that just wasn't possible before.
I think it's a pretty exciting time.
There are a lot of pretty polished tools.
Yeah.
It's gotten so good.
Yeah.
There are some interesting ones like OpenBB.
Do you know that?
The financial dashboard thing.
I've heard of this.
I haven't seen it.
Yeah.
It's basically for traders, but it's like a terminal type thing that has a bunch of map
plot lib and other interactive stuff that pops up compared to, say, Bloomberg dashboard
type things.
But yeah, that's one sense where like maybe like traders go and learn Python because it's
like, all right, there's enough value here.
But in general, I don't think, yeah, I don't think people are going to stop what they're
doing and learning the code.
So these new UI things are not.
All right.
Let's dive in and talk about this general category first of data pipelines, data orchestration,
all those things.
And we'll talk about Dagster and some of the trends and that.
So let's grab some random internet search for what does a data pipeline maybe look like?
But, you know, people out there listening who don't necessarily live in that space, which
I think is honestly many of us, maybe we should, but maybe in our minds, we don't think we live
in data pipeline land.
Tell them about it.
Yeah, for sure.
It is hard to think about if you haven't done or built one before.
In many ways, a data pipeline is just a series of steps that you apply to some data set that
you have in order to transform it to something a little bit more valuable at the very end.
That's a simplified version.
The devil's in the details.
But really, like at the end of the day, you're in a business.
The production of data sort of happens by the very nature of operating that business.
It tends to be the core thing that, you know, all businesses have in common.
And then the other sort of output is you have people within that business who are trying
to understand how the business is operating.
And this used to be easy when all we had was a single spreadsheet that we could look at once
a month.
Yeah.
I think businesses have gone a little bit more complex than these days.
Computers.
And the expectations.
Like they expect to be able to see almost real time, not I'll see it at the end of the month.
Sort of.
That's right.
Yeah.
I think people have gotten used to getting data too, which is both good and bad.
Good in the sense that now people are making better decisions.
Bad.
And then there's more work for us to do.
And we can't just sit on our feet for half a day, half a month and waiting for the next
request to come in.
There's just an endless stream that seems to never end.
So that's what really Pipeline is all about.
It's like taking these data and making it consumable in a way that users, tools will understand.
That helps people make decisions at the very end of the day.
That's sort of the nuts and bolts of it.
In your mind, does data acquisition live in this land?
So for example, maybe we have a scheduled job that goes and does web scraping, calls an
API once an hour, and that might kick off a whole pipeline of processing.
Or we watch a folder for people to upload over FTP, like a CSV file or something horrible
like that.
You don't even know what it's unspeakable.
But something like that where you say, oh, a new CSV has arrived for me to get, right?
Yeah.
I think that's the beginning of all data pipeline journeys in my mind.
Very much, right?
Like an FTP, as much as we hate it, it's not terrible.
I mean, there are worse ways to transfer files, but I think it's still very much in use today.
And every data pipeline journey at some point has to begin with that consumption of data from
somewhere.
Yeah.
Hopefully it's SFTP, not just straight FTP, like the encrypted.
Don't just send your password in the plain text.
Oh, well.
I've seen that go wrong.
That's a story for another day, honestly.
All right.
Well, let's talk about the project that you work on.
We've been talking about it in general, but let's talk about Dagster.
Like, where does it fit in this world?
Yes.
Dagster, to me, is a way to build a data platform.
It's also a different way of thinking about how you build data pipelines.
Maybe it's good to compare it with kind of what the world was like, I think, before Dagster
and how it came about to be.
So if you think of Airflow, I think it's probably the most canonical orchestrator out there.
But there are other ways which people used to orchestrate these data pipelines.
They were often task-based, right?
Like, I would download file.
I would unzip file.
I would upload file.
These are sort of the words we use to describe the various steps within a pipeline.
Some of those little steps might be Python functions that you write.
Maybe there's some pre-built other ones.
Yeah.
There might be Python.
Could be a bash script.
Could be logging into a server and downloading a file.
Could be hitting requests to download something from the internet and zipping it.
Just a various, you know, hodgepodge of commands that would run.
That's typically how we thought about it.
For more complex scenarios where your data is bigger,
maybe it's running against a Hadoop cluster or a Spark cluster.
The compute's been offloaded somewhere else.
But the sort of conceptual way you tended to think about these things is in terms of tasks, right?
Process this thing, do this massive data dump, run a bunch of things,
and then your job is complete.
With Airflow, or sorry, with Dagster, we kind of flip it around a little bit on our heads.
And we say, instead of thinking about tasks,
what if we flipped that around and thought about the actual underlying assets that you're creating?
What if you told us not, you know, the steps that you're going to take,
but the thing that you produce?
Because it turns out as people and as data people and stakeholders,
really, we don't care about the task.
Like, we just assume that you're going to do it.
What we care about is, you know, that table, that model, that file, that Jupyter notebook.
And if we model our pipeline through that,
then we get a whole bunch of other benefits.
And that's sort of the Dagster sort of pitch, right?
Like, if you want to understand the things that are being produced by these tasks,
tell us about the underlying assets.
And then when a stakeholder says and comes to you and says, you know,
how old is this table?
Has it been refreshed lately?
Well, you don't have to go look at a specific task.
And remember that task ABC had model XYZ.
You just go and look up model XYZ directly there, and it's there for you.
And because you've defined things in this way,
you get other nice things like a lineage graph.
You get to understand how fresh your data is.
You can do event-based orchestration and all kinds of nice things
that are a lot harder to do in a task world.
Yeah, more declarative, less imperative, I suppose.
Yeah, it's been the trend, I think, in lots of tooling.
React, I think, was famous for this as well, right?
In many ways.
Yeah.
It was a hard framework, I think, for people to sort of
get their heads around initially,
because we were so used to like the jQuery declarative,
or jQuery style of doing things.
Yeah, how do I hook the event that makes the thing happen?
Right?
And React said, let's think about it a little bit differently.
Let's do this event-based orchestration, really.
And I think the proof's in the pudding, React's everywhere now,
and jQuery could be not so much.
Yeah.
There's still a lot of jQuery out there,
but there's not a lot of active jQuery.
But I imagine there's some.
There is, there is, yes.
Yeah, just because people are like,
you know what, don't touch that, that works.
Which is probably the smartest thing people can do, I think.
Yeah, honestly.
Even though new frameworks are shiny.
And, you know, if there's any ecosystem
that loves to chase the shiny new idea,
it's the JavaScript web world.
Oh, yeah.
There's no shortage of new frameworks coming out every time.
Yeah, I mean, we do too,
but not as much as like,
that's six months old.
That's so old, we can't possibly do that anymore.
We're rewriting it.
We're going to do the big rewrite again.
Mm-hmm.
Yep.
Fun.
Okay, so Dagster is the company,
but also is open source.
What's the story around, like,
can I use it for free?
Is it open source?
Do I pay for it?
100%.
Okay.
So Dagster Labs is the company.
Dagster open source is the product.
The 100% free,
we're very committed to the open source model.
I would say 95% of the things you can get out of Dagster
are available through open source.
And we tend to try to release everything through that model.
You can run very complex pipelines
and you can deploy it all on your own if you wish.
There is a Dagster Cloud product,
which is really the hosted version of Dagster.
If you want hosted plain,
we can do that for you through Dagster Cloud,
but it all runs on the same code base
and the modeling and the files
all essentially look the same.
Mm-hmm.
Okay.
So obviously you could get,
like I talked about at the beginning,
you could go down the DevOps side,
get your own open source Dagster set up,
schedule it, run it on servers,
all those things.
But if we just wanted something real simple,
we could just go to you guys and say,
hey, I built this with Dagster.
Will you run it for me?
Pretty much.
Yeah.
Right.
So there's two options there.
You can do the serverless model,
which says, you know, Dagster, just run it.
We take care of the compute,
we take care of the execution for you,
and you just write the code
and upload it to GitHub
or any, you know, repository of your choice
and we'll sync to that and then run it.
The other option is to do the hybrid model.
So you basically do the CICD aspect.
You just say, you push to name your branch.
If you push to that branch,
that means we're just going to deploy a new version
and whatever happens after that,
it'll be in production, right?
Exactly.
Yeah.
And we offer some templates that you can use
in GitHub for workflows
in order to accommodate that.
Excellent.
Then I cut you off.
You're saying something about hybrid.
Hybrid is the other option.
For those of you who want to run your own compute,
you don't want the data leaving your ecosystem,
you can say, we've got this Kubernetes cluster,
this ECS cluster,
but we still want to use the Dagster Cloud product
to sort of manage the control plane.
Dagster Cloud will do that.
And then you can go off
and execute things on your own environment
if that's something you wish to do.
Oh yeah, that's pretty clever
because running stuff in containers isn't too bad,
but running container clusters,
all of a sudden,
you're back doing a lot of work, right?
Exactly, yeah.
Yeah.
Okay, well, let's maybe talk about Dagster for a bit
that I want to talk about some of the trends as well,
but let's just talk through maybe setting up a pipeline.
Like, what does it look like?
You know, you talked about in general,
less imperative, more declarative,
but what does it look like?
Be careful about talking about code on audio,
but you know, just give us a sense
of what the programming model feels like for us.
As much as possible,
it really feels like just writing Python.
It's pretty easy.
You add a decorator on top of your existing Python function
that does something.
That's a simple decorator called asset.
And then your pipeline,
that function becomes a data asset.
That's how it's represented in the Dagster UI.
So you could imagine you've got a pipeline
that gets like maybe Slack analytics
and uploads that to some dashboard, right?
Your first pipeline,
your function would be called something like Slack data,
and that would be your asset.
In that function is where you do all the transform,
the downloading of the data
until you've really created that fundamental data asset
that you care about.
And that could be stored either,
you know,
data warehouse to F3,
however you sort of want to persist it,
that's really up to you.
And then the resources is sort of where the power,
I think,
of a lot of Dagster comes in.
So the asset is sort of like declaration
of the thing I'm going to create.
The resource is how I'm going to,
you know,
operate on that,
right?
Because sometimes you might want to have a,
let's say,
a DuckDB instance locally
because it's easier and faster to operate.
But when you're moving to the cloud,
you want to have a Databricks or a Snowflake.
You can swap out resources based on environments
and your asset can reference that resource.
And as long as it has that same sort of API,
you can really flexibly change between
where that data is going to be persistent.
Does Dagster know how to talk to those different platforms?
Does it like natively understand DuckDB and Snowflake?
Yeah.
So it's interesting.
People often look to Dagster and like,
oh,
does it do X?
And the question is like,
Dagster does anything you can do Python with.
Which is most things.
Yeah.
Which is most things.
So I think if you come from the Airflow world,
you're very much used to like these Airflow providers.
And if you want to use...
That's kind of what I was thinking.
Yeah.
You want to use a Postgres,
you need to find the Postgres provider.
You want to use S3,
you need to find the S3 provider.
With Dagster,
you kind of say,
you don't have to do any of that.
If you want to use Snowflake,
for example,
install the Snowflake connector package from Snowflake,
and you use that as a resource directly.
And then you just run your SQL that way.
There are some places where we do have integrations that help.
If you want to get into the weeds with IO manager,
it's where we persist the data on your behalf.
And so for S3,
for Snowflake,
for example,
there's other ways where we can persist that data for you.
But if you're just trying to run a query,
just trying to execute something,
just trying to save something somewhere,
you don't have to use that system at all.
You can just use whatever Python package you would use anyway to do that.
So maybe some data is expensive for us to get as a company.
Like maybe we're charged on a usage basis or super slow or something.
I could write just Python code that goes and say,
well,
look in my local database.
If it's already there,
use that and it's not too stale.
Otherwise,
then do actually go get it,
put it,
put it there,
and then get it back.
And like that kind of stuff would be up to me to put together.
Yeah.
And that's the nice thing is you're not really limited by like anyone's data model
or world view on how data should be retrieved or saved or augmented.
You could do it a couple of ways.
You could say,
whenever I'm working locally,
use this persistent data store that we're just going to use for development purposes.
Fancy database called SQLite,
something like that.
Exactly.
Yes.
A wonderful database.
And actually it's,
yeah,
it'll work really,
really well.
And then you just say,
when I'm in a different environment,
when I'm in production,
swap out my SQLite resource for a name,
your favorite cloud warehouse resource and go fit,
fetch that data from there.
Or I want to use it mini IO locally.
I want to use S3 on prod.
It's very simple to swap these things out.
Okay.
Yeah.
So it looks like you build up these assets as y'all call them,
these pieces of data,
Python code that accesses them.
And then you have a nice UI that lets you go and build those out kind of workflow style,
right?
Yeah,
exactly.
This is where we get into the wonderful world of DAGs,
which stands for directed acyclic graph.
I think it stands for a bunch of things that are not connected in a circle,
but are connected in some way.
So there can't be any loops,
right?
Because then you never know where to start or where to end.
Could be a diamond,
but not a circle,
right?
Not a circle.
As long as there's like a path through this data set with the beginning and an end,
then we can kind of start to model this connected graph of things.
And then we know how to execute them,
right?
We can say,
well,
this is the first thing we have to run because that's where all dependencies start.
And then we can either branch off in parallel or we can continue linearly until everything
is complete.
And if something breaks in the middle,
we can resume from that broken spot.
Okay.
Excellent.
And is that the recommended way?
Like if I write all this Python code that works on the pieces,
then the next recommendation would be to fire up the UI and start building it?
Or do you say,
ah,
you should really write it in code and then you can just visualize it or monitor it?
Everything in Dagster is written as code.
The UI reads that code and it interprets it as a DAG and then it displays that for you.
There are some things to do with the UI.
Like you can materialize assets,
you can make them run,
you can do backfills,
you can view metadata,
you can sort of enable and disable schedules.
But the core,
we really believe this is Dagster,
like the core declaration of how things are done,
it's always done through code.
Okay.
Excellent.
So when you say materialize,
maybe I have an asset,
which is really a Python function I wrote that goes and pulls down a CSV file.
The materialize would be,
I want to see kind of representative data in this,
in the UI.
so I could go,
all right,
I think this is right.
Let's keep passing it down.
Is that what that means?
Materialize really means just run this particular asset,
make this asset new again,
fresh again,
right?
As part of that materialization,
we sometimes output metadata.
And you can kind of see this on the right.
If you're looking at the screen here,
where we talk about what the timestamp was,
the URL,
there's a nice little graph of like number of rows over time.
All that metadata is something you can emit.
And we emit some ourselves by default with the framework.
And then as you materialize these assets,
as you run that asset over and over again,
over time,
we capture all that.
And then you can really get a nice overview of,
you know,
this asset's lifetime,
essentially.
Nice.
Yeah.
I think the asset,
the metadata is really pretty excellent,
right?
Over time,
you can see how the data's grown and changed.
Yeah.
The metadata is,
is really powerful.
And it's one of the nice benefits of being in this asset world,
right?
Because you don't really want to metadata on like this task that run.
You want to know like this table that I created,
how many rows has it had every single time it's run?
Because if that number drops by like 50%,
that's a big problem.
Conversely,
if the runtime is slowly increasing every single day,
you might not notice it,
but over a month or two,
it went from a 30 second pipeline to 30 minutes.
maybe there's like a great place to start optimizing that one specific asset.
Right.
And what's cool if it's just Python code,
you know how to optimize that probably,
right?
Hopefully.
Yeah.
Well,
as much as you're going to,
yeah,
you got,
you have all the power of Python and you should be able to,
as opposed to it's deep down inside some framework that you don't really.
Exactly.
Yeah.
You use Python,
you can benchmark it.
There's probably,
you probably knew you didn't write it that well when you first started and you can
always find ways to improve it.
So this UI is something that you can just run locally.
Kind of like Jupyter.
A hundred percent.
Just type Degester dev and then you get the full UI experience.
You get to see the runs,
all your assets.
Is it a web app?
It is.
Yeah.
It's a web app.
There's a Postgres backend.
And then there's a couple of services that run the web server,
the GraphQL,
and then the workers.
Nice.
Yeah.
So pretty serious web app.
It sounds like,
but yeah,
just something you run all probably containers or something.
You just fire up when you download it.
Right.
Locally it doesn't even use containers.
It's just all pure Python for that.
But once you deploy,
yeah,
I think you might want to go down the container route,
but it's nice not having to have Docker just to like run a simple test deployment.
Yeah.
I guess not everyone's machine has that for sure.
So question from the audience here.
Jazzy asks,
does it hook into AWS in particular?
Is it compatible with existing pipelines like ingestion lambdas or transform lambdas?
Yeah,
you can hook into AWS.
So we have some AWS integrations built in.
Like I mentioned before,
there's nothing stopping you from importing Boto3 and doing anything really you want.
So a very simple use case,
like let's say you already have an existing transformation being triggered in AWS through
some Lambda.
You could just model that within Dagster and say,
you know,
trigger that Lambda Boto3.
Okay.
Then the asset itself is really that representation of that pipeline,
but you're not actually running that code within Dagster itself.
That's still occurring on the AWS framework.
And that's a really simple way to start adding a little bit of observability and orchestration
to existing pipelines.
Okay.
That's pretty cool because now you have this nice UI and these metadata in this history,
but it's someone else's cloud.
Exactly.
Yeah.
And you can start to pull more information in there.
And over time,
you might decide,
you know,
this,
you know,
Lambda that I had,
it's starting to get out of hand.
I want to kind of break it apart into multiple assets where I want to sort of optimize it a
little way in Dagster can help you along that.
Yeah.
Excellent.
How do you set up,
like triggers or observability inside Dagster?
Like Jazzy's asking about S3,
but like in general,
right?
If a row is entered into a database,
something is dropped in a blob storage or the date changes.
I don't know.
Yeah.
Those are great questions.
You have a lot of options.
In Dagster,
we do model every asset with a couple little flags,
I think that are really useful to think about.
One is whether the code of that particular asset has changed.
Right.
And then the other one is whether anything upstream of that asset has changed.
And those two things really power a lot of automation functionality that we can get downstream.
So let's start with the,
I think the S3 example is the easiest to understand.
You have a bucket and there is,
you know,
a file that gets uploaded every day.
You don't know what time that file gets uploaded.
You don't know when it'll be uploaded,
but you know,
at some point it will be in Dagster.
We have a thing called the sensor,
which you can just connect to an S3 location.
You can define how it looks into that file or into that folder.
And then you would just pull every 30 seconds until something happens.
When that something happens,
that triggers sort of an event.
And that event can trickle at your will downstream to everything that depends on it
as you sort of connect to these things.
So it gets you awake from this,
like,
Oh,
I'm going to schedule something to run every hour.
Maybe the data will be there,
but maybe it won't.
And you can have a much more event-based workflow.
When this file runs,
I want everything downstream to know that this data has changed.
And as sort of data flows through these systems,
everything will sort of work its way down.
Yeah,
I like it.
This portion of Talk Python to Me is brought to you by Posit,
the makers of Shiny,
formerly RStudio,
and especially Shiny for Python.
Let me ask you a question.
Are you building awesome things?
Of course you are.
You're a developer or data scientist.
That's what we do.
And you should check out Posit Connect.
Posit Connect is a way for you to publish,
share,
and deploy all the data products that you're building using Python.
People ask me the same question all the time.
Michael,
I have some cool data science project or notebook that I built.
How do I share it with my users,
stakeholders,
teammates?
Do I need to learn FastAPI or Flask or maybe Vue or React.js?
Hold on now.
Those are cool technologies,
and I'm sure you'd benefit from them,
but maybe stay focused on the data,
project.
Let Posit Connect handle that side of things.
With Posit Connect,
you can rapidly and securely deploy the things you build in Python.
Streamlit,
Dash,
Shiny,
Bokeh,
FastAPI,
Flask,
Quarto,
ports,
dashboards,
and APIs.
Posit Connect supports all of them.
And Posit Connect comes with all the bells and whistles to satisfy IT and other enterprise requirements.
Make deployment the easiest step in your workflow with Posit Connect.
For a limited time,
you can try Posit Connect for free for three months by going to talkpython.fm/posit.
That's talkpython.fm/P-O-S-I-T.
The link is in your podcast player show notes.
Thank you to the team at Posit for supporting Talk Python.
The sensor concept is really cool because I'm sure that there's a ton of cloud machines,
people provisioned, just because this thing runs every 15 minutes, that runs every 30 minutes,
and you add them up and aggregate, we need eight machines just to handle the automation rather than,
you know, because they're hoping to catch something without too much latency,
but maybe like that actually only changes once a week.
Exactly.
And I think that's where we have to like sometimes step away from the way we're so used to thinking
about things.
And I'm guilty of this.
When I create a data pipeline, my natural inclination is to create a schedule where it's
a, is this a daily one?
Is this weekly?
Is this monthly?
But what I'm finding more and more is when I'm creating my pipelines, I'm not adding a schedule.
I'm using Dacister's auto-materialized policies, and I'm just telling it, you figure it out.
I don't have to think about schedules.
Just figure out when the things should be updated.
When it's, you know, parents have been updated, you run.
When the data has changed, you run.
And then just like figure it out and leave me alone.
Yeah.
And it's worked pretty well for me so far.
I think it's great.
I have a search, refresh the search index on the various podcast pages that runs and it
runs every hour, but the podcast ships weekly, right?
But I don't know which hour it is.
And so it seems like that's enough latency, but it would be way better to put just a little
bit of smarts.
Like what was the last date that anything changed?
Was that since the last time you saw it?
Maybe we'll just leave that alone.
You know, you're starting to inspire me to go write more code, but pretty cool.
All right.
So on the homepage at Dagster.io, you've got a nice graphic that shows you both how to write
the code, like some examples of the code, as well as how that looks in the UI.
And one of them is called, says to launch backfills.
What is this backfill thing?
Oh, this is my favorite thing.
Okay.
So when you first start your data journey as a data engineer, you sort of have a pipeline
and you build it and it just runs on a schedule and that's fine.
What you soon find is, you know, you might have to go back in time.
You might say, I've got this data set that updates monthly.
Here's a great example.
AWS cost reporting, right?
AWS will send you some data around, you know, all your instances and your S3 bucket, all
that.
And it'll update that data every day or every month or whatever have you.
Due to some reason, you've got to go back in time and refresh data that AWS updated due
to some like discrepancy.
Backfill is sort of how you do that.
And it works hand in hand with this idea of a partition.
A partition is sort of how your data is naturally organized.
And it's like a nice way to represent that natural organization.
It has nothing to do with like the fundamental way, how often you want to run it.
It's more around like, I've got a data set that comes in once a month, it's represented monthly.
It might be updated daily, but it's the representation of the data is monthly.
So I will partition it by month.
It doesn't have to be dates.
It could be strings.
It could be a list.
You could have a partition for every company or every client or every domain you have,
whatever you sort of think is a natural way to think about breaking apart that pipeline.
And once you do that partition, you can do these nice things called backfills, which says,
instead of running this entire pipeline and all my data, I want you to pick that one month
where your data went wrong or that one month where data was missing and just run the partition
on that range.
And so you limit compute, you save resources and get a little bit more efficient.
And it's just easier to like think about your pipeline because you've got this natural
built-in partitioning system.
Excellent.
So maybe you missed some important event.
Maybe your automation went down for a little bit, came back up.
You're like, oh no, we've, we've missed it.
Right.
But you want to start over for three years.
So maybe we could just go and run the last day.
It's worth it.
Exactly.
Or another one would be your vendor says, hey, by the way, we actually screwed up.
We uploaded this file from two months ago, but the numbers were all wrong.
So we've uploaded a new version to that destination.
Can you update your data set?
One way is to recompute the entire universe from scratch.
But if you've partitioned things and you can say, no, limit that to just this one partition
for that month.
And that one partition can trickle down all the way to all your other assets that depend
on that one.
Do you have to pre decide, do you have to think about this partitioning beforehand or can you
do it retroactively?
You could do it retroactively.
And I have done that before as well.
It really depends on, on where you're at.
I think it's your first asset ever.
Probably don't bother with partitions, but it really isn't a lot of work to get them to
get them started.
Okay.
Yeah.
Really neat.
I like a lot of the ideas here.
I like that it's got this visual component that you can see what's going on, inspect it.
You also see you can debug runs.
What happens there?
Like, obviously, when you're pulling data from many different sources, maybe it's not your
data you're taking in.
Fields can vanish.
It can be the wrong type.
Systems can go down.
I'm sure.
Sure.
The debugging is interesting.
So what's it looks a little bit kind of like a web browser debug dev tools thing.
So for the record, my code never fails.
I've never had a bug in my life.
But for the other you have.
Yeah.
Well, mine doesn't.
I only do it to make an example and remind me how others.
Yes.
If I do, it's intentional, of course.
Yeah.
To humble myself a little bit.
Exactly.
This view is one of my favorite.
I mean, so many favorite views.
But this is, it's actually really fun to watch.
Watch this actually run when you execute this pipeline.
But really, like, let's go back to, you know, the world before orchestrators.
We use cron, right?
We'd have a bash script that would do something.
And we'd have a cron job that said, make sure this thing runs.
And then hopefully it was successful, but sometimes it wasn't.
And it's a sometimes it wasn't.
That's always been the problem, right?
It's like, well, what do I do now?
How do I know why it failed?
What was, when did it fail?
You know, at what point or what steps did it fail?
That's really hard to do.
What this debugger really is, is a structured log of every step that's been going on through your pipeline, right?
So in this view, there's three assets that we can kind of see here.
One is called users.
One is called orders.
And one is to run dbt.
So presumably there's these two, you know, tables that are being updated.
And then a dbt job, it looks like that's being updated at the very end.
Once you execute this pipeline, all the logs are captured from each of those assets.
So you can manually write your own logs.
You have access to a Python logger and you can use your info, your error, whatever have you, in log output that way.
And it'll be captured in a structured way.
But it also capture logs from the integrations.
So using dbt, we capture those logs as well.
You can see it processing every single asset.
So if anything does go wrong, you can filter down and understand at what step, at what point did something go wrong.
That's awesome.
And just the historical aspect.
Because just going through logs, especially multiple systems, can be really, really tricky to figure out what's the problem.
What actually caused this to go wrong?
But come back and say, oh, it crashed.
Pull up the UI and see.
All right.
Well, show me what this run did.
Show me what this job did.
And it seems like it's a lot easier to debug than your standard web API or something like that.
You can click onto any of these assets that get that metadata that we had earlier as well.
If, you know, one step failed and it's kind of flaky, you can just click on that one step and say, just rerun this.
Everything else is fine.
We don't need to restart from scratch.
Okay.
And it'll keep the data from before.
So you don't have to rerun that.
Yeah.
I mean, it depends on how you built the pipeline.
We like to build idempotent pipelines is how we sort of talk about it, the data engineering landscape, right?
So you should be able to run something multiple times and not break anything in a perfect world.
That's not always possible.
But ideally, yes.
And so we can presume that if users completed successfully, then we don't have to run that again because that data was persisted, you know, database S3 somewhere.
And if orders was the one that was broken, we can just only run orders and not have to worry about rewriting the whole thing from scratch.
So idempotent for people who maybe don't know, you run it once or you perform the operation once or you perform it 20 times, same outcome.
Should have side effects, right?
That's the idea.
Yeah.
That's the idea.
Easier something done sometimes.
It sure is.
Sometimes it's easy.
Sometimes it's very hard.
But the more you can build pipelines that way, the easier your life becomes in many ways.
Generally, not always, but generally true for programming as well, right?
If you talk to functional programming people, they'll say like, it's an absolute, but.
Yes.
Functional programmers love this kind of stuff.
And it actually does lend itself really well to data pipelines.
Data pipelines, unlike maybe some of the software engineering stuff, it's a little bit different in that the data changing is what causes often most of the headaches, right?
It's less so the actual code you write, but more the expectations tend to change so frequently and so often in new and novel and interesting ways that you would often never expect.
And so the more you can sort of make that function so pure that you can provide any sort of data set and really test really easily.
These expectations, when they get the easier it is to sort of debug these things and build on them in the future.
Yeah.
And cache them as well.
Yes.
It's always nice.
Yeah.
So speaking of that kind of stuff, like what's the scalability story?
If I've got some big, huge, complicated data pipeline, can I parallelize them and have them run multiple pieces?
Like if there's different branches or something like that?
Yeah, exactly.
That's one of the key benefits, I think, in writing your assets in this DAG way, right?
Anything that is parallelizable will be parallelized.
Now, sometimes you might want to put limits on that.
Sometimes too much parallelization is bad.
Your poor little database can't handle it.
And you can say, you know, maybe a concurrency limit on this one just for today is worth putting.
Or if you're hitting an API for an external vendor, they might not appreciate 10,000 requests a second on that one.
So maybe you would slow it down.
But in essence...
Or rate limiting, right?
You can run into too many requests and then your stuff crashes.
Then you got to start.
It can be a whole thing.
There's memory concerns.
But let's pretend the world is simple.
Anything that can be paralyzed will be through Dexter.
And that's really the benefit of writing these DAGs is that there's a nice algorithm for determining what that actually looks like.
Yeah.
I guess if you have a diamond shape or any sort of split, right?
Those two things now become...
Because it's acyclical.
They can't turn around and then eventually depend on each other again.
So...
That's a perfect chance to just go fork it out.
Exactly.
And that's kind of where partitions are also kind of interesting.
If you have a partitioned asset, you could take your data set, partition it to five buckets and run all five partitions at once, knowing full well that because you've written this in a idempotent and partition way, that the first pipeline will only operate on apples and the second one only operates on bananas.
And there is no commingling of apples and bananas anywhere in the pipeline.
Oh, that's interesting.
I hadn't really thought about using the partitions for parallelism, but of course...
Yeah.
It's a fun little way to break things apart.
So if we run this on the Dagster cloud or even on our own, this is pretty much automatic.
We don't have to do anything.
Like Dagster just looks at it and says, this looks parallelizable and it'll go or...
That's right.
Yeah.
As long as you've got the full deployment, whether it's OSS or cloud, Dagster will basically parallelize it for you as much as possible.
Excellent.
You can set global concurrency limits.
So you might say, you know, 64 is more than enough, you know, parallelization that I need.
Or maybe I want less because I'm worried about overloading systems.
It's really up to you.
I'm putting this on a $10 server.
Please don't.
Please don't kill it.
Just respect that it's somewhat wimpy, but that's okay.
It'll get the job done.
All right.
I want to talk about some of the tools and some of the tools that are maybe at play here when working with Dagster and some of the trends and stuff.
But before that, it may be speak to where you could see people adopt a tool like Dagster, but they generally don't.
They don't realize like, oh, actually, there's a whole framework for this, right?
Like I could, sure, I could go and build just on HTTP server and hook into the request and start writing to it.
But like, maybe I should use Flask or FastAPI.
Like there's these frameworks that we really naturally adopt for certain situations like APIs and others, background jobs, data pipelines, where I think there's probably a good chunk of people who could benefit from stuff like this.
But they just don't think they need a framework for it.
Like Cron is enough.
Yeah, it's funny because sometimes Cron is enough.
And I don't want to encourage people not to use Cron.
But think twice, at least, is what I would say.
So probably the first like trigger for me of thinking of, you know, is that actually a good choice is like, am I trying to ingest data from somewhere?
That's something that fails.
Like, I think we just can accept that, you know, if you're moving data around, the data source will break.
The expectations will change.
You will need to debug it.
You will need to run it.
And doing that in Cron is a nightmare.
So I would say definitely start to think about an orchestration system if you're ingesting data.
If you have a simple Cron job that sends one email, like, you're probably fine.
I don't think you need to implement all of DAG searches just to do that.
But the more closer you get to data pipelining, I think the better your life will be if you're not trying to debug a obtuse process that no one really understands six months from now.
Excellent.
All right.
Maybe we could touch on some of the tools that are interesting.
You see people using, you talked about DuckDB and DBT, a lot of D's starting here.
But give us a sense of like some of the supporting tools you see a lot of folks using that are interesting.
Yeah, for sure.
I think in the data space, probably DBT is one of the most popular choices.
And DBT, in many ways, it's nothing more than a command line tool that runs a bunch of SQL in a DAG as well.
So there's actually a nice fit with Dijkstra and DBT together.
DBT is really used by people who are trying to model that business process using SQL against typically a data warehouse.
So if you have your data in, for example, Postgres, Snowflake, Databricks, Microsoft SQL, these types of data warehouses, generally you're trying to model some type of business process.
And typically people use SQL to do that.
Now you can do this without DBT, but DBT has provided a nice clean interface to doing so.
It makes it very easy to connect these models together, to run them, to have a development workflow that works really well.
And then you can push it to prod and have things run again in production.
So that's DBT.
We find it works really well.
And a lot of our customers are actually using DBT as well.
There's DuckDB, which is a great, it's like the SQLite for columnar databases, right?
Yeah.
It's in process.
It's fast.
It's written by the Dutch.
There's nothing you can't like about it.
It's free.
We love that.
It feels very comfortable in Python itself.
It does.
It's so easy.
Yes, exactly.
The Dutch have given us so much and they've asked nothing of us.
So I'm always very thankful for them.
It's fast.
It's so fast.
It's like if you've ever used Pandas for processing large volumes of data, you've occasionally hit memory limits or inefficiencies in doing these large aggregates.
I won't go into all the reasons of why that is, but DuckDB sort of changes that because it's a fast serverless sort of C++ written tooling to do really fast vectorized work.
And by that, I mean like it works on columns.
So typically in like SQLite, you're doing transactions.
You're doing single row updates, writes, inserts, and SQLite is great at that.
Where typical transactional databases fail or aren't as powerful is when you're doing aggregates, when you're looking at an entire column, right?
Just the way they're architected.
If you want to know the average, the median, the sum of some large number of columns, and you want to group that by a whole bunch of things, you want to know the first date someone did something and the last one.
Those types of vectorized operations, DuckDB is really, really fast at doing.
And it's a great alternative to, for example, Pandas, which can often hit memory limits and be a little bit slow in that regard.
Yeah, it looks like it has some pretty cool aspects, transactions, of course.
But it also says direct Parquet, CSV, and JSON querying.
So if you've got a CSV file hanging around and you want to ask questions about it or JSON or some of the data science stuff through Parquet, turn an indexed proper query engine against it.
Don't just use a dictionary or something, right?
Yeah.
It's great for reading a CSV, zip files, tar files, Parquets, partition Parquet files, all that stuff that usually was really annoying to do and operate on.
You can now install DuckDB.
It's got a great CLI, too.
So before you go and program your entire pipeline, you just run DuckDB and you start writing SQL against CSV files and all this stuff to really understand your data and just really see how quick it is.
I used it on a bird data set that I had as an example project and there was millions of rows and I was joining them together and doing massive group buys and it was done in like seconds.
And it's just hard for me to believe that it was even correct because it was so quick.
So it's wonderful.
I must have done that wrong somehow because it's done.
It shouldn't be done.
Yeah.
And the fact it's in process means there's not a babysit, a server for you to babysit patch, make sure it's still running.
It's accessible, but not too accessible.
All that, right?
It's a pip and sell away, which is always, we love that, right?
Yeah, absolutely.
You mentioned, or I guess I mentioned Parquet, but also Apache Arrow seems like it's making its way into a lot of different tools and sort of foundational sort of high memory, high performance in memory processing.
Have you used this, Eddie?
I've used it, especially through like working through different languages.
So moving data between Python and R is where I last used this.
I didn't know Arrow's great at that.
I believe Arrow is like the underneath some of the Rust to Python as well.
It's working there.
So typically I don't use Arrow like directly myself, but it's in many of the tooling I use.
Right.
It's a great product.
And like so much of the ecosystem is now built on Arrow.
Yeah, I think a lot of it is, I feel like the first time I heard about it was through Polars.
That's right.
Yeah.
I'm pretty sure, which is another Rust story for kind of like Pandas, but a little bit more fluent, lazy API.
Yes.
We live in such great times, to be honest.
So Polars is a Python bindings for Rust, I believe is kind of how I think about it.
It does all the transformation in Rust, but you've had this Python interface to it and it makes things, again, incredibly fast.
I would say similar in speed to DuckDB.
They both are quite comparable sometimes.
Yeah, it also claims to have vectorized and columnar processing and all that kind of stuff.
Yeah, it's pretty incredible.
So not a drop-in replacement for Pandas, but if you have the opportunity to use it and you don't need to use the full breadth of what Pandas offers, because Pandas is quite a huge package.
There's a lot it does.
But if you're just doing simple transforms, I think Polars is a great option to explore.
Yeah, I talked to Richie Vink, who is part of that, and I think they explicitly chose to not try to make it a drop-in replacement for Pandas, but tried to choose an API that would allow the engine to be smarter and go like, I see you're asking for this, but the step before you wanted this other thing.
So let me do that transformation all in one shot and a little bit like a query optimization engine.
Yeah.
What else is out there?
We've got time for just a couple more.
If there's anything that you're like, oh, yeah, people use this all the time.
Obviously, the databases, you've said, Postgres, Snowflake, et cetera.
Yeah, there's so much.
So another little one I like, it's called DLT, DLT Hub.
It's getting a lot of attraction as well.
And what I like about it is how lightweight it is.
I'm such a big fan of lightweight tooling that's not, you know, massive frameworks.
Loading data is, I think, still kind of yucky in many ways.
It's not fun.
And DLT makes it a little bit simpler and easier to do so.
So that's what I would recommend people just look into if you got to either ingest data from, you know, some API, some website, some CSV file.
It's a great way to do that.
It claims it's the Python library for data teams loading data into unexpected places.
Very interesting.
Yes, that's great.
Yeah, this looks cool.
All right.
Well, I guess maybe let's talk about, let's talk business and then we can talk about what's next and then we'll probably be out of time.
I'm always fascinated.
I think there's starting to be a bit of a blueprint for this, but companies that take a thing, they make it and they give it away and then they have a company around it.
And, you know, congratulations to you all for doing that.
Right.
And a lot of it seems to kind of center around the open core model, which I don't know if that's exactly how you would characterize yourself.
But maybe you talk about the business side, because I know there's many successful open source projects that don't necessarily result in full time jobs or companies if people were to want that.
It's a really interesting place.
And I don't think it's one that anyone has truly figured out well.
I can say this is the way forward for everyone, but it is something we're trying.
And I think for Dexter, I think it's working pretty well.
And what I think is really powerful about Dexter is like the open source product is really, really good.
And it hasn't really been limited in many ways in order to drive like cloud product consumption.
Yeah, sure.
We really believe that there's actual value in that separation of these things.
There are some things that we just can't do in the open source platform.
For example, there's pipelines on cloud that involve, you know, ingesting data through our own systems in order to do reporting, which just doesn't make sense to do on the open source system.
It makes the product way too complex.
But for the most part, I think Dexter open source, like we really believe that like just getting it in the hands of developers is the best way to prove the value of it.
And if we can build a business on top of that, I think we're all super happy to do so.
It's nice that we get to sort of drive both sides of it.
To me, that's like one of the more exciting parts, right?
A lot of the development that we do in Dexter open source is driven by people who are paid through, you know, what happens on Dexter cloud.
And I think from what I can tell, there's no better way to build open source product than to have people who are adequately paid to develop that product.
Otherwise, it can be, you know, a labor of love, but one that doesn't last for very long.
Yeah, whenever I think about building software, there's 80% of it that's super exciting and fun, 10%.
And then there's that little sliver of like really fine polish that if it's not just your job to make that thing polished, you're just for the most part, just not going to polish that bit, right?
It's tough. UI, design, support.
There's all these things that go into making software like really extraordinary.
That's really, really tough to do.
And I think I really like the open source business model.
I think for me, being able to just try something, not having to talk to sales and being able to just deploy locally and test it out and see if this works.
And if I choose to do so, deploy it in production.
Or if I bought the cloud product and I don't like the direction that is going, I can even go into open source as well.
That's pretty compelling to me.
Yeah, for sure it is.
And I think the more moving pieces of infrastructure, the more uptime you want and all those types of things, the more somebody who's maybe a programmer but not a DevOps infrastructure person but needs to have it there, right?
Like that's an opportunity as well, right?
For you to say, look, you can write the code.
We made it cool for you to write the code, but you don't have to like get notified when the server's down or whatever.
Like we'll just take care of that for you.
That's pretty awesome.
Yeah.
And there's efficiencies of scale as well, right?
Like we've learned the same mistakes over and over again, so you don't have to, which is nice.
I don't know how many people who want to maintain servers, but people do.
And they're more than welcome to if that's how they choose to do so.
Yeah, for sure.
All right.
Just about out of time.
Let's close up our conversation with where are things going for Dagster?
Like what's on the roadmap?
What are you excited about?
Oh, that's a good one.
I think we've actually published our roadmap line somewhere.
If you search Dagster roadmap, it's probably out there.
I think for the most part, that hasn't changed much going into 2024, though we may update it.
There it is.
We're really just doubling down on what we've built already.
I think there's a lot of work we can do on the product itself to make it easier to use, easier to understand.
My team specifically is really focused around the education piece.
And so we launched Dagster University's first module, which helps you really understand the core.
Our next module is coming up in a couple months, and that'll be around using Dagster with DBT, which is our most popular integration.
We're building up more integrations as well.
So I've built a little integration called Embedded ELT that makes it easy to ingest data.
But I want to actually build an integration with DLT as well, DLT Hub.
So we'll be doing that.
And there's more coming down the pipe, but I don't know how much I can say.
Look forward to an event in April where we'll have a launch event on all that's coming.
Nice.
Is that an online thing people can attend or something?
Exactly.
Yeah, there'll be some announcement there on the Dagster website on that.
Maybe I will call it one thing that's actually really fun.
It's called Dagster Open Platform.
It's a GitHub repo that we launched a couple months ago, I want to say.
We took our internal...
I should go back one more.
Sorry.
It's like GitHub, Dagster Open Platform and GitHub.
I have it somewhere.
Yeah.
It's here under the organization?
Yes, it should be somewhere in here.
There it is.
Dagster Open Platform on GitHub.
And it's really a clone of our production pipelines for the most part.
There's some things we've chosen to ignore because they're sensitive.
But as much as possible, we've defaulted to making it public and open.
And the whole reason behind this was because, you know,
as data engineers, it's often hard to see how other data engineers write code.
We get to see how software engineers write code quite often,
but most people don't want to share their platforms for various good reasons.
Also, there's like smaller teams or maybe just one person.
And then like those pipelines are so integrated into your specific infrastructure, right?
So it's not like, well, here's a web framework to share, right?
Like, here's how we integrate into that one weird API that we have that no one else has.
So it's no point in publishing it to you, right?
That's typically how it goes.
Or they're so large that they're afraid that there's like some, you know,
important information that they just don't want to take the risk on.
Yep.
And so we built like something that's in the middle where we've taken as much as we can
and we've publicized it.
And you can't run this on your own.
Like, that's not the point.
The point is to look at the code and see, you know, how does Dagster use Dagster?
And what does that kind of look like?
Nice.
Okay.
All right.
Well, I'll put a link to that in the show notes and people can check it out.
Appreciate it.
Yeah.
I guess let's wrap it up with the final call to action.
People are interested in Dagster.
How do they get started?
What do you tell them?
Oh, yeah.
Dagster.io is probably the greatest place to start.
You can try the cloud product.
We have free self-serve or you can try the local install as well.
If you get stuck, a great place to join is our Slack channel, which is up on our website.
There's even a Ask AI channel where you can just talk to a Slack bot that's been trained
on all our GitHub issues and discussions.
And it's surprisingly good at walking you through, you know, any debugging, any issues or even advice.
That's pretty excellent, actually.
Yeah.
It's real fun.
It's really fun.
And if that doesn't work, we're also there in the community where you can just chat to
us as well.
Cool.
All right.
Well, Pedram, thank you for being on the show.
Make sure all the work on Dagster and sharing it with us.
Thank you, Michael.
You bet.
See you later.
This has been another episode of Talk Python to Me.
Thank you to our sponsors.
Be sure to check out what they're offering.
It really helps support the show.
This episode is sponsored by Posit Connect from the makers of Shiny.
Publish, share, and deploy all of your data projects that you're creating using Python.
Streamlit, Dash, Shiny, Bokeh, FastAPI, Flask, Quarto, Reports, Dashboards, and APIs.
Posit Connect supports all of them.
Try Posit Connect for free by going to talkpython.fm/posit, P-O-S-I-T.
Want to level up your Python?
We have one of the largest catalogs of Python video courses over at Talk Python.
Our content ranges from true beginners to deeply advanced topics like memory and async.
And best of all, there's not a subscription in sight.
Check it out for yourself at training.talkpython.fm.
Be sure to subscribe to the show.
Open your favorite podcast app and search for Python.
We should be right at the top.
You can also find the iTunes feed at /itunes, the Google Play feed at /play,
and the direct RSS feed at /rss on talkpython.fm.
We're live streaming most of our recordings these days.
If you want to be part of the show and have your comments featured on the air,
be sure to subscribe to our YouTube channel at talkpython.fm/youtube.
This is your host, Michael Kennedy.
Thanks so much for listening.
I really appreciate it.
Now get out there and write some Python code.
I'll see you next time.