WEBVTT

00:00:00.140 --> 00:00:04.200
Are you using interactive notebooks for your data exploration or your day-to-day programming?

00:00:04.200 --> 00:00:06.080
What environments do you use?

00:00:06.080 --> 00:00:08.440
Was it Jupyter and now you've made your way over to JupyterLab?

00:00:08.440 --> 00:00:13.540
That's a great choice, but did you know there are more environments out there to choose from and to compare?

00:00:13.540 --> 00:00:15.880
Have you heard of Callisto or Iodide?

00:00:15.880 --> 00:00:17.780
How about CoCalc or PolyNote?

00:00:17.780 --> 00:00:19.940
Those are just the tip of the iceberg.

00:00:19.940 --> 00:00:24.260
That's why I'm happy to have Sam Lau and Philip Guo here to share their research,

00:00:24.260 --> 00:00:27.380
comparing and categorizing over 60 notebook environments.

00:00:27.740 --> 00:00:32.400
This is Talk Python To Me, episode 268, recorded June 11th, 2020.

00:00:32.400 --> 00:00:52.020
Welcome to Talk Python To Me, a weekly podcast on Python, the language, the libraries, the ecosystem, and the personalities.

00:00:52.020 --> 00:00:53.960
This is your host, Michael Kennedy.

00:00:53.960 --> 00:00:56.080
Follow me on Twitter where I'm @mkennedy.

00:00:56.280 --> 00:01:02.280
Keep up with the show and listen to past episodes at talkpython.fm and follow the show on Twitter via at Talk Python.

00:01:02.280 --> 00:01:05.520
This episode is brought to you by Linode and Sentry.

00:01:05.520 --> 00:01:07.680
Please check out what they're offering during their segments.

00:01:07.680 --> 00:01:09.320
It really helps support the show.

00:01:09.320 --> 00:01:12.080
Sam and Philip, welcome to Talk Python To Me.

00:01:12.080 --> 00:01:12.960
Pleasure to be here.

00:01:12.960 --> 00:01:13.600
Same here.

00:01:13.600 --> 00:01:15.360
Yeah, nice to have you on the show, Sam.

00:01:15.360 --> 00:01:16.640
Philip, welcome back.

00:01:16.640 --> 00:01:17.980
You've been on the show a few times.

00:01:18.200 --> 00:01:23.880
You were one of the very first guests way back when, diving into the CPython source code internals.

00:01:23.880 --> 00:01:32.420
And then we've talked about a bunch of fun topics, you know, coding in your golden years and maintaining open source projects individually and things like that.

00:01:32.420 --> 00:01:34.660
It's been a lot of fun to have you on the show and nice to have you back.

00:01:34.660 --> 00:01:35.700
Yeah, it's great to be back.

00:01:35.800 --> 00:01:38.360
And yeah, that was my first ever podcast with you.

00:01:38.360 --> 00:01:40.480
That was, I think, almost five years ago.

00:01:40.480 --> 00:01:43.220
It's good to be back as a podcast veteran now.

00:01:43.220 --> 00:01:44.040
That's right.

00:01:44.040 --> 00:01:44.820
You know the whole deal.

00:01:44.820 --> 00:01:46.640
And Sam, welcome to the show.

00:01:46.640 --> 00:01:52.880
Before we get to the main topic, I always like to set the stage for where the guests are coming from.

00:01:52.960 --> 00:02:02.920
So when somebody says, you know, like, I think you should really do this, like, they might say that because they're a biologist using Python, not a person running Facebook or the other way around, right?

00:02:02.920 --> 00:02:06.620
So maybe just tell us really quickly about your background and how you got into Python.

00:02:06.620 --> 00:02:15.840
My background in Python came from, actually, back in high school, I ran into the first wave of, like, massive open online courses.

00:02:15.840 --> 00:02:17.400
Right.

00:02:17.400 --> 00:02:18.440
Right.

00:02:18.440 --> 00:02:22.580
And so, like, at my school, there wasn't much emphasis on programming much at all.

00:02:23.100 --> 00:02:36.900
And so when I ran into, when I found out about those courses, I got really into it and decided to major in computer science at UC Berkeley and then ended up doing, ended up starting this PhD at UCSD with Philip studying cognitive science.

00:02:36.900 --> 00:02:38.300
Cognitive science is really interesting.

00:02:38.300 --> 00:02:40.520
I've talked to a few folks from there.

00:02:40.520 --> 00:02:46.120
There's a lot of interesting computational CS type problems happening in cognitive science.

00:02:46.120 --> 00:02:46.380
Yeah.

00:02:46.380 --> 00:02:47.420
And data science as well.

00:02:47.420 --> 00:02:47.840
Absolutely.

00:02:48.280 --> 00:02:55.960
I worked for a while at a company that was basically a spinoff from a research lab that was a bunch of cognitive science PhDs.

00:02:55.960 --> 00:02:58.440
And we did all sorts of cool stuff with eye tracking and programming.

00:02:58.440 --> 00:02:59.940
And, man, it's just a lot of fun.

00:02:59.940 --> 00:03:01.380
I really enjoyed my time in that space.

00:03:01.380 --> 00:03:01.660
Yeah.

00:03:01.660 --> 00:03:07.880
People here are, cognitive science is so broad that you have people here using programming for all sorts of tasks.

00:03:07.880 --> 00:03:18.960
Like, we have people here training deep neural networks, but also people studying fMRI signals and processing those and working with neuroimaging.

00:03:18.960 --> 00:03:23.580
And so you just get a really diverse, broad range of perspectives and uses for Python.

00:03:23.580 --> 00:03:23.920
Yeah.

00:03:23.920 --> 00:03:26.820
It's interesting, too, because I feel like there's still a lot of open questions.

00:03:26.820 --> 00:03:27.140
Yeah.

00:03:27.140 --> 00:03:28.200
There's a lot we don't know.

00:03:28.260 --> 00:03:31.720
And it feels like the more we know, the more we know about what we don't know.

00:03:31.720 --> 00:03:33.620
Yeah, exactly.

00:03:33.620 --> 00:03:36.340
Every answer opens up to more questions.

00:03:36.340 --> 00:03:36.720
That's right.

00:03:36.720 --> 00:03:37.140
Exactly.

00:03:37.140 --> 00:03:37.600
All right.

00:03:37.600 --> 00:03:48.680
Well, we're going to talk today about the research that two of you have done in the space of notebooks, as in computational notebooks, Jupyter notebooks, that type of thing.

00:03:48.680 --> 00:03:53.240
And it turns out, actually, there's more than just IPython and Jupyter, right?

00:03:53.240 --> 00:03:54.560
Quite a few more.

00:03:54.560 --> 00:03:55.160
Yeah.

00:03:55.160 --> 00:04:03.560
So in our paper, we talk about a total of 60 different notebook systems that we put together and try to draw out some patterns from.

00:04:03.560 --> 00:04:04.400
Yeah, it's really interesting.

00:04:04.400 --> 00:04:12.600
I mean, people, I think Jupyter, IPython, when it was first started, became Jupyter, really changed the way people thought about programming.

00:04:12.600 --> 00:04:13.860
I mean, there were tools like this.

00:04:13.860 --> 00:04:17.560
Maybe you guys can throw out some that felt kind of like that.

00:04:17.560 --> 00:04:24.540
So when I say that, the one that comes most to mind is, I think, Mathematica or Maple, right?

00:04:24.540 --> 00:04:36.380
They're really beautifully visual, but then they also had computation, but they also had like output, you know, MATLAB, but MATLAB's not quite as pretty, for whatever reason, more utilitarian, I guess.

00:04:36.380 --> 00:04:46.380
And when you thought about programming, that was, you know, maybe if you're trying to emulate that, it would be a script, and then it would like output some stuff, or it would pop up a window, it'd save like a JPEG or something.

00:04:46.380 --> 00:04:49.700
But the notebooks really brought those two worlds together.

00:04:49.700 --> 00:04:57.380
Say, look, you can write code in a, like a pro programming language in a way that you really would use like libraries and stuff that are not just baked into these tools.

00:04:57.380 --> 00:05:00.240
But then they have this kind of interactive world.

00:05:00.240 --> 00:05:04.420
I think it's really interesting to see all these derivative concepts, right?

00:05:04.460 --> 00:05:10.040
We've got Jupyter that had its way of doing things, but there's challenges there, and there's a lot of variation.

00:05:10.040 --> 00:05:13.340
Like, were you surprised to find this many different systems around?

00:05:13.340 --> 00:05:14.460
I certainly was.

00:05:14.460 --> 00:05:21.260
I think I came into this project thinking, oh, it's probably just Jupyter plus like maybe three or four other systems.

00:05:21.920 --> 00:05:25.900
And I think the deeper we went, the more we were like, whoa.

00:05:25.900 --> 00:05:35.900
People are really taking Jupyter and changing it, adding new things to it, making it fit their use case more effectively.

00:05:36.380 --> 00:05:45.600
And there's a lot of, it turns out that there's a lot of different groups studying Jupyter and notebook systems in general and trying to figure out how they can make it better for themselves.

00:05:45.840 --> 00:05:50.860
Yeah, I think I'd just add to that, to what Sam said, was that, you know, we started this project.

00:05:50.860 --> 00:05:59.480
So this is, this paper is co-authored by Sam, one of my other PhD students, Androsos, one of my undergrad students, Julia Markle, and myself.

00:05:59.480 --> 00:06:04.440
And we basically just kind of split up the work and just went to find a lot of these notebook systems.

00:06:04.440 --> 00:06:15.900
And the motivation for this was that, you know, in the academic literature, in the kind of academic world of studying programming tools, in the past few years, there's been a lot of people studying how people use notebooks.

00:06:15.900 --> 00:06:19.240
I believe Adam Rule was on your podcast, Michael, was Adam?

00:06:19.240 --> 00:06:21.000
It sounds familiar.

00:06:21.000 --> 00:06:25.720
Yeah, he was about the Jupyter, the, you know, analyzing the million Jupyter notebooks.

00:06:25.720 --> 00:06:26.620
Yes, that's right.

00:06:26.620 --> 00:06:27.080
Yeah, that's right.

00:06:27.080 --> 00:06:27.280
Yeah.

00:06:27.280 --> 00:06:33.600
So there's a bunch of studies around Jupyter notebooks and how people use them for science and stuff, and then people developing new prototypes.

00:06:34.240 --> 00:06:40.380
And at the same time, there's a bunch of industry people, you know, every startup company is like, we're going to do a notebook, we're going to do this other notebook, this other notebook.

00:06:40.380 --> 00:06:41.880
So it became like this wild west.

00:06:41.880 --> 00:06:44.740
That's right. Google CoLab, DataLore, Azure notebooks, all those, yeah.

00:06:44.740 --> 00:06:51.660
Yeah, so it became like this wild west, and we felt it was around time for this sort of what we call a survey paper or a meta-analysis, right?

