#438: Celebrating JupyterLab 4 and Jupyter 7 Releases Transcript
00:00 Jupyter Notebooks and JupyterLab have to be one of the most important parts of Python when it comes to bringing new users into the Python ecosystem.
00:08 And certainly for the day-to-day work of data scientists and scientists in general who have made some of the biggest discoveries of recent times.
00:16 The Jupyter platform has recently gotten a major upgrade with JupyterLab 4 released and Jupyter Notebook 7 being significantly reworked to be based on the changes from JupyterLab as well.
00:27 We have an excellent panel of guests, Sylvain Corlay, Frederik Collonwall, Jeremy Tuloup, and Afshin Darian here to tell us about what's new with these and other parts of the Jupyter ecosystem.
00:38 This is Talk Python to Me, episode 438, recorded October 16th, 2023.
00:43 Welcome to Talk Python Me, a weekly podcast on Python.
01:01 This is your host, Michael Kennedy.
01:03 Follow me on Mastodon, where I'm @mkennedy, and follow the podcast @talkpython, both on fosstodon.org.
01:10 Keep up with the show and listen to over seven years of past episodes at talkpython.fm.
01:15 We've started streaming most of our episodes live on YouTube.
01:19 Subscribe to our YouTube channel over at talkpython.fm/YouTube to get notified about upcoming shows and be part of that episode.
01:27 This episode is brought to you by Phylum.
01:30 Developers and data scientists are the new high-value targets.
01:32 That's you.
01:33 And yet this group remains severely underprotected.
01:36 Phylum detects, reports, and blocks malicious packages.
01:40 Get their research and join their community at talkpython.fm/phylum-research.
01:45 And it's brought to you by Python Tutor.
01:48 Visualize your Python code step-by-step to understand just what's happening with your code.
01:53 Try it for free and anonymously at talkpython.fm/Python-Tutor.
01:57 Hey, Darian, Jeremy, Sylvan, and Frederic, welcome to all of you to Talk Python and me.
02:04 It's great to have you here.
02:05 Thanks, Jeremy.
02:06 Yeah, thanks.
02:07 Thanks, Michael.
02:08 Yeah, you bet.
02:09 And so many Jupyter team members, people around here, and all the work you've done on the different parts of Jupyter Notebook, JupyterLab, JupyterLite, all the things is really fantastic.
02:21 So I'm looking forward to celebrating the new releases.
02:24 They're not quite as new as when we first started talking about this.
02:27 It took us a while to put this many people together on for an hour, but yeah, it's still, it's going to be great, right?
02:32 Sounds good.
02:33 Yeah, for sure.
02:34 So before we get into the topics, maybe just a quick introduction for each of you here, and we'll go around the Brady Bunch circles in the video.
02:42 Darian, we'll start with you.
02:45 Hi, so I'm Darian.
02:46 I work at QuantStack along with everyone else on this call.
02:52 And I have been working on the JupyterStack for about eight years now.
03:01 And I originally started working on what became JupyterLab.
03:08 And nowadays, in addition to that aspect of things, I'm also part of the Jupyter Executive Council, which is one of the governing bodies of the project.
03:17 As of this year, we actually changed our governance structure.
03:21 And so each year, there are elections and we have this new set of governing institutions that I've been a part of.
03:28 That's really fantastic.
03:29 So there's a lot of projects where there's one maintainer who is primarily the maintainer.
03:35 Then there's projects that get put under an organization, you know, like Flask with Palettes.
03:40 There's not very many open source projects like this that have governing bodies.
03:45 You know, Python itself comes to mind, Django.
03:48 That's awesome.
03:49 I think, you know, Jupyter is such a vibrant ecosystem.
03:52 It's an exciting space, for sure.
03:54 Yeah, absolutely.
03:55 All right, Jeremy, quick background on you.
03:57 I'm Jeremy and I've also been working on the JupyterStack for a couple of years, I think something around five or six years.
04:04 I started a bit like on my own first, like a spare time thing, you know, contributing to projects on GitHub before joining CronStack.
04:14 And currently, I'm mostly involved in the JupyterLab project, also the Jupyter Notebook 7, Voila dashboards, also a bit of IPy widgets, and most recently on the JupyterLite.
04:28 Hi, everyone.
04:29 So yes, I'm Sylvain.
04:30 I'm the CEO of CronStack, which I founded in 2016.
04:33 I've been working on the JupyterStack for about 10 years now.
04:37 So yeah, it's been a while.
04:39 I think it's almost the anniversary right now.
04:42 And in the Jupyter ecosystem, I mostly worked on kernels, widgets, the Jupyter server, and a tiny bit on the front end pieces as well.
04:52 So it's a Jupyter space over there at CronStack.
04:56 Top to bottom, right?
04:57 That's right.
04:59 Hey, Frederic.
05:01 Hey, everybody.
05:02 So I'm Frederic.
05:03 I'm working at CronStack as everybody else.
05:06 And I'm working mainly on JupyterLab.
05:09 I'm actually the representative to the software steering council of Jupyter for that sub project mainly.
05:16 And I started contributing like a bit like Jeremy five to six years ago, trying to convince colleagues in my aeronautics company back then to use Python and Jupyter instead of Excel.
05:30 You're fighting the good fight.
05:31 That's awesome.
05:32 Maybe I could ask you all a quick question since it might give people an interesting view into the world of Jupyter.
05:37 It's just, you know, there's a lot of reasons people get into programming, but what attracted you all individually to the Jupyter ecosystem itself?
05:46 Darian, how about you?
05:48 So I got lucky.
05:49 I liked the idea of working on open source software.
05:54 And I'd worked at a few startups that released open source software, but they were startup projects that were driven primarily by one company.
06:03 And some of them had community in the sense that there were lots of users and there'd be a lot of traffic, say on forums and stuff, but not community in the sense of a public minded group runs this thing and makes decision.
06:15 It was the decision was at my employers.
06:18 And nonetheless, I liked it.
06:42 Now I think that's still the same.
07:20 It turns out none of those were necessary.
07:21 You could make it way easier for people.
07:23 So I liked working on that.
07:24 I liked the community.
07:25 I like the people and that's why I'm still here.
07:30 It is pretty unique of an idea to say we're going to have kind of a document, we're going to have results and we're going to have code and it's going to be live.
07:37 And that's very special.
07:38 Jeremy, how'd you get into Jupyter?
07:39 Yeah, I started as a user, I think back in the days when it was still the IPython notebook, like altogether just Python, the programming language.
07:53 I think that was really this idea of being able to write normal text alongside code and have this kind of narrative with charts, interactive graphs and so on and share that with people.
08:06 So I used it on my own.
08:08 For personal projects, but also different companies to share reports, then communicate results more easily.
08:16 And after a while, when you start using a tool, you want to make fixes to it or improve it.
08:21 So that's how you can go to the side of the contributor side, start submitting pull requests and getting in touch with the community.
08:30 Sylvain, I'm going to come back to you.
08:31 Frederic, let's have your story.
08:33 So that's a bit like Jeremy.
08:35 So as I said, I try to convince people that something better than Excel exists out there.
08:41 And that's when I discovered Jupyter.
08:43 And what was really interesting was the ability to, like, as I've said, mixing very nice and advanced visualization with text and being able to do that interactively so that in a meeting you don't have to remember which tab in your Excel is the right result.
09:02 It's like, yeah, you just type two lines of Python code and you get a nice graph to display the points you try to make from the data.
09:10 And that was it.
09:11 And as Jeremy, then at some point you say, hey, I can do some stuff better and I can contribute because it's open source.
09:18 So I put my finger in that and now all my body is in it.
09:42 And that's a little bit different, isn't it?
09:43 I think nowadays with the maturity of TypeScript as something that serious, large projects can use, it's a little bit better, but you know, it wasn't obvious to us as a foregone conclusion that we should use TypeScript back in 2015.
10:03 So I think over time that problem has somewhat attenuated, but it's not, we're not in the clear.
10:12 We do definitely have a lot more people who would like to hack Python than would want to contribute to a gigantic TypeScript plugin based, you know, front end application.
10:25 Yeah, exactly.
10:26 They come to Jupyter cause they're like doing Python.
10:28 They get really excited.
10:29 Like I want to be part of this.
10:30 I want to help.
10:31 Oh wait, hold on.
10:32 It's a bit of a, an irony or maybe even web assembly as we'll talk about Jeremy.
10:36 All right, Sylvain, back to you.
10:37 So I wanted to change the question a little bit for you and just maybe have you talk about like what are the benefits of having QuantSite, like the whole company being so in on Jupyter, like how's that affected you all?
10:48 Is that for your business?
10:49 This is really how it started actually.
10:50 So I was a Jupyter contributor back in a previous job before I founded QuantStack and I really, QuantStack is almost an accidental startup in that I started the company as a means to continue working on the project being paid by, as I was a core contributor already being paid by clients on consulting contracts and whatnot to, to continue working on this.
11:17 And very quickly we had enough business that I could hire one other person and then another and then another.
11:24 So we bootstrapped from day one.
11:27 So our success, I would say is really bound to the success of the project.
11:33 And I think it's been a positive feedback loop since the very beginning.
11:38 It's, I'm sure it brings a real advantage when people come to you to look and sort of see like, yeah, this is the company to help me with, you know, Jupyter type of change, maybe adopting Jupyter or some advanced deployment problem solving.
11:50 Yeah, this, I mean, we're not trying to be the Jupyter company.
11:53 There are other groups and we really have a consulting business model in that people can really come to us for our skills and expertise.
12:04 And it turns out that so far we've been able to contribute back everything that we've done or nearly everything.
12:10 In some occasions we have to do something that's very ad hoc to a client and, you know, some development that requires using some of their internal APIs or whatever.
12:18 But like I would say that 99% of our work is out there.
12:22 So yeah.
12:25 Let's start talking about just a recent event here.
12:26 A couple of months ago, it was JupyterCon.
12:30 I think the videos, now the videos have been up for two months.
12:32 So a little, it's been around for a little while, but multiple of you, I don't know if all of you, I haven't gone through all of the videos here, but you know, there's 86 sessions posted for JupyterCon 2023.
12:43 There's a ton of good stuff.
12:45 Maybe you all could just speak to the talks that you gave there or some of the real interesting things that you want people should maybe check out, because if you just get into Jupyter, you can learn a lot by watching some of these talks, I think.
12:57 Our recommendation, Jupyter Notebook 7 was talk where Jeremy and a few other contributors to the project introduced the new version of Jupyter Notebook.
13:10 And usually when you go from version six to seven of a software package, it's, you know, an iteration, but in this particular case, it's a whole new application with a whole new architecture that has the same experience of the Jupyter Notebook as version six, but has all new architecture and can use the same plugins as lab.
13:30 And it's pretty exciting.
13:32 So I would recommend checking out that talk.
13:36 That was a good one.
13:37 I think that's something that's main topic of the show is sort of this interplay between JupyterLab and Jupyter Notebook and both of the big new releases, which is, yeah, it's a big change, isn't it?
13:48 Bigger than just the six to seven would indicate.
13:51 There are also plenty of other videos.
13:52 So there are quite a few, let's say technical videos or more like product updates as we call them.
13:59 Like each sub project has a talk where they discuss and present their new features or what they've been to the past few months.
14:09 But there are also quite a lot of interesting talks on use cases so that we can learn how people use Jupyter in the wild, like at companies, also in education.
14:20 And those are very inspiring.
14:22 So because they also give people ideas on what they could do with Jupyter in general.
14:28 Well, yeah, well, I certainly recommend people check this out.
14:30 And then there was a talk that you, Darian and Martha gave introducing JupyterLab 4, right?
14:37 Yes, that's right.
14:38 JupyterLab 4 is also the first time we did one of our keynote product launch talks with the desktop version of the application, just kind of to expose people to this new way to use JupyterLab, which isn't super new, but I think is new to most people.
14:59 So we thought that would be a good opportunity not just to show the new JupyterLab 4 UI and its new features, but also to show you can download it onto your desktop, double click a notebook and open it up in JupyterLab.
15:11 This portion of Talk Python to Me is brought to you by Phylum, your Python developer security partner.
15:17 Developers and data scientists are the new high value targets.
15:20 That's you.
15:21 Yet, this group remains severely underprotected.
15:24 Hackers know that developers control the keys to the kingdom, SSH, GPG and signing keys, API tokens, infrastructure secrets and proprietary source code.
15:34 Do you use open source dependencies in your code?
15:37 Of course you do.
15:38 We all do.
15:39 Vulnerability exploits in open source code are rare, but software supply chain attacks via malicious dependencies are unfortunately kind of common now.
15:48 And these attacks can compromise developers and organizations.
15:52 Phylum detects, reports and blocks malicious packages, while other solutions you may have heard of merely look for known vulnerabilities.
15:59 Of course, Phylum also reports on vulnerabilities as well as author, engineering and license risks.
16:05 But critically, Phylum doesn't wait for a CVE to be published before alerting on bad packages.
16:11 Phylum provides integrations to protect developers where they live, guarding PRs and CI environments and with CLI and pre-commit hooks for local development work.
16:20 Help you and your organization's Python security game with Phylum.
16:24 Get started today.
16:25 Subscribe to their newsletter to get Phylum's research sent directly to you or even sign up for their service for free.
16:31 Visit talkpython.fm/phylum-research and enter your email in the subscribe to our research field in the middle of the page or create your free account by clicking the sign up button in the nav bar.
16:43 Stay safe out there.
16:44 Visit talkpython.fm/phylum-research.
16:47 That's P-H-Y-L-U-M-dash research.
16:51 Thank you to Phylum for supporting the show.
16:55 Let's set the stage about just what, you know, people maybe they've heard the word Jupyter, have heard the word notebooks, plural, you know, but they might not know the difference between JupyterLab, Jupyter notebook.
17:08 Maybe you all could like sort of position those two side by side.
17:12 What are these two different things?
17:13 Are they the same?
17:14 Are they different?
17:15 Are they synonyms?
17:17 There is a file format that you will see with the extension dot IPYNB because historically was the IPython notebook file format.
17:27 And we've kept that.
17:28 And those are called Jupyter notebooks.
17:30 Commonly, it's a generic term for that kind of file.
17:34 And then there is a browser based application that millions of people use for rendering those notebooks and writing them and authoring them.
17:44 And that application is called Jupyter notebook.
17:46 And we just released version 7 of that.
17:49 And there is a data environment that features notebooks, but also has lots of other functionality that we call the other front end.
18:00 And that's Jupyter lab, right?
18:03 And Jupyter lab has a notebook renderer in it, among other things for Jupyter notebooks.
18:09 And that same notebook renderer is what powers the application called Jupyter notebook.
18:16 I think if I keep saying these words, you'll get more confused.
18:19 So I'm stopping here.
18:21 In my mind, I sort of think of Jupyter notebook as, you know, which is the single page, the single file view type of thing.
18:30 The little bit, not quite the right analogy, but a little bit like the Vim or the Emacs user who likes just to have like a single file totally open and just focused on that.
18:38 Whereas Jupyter lab is more like the IDE style.
18:41 I want all the tools and the extras.
18:43 I want to be able to get to my, browse my file system, go to the terminal, do all the different things and have like multiple files open and work between them.
18:51 Is that a good mental model or am I not quite there yet?
18:54 No, I think that's right.
18:56 Jupyter notebook is a single document interface.
19:00 It is, I mean, even like Vim, it has a command mode and you know, an edit mode and all those.
19:05 So it's not about analogy at all.
19:07 Jupyter lab is just a really flexible environment to do a lot of different activities in your analysis of any particular data.
19:17 It is a much more sort of multi-tool for that.
19:22 Okay, excellent.
19:23 Anyone else want to add more to that?
19:25 Those comparisons or the derringer?
19:26 Yeah, I mean, for the genesis of this, of Jupyter lab, I mean, the first tool that everybody saw and the whole world saw in the beginning in 2014 was the notebook, right?
19:37 And got a lot of people excited, but there was a, like a very recurrent request for bringing together in the same page, the text editor, the terminals, the having a console as well as regular Python console alongside the notebook in the same, on the same page.
19:54 And so this is what we delivered with Jupyter lab.
19:57 And even though it was a very popular, like common demand from the community, a lot of people really loved this more rigid full page notebook UI and kept using the notebook.
20:11 So this is where we were about two years ago when we started the discussion about notebook seven and modernizing the classic notebook user interface.
20:24 Was there ever a time where people were thinking to have Jupyter lab be the next version of a Jupyter notebook and kind of replace it?
20:32 And then the people are like, you know what, maybe please don't take that away.
20:36 No, it was definitely at some point our strategy to deprecate the notebook eventually.
20:44 And we had a large public conversation about this.
20:49 And it just, I think is clear that people like having that choice.
20:54 People like having what is just a simple editor for notebooks.
20:59 And people also like having the Swiss army knife, and they're not always the same people, but we want everyone who is using these things to be able to get both the benefit of the modern architecture and the updates and also the user experience they want.
21:17 Because most of the plugins that come out lately are for Jupyter lab, and you're feeling more and more left behind.
21:23 That's not a great experience.
21:24 And so deprecating that tool you're using and saying you must use this other one, it just isn't what our community needed.
21:32 So now we I think have an architecture that we can sustainably maintain, because it's effectively the same code base.
21:40 But we also can give users what they want, because there are different contexts.
21:46 And it is the case that we would have left some people behind and it's better not to.
21:50 I can imagine in different scenarios, different user bases, it might make a lot of sense to have one or the other, right?
21:57 If I'm a data scientist working on complicated projects, maybe Jupyter lab is the right place.
22:03 But if I'm trying to teach a little bit of computation for a psychology class, and I just want them to do three plots and pull in some data, you don't want to drop non developers into something that looks kind of complicated.
22:15 Like, where do I go?
22:17 Here's your page, you type in these cells, you see the picture, you get the graph for the study we're talking about or something, right?
22:24 Yeah, that's exactly the idea.
22:27 So you touched on something interesting there that Jupyter notebook, the single page or the single view version is now based on Jupyter lab.
22:36 And there's a lot of overlap of these things, right?
22:39 I don't know if it was the right time to go more into the details.
22:42 But give us a little, it's a bit of a jump ahead.
22:45 But I let just give us a sense that people who maybe people are listening, go, I'm not going to use Jupyter lab, I'm kind of the notebook type of person, right?
22:52 There's a lot of what we're talking about that still directly applies, because there's a bunch of similarity or actually reused, right?
22:59 So one thing we didn't mention yet about Jupyter lab is that, so for end users, it is indeed a more advanced environment with more like an ID, even though it's not really an ID.
23:10 For developers, it's also a framework.
23:13 So Jupyter lab itself is just a set of plugins and extensions.
23:18 They were designed from the very beginning to be reused in, you know, in different ways.
23:23 So like, in a few, actually, if you go to the Jupyter repo, there is an examples, a folder.
23:30 And in there, there is a, there are a few, a few different apps that you can build yourself.
23:34 And they are not Jupyter lab.
23:36 They are like just a single cell on the page, or maybe just, yeah, this one, maybe just a console, maybe just a notebook.
23:44 And this is made possible because Jupyter lab is indeed just a set of extensions.
23:49 These examples, they just reuse some of them and they just put them together in a different way.
23:54 So we sometimes call them remixes.
23:57 And in the end, notebook seven is a Jupyter lab remix.
24:01 It's just a different Jupyter lab interface, but focused on the document centric experience that, you know, users have been liking for many years already.
24:13 So yeah, that's a bit of the second side of Jupyter lab.
24:20 There's a bunch of features that we're going to talk about here that come to Jupyter notebooks in seven, because yeah, seven, you can get the right version for the right product because of what you all have done here, like interactive debugging and real time collaboration and things like that.
24:37 All of that was really a by-product of moving over to the Jupyter lab architecture.
24:40 And one other key aspect of notebook seven over notebook six is that since we use the text editor from Jupyter lab four, which is a newer version of code mirror, we also get a lot of benefits in terms of accessibility.
25:10 And so we're in a much better shape on this regard with Jupyter lab four and notebook seven.
25:18 That's right.
25:19 Quite a bit.
25:20 Let's start by talking about some of the new features for Jupyter lab.
25:24 One of the ones is for very large notebooks, Jupyter lab is quite a bit faster, right?
25:29 That's, that's excellent.
25:30 Who wants to take that one?
25:32 I nominate.
25:33 Yeah, I can go ahead with that one.
25:35 Go ahead.
25:37 So yeah, that's one of the complaint of the user is that when you get lots of notebook open or when you get some notebook that are very lengthy, the UI responsiveness can be low.
25:51 And so we decided to focus quite some time on that aspect.
25:56 And that was made possible by fully upgrading the text editor to the latest version.
26:01 So we are using CodeMirror.
26:03 So for party, awesome for party library for dealing with text editor.
26:09 And we upgraded the latest one that bring up a very important speed up.
26:13 And also we, we have work on the styling to try to optimize it because styling can hit your browser pretty hard.
26:21 And lately we have also introduced a new way of rendering notebook, like only rendering what the user is seeing basically.
26:31 That one is still experimental.
26:33 So by default, this off and user can try it.
26:36 And we are still working on that one to get it on by default for the next version.
26:42 So for 4.1.
26:44 Hopefully when we reach that milestone, we get like a very smooth experience for 99% for user.
26:53 That's the goal.
26:55 It's tricky because web browsers typically want to just have the whole document, the DOM loaded and they want you to just work with it.
27:02 But if you've got a hundred, hundred virtual pages, right, that you would go through, you don't want to style all those and do all the widgets and all that if they're not on the screen.
27:13 So there's this tension.
27:14 And sometimes it can come from tricky part, like just displaying for education, for example, they use and that's very nice.
27:21 All that's of equation, nice rendering.
27:24 And those are creating so many elements in the webpage that sometimes just having not so long notebook, but if we've lots of math expression can crush your browser, basically.
27:36 That's surprising at first.
27:38 All right.
27:41 So what I'm hearing is like complex math, like calculus, differential equations, those kinds of things, not just hard for people, but also hard for web browsers.
27:50 Math is hard for web browsers.
27:51 Got it.
27:52 That's pretty interesting.
27:53 Darren, you showed in your talk, you showed this off in a video, a side-by-side Jupyter Lab three versus four with a large notebook.
28:01 And it was much faster.
28:03 Did that video have the virtual paging, like the render, the scene culling thing where it doesn't show it doesn't render the stuff it doesn't see, or is that just the first default version right now?
28:15 This is where I come clean to your audience and say, Fred is the person who produced and recorded those videos.
28:21 And okay.
28:23 Fred was originally going to give that talk.
28:24 I can tell you that.
28:25 Yes, that's exactly what's going on.
28:27 But Fred can give you the actual details because he's the one who hit the record button.
28:33 Tell us, Fred.
28:34 I have a very happy event that prevent me to go to the JupyterCon.
28:36 So I was mentioned, normally you was the one that had to do the talk with Marta, but we had to switch last minute and thank again, Afin for doing that.
28:45 But definitely the video that was displayed was that we, it's a comparison between the latest 3.6 version and the four version with that feature that's off for now by default, but we'll bring the best performance for the end user.
29:01 It was a massive speed up.
29:03 You know, on one hand you're like, ah, you're just waiting 10 seconds, but those kinds of little delays, they just kind of break your thought and your flow.
29:10 And you just feel like the tools are getting in the way.
29:13 And if it's really, really quick, then the tools kind of vanished to the background and you don't think about them.
29:19 That's how it should be.
29:21 Even when, even when rendering all of the notebook and without enabling the virtual scrolling, we get already a nice speed up already, thanks to the adoption of CodeMirror 6, which is much faster to render and a bunch of other optimizations that we were able to do.
29:36 But yeah, I mean, it was the easiest clap in the entire talk was just playing that video and seeing the fast one render and the slow one keep going.
29:44 It just, it's a really different user experience, even though, as you say, it's only a few seconds, it turns out a few seconds is enough to cause the kind of interruption that leaves a negative, a negative overall impression in the user's experience.
30:03 This portion of Talk Python to Me is brought to you by Python Tutor.
30:11 If so, check out Python Tutor.
30:14 This free website lets you write code, run it and visualize what happens line by line as your code executes.
30:20 No more messy print statements or fighting with the debugger to understand what code is doing.
30:25 Python Tutor automatically shows you exactly what's going on step by step in an intuitive visual way.
30:31 You'll see all the objects as they are represented in Python memory, and how they are connected and potentially shared across variables over time.
30:39 It's a great free tool to complement what you're learning from books, YouTube videos, and even online courses like the ones right here at Talk Python Training.
30:47 In fact, I even used Python Tutor when creating our Python Memory Management and Tips course.
30:53 It was excellent for showing just what's happening with references and containers in memory.
30:58 Python Tutor is super easy to check out.
31:00 Just visit talkpython.fm/python-tutor and click visualize code.
31:05 It comes preloaded with an example, and you don't even need an account to use it.
31:09 Again, that's talkpython.fm/python-tutor to visualize your code for free.
31:13 The link is in your podcast player show notes.
31:16 Thank you to Python Tutor for sponsoring this episode.
31:20 This is not a JupyterLab feature exactly, but while we're on this code editor topic, I wanted to ask you all just your thoughts about this.
31:29 Now keep in mind before I ask this question, my perspective.
31:32 I've come from doing a lot of traditional software development with editors like PyCharm and Visual Studio Code and others.
31:39 So when I work in Jupyter Notebook or Lab, it doesn't really matter.
31:44 And I'll say some variable dot.
31:47 It doesn't give me any help unless I press tab to see the autocomplete.
31:52 Is there an option or discussion around having more aggressive autocomplete that kind of automatically shows up as you work with it?
32:00 Or is the community just like, we don't really want that stuff popping up around.
32:04 We just want to type.
32:06 So the reason it's currently this way is primarily due to the behavior of Jupyter Notebook a long time ago and not subverting user expectations.
32:20 But we can often keep that as the default and have some setting to facilitate a different kind of behavior.
32:30 With this one, I think there's probably actual appetite for it, but no one's shown up to do it.
32:37 I don't think we would turn down a feature like this hidden behind a setting.
32:40 I just don't think anyone has both been bothered enough and also been in the time and place with the resources and where it would fall necessary to do it.
32:50 But it doesn't sound...
32:52 Yeah, it sounds totally doable and compatible with both keeping the user expectations intact and offering you the feature you're talking about.
33:00 Because yeah, people have different styles of completion that they're into.
33:04 And new things are appearing all the time and creating new expectations like LSP, which changes the language.
33:09 It changes the language server protocol.
33:12 Anyone else have thoughts on that?
33:13 I would say that in 4.1, there are things coming to at least give you the ability to more quickly restore history.
33:21 Like you type and then it's going to propose you to copy paste the code that was written previously in some previous cells and stuff like that.
33:31 And the same infrastructure will be available for plugins.
33:38 And I know some people are working on AI integration in Jupyter and some of them are already working and okay, let's try to do a request when the user is typing to help him complete the code or give him a hint on how to improve things.
33:54 And yeah, there are a couple of people working on that.
33:58 So stay tuned for more.
34:00 Yeah, okay.
34:01 I really liked JupyterLab and working it now.
34:03 But if you could just go and these are all the things you can do just as I would, you know, I would make me even more happy.
34:08 Darn, you mentioned settings and that's actually one of the new features as well as like a UI for settings.
34:15 Is that right?
34:17 So this is basically a front end that's capable of taking any extensions, defined settings and rendering a UI for it because we don't know what the preferences and extension author is going to want are going to look like.
34:35 We can't create like a custom UI for it.
34:38 Instead, we have to read a schema file that defines such like the extension author who wrote an extension that does git, right, also has a whole bunch of booleans that are by default set to true.
34:54 So this UI is like, oh, okay, cool.
34:55 I'll bring a bunch of checkboxes and check them.
34:58 And so it's very flexible.
34:59 It can take any extension settings and as long as they're described properly, according to the API, they will render inside that UI.
35:07 And it really meets what we used to have there, which is just a JSON blob editor.
35:12 Here you go.
35:13 Here's your JSON.
35:14 Good luck.
35:15 And we tried to make it slightly nicer.
35:17 I think we tried to make it support a version of JSON that has inline comments as well, but like it's still not that nice.
35:26 So I'm very happy to see this as the way you go playing around with all the choices you have because JupyterLab has a lot of settings, but it's really difficult to explore them without something like this.
35:39 Especially with all the extensions kind of unbounded set, right?
35:44 The settings UI has a search that searches through all the different areas for settings.
35:48 It's one of my favorite things on complex apps.
35:50 I mean, like, I don't know what, what is in here, but I bet if I start typing, it'll reveal itself if it's in there somewhere.
35:59 JupyterLab has two places like that.
36:00 One is the command palette.
36:02 So let's you search the entire menu system basically.
36:05 And that's become, you know, in other ideas too.
36:08 I mean, I think there's a certain point as a user of these tools where you discover something like that.
36:15 And then after that point, you don't want to go back.
36:18 So I think you're right.
36:20 Like I didn't used to always need search in my applications, but now I do just like you say.
36:25 Yeah, exactly.
36:26 This really goes into the thing we were mentioning earlier about JupyterLab remixes.
36:30 So as you know, JupyterLab is basically only a collection of extensions, right?
36:34 And the notebook itself, the command palette, all of these things are extensions to the core app, right?
36:41 And the, so remixes are a way to cherry pick some of these core extensions, potentially include third party extensions into a new thing.
36:51 I think that there are not many equivalents to JupyterLab in that regard.
36:56 If you try to make a new complex application in the web, like a photo editor, a CAD engine, anything that falls into the category of having to display a lot of information on the screen, doing something that you spend hours doing every day, you will want a framework that allows extensibility, theming, a command palette, unified keyboard shortcuts across the application, a settings editor for your main app and all of your extensions, configurable keyboard shortcuts, I mentioned that earlier, potentially real-time collaboration.
37:30 And these are lots of checkboxes to check if you are starting from scratch.
37:36 And so the JupyterLab basically application framework allowed us to reuse all of that work for other things that have nothing to do with the notebook, for example.
37:47 So earlier this year, we released JupyterCAD, which is a web-based CAD modeler, which is a JupyterLab remix, really.
37:54 It can be used both at the JupyterLab extension where you find everything that you're used to or in a standalone fashion.
38:01 And this JupyterCAD is really interesting.
38:03 It's a 3D CAD curated design editor that's built on top of the JupyterLab framework, but it's not itself exactly about Jupyter, like programming and so on, right?
38:16 And it has really interesting things, like it has real-time collaboration between multiple people and all of that stuff comes from just building on top of this, like you said.
38:24 That's a good example of something really different, but still possible.
38:29 So in the way we enable real-time collaboration in JupyterLab, we have to specialize a few things depending on the type of document that you're editing, but really the framework is generic and you can start enabling real-time collaboration and other types of content than just textual content or whatnot.
38:47 And we all got used to real-time collaboration and collaborative editing on text, you know, on the sort of software suite that we use for basic productivity, but very convinced that this will be the case for more technical computing, not just code, but everything where you have to put together a really complex system.
39:07 Like especially if you are building something that really requires a lot of people to coordinate, like you're making a new plane or a football stadium, and you have this unified model where everything percolates across many domain-specific applications from CAD to electrical systems or whatnot.
39:25 And for people to effectively collaborate in these kinds of environments, I think collaborative editing is going to bring a lot if we can implement this vision.
39:34 So really JupyterCAD is a demonstrator that you can do collaborative editing on other things than just notebooks.
39:41 And I think the collab may become the foundation for things that we would never expect to be part of programming.
39:45 Like you're talking about, it's interesting.
39:48 It's more technical computing than just, you know, interactive computing, I would say.
39:53 I was thinking about this book here, like, oh man, this book is thrown around as like, by Fred Brooks, basically saying like, there's no project where adding more and more people, it's going to speed it up and get it done more on time.
40:07 And I was thinking about sort of the follies of like, well, as you add more people, the complexity of the communication and the overhead of syncing and all of that is kind of going to break everything.
40:17 And so, you know, you, you can't make a baby in like one month by having nine women work on it and sort of story, you know, like, but the stuff that you're talking about here and all of this communication tools and all of this interesting async stuff that we're doing these days, I kind of feel like people should rethink these ideas.
40:34 And I think kind of what you're touching on here is like, it is possible to get deeper, important work done as a groups, then maybe the methodology that people think about in the software world traditionally has been, it's a different world in 2023 and on.
40:49 I mean, it's kind of a sidebar of it.
40:51 It's also important to what this, this collaborative editing.
40:54 I like this book.
40:55 So for a long time, we have been trying to introduce real-time collaboration to Jupyter.
41:00 We've had at least three significant technical attempts at it, right?
41:06 It's a hard problem.
41:07 It's one we've worked on a long time, and it's given me a unique opportunity that most people don't have, which is try to justify to myself over the course of six years, why anyone should want real-time collaboration inside a programming environment.
41:24 And what I can say is over that time period, I have spent, I don't know, hundreds of hours inside documents with other people that are markdown files, because that's how we conduct our meetings or inside Google Docs, because that's how we wrote our governance or asynchronously back and forth on GitHub, which is not exactly the same thing, but truly is collaboration.
41:50 And so I don't think there's a tension between there's a group of us working on something in a room and we want technical tools so that we don't all have to be in that room, but we can have that seamlessness and the myth of the mythical, you know, the man month, right?
42:07 I actually think those problems are like on the surface, they look pretty similar, but I actually think they're not the same thing.
42:15 It's more like back when that book was written, groups of people would get inside one room and work collaboratively.
42:22 Today, every one of us on this call is in a different location and some of us are pretty far apart.
42:28 We're in different countries and it's all working out fine.
42:31 And Jupyter is bringing tools like that to people and less tools like let's add 5,000 people.
42:37 Now what Sylvan was talking about still, you know, you're not going to have one person opening up the grand document that describes like the whole Coliseum, right?
42:47 But there's going to be tons of groups that are working on systems where there's like seven people who need to work on this thing together.
42:54 And Google Docs for wiring documents doesn't exist yet, you know, but it could exist.
43:00 And it could be built on JupyterLab.
43:01 That's right.
43:02 One of the big features is this real time collaboration.
43:03 Let's, you know, let's talk about that for a moment.
43:06 I think that's, I think it's a big deal as I've been hinting that with my sidebar and so on.
43:11 But in the beginning, I think we need to start small.
43:15 Even with, you know, Google Docs when it came out, I think in 2006, a lot of many people didn't see the point.
43:21 Like why would I want someone else's cursor in my document?
43:24 It sounds dangerous, right?
43:27 So if you were to make a survey of what people wanted at the time, nobody would have said that, right?
43:35 Yet everybody does that now, right?
43:37 And it's probably, people probably have the same feeling when it comes to writing code or doing any sort of technical work.
43:45 And I think we'll get past this point where people will get it.
43:49 And in the very beginning, this can start being useful for peer programming, doing something together while we're reviewing code over a Zoom meeting, that sort of thing where, you know, there is a, you know, real time interaction between people over some kind of medium.
44:07 If you look at more technical objects, like for example, you have two different teams, like someone's making a plane, there is a team of people that's doing some simulation and see how, you know, the plane goes through the air and another person is making physical prototypes of parts of the plane.
44:28 And you have this interaction.
44:29 Now, normally these two groups would be in two different branches of the company.
44:34 And in order to change any kind of spec, you need to go up and down in the hierarchy by a few, you know, degrees.
44:42 You schedule a meeting for next week, that sort of thing.
44:46 And you change the specs and now everybody has to change or make changes to their boundaries.
44:53 And if you enable more real time, you know, feedback on suggestions and whatnot, you may be become a lot more efficient.
45:01 So how's it, it's pretty similar to Jupyter, to Google Docs, excuse me.
45:06 You have to install the Jupyter Collaborator collaboration extension for the server, right?
45:12 In order for this to work.
45:13 It's not just, yeah, install JupyterLab and you're good to go.
45:17 Well, you can install JupyterLab and install Jupyter Collaboration if you need the one liner.
45:24 But the idea was lots of people install for personal use on their own laptops and anyone who's going to create an environment where collaboration is happening is doing more than running just one command to install Jupyter anyway.
45:36 Yeah, yeah, of course.
45:38 You know, so like as a toy, if the five of us are in the same network, we can launch it that way just to play around with.
45:45 But really any sophisticated user is going to tie in the user system and do a whole bunch of config and all those things.
45:50 And so we're not shipping the code that does that inside core JupyterLab for two reasons.
45:59 One is that, you know, the main sort of install base doesn't do real time collaboration.
46:06 The other is that we're working on that package much faster than we're working on JupyterLab core.
46:12 And having them in separate packages allows us to bump versions if we need without carrying that much and to add new features and to just, you know, it's a smaller subset, it can move way faster.
46:22 Yeah, that's a great design philosophy process because there was a conversation like this in core Python and requests are like, we have a URL library in Python, but requests seems to be the default.
46:34 We should move it in and be like, Whoa, Whoa, Whoa, you're going to make us ship requests once a year.
46:38 We don't want to do that.
46:39 This is not like, this is changing fast and it needs to be more adaptive.
46:41 And that sounds like a similar deal here.
46:44 Let's hit on some more of the new things.
46:45 So we've got one of the things that's new is cell toolbars.
46:51 There's like when I'm editing a cell within the little cell, there's a toolbar with some new features.
46:55 Anyone want to talk about that?
46:56 Yeah, that's exactly what you said.
46:58 One question often asked by extension authors is, okay, I want to do a certain thing to a specific kind of cell, right?
47:07 Like I want to somehow pull out this cell and do something extra with it.
47:11 Where do I put that button?
47:12 Or, you know, it's the answer to that question.
47:14 But really, all of the things that you can do were there before.
47:17 It's just meant to give users a discoverable way to learn maybe some capabilities they didn't know, or maybe even hover over the button and learn a new keyboard shortcut or something.
47:28 It's one of those quality of life features.
47:30 It's not like revolutionary.
47:32 It's more like just making this thing slightly more ergonomic.
47:35 Yeah, I was thinking when I saw that, I was thinking of, you know, the biologists who is doing their first semester of a class where they had to use Jupyter notebooks for their work and they're like, how do I, you just seeing those buttons there for the first month of working with it is helpful.
47:52 And as you point out, you learn the hotkeys and like I press B, I don't go over here with the mouse and those kinds of things.
47:57 But still, I think it's a nice one.
48:00 Let's see what else that I want to give a shout out to that we haven't done yet.
48:04 Oh, collapsing based on markdown headers.
48:07 That's kind of interesting that you can organize your document in a way to kind of expose parts or make it more of a report or more of a coding environment and these kinds of things.
48:17 Who wants to introduce that feature?
48:19 The idea was to, especially when you have some document that can be long, like from education that has lots of text and stuff like that.
48:27 It tells the student, for example, to be able to focus or to scroll artificially, let's say to the right place more faster.
48:38 So that's one of those nice features.
48:40 And I think it's something we're so now we are used to because lots of classical office text editor have that kind of ability.
48:49 So it was a nice feature to add to in JupyterLab.
48:52 Yeah, kind of related and it's probably going to sound really boring, but it actually is pretty awesome.
48:58 I think is the table of contents where it looks like it's showing the table of contents, but as it's, if you say run all cells, it'll actually show you as you go, it'll sort of like go down the table of contents showing where in like some big doc, if the running cell is off the screen, what it's working on currently, which is actually pretty excellent, I think.
49:16 And then soon you would also report that one side crashed and you should look at it.
49:21 That's coming up in the next version.
49:26 Okay, excellent.
49:28 What else?
49:29 Running kernels in the side panel sounds kind of interesting, like different kernels, you can go create notebooks based on them and see all of what is at play.
49:36 I think that's probably worthwhile as well.
49:40 So this is more something you would care about if you're running JupyterLab than notebooks.
49:46 So it's a sidebar in JupyterLab that just says, in the environment where you're running, here are all the kernels that you as a user can see.
49:55 And so you can even have kernels that might not be coming from your Jupyter server at some future date, right?
50:03 The idea being, why shouldn't JupyterLab be the place you interact with lots of different resources wherever they might be.
50:13 And for the longest time, we thought of a running kernel session, for want of a better word, as intricately tied to a file, right?
50:24 The notebook that it's the kernel for.
50:26 But you know, we've been moving away from that.
50:28 I mean, the same way IPython hits a kernel, but isn't really transient, we have code consoles inside of JupyterLab that aren't really transient.
50:36 But you can take a notebooks kernel and open a code console on it so that you could do some scratch work, but not modify your document.
50:44 So there's just having more insight into what's available in your environment is what that's about.
50:49 And again, it's not a revolutionary change.
50:51 It's just one of these sort of ergonomic features to make it a better multi-tool for being in an environment that gives you lots of different kernels to play with.
51:00 Like the sort of use case that we'd like to tackle with this is, for example, there are lots of desktop applications that embed a Python interpreter, like FreeCAD or Blender.
51:09 But eventually, if these desktop applications advertise a way to connect to these running interpreters with a Jupyter kernel API, then they would be listed there.
51:20 So the JupyterLab could almost become a scripting front end to like a running Blender project or something like that?
51:29 So this has already been done actually in Ketwer's Slic3r 3D project.
51:34 So they run a kernel as part of their desktop application.
51:39 And so we want to streamline that use case and make it more easier to do.
51:44 I'm sure the UI for a lot of people's hosted integrated Python is really poor.
51:49 You know, there's probably, maybe you'll get auto indentation if you're lucky, right?
51:54 You know, like it's just, there's not a, there's not a great story.
51:57 So they could just, like the other examples we talked about, build upon what JupyterLab is already doing and just add their part.
52:04 So instead of them having to reinvent everything, they can just reuse Jupyter.
52:08 And because of the extensions, you could theoretically have like a Blender extension for JupyterLab potentially.
52:15 Actually, someone has made one.
52:16 So for the specific use case, I think it's Jan Hendrik Muller has a Blender extension to render Blender model in line in the notebook.
52:25 So yeah, check it out.
52:28 All right, y'all, we're getting very short on time here.
52:30 There's two things I want to touch on really quick before we put a wrap on it.
52:33 These are not exactly like brand new things, but they're very exciting.
52:37 And one is JupyterLite.
52:39 And Jeremy, I know you've done a lot with JupyterLite.
52:41 You want to tell us quick, quick about JupyterLite?
52:44 Yeah, sure.
52:45 The idea behind JupyterLite is to have a full Jupyter distribution that runs in a web browser.
52:52 So normally when you use Jupyter, you need to install JupyterLab package, Python package, or the notebook Python package, your machine or on a server.
53:02 But with JupyterLite, you don't need to do this.
53:04 So in the end, what you get is just a set of static files.
53:09 So it's just a bunch of files sitting on this.
53:16 So the main difference compared to a traditional Jupyter installation is the fact that the execution, the environment runs in a browser as well.
53:27 So for example, Python, but it could also be other languages that are compiled to WebAssembly.
53:33 All of this is, again, built on the shoulder of Giants.
53:37 Yeah, this is awesome.
53:38 This is so awesome.
53:39 The Jupyter stack is just another way of kind of remixing the whole stack.
53:45 So you take a bit of JupyterLab, a little bit of the Jupyter protocol to interact with the kernels.
53:54 And then even the kernels can be reused in some way.
53:57 And then you put that together and make something new.
53:59 So that's the idea behind JupyterLite.
54:02 It was also made possible by the work on the Pyodite.
54:07 So this Python compiled to WebAssembly.
54:10 Since Python is still the most heavily used language in Jupyter, this is kind of what people expect when they use Jupyter and JupyterLite to have a Python kernel.
54:21 So if I wanted to say host some interactive code exploration, I want to have something that people can play with, maybe I'm an educator and I've got a thousand students, but I don't want to set up a server and worry about what people might do to it, but I want to give them flexibility, right?
54:37 Like this is really nice.
54:38 You could just put this on a static file server like Netlify.
54:41 Yeah, that's definitely a use case.
54:43 So GitHub pages, Orita docs, it's very simple.
54:46 It's much simpler than having to do sysadmin work to install packages.
54:52 And also for the end user is also simpler because they don't have to install anything.
54:56 Everything is already pre-packaged.
54:58 It's crazy.
54:59 It looks just like JupyterLab, you know, but it's...
55:01 Because it is in the end just JupyterLab.
55:04 And there is also a Notebook 7 running as well.
55:07 So again, like we were talking about earlier, if some users prefer to have this document centric interface, then they can also use a Notebook 7 instead.
55:16 That's excellent.
55:17 If you want to give some, give access to some notebook, but not run a server.
55:22 I think there's kind of two options here.
55:24 This is one of them.
55:25 The other is if I'm going to give a notebook file to somebody and say, here, run this on your computer.
55:31 There's a lot of assumptions about what happens at that point.
55:34 Do you have Python?
55:35 Do you have the right Python?
55:36 Do you have permissions to install Jupyter and all the other dependencies?
55:40 Can you run a server?
55:41 Do you know what a terminal is?
55:42 Like that's a long conversation.
55:45 And so I think the other thing that's really interesting, I don't know where I pulled it up, but yeah, Jupyter desktop is also quite interesting as a quick start to getting in a Jupyter Python environment on your system.
55:58 That's some work done by Mehmet and basically it bundled an Electron.
56:03 So it's a web browser that's packaged with JupyterLab.
56:06 And it's very powerful because now it can come with its own Python, but you can also use the Python that you have on your computer.
56:16 And yeah, that's really a nice way for distributing and easing the installation for the end user, especially on non-friendly operating system, let's call it like that.
56:29 Or people who are not familiar with it.
56:32 Like, yeah, I mean, you've got a Mac.
56:35 Well, there is a Mac OS ARM and 64 version.
56:39 There's a Debian and Fedora.
56:41 There's a Windows EXE like that's...
56:43 No, it's really solved the problem of I've never used the command line, but I know lots of math.
56:52 Yes, exactly.
56:53 But when I run MATLAB, I just click the MATLAB icon and then I get that shell.
56:56 What is, why can't I have permissions to install Jupyter?
56:59 It says I don't have...
57:00 No, I get it.
57:01 That whole frustration side could go away, I think.
57:04 This is interesting.
57:05 But I mean, this is a harder problem than one might imagine just because of how many packages there are in the ecosystem, what things you might be using.
57:15 So JupyterLab desktop is pretty clever.
57:18 It can also detect if you have Conda or Mamba installed and use those environments.
57:24 It can use a running server.
57:27 So it shifts with the newest version of JupyterLab, right?
57:30 But it could also connect to a server that's serving a different version of JupyterLab and give you that.
57:35 It can be a client to different JupyterLabs is what I mean.
57:38 One time, just to see if it would work, I ran Jupyter Notebook and Lab and Desktop with real-time collaboration and it turns out you could do that.
57:47 So it really is like first-class JupyterLab and it's very flexible and it tries to integrate with what you've got.
57:52 If you've got nothing, it brings what it needs.
57:55 If you've got Conda set up, it finds stuff there.
57:58 If you've got Mamba set up, it finds stuff there.
58:00 So it basically tries to be exactly what that first user experience you would want is.
58:06 You go, you download, you double-click a file.
58:09 The only thing that's missing is you have to go to GitHub to get this.
58:12 We should probably put it in an easier place for you to find.
58:15 Yeah, possibly.
58:16 Like maybe in the various stores.
58:19 I don't know.
58:20 That's such a hassle.
58:21 Well, no, I just mean go to jupyter.org.
58:22 I just said a URL.
58:24 Sadly, it's not going to work for you, but maybe we should do that.
58:27 Yes, exactly.
58:28 That would be a pretty easy thing to do, actually.
58:30 Just detect the OS and highlight that or have that all drop down and choose another OS, right?
58:35 See all downloads.
58:36 I think these two options are going to really make it possible to reach the next 10 million users of Jupyter.
58:42 Like, especially JupyterLite in terms of scalability is unmatched at the moment.
58:48 There is a deployment of an in-browser Jupyter flavor in use at the moment by the French high school system.
58:56 They started with the Paris area and now they enabled all the school districts there.
59:00 There is over half a million users on this deployment, 200,000 sessions per week.
59:06 And it's also one single virtual machine.
59:09 And if they were trying to do this with a one Docker image per user session, it wouldn't fly.
59:16 They'd need a massive IT team to pull that off.
59:20 And France is not home to hyperscaler cloud providers.
59:24 So we'd need to host that Azure or Alibaba or Google, and that would be an enormous cost.
59:32 And this is incredibly cheap.
59:35 There are some limitations to WebAssembly.
59:38 And I mean, for the sort of use cases, I know what a high schooler is going to do in a notebook, like learning how to write for loops or computing a greatest common denominator.
59:47 This is more than enough.
59:50 The complexity of it is lesser than rendering the UI.
59:53 So yeah, I think you're absolutely right.
59:55 That's why I put them both side by side, the JupyterLite and the Jupyter desktop app.
59:58 I think they kind of address similar audience, but in a different way.
01:00:02 Check this out, by the way.
01:00:03 This probably won't come through very well.
01:00:06 This is my iPad and I've got JupyterLite working just the same on my browser there as I did, or it'd be a Chromebook or whatever.
01:00:15 Like it really reaches a big audience.
01:00:17 I mean, modern browsers now can all handle it.
01:00:18 It's not the bad old days, at least on that front.
01:00:21 There will be a lot of really exciting things that happen inside browsers that will surprise anyone who was using this era of the web.
01:00:29 Like we're about to see crazy things.
01:00:31 We are about to see crazy things.
01:00:33 We already see crazy things.
01:00:34 We'll see more of them.
01:00:35 That's for sure.
01:00:37 All right, y'all.
01:00:38 I think we are out of time, but we are certainly not out of topics.
01:00:41 We could keep talking for a long time, but we'll close it here.
01:00:43 I guess final thoughts, call to action.
01:00:46 People want to check this stuff out.
01:00:47 Maybe they want to upgrade from an older version, either JupyterLab 4 or Jupyter Notebook 7.
01:00:52 What do you say?
01:00:53 pip install Notebook.
01:00:54 pip install JupyterLab and have fun.
01:00:58 Dash dash upgrade.
01:01:00 Good point.
01:01:01 I guess you already got it.
01:01:02 Pull request welcome.
01:01:06 So it's a huge project with lots of people involved.
01:01:10 Frederic, final thoughts.
01:01:12 That's a very fun project to work on too.
01:01:15 So if people are willing to contribute, just come and contribute to it.
01:01:20 There's plenty of spaces as we have just touched some of them here and we are very happy to have new contributors and help people learn the ecosystem to try to contribute.
01:01:31 And there is no small contribution.
01:01:34 There is no small contribution.
01:01:35 Everybody is welcome.
01:01:39 Somebody could set up the download page for Jupyter Desktop.
01:01:44 Jeremy, you get the final, final word.
01:01:46 Yeah, that was what I was going to say a little bit as well.
01:01:50 The Jupyter community is very welcoming, so you can contribute in many different ways.
01:01:54 It doesn't have to be about technical details or code only.
01:01:59 Even just putting a talk out there for support or going to JupyterCon and sharing your use cases is already very valuable to the community and also to the developers because they can learn about how people use the tools, get a very valuable feedback.
01:02:14 So that'll be your one call to action is don't hesitate to get involved.
01:02:20 And if you think there is room to improve, for sure, as I was saying before, PRs are welcome as we say often.
01:02:27 And yeah, check out the latest update on the JupyterLite because there is going to be exciting new updates to the JupyterLab 4 and the Book 7 coming in a couple of days.
01:02:39 So I think maybe by the time this podcast is released, it will probably be out already.
01:02:44 And also exciting developments when it comes to real-time collaboration in JupyterLite, JupyterLab Desktop, JupyterLab together.
01:02:52 Yeah, very exciting.
01:02:53 A lot of things are already great here that we talked about.
01:02:56 These are some big changes.
01:02:57 So thank you all for being on the show and sharing what you and everyone else has been up to.
01:03:02 Thank you.
01:03:03 Thanks very much.
01:03:04 Thank you.
01:03:05 Yeah, thank you.
01:03:07 This has been another episode of Talk Python to Me.
01:03:08 Thank you to our sponsors.
01:03:10 Be sure to check out what they're offering.
01:03:11 It really helps support the show.
01:03:15 Developers and data scientists are the new high-value targets.
01:03:18 That's you.
01:03:19 And yet this group remains severely underprotected.
01:03:22 Phylum detects, reports, and blocks malicious packages.
01:03:25 Get their research and join their community at talkpython.fm/phylum-research.
01:03:32 Python tutor.
01:03:33 Visualize your Python code step-by-step to understand just what's happening with your code.
01:03:39 Try it for free and anonymously at talkpython.fm/python-tutor.
01:03:42 Want to level up your Python?
01:03:46 We have one of the largest catalogs of Python video courses over at Talk Python.
01:03:51 Our content ranges from true beginners to deeply advanced topics like memory and async.
01:03:56 And best of all, there's not a subscription in sight.
01:03:58 Check it out for yourself at training.talkpython.fm.
01:04:01 Be sure to subscribe to the show.
01:04:03 Open your favorite podcast app and search for Python.
01:04:06 We should be right at the top.
01:04:07 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.
01:04:17 We're live streaming most of our recordings these days.
01:04:20 If you want to be part of the show and have your comments featured on the air, be sure to subscribe to our YouTube channel at talkpython.fm/youtube.
01:04:28 This is your host, Michael Kennedy.
01:04:29 Thanks so much for listening.
01:04:31 I really appreciate it.
01:04:32 Now get out there and write some Python code.
01:04:34 Thanks for watching.