From 1d1df161cbf106be0fddf88160e334f1d4c1f2ed Mon Sep 17 00:00:00 2001 From: EmacsConf Date: Sat, 7 Dec 2024 13:00:14 -0500 Subject: Automated commit --- ...-in-julia-and-emacs--gabriele-bozzola--main.vtt | 616 +++++++++++++++++++++ 1 file changed, 616 insertions(+) create mode 100644 2024/captions/emacsconf-2024-julia--exploring-shared-philosophies-in-julia-and-emacs--gabriele-bozzola--main.vtt (limited to '2024/captions') diff --git a/2024/captions/emacsconf-2024-julia--exploring-shared-philosophies-in-julia-and-emacs--gabriele-bozzola--main.vtt b/2024/captions/emacsconf-2024-julia--exploring-shared-philosophies-in-julia-and-emacs--gabriele-bozzola--main.vtt new file mode 100644 index 00000000..b6e69c85 --- /dev/null +++ b/2024/captions/emacsconf-2024-julia--exploring-shared-philosophies-in-julia-and-emacs--gabriele-bozzola--main.vtt @@ -0,0 +1,616 @@ +WEBVTT captioned by gabriele + +00:00:00.000 --> 00:00:02.359 +Hello, I'm very excited to tell you + +00:00:02.360 --> 00:00:03.679 +about shared philosophies + +00:00:03.680 --> 00:00:06.479 +between the Julia programming language and Emacs. + +00:00:06.480 --> 00:00:08.679 +While Julia and Emacs might look like + +00:00:08.680 --> 00:00:10.279 +different pieces of software, + +00:00:10.280 --> 00:00:13.439 +I think there is profound commonalities between the two. + +00:00:13.440 --> 00:00:16.359 +Let's start by introducing Julia. + +00:00:16.360 --> 00:00:19.719 +Julia is a high-level dynamic programming language. + +00:00:19.720 --> 00:00:21.679 +Julia is free and open source software + +00:00:21.680 --> 00:00:24.639 +and is used primarily for scientific computing. + +00:00:24.640 --> 00:00:27.039 +The reason Julia is used for scientific computing + +00:00:27.040 --> 00:00:29.679 +is that while Julia is high level + +00:00:29.680 --> 00:00:32.559 +and has a syntax that looks like Python or MATLAB, + +00:00:32.560 --> 00:00:34.559 +Julia can be high performance. + +00:00:34.560 --> 00:00:36.519 +I use it to develop climate models + +00:00:36.520 --> 00:00:38.479 +that run on hundreds of GPUs. + +00:00:38.480 --> 00:00:43.399 +Models that are traditionally developed with C, C++, or Fortran. + +00:00:43.400 --> 00:00:44.759 +But how is this possible? + +00:00:44.760 --> 00:00:46.799 +How can Julia be high performance + +00:00:46.800 --> 00:00:48.799 +but also high level at the same time? + +00:00:48.800 --> 00:00:50.424 +What makes Julia, Julia? + +00:00:50.425 --> 00:00:52.469 +Well, what makes Julia, Julia + +00:00:52.470 --> 00:00:54.719 +is the idea of multiple dispatch. + +00:00:54.720 --> 00:00:58.999 +Multiple dispatch is the concept where a function call is resolved + +00:00:59.000 --> 00:01:02.359 +by looking at the types of every single argument involved. + +00:01:02.360 --> 00:01:04.959 +So, let's explore this with this example. + +00:01:04.960 --> 00:01:07.719 +Here, I define a function add that takes two objects + +00:01:07.720 --> 00:01:09.159 +and sums them together. + +00:01:09.160 --> 00:01:11.879 +And I call add with two different types. + +00:01:11.880 --> 00:01:14.639 +First with just integers and second with floats. + +00:01:14.640 --> 00:01:17.559 +So, let's look at what this produces. + +00:01:17.560 --> 00:01:20.439 +Here is the output of add in Julia. + +00:01:20.440 --> 00:01:23.279 +So, first we have add, a function with one method. + +00:01:23.280 --> 00:01:24.839 +I'm going to explain this in a second. + +00:01:24.840 --> 00:01:28.719 +And then we have our return values 12 and 12.0. + +00:01:28.720 --> 00:01:30.799 +What we cannot see here is that + +00:01:30.800 --> 00:01:33.439 +Julia has specialized code + +00:01:33.440 --> 00:01:35.119 +for the two different function calls. + +00:01:35.120 --> 00:01:38.359 +For integers and for floating points. + +00:01:38.360 --> 00:01:42.239 +Let's make this more explicit by specifically providing + +00:01:42.240 --> 00:01:45.079 +a new method for the case with floating point. + +00:01:45.080 --> 00:01:47.599 +So here, now I have an add function + +00:01:47.600 --> 00:01:50.119 +specifically for floating point. Instead of taking + +00:01:50.120 --> 00:01:54.759 +A + B, this returns A exponent B. Let's call this. + +00:01:54.760 --> 00:01:56.799 +And what we can see here is that + +00:01:56.800 --> 00:01:58.319 +now we have two methods. + +00:01:58.320 --> 00:02:00.559 +So, we add a new method to the same function. + +00:02:00.560 --> 00:02:01.639 +This is a method that is + +00:02:01.640 --> 00:02:03.679 +specifically for floating points. + +00:02:03.680 --> 00:02:06.959 +And instead of having the value 12, we have 100. + +00:02:06.960 --> 00:02:09.039 +And this is where the trick lies. + +00:02:09.040 --> 00:02:13.879 +Julia compiles the most, um, specialized version + +00:02:13.880 --> 00:02:16.839 +that can be compiled. So, a version with integers, + +00:02:16.840 --> 00:02:19.199 +a version with floats. And in this, + +00:02:19.200 --> 00:02:22.679 +compiling is an actual compilation with LLVM + +00:02:22.680 --> 00:02:24.479 +with optimization and so on. + +00:02:24.480 --> 00:02:27.439 +This is not just ahead of time compilation. + +00:02:27.440 --> 00:02:30.719 +Soon as the Julia knows the type, + +00:02:30.720 --> 00:02:33.719 +a function is compiled if it's not compiled already + +00:02:33.720 --> 00:02:35.079 +and then it's used. + +00:02:35.080 --> 00:02:37.159 +When types are stable and well inferred, + +00:02:37.160 --> 00:02:40.079 +this can lead to code that is as performant + +00:02:40.080 --> 00:02:42.159 +or comparable to C and Fortran. + +00:02:42.160 --> 00:02:45.159 +So, this is what makes Julia, Julia. + +00:02:45.160 --> 00:02:48.439 +Multiple dispatch with just ahead of time compilation + +00:02:48.440 --> 00:02:49.719 +of highly efficient code. + +00:02:49.720 --> 00:02:53.439 +So now, what makes Emacs, Emacs? + +00:02:53.440 --> 00:02:56.679 +Well, in my opinion, what makes Emacs, Emacs + +00:02:56.680 --> 00:03:01.159 +is interactivity, extensibility, and community. + +00:03:01.160 --> 00:03:06.199 +And I claim that Julia has the same three. + +00:03:06.200 --> 00:03:09.079 +Interactivity, extensibility, and community + +00:03:09.080 --> 00:03:11.839 +are three key pillars for Julia. + +00:03:11.840 --> 00:03:14.599 +More specifically, Julia encourages a + +00:03:14.600 --> 00:03:17.079 +REPL-driven, introspective, interactive workflow. + +00:03:17.080 --> 00:03:19.879 +It's largely open to extension and modification + +00:03:19.880 --> 00:03:23.559 +to the point that most of Julia is written in Julia. + +00:03:23.560 --> 00:03:25.959 +And Julia has a thriving and welcoming community + +00:03:25.960 --> 00:03:28.799 +with lots of packages. So, let me showcase + +00:03:28.800 --> 00:03:31.079 +a little bit of this REPL-driven, introspective, + +00:03:31.080 --> 00:03:34.359 +interactive workflow with the hope that commonalities + +00:03:34.360 --> 00:03:36.759 +with Emacs will emerge naturally. + +00:03:36.760 --> 00:03:39.919 +So, let's start by opening a Julia REPL. + +00:03:39.920 --> 00:03:41.759 +Here, I have a Julia REPL. + +00:03:41.760 --> 00:03:44.399 +Let me give you a tour of the Julia REPL. + +00:03:44.400 --> 00:03:47.759 +So, the REPL comes with lots of useful features, + +00:03:47.760 --> 00:03:51.559 +from a shell to a package manager. + +00:03:51.560 --> 00:03:54.999 +So, for example, let's add the random package. + +00:03:55.000 --> 00:03:58.279 +Um, yeah, I have the random package. + +00:03:58.280 --> 00:03:59.279 +I can look at what's inside. + +00:03:59.280 --> 00:04:01.279 +We have the statistics with random + +00:04:01.280 --> 00:04:02.479 +in this particular environment. + +00:04:02.480 --> 00:04:05.719 +Environments are fully declarative. + +00:04:05.720 --> 00:04:08.039 +So here we have the dependencies of this environment. + +00:04:08.040 --> 00:04:10.239 +And I can explore in this manifest, + +00:04:10.240 --> 00:04:13.999 +the specific versions that are used. + +00:04:14.000 --> 00:04:17.719 +So we have a shell, we have a package manager, + +00:04:17.720 --> 00:04:20.559 +and then we have a very powerful help system. + +00:04:20.560 --> 00:04:24.199 +So, for example, I can ask for help for length. + +00:04:24.200 --> 00:04:26.639 +And here we can see we have, well, + +00:04:26.640 --> 00:04:30.999 +the help for length. Lots of information about + +00:04:31.000 --> 00:04:33.399 +how to call length, the expected return values, + +00:04:33.400 --> 00:04:36.119 +examples. And now you can probably start seeing that + +00:04:36.120 --> 00:04:37.759 +this is not that different from calling length. + +00:04:37.760 --> 00:04:42.119 +So this is the output for length, + +00:04:42.120 --> 00:04:44.999 +or for help for length in in Emacs. + +00:04:45.000 --> 00:04:47.959 +So we have help, and we can do more. + +00:04:47.960 --> 00:04:51.879 +We can even look at the source code for length. + +00:04:51.880 --> 00:04:57.079 +So now, what we can see here is that now, well, + +00:04:57.080 --> 00:04:58.919 +we cannot see because it's zoomed in + +00:04:58.920 --> 00:05:02.799 +because the font size is huge, but in this page here, + +00:05:02.800 --> 00:05:04.759 +we can see the implementation of length. + +00:05:04.760 --> 00:05:06.719 +It's this line here in the middle, + +00:05:06.720 --> 00:05:09.719 +or these few lines here in the middle. + +00:05:09.720 --> 00:05:12.079 +And as you... Let's do this again. + +00:05:12.080 --> 00:05:12.999 +As we can see here at the bottom, + +00:05:13.000 --> 00:05:13.799 +what we are looking at, + +00:05:13.800 --> 00:05:15.639 +this is the source code of Julia. + +00:05:15.640 --> 00:05:17.039 +We can change this. + +00:05:17.040 --> 00:05:20.039 +There's even a macro edit + +00:05:20.040 --> 00:05:22.759 +if you want to change its length. + +00:05:22.760 --> 00:05:24.599 +And yeah, I use the word macro. + +00:05:24.600 --> 00:05:28.639 +Julia supports metaprogramming. + +00:05:28.640 --> 00:05:30.359 +And actually metaprogramming is + +00:05:30.360 --> 00:05:32.079 +one of the key features in Julia. + +00:05:32.080 --> 00:05:33.639 +It's used extensively in the core, + +00:05:33.640 --> 00:05:36.399 +but it's also used extensively in packages, + +00:05:36.400 --> 00:05:40.079 +both to extend the Julia ecosystem and functionalities, + +00:05:40.080 --> 00:05:43.479 +but also to develop full domain specific languages. + +00:05:43.480 --> 00:05:47.239 +Some of the useful macros are, well, I don't know, + +00:05:47.240 --> 00:05:52.239 +like time. Here, we have a built-in + +00:05:52.240 --> 00:05:55.799 +basic performance tool in in in Julia. + +00:05:55.800 --> 00:06:00.479 +And I want to showcase more introspection, macros. + +00:06:00.480 --> 00:06:02.959 +But for that, I'm going to do it slightly different. + +00:06:02.960 --> 00:06:04.039 +I'm going to open a file + +00:06:04.040 --> 00:06:06.239 +example.jl where I define a + +00:06:06.240 --> 00:06:08.039 +function, or our + +00:06:08.040 --> 00:06:09.519 +function add, there was an asterisk + +00:06:09.520 --> 00:06:11.199 +and I will go back to that in a second. + +00:06:11.200 --> 00:06:15.239 +So now, I am going to include this this file, + +00:06:15.240 --> 00:06:18.199 +and I can call my function add, one and two, + +00:06:18.200 --> 00:06:22.639 +and we get three. And now, what I can do is this. + +00:06:22.640 --> 00:06:28.039 +I can look at what code gets compiled + +00:06:28.040 --> 00:06:31.359 +when I call my when I call 1 + 2. + +00:06:31.360 --> 00:06:33.359 +And here, now we can see + +00:06:33.360 --> 00:06:34.639 +that there is some integer stuff. + +00:06:34.640 --> 00:06:38.159 +But if I make this floating point, + +00:06:38.160 --> 00:06:40.239 +now the compiled code changes. + +00:06:40.240 --> 00:06:43.599 +Now, maybe assembly code + +00:06:43.600 --> 00:06:45.079 +is a little bit too hard to read, + +00:06:45.080 --> 00:06:48.639 +so I can look at the LLVM IR representation. + +00:06:48.640 --> 00:06:50.399 +In this case we can see that there is promotion. + +00:06:50.400 --> 00:06:52.239 +The promotion will probably go away + +00:06:52.240 --> 00:06:56.039 +if I make everything float. So this we have F add, + +00:06:56.040 --> 00:06:57.999 +floating point add for a double, + +00:06:58.000 --> 00:06:59.439 +but we can also look at + +00:06:59.440 --> 00:07:04.239 +the Julia lowered representation + +00:07:04.240 --> 00:07:06.079 +after the abstract syntax tree is produced. + +00:07:06.080 --> 00:07:07.919 +The reason I put this in a file is because + +00:07:07.920 --> 00:07:10.119 +now what I can do is I can change this. + +00:07:10.120 --> 00:07:14.079 +And now, one and two will be two. + +00:07:14.080 --> 00:07:16.879 +So this to me is very reminiscent + +00:07:16.880 --> 00:07:18.719 +of how I work in Emacs, + +00:07:18.720 --> 00:07:20.239 +where there is a global state + +00:07:20.240 --> 00:07:22.959 +that I can access and modify any time + +00:07:22.960 --> 00:07:27.159 +with no restrictions. And this happens in in Julia too. + +00:07:27.160 --> 00:07:29.559 +Typically, we don't want to modify functions + +00:07:29.560 --> 00:07:32.519 +that are in other packages or they are in base, + +00:07:32.520 --> 00:07:34.079 +but we can do that. For example, + +00:07:34.080 --> 00:07:37.639 +I can change what is plus for integers. + +00:07:37.640 --> 00:07:41.079 +And if I change with this plus + +00:07:41.080 --> 00:07:43.759 +and make it so that any two integers return zero, + +00:07:43.760 --> 00:07:46.319 +well, I can do this. This will break Julia because, + +00:07:46.320 --> 00:07:48.359 +well, Julia is built in Julia. + +00:07:48.360 --> 00:07:51.399 +So if we break this, well, nothing will work. + +00:07:51.400 --> 00:07:53.399 +But I can do that. This to me is one of + +00:07:53.400 --> 00:07:56.199 +the signs of the powerful, introspective, + +00:07:56.200 --> 00:07:58.479 +and powerful interactive type of workflows + +00:07:58.480 --> 00:07:59.279 +that Julia enables. + +00:07:59.280 --> 00:08:03.479 +Finally, I want to talk about the general registry. + +00:08:03.480 --> 00:08:06.399 +This is the equivalent of Melpa. + +00:08:06.400 --> 00:08:08.759 +It comes with with Julia. + +00:08:08.760 --> 00:08:11.119 +But this is very akin to Melpa. + +00:08:11.120 --> 00:08:14.479 +It's built upon Git essentially. + +00:08:14.480 --> 00:08:19.399 +It's collaborative, as relies heavily on GitHub, GitLab. + +00:08:19.400 --> 00:08:21.119 +It's heavily automated. + +00:08:21.120 --> 00:08:24.479 +And comes with lots and lots of tools and packages. + +00:08:24.480 --> 00:08:27.559 +What's beautiful about all these tools and packages + +00:08:27.560 --> 00:08:30.279 +is that in the same way many of Emacs packages + +00:08:30.280 --> 00:08:32.399 +just play nicely with each other + +00:08:32.400 --> 00:08:34.879 +without any input from the developers, + +00:08:34.880 --> 00:08:37.559 +the same is true for Julia packages. + +00:08:37.560 --> 00:08:40.679 +The Julia packages are highly composable, + +00:08:40.680 --> 00:08:42.879 +so two developers can develop + +00:08:42.880 --> 00:08:44.719 +two distinct packages + +00:08:44.720 --> 00:08:47.639 +that end up playing nicely together for free + +00:08:47.640 --> 00:08:51.879 +because of the intrinsic structure, intrinsic way + +00:08:51.880 --> 00:08:54.079 +Julia objects are built. + +00:08:54.080 --> 00:08:57.479 +So, with all of this, I also want to mention that + +00:08:57.480 --> 00:09:00.079 +the community, in addition to have all these packages, + +00:09:00.080 --> 00:09:02.599 +is highly active, highly collaborative. + +00:09:02.600 --> 00:09:06.159 +The community meets regularly on places like Slack, + +00:09:06.160 --> 00:09:08.199 +as opposed to the Emacs community + +00:09:08.200 --> 00:09:10.039 +that I'd say maybe meets on Reddit. + +00:09:10.040 --> 00:09:12.999 +So, with all of this, I want to thank you + +00:09:13.000 --> 00:09:16.560 +for your attention, enjoy Emacs, and enjoy Julia. -- cgit v1.2.3