00:06:51.660 --> 00:07:03.640
It's like, this paper is not doing original research in that we're not making a new notebook, but we are collecting together dozens of these notebooks from both academic prototypes and also industry products and trying to, like,

00:07:04.040 --> 00:07:06.860
analyze them and see, you know, how does this space fit together?

00:07:06.860 --> 00:07:12.660
So I got a few of my students together, and we kind of brainstormed and looked for a lot of notebooks and stuff.

00:07:12.660 --> 00:07:17.680
And then Sam, who is the first author on this, kind of, you know, did a lot of the leadership on this work.

00:07:17.680 --> 00:07:22.760
So I'll let him talk more about the details, because I forgot all the details, so I just delegate them.

00:07:22.760 --> 00:07:22.860
Yeah, sure.

00:07:22.860 --> 00:07:26.400
Yeah, and your primary research is in human-computer interaction?

00:07:26.580 --> 00:07:27.080
Right, right.

00:07:27.080 --> 00:07:31.760
So my primary research area that my students are in is called HCI, or human-computer interaction.

00:07:31.760 --> 00:07:36.800
And the kind of industry term for this is, you know, people know it as UX design, right?

00:07:36.800 --> 00:07:39.160
User experience design, user interface design.

00:07:39.160 --> 00:07:49.740
And, you know, HCI, or human-computer interaction, is sort of the academic term for the research that goes into how do you make better user experiences for, you know, different kinds of users.

00:07:49.800 --> 00:07:52.900
In this case, it's for scientific programmers and data scientists.

00:07:52.900 --> 00:07:53.260
Yeah.

00:07:53.260 --> 00:07:54.020
Okay.

00:07:54.020 --> 00:08:05.780
Now, I think probably we should start this conversation with a definition, because I kind of opened it saying, well, Jupyter is the prototypical thing of what a notebook is.

00:08:05.780 --> 00:08:09.980
And it's kind of the natural progression of something like Mathematica.

00:08:09.980 --> 00:08:14.940
But what would you all define a notebook system to be?

00:08:14.940 --> 00:08:19.180
So, like, how do other things that are, you know, not exactly that fit into this world?

00:08:19.420 --> 00:08:32.080
In this paper, we define a computational notebook as a system that supports literate programming, where you can blend a text-based programming language with program outputs in a single document.

00:08:32.080 --> 00:08:32.340
Right.

00:08:32.340 --> 00:08:34.140
And this is not a super new idea, right?

00:08:34.140 --> 00:08:38.520
This, I mean, Donald Newt is like in the 80s or something talked about this idea, right?

00:08:38.520 --> 00:08:38.880
Yeah.

00:08:38.880 --> 00:08:45.560
And actually, I think the entire tech program, like LaTEC, the tech that Donald Newt made, was a literate program to begin with.

00:08:45.860 --> 00:08:50.140
He was like the, I would say, like most prominent proponent of literate programming.

00:08:50.140 --> 00:08:50.460
Okay.

00:08:50.460 --> 00:08:54.660
So, notebooks are these embodiments of this literate programming idea.

00:08:54.660 --> 00:09:07.340
Basically, I guess I'm hearing that it's the ability to blend together the presentation of, like, prose almost, and computation and visualization around that.

00:09:07.440 --> 00:09:08.160
Yeah, yeah.

00:09:08.160 --> 00:09:12.260
And it kind of shifted the dynamic of how we view a program.

00:09:12.260 --> 00:09:22.640
Instead of having a program be instructions for a computer, it allowed us to see programs as kind of like the outputs themselves, as a thing that you would show to other people in the end.

00:09:22.720 --> 00:09:25.720
Yeah, because traditionally, it would be, here's the graph.

00:09:25.720 --> 00:09:26.280
Exactly.

00:09:26.280 --> 00:09:28.780
We ran the analysis, and this is the output.

00:09:28.780 --> 00:09:33.340
Here's the description of the output, maybe a description of the algorithm, and here's the output.

00:09:33.340 --> 00:09:37.780
And, you know, there's been a big push in the scientific space for reproducibility.

00:09:37.780 --> 00:09:42.300
And I think also just in the data science space for explorability, right?

00:09:42.300 --> 00:09:43.200
Like, I've got data.

00:09:43.200 --> 00:09:44.300
I don't really know what it is.

00:09:44.300 --> 00:09:48.180
I need to just get in there and play with it before I turn the algorithms loose on it.

00:09:48.280 --> 00:09:50.380
And that's kind of what's happening here, right?

00:09:50.380 --> 00:09:51.160
Yeah, definitely.

00:09:51.160 --> 00:10:04.620
I would say many of the projects that we looked at in this paper were birthed out of this, directly out of, like, the reproducibility issue, where some person might write a script to generate a graph somewhere, but then lose it.

00:10:04.620 --> 00:10:06.600
And then all you have now is, like, a graph in the end.

00:10:06.600 --> 00:10:14.780
If you had a notebook, the pitches, if you had a notebook, you wouldn't need to have a separate graph, like JPEG, and then a separate program to run it.

00:10:14.780 --> 00:10:16.000
You could just have it in one place.

00:10:16.000 --> 00:10:17.120
Right, right, right.

00:10:17.540 --> 00:10:30.960
How often does version control in the science space or the sort of beginner developer space look like a bunch of zip files where they're named the thing and then the date or the thing of the date and then, like, two and then three?

00:10:30.960 --> 00:10:31.660
Oh, yeah, exactly.

00:10:31.660 --> 00:10:32.100
Something like that.

00:10:32.100 --> 00:10:35.700
It's like zero five underscore final final V3, you know?

00:10:35.700 --> 00:10:37.260
Exactly.

00:10:37.260 --> 00:10:38.200
Final edited.

00:10:38.200 --> 00:10:39.560
That's not amazing.

00:10:39.560 --> 00:10:52.640
So having something in here that sort of brings a little more formality and brings, I guess, the paper and the presentation and the script or code that ran it, like, into one thing that's versioned continuously seems a little bit better.

00:10:52.640 --> 00:11:00.380
Yeah, and actually, there are the basic way to version control a Jupyter notebook is to put it in a version control system like Git.

00:11:00.380 --> 00:11:11.020
But oftentimes, it's not good enough for actual scientists who have, like, the notebook files themselves, but also their data and also the libraries that the notebook use to generate the outputs.

00:11:11.020 --> 00:11:17.820
And so there's a group of projects that we surveyed that not only version a notebook, but also in version a notebook and the dependencies.

00:11:17.820 --> 00:11:18.360
Okay.

00:11:18.360 --> 00:11:19.440
Yeah, very nice.

00:11:19.440 --> 00:11:28.080
One of the challenges, however, I think it's ironic, like, it brings stuff together here to make the code and the analysis and the presentation all as one.

00:11:28.080 --> 00:11:30.940
But it actually, Jupyter notebooks are not very easy to version.

00:11:30.940 --> 00:11:32.240
Quite hard, actually.

00:11:32.240 --> 00:11:32.580
Yeah.

00:11:32.580 --> 00:11:40.340
Yeah, like, if they store the last run of the output, and if that is dynamic in the sense that it's, like, not every time you run it, you get the same output.

00:11:40.340 --> 00:11:43.500
That can be a, I mean, even if it changes, right?

00:11:43.500 --> 00:11:44.800
Even if it is that case, it's still hard.

00:11:44.800 --> 00:11:51.540
But if it's, like, changes every time you run it because it pulls something from the internet that varies or whatever, it's basically always a merge conflict.

00:11:51.540 --> 00:11:57.200
So there's tools like NB strip out, which are nice, that are, like, pre-commit hooks that'll let you do that and other ones.

00:11:57.300 --> 00:12:05.220
But still, it's, I think it's, these notebooks, they come both with, like, a new power and accessibility, but also their own challenges.

00:12:05.220 --> 00:12:06.000
Yeah, exactly.

00:12:06.000 --> 00:12:06.420
Yeah.

00:12:06.420 --> 00:12:12.620
So in your paper, one of the things you all talked about is you said around notebooks, they have these several themes.

00:12:12.620 --> 00:12:19.280
They have end-user programming, exploratory programming, live programming, and literate computing.

00:12:19.280 --> 00:12:23.060
So what do you mean by, like, live programming?

00:12:23.060 --> 00:12:25.580
I understand end-user programming, which is pretty cool.

00:12:25.940 --> 00:12:27.240
Observatory makes sense.

00:12:27.240 --> 00:12:28.340
But what's the live here?

00:12:28.340 --> 00:12:31.980
So, yeah, so there are a few kinds of definitions of live programming.

00:12:31.980 --> 00:12:34.920
One definition comes from kind of the creative space.

00:12:34.920 --> 00:12:42.860
So there are these people who are graphic artists or musicians who actually literally, you know, they're streaming on Twitch or they're doing these, you know, pre-COVID, I guess.

00:12:42.860 --> 00:12:52.340
They're doing these live performances on stage where they're using some kind of graphical software to, you know, Max MSP or whatever to put together live music performances or graphical art.

00:12:52.960 --> 00:12:59.080
Another form of live programming that I think what we mean in this paper is more like a programming environment that updates live, right?

00:12:59.080 --> 00:13:03.420
So as you're typing the code, it's actually just constantly running it and generating output.

00:13:03.420 --> 00:13:10.900
So some of the notebook systems we've looked at allows you to kind of do this live programming where as you start typing, it might autocomplete.

00:13:10.900 --> 00:13:16.640
It might start generating graphs for you just to kind of cut down on this edit run loop and such.

00:13:16.880 --> 00:13:17.180
Right, right.

00:13:17.180 --> 00:13:20.220
It's not this I'm going to edit when it's time to hit run, I run.

00:13:20.220 --> 00:13:25.180
Or, you know, maybe in some languages there's a compile, then a link, then a run, and there's a big delay.

00:13:25.180 --> 00:13:35.720
Would something like some of the features in the editors, like PyCharm and probably VS Code, I don't know what plugin you need for it, but where it's like continuously running unit tests just as you type?

00:13:35.720 --> 00:13:38.400
Yeah, I mean, that's a form of liveness, right?

00:13:38.400 --> 00:13:39.620
The kind of, you know, whatever.

00:13:39.620 --> 00:13:42.180
And even like, you know, even the squiggly lines, right?

00:13:42.180 --> 00:13:45.220
The IntelliSense and the, you know, linting and those things.

00:13:45.220 --> 00:13:50.200
You know, anything that kind of cut down on the, you know, the friction of having to write a bunch of code.

00:13:50.200 --> 00:13:51.680
Because especially for beginners, right?

00:13:51.740 --> 00:14:00.420
So for beginners and for people who might be scientists and people who may not be as programming experienced, you know, one thing you often see beginners do is they write a lot of code, right?

00:14:00.420 --> 00:14:02.320
They write a lot of code and they sit and they hit run.

