Programming Languages Today and Tomorrow - CourtneyR.dev's 2nd Brain

Programming Languages Today and Tomorrow ![rw-book-cover](https://img.youtube.com/vi/Za1epSDmyH4/maxresdefault.jpg) 🔗 **Source:** [Programming Languages Today and Tomorrow](https://www.youtube.com/watch?v=Za1epSDmyH4) > [!note]+ Document Notes > # 🏷️ Title: Programming Languages Today and Tomorrow > > **Current-agent capture.** The transcript is saved, but the full deep-read analysis is still pending (current-agent mode). The active Codex task must add the notes, topic tags, master highlights, and Reader-native inline highlights before this document is complete. > --- > ## Full Transcript > [00:11] Hi folks. Hi everyone. I'm Vital [00:14] Bragillski. I'm here today with uh this [00:17] lecture which is called programming [00:18] languages today and tomorrow. And I'm at [00:23] PAS programming camp. And the original [00:26] idea of this lecture is just just to [00:28] talk to students of this programming [00:30] camp. But then we realized that it's a [00:32] good idea to have an open lecture and [00:34] then to have online translation and [00:36] stuff like that. But I believe that my [00:39] main audience is this group of amazing [00:42] students that we have here in Buffas for [00:45] for this programming camp. And in the [00:48] end I hope you will understand why why [00:50] uh you are the the main audience here. [00:54] Uh so uh I'm my my job role at Jet [00:57] Brains is head of Rustico system. I will [00:59] tell you more about that later in this [01:01] talk. And I will actually start with [01:03] sort of a anti-pattern of uh speaking [01:08] like speaker sometimes likes to talk [01:11] about themselves a lot and I usually [01:14] don't do that but uh this case is kind [01:17] of special because uh like who I am is [01:21] actually why it makes sense to listen to [01:23] me when I'm talking about programming [01:26] languages. So my first exposure to [01:29] coding was in 1992 like many many years [01:32] ago. It was basic basic programming [01:35] language and it was at some uh youth [01:39] community center. There were classes on [01:42] coding and I got there in the middle of [01:46] the year and I remember till this day [01:48] that the topic was arrays in basic and [01:53] after that class I realized that [01:55] programming is not for me because I [01:57] didn't understand the word there. So I [02:00] just dropped out after the first class [02:02] like and it was decided programming is [02:05] not for me. Then like in the local [02:09] library I found a book which was also [02:12] about programming and this book was [02:16] actually covering three programming [02:18] languages at once. There was forran [02:20] there there was Pascal and there was [02:22] basic [02:24] and like for for a year year and a half [02:26] I was reading this book. I didn't have a [02:28] computer at that time. I was reading a [02:31] book. I was writing like programs on [02:34] paper that was enough for me. [02:37] Then there was kind of like more proper [02:40] education like at at school at the [02:43] university and I've learned many [02:45] different programming languages. I use [02:48] some of them. I was developing websites [02:51] in Pearl on PHP. I was learning [02:53] JavaScript. I was learning uh Java, C [02:57] all those languages like Object Pascal. [02:59] It's a language of Deli uh programming [03:01] system. [03:03] And pretty soon like year 2000 I started [03:07] teaching coding myself and during my [03:10] career and I mostly work at universities [03:13] uh I taught more than 20 programming [03:16] languages [03:18] like like full-blown courses on some [03:20] programming languages or maybe just [03:23] lecture or two about one of them. So uh [03:25] like I taught really many programming [03:28] languages. At some point like some way [03:31] around 2005 [03:33] I started doing some Haskell [03:36] and then after some years in that [03:39] community I become a GHT Glasgow Huskell [03:43] compiler steering committee member and [03:46] like I was like part of the development [03:49] of Huskell programming language and I [03:52] wrote a book about Huskell Huskell in [03:54] depth. It was published five years ago. [03:57] uh a bit later 2008 uh I started uh [04:03] learning about the theory of programming [04:05] language. I was interested in lambda [04:07] calculus a lot. I was interested in [04:09] proof assistance in such languages as [04:11] rock which used to be known as coke [04:14] language or lean lean is extremely [04:17] popular in that area right now. So I was [04:20] translating some books. I was uh [04:22] teaching about the theory of programming [04:24] languages. [04:26] Since 2022, I am a Rust developer [04:30] advocate and I later moved to this role [04:32] of head of Rust ecosystem at Jet Brains. [04:35] Since this June, I am a the member of [04:39] the Rust commercial network steering [04:41] committee. I will tell you more about [04:43] that in this lecture. But in fact, [04:47] I talk to people in programming [04:49] languages a lot. Like all these years, I [04:54] talk to users of programming languages. [04:56] I talk to developers of programming [04:58] languages, developers of compilers, to [05:01] language designers. So I talk a lot and [05:04] I hear a lot of things. And because of [05:06] that, I think I have some sort of [05:09] understanding of what's going on in this [05:11] area. Of course, not everything. And of [05:14] course I'm not going to talk here about [05:17] what was actually promised in this tweet [05:20] by Jet Brains X account. [05:24] So this is what they wrote on on Twitter [05:27] on next um about this lecture. It's not [05:31] what I'm going to talk about. Of course, [05:34] this description was based on my [05:36] description, [05:38] but I never had those accents in my [05:41] description. Like, and the main reason [05:44] is that I don't know the future. [05:47] And if someone tells you that they know [05:49] future, they are lying. [05:51] So, I don't know the future for sure. [05:54] And I don't know trends. Like this [05:57] lecture is mostly about my observations. [05:59] like I see something, I hear something [06:02] because I talk to people and then I have [06:04] some ideas of what's going on. But I [06:08] don't know. We'll see. It's just [06:11] irrelevant what's going to be later like [06:13] in six months. I don't know. And I don't [06:16] care to be honest. So what this lecture [06:19] is actually about, [06:21] we'll talk about this symbol. [06:25] Some people call it carrot or hat [06:28] operator or circumlex. [06:31] So this is like one of the main topics [06:33] of this lecture. We'll also talk about [06:36] this uh term word capability [06:41] because it's kind of important these [06:42] days capability. [06:45] We'll also talk about safety. Another [06:48] very important concept in programming [06:50] languages safety. And you can combine [06:54] these to like capability meaning like [06:56] you are capable of doing something like [06:59] if you are capable of doing only right [07:01] things that's safety and if you are [07:05] capable of doing some wrong things [07:06] that's definitely unsafety. Okay. We'll [07:10] also talk about LLMs in this lecture. [07:13] Why? Because like these days if you are [07:15] speaking on any IT topic avoiding LLMs [07:18] is just impossible. It's unavoidable. [07:22] And we will also talk about people [07:24] because at the end at the end of the [07:27] day, it's all about people. Everything [07:30] that is going on with programming [07:31] languages is about people, how they [07:34] evolve, how they are developed. It's all [07:37] about people, their decisions, their [07:39] ideas. So these are five main topics of [07:45] this lecture. And no trends, I promise. [07:51] I will structure this lecture in this [07:53] like several chapters. There will be [07:55] five chapters if I'm on time or there [07:58] will be four if I am not on time but [08:00] we'll see. So programming languages in [08:03] general. So what are programming [08:04] languages? [08:06] Uh of course it's always starts with the [08:09] syntax. Syntax is like these days it's [08:13] the least interesting thing about [08:15] programming languages. Of course there [08:17] is some grammar, there is some notation, [08:20] how you write expressions, how you [08:22] define functions that's not very [08:25] interesting and like for 50 years we [08:27] already like there are no really [08:29] interesting topics in syntax. Then there [08:32] is semantics. Semantics was always [08:35] interesting. So what what those programs [08:38] actually mean when they run like [08:42] what is actually executed? How do we [08:44] know that it's doing the right thing or [08:47] maybe wrong thing? So this is semantics. [08:49] This is interesting. There are a lot of [08:51] ways of explaining like semantics of [08:53] programming language. [08:55] But I believe that even semantics is not [08:58] that important as uh number three in [09:02] this list because number three is about [09:05] ideas. [09:07] ideas. [09:09] It it's a they are more much more high [09:12] level than just some semantic rules or [09:16] syntactic rules. Ideas are about [09:19] properties of programming languages, [09:21] properties of some features. It's about [09:24] principles. It's about goals that uh [09:28] developers of programming languages want [09:30] to achieve. So these are much more [09:32] important concepts than anything else [09:36] and we'll try to focus more on ideas [09:39] behind programming languages in this [09:41] lecture. [09:43] And then of course there are different [09:45] other things there are tooling [09:47] ecosystem. It's impossible to use a [09:49] programming language without a compiler [09:52] without a lot of like package managers [09:55] other tools they should exist. Then [09:58] there should be some sort of governance. [10:01] Who is in charge of programming [10:03] language? Which features go into into [10:06] language? Which features are not going [10:08] there? And it's also important to think [10:11] about community around programming [10:14] language, who is actually like using [10:16] that language, how they can influence [10:19] the development of a language. those are [10:21] also like these days we can say that [10:25] those are very important components of a [10:27] programming language. [10:30] Uh now let's try to to be a little bit [10:33] more interactive. I will show you [10:35] several slides one by one [10:40] uh where I put some very important ideas [10:44] behind some programming languages and [10:48] your task is to guess which language is [10:52] hiding behind those like three or four [10:55] words [10:59] like several languages several tasks but [11:02] that's not an easy task Maybe like some [11:05] languages are easily recognizable, some [11:08] others are like much more difficult and [11:11] I'm pretty sure that there will be a [11:13] language that you don't know. So let's [11:16] see. So my first uh slide here, zero [11:21] overhead abstractions. [11:24] Which language is that? Yeah, just [11:28] >> Rust. [11:30] [laughter] Other ideas? [11:31] >> C++. C++ that's that is C++ and this is [11:36] like a mantra moto that is like many [11:39] times bes the design of C++ he repeats [11:44] this thing C++ is about zero overhead [11:48] abstractions so you build abstractions [11:50] on top of your language you're building [11:53] classes templates all that stuff but [11:57] it's zero overhead at runtime [12:01] so if you use something you pay for that [12:03] with performance penalties of course but [12:06] if you don't use something then you [12:08] don't pay for that so this zero overhead [12:11] idea is extremely important for C++ [12:14] and when folks think about how to [12:16] develop C++ further this is for them is [12:20] the main guiding principle [12:22] so this is much more important than [12:25] anything else in in in this language so [12:29] is it zero overhead abstraction or lot. [12:32] So ideas are more important here. All [12:35] right. One uh uh next next language [12:41] right uh second right once run anywhere. [12:46] Yeah [12:47] >> Java definitely Java like the motor [12:49] which goes back to 1995. [12:53] It's not true anymore. [12:55] we have like much more platforms like [12:58] there are I think there are some issues [12:59] for Java on web assembly for example [13:03] uh but yeah that's that's pretty [13:04] well-known moto for for a programming [13:06] language [13:08] uh next example concise multi-platform [13:13] fun [13:19] it's Kotlin yeah it's Kotland if you go [13:21] to the Kotlin website language that is [13:23] developed by Jetbrain Means if you go to [13:25] their website you will see that [13:27] immediately on the main page concise [13:30] which means more concise than Java [13:33] usually multi-platform which means that [13:36] you can target different platforms you [13:38] can use you can use cotlin for iOS [13:41] applications for web assembly and like [13:45] our team which is doing web assembly [13:48] compiler for cotlin they're very well [13:51] known in general web assembly world for [13:53] example so It's it's kind of important [13:55] there and fun. Well, first because [13:59] you're writing functions there. It's a [14:00] keyword, but also because it's real fun [14:03] to use that. All right. Maybe a bit more [14:06] difficult task. [14:09] Some languages define themsel as [14:11] oppositions [14:13] like no hidden control flow, no hidden [14:16] memory allocations, no prep-processor, [14:20] no macros. [14:23] Zeke, thank you very much. It's Zeke [14:25] really like if you go to the main page [14:27] of Zeke website, it's right there. They [14:29] say it's a simple language. You don't [14:32] need to learn that much to use that [14:34] language. And they define themselves [14:36] through these ideas. So they don't have [14:39] exceptions for example because [14:41] exceptions is control flow that is [14:44] hidden [14:46] and they don't have a lot of other stuff [14:48] but they they suggest ways to do the [14:51] things differently. So that's ZIK [14:53] definitely. [14:55] Next language, [14:57] a mostly functional, richly typed [15:00] language that combines safety and [15:03] convenience. [15:06] What [15:09] >> sorry? [15:10] >> Really? [15:13] Actually, there are two answers for [15:15] that. Yeah. Go ahead. [15:17] >> Scala. This is actually Scala because [15:19] this phrase I just took it from Martin [15:22] Adski uh talk about Scala uh like the [15:27] talk was one year ago and it's like [15:29] current definition of Scala programming [15:31] language. There is another language [15:33] which is actually like very like similar [15:36] in that regard. [15:39] It's different but uh so this is Scala [15:42] that's the right answer. There is [15:43] another language which is also like kind [15:45] of like that. [15:49] Okay, that's okamel. Okamel is also very [15:52] close to this idea. [15:55] Okay, and and I have last example [15:59] fast, friendly, [16:02] functional, [16:07] >> go. No, no, definitely not. Go is not [16:11] functional like at all. [16:14] >> Yeah. F [16:16] >> F other ideas? [16:21] >> Sorry. [16:23] >> I don't I don't hear [16:26] >> elixir. Well, it's not alexir. [16:31] >> Haskell is Haskell friendly? Is Haskell [16:35] fast? I'm not sure to be honest. [16:39] >> No, it's not Haskell. Definitely. No. [16:42] Well, it's a it's a very well it's [16:44] impossible task, you know. It is [16:46] impossible. Yeah. [16:48] >> Ag No, no, no. Agda is never like [16:54] well not friendly like not it's [16:57] impossible task. So this is a very new [17:00] language uh which is called rock but not [17:03] that rock that I already mentioned. It's [17:05] like ro. If you Google these three words [17:08] you will immediately find it. It's a [17:10] very new language like it's its release [17:13] 0.1.0 [17:15] zero is planned for this week maybe like [17:18] next one [17:20] but uh the author of this language [17:23] Richard Feldman is well known in [17:24] programming languages community because [17:26] he's the author of Elm programming [17:29] language [17:30] and this is another new language from [17:33] Richard Feldman and it's really fast [17:36] there is an amazing hot reload feature [17:39] there it's friendly it's easy to write [17:41] code and it's singly paradigm language [17:44] so it's only function [17:45] nothing else. I recommend you looking at [17:48] that language. Maybe like in 10 years it [17:51] will be the main programming language in [17:53] this world. Maybe not. I don't know. But [17:55] it's just it's nice to see that new [17:57] languages are coming all the time. Like [18:00] we are getting a lot of new languages [18:02] every day. Why? Because like it's it's [18:07] interesting. It's fun to create [18:08] programming languages. [18:11] So like after this game we can say that [18:14] every programming language is actually a [18:17] set of bets about which ideas matter [18:22] most. So this is very important. These [18:25] ideas are important matter for this [18:28] language and they they can be like [18:31] really unrelated to some other [18:33] programming language. So everyone is [18:36] just this set of bets. [18:38] And there is one other thing one one [18:41] other way of thinking about programming [18:43] languages. And here we'll show you some [18:46] picture which is a very old meme. It uh [18:49] dates back to 2009 actually December [18:54] 2009. It was published at that time. It [18:57] it kind of maybe maybe it's too small. [18:59] So it's how developers on some [19:02] programming languages are seen by fans [19:05] of those programming languages [19:08] like if you look at the diagonal here it [19:11] means like like how Java developers are [19:14] seen by Java fans. So this diagonal is [19:17] is just amazing things but everything [19:20] else is just kind of maybe questionable [19:24] maybe not politically correct. [19:27] So, except Haskell of course like I like [19:30] this column about Haskell a lot. That's [19:33] that's exactly what you should think [19:35] about Huskell. That's exactly what [19:36] everyone should think about Haskell. Uh [19:40] but there is a lot of sense in this [19:42] picture. Of course, it's a meme. It's a [19:43] joke. But really like we can look at [19:47] this picture for hours and see some [19:49] interesting stuff. So there's there are [19:52] a lot of deep concepts behind that. [19:56] And speaking about deep consonants [19:58] concepts in this chapter about like [20:01] programming languages in general I would [20:04] like to show you some trend let's call [20:07] it this way they wanted trend so here is [20:09] a trend. [20:11] So one of the most important concepts in [20:14] programming language languages is typing [20:17] discipline. [20:18] We have languages with dynamic typing [20:21] where types are checked at runtime. And [20:24] we have languages with static typing [20:26] where types are checked at compile time. [20:29] So before they actually executed and [20:33] there are some examples in both camps. [20:36] But what is really very visible these [20:38] days is that industry want some shift [20:44] here. Dynamic languages are known for [20:48] being flexible. [20:51] You don't need to think much in advance. [20:53] You write some code and it just works. [20:56] But these days we need more safety in [21:01] our programs. So we need more types. [21:04] This is a basic level of ensuring [21:07] safety. [21:08] And what we see, we see an emerging [21:11] thing of gradual typing, which means [21:15] some parts of our code are dynamically [21:19] typed while some other parts of our code [21:22] base are statically typed. And we have [21:26] this in Python with a lot of actually [21:28] tools much more than these two [21:30] approaches for typing Python. And also [21:33] we have Typescript which is like [21:35] gradually typed uh wrapper over [21:39] JavaScript. So we are moving from [21:43] dynamically typed languages towards [21:47] statically typed languages. This is a [21:49] trend. This is something that is really [21:51] observable [21:53] and the folks in those language [21:55] communities are working hard to uh [21:57] provide tooling that supports these ways [22:01] of developing programs. All right. So [22:04] this is real trend. We are going with [22:08] more and more types. [22:12] All right. [22:15] Next chapter [22:17] that weird symbol. Do you remember the [22:20] names like this carrot, circumflex, hat? [22:26] So yeah, [22:29] this symbol it has a lot of names and it [22:32] has a lot of uses in programming [22:34] languages. Here you can see some [22:36] examples. [22:38] So like uh excluded or operation or [22:43] pointer types referencing in some [22:45] languages or uh power [22:49] uh operator or in regular expressions is [22:54] negation and I'm pretty sure there are [22:56] much more uses of this lang this symbol. [22:59] Why I call it weird? Because like when [23:02] you look at this symbol, when you see [23:04] this symbol in the new programming [23:06] language, you can never assume its [23:08] meaning. [23:10] It's just well, what does it mean? Like [23:13] you need to to ask LLM [23:16] or to read the reference. It's [23:19] impossible to guess because this is like [23:24] this is the problem with this symbol. [23:26] And sometimes sometimes it's even like [23:29] single carrot is not enough. Now to [23:33] continue this lecture I need some [23:35] addition to my outfit. [23:38] One second. [23:40] This one. And now now I have a question [23:43] to you. [23:45] Which programming language I'm going to [23:47] talk about now? [23:51] >> You might be not wrong. By the way, this [23:54] is uh our Rust ecosystem. [23:59] So this photo was taken at Rust week [24:01] conference this year. This conference is [24:03] run in Utre uh every May in Utre like [24:07] the huge gathering of Rust folks. So you [24:10] can see like everyone wears these cat [24:13] ears and there is some story behind [24:15] that. But actually I'm not going to talk [24:18] about trust here. [24:22] Any other ideas? [24:25] Which language has this operator which [24:28] is called cat ears? It's not rust. In [24:32] rust, there is no such thing. Cat ears [24:35] operator. [24:39] This is funny not to get an answer in [24:41] this audience. [24:44] I'm going to talk about C++ here. [24:51] But today and tomorrow maybe you know [24:54] like yesterday's C++. [24:57] So what they have in C++ right now is [24:59] so-called reflection. C++ 26 reflection [25:05] is implemented using this cat ears [25:08] operator. [25:10] So I have an example here. It's like [25:13] very simplified example but I will show [25:15] you what this operator is doing here in [25:17] C++. So I have some like this is like [25:20] first part of the code. So I have some [25:23] headers included and look there is this [25:26] experimental meta here. Uh I'm using [25:30] name spaces. So there is some structure [25:32] with uh two members [25:35] string fame and integer count. All right [25:40] there is some structure. Now second part [25:43] of this code there is a main function [25:48] and in that main function I am doing [25:50] some compile time computations. [25:54] You can see that those are compile time [25:56] computations because I'm using const [25:58] expert expressions there which means [26:01] like they they can be computed at [26:03] compile time. So I am getting access to [26:06] some context like here in this line [26:11] and then [26:13] look so this is cat ears operator [26:17] I am getting this is a reflection [26:19] actually so I am getting some meta [26:22] information about the type behind my ops [26:27] structure [26:30] so this is a very nice way to get [26:32] information about type like we have some [26:35] value, we have some structure and we can [26:37] get information about members. Now I'm [26:40] using some uh functions non-static data [26:44] members of this type and then I put them [26:48] in a static array with another function [26:51] from that header which I included. [26:54] And now data members is array of [26:58] something which be information about [27:03] members of my op structure. It's static [27:06] array which means that it can be [27:08] computed at compile time. [27:12] Then I am using template for loop and [27:15] template for loop makes this loop [27:18] computable at compile time as well. [27:22] So it's a loop over data members and I'm [27:26] just doing some print line there. [27:30] Uh [27:32] print line. Do you know this nice [27:34] function in C++ [27:38] very modern one you know it's workable [27:41] example like in the previous slide there [27:43] was a link to uh godbold.org or so it's [27:47] a working example and it will print [27:49] exactly this that in gray box you see [27:51] member named f name member named count [27:56] so [27:58] all this code is computed at compile [28:02] time [28:04] there might be some loop in the compiled [28:07] output in assembly but in this case I [28:10] believe with some optimizations there [28:12] will be no loop actually there will be [28:13] two print lines print line this line [28:16] that because we don't need runtime for [28:18] that. Everything can be computed. But [28:22] reflection gives you a way to look into [28:25] your data types. It's like you are [28:28] seeing something in your program while [28:30] you are writing your program. [28:33] So cat ears operator. So why reflection [28:37] matters? Because reflection is part of [28:41] meta programming and for C++ meta [28:44] programming is extremely important. [28:47] We have in C++ we have C pre-processor [28:51] macros which is a terribly terrible [28:54] thing. It's extremely important to get [28:57] them right. Okay. They they allow you to [29:00] write like very performant code in some [29:03] cases and like we use them a lot like [29:05] all C++ C++ programmers use that but [29:08] it's like just textual substitution. [29:11] There is no type safety at all. They're [29:14] very fragile. They don't follow the [29:16] rules of C++ in terms of scoping stuff [29:19] like that like terrible terrible thing. [29:22] There is also template meta programming [29:25] which is amazing which is touring [29:27] complete. You can do whatever you want, [29:29] but it's it's like very slow to compile. [29:33] Like compiler error messages are [29:36] terrible. It's it's impossible to [29:38] understand them. You need to know what's [29:40] going on to to to read that error [29:43] message. [29:45] So very cryptic and [29:48] not very convenient. [29:51] Then we have these constax for constable [29:54] things like constable it's a function [29:56] that can be computed at compile time. [29:59] They're much better because you are [30:01] writing regular code like template with [30:04] a programming is that is like yet [30:05] another language on top of C++ [30:09] but with constax pro you're writing [30:11] regular C++ although it is compiled at [30:14] compile it is executed evaluated at [30:17] compile time but there are very limited [30:20] ways to look into your program and C++ [30:24] 26 reflection is actually a way to see [30:28] what's going on a very new development [30:30] in C++. [30:32] But you can also like apart from seeing [30:35] your code, you can also manipulate with [30:38] your code. You can with another operator [30:41] which is called splice, you can insert [30:43] the results of your introspection [30:46] and to generate some code uh at compile [30:50] time and reflection. It's not fully done [30:55] yet. Actually promise a lot to C++ [30:58] developers. Like these things will be [31:01] possible when we get full C++ [31:05] reflection. Like these days it's very [31:08] difficult to find like a particular [31:10] compiler like you need some specific [31:14] branch which is capable of compiling [31:17] this sort of code. So it's kind of a [31:20] future [31:22] but it will be implemented at some [31:25] point. It will be available in all other [31:27] compilers. So the direction is clear. [31:30] C++ folks want to have proper meta [31:34] programming. [31:36] And if you go to this talk, it's [31:39] available on YouTube. Uh it was a [31:41] keynote at CBP now conference this year. [31:44] I think it was in March. uh Barry [31:46] Revzen, one of the authors of uh C++ [31:49] reflection, he talks about reflection [31:53] that is only half of this story and he [31:56] gives like a long introduction into meta [31:59] programming in C++ and he shows how it [32:02] can be used in the future and he also [32:05] shows examples from Swift and Rust [32:09] because one of the uh very important [32:13] topics in programming languages like if [32:15] you are working with a programming [32:16] language you need to know what's going [32:18] on in other languages and bar in that [32:22] talk is discussing the topic what can be [32:25] borrowed from Russ what can be borrowed [32:27] from swift to get nice code generation [32:31] story for C++ [32:33] so this is somewhat very interesting [32:37] development in C++ these days [32:41] maybe at some point in 20 years it will [32:44] reach competitive programming [32:46] Maybe not. We'll see. [32:51] Chapter three. [32:53] I think I don't need cat ears for this [32:55] chapter. So, sorry. [32:59] Uh, memory safety. So, [33:04] [laughter and cough] [33:04] what is memory safety? [33:07] This is interesting topic. [33:11] Uh [33:13] here I have one of the definitions. [33:16] Uh in a memory safe programming [33:19] language, memory logic bugs don't give [33:22] the attacker control over all the all of [33:26] memory. [33:28] This definition is pretty new one. [33:32] It's uh it was given by Philip Pasler, [33:37] creator of a project compiler which is [33:40] called Phil C. Have you heard about Phil [33:43] C? [33:45] It's like two years old project uh [33:47] already. So uh he gave this talk at [33:51] software should work conference which is [33:53] amazing conference. If you go to YouTube [33:55] and uh look for talks from uh software [33:59] should work you will see a lot of them. [34:01] They are all amazing. [34:03] And Philip Pasler believes that memory [34:07] safety is is not just something about [34:10] like no crashes at runtime or no [34:12] segmentation faults. No, memory safety [34:16] is about exploitability. [34:19] Like we can all agree that it's [34:22] impossible to avoid all the memory logic [34:26] bugs in our code. It's just impossible. [34:30] What is possible and this is proved by [34:33] Philillip. [34:34] It is possible to avoid exploitability. [34:38] It is possible to make sure that it's [34:40] impossible to get control over memory to [34:43] get read and write access to other parts [34:46] of the code because of like buffer [34:49] overruns or some other memory logic bugs [34:53] like use after free double free things. [34:58] It's impossible to avoid exploitability [35:01] of those bots. [35:04] Now with this definition in mind, I will [35:06] show you some very hot story like from [35:09] the recent month. It's it it all [35:11] happened in July. [35:14] Are you ready for this level of like [35:16] being uh on top of the things? [35:22] Uh we'll talk about Zeke programming [35:24] language. Uh Andrew Kelly is a creator [35:27] of Zik programming language very [35:29] prominent developer very well-known uh [35:32] figure in programming language community [35:35] and recently he opened an issue on the [35:37] ze repo on codeback [35:40] uh about adding a so-called actually [35:44] memory safe unlike rust compilation mode [35:49] to zik [35:52] and this phrase [35:54] it created some kind of tension in [35:58] programming language community like what [36:00] what do you mean memory safe unlike Rust [36:03] like do you assume that Rust is not [36:05] memory safe and then people started like [36:08] trigger triggered by this uh started to [36:11] write comments in that uh issue and and [36:15] they also saying things like on social [36:18] media something like like Andrew Kelly [36:21] is totally crazy and he hates Raz us [36:25] because like recently ban JavaScript [36:27] runtime was written from Zeke to RAS. So [36:31] now he's just like going crazy about [36:33] that mad. Well, the actual question is [36:38] what is memory safety [36:41] and maybe Rust is not memory safe with [36:45] some sort of a definition. And in [36:47] general, how do you measure safety [36:49] guarantees in different programming [36:51] languages? which language is more safe. [36:55] So this is not about Andrew Kelly, not [36:58] about memory safety. It's actually about [37:01] people and people have different [37:03] understandings of words like memory [37:07] safety for someone can mean totally [37:10] different thing for some other. So it's [37:13] kind of interesting what is memory [37:15] safety. [37:17] Um and this discussion it was really [37:20] heated like at some point Andrew Kelly [37:22] wrote like literally something like if [37:24] you don't have Zeke repos in this [37:28] website or if you are not Philip Pasler [37:31] you are not like your opinion does not [37:34] matter in this discussion literally and [37:38] then like the whole thread was blocked [37:40] at some point like too heated and like [37:44] it's impossible to block all the threads [37:46] on Twitter of course and you can find a [37:48] lot of them like it's really hot and the [37:51] the the name of the issue was edited [37:54] several times. It was edited four times [37:58] actually like the the the next attempt [38:01] like to making it smoother to make it it [38:03] like more kind was I think it was like [38:07] unlike borrow checking without [38:09] mentioning rust [38:12] and then uh there was a [laughter] other [38:15] attempt I don't remember this is the the [38:18] final name of that issue introduce a [38:21] fully memory safe no escape hatches like [38:25] in Rust compilation mode inspired by [38:29] field C. So like almost politically [38:33] correct and technically correct [38:36] definition of what is actually going on. [38:40] So now we see like Rust is not unsafe [38:43] but in Rust there are sort of escape [38:46] hatches that allows you to write non [38:49] unsafe code and this compilation mode [38:52] among others [38:54] can prevent those kind of things. [38:58] Now [39:00] it's time to talk about like these [39:03] approaches to memory safety. [39:06] So in Rust we have so-called static [39:11] borrow checking [39:13] and this borrow checking enforces [39:15] ownership at compile time. So every [39:18] piece of memory is owned by some [39:22] variable [39:23] and it's impossible like almost [39:25] impossible to have two variables own the [39:28] same memory and when the variable goes [39:31] out of scope this memory is [39:34] automatically it it automatically goes [39:37] back to the operating system or to like [39:41] uh memory memory manager. [39:44] So you don't have to have like garbage [39:47] collection. You don't have to insert [39:49] instructions for like freeing that [39:51] memory because everything is done [39:53] automatically based on the results of [39:55] static borrow checking. [39:58] But in Rust there is a possibility of [40:01] unsafe code. [40:03] It is used for talking to C++ binary [40:08] libraries. For example, if you want to [40:10] have like this foreign function [40:12] interface, if you want to call some code [40:14] from C, you need unsafe code. It's [40:16] impossible to call it without that. And [40:19] these unsafe blocks allows you to bypass [40:22] some checks. Not every check, but some [40:25] checks. [40:26] And some patterns that Rust developers [40:30] use in their code also require unsafe [40:34] because it's impossible to prove [40:36] something to borrow checker. Like if [40:38] you're implementing some interesting [40:40] data structures in many cases you will [40:43] need to go to unsave block. You need to [40:46] use it otherwise it's impossible to [40:49] compile your code. But this is the [40:51] nature of static analysis. It's [40:54] impossible to do 100% correct static [40:58] analysis. It's just impossible in terms [41:00] of uncomputability. [41:03] Like it's not computable, [41:05] theoretically impossible. So there is [41:08] this idea of having unsafe blocks. But [41:11] once you have an unsafe block, you can [41:15] do you can do whatever you want and you [41:17] can get a lot of memory bugs in your [41:20] code and those bugs can be exploited by [41:24] the attackers and you can get a lot of [41:27] problems even though you use you're [41:29] using safe quote safe programming [41:33] language. [41:35] So uh Zeke gives you another approach. [41:39] They have several compilation modes and [41:43] there is the so-cal safe compilation [41:45] mode where they introduce runtime checks [41:49] for every operation with a pointer. Of [41:52] course, it's slow like no like it's [41:56] obvious it should be slow like every [41:58] memory access and then you have some [42:01] conditional operator checking that it [42:03] actually correct. And if you want to [42:06] write like without those checks without [42:09] using safe compilation mode then you are [42:12] supposed to do all the control [42:15] explicitly. You need to write your [42:17] conditionals by yourself. You need to [42:20] check everything. You need to make sure [42:21] that it actually safe code which is [42:25] difficult and developers make mistakes [42:28] and this is like we can do the same [42:30] stuff in C but we know that well there [42:34] are a lot of bugs in C code [42:36] and then there is this very interesting [42:39] and very new field C approach [42:42] which was developed by Philip Pasot and [42:46] he suggests using so-called invisible [42:49] capabilities is and the idea behind that [42:53] is to use sort of runtime tracking of [42:56] every operation with pointers. [43:00] And for every pointer when every pointer [43:04] memory for every point is allocated [43:07] he puts some additional [43:11] um memory like like fields into memory [43:15] with information about upper and lower [43:19] memory address [43:21] to show you okay using this pointer you [43:23] can access memory from this to that and [43:28] no more. So for every allocation like [43:31] you put these additional uh fields into [43:34] the memory and then for every memory [43:37] access you read those members and check [43:41] that the uh everything is correct. [43:45] Of course there is a lot of like runtime [43:47] overhead here. you have more locations [43:51] but because of this every memory access [43:55] is checked [43:57] it's really unexploitable [44:00] so your program will panic but any [44:04] attacker cannot get any access to your [44:08] memory so that's the idea [44:11] so like once again invisible [44:15] capabilities so every pointer goes with [44:18] this invisible capability [44:21] which really describes where this point [44:24] is actually pointing from this part of [44:26] memory to that part of me memory and [44:28] then at runtime like every memory access [44:31] is checked according to this capability [44:34] it's impossible to forge anything [44:39] and the way how Philip implemented that [44:42] is just like some addition to LLVM M. [44:48] So you have clunk compiler from a little [44:51] VM suit and then that means that you can [44:55] compile any C code, any C++ code and [45:01] then with these additional passes you [45:03] get this sort of memory safety. [45:07] So it's a not a programming language [45:09] because programming language is either C [45:10] or C++. It's a compiler which makes it [45:15] totally safe in terms of the definition [45:18] which I gave you in the beginning like [45:20] not exploitable. [45:24] So you put anything from your existing [45:27] CC++ code and then you get memory [45:30] safety. [45:32] There are some some issues like in many [45:34] old C programs they don't use [45:38] pointers because like they they keep [45:41] memory address as an integer variables [45:44] and then it's like really difficult to [45:46] see that this is a pointer. So it [45:48] doesn't work in that way. But still we [45:52] know that it's impossible to guarantee [45:55] memory safety at compile time like 100% [45:59] guarantee is is impossible but we can [46:03] prove it at runtime. We pay for that but [46:06] we get that memory safety if you want. [46:10] uh and it's actually possible to like in [46:13] a recent talk uh Philip he showed like [46:15] he compiled Libra office like completely [46:18] it's a huge huge code huge code base it [46:22] is compiled using uh fieldc it all works [46:25] almost without modifications as he puts [46:28] it [46:30] so this is a fundamental tradeoff if you [46:33] want safety that's one thing which means [46:37] like safety means not really performing [46:40] per moment. If you want real [46:43] performance, you don't get that safety, [46:45] but it will be very performant code. [46:49] So, it's an access and we can put [46:53] different languages on different parts [46:55] of that access like some languages are [46:59] more performance, some languages are [47:01] more safe. So, where is Rust? [47:04] So, if we are not using unsafe blocks in [47:06] Rust, there's definitely safe language. [47:10] But if you want to make it at some point [47:13] like more performant, chances are you [47:16] will need to use unsafe blocks and then [47:19] it will be much less safe. It will be [47:22] performant just as C and C++ but you [47:26] will you might have some issues with [47:28] performance or with the safety [47:32] but it's not the only axis that we need [47:34] to use here. Like speaking about trust, [47:38] uh recently uh TypeScript compiler has [47:42] been rewritten in Go and not in Rust [47:45] notably like it was like several months [47:48] ago we got this information that the [47:50] TypeScript compiler is rewritten [47:53] and there is a recent like this week [47:55] maybe this Monday it was published the [47:58] interview of Anders Hailsburg which is [48:01] like very well-known guy in programming [48:04] language community. He He's the guy [48:06] behind Turba Pascal. [48:09] It's like [48:11] 1985. [48:14] Uh he's a guy behind C. He's a creator [48:17] of Typescript. [48:19] And he answered this question, why did [48:21] you choose Go over Rust? Like everyone [48:24] is writing to Rust. Why did you choose [48:26] Go? [48:28] And his answer was like quite [48:30] sophisticated. There were quite a lot of [48:32] arguments there. why go is actually the [48:35] language that was good enough for them. [48:37] But this is the reason uh like one of [48:40] the main reasons why it's not trust [48:43] because [48:45] they have a lot of circular structures [48:48] like circular lists and if you want to [48:51] implement them in rust you need to [48:54] struggle like it's really complicated [48:58] thing and they just decided that it [49:01] doesn't worth it like it's better to not [49:04] not to do that they they what they are [49:08] speed up because they rewrote it in [49:10] native language and go they have garbage [49:13] collection like it it doesn't matter [49:16] they didn't have to fight borrow checker [49:20] so this is more about convenience it's a [49:23] convenience argument so you might have [49:25] like safety performance but then maybe [49:28] you just don't want to do that stuff in [49:30] that complicated language that's fine [49:32] why not [49:36] So there are diff different [49:38] considerations here when you decide. [49:42] So that was about memory safety. But [49:45] memory safety is not all the safety that [49:49] we might need. [49:51] And in my next chapter I'm going to talk [49:54] about safety in more general terms. [49:59] And then surprisingly this is the [50:01] chapter where I'm going to talk about [50:04] LLMs and agentic development because it [50:08] looks like these topics are really close [50:10] to each other. [50:13] But I will start with some idea like [50:16] remember one of the words which I [50:18] promised to talk about capability. We [50:20] already uh saw them in the previous [50:23] chapter. So what are capabilities? [50:27] This is actually a very old idea. It is [50:31] 60 years old [50:33] and it originated in a like paper about [50:38] like some system which was described in [50:41] 1962. Uh they didn't have the word [50:44] capability. They use the word code word [50:47] code word some words with some [50:50] additional information. And the word [50:52] capability was introduced in 1966 by [50:55] Dennis and Van Horn in some other paper. [50:59] And the idea was like that capability is [51:02] some token which is unforgeable like you [51:05] cannot like do anything with that. And [51:09] this token grants you access to some [51:12] resource [51:13] and resource can be like really like [51:16] everything like part of memory some [51:21] device [51:23] network socket whatever resource [51:27] sometimes like even CPU might be a [51:31] resource or GPU might be a resource they [51:33] didn't have GPU at that time but doesn't [51:35] matter so token that grants you access [51:38] to some resource [51:40] and capability approach is actually one [51:44] of the two available and widely uses [51:47] approaches for [51:50] security systems. We have ACL's which is [51:54] called access control list [51:57] and when you log into uh like Linux or [52:02] Mac OS you're using ACL's because ACL is [52:05] a list like you have usernames and then [52:08] there are some permissions and ACL says [52:12] okay this user has permission to do this [52:15] this and that like for this file you can [52:18] read it you can write it but you're not [52:19] allowed to execute it for example [52:22] So this is ACL and capability is if you [52:26] possess something that proves that you [52:29] have the permission and of course we can [52:32] use some cryptography techniques to to [52:34] to build those uh tokens but it's [52:37] capability. You have something you you [52:40] show it and then you are allowed to do [52:43] something. [52:45] So in general capabilities they are [52:48] unforgeable [52:50] they are composable because you can put [52:53] two tokens together like token one token [52:56] two token three and then you can you are [52:59] allowed to do all that stuff and they [53:02] are transferable so you can take them [53:05] with you you can put it like bring it [53:08] there bring it there bring it there so [53:10] that's an idea [53:13] now this all this old idea. So we saw [53:16] some example of invisible capabilities. [53:19] That's the same thing something [53:21] additional that you add to your data to [53:24] your variable which allows you to check [53:27] whether you can access that memory or [53:29] not. But this idea is implemented in [53:32] much more general way in Scala. [53:37] And in Scala they have this surprising [53:42] operator which is called carrot or hat [53:47] or circumflex [53:51] and they use it for providing [53:53] capabilities. [53:55] This is a very simplified example and [53:58] this is also work in progress in Scala. [54:01] So it's quite difficult to set up your [54:03] project to be able to compile stuff like [54:06] that. So let's see what what what what [54:08] what we have here. [54:11] So we have a red lines red lines [54:14] function. It takes a string name of the [54:18] file [54:20] and it takes like this using file system [54:24] thing [54:27] like which means like it is allowed to [54:30] do some file system operations here. [54:34] And then we also say that we are [54:36] returning some list of strings [54:40] with this capability. [54:43] So it means like we got this list of [54:45] links. We got this list of strings by [54:50] using file system. [54:54] Now it's a definition function [54:56] definition. You use like some methods [54:58] from this file system to get those [55:00] lines. doesn't matter [55:02] what we call here our resulting type [55:05] actually captures file system [55:08] capability. [55:10] So this list of strings was produced by [55:14] accessing file system. [55:16] Now let's see at this uh let's look at [55:19] this line. [55:21] So variable on the left is list of [55:23] strings with [55:26] you see this hat and cap with minimal [55:30] capability [55:32] like minimal possible capability like no [55:35] capabilities at all and it's impossible [55:38] to assign to this list read lines it [55:41] will be a compilation error because red [55:45] lines gives you something which requires [55:48] this capability. [55:50] So if it would compile it means that [55:53] capability escape somehow you are using [55:56] it in a context where it is not expected [56:00] and compiler can check those things. So [56:03] we have these cap captured capabilities. [56:06] We we we have them in types and we can [56:09] control a lot of [56:11] I realize that my explanation is too [56:14] simp oversimplified. It's impossible to [56:16] understand what capabilities in Scala [56:19] are and you if you are interested you [56:21] can look into like there uh I will give [56:23] you recommendation for a talk here. So [56:26] there there will be something uh like [56:29] there's much more information about that [56:32] but uh as a big picture. [56:35] So [56:37] if we don't have this capture capability [56:41] checking then value can silently escape [56:45] with whatever capability it holds which [56:48] means like we can our file handles can [56:50] go somewhere database connections. So we [56:53] can uh leak some information [56:57] and if we are using capture checking we [56:59] allow the compiler we give the compiler [57:01] a tool to check all those things and to [57:06] disallow certain operations. [57:09] So if you want to learn more about [57:11] capabilities, the best way is to is in [57:15] Scala to listen to watch this talk by [57:18] Martin Adski, Scala's designer. Where [57:21] are we with Scala's capabilities? [57:25] It was like last year, it was in October [57:28] I believe. Uh but now [57:33] one interesting shift in a discussion [57:36] that actually these capabilities idea is [57:40] something where programming languages [57:42] research meets agentic development. [57:46] Martin Adski this May he published a [57:49] paper which is called tracking [57:50] capabilities for safer agents [57:54] and it's a whole paper which is devoted [57:57] to this simple question how we can [58:00] provide additional guarantees to agent [58:05] just to prohibit it from doing wrong [58:08] stuff stuff that is not allowed here. [58:12] So there is this general idea of a [58:16] gentic harness [58:18] and harness in this case gives agents [58:21] tools how to what they allowed to do in [58:25] the real world like if they want to [58:27] access shell if they want to connect to [58:29] database if they require some API keys [58:32] or access to file systems. So there is [58:36] this danger if if agent holds holds all [58:41] the capabilities is allowed to do [58:43] everything uncontrollably [58:46] then we might get in trouble like we [58:49] don't want to give access to everything. [58:53] So what uh Adski says in that paper is [58:57] that compiler can actually enforce [59:00] capability discipline [59:03] because you have this way of expressing [59:05] for each function like what is it is it [59:09] is allowed to touch and you use types [59:12] with capabilities for that and then if [59:15] some functions some programs violate the [59:18] contract they those programs are [59:21] rejected by type checker or they're not [59:23] compiled. you get a compilation error. [59:25] So you don't get any runtime surprises [59:28] because of this capability safety that [59:30] is ensured at compile time. And the [59:33] general vision here in this in this [59:36] approach is that we have a compiler if [59:40] it is strict enough we can use it as a [59:42] gentic harness. [59:45] So we can guarantee that our agents [59:47] cannot do something wrong. [59:50] So agent tools in this approach are some [59:54] sort of typed resources not just [59:56] function calls and then we use [59:59] capabilities to see that there are no uh [60:02] leaks [60:04] in all sorts of resource no some runtime [60:06] exploits and this also means that if we [60:10] have a stricter language like Rust with [60:12] borrow checking or Scala [60:15] it is actually safer to use them in this [60:19] age of LLM. times [60:21] because these languages control gives [60:24] you they give you more control over [60:27] what's going on at runtime [60:30] and maybe this is one other trend that I [60:33] see. So the problem is that like we know [60:39] that for sure it's impossible to read [60:42] and review all the AI generated code. [60:46] Let's just admit that there will be much [60:49] more code that we are like physically [60:52] able to review which means that we need [60:55] to send to production some code that is [60:58] not reviewed [61:00] and in a bad scenario it can execute a [61:04] lot of bad stuff. So if we try to use [61:08] safe languages for that, if we try well [61:11] and our goal should be to add as as much [61:16] like strict harness as possible and [61:18] compiler can be really like good basic [61:21] level for that harness and Scala [61:24] capabilities is one approach of of doing [61:26] that [61:27] and maybe in the future we'll see more [61:30] ways of ensuring safety maybe with [61:33] capabilities maybe using other [61:34] approaches I don't But there will be [61:37] definitely something because [61:40] we can cannot review all the generated [61:44] code. And it's not like I think that [61:47] it's a good thing. It's maybe it's a bad [61:50] thing, but we we have no choice these [61:53] days. [61:57] I'm going to chapter five. And now uh [62:01] for this chapter I will actually use [62:03] Rust as the main example and I will talk [62:07] about governance and community and we'll [62:09] tell you about uh like I will tell you I [62:12] will cover this topic of how programming [62:15] languages are developed [62:18] and I will use Rust as an example but uh [62:21] all other languages they use like [62:22] different systems for development and [62:25] it's like they're really very different. [62:28] So I was involved in some sense in [62:31] developing Haskell years ago. Now I [62:34] focus on Rust. I know something about [62:37] how Kotlin is developed. I know [62:39] something about Java and C++. I have [62:42] friends [62:43] uh telling me stories about that. But [62:46] like here we'll focus on Rust because [62:48] it's like the closest thing that I'm [62:50] doing these days as part of my job [62:52] actually. [62:54] So when we are talking about trust [62:56] governance, there are two main bodies. [62:58] There is a RAS project which is not a [63:01] formal thing. It's actually a group of [63:04] individuals and they work on a compiler, [63:07] standard library, some tooling. They are [63:11] organized into teams. There is a [63:13] leadership council. But at the end of [63:15] the day is just group of people and [63:18] anyone can join. If you show like some [63:21] sort of dedication, knowledge, you can [63:24] join that group and you can develop Rust [63:31] and then there is this Rust Foundation [63:35] and it's a nonprofit organization. It's [63:37] independent. [63:39] uh if you want to be a member you need [63:41] to pay and you need to pay quite a lot [63:44] like Jet Brains is a member but we are [63:46] on a smaller level and there are like [63:49] big players here AWS, Google, Microsoft, [63:53] Meta, Huawei they are like big platinum [63:56] members and they control Russ Foundation [63:59] but like all of them together they [64:01] cannot control anything because it's [64:04] just like different uh companies and [64:07] there are a lot of companies There we [64:09] have a board of directors and there are [64:11] directors which represent members and [64:14] directors which represent project Ras [64:17] project and the important thing about [64:20] Russ foundation that it's not about [64:22] control over language design language [64:25] design tooling everything goes to Russ [64:28] project and Russ foundation don't do [64:31] that they do some things where it's [64:35] difficult to find open source maint [64:38] container like they they they do crates [64:41] IO for example it's a a repository with [64:44] all the libraries for us like they they [64:48] make sure that it works like they they [64:50] pay for the uh like uh course Rust [64:54] foundation pays for development like [64:57] development resources like if you need [65:00] some GitHub actions Russ foundations [65:02] pays for that stuff like that but they [65:05] don't have any control [65:07] So two bodies. So they are they have [65:11] some connections because of project [65:13] directors like they elected as from the [65:15] project and they are represent project [65:18] rust foundation and they talk a lot with [65:21] each other. [65:23] But there is one other thing here which [65:25] was recently created and which was [65:27] supposed to solve certain problems that [65:30] is called Russ commercial network. [65:33] So remember Ras Foundation it it uses [65:36] this model with paid membership you need [65:38] to pay. Ras commercial network is open [65:41] for anyone for companies for the project [65:46] for other open source projects for any [65:48] individual [65:50] and the idea behind trust commercial [65:53] network is to identify are there any [65:56] blockers in language in the compiler in [65:59] tooling that prevent Rust adoption [66:03] like everyone in Rust community want [66:06] Rust to succeed to have more commercial [66:09] adoption to have more companies to have [66:11] more projects implemented with rust but [66:13] if there are some blockers maybe we can [66:16] discuss together and solve them so we [66:19] have regular online meetings it's like [66:22] the next one is August 31 please join if [66:25] you are interested uh you just write [66:28] like Russ commercial network you go to [66:30] the website you will see an open [66:32] calendar and all the information is [66:34] available there and as part of Russ [66:37] commercial network. What we are doing is [66:39] like we having we have sort of [66:41] initiatives [66:43] which can lead to creating some working [66:46] groups, interest groups or maybe [66:48] consortiums in different areas like for [66:51] example we have a fully functional [66:53] network services working group right now [66:57] like they meet regularly and they [66:59] discuss which problems we have currently [67:02] with network services with a sync code [67:05] with stuff like that and they're [67:07] discussing how to find money for [67:10] developers doing what is actually [67:13] needed. So it's like a lot of things [67:16] going on right now. Like this is a new [67:19] development but it's very important [67:20] these days. Ras commercial network is [67:23] also busy with funding. [67:26] So this is something that businesses can [67:29] do. For example like maintainers need [67:31] money, someone needs to pay them. So we [67:34] are trying to to find like common ground [67:38] between maintainers and companies and [67:41] companies have some money so they can [67:43] they can give it to give them to [67:45] maintainers. [67:47] One other thing [67:51] Rust community is also like something [67:53] which is like apart from commercial [67:56] network or Russ foundation or Russ [67:58] project. So we have conferences [68:02] uh we have meetups like local groups [68:04] like I know a lot of Russ meetup group [68:06] organizers like all over the world we [68:10] have this discord server we have zulip [68:13] do you use zulip [68:16] zulip is the main thing for us folks [68:19] like if you are into ras you have to use [68:21] zulip I hate zulip it's a well it's it's [68:24] like messenger it is so that [68:30] but well we we use it in in rust. So if [68:33] you want to participate in the like [68:35] language design you have to use Zulip [68:38] you go to this raslangzulip chat.com [68:41] and then like it's open you can join it [68:44] easily and then you can see how language [68:47] decisions are actually uh uh taken how [68:51] how they they discuss things [68:54] or you can also go to GitHub for RAS [68:56] language you can find source code of a [68:58] compiler this is the place where Rust is [69:01] developed and we a lot of discussions [69:03] there as well because like like issues, [69:07] pull requests, it's all there. [69:10] So it is important to remember all the [69:12] time that open source is not just code. [69:16] It's it's people choosing to show up at [69:20] the right time at the right place. So [69:25] it's a fun thing to develop programming [69:28] languages. [69:30] So can a single person make a difference [69:34] for a programming language? And I [69:36] believe yes, it is possible. It's not [69:39] that easy, but it's not that difficult. [69:42] Like most programming languages, the [69:45] majority of programming languages are [69:46] developed in a very open way. So anyone [69:51] can do a difference. And this is my [69:54] message to those who may be thinking [69:57] about like it's fun to develop [70:00] programming language. Maybe maybe it's a [70:02] good idea to participate and I tell you [70:05] it is a very good idea and it's an [70:07] amazing thing. So please join Ras [70:10] developers or Huskell developers or [70:14] Scala developers or C++ developers or [70:18] cotlin developers. Please it's it's fun. [70:24] Now I have this outro. [70:27] Uh I would like to mention several [70:29] different projects and I won't spend [70:32] time on each of them. Once again those [70:35] are just my observations. It's not [70:37] everything that is going on right now in [70:38] the area of programming languages but [70:40] this is something that caught my [70:42] attention. So I spent some time looking [70:45] into that. [70:47] I believe those are interesting things. [70:50] So [70:52] uh one important thing I mentioned [70:56] partially that already. So we have these [70:58] uh ports and rewrites. [71:03] It's a trend these days to take some [71:05] tool and rewrite it using some other [71:08] programming language or using some other [71:10] technologies. Uh and it works like for [71:15] example UV. UV is a tool which like has [71:20] reimagined the whole Python community. [71:23] like UV is a package manager and in [71:26] Python community they had tooling [71:29] forever for package management but all [71:32] of that tooling was implemented using [71:34] Python mostly and when Charlie Marsh the [71:38] guy behind UV decided to use Rust to [71:41] implement package manager [71:44] he literally created the new world of [71:46] Python development because like [71:48] everything became like like hundreds [71:53] time faster [71:56] like you don't need time to install new [71:58] additional dependency for Python project [72:00] because now it's really fast it's [72:03] amazing for CI it's amazing for agents [72:06] it's amazing for everything so it's a [72:10] very important rewrite and now like UV [72:13] and the company behind that this Charlie [72:15] Marsh startup Astral it was recently [72:18] acquired by open AI so basically open [72:21] AAI now owns uh Python package [72:25] management. [72:27] So that's kind of scary thing for [72:29] someone but it happens. Uh there is [72:33] another project ban ban rewrite ban was [72:36] a project by Jared SA and he used LLM's [72:41] uh for rewriting it from zik to rust and [72:46] some people say that it was a [72:48] advertisement campaign for anthropic [72:51] because bun belongs to anthropic and [72:54] they show that it's possible to do these [72:56] like huge things using their agents and [73:01] their LLM times but it's uh like like if [73:06] you are in social media if you're on [73:08] Twitter like it's impossible to avoid [73:10] this topic and it's still you can hear a [73:13] lot of stuff about that right another [73:15] example that I mentioned uh go [73:19] TypeScript compiler it was written from [73:21] JavaScript to go very interesting [73:24] project no LLMs it was manual rewriting [73:31] And the results of those rewrites they [73:34] are faster and they are safer which is [73:37] interesting. [73:40] Another totally different example [73:43] Cotlin LLM like if you go to uh like if [73:47] you Google Cotlin LLM you will see this [73:50] blog post um Cotlin blogs about Cotlin [73:54] LLM and smart macros like research [73:57] project like July 2026 [74:02] uh what they are doing is just like [74:04] sometimes you [74:06] uh don't want to implement some tedious [74:10] code. So you just put in your code base [74:13] like this as LLM uh macro and then write [74:18] some instructions and then LLM during [74:22] compilation will turn this description [74:25] into cotlin code and it will be type [74:28] checked [74:30] and then you will get this code and you [74:32] will commit it into your codebase. So [74:34] you use LLM but only once and the [74:36] results are in the codebase. So if you [74:39] uh and they they they think that this [74:42] smart micro idea is actually cool one. [74:45] It's an interesting project. If you go [74:46] there to just Google cotton LLM, you [74:49] will look at the blog post like end of [74:51] July like very recent development. [74:54] Maybe you will find something [74:56] interesting there. [74:58] Now like much bigger project Java. Java [75:02] is still extremely important language [75:04] for industry for software development. [75:08] And in Java for many years I keep [75:11] hearing about these projects Loom [75:14] Valhalla Panama. [75:17] And this is another example of how we [75:19] can reshape Java. Java is an old [75:21] language. It's more than 30 years old. [75:24] And what they are doing they are [75:26] bringing a lot of very cool stuff to a [75:29] very old language. It takes years to [75:33] come up with the proposals to tweak them [75:36] to implement them. But now we are [75:38] started seeing like in new Java versions [75:42] that some parts some components of those [75:44] projects get into them. So [75:48] like I like the project panama is my [75:50] favorite one. It brings Java much closer [75:54] to C code to native code which means [75:56] like more performance interoperability [75:59] between Java and the native world [76:01] becomes much much much more easier. So [76:04] it's an amazing development. If you are [76:07] into Java, well, you have to know this [76:10] stuff. [76:13] Another industrial language C. [76:16] in C in a recent uh we in a recent [76:20] version which is not actually released [76:21] fully released these days C# 15 they're [76:25] getting so-called discriminated unions [76:29] and this is an implementation of very [76:32] old idea of algebraic data types which [76:35] is well known since 1970s [76:39] at some point like Kotlin have some [76:42] version of that Scala has some version [76:44] of that swift rust past and now they're [76:47] going into C in C# they're getting [76:50] exactly union types you see like well [76:54] it's mainstream adoption of this very [76:56] old idea from functional programming [76:58] languages so good ideas they travel very [77:01] slowly but that's fine they if they are [77:04] really good they will arrive at some [77:06] point so new development in C old [77:10] development for some other languages but [77:12] they are doing that they're adding that [77:13] in a very like nice way. It's very [77:16] difficult to bring some very new feature [77:20] to an old language and it looks like [77:22] they are doing the right thing that [77:24] right now. [77:27] Another example, code speak. Codespeak [77:30] is a project by Andre Brislav. Andre [77:33] Brislav is original designer of Kotlin [77:35] and he's an amazing guy and like I love [77:38] him. He's like I recommend watching his [77:41] talks uh his interviews. he's just just [77:44] great. [77:46] And now he came up with an idea of how [77:49] to reimagine software development in [77:51] general. So he says, "Okay, we cannot [77:55] review that code. It's it's un it's [77:58] impossible. So what if we give [78:01] developers some new like more highlevel [78:04] way of describing their software using [78:08] some specifications [78:10] on top of your code base and then we'll [78:13] use LLMs to go from specifications to [78:16] code in some programming language. [78:20] So this gives programmers the way to say [78:23] what they mean using natural language [78:27] and they don't have to say how to do [78:29] that because well LLMs can do that for [78:31] them. [78:33] So it's a very interesting approach like [78:35] I recommend watching some talk by Andre [78:38] about that. But in general, like when [78:42] the creator of a very good programming [78:44] language turns to some new idea, it's [78:47] it's it's always worth to pay attention [78:50] because chances are this is a good idea [78:52] as well because for me programming [78:55] language creators are like the the [78:58] smartest, the most brilliant folks in [79:01] this world. Like they are really genius. [79:04] So let's let's uh look at what they're [79:08] doing right now. [79:10] I'm about to finish my lecture. [79:13] So I have several takeaways like if you [79:17] if like I would be happy if you remember [79:20] these takeaways after this lecture. So [79:23] first thing programming languages are [79:25] constantly evolving. They never stop. [79:28] They never die. They are evolving. [79:34] We are in a world of AI code generation [79:37] and this world requires more automatic [79:40] safety. Automatic as opposed to manual [79:43] ensuring that we have some safety [79:45] because people can't review everything. [79:49] Unfortunately, safety has its costs in [79:52] terms of performance. Well, we have to [79:55] pay if you want that safety. [79:59] And also programming language [80:01] development is really it is an open [80:04] club. Everyone can join and you can join [80:10] and that's a very good like way to spend [80:13] your free time or maybe at some point it [80:15] will become your like [80:18] job. [80:20] And also this weird symbol carrot [80:26] circumflex [80:28] hat operator. It's really fun symbol. [80:31] Maybe it's not weird at all. We can use [80:33] it for very nice things. [80:37] Thank you very much. If you have uh like [80:41] some questions, you can ask them now or [80:43] maybe we have like five minutes uh left [80:46] here or you can always contact me on [80:49] social media or by mail. Thank you. [80:53] [applause] [81:01] So questions. Do you have any questions? [81:11] Go ahead. [81:17] >> So my question is why ideas [81:21] so slowly [81:24] so enterprise focused. [81:28] >> Yeah. So I I'll repeat the question for [81:30] the translation. why ideas are adopted [81:33] like so slowly like they were available [81:36] like many years ago and only now they go [81:38] to mainstream languages [81:43] well it's uh [81:45] I think it's because like some ideas are [81:49] not needed like if you are programming [81:52] language creator you might have [81:54] brilliant ideas but they don't belong to [81:56] your world to your time and it's fine [81:59] like they're just not needed in [82:01] mainstream languages and we we we saw [82:04] that many times like lambda functions [82:07] they they known like since 30s like [82:10] before programming languages but we've [82:13] got them in Java in 201 what eight or 10 [82:17] or 15 I don't remember like it's like [82:19] many years garbage collection was first [82:22] implemented for lisp in 50s [82:26] like I think Java was the first [82:28] mainstream language with garbage [82:29] collection [82:30] It's it's normal like before that we [82:33] didn't need that but then if you're a [82:35] programming language designer you need [82:37] to know about those ideas [82:40] like you need to know you need to learn [82:42] about old languages [82:45] it's interesting and it might be useful [82:47] at some point it's fine it's not a [82:50] problem to be honest we don't need these [82:53] like features of esoteric esoteric [82:55] languages in the mainstream languages [82:57] why like Maybe in 50 years those ideas [83:02] which we consider esoteric now they will [83:04] be mainstream that's fine no problem at [83:07] all so I don't know why it just happens [83:09] like that but it's it's good thing [83:13] and then it's good for us like we are [83:14] interested in programming languages [83:16] history like I'm interested in history [83:18] programming languages and for me it's [83:21] very nice to see okay now you are doing [83:24] that okay that's funny that's that's [83:26] good to So [83:29] yeah, it's it's it's not an answer. [83:31] Sorry. But that's that's what I think [83:33] about it. Yeah. Other questions. [83:40] Don't be scared. [83:49] Do we have any questions in chat? maybe [83:52] on the translation [83:55] anything [84:01] or maybe by the way like like I I know [84:04] that I am right between uh like I am [84:08] between the students of a camp and the [84:11] dinner so maybe it's a good idea [84:13] >> question [84:15] >> okay yeah we have a question [84:17] >> so the question is I am really [84:19] struggling with languages syntax [84:22] when they put types after arguments [84:25] variables. Why is it so? [84:28] >> I'm really struggling with the [84:31] programming language syntax when they [84:32] put types after variables. [84:36] That's the question. Uh [84:41] yeah, that's fine. You know, you know [84:43] what? Uh I struggle with that as well to [84:47] be honest. [84:49] and uh uh like struggling with syntax is [84:54] is something that we can uh we have a [84:56] cure. We have LLMs. [84:59] We don't need to think about syntax [85:01] anymore. So that's a good news [85:04] because LLMs will generate everything [85:06] for us. They are good at syntax. They [85:08] are amazing at syntax actually. But [85:11] yeah, I have like like speaking about [85:14] syntax, I have huge issues with Scala [85:18] syntax. [85:19] I just it's for me like I'm looking at [85:22] Scala for maybe 15 years [85:25] and like for me it's impossible to write [85:28] Scala code. I don't know why they use [85:31] all those like like parentheses, [85:33] brackets, everything. And like for me to [85:36] combine them like by by myself all those [85:39] symbols is just impossible. I don't know [85:41] why. Maybe it's just some psychological [85:44] incompatibility [85:45] maybe. [85:49] All right. Any any questions from the [85:51] audience? [85:53] Well, I think we are done here. Thank [85:56] you very much folks. Thank you. And [86:00] [applause] [86:02] and folks folks on YouTube. Bye-bye. Unfortunately, Youtube does not provide subtitles for this video, Programming Languages Today and Tomorrow, YouTube, 01m0mzb7axx03g6w4rthxpqf3y.