The toolchain for modern data science can be intimidating.
How do you choose between all the data visualization libraries out there?
How about creating interactive web apps from those analysis?
On this episode, we dive into a project that attempts to bring that whole story together,
HoloViz.
HoloViz is a coordinated effort to make browser-based data visualization in Python easier to use,
easier to learn, and more powerful.
We have Philip Rudiger from HoloViz here to guide us through it.
This is Talk Python to Me, episode 269, recorded June 15, 2020.
Welcome to Talk Python to Me, a weekly podcast on Python, the language, the libraries, the
ecosystem, and the personalities.
This is your host, Michael Kennedy.
Follow me on Twitter, where I'm @mkennedy.
Keep up with the show and listen to past episodes at talkpython.fm, and follow the show on Twitter
via at Talk Python.
This episode is sponsored by Brilliant.org and Datadog.
Please check out what they're offering during their segments.
It really helps support the show.
Philip, welcome to Talk Python to Me.
Thanks so much for having me.
I'm excited to have you here.
Now, we're going to talk about a bunch of cool libraries that are all brought together
around this HoloViz overall meta project, if you will, to kind of make...
Yeah, exactly.
This umbrella to make working with data and exploring and visualizing it in Python a little
bit easier.
And I think that's a great project, and it looks like it's getting a lot of traction, and I'm
happy to be here to chat about it.
I'm excited to talk about the various libraries in it.
Yeah, absolutely.
Before we get to that, though, let's start with your story.
How did you get into programming in Python?
So I got started with programming pretty late.
So apart from the usual thing of the 90s, you had a GeoCities website, you hacked some HTML,
CSS.
I really didn't get started with actual programming until I joined an electronic engineering course
in my undergrad.
So I moved from Germany to the UK to study electronic engineering and music technology, thinking I
was better at music than I really was.
But I took a liking to kind of programming.
We did some programming in C and Barilog, the pretty low-level stuff.
And then towards the end of that project, kind of that undergrad degree, I developed a simulator
of like bipedal locomotion in C++, which was far more complex than I'd envisioned it.
But it was really exciting to me to kind of actually get into like a big project of my own.
And from there, I then joined a master's course and started programming in Python and doing
data analysis.
And we had this simulator called Topographica, which did kind of...
That's cool.
You talked about working on this bipedal locomotion simulator in C++.
Like, forget the language.
That kind of stuff is trickier than it seems like it should be, right?
Oh, absolutely.
Because back then I had no idea about neural networks.
It was like I just kind of jumped in, heard about neural networks, heard about like genetic
programming.
So I built a huge network with way too many parameters and assumed like generic programming
would make it work.
It didn't.
It didn't really work.
The simulator worked.
So it did flop around and like my little bipedal humanoid would flop around a little bit, but
it never actually managed to generate actually real bipedal motion.
Yeah.
I guess there is something to training these models correctly and getting them set up right
in the first place.
It's not just magic that you can throw at a problem, right?
Yes.
But then I decided this thing wasn't complicated enough, so I'd actually try and solve the brain.
So that's, I then joined a master's and PhD graduate program, neural informatics.
And yeah, hoping to actually learn about how these things actually work.
Oh, that's really cool.
So was that like trying to model the way brains and synapses work using neural networks?
Yes.
So it was pretty close to what you'd consider like a convolutional neural network nowadays.
Well, they were around back then.
They weren't as popular.
Yeah.
And then, but then we also have like recurrent connections and it was, the idea was to model
the human visual system, basically.
You're just generally the mammalian visual system.
And so starting to vary a little bit.
What kind of problems were you trying to do?
What were you trying to ask it to do and see if it, what was success for you?
It was really, the idea was that it was self-organizing, right?
So that you didn't have to reprogram a bunch of like known stuff into the network or just
kind of organize like many of the convolutional neural networks nowadays do.
But we were trying to kind of keep it closer to the actual biology.
So we had different cell types that were interacting and those models were tremendously complex and
it was just super hard to analyze them.
Like I started having these huge model outputs.
Like I have like 60, 100 page outputs of like a model run of PDFs with just images in it.
And that's actually where I started developing these visualization tools.
So me and a colleague of mine were like, yeah, this isn't feasible.
We can't analyze these things properly.
Just looking, like flipping through PDFs, I'd wake up and like flip through these PDFs
and almost cut myself.
And then I'd start, we started writing this.
Yeah.
It's like trying to watch the green in the matrix, right?
Like just trying like, no, I can't see it this way.
This is, we got to look at it better.
Yes, precisely.
So the idea was that we'd start building something like you have these huge parameter spaces,
right?
It's like excitatory strings, inhibitory strings, the model would evolve over time.
And so we had these very complex parameter spaces that we were trying to explore.
And so we built this tool called HoloViews to kind of start digging into that and kind of
visualizing like what effect does this parameter actually have on the evolution of the model?
So you could drag a slider and see the accessory strength of this to the model, the inhibitory
strength of that.
And so then this is how it evolves over time.
And that was really breakthrough to actually start analyzing.
But it also meant that I eventually started spending more time building this visualization
tool than I was actually spending on my actual project.
And I found that's one of the challenges.
I found that in the end, I found that more rewarding than actually working on.
Yeah.
That's the real danger, right?
Is like, I mean, I started getting into programming, doing research on complex dynamical systems and
math and whatnot.
And I, after a while, I realized, you know, the part of this project that really makes me
happy is when I'm not doing the math.
That was a sign that I should probably be doing something else.
But it's, it is really fun to build these things.
I also do think it's, you know, it's a challenge of research projects and this academic stuff in
general is it's hard to get credit for that, right?
Like you're not, they're not going to go, man, that's a killer contribution to data science
that you made.
Here's your PhD.
They're like, where's the network?
Where's the paper, right?
Right.
Where's the publication?
Yeah, exactly.
Where's the publication?
Exactly.
Yeah.
And actually we did publish a paper on all of these and that was turned out to be the
only paper I published in my PhD.
The rest, I mean, yeah, basically my models didn't work until the very end, like two weeks
before I handed in my thesis, the models started working and I actually had results, but I never
got around to actually publishing.
Man, that's down to the wire.
Yeah, it was really down to the wire.
And at least, yeah, I'm kind of glad that's over with.
Yeah.
Well, it's, it's better late than never in that case.
So that's how you got into programming and found your way over to Python.
I mean, obviously it's a natural place to go.
Python is if you're doing neural networks.
What time frame was this in?
Like what year was this?
So I joined this.
It was a really good program.
So it was the doctoral training center in Edinburgh that actually doesn't exist anymore.
So it was part of the informatics department, but they had close collaboration with the neurotrans
department.
And I joined in 2010 and the first year was a master's program.
And then it was kind of, it took me way longer than it should to finish my program.
But I think in 2015, I handed in the thesis and did my defense.
Yeah.
Cool.
I'm just wondering, you know, you started in 2010 with, with some of this stuff.
If you started now, how much easier do you think it would be, or would it be basically the same to work on?
The visualization problems, the neural network problems?
It just seems like that has come so far in the last five years.
Oh, absolutely.
So back then I remember like we had, obviously we had to interface with C code a lot.
And so we had to, we used something called SciPy Weave, which many people probably don't know about anymore.
Yeah.
But it was this really awkward interface for C extensions.
And nowadays that would be, I mean, you've got things like Numbo, you could write the kernels that were running these neural networks.
And like in pure Python, you know, just to compile it to something fairly optimized.
Right.
Absolutely.
Same with the visualization tools.
There's like so many interactive visualization tools at this point.
So back then, for example, all of you just built using, on top of MepaLoop, that's what it output.
But the actual rendering nowadays, we build on bouquet and property.
And so we've gotten a lot more insights just contractively exploring this data.
That's really cool.
It's been such a huge evolution of tools.
Yeah.
Nice.
All right.
Well, what are you up to these days?
What do you do day to day?
So it's really nice.
I have kind of the freedom to switch between, well, not total freedom, but we kind of, when
I joined Continuum Analytics, which is now Anaconda in 2015, actually, before I handed in my thesis,
I was running out of funding and then joined Anaconda kind of as a day job between writing
my thesis.
All right.
And so I joined to do consulting.
Basically, I'd solve machine learning and visualization problems for various government
clients, corporations, and so on.
But from the very beginning, we kind of had this idea of we'd build open source tools that
would solve people's problems and then use them in our consulting.
That kind of model worked really well for us.
The entire whole of this suite of tools was built kind of as a spending quite a bit of
open source time, unpaid or unbillable time on the open source side.
But also, kind of, for example, a panel was built with funding from U.S. Army Corps of Engineers.
So they just started to take a gamble with us and built this new dashboarding framework.
And so I had the freedom for over basically six, nine months to build this new tool.
Yeah, a panel is really cool.
We'll talk about that for sure.
So yeah, I go between most of my time is consulting work.
But as much as possible, we try to contribute the stuff we work on during that time back to
the open source.
Yeah.
And so you mostly do remote work, I would guess?
Yes.
So actually, I was in Edinburgh.
Anaconda in Austin?
Yeah, I was in Edinburgh for years.
And then last year, I moved here back to Berlin, which is where I grew up.
And actually, we had an office.
So Anaconda just opened an office here.
And I thought it would be nice to actually spend two to three days a week just actually
going to the office, seeing people have a more regular routine.
Yeah, yeah.
Just work until 3 a.m.
And then getting up before noon.
And then COVID happened and we're back to being fully remote.
Yeah, yeah.
Well, going to be around people.
Yeah, not everyone's used to it.
Yeah, for sure.
It's a bit of a bummer.
I mean, for folks like us who can work remotely and just carry on mostly doing what we're doing,
it's a bit of a bummer.
For a lot of people, it's a tragedy, right?
It's a huge, huge problem.
Especially for kids.
I don't know how people do it.
I know.
It seems really, really scary.
Hopefully we get through that soon and we can go back to an office.
Who knows what people's desire to get back to work together will be like.
Some of these remote ideas, I think, are going to stick.
And some people are kind of like, oh, so glad that's over.
Yeah, I think so.
Particularly, I mean, it's really not a good test for people talking like this is going
to usher in the revolution.
But it's a forced scenario, right?
People don't have childcare.
They're stuck at home.
Yeah.
So I don't know if it'll just put people off of remote work entirely.
Well, I think you touched on the real challenge.
It's one thing to say, well, let's all try to be remote for a while.
It's another to say, let's work with your small children around you all the time.
Like, that is the real struggle, I think, as a parent to find the time and the focus, right?
So I think it's an unfair test.
But if it's working under these scenarios, this is like the worst case scenario.
So obviously...
And it still seems to be mostly working, right?
Exactly.
It's interesting.
Also, it's kind of nice.
I actually kind of like, I don't know, you have a client meeting and get all stolen.
Yeah.
It does humanize people a little bit.
I think, you know, it's...
I don't want to go too far in it, but like, you know, watch the news or you watch like comedy
shows that are still going.
And it's just like, yeah, everyone's at their couch or at their kitchen table or just their
little home office.
And yeah, it's funny.
So let's talk about the history of this project a little bit.
So you started with HoloViz.
HoloViz.
Yes.
Thank you.
So Holo...
Yeah, it's kind of confusing.
And there's...
Yeah, yeah.
I know.
There's even more confusing history around it, which I'm sure we'll get into.
This portion of Talk Python to Me is brought to you by Brilliant.org.
Brilliant has digestible courses in topics from the basics of scientific thinking all the way
up to high-end science like quantum computing.
And while quantum computing may sound complicated, Brilliant makes complex learning uncomplicated
and fun.
It's super easy to get started, and they've got so many science and math courses to choose
from.
I recently used Brilliant to get into rocket science for an upcoming episode, and it was a
blast.
The interactive courses are presented in a clean and accessible way, and you could go
from knowing nothing about a topic to having a deep understanding.
Put your spare time to good use and hugely improve your critical thinking skills.
Go to talkpython.fm/brilliant and sign up for free.
The first 200 people that use that link get 20% off the premium subscription.
That's talkpython.fm/brilliant.
Or just click the link in the show notes.
How did you go from trying to create better visualizations to this larger project?
I guess, as a way of introduction, maybe tell people how you got there, and then give us
a high-level view of what it is.
Yeah, absolutely.
So we started with Olive Views, which was actually built on this project called Param.
So Param is kind of like, we now have data classes in Python, kind of parameters on classes,
that are typed and so on, and there's projects like Patelits.
So Param was kind of the foundation of everything.
Built on top of that to kind of have type validation, just general semantic validation as well.
This thing is not just a tuple, but it's a range of two numbers.
It actually represents a range.
That was kind of the initial thing, which had been around before I even got into Python.
And then we built Olive Views on top of that.
And then one of our first projects at Continuum, back in the Continuum days, was for the UK
med office to build, kind of extend Olive Views to have geographic support, brought about
GeoViews, which is kind of just an extension for Olive Views.
And then...
Right.
Obviously focused on, you know, geographical data and map data and whatnot.
Yes.
Yeah.
Handling the projections for you and stuff like that.
That's just quite nice.
But then, I mean, what we saw over and over again as part of our consulting project was
people were happy to have these analysis and a lot of them were in notebooks.
And then people would share these notebooks.
But really, someone who doesn't know about code is kind of scared or put off by all the
code in this notebook.
And they want another way to share it.
And that's kind of how we started building dashboarding tools.
Right.
So notebooks are pretty nice to show people.
But at least in Jupyter, as far as I know, there's not a great way to say, please load
this with every bit of code collapsed.
Right.
So, I mean, there's templates, but maybe they're kind of obscure.
Not everyone is familiar with them.
And just generally, like, if you just want to have everything nicely presented as a nice
layout that you put together.
There wasn't really tools for that.
Yeah.
Right.
Okay.
But all of that has changed.
I'll get into that a little bit.
And then we just needed a name for all of this stuff, which we decided on Pyviz.
Pyviz seemed like a good name.
It wasn't taken.
And then it was a great name.
But we had a little bit of pushback from the community.
Pyviz sounds like just Python visualization, right?
It's kind of presumptuous to think that it's a name we could keep.
Like, you can't claim it all.
Right.
And I think that was...
We've got Bogey.
We've got, yeah.
Yeah.
It was a totally fair criticism.
And we kind of talked to various community members and were like, okay, Pyviz becomes this
general thing and we're going to find a new name, which has been confusing.
Like, obviously, we haven't...
I think this was a year and a half ago.
And we kind of run with the Pyviz name for a year and a half as well.
And so oftentimes when you see a blog post out there now, it's still the Pyviz is us,
not the general resource that it's meant to be.
Yeah.
I was looking at some videos on YouTube about some of the presentations you gave and stuff.
And I saw sometimes it was called HoloViz and sometimes it was Pyviz.
And I'm like, oh, I wonder what the relationship is here.
And I see historically where that comes from.
Yeah.
So I think overall, it was a good idea to kind of have Pyviz.org become this general resource.
And we absolutely, we're happy to kind of have this listing of all the different visualization
dashboarding libraries on there.
And we'd like to have more tutorial material to point to and stuff like that.
So just it becomes a general resource.
And HoloViz is now our effort to kind of have a coordinate and we need a set of tools that
work well together to have browser-based visualization, dashboarding, and just make that easier and make
it all fit together.
Yeah.
Very cool.
You're basically making a bunch of choices for people.
Like, here's a way that you can plot stuff.
Here's a way that you can stream data or process large amounts of data with what doesn't fit in
RAM or whatever.
Yeah.
But you're not forcing them down that path, right?
One of the things that was cool is like, okay, if you need more control or you want to do
something different, you can just do this yourself.
If you want to not do less work and accept the defaults or the default way of working, right,
you can use something built in.
That's exactly right.
Yeah.
So the idea that there is, the way we try to communicate that is it's about shortcuts,
not good ends, right?
To make it easy, the default should be good.
You should just be able to get something on screen quickly, which is kind of a philosophy
that you could use in particular.
You just wrap your data and it visualizes itself.
But then you shouldn't be stuck there.
It shouldn't be.
There's plenty of libraries where you just put, get your quick plot, but then it's really
hard to customize from there.
And that's something we had to learn as well, I think.
So all of these is pretty opinionated, actually.
And it doesn't fit the regular model that people are thinking of, right?
It's imperative plotting model where you say, you get your figure, get your axes, you kind
of modify each little bit of the axes.
It's about just wrapping your data and have it visualize itself.
And then you can tweak the options on it.
And that model doesn't work for everyone, which is something we had to learn.
We've kind of decided now that we'd rather meet people where they are, right?
People already, there's already such a big ecosystem of visualization tools.
And at this point, even a big ecosystem of dashboarding tools.
And rather than tell people, like, this is the way you have to do it, you should just be
able to plug in what you have and go from there.
And that's the Ada philosophy behind HV plot, which is kind of a wrapper around all of you,
which just, you use Pandas, you'll know that Pandas has a .plot API, which just takes your
Pandas data and you tell it a little bit of, like, this goes on the x-axis, this goes on
the y-axis.
I want to color by this variable.
And then it gives you the plot.
And we wanted to take that and kind of say, well, this works well for Pandas.
We want it to work for the entire pay data.
Right.
HV plot is meant to work not just with Pandas, but with Dask, X-Ray, NetworkX, Geopandas.
And the most recent addition there is QDFs.
So GPU data.
Yeah.
I haven't heard of QDF.
That sounds really cool.
But, like, Dask is very powerful.
And I had Matthew Rockland on the show to talk about that.
And it's like data.
That's what's important.
It's like Pandas.
Yeah.
It's like Pandas, but across multiple machines if necessary.
Sort of thing that has the same.
If necessary.
Or across multiple cores locally.
Yeah.
Lots of you.
Yeah.
Scaling up and out.
Yeah.
It's super cool.
And that's super nice, particularly because we have this data shader project.
It basically takes your data and you can describe it as like a fancy 2D histogram, right?
You get some basically heat map out.
But it does this really fast.
It's built on Numba and Dask.
So you can generate basically images from data points really quickly.
It doesn't just support point data.
It supports polygons.
It supports lines.
It supports re-grading of rasters and quad meshes and tri-meshes.
And basically it just takes your data, renders it with Numba and Dask.
Just put something on screen really, really quickly.
And the idea there is just to have fast and accurate rendering of large data sets.
And when we're talking large, that means millions or billions of dollars.
Yeah.
That's cool.
I think it was on your project where you've got a picture of, was it the US?
Yes.
Plotting every single person and where they were.
Right.
300 million data points.
Super quickly?
Yeah.
300 million data points a second or less.
And interactively zoom in and out.
I think particularly now that we have the app support, which basically NVIDIA has this new
initiative called Rapids, where they're rebuilding the PyData ecosystem on top of GPUs.
That's crazy.
It is crazy, but you couldn't always use.
Crazy awesome, yeah.
Yeah.
Like, yeah, exactly.
You used to have to write these CUDA kernels yourself, and it was really obscure.
But now it's, you just use your GPU and it just works.
So they had initial prototype for Data Shader, and our collaborator of ours called John Meese,
who normally is chief scientist at Botley, and took that and extended Data Shader to support
GPUs natively.
So now you can, like, it takes maybe 10, 20 milliseconds to aggregate these 300 million
data points.
Wow.
It's just incredible.
So cool.
And in theory, it's also scaled across multiple GPUs.
I haven't been able to try that.
Yeah.
I don't have access to that.
It never ceases to amazes me how powerful GPUs are.
Right.
Yes.
Every time I think, wow, it can do that, that's amazing.
And then it's like, nope, it could do more.
Exactly.
And yeah, it's kind of, for us, it's coming full circle, right?
GPUs, G and GPUs stands for graphical.
Yeah.
If you actually wanted to use it for graphical stuff or visualization stuff, there is basically,
well, you have to write your own kernels.
It would be super painful, but now it's possible.
All the hard work that you reference for actual people.
That's super cool.
Very, very cool.
All right.
So we've got hollow views and then related to that, the library, geo views.
You talked about HV plot.
Yes.
Talked about data shader.
This is what we were just talking about, quickly rendering like 200 million points on a map.
Talked about param as the basis for like the data class like functionality.
We also have color set.
Yes.
Color set is just, we all know that color maps can be crucial.
I don't know if everyone knows this, but I think the most famous example is the jets or rainbow color map.
That's been so divided for a good reason.
Basically, it distorts the data space terribly and you can draw all kinds of false conclusions just because in color space it can really distort things.
So there's actually scary stuff about potentially like doctors may have drawn false conclusions just by looking at the color maps.
That's jets in risk interpreting jets, which is easy to do.
So we created this package called color sets, which basically just has a set of, it's actually uniform color maps.
It actually takes work, I should have read up on this, but basically we took a set of color maps that someone had published a paper about and kind of published, draft those for the Python ecosystem.
And that became color set.
So please look at the website to look up the names.
I feel bad for not properly crediting the person here.
It's really handy to have that put together and well thought through and yeah.
Choosing colors, one, that look good and two, that are meaningful and not so easy.
Yes, it's not easy.
But I mean, thankfully the community has become really aware of this and there's a few packages like this now.
So it's just good to see that happen.
Particularly with like, I think the turning point was when the default column had not been not published, it's changed to very good.
I think at one point it actually was jet, wasn't it?
The final star of the show here is panel, which you talked about being that six to nine month project that you've got to work on new dashboarding tools.
Yeah.
So the Python ecosystem for a long time, R had Shiny and Shiny was great.
It's super cool.
It makes it easy to kind of share your analysis in R.
And Python didn't have this, right?
It had, there was, early on there was like this Jupyter dashboard project where you could take a Jupyter notebook and kind of arrange the cells a little bit and get a layout.
And we used that for a little while, but then it was abandoned.
But this was a problem that we kept coming back to.
People wanted to share their analyses without, as an actual dashboard or just a little app.
And so we decided to build panel.
Just before then actually, Plotly came out with this project called Dash, which is also a really nice, nice library to build dashboards in Python.
It requires a little bit more knowledge of CSS and JavaScript in certain cases.
And we wanted something where people could just drop in their analysis, their existing analysis.
You could drop it in.
You could wrap in a function and then annotate that, like, this function depends on these things.
And so when those things change, it updates kind of a reactive model.
And we just wanted a library where you drop in your existing analysis.
You've got some notebook.
You want to share it and reduce the friction of that, right?
That's what we kept seeing over and over again in different organizations was the fact that they had a bunch of data scientists.
And then they had a visualization team.
And the data scientists would produce some analysis.
And then they have to hand it over to the visualization team.
It didn't necessarily work in Python, right?
It could be.
We had some custom JavaScript framework or, yeah, there's just friction in making that transition from, let's say, Python analysis.
To shareable dashboard.
That process needed to become easier.
Right.
And that's how a panel emerged.
So a panel is a way where, yeah, you can basically lay out different parts of visualization.
And it's like organizing a notebook with not necessarily showing the code.
And you get some little sliders and other widgets that you can interact with that drive it.
And to me, it feels like just a really nice way to quickly take what you were already doing in exploratory mode and put it up in a user interactive way.
Without learning Flask, APIs, JavaScript.
This portion of Talk Python to me is brought to you by Datadog.
Are you having trouble visualizing bottlenecks and latency in your apps?
And you're not sure where the issue is coming from or how to solve it?
With Datadog's end-to-end monitoring platform, you can use their customizable built-in dashboard to collect metrics and visualize app performance in real time.
Datadog automatically correlates logs and traces at the level of individual requests, allowing you to quickly troubleshoot your Python application.
Plus, their service map automatically plots the flow of requests across your application architecture so you understand dependencies and can proactively monitor the performance of your apps.
Be the hero that got your app back on track at your company.
Get started today with a free trial at talkpython.fm/Datadog.
Precisely.
So, yeah, the idea is that, yeah, you just have your announcers, you drop them into this thing, you put it in a bunch of rails and columns, lay it out on your screen, and then you put one little command at the end of this thing.
You build the layout you have to build called servable.
And then you can run panels, serve the notebook, and it just pops up with your dashboard.
Nice.
How do you host it?
So, actually, it's just built on Bokeh, so it's just a Tornado server.
So you can just host it on any of the cloud server providers.
We are trying to kind of build out our documentation to make that a really simple process.
Or even thinking about having a command to say, I'm going to deploy this to AWS or to Google Cloud or whatever.
Right, right.
But, yeah, that's still areas we're actually working on.
But in the end, it's just...
What about like a container?
Oh, absolutely.
Oh, yes.
Yeah.
That's...
Yeah.
For our examples, we have...
We build on this tool called Anaconda Project.
It wraps a conda environment with some commands, and then it deploys it.
And what we're hoping for is that...
I think there's a PR, or maybe it's already merged, where you basically just give it this project file,
which is just a YAML file with the environment and these commands that it runs.
And then it builds a Docker container for you.
So I think that that's a really nice route to go.
Just to kind of contain everything, your entire environment,
and the commands you need to run, and then you just get it.
Yeah.
Maybe even go to like some kind of hosted Kubernetes cluster service.
Just go take this, run it there, make sure it keeps running, upgrade it for me if I need it.
Yes.
But we're certainly looking for...
So if anyone's interested in helping us out with our friends, we're always looking for contributors.
Yeah.
Sure.
But otherwise, yeah, we're also working on including documentation.
Yeah.
It's a bit of an orthogonal problem and skill set to solving visualization, right?
Like, it's one thing exactly through the JavaScript.
Cool visualization is another to like, well, now I do DevOps too.
Exactly right, yeah.
Although it's something, I mean, it's a good skill to learn, so I'm happy to dive into it a little bit.
Yeah.
Yeah, absolutely.
So on your website, I think it's into the getting started section, so at holoviz, H-O-L-O-V-I-Z.org,
you've got a document that sort of talks about, given these different scenarios, more of a picture, I guess,
answer a couple of questions about it, and we'll help you choose the subset of tools to kind of flow this together, right?
Right.
You want to maybe talk us through some of these scenarios?
So it says, are you working with tabular data, working with like other types of arrays, network,
n-dimensional, or streaming data?
And then there's like sort of this flow of like, all right, here's how you piece together these tools
to come up with something excellent.
Yes.
So we call this the mermaid diagram.
And yeah, if you look at holoviz.org, you'll find it there.
I actually don't know why it's called the mermaid diagram, but there we go.
But yeah, the general idea is that it takes you from the type of data, as we said.
So let's say you've got some tabular data, and now you need to decide, like, what library should I choose to load this data?
So you might, below a certain threshold, pandas is totally fine.
And if you want to go to geographic data, use geopandas, or actually geometries.
Geographic geometries, use geopandas.
Right.
And just so people know, yeah, and you're cut off here, you say, do you have more than 50,000 rows?
I mean, obviously, it varies a little bit on the computer you have.
Yeah, that's pretty arbitrary.
Yeah, exactly.
But it gives you a kind of a sense.
It's not millions of rows or billions or something like that, right?
It's not that high of a number to say, okay, well, maybe you want to consider something other than pandas for working on some of this.
But yeah, okay.
Is it a huge amount of data?
By some definition, a huge.
And if not, is it geospatial?
Precisely.
And then you might use geopandas.
Otherwise, you may use Dask, for example, instead.
So Dask is a really great tool.
We've already mentioned time to load.
You've got millions or billions of rows, and you just want to, you can't load it all into memory.
You just don't have the space.
And you want to build a Dask.
And then the whole point behind our ecosystem, particularly HBplot, is you shouldn't have to change any code.
Whether you choose pandas or Dask or now the QDF library, you shouldn't have to change any code.
You should just be able to dump your data into this framework and then call .heplot on it, and then you get your plot out.
So that's kind of the philosophy here.
The same applies to, like, you've got some n-dimensional arrays.
We generally recommend, for example, that you go with X-Array.
So X-Array is really underrated as a library.
It should be more popular.
I don't know, maybe not that many people have, like, n-dimensional arrays, but it's kind of pandas for n-dimensional arrays.
Yeah, for beyond tabular.
Beyond tabular, exactly, yeah.
So you've got, I don't know, you've got satellite imagery over time, right, or satellite.
Right.
Or microscope data also over time, like, or Z-Stack over time, like, four-dimensional, five-dimensional, whatever.
Okay.
For that, it's just really nice to explore it that way.
So for that kind of data, you might use that instead.
Or you might keep it simple and just use NumPy or DaskArrays, which kind of is a lower local.
But in the end, the idea is that, yeah, in any case, you just drop it into HBplot with the .plot call, and then you get this whole of these objects out of it.
And this whole of these objects will already display itself, so you already have an interactive plot.
But then you might have the issue, like, yeah, this was a lot of data.
We used a DaskDataFrame for a reason.
Right.
Or a DaskArray.
So you may not want to dump it straight into your browser.
Jumping a gigabyte to your browser is a surefire way to crash it.
Even with the speed to download it quickly, you know, that much JavaScript is going to make it hurt.
Yeah.
It's really going to make it hurt, yeah.
So that's, like, then you just have the option to HBplot to say, data shape this instead.
And so that means that you've got server-side aggregation to kind of aggregate this data as you're zooming around.
And what you get out is a nice interactive Bokeh plot using HBplot.
Or if you kind of want to do a bit more customization, HBplot actually doesn't directly support Bottley or Mouthable output, but with a little bit of it, you can get there, too.
And then once you're there, you can save it, you can share your notebook, or you can dump it into panel and do it.
Right, right.
Turn it into a dashboard.
Okay.
Yeah, very cool.
I'll link to this flowchart for people over so they can think about it when they're checking this out.
And I think it also gives you a sense of, even outside of HoloViz, there's useful stuff.
You're like, do I have streaming data?
Maybe check out StreamZ or N-Dimensional, like you said, check out X-Ray and Dask.
And just this idea of, like, how do I think about the right underlying library rather than trying to jam everything into Pandas or NumPy or something.
Right, yes.
Yeah, a lot of people, I still see, like, 2D in Pandas and really, yeah, try to switch to X-Ray.
It's a great library.
And actually, Pandas used to have this N-Dimensional data structure called a panel, and they've actually deprecated that saying, yes, please just use X-Ray.
That's what it's made for.
I see.
Okay.
Interesting.
I didn't realize that.
When you talked about visualizing millions and millions of data points quickly in the browser, you said, okay, we're going to use Data Shader.
And I don't know that we necessarily dove into it enough to say exactly what it does.
So basically, let me see if I get it right how it works.
It can look at millions, hundreds of millions of data points and say, well, the size of the graph is really this.
And if you look at these 10,000 at this scale, that's kind of going to be the same.
Is that how it works?
Or is it, like, does it downsample somehow?
Or how does it actually make meaningful pictures or a process of that?
That's the cool thing about it.
So it actually is that fast, right?
It actually, it always looks at all your data.
Okay.
But if you're zoomed into something, obviously it won't.
If it's out of your report.
Yeah, yeah, yeah.
If it zooms in, like, it has the clipping outside the rectangle.
But if you're zoomed out, it actually does iterate over your entire building data points and aggregates them within 50, 100 milliseconds.
Does that happen on the server, right?
Exactly.
It doesn't have the browser, right?
Exactly.
That happens on the server.
And then all it has to do is send the image of the aggregated data, which, or if you have 10 million points or a billion points,
then a thousand by thousand pixel image is going to be much, much smaller than the actual whole data set.
Yeah, yeah.
Absolutely.
Yeah.
That's basically the same size, no matter how much data you have.
Exactly.
Yes.
Compression a little bit, but not so much.
Yeah.
Exactly.
So, yeah, you get a fixed size image out of it.
And that works with most visual elements.
We've kind of been expanding to visual elements.
When DataShare was first created, I think it aggregated point data and line data.
But now it kind of expanded to cover polygons, tri-meshes, quad-meshes, just downsampling images as you're zooming.
So if you've got a huge, like, one gigapixel image, you can dump it into DataShader.
It'll downsample it dynamically.
So you can zoom in panel rounds and export.
Yeah, that's great.
And looking at it, it says that it has scalability with Dask or QDF.
Mm-hmm.
QDF.
How do you configure it to make it choose one or the other on the server?
If you have a Dask data frame, it'll just take that.
It'll take that.
And basically, the way a Dask data frame works is basically you should think of it as a bunch of chunks of underlying Pandas data frames, right?
And these chunks might be distributed across, like, it might be on your machine, or it might be across, like, a whole cluster of machines.
And so it just keeps the computation local.
It means that the aggregation for each of those chunks happens on that particular node in your cluster.
And then once it's done the aggregation, it just has to send the fixed-size image back to the main node to aggregate that.
And so that way, you can distribute the computation, but still have it available for virtualization.
Okay, so what you provide to the DataShader basically tells it how to process it.
Do you give it a Pandas data frame?
Do you give it a Das data frame?
Do you give it a QDF frame?
And it just goes, and it just knows how to work with all of them, but that implies how it's computed.
Yes, so those three in particular are, yeah.
Got it, okay, now I see.
So we actually, on DataShader.org, if you look at, I think, one of the user guides or sorting guides,
there's a nice handy little table to show you, like, for this data type, like, for point data, these data backends are supported.
And for points, for example, it might be Pandas, Dask, and Pudia.
But for an image, it might be X-Ray only, because it doesn't really make sense to show your image into Pandas.
Yeah, exactly.
Cool.
Well, it seems like a really nice way to fit all these things together, and just such a great API.
Maybe we could talk about some of the projects or communities that are using all of this.
Oh, absolutely.
One ecosystem that's really taken up these goals, particularly HVPot and DataShader, is the Pangeo initiative,
which is basically, it's an initiative by various geoscience folks to build, like, this big data platform to analyze data in the cloud, right?
So you used to have all these different data silos where, like, you have this data in the cloud, you have to download it onto your local machine and explore it.
And they've been building, basically, a platform so you can easily deploy your own JupyterHub and then keep your data in the cloud, but analyze it also in the cloud, right?
And so for these people, so there might be climatologists, there's a lot of climatologists or oceanographers.
Can I say that word?
Oceanographers.
Oceanographers, that's right.
And they have these huge data sets, right?
They have huge meshes of data, and they need to do them.
But they weren't really cool to do that.
And thanks to all these open-source tools like Dask, you can load the data from the cloud, aggregate it using DataShader, and kind of zoom and pan interactively around without having to kind of download the data.
So Pangeo is a really great use of it and makes me super happy to see climatologists actually use these tools.
Yeah, solving some real problems.
That's awesome.
Also, Intake.
What's that?
Intake.
Oh, that's a really interesting project.
So again, actually, this is also leveraged by the Pantheon community.
So Intake is a project.
If you've ever had to, like, you have a bunch of data sources, and you have data catalogs, and if you want to keep track of all your data, you want to not have custom scripts to load this kind of data and that kind of data, Intake lets you write one catalog data catalog, which is really just a YAML file to specify.
I've got the CSV files here, and there's 10,000 of them, and I'll load them somehow.
And then I've got this netcdf file there, and I've got a bunch of parquet files here.
You can kind of encapsulate it all in this nice little data catalog, load it, and then I explore it.
And so in the notebook, literally, you just point it to your catalog and say, load this, and thanks to the specification in that YAML file, it'll just load it.
And that has integration with our tools in a number of ways.
So first of all, you can even put your HB plot spec into your data catalog.
So you can say, I have this default plot that I always look at for this data, right?
So you can say, in this data source, plot the X column, point at the longitudes in this CSV file, longitudes and latitudes, and then it'll automatically generate your plot.
You kind of pre-declared your plots in this catalog file.
I see.
Okay.
Yeah, that's super cool.
Another thing it has, it has a little GUI built on top of a panel, which kind of lets you explore the data, right?
You've already got your data, and now you can just, by a graphical interface, kind of click around and say, I want to plot this column against this column and color it by that.
Cool.
So you specify how to import it and whatnot, and then visualize it.
That's great.
Yeah.
And then what's QCrossFilter?
So I only recently found out about this.
So NVIDIA, as I said, has this Rapids initiative, and they've been playing around with visualization.
in various forms.
And interestingly, they built this QCrossFilter library, which kind of builds on top of panel and bokeh to build cross-filturing applications.
Kind of, okay, just cross-filturing.
It's also referred to as loop brushing.
So you select something on one plot, and kind of you see that reflecting on other plots.
And that's built on panel, and basically lets you build dashboards, like cross-filturing stuff.
They're easily using GPU.
Super cool.
And then some space stuff as well.
These are actually projects that there's consulting clients we've worked with.
So one of them is the LSST telescope.
I think it's recently actually got a real name, which is the Vera Rubin telescope.
It's one of the largest optical telescope in the world.
And they basically approached me saying they wanted to do some Q&A on the data that comes out of this telescope.
Right?
This telescope.
And there's huge amounts of data.
There's terabytes a day.
It can be challenging because they have 50 petabytes of images and data they're going to be collecting and stuff.
And yeah, it's challenging to go through.
Yes.
Particularly, yeah.
If you have to do the same analysis every day, then you can have a tool that can handle this stuff.
And so I handed over this project to QuantSite.
So our famous Travis Oliphant, who is our former CEO, went off and started this other consulting firm called QuantSite.
And I handed over this project to them.
And they've been kind of a bit of help for me, but not very much.
They've built this really nice dashboard to kind of do the Q&A stuff for them.
And yeah, easily it will handle 500 petabytes.
But maybe it'll need some more clicking to quite get there.
Yeah.
But still, that's pretty impressive.
That's awesome.
And it's cool to see all of these projects using the libraries you guys put together.
They're probably giving it some pretty serious testing.
Oh, absolutely.
Testing and standard data science.
Yeah.
And they'll absolutely find all the little performance issues.
And yeah, it's great.
That's actually the best part of my job.
I don't just building open-source tools is awesome.
But really, if you're completely divorced from the actual users of those libraries, it's really hard to tell.
Are you doing the right thing or are you just wasting your time?
So it's super nice to go back and forth between actual consulting where you see people's problems and then going back to the tool and kind of improving it.
Absolutely.
Yeah, you need this blend to keep it real.
But if you're too focused on just solving problems for consulting, you don't get that spare time to develop new stuff as much.
Yeah.
I want to close the conversation out with two quick things.
One, I really like to explore things like this, like visual play analysis type of libraries and whatnot by just looking at some examples because usually you can look at some nice pictures and get a quick sense.
So you guys have a bunch of different tutorials or simple little examples, expositions, showing them off.
Maybe is there like a couple of favorites you just want to point people out and tell them what it does?
Oh, absolutely.
Yeah.
I don't know how best to do this.
So what we can do is, so most of our websites, particularly for like hollow views and geoviews and panel, we have a little gallery.
So maybe we can look at some of those.
But then we also have this website, examples.privates.org, which really we want contributing to the content of these articles.
Again, privates can not be this general thing.
So if people are interested in contributing their own examples.
Yeah.
Just grab a couple that you think are like really cool and show off stuff people would appreciate.
Yeah.
So let's go with the one that you talked about earlier, the census example.
So if you go to examples.privates.org.
Just search for census.
It'll be right on the main page, right?
There's like a little gallery.
And then if you click on that, there's at the top right, there's the census example, which kind of explores how do I use.
Yeah.
I've got this census dataset.
How do I actually display it?
It's like start exploring it.
So it starts off by kind of loading the dataset.
We just load it in this case with a library called, well, and in fact, it's just loaded with Dask.
But we've got this little wrapper around Dask, which does spatial indexing.
So spatial indexing means that it has built an index of the space.
It's with the term, it's an archery.
It's super fast to say, show me the things that are near here or are right here.
Precisely.
Yes.
So if you're zooming in and no longer, as I talked about earlier, by default, DataShader has to scan through the entire dataset each time, even if you're zoomed in to just a little spot.
With spatial indexing, you can say, okay, this stuff is definitely not in my viewport.
I don't need to consider it.
And so it becomes faster as you zoom in.
Right.
If you look at that notebook, you kind of start by loading the dataset, data shading it, and we start with just simple linear aggregation.
And what you'll immediately notice is that it's just black.
If you think about the population in the US, there's a few hotspots, but New York is super dense.
All the cities are kind of dense, but New York is particularly dense.
And so all you see with linear color mapping is basically New York and then a few kind of blurry cities.
A little bit of LA, a little bit of Chicago.
That's about it.
Yeah.
And so the nice thing about DataShader is that it kind of takes away that you can do linear, you can do log, or you can kind of adjust the color map.
And that's all kind of difficult.
But by default, DataShader actually does something called EQHist, which is histogram equalization, which means that it kind of adjusts the histogram of the color map in such a way that the lowest number of...
It's hard to explain.
But it kind of equalizes the color map in such a way that actually...
It's a picture over audio only.
Yeah, it's a hard one.
But basically it reveals the shape of your data, if not the exact values.
So you shouldn't use it for reading out the exact values of something, but to get an overall idea of something, it's a really nice mechanism.
And that kind of is part of what makes like...
If you look at the DataShader image, or you like...
Sometimes on Twitter, I'll see like an image, and it just pops.
And that's the EQHistogramming color section.
Makes sure that you see the overall shape of your data, not the exact values.
And this kind of goes through that example, goes through that, and kind of explains what does this actually do.
So in the census data, you can see the shape of each city now.
You can see kind of a lot of the non-inotonous area in the west of the U.S.
It's kind of empty.
And yeah, it really reveals like the population distribution in the U.S.
And then it also kind of demonstrates how to manipulate your color map to kind of show the hot spots, especially.
So you can kind of...
Because you've now aggregated into a fixed-dice image, you can say values above this density, you call it in red.
And so you really get the cities to pop out.
Yeah, very cool.
And then maybe I won't go into too much detail on this one anymore, but do check it out.
Sure, sure.
But it really builds up.
People can check it out.
I'll link to it.
And each one of these steps like builds up with just like a line or two of code.
It's not super complicated.
Exactly right, yeah.
And then we kind of explore kind of depressing facts.
So this dataset has basically the race of all the individual people.
And you can really see the segregation in different cities.
It's horrible to think about.
Yeah, that's not good.
Yeah, it really reveals the fact if you look at it.
Wow.
Yeah, I see.
And then finally, it rounds out with like showing you how to...
Because our tools are meant to work well together, the final example kind of demonstrates how
to take this data and use HoloViews to generate an interactive plot where if it was running on
a server, so on the website, you're not going to be able to zoom very much, kind of gets very pixelated.
But if you're running it on your own in a notebook yourself, or you deploy it to a server panel, for example, then you can zoom around and pan and zoom into individual people.
Yeah, wow.
Yeah.
Wow.
That's wild.
Yeah.
So maybe there's a whole bunch of examples over at examples.pyviz.org.
And each one of the examples is tagged with the various libraries that people might want to explore.
So there's a bunch here.
People can just go there and dig into them and check it out.
And this is just one of them.
Yeah.
And we're trying to keep those up to date.
And if you build a cool thing, please submit it.
Yeah.
Awesome.
All right.
I guess maybe you could just touch really quick on awesome-panel.org and then tell us what's next with the whole project and probably be out of time then.
I've been super happy to see.
So community building is hard.
And I think many open source developers realize this.
And we're definitely still learning.
But there's been quite a lot of interest in panel.
And Mark Skroth-Matson, who works in Denmark, built this website called awesomepanel.org,
which really kind of tries to show off what you can build with panel.
So our examples kind of try to focus on the simpler stuff.
But awesomepanel really shows you what you can do.
And it's really impressive what he's done with panel on awesomepanel.org.
Has lots of resources for how to best leverage things.
And a lot of stuff, ideally, would migrate back to our website.
But yeah, he's built this complex multi-page site, which takes you through a lot of different ways of using panel and has a lot of examples.
Yeah.
Cool.
It's kind of meta, right?
Like panels involved in it as well?
Oh, yeah.
It's built on panel, right?
A website that's built entirely in panel.
About panel.
But also about panel.
And yeah, I've been trying to take that further as well.
So recently, I did a talk for our AnacondaCon, which is our conference here at Anaconda.
And I built the entire presentation.
I built a presentation tool on top of panel.
Demo panel.
Yeah.
Awesome.
Very, very cool.
All right.
So what's next with the whole project?
Where are you guys going?
So one thing that we've kind of been working on recently a lot is in terms of HoloViews is we've added link selections.
So you can now, in the spirit of shortcuts, not dead ends, you can generate your HoloView plots.
And if they're all using the same data, you can just say link selections, apply it to these various components.
And then it will automatically hook up all the linking between the plots so that when you select on one, all the other ones update.
I'm really excited about that.
It makes it super easy to build a complex dashboard.
Yeah, that's super cool.
Unless you dive into the data.
Yeah.
Cool.
And particularly with the GPU support now, you can build like, yeah.
With GPU support and data shader, you can now like explore tens of millions or billions of data points using link selections.
It's really easy.
It's super cool.
That's one thing I'm excited about.
Okay.
Another thing in terms of panel ecosystem I'm excited about is the next release is going to have default templates.
And so what that means is panels always have the ability to kind of just put stuff together.
You say this thing goes in a row with this thing, like a bunch of widgets go in a row or a column.
And then you put plot here.
But if you want to have more control, you kind of have to write your own kind of HTML and CSS to lay things out.
And you have that ability, you do templates.
But the next release is going to...
You might not want to exercise it.
Yeah.
So yeah, that's what we're trying to keep people from, right?
We don't want people to have to do that kind of thing.
So what we've done now is added some default templates where you basically say, I want this to go in the sidebar.
I want to do this to go in the header.
I want this to go in the main area.
And it looks like a polished website.
It's not just a bunch of things on the webpage.
It's actually a nice looking thing.
So I'm also really excited about that because I think that's something that's been missing.
So we've had a lot of cool little demos, but it's like to build a whole nice polished looking dashboard.
Yeah, a little more control.
And that's kind of bridge that gap.
And then the last thing I'm really excited about in this next release of the panel is integrating the other ecosystems.
So if you're familiar with Jupyter, you'll know about IPI widgets.
And IPI widgets has been like lots of lives have now built on top of Jupyter widgets to kind of, I don't know, there's things like IPI volumes, explore 3D volumes.
There's just a whole bunch of lives, right?
And it's kind of been a shame that we don't want to have divergent ecosystems, right?
And so in this next release, we're going to be able to just put your IPI widget into your panel app or even your Bokey app.
So this has been done at the Bokey level since we've built on Bokey.
You just dump it in there and it's just feeding on the deployed tornado server or the Bokey server.
It'll just work and load the feature to your widgets correctly and hook up all the communication for you.
And so now we don't have these two divergent ecosystems anymore.
You can just use IPI widgets in panel or you can go the other way and kind of say,
well, we've got this deployment system and there's this library called Volal, which kind of serves Jupyter Notebooks as well.
And so you can now put your panel app into Volal and just serve that.
You just make sure that ecosystems don't diverge and you can use the tools that you want.
Yeah, that's nice.
Because you don't want to have to have a separate set of widgets for your visualizations.
And then people also building them for Jupyter, of course, they would build them for there.
Right.
So might as well just bring these together.
Exactly.
So it's been a long effort.
And there's still, I'm sure, some issues to find out.
But super good to be able to shift that.
Yeah.
All right.
Well, very cool.
Great project.
Great examples.
And it looks like you got a lot of momentum going forward as well.
So thanks for bringing all of your experience and talking about what you guys have built there.
Thanks so much for having me.
It's been really great to talk about this stuff.
Yeah, you bet.
Before we get out of here, though, you've got to answer the final two questions.
If you're going to write some Python code, what editor do you use?
Oh, I'm still on Emacs.
My professor is now my boss at Anaconda hooked me and I'm still there.
Although I do dabble in Gears Code now.
Yeah, very cool.
And probably some Jupyter as well at some point.
Yes.
I always have like four JupyterLab tabs open and then Emacs on the side.
Yeah, cool.
And then notable PyPI package.
You got a bunch here already.
It's worth saying you can just pip install HoloViz.
Oh, there's a bunch.
But yeah, I think I've already.
Yeah, you can pip install HoloViz, which is kind of a good tutorial.
But I really want to take this opportunity to plug some of the underlying libraries.
I think X-Ray is awesome.
I've already mentioned this.
And Dask is awesome.
So I really want to plug those.
I agree.
All right.
Very cool.
So people are excited about HoloViz.
Sounds like it really might solve the problem or help them build some dashboards.
Final Call to Action.
What can they do?
Come visit us at HoloViz.org.
There's a tutorial that will take you through the initial steps of using our projects and
finally let you build a whole dashboard.
So go there, check that out.
Also, check out examples.pipiz.org to see what you can do if you master this stuff to build
more complex examples.
And then message me on Twitter or message our individual projects like HoloViz or panel on
Twitter.
And if you've got any longer form questions, join us on our discourse, which is at discourse.holoviz.org.
Super.
All right.
Well, it looks like a great project.
And I think people build cool things with it.
So thanks for sharing it with us.
Awesome.
Thanks again.
You bet.
Bye.
This has been another episode of Talk Python to Me.
Our guest on this episode has been Philip Rudiger and it's been brought to you by Brilliant.org
and Datadog.
Brilliant.org encourages you to level up your analytical skills and knowledge.
Visit talkpython.fm/brilliant and get Brilliant Premium to learn something new every
day.
Datadog gives you visibility into the whole system running your code.
Visit talkpython.fm/datadog and see what you've been missing.
Go throw in a free t-shirt with your free trial.
Want to level up your Python?
If you're just getting started, try my Python Jumpstart by Building 10 Apps course.
Or if you're looking for something more advanced, check out our new async course that digs into
all the different types of async programming you can do in Python.
And of course, if you're interested in more than one of these, be sure to check out our
Everything Bundle.
It's like a subscription that never expires.
Be sure to subscribe to the show.
Open your favorite podcatcher 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.
This is your host, Michael Kennedy.
Thanks so much for listening.
I really appreciate it.
Now get out there and write some Python code.
Thank you.
Bye.
Thank you.