00:14:02.320 --> 00:14:03.400
They're like, why doesn't it work, right?

00:14:03.400 --> 00:14:11.540
Whereas more experienced programmers kind of know to write a line, check it, print something out, make sure it works, and then write the next line, write the next section and such.

00:14:11.540 --> 00:14:16.700
Yeah, it's easy to do a bunch of work and then have it, especially when you're new, and have it not come out the way you like.

00:14:16.700 --> 00:14:18.280
And you're like, well, now it's broken.

00:14:18.280 --> 00:14:18.980
Oh, no.

00:14:18.980 --> 00:14:20.300
What am I going to do, right?

00:14:20.500 --> 00:14:22.760
It's small bites, of course, small steps.

00:14:22.760 --> 00:14:28.340
This portion of Talk Python To Me is brought to you by Linode.

00:14:28.340 --> 00:14:37.280
Whether you're working on a personal project or managing your enterprise's infrastructure, Linode has the pricing, support, and scale that you need to take your project to the next level.

00:14:37.280 --> 00:14:47.780
With 11 data centers worldwide, including their newest data center in Sydney, Australia, enterprise-grade hardware, S3-compatible storage, and the next-generation network,

00:14:48.260 --> 00:14:51.940
Linode delivers the performance that you expect at a price that you don't.

00:14:51.940 --> 00:15:07.980
Get started on Linode today with a $20 credit, and you get access to native SSD storage, a 40-gigabit network, industry-leading processors, their revamped cloud manager at cloud.linode.com, root access to your server, along with their newest API, and a Python CLI.

00:15:08.400 --> 00:15:16.020
Just visit talkpython.fm when creating a new Linode account, and you'll automatically get $20 credit for your next project.

00:15:16.020 --> 00:15:17.300
Oh, and one last thing.

00:15:17.300 --> 00:15:18.080
They're hiring.

00:15:18.080 --> 00:15:21.180
Go to linode.com slash careers to find out more.

00:15:21.180 --> 00:15:22.500
Let them know that we sent you.

00:15:25.620 --> 00:15:36.800
When you had live here, and you talked about the live, sort of interactive, almost onstage type of stuff, I was thinking of FoxDot and the live, like, musical composition with Python.

00:15:36.800 --> 00:15:38.000
Have either of you guys seen that?

00:15:38.000 --> 00:15:38.920
No, I haven't seen this.

00:15:38.920 --> 00:15:39.360
I have not.

00:15:39.360 --> 00:15:40.500
I think it's called FoxDot.

00:15:40.500 --> 00:15:42.440
I'll put a link of a presentation.

00:15:42.440 --> 00:15:45.580
So there's this thing called FoxDot, which is Python-based.

00:15:45.580 --> 00:15:48.540
People can go up there, and they basically create little, like, symphonies.

00:15:48.540 --> 00:15:49.720
Oh, that is awesome.

00:15:50.040 --> 00:15:52.840
And with Python, and it's super interesting.

00:15:52.840 --> 00:15:56.440
Anyway, I was going to ask your thoughts on that as a sort of HCI person.

00:15:56.440 --> 00:15:57.700
Yeah, yeah.

00:15:57.700 --> 00:15:58.560
I'll get it next time.

00:15:58.560 --> 00:16:01.380
Yeah, I grabbed a, yeah, I'm just looking at the page now.

00:16:01.380 --> 00:16:02.520
But yeah, that's a whole other world.

00:16:02.520 --> 00:16:03.480
I mean, it's an awesome world.

00:16:03.480 --> 00:16:08.140
I mean, this whole world of just live performance and, you know, live streaming and stuff is fascinating.

00:16:08.140 --> 00:16:14.500
You know, maybe the next Twitch stars are going to be data scientists, right, who are, you know, live streaming their exploratory analysis.

00:16:14.500 --> 00:16:19.380
There are some data scientists I've seen who do these live streams or do these, you know, recorded sessions.

00:16:19.380 --> 00:16:24.960
Like, let me just play with this data or do this Kaggle thing and just watch me play with it, which is really cool.

00:16:24.960 --> 00:16:26.820
That's really, I think you're right.

00:16:26.820 --> 00:16:27.780
I think it's super interesting.

00:16:27.780 --> 00:16:34.700
I feel like a lot of algorithms and libraries and just software products, I guess you'd call them.

00:16:34.700 --> 00:16:38.040
It could be very stale, you know, much like math or science.

00:16:38.040 --> 00:16:39.280
Like, here's the final result.

00:16:39.280 --> 00:16:40.920
Here's the algorithm or the formula.

00:16:41.420 --> 00:16:51.020
But that doesn't give you an appreciation of, like, seeing the, how do I, like, bumble around and, like, discover and think and try and explore and then come up with an answer.

00:16:51.020 --> 00:16:55.220
I think that would be really interesting for data science and, like, Kaggle competitions and stuff.

00:16:55.340 --> 00:16:55.500
Yeah.

00:16:55.500 --> 00:17:11.440
And I think that segues to our notebook work, too, because I feel like a lot of these notebooks, maybe Sam, I'm going to talk more on this later, is that, like, a lot of these sorts of interfaces could support this sort of liveness and this sort of iteration and keeping different versions around and seeing how you, you know, bumble your way toward a final result.

00:17:11.640 --> 00:17:11.980
Yeah, yeah.

00:17:11.980 --> 00:17:16.640
Maybe the next big particle physics discovery Nobel Prize will be live streamed.

00:17:16.640 --> 00:17:16.980
All right.

00:17:16.980 --> 00:17:19.580
So, Sam, let's get to the analysis.

00:17:19.580 --> 00:17:31.060
So, you said there were a bunch of different environments that you studied and you broke them into three categories, the academic world, the product world, and the R&D world.

00:17:31.060 --> 00:17:34.440
Maybe give us a sense of what's in each one.

00:17:34.440 --> 00:17:42.680
I don't know if we want to go through all of them, but read off maybe, like, five from each of those that you feel like is representative of that area, just to give people a sense of what's all out there.

00:17:42.680 --> 00:17:43.060
Yeah.

00:17:43.060 --> 00:17:51.900
So, probably start with the industry world because that world is probably the most familiar to us and maybe to your listeners as well.

00:17:51.900 --> 00:18:15.280
So, in the product world, we kind of have Jupyter Notebook and we also have, like, Google Colab, which is Google's version of Jupyter Notebook, as well as Azure Notebooks, which is kind of like this up-and-coming notebook system for JavaScript.

00:18:15.480 --> 00:18:28.600
Okay. Oh, right, right. Yeah. There is this move to try to make a JavaScript equivalent, basically, of what Python has, right? I mean, it's pretty natural to run JavaScript, but the trick is to find the libraries, right?

00:18:28.600 --> 00:18:29.580
Exactly. Yeah.

00:18:29.580 --> 00:18:30.480
And maybe integers.

00:18:30.480 --> 00:18:31.080
Yeah.

00:18:31.080 --> 00:18:36.900
No integers in JavaScript can make that a little hard, but still, very cool.

00:18:36.900 --> 00:18:52.180
All right. And then, next category is academic notebook projects. And these projects typically come in the form of, like, papers. So, people will prototype some interaction and then submit a paper in a human-computer interaction conference.

00:18:53.140 --> 00:19:12.260
And these papers typically have, like, they take a base notebook system and extend it in one particular way. For example, the Callisto system takes Jupyter Notebook and adds in, like, some live collaboration tools, like a chat window, as well as, I think, being able to see other people's cursors and where they are on the screen.

00:19:12.260 --> 00:19:15.560
A little bit like a Google Doc-ification of Jupyter.

00:19:15.760 --> 00:19:41.200
Yeah, yeah. That's what they're going for. We have tools like Rex, which is a tool specifically for, like, data cleaning. So, the idea there is that you would, you could display a data frame in your notebook and then, by example, show Python, in a sense, like, what you want the data to look like after data cleaning. And it can try to infer the Python code that would generate that, that would change the data in the way that you want.

00:19:41.200 --> 00:19:45.080
Oh, that's pretty cool. And so, it uses a bit of machine learning or something.

00:19:45.680 --> 00:20:15.280
Yeah, it uses what's called program synthesis. Yeah, that actually was a project led by Ian, who was my other PhD student, who was a co-author on this paper. He did this at a Microsoft research internship. So, they have this program synthesis technology. They have this, you know, engine that basically synthesizes pieces of code. And they applied this technology to notebooks. So, what you can actually do is you can, you know, in a data table, you can say, here are some examples of the way I want to clean the data. And then it'll infer. I don't think it actually is machine learning because it's not database. It's kind of rules-based.

00:20:15.600 --> 00:20:45.580
Right, right, right, right.

00:20:45.980 --> 00:20:53.500
So, you kind of have, like, these experimental, but also, like, you look at it and you're like, well, that could be useful in a real system.

00:20:53.700 --> 00:21:02.640
Yeah, yeah, yeah, I could see that for sure. You maybe just drop a marker, like, hey, I'm going to go explore this. I might want to, like, a save point type of thing. Maybe you want to get back here.

00:21:02.640 --> 00:21:03.140
Exactly.

00:21:03.140 --> 00:21:14.440
And then, right, it'll just sort of, that's, like, behind the scenes. We're going to create a Git branch and start doing stuff for you, right? Like, that'd be really nice for people who are, they don't know how to, like, deal with Git branches or want to deal with it and stuff like that.

00:21:14.500 --> 00:21:21.380
Yeah, that's exactly the use case that they were going for. It's for this very exploratory, early stage, like, data exploration. Yeah.

00:21:21.380 --> 00:21:34.140
Yeah. Yeah. Okay, cool. The one in the product space that seems to be closest to that is Gigantum. I had those guys on the show and there's a little bit of, like, auto-versioning collaboration stuff in that world.

00:21:34.280 --> 00:21:40.000
Yeah, yeah. We looked at Gigantum in this paper and I think we did mark it down as being relatively similar to that.

00:21:40.000 --> 00:21:43.160
Yeah, yeah, cool. All right, the third category was experimental and R&D.

00:21:43.160 --> 00:21:59.660
Yeah. So experimental R&D is, in a sense, very much like the academic projects in that they are, they're trying to test out new interactions or new features that might not, like, don't have immediate, like, industry use cases or maybe, like, business propositions.

00:22:00.200 --> 00:22:12.640
And so we have tools like Carbide is an interesting one. Carbide actually allows you to, it creates widgets for your Python variables in line with your Python code.

00:22:12.640 --> 00:22:17.360
And then it allows you to, like, use sliders to change your variables on the spot.

00:22:17.360 --> 00:22:18.280
Okay.

00:22:18.280 --> 00:22:25.620
And it's, like, way out there. It's really interesting. But you can, it actually infers, like, what values your Python variables should take on to produce an output.

00:22:25.620 --> 00:22:35.440
So if you use a widget to say, like, oh, I want Y to be, like, 32, then if Y depends on X, then it'll also update X at the same time.

00:22:35.440 --> 00:22:44.060
So it does, like, it's weird. It does look like it's really, like, intriguing, like, program synthesis or, like, program, like, inference, like, behind the scenes to get your program to look right.

00:22:44.060 --> 00:22:46.600
Right, to look at the dependencies and figure out what it has to rerun.

00:22:46.600 --> 00:22:47.420
Yeah, yeah.

00:22:47.620 --> 00:22:55.620
Yeah, that's really cool. It sounds a little bit like the interactive widgets in Jupyter that you can have, you know, you can sort of put some sliders and adjust some things.

00:22:55.620 --> 00:23:03.760
But I don't believe the Jupyter one has a lot of pendency type of stuff on down the line, right? It's just like this one cell as you slide the widget recomputes.

00:23:03.760 --> 00:23:09.660
Yeah, yeah. Like, Carbide is like those Jupyter widgets, but super next level. The widgets can change the code itself.

00:23:09.760 --> 00:23:10.760
Okay, that's pretty wild.

00:23:10.760 --> 00:23:29.760
Yeah. We have a few industry projects here as well. We have projects from, like, Netflix and Stripe, where they take notebooks, but use notebooks as, like, kind of, like, recurring jobs instead of just one-off, like, exploratory scripts, where they use notebooks as these jobs.

00:23:29.760 --> 00:23:35.420
And so they can re- the notebook might automatically rerun, like, once a day to perform some data operation.

00:23:36.080 --> 00:23:40.620
They're kind of, like, broadening the scope of what notebooks can be used for in a large-scale setting.

00:23:40.620 --> 00:23:45.740
Yeah, you know, the stuff that Netflix was doing with, like, Paper Mill was super interesting.

00:23:45.740 --> 00:23:56.660
How they're using it to automate a bunch of stuff and sort of schedule a bunch of things to work, but also the fact that if it fails, the notebook has the output of the failure.

00:23:56.660 --> 00:24:02.360
So basically, you can, you know, save the notebook in that state and just go look at it and see what went wrong.

00:24:02.420 --> 00:24:09.140
Rather than there's a log message that says something went wrong, like, there's the whole sequence with the history of the notebook output, which is pretty awesome.

00:24:09.140 --> 00:24:13.440
Yeah. I think the Paper Mill stuff, I mean, they have a blog post about it, but we link to all of this in the paper.

00:24:13.440 --> 00:24:15.660
So if you, you know, link to our paper, we have all the URLs.

00:24:15.660 --> 00:24:17.180
I mean, I thought that was interesting.

00:24:17.180 --> 00:24:22.620
I mean, we didn't really capture this in the- in our space because, you know, most of it is for data scientists.

00:24:22.620 --> 00:24:28.900
But the Paper Mill project is interesting because it's using notebooks for, like, DevOps and for, you know, production deployment work, right?

00:24:28.900 --> 00:24:34.560
It's like really using the notebooks as a kind of a DevOps-y sort of tool rather than a direct data science tool.

00:24:34.560 --> 00:24:37.800
So I thought that was a really interesting and out-of-the-box use case.

00:24:37.800 --> 00:24:44.400
It's like instead of running cron jobs and seeing, like, gigantic log files on your terminal or grepping through text files,

00:24:44.400 --> 00:24:50.980
you can just, you know, reconstruct it in a notebook and actually use a notebook to debug your production software, which is cool.

00:24:50.980 --> 00:24:56.420
Yeah. And the essence of that, I think, was one of the things you do with Paper Mill, if I have it remembered correctly,

00:24:56.420 --> 00:24:59.740
is the notebooks can take inputs and they can generate outputs.

00:24:59.740 --> 00:25:03.680
They're, like, sort of become functions in the traditional black box sense of it.

00:25:03.680 --> 00:25:04.000
Yeah.

00:25:04.000 --> 00:25:05.180
Yeah. That's pretty neat.

00:25:05.180 --> 00:25:08.000
Another one I see that you have in there is NB Dev.

00:25:08.000 --> 00:25:10.360
NB Dev is a really interesting project.

00:25:10.360 --> 00:25:15.820
I just, we talked about that, Brian Nock and I did a couple episodes ago on Python Bytes.

00:25:15.820 --> 00:25:18.140
And I was like, oh, well, this might be kind of interesting.

00:25:18.140 --> 00:25:21.800
And I looked and I'm like, wow, this is something really quite special.

00:25:21.800 --> 00:25:24.120
It does a lot of neat things over there.

00:25:24.120 --> 00:25:32.460
Right. So if I'm remembering correctly, NB Dev allows you to take a notebook and, like, deploy it as a Python library.

00:25:32.460 --> 00:25:35.640
Yes, exactly. Yeah. You can basically turn it into a package.

00:25:35.640 --> 00:25:38.020
Right. And it can have the test, like, built into it.

00:25:38.020 --> 00:25:47.660
And, yeah, it's, again, a really interesting example of, like, notebooks are kind of being reused in all sorts of ways that we would see traditional Python scripts being reused.

00:25:47.660 --> 00:25:54.440
So in this case, instead of writing a set of Python files to become a Python package, you could write a notebook instead.

00:25:54.440 --> 00:25:56.040
And that could be, like, your package.

00:25:56.040 --> 00:26:00.780
Yeah. I'll give you the quick rundown for people who are listening and might be interested just off their little highlights.

00:26:01.320 --> 00:26:04.200
So you can export the functionality of a notebook to a library.

00:26:04.200 --> 00:26:08.560
They have a CLI commands you can use to interact with NB Dev.

00:26:08.560 --> 00:26:11.760
Export to HTML builds documentation for your library.

00:26:11.760 --> 00:26:13.800
Sync brings the Python.

00:26:13.800 --> 00:26:17.200
So you can edit the Python code and then bring it back into your library.

00:26:17.200 --> 00:26:20.060
You can put the tests in there and run them in CI.

00:26:20.060 --> 00:26:24.660
There's just a button that also has this, like, NB strip out concept as well for checking stuff in.

00:26:24.760 --> 00:26:29.280
So, yeah, that's, I mean, there's a bunch of exploration and innovation happening here.

00:26:29.280 --> 00:26:30.240
Yeah, it's really interesting.

00:26:30.240 --> 00:26:34.480
One other interesting project in the experimental section is, like, Iodide.

00:26:34.480 --> 00:26:37.440
Iodide is, Iodide is, like, super experimental.

00:26:37.440 --> 00:26:44.120
But they compiled Python and some of its data science libraries into WebAssembly.

00:26:44.120 --> 00:26:49.000
And then because of that, you can run, you can write Python in the browser.

00:26:49.000 --> 00:26:53.020
And it doesn't require a separate Python process to run that.

00:26:53.020 --> 00:27:00.780
Instead, it runs completely within the browser because your browser is interpreting the WebAssembly version of, like, the Python interpreter.

00:27:00.780 --> 00:27:05.180
And, like, I think they have, like, NumPy and, like, Matplotlib support in there, too.

00:27:05.180 --> 00:27:11.480
Yeah, they've recompiled many of the core, what would be C-based Python libraries as well, right?

00:27:11.480 --> 00:27:13.660
Like you said, like, NumPy and maybe Matplotlib.

00:27:13.660 --> 00:27:14.200
I can't remember.

00:27:14.200 --> 00:27:15.420
But some of those types of libraries.

00:27:15.420 --> 00:27:15.760
Right.

00:27:15.760 --> 00:27:19.720
It's really, it took a while for me to wrap my mind around it.

00:27:19.720 --> 00:27:21.460
But I was really amazed when I first saw that.

00:27:21.460 --> 00:27:25.980
I think WebAssembly has some real interesting possibilities to bring a lot of this stuff together.

00:27:25.980 --> 00:27:34.300
You know, it's one of the things that's interesting about some of the stuff you were covering in these different projects here is just what it means to run the notebook, right?

00:27:34.300 --> 00:27:42.880
Sometimes that means a Docker image is spun up and configured exactly for you in some environment or even, like, with Gigantum on your local machine.

00:27:42.880 --> 00:27:47.260
With Google CoLab, there's, like, a way to say, run this on a GPU, by the way.

00:27:47.260 --> 00:27:47.880
Yeah.

00:27:47.880 --> 00:27:49.980
Just to get a GPU to run it on.

00:27:49.980 --> 00:27:53.080
And Iodide runs in the browser through WebAssembly.

00:27:53.680 --> 00:27:56.620
There's just, there's a bunch of options here that are pretty cool.

00:27:56.620 --> 00:27:56.940
Yeah.

00:27:56.940 --> 00:28:01.120
Kind of to Michael's point, it's like, you know, we've just informally kind of starting this project.

00:28:01.120 --> 00:28:02.480
We've kind of heard about all these.

00:28:02.480 --> 00:28:04.080
It's felt like the Wild West, right?

00:28:04.080 --> 00:28:05.420
It's like, oh, you can run the notebooks locally.

00:28:05.420 --> 00:28:06.600
You can run some JavaScript.

00:28:07.100 --> 00:28:08.240
Observable ones run the browser.

00:28:08.240 --> 00:28:10.940
And, like, you know, Iodide, Pyodide compiles.

00:28:10.940 --> 00:28:12.240
The WebAssembly runs the browser.

00:28:12.240 --> 00:28:14.240
And then you need some other ones in the cloud.

00:28:14.240 --> 00:28:16.060
And then some of them have this live editing.

00:28:16.060 --> 00:28:16.640
Some of them don't.

00:28:16.640 --> 00:28:25.060
So that's why kind of motivation for putting together this paper was, you know, how do we just categorize all this in the most kind of concise way we can?

00:28:25.060 --> 00:28:29.840
And, I mean, we're going to talk about more of this detail, but we have one category about runtime environment, right?

00:28:29.840 --> 00:28:34.700
So we categorize, here's the four types of main types of runtime environments people have and other things.

00:28:34.700 --> 00:28:38.540
So the kind of main contribution of this paper was really people have all these intuitions.

00:28:38.540 --> 00:28:40.560
They've heard about these notebooks doing all these different things.

00:28:40.560 --> 00:28:44.300
Let's just try to plop them all together in a map, in a sense, right?

00:28:44.300 --> 00:28:47.960
Like, where does everything lie on this wild, this high-dimensional space?

00:28:47.960 --> 00:28:49.340
Yeah, it's highly dimensional.

00:28:49.340 --> 00:28:51.160
We're going to talk about the dimensions in a minute.

00:28:51.160 --> 00:28:52.500
It's more than three dimensions.

00:28:52.500 --> 00:28:58.060
This portion of Talk Python To Me is brought to you by Sentry.

00:28:58.060 --> 00:29:00.700
How would you like to remove a little stress from your life?

00:29:00.700 --> 00:29:06.440
Do you worry that users may be having difficulties or are encountering errors with your app right now?

00:29:06.440 --> 00:29:09.340
Would you even know it until they send that support email?

00:29:09.340 --> 00:29:19.720
How much better would it be to have the error details immediately sent to you, including the call stack and values of local variables, as well as the active user stored in the report?

00:29:20.180 --> 00:29:23.500
With Sentry, this is not only possible, it's simple and free.

00:29:23.500 --> 00:29:26.900
In fact, we use Sentry on all the Talk Python web properties.

00:29:26.900 --> 00:29:33.440
We've actually fixed a bug triggered by our user and had the upgrade ready to roll out as we got the support email.

00:29:33.440 --> 00:29:35.240
That was a great email to write back.

00:29:35.240 --> 00:29:37.700
We saw your error and have already rolled out the fix.

00:29:37.700 --> 00:29:38.880
Imagine their surprise.

00:29:38.880 --> 00:29:41.560
Surprise and delight your users today.

00:29:41.560 --> 00:29:49.460
Create your free account at talkpython.fm/sentry and track up to 5,000 errors a month across multiple projects for free.

00:29:49.460 --> 00:30:00.720
And if you use the code Talk Python, all one word, it's good for two free months of Sentry's team plan, which will give you up to 20 times as many monthly events in some other features.

00:30:00.880 --> 00:30:02.460
So create that free account today.

00:30:06.200 --> 00:30:12.520
One thing I do want to talk about maybe first is just like some of the challenges of notebooks and then the paradox of choice.

00:30:12.520 --> 00:30:17.760
So first of all, I think this comes from the paper, but also some of the feelings I had.

00:30:17.760 --> 00:30:29.200
So you talked about some of the challenges, Sam, being stale data, out of order execution, abundance of code, and then the inability for composition, things that Paper Mill, for example, is trying to solve.

00:30:29.940 --> 00:30:32.520
Do you want to speak to some of the challenges you saw out in this space?

00:30:32.520 --> 00:30:51.000
Well, one of the first challenges that a user of Drupal notebooks encounters is typically the out-of-order execution problem, where because you can run cells in any order you want, what might happen is you run some cells, and then you delete some cells, and then you write more cells, and you run those in some out-of-order way.

00:30:51.000 --> 00:30:59.160
And what happens is, well, one problem is that sometimes your variables just get changed, and you don't know where a change came from because your code might be gone.

00:30:59.480 --> 00:31:01.540
Right. You might even delete the cell that defined them.

00:31:01.540 --> 00:31:02.600
Yeah, yeah.

00:31:02.600 --> 00:31:06.340
But the kernel's still running, so they're still in memory. For now, it's going to be okay.

00:31:06.340 --> 00:31:13.960
Exactly, exactly. It happens really, really often, in my experience, when we teach students how to use Drupal notebooks for the first time.

00:31:13.960 --> 00:31:22.660
They hit some random keyboard shortcut, and their cell's gone. And it looks like the code's running fine, but then when they try to turn in their code, everything kind of goes up in flames.

00:31:22.660 --> 00:31:40.180
Yeah. Well, but it's so much the power of Jupyter as well, right? Like, there's some reports and stuff I have for my business behind the scenes, where there's like a 30-second bunch of reading data, correlating data, and then you want to graph it and slice it and analyze it.

00:31:40.340 --> 00:31:56.540
And the ability to just go, rerun the cell that sorts it this way and shows that aspect, it runs instantly, right? It just goes and goes and goes. And it's so powerful to not have to rerun that code to be able to change your analysis or how you're exploring it, right?

00:31:56.660 --> 00:32:00.740
Yeah, exactly. That was the selling point of Jupyter. That's why I've got everyone hooked on Jupyter to begin with.

00:32:00.740 --> 00:32:00.980
Yeah.

00:32:00.980 --> 00:32:01.860
It was like that ability to really quickly.

00:32:01.860 --> 00:32:04.900
Yeah, you do the expensive part. Exactly. Exactly.

00:32:04.900 --> 00:32:09.080
But it's like the world's worst go-to and then some, you know?

00:32:09.080 --> 00:32:16.140
Sure. It's like the human-powered go-to, right? Like, you're self-like running the cells and go-to statements yourself.

00:32:16.140 --> 00:32:23.080
Exactly. Like, with a real go-to, it might be really hard to understand, but you can literally go through the code and see it.

00:32:23.080 --> 00:32:24.340
Yeah, it's at least deterministic.

00:32:24.560 --> 00:32:29.020
Yeah, it's at least deterministic, right? But yeah, it's not even with Notebook. So that's a challenge.

00:32:29.020 --> 00:32:29.960
Yeah, exactly.

00:32:29.960 --> 00:32:37.780
Because to me, that's the biggest challenge. Yeah, it's this sort of out-of-order stuff. But it's so hard to say, like, well, let's just not do that because it's also the superpower.

00:32:37.780 --> 00:32:53.560
Right, right. One of the dimensions in this space, I don't know if we're getting there quite yet, but one of the dimensions in this space specifically addresses this because a number of projects that we see from academia and from industry try to, like, address this specific in-order, out-of-order execution issue.

00:32:53.960 --> 00:33:06.380
Projects like Papermode, which we briefly talked about before, address it in a different way by trying to just, like, make sure that whenever a Notebook is run, it only runs from top to bottom like a computer would, rather than how a human might execute it.

00:33:06.520 --> 00:33:16.420
So there's different angles on how to get around an out-of-order execution thing. But as you mentioned, it's like the main benefit and also the main weakness of these Notebook systems.

00:33:16.640 --> 00:33:19.100
Yeah. Did you guys study Streamlit?

00:33:19.100 --> 00:33:20.400
Streamlit?

00:33:20.400 --> 00:33:20.500
Yeah.

00:33:21.640 --> 00:33:27.760
So Streamlit has a really interesting way of solving that in that they basically use Funktool's LRUCache.

00:33:27.760 --> 00:33:31.260
They don't exactly use that, but they more or less, the concept is the same.

00:33:31.260 --> 00:33:35.120
And they've got these different functions that more or less act like cells.

00:33:35.120 --> 00:33:38.960
And when you rerun it, if you give it the same inputs, it uses the cached version.

00:33:38.960 --> 00:33:42.120
But if the inputs happen to change, then it'll give you a different output.

00:33:42.280 --> 00:33:47.520
So it sort of keeps that, you know, don't recompute the stuff I already know aspect.

00:33:47.520 --> 00:33:48.420
Right, right.

00:33:48.420 --> 00:34:01.780
So Streamlit has an interesting execution model that I think we also noticed in some other systems where it looks to you as a user that whenever you make a change, your Notebook gets rerun from top to bottom every time.

00:34:01.780 --> 00:34:06.740
But then behind the scenes, it does some smart caching and computing to avoid the work.

00:34:07.280 --> 00:34:16.500
So you kind of get the benefit of rerunning a script every time without the drawback of having to like wait a long time for some expensive operation to recompute.

00:34:16.500 --> 00:34:16.800
Yeah.

00:34:16.800 --> 00:34:17.460
Yeah.

00:34:17.460 --> 00:34:17.920
Interesting.

00:34:17.920 --> 00:34:21.200
This is a big challenge to put all these things together.

00:34:21.200 --> 00:34:25.680
I mentioned The Paradox of Choice, which is a fantastic book if people haven't read it.

00:34:25.680 --> 00:34:33.280
But I feel like one of the challenges that things you all may experience is if you look at all these different things, you're like, oh, Rex does this amazing thing.

00:34:33.280 --> 00:34:34.640
Callisto does that.

00:34:34.640 --> 00:34:36.140
And Streamlit does this other thing.

00:34:36.240 --> 00:34:38.540
And then Jupyter has this amazing aspect.

00:34:38.540 --> 00:34:42.540
Not any single one of these has all the good things you want.

00:34:42.540 --> 00:34:50.180
But any choice down one path will make you feel like, well, I don't get the machine learning like auto cleanup in this one.

00:34:50.180 --> 00:34:52.040
And I don't get the, you know, the cursors.

00:34:52.040 --> 00:34:59.540
Like, do you feel like there's a bit of a, I don't know, fear of missing or feeling of missing out as you like have to go down?

00:34:59.540 --> 00:35:00.300
You got to use one.

00:35:00.300 --> 00:35:01.100
You can't use them all.

00:35:01.100 --> 00:35:02.260
Oh, yeah, for sure.

00:35:02.500 --> 00:35:06.360
Nowadays, when I use Jupyter, I mean, Jupyter is a system I still use.

00:35:06.360 --> 00:35:13.380
But now that I know about all these other systems, oftentimes when I use Jupyter now, I'm like, dang, if only I had, you know, Next Journal.

00:35:13.380 --> 00:35:15.420
If only I had like Databricks right now.

00:35:15.420 --> 00:35:15.780
Yeah.

00:35:16.040 --> 00:35:18.520
But then you'd want Jupyter to lab back for something else, right?

00:35:18.520 --> 00:35:21.340
I mean, it's like, there's a lot of different things going on here.

00:35:21.340 --> 00:35:23.980
It's a lot of flowers blooming, I would say, I guess.

00:35:23.980 --> 00:35:24.840
Right, right.

00:35:24.960 --> 00:35:30.880
So we talked a little bit at the end of the paper in the kind of discussion part about, you know, what if you did this kitchen sink, right?

00:35:30.880 --> 00:35:32.520
What if you just threw everything together?

00:35:32.520 --> 00:35:34.580
What if someone made a notebook that has everything?

00:35:34.580 --> 00:35:38.120
And, you know, one, it's an enormous software engineering challenge, right?

00:35:38.120 --> 00:35:42.900
Nobody would want to take on that challenge of maintaining 500 different sorts of features.

00:35:43.100 --> 00:35:46.740
And the other one is that it just may make the interface really complicated, right?

00:35:46.740 --> 00:35:58.840
It's not like, if you can choose, imagine, like, you can choose different kinds of execution orders or choose a reactive versus an in-order one and you choose all the stuff, like, it would just be really, really hard for people to set up.

00:35:58.840 --> 00:36:08.860
So, you know, some of these notebook systems, you know, say Jupyter or some of the other ones, I think they've been successful because they've, I would say, I don't want to say straightforward, but their feature set is limited, right?

00:36:08.860 --> 00:36:16.100
Like that, you know, it's, even though Jupyter has this out-of-order issue, it's like, okay, what you see is what you get as long as you execute in that order.

00:36:16.100 --> 00:36:16.440
Yeah.

00:36:16.440 --> 00:36:33.020
And some of the real power is you can have semi-structured, reusable tiny bits in, say, cells when you're just a biologist or an economist and you don't have to become a computer scientist person to, like, learn Haskell to take advantage of this thing.

00:36:33.020 --> 00:36:42.840
Like, it's incredibly, yeah, it's incredibly accessible to just jump in and write a few lines of imperative code and then get some really awesome output.

00:36:42.840 --> 00:36:50.920
And so, yeah, I feel like if it became too advanced, right, you're like, well, do you want the reactive model, the asynchronous model?

00:36:50.920 --> 00:36:52.020
You're like, I don't know what this means.

00:36:52.020 --> 00:36:53.440
I just want a graph, right?

00:36:53.640 --> 00:36:56.340
Yeah, because, I mean, one of the challenges with, say, Observable, right?

00:36:56.340 --> 00:37:03.140
I mean, Observable has this really elegant reactive thing where this stuff auto-updates, and they have a lot of examples, right, on their website.

00:37:03.140 --> 00:37:09.540
But I still think it's going to be hard for regular people, regular programmers to pick up because it looks kind of like JavaScript.

00:37:09.540 --> 00:37:15.960
But then when you write it, it's like it has all these, like, little extensions to JavaScript that you need to wrap your head around.

00:37:15.960 --> 00:37:22.700
So, you know, it's the age-old thing of, you know, more powerful programming languages environments are just going to be higher barrier to learn, right?

00:37:22.700 --> 00:37:24.160
So it's very hard in practice.

00:37:24.160 --> 00:37:24.700
Yeah, yeah.

00:37:24.700 --> 00:37:26.360
So let's talk about the dimensions.

00:37:26.360 --> 00:37:34.460
Sam, you put together 10 different dimensions on how you sort of evaluate these things and, you know, a spectrum along them.

00:37:34.460 --> 00:37:39.580
For example, like data sources, you have local files, cloud storage, large data, streaming data.

00:37:39.580 --> 00:37:41.640
Want to run us through this?

00:37:41.860 --> 00:37:42.300
Sure.

00:37:42.300 --> 00:37:45.200
We can start with, like, the highest level breakdown.

00:37:45.200 --> 00:37:51.360
We organize the design space dimensions here around the steps in the workflow of a data scientist.

00:37:51.360 --> 00:38:02.180
So as a data scientist, we imagine that you might start a project by importing your data and then writing and editing your code and your prose around that code.

00:38:02.180 --> 00:38:04.480
And then you would want to run that code.

00:38:04.480 --> 00:38:07.600
And then finally, you'd want to publish your notebook in some way.

00:38:07.740 --> 00:38:12.980
So it's like the input, editing, and output steps for a data scientist.

00:38:12.980 --> 00:38:16.160
And those are, like, the workflow steps.

00:38:16.160 --> 00:38:28.840
And the 10 dimensions that we pulled out were data sources, as you mentioned, and things like versioning and collaboration, as well as execution models and execution liveness.

00:38:29.300 --> 00:38:38.320
And for publishing a notebook, we talked about, like, you might want a notebook as a static HTML page or maybe as a software package, as we alluded to earlier.

00:38:38.320 --> 00:38:39.880
There is a lot to consider here.

00:38:39.880 --> 00:38:45.240
Let's just maybe grab a couple and to give people a sense, then they can go look at the paper.

00:38:45.240 --> 00:38:48.680
You've got a big full page graph chart type of thing.

00:38:48.680 --> 00:38:49.300
Yep.

00:38:49.300 --> 00:38:50.040
Chart, I guess.

00:38:50.400 --> 00:38:52.320
For example, I mentioned data sources, right?

00:38:52.320 --> 00:38:53.700
We've got local files.

00:38:53.700 --> 00:38:56.060
And you say, okay, this is access local file system.

00:38:56.060 --> 00:38:59.920
And you always give an example of a system that implements that.

00:38:59.920 --> 00:39:01.400
Like, so RStudio, for example.

00:39:01.400 --> 00:39:02.360
Right, right.

00:39:02.360 --> 00:39:03.840
What else is on that access there?

00:39:03.840 --> 00:39:04.240
Yeah.

00:39:04.320 --> 00:39:12.980
So we have local files, which means that the system basically only, like, natively supports opening files that are stored locally on the same computer.

00:39:12.980 --> 00:39:20.760
Some notebook systems also allow you to read in cloud files, like files on their servers as though they were local.

00:39:20.760 --> 00:39:23.100
This is what Google Colab does.

00:39:23.100 --> 00:39:28.520
It allows you to read in files from Google Drive as if they were stored locally alongside a notebook.

00:39:29.500 --> 00:39:38.280
We have some systems that have some special handling for large data sets, like data sets that don't fit in a computer's memory, like Databricks, uses Spark to handle that.

00:39:38.280 --> 00:39:38.660
Right.

00:39:38.660 --> 00:39:41.840
And we also have some systems that support streaming data.

00:39:41.840 --> 00:39:47.080
So, like, you might hook up your notebook to some, like, web socket on the internet.

00:39:47.080 --> 00:39:52.980
And as new data comes in, your notebook will automatically rerun and update to reflect the latest versions of those data.

00:39:52.980 --> 00:40:02.280
Oh, like if you want to set up a dashboard and as things behind the scenes change, like, the notebook is always sort of up to date with the state of the world.

00:40:02.280 --> 00:40:03.540
Polling almost, but better.

00:40:03.540 --> 00:40:04.420
Yeah, exactly.

00:40:04.420 --> 00:40:11.260
So you can kind of see from the way you described that, that every single, like, dimension here has some use case.

00:40:11.260 --> 00:40:19.360
And the use case is kind of motivated by some real world, like, somebody sat down and was like, man, I don't like rerunning my notebook to update my dashboard every time.

00:40:19.360 --> 00:40:23.620
I just wish I had some way to, like, have it automatically, like, streaming the data and update itself.

00:40:23.620 --> 00:40:23.900
Yeah.

00:40:23.900 --> 00:40:25.140
Yeah, for sure.

00:40:25.140 --> 00:40:29.640
So let's go just through two more and then I'll let people go check out the details for the rest.

00:40:29.640 --> 00:40:31.620
So how about execution order?

00:40:31.620 --> 00:40:42.940
Yeah, so execution order goes directly to the in order, out of order problem that we were talking about earlier, where the Drupal notebooks allow users to run cells in any order they choose.

00:40:42.940 --> 00:40:44.640
So I can jump around cells freely.

00:40:44.640 --> 00:40:50.220
Other systems like Observable require a certain order of cells.

00:40:50.220 --> 00:41:02.760
So what Observable does is it takes a cell, looks at all the dependencies, like, the variable dependencies of that cell, and then forces a notebook to run in the topically sorted order of cells, right?

00:41:02.760 --> 00:41:06.540
Depending on, like, what cells to run should depend on other cells.

00:41:06.540 --> 00:41:17.660
We also have systems like Streamlit, which force, like, this in order execution model that we discussed earlier, where it looks to the user, like, the cell, like, the notebook always runs from top to bottom every time.

00:41:17.800 --> 00:41:22.600
So those are the three main variations we found of ordering execution.

00:41:22.600 --> 00:41:23.860
Yeah, interesting.

00:41:23.860 --> 00:41:29.680
Let's go to the very last part, the end of this lifecycle, if you will, and talk about notebook outputs.

00:41:29.680 --> 00:41:39.080
Yeah, so notebook outputs, we found the most common use case, I think, reflected across all of our systems was taking a notebook and publishing it as a static report, so to speak.

00:41:39.080 --> 00:41:47.100
So it's essentially like taking a notebook and converting it to HTML and emailing the HTML file or putting it up as a web page somewhere.

00:41:47.540 --> 00:41:58.220
The next step up would be, like, a dashboard where you don't have, where you don't show viewers the code that you might, like, where you might require to produce to charts or graphs.

00:41:58.220 --> 00:42:01.220
You just show the charts or graphs, like, themselves.

00:42:01.220 --> 00:42:01.740
Right.

00:42:01.740 --> 00:42:02.680
Okay.

00:42:02.680 --> 00:42:13.600
And then finally, within that space, we have, like, what we call software artifacts, which encapsulate the idea of you can use notebooks as cron jobs, or you can use notebooks as software packages.

00:42:13.960 --> 00:42:17.240
Right, right, like NB dev creating something you could put on PyPI.

00:42:17.240 --> 00:42:18.120
Yeah, exactly.

00:42:18.120 --> 00:42:18.780
Exactly.

00:42:18.780 --> 00:42:19.220
Yeah.

00:42:19.220 --> 00:42:19.920
Yeah.

00:42:19.920 --> 00:42:28.060
I really think it's cool that you broke it down like this, but then each one has an example type of thing.

00:42:28.060 --> 00:42:30.740
So you're like, okay, well, how does, say, Gigantum do it?

00:42:30.740 --> 00:42:32.780
Or how does Streamlit do this thing?

00:42:32.780 --> 00:42:33.840
Or Observable?

00:42:33.840 --> 00:42:34.640
And so on.

00:42:34.840 --> 00:42:40.900
Yeah, I think actually seeing all this stuff together might inspire features to start cross-pollinating.

00:42:40.900 --> 00:42:42.940
Hopefully not every single feature, right?

00:42:42.940 --> 00:42:44.080
That would be too much, but still.

00:42:44.080 --> 00:42:44.860
The kitchen sink.

00:42:44.860 --> 00:42:45.100
Yeah.

00:42:45.100 --> 00:42:45.420
It seems powerful.

00:42:45.420 --> 00:42:46.960
Kitchen sink notebook.

00:42:46.960 --> 00:42:48.380
Yeah.

00:42:48.380 --> 00:42:49.780
Yeah.

00:42:49.780 --> 00:42:52.380
I mean, maybe kitchen sink is available on PyPI.

00:42:52.380 --> 00:42:53.420
Like, you could just go for that.

00:42:53.420 --> 00:42:53.540
Yeah, yeah.

00:42:53.540 --> 00:42:54.380
Pick install kitchen sink.

00:42:54.380 --> 00:42:54.600
Yeah.

00:42:54.600 --> 00:42:55.140
Exactly.

00:42:55.140 --> 00:42:57.480
Gives you half the kitchen sink.

00:42:57.480 --> 00:42:58.180
Takes half an hour.

00:42:58.180 --> 00:42:58.820
Yeah.

00:42:58.820 --> 00:42:59.660
Kitchen sink.

00:42:59.660 --> 00:43:00.860
Wait five minutes.

00:43:00.860 --> 00:43:01.980
Awesome.

00:43:01.980 --> 00:43:02.520
All right.

00:43:02.520 --> 00:43:04.380
Well, this is a really interesting view.

00:43:04.380 --> 00:43:08.640
I guess, you know, maybe let's kind of close out the conversation around this stuff by asking,

00:43:08.640 --> 00:43:10.820
I'll let you both each way in on this.

00:43:10.820 --> 00:43:12.160
What surprised you?

00:43:12.160 --> 00:43:16.860
Like, as you went through this, what did you expect and what was different than that?

00:43:16.860 --> 00:43:18.100
What surprised you as you went through this?

00:43:18.100 --> 00:43:21.860
I mean, first thing that surprised me is how many there were, but what else?

00:43:21.860 --> 00:43:27.100
For me, I think it was this tension between we hear about the problems of notebooks quite often.

00:43:27.360 --> 00:43:33.420
And yet we, from this analysis, we don't often see those desires reflected in actual products.

00:43:33.420 --> 00:43:43.880
So the in order, out of order execution model, for example, the vast majority of the systems we looked at only allowed any order execution where the user defines execution.

00:43:43.880 --> 00:43:48.920
Collaboration between users and notebook authors is relatively common.

00:43:49.060 --> 00:43:53.440
But in a company, you'd rarely find someone working on notebook all by their loans themselves.

00:43:53.440 --> 00:44:00.160
But at the same time, we see very few systems that support like the sort of real-time collaboration that Google Docs has made popular.

00:44:00.160 --> 00:44:00.440
Right.

00:44:00.440 --> 00:44:06.260
And it seems so, so easily on the cusp of that because it's already in the browser.

00:44:06.260 --> 00:44:08.060
Often it's already hosted.

00:44:08.060 --> 00:44:09.240
Right?

00:44:09.240 --> 00:44:09.660
Right.

00:44:09.660 --> 00:44:10.220
Right.

00:44:10.220 --> 00:44:10.560
Exactly.

00:44:10.800 --> 00:44:18.840
So it kind of reveals, I think as a whole, the analysis reveals that there's still room for improvement for a lot of these products.

00:44:18.840 --> 00:44:19.260
Yeah.

00:44:19.260 --> 00:44:19.980
Yeah.

00:44:19.980 --> 00:44:20.180
Good.

00:44:20.180 --> 00:44:20.420
Yeah.

00:44:20.420 --> 00:44:34.080
And I guess, I don't know if it was a surprise as much as, you know, something that, you know, we mentioned toward the end of the paper was that, you know, on the, you know, Sam kind of mentioned the product side of, you know, practically speaking, things are pretty tied to Jupyter-like things because people are used to that.

00:44:34.080 --> 00:44:41.200
And a lot of products are Jupyter extensions or Jupyter hosted on Azure, Jupyter hosted on AWS, Jupyter hosted on Google Cloud.

00:44:41.200 --> 00:44:48.320
And so my kind of focus is thinking about the academic side, think about the research papers that people have been prototyping for this.

00:44:48.320 --> 00:44:58.160
And, you know, I don't know if it was a surprise, but it's something that was kind of a call to action we had at the end of the paper is that, you know, I felt personally that the academic work was not sufficiently weird, maybe.

00:44:58.360 --> 00:44:58.480
Right.

00:44:58.480 --> 00:45:06.020
So it's like you want, you kind of, you, you know, one of the roles of academic research and prototypes is you want to push the bounds and try stuff that's very different.

00:45:06.020 --> 00:45:06.220
Right.

00:45:06.220 --> 00:45:09.800
So imagine experimental programming language or experimental toolkits.

00:45:09.800 --> 00:45:11.540
You know, the point isn't to be practical.

00:45:11.540 --> 00:45:14.120
The point is to stretch the limits of what we know.

00:45:14.120 --> 00:45:22.020
So because I think notebook research is still pretty early, it's all these systems in academia have been done probably within the last four or five years.

00:45:22.200 --> 00:45:28.200
It makes sense that the first wave is fairly kind of, you know, making the extensions that people expect, right?

00:45:28.200 --> 00:45:31.220
Versioning, in order execution, collaboration and stuff.

00:45:31.220 --> 00:45:39.120
So I think that what would excite me more to see in the coming years is just to see the academic projects or the R&D projects becoming more weird, right?

00:45:39.120 --> 00:45:46.100
So one of the things that we pitched at the end is just thinking about multi-device, different kinds of off-desktop devices, right?

00:45:46.100 --> 00:45:57.760
I mean, already we're computing with phones and smartwatches and augmented reality and displays, but we're still just hunched over in front of our laptop, typing in this, literally just typing in a text box in the web browser, right?

00:45:57.760 --> 00:45:58.840
Like that's all the notebooks are.

00:45:58.840 --> 00:46:00.600
They're just little text boxes in web browsers.

00:46:00.600 --> 00:46:04.720
So I think we can really expand our imagination thinking, you know, way beyond.

00:46:04.720 --> 00:46:06.540
That would excite me a lot more.

00:46:06.540 --> 00:46:07.360
Yeah.

00:46:07.360 --> 00:46:08.320
Very interesting.

00:46:08.320 --> 00:46:08.660
Yeah.

00:46:08.660 --> 00:46:14.400
And to echo that point, what we drew out of the notebook systems was like this data science workflow.

00:46:14.900 --> 00:46:24.680
But the reason why we drew out the data science workflow is because I think every single system that we've evaluated here was designed for data scientists for the most part.

00:46:24.680 --> 00:46:35.280
And so with data scientists as the audience of choice, I think they're necessarily like, it comes with like a limitation on what we can imagine notebook be used for.

00:46:35.280 --> 00:46:45.020
So in the paper, we talk about broadening notebook use cases for other types of users, like perhaps instructors for perhaps like maybe like artists, let's say.

00:46:45.020 --> 00:46:52.660
And each of those audiences has probably an entirely different set of desires and things they want to accomplish with programming.

00:46:53.060 --> 00:46:58.540
And I think with that comes like a whole nother set of trade-offs and perhaps design dimensions for notebook systems.

00:46:58.540 --> 00:46:59.280
That's a good point.

00:46:59.280 --> 00:46:59.520
Yeah.

00:46:59.520 --> 00:47:02.900
Like DJs, musicians, orchestras.

00:47:03.280 --> 00:47:04.280
Like what could you do?

00:47:04.280 --> 00:47:08.860
Like what kind of world would you build if you were trying to, you know, coordinate that kind of stuff?

00:47:08.860 --> 00:47:13.260
Philip, you brought up our phones, which are pretty incredible these days.

00:47:13.260 --> 00:47:15.160
Did you guys look at Carnet?

00:47:15.260 --> 00:47:28.620
I mean, it's not really something that needs separate analysis because it's just basically Jupyter, but Carnet, C-A-R-N-E-T-S, which is a open source thing on at least a free thing.

00:47:28.620 --> 00:47:31.980
I'm pretty sure it's open source for Jupyter running natively on iOS.

00:47:31.980 --> 00:47:32.720
Oh, interesting.

00:47:32.720 --> 00:47:34.260
I haven't looked at that.

00:47:34.260 --> 00:47:35.860
Yeah, it's pretty new.

00:47:35.860 --> 00:47:37.540
I just learned about it a few months ago.

00:47:37.540 --> 00:47:38.920
Oh, Stan, that's on GitHub.

00:47:38.920 --> 00:47:39.740
Yeah.

00:47:39.740 --> 00:47:43.220
We should add that to our analysis if we had time.

00:47:43.220 --> 00:47:44.320
That's pretty cool.

00:47:44.320 --> 00:47:49.320
It is, but I mean, it's not really fundamentally different, but it's interesting that it has NumPy.

00:47:49.320 --> 00:47:50.200
Right.

00:47:50.200 --> 00:47:51.280
It's just on the platform.

00:47:51.280 --> 00:47:51.560
Yeah.

00:47:51.560 --> 00:47:58.900
And a lot of those libraries like natively executed on iOS, not like an interface to some cloud thing, but like legitimately there, you know?

00:47:58.900 --> 00:47:59.240
Yeah.

00:47:59.240 --> 00:48:02.900
I mean, already people are talking about, you know, on our mobile phones, right?

00:48:02.900 --> 00:48:04.560
That, you know, for machine learning, right?

00:48:04.560 --> 00:48:09.740
You download these pre-trained models so then you can just do inference on your phone without going to the cloud, right?

00:48:09.740 --> 00:48:10.980
So both for privacy, right?

00:48:10.980 --> 00:48:13.560
If you want to do image recognition, both for privacy and for bandwidth.

00:48:13.560 --> 00:48:16.180
You can do all this computation on your phone locally.

00:48:16.180 --> 00:48:20.720
So you could imagine, you know, what would it mean if you could do data science out in the world, right?

00:48:20.720 --> 00:48:22.240
You have your smartwatch, you have your phone.

00:48:22.240 --> 00:48:25.840
You could just, you know, do your analysis, your Google Glass or whatever.

00:48:25.840 --> 00:48:27.820
There's this kind of sci-fi future.

00:48:27.820 --> 00:48:28.000
Yeah.

00:48:28.020 --> 00:48:35.980
I guess like, you know, the thought that we have as kind of human computer interaction or HCI researchers is, you know, what would the future of computing look like, right?

00:48:35.980 --> 00:48:40.120
Right now, it still looks like people hunched over on their laptops, typing in text boxes, right?

00:48:40.120 --> 00:48:42.220
Like, you want to go beyond that somehow.

00:48:42.220 --> 00:48:45.820
Still waiting to just plug an interface right into the neck, right?

00:48:45.820 --> 00:48:47.460
No more typing or massing.

00:48:47.460 --> 00:48:49.140
Projects onto your retina.

00:48:49.700 --> 00:48:51.900
You can have Jupyter in your eyes.

00:48:51.900 --> 00:48:52.480
Exactly.

00:48:52.480 --> 00:48:53.820
Sign me up.

00:48:53.820 --> 00:48:55.780
You'll be the first best subject.

00:48:55.780 --> 00:48:56.820
Yeah.

00:48:56.820 --> 00:49:00.320
Maybe not the first, but early adopter.

00:49:00.320 --> 00:49:01.280
Let's put me in that category.

00:49:01.280 --> 00:49:02.120
All right, you guys.

00:49:02.120 --> 00:49:03.140
This was super interesting.

00:49:03.140 --> 00:49:08.000
And it definitely opened my eyes to some things that are going on out there that I had no idea about.

00:49:08.000 --> 00:49:09.460
So super cool research.

00:49:09.460 --> 00:49:09.820
Thanks.

00:49:10.000 --> 00:49:11.360
It was really fun for us to talk about it.

00:49:11.360 --> 00:49:12.020
Yeah, for sure.

00:49:12.020 --> 00:49:17.440
Now, before you get out of here, I'm going to ask you the two questions that go at the end of the show all the time.

00:49:17.440 --> 00:49:19.840
And I'll, Philip, I'll pick on you since you're a veteran.

00:49:19.840 --> 00:49:23.000
If you're going to write some Python code, what editor do you use?

00:49:23.000 --> 00:49:26.200
I still use Vim because I haven't learned anything new.

00:49:26.200 --> 00:49:28.720
So I still use Vim with whatever defaults.

00:49:28.720 --> 00:49:29.740
Right on.

00:49:29.740 --> 00:49:30.160
All right.

00:49:30.160 --> 00:49:34.160
And then notable PyPI package, something that you've used that is interesting.

00:49:34.160 --> 00:49:36.000
I'll do a plug for Sam's actually.

00:49:36.140 --> 00:49:42.760
So Sam, for his master's thesis at Berkeley, he made this package called MB Interact, which is related to Jupyter Notebooks.

00:49:42.760 --> 00:49:44.000
It's called MB Interact.

00:49:44.000 --> 00:49:45.120
And you can pip install it.

00:49:45.120 --> 00:49:46.780
So I'll let Sam talk more about that.

00:49:46.780 --> 00:49:49.140
That's a lead into Sam's stuff.

00:49:49.140 --> 00:49:50.460
Thanks.

00:49:50.460 --> 00:49:50.980
Yeah, yeah.

00:49:50.980 --> 00:49:51.200
Cool.

00:49:51.200 --> 00:49:51.760
All right.

00:49:51.760 --> 00:49:53.360
Sam, if you're going to write some Python code editor?

00:49:53.360 --> 00:49:53.860
Yeah.

00:49:53.860 --> 00:49:54.980
So I use VS Code.

00:49:54.980 --> 00:49:59.880
But I've hopped from Sublime to Emacs to Vim and then not to VS Code.

00:49:59.880 --> 00:50:02.320
So now I'm a happy VS Code user.

00:50:02.320 --> 00:50:02.800
All right.

00:50:02.800 --> 00:50:03.020
Cool.

00:50:03.020 --> 00:50:04.460
Do you do any bindings?

00:50:04.620 --> 00:50:07.480
Like you set up Vim bindings or Emacs bindings in there or something?

00:50:07.480 --> 00:50:08.660
I set up Vim bindings.

00:50:08.660 --> 00:50:14.080
But if the VS Code team is listening, there are some problems I have with the Vim bindings in VS Code that I'd love to talk about.

00:50:14.080 --> 00:50:14.780
Oh, we're calling them out.

00:50:14.780 --> 00:50:16.560
This is the call-out section.

00:50:16.560 --> 00:50:18.160
This is where we start the beefs.

00:50:18.160 --> 00:50:20.440
The call-out section at the end of the episode.

00:50:20.440 --> 00:50:20.820
That's right.

00:50:20.820 --> 00:50:23.160
It's the underhanded compliment.

00:50:23.160 --> 00:50:24.320
Not exactly.

00:50:24.320 --> 00:50:26.400
But it's like, I love it, but beautiful.

00:50:26.400 --> 00:50:28.020
No, VS Code is a good one.

00:50:28.020 --> 00:50:28.600
All right.

00:50:28.600 --> 00:50:29.880
You want to tell us about MB Interact?

00:50:29.880 --> 00:50:30.320
Sure.

00:50:30.320 --> 00:50:34.580
MB Interact, it lets you take a Jupyter Notebook with some widgets.

00:50:35.400 --> 00:50:38.440
And normally those widgets don't work outside of the notebook environment.

00:50:38.440 --> 00:50:46.320
Like if you convert the notebook to a web page, to an HTML page by default, the widgets will just break because you don't have a Python service running underneath the notebook.

00:50:46.540 --> 00:51:00.600
But MB Interact allows, it kind of like takes your HTML page and hooks it up to the binder service from the Jupyter team so that you can have a, you can have like this HTML page with interactive widgets, but it doesn't require you to have notebook, a notebook server running locally.

00:51:00.600 --> 00:51:02.220
So you can kind of like share those things.

00:51:02.220 --> 00:51:05.760
You can kind of share your interactive notebooks more readily.

00:51:05.760 --> 00:51:06.540
That's the idea.

00:51:06.540 --> 00:51:06.860
I see.

00:51:06.860 --> 00:51:09.960
You don't have to set up a proper Jupyter server with all the execution and stuff.

00:51:10.040 --> 00:51:10.260
Yeah.

00:51:10.260 --> 00:51:14.060
You're going to send someone a link to a web page and then they can run your interactive widgets.

00:51:14.060 --> 00:51:15.360
That's the idea.

00:51:15.360 --> 00:51:15.620
Okay.

00:51:15.620 --> 00:51:16.280
Yeah.

00:51:16.280 --> 00:51:16.600
Yeah.

00:51:16.600 --> 00:51:17.460
Ah, excellent.

00:51:17.460 --> 00:51:20.280
As for like personal use, I like the TQDM package.

00:51:20.280 --> 00:51:23.600
It gives you like a progress bar when you run, when you run the four loops.

00:51:23.600 --> 00:51:24.460
Really handy.

00:51:24.460 --> 00:51:24.840
Yeah.

00:51:24.840 --> 00:51:25.060
Yeah.

00:51:25.060 --> 00:51:25.820
That's really cool.

00:51:25.820 --> 00:51:31.880
There's a couple of interesting progress bars that you can use, but it's those little touches,

00:51:31.880 --> 00:51:35.100
you know, color, progress bars, maybe a few emojis.

00:51:35.100 --> 00:51:38.000
It just makes it feel so much nicer to work in a CLI app.

00:51:38.000 --> 00:51:38.220
Yeah.

00:51:38.220 --> 00:51:41.540
Our next paper is analyzing 60 progress bar libraries.

00:51:41.540 --> 00:51:41.980
Yeah.

00:51:41.980 --> 00:51:44.100
60, 60 progress bar libraries.

00:51:44.100 --> 00:51:44.720
And emojis.

00:51:44.720 --> 00:51:46.100
What emojis they use.

00:51:46.100 --> 00:51:46.900
And emojis.

00:51:46.900 --> 00:51:47.340
Yeah.

00:51:47.340 --> 00:51:47.920
Perfect.

00:51:47.920 --> 00:51:48.300
Perfect.

00:51:48.300 --> 00:51:49.300
All right.

00:51:49.300 --> 00:51:50.520
Well, you guys, this is really fun.

00:51:50.520 --> 00:51:52.880
People want to know more about your research, your paper.

00:51:52.880 --> 00:51:53.560
What do they do?

00:51:53.560 --> 00:51:54.240
How do they find it?

00:51:54.400 --> 00:51:56.180
I mean, I'll put a link in the show notes, but what else?

00:51:56.180 --> 00:51:56.440
Yeah.

00:51:56.440 --> 00:51:57.520
They can just go to the links.

00:51:57.520 --> 00:52:00.220
Michael, I sent you a link in the chat about MB Interact.

00:52:00.220 --> 00:52:03.140
And then we sent you the paper links and such.

00:52:03.140 --> 00:52:06.400
We can put both of our homepages on there and such.

00:52:06.400 --> 00:52:07.960
Sam, any other plugs?

00:52:07.960 --> 00:52:08.760
Yeah.

00:52:08.760 --> 00:52:13.340
I think you remind me that I haven't put up the paper online.

00:52:13.340 --> 00:52:14.940
I don't know if you have the paper online anywhere.

00:52:14.940 --> 00:52:15.240
Yeah.

00:52:15.240 --> 00:52:16.140
I have it on my page.

00:52:16.140 --> 00:52:16.280
Yeah.

00:52:16.280 --> 00:52:16.740
Oh, you do.

00:52:16.740 --> 00:52:17.120
Okay.

00:52:17.120 --> 00:52:19.320
So we can maybe link to the paper from Philip's page.

00:52:19.320 --> 00:52:19.640
Yep.

00:52:19.640 --> 00:52:20.140
Sounds good.

00:52:20.140 --> 00:52:21.240
Well, I'll definitely do that.

00:52:21.240 --> 00:52:22.120
All right, you guys.

00:52:22.120 --> 00:52:23.420
Thank you so much for being on the show.

00:52:23.640 --> 00:52:24.800
It's been really interesting.

00:52:24.800 --> 00:52:30.760
And yeah, there's a lot of notebook exploration and flowers blooming.

00:52:30.760 --> 00:52:34.480
So thanks for putting it all together into like one analysis here.

00:52:34.480 --> 00:52:34.780
Yeah.

00:52:34.780 --> 00:52:37.180
Really big thanks to you, Michael, for having us on.

00:52:37.180 --> 00:52:41.300
And it's been really fun to talk about all the flowers, all the fields of flowers.

00:52:42.240 --> 00:52:43.560
Likewise.

00:52:43.560 --> 00:52:44.840
Thank you so much, Michael.

00:52:44.840 --> 00:52:45.500
Have a good day.

00:52:45.500 --> 00:52:45.860
See you later.

00:52:45.860 --> 00:52:46.860
Bye.

00:52:46.860 --> 00:52:49.700
This has been another episode of Talk Python To Me.

00:52:49.700 --> 00:52:52.700
Our guests on this episode were Sam Lau and Philip Guo.

00:52:53.180 --> 00:52:55.420
And it's been brought to you by Linode and Sentry.

00:52:55.420 --> 00:53:00.340
Start your next Python project on Linode's state-of-the-art cloud service.

00:53:00.340 --> 00:53:03.120
Just visit talkpython.fm/Linode.

00:53:03.120 --> 00:53:04.640
L-I-N-O-D-E.

00:53:04.640 --> 00:53:07.960
You'll automatically get a $20 credit when you create a new account.

00:53:07.960 --> 00:53:10.640
Take some stress out of your life.

00:53:10.640 --> 00:53:15.240
Get notified immediately about errors in your web applications with Sentry.

00:53:15.660 --> 00:53:19.320
Just visit talkpython.fm/sentry and get started for free.

00:53:19.320 --> 00:53:21.480
Want to level up your Python?

00:53:21.480 --> 00:53:26.340
If you're just getting started, try my Python Jumpstart by Building 10 Apps course.

00:53:26.340 --> 00:53:31.440
Or if you're looking for something more advanced, check out our new async course that digs into

00:53:31.440 --> 00:53:34.500
all the different types of async programming you can do in Python.

00:53:34.500 --> 00:53:38.460
And of course, if you're interested in more than one of these, be sure to check out our

00:53:38.460 --> 00:53:39.160
Everything Bundle.

00:53:39.160 --> 00:53:41.040
It's like a subscription that never expires.

00:53:41.040 --> 00:53:43.200
Be sure to subscribe to the show.

00:53:43.200 --> 00:53:45.700
Open your favorite podcatcher and search for Python.

00:53:45.700 --> 00:53:46.840
We should be right at the top.

00:53:46.840 --> 00:53:51.660
You can also find the iTunes feed at /itunes, the Google Play feed at /play,

00:53:51.660 --> 00:53:55.820
and the direct RSS feed at /rss on talkpython.fm.

00:53:55.820 --> 00:53:57.900
This is your host, Michael Kennedy.

00:53:57.900 --> 00:53:59.400
Thanks so much for listening.

00:53:59.400 --> 00:54:00.440
I really appreciate it.

00:54:00.440 --> 00:54:02.200
Now get out there and write some Python code.

00:54:02.200 --> 00:54:22.960
I'll see you next time.