← Software Engineering Daily
Software Engineering Daily
Creating a Rust IDE with Vitaly Bragilevsky
00:43:08
Rust is a systems programming language created by Graydon Hoare in 2006 and first released by Mozilla in 2010. It is designed for performance, safety, and concurrency, with a focus on memory safety without a garbage collector.
Loading summary
Transcript46 lines
- [00:00]
Lee Acheson
Rust is a systems programming language created by Graydon Hoare in 2006 and first released by Mozilla in 2010. It's designed for performance safety and concurrency, with a focus on memory safety without a garbage collector. Rust's ownership model ensures safe memory management, making it viable for tasks that require control over system resources, such as embedded systems, webassembly, and game development. Rust Rover is a dedicated Rust IDE that was created by Jetbrains to support the growing popularity of Rust. Vitaly Bragalevsky is a developer advocate at Jetbrains and has expertise in Rust in IDE tooling. He joins the podcast with Lee Acheson to talk about Rust, the current Rust developer ecosystem, using an IDE to make Rust more accessible and more this episode is hosted by Lee Acheson. Lee Acheson is a software architect, author and thought leader on cloud computing and application modernization. His bestselling book, Architecting for Scale, is an essential resource for technical teams looking to maintain high availability and manage risk in their cloud environments. Lee is the host of his podcast Modern Digital Business, produced for people looking to build and grow their digital business. Listen at MDB FM, follow Lee at softwarearchitectureinsights.com and see all his content at leeachison.com.
- [01:37]
Vitaly welcome to Software Engineering Daily.
- [01:40]
Vitaly Bragalevsky
Hi, thank you for having me here.
- [01:42]
Lee Acheson
So most listeners probably know what Rust is, but I don't think everybody does. So for those who don't, can you start by telling me what type of programming language is Rust?
- [01:55]
Vitaly Bragalevsky
Sure. So Rust is usually called systems programming language, so when it was created it was supposed to be used as a replacement for languages like C and C with low level systems jobs. Something like implementing operating system drivers or whole operating systems and doing some sort of that what we usually call systems programming. Maybe that's why there is no garbage collection for example in Rust. And there are other tools for managing memory and it is really low level. But it turned out that it's not necessarily systems programming language these days because it is used in all other domains as well, like web development for example. So right now it's more like a general purpose programming language. Very interesting one in terms of like programming language theory and stuff like that. And it's quite popular I should say.
- [02:55]
Lee Acheson
I always thought it'd be interesting to build a dynamic web application using C. I used to use C way back in the old days. I've actually done some things with web apps with C in the many, many, many, many years ago and it's not as hard as you would think but of course, you know, the whole C ecosystem causes all sorts of issues that you have to deal with. And now the whole idea behind Rust was to solve some of those problems, right? I've never used Rust. Now can you tell me, how is Rust better than C and C trying to do the same sorts of things, since it's that sort of a language.
- [03:35]
Vitaly Bragalevsky
So when you say better, that means that you are trying to compare these languages. And comparing languages is not something like, from my point of view, it is not very productive. So you're right. So when I, for example, read the most famous book about Rust, which is called the Rust programming language, you just immediately get this feeling that they are trying to solve C issues. Like, one of the most famous issues with C is memory management. It is very easy to introduce some error regarding memory access. Like you have a pointer, you allocated memory for it, and then you free double times. Okay, so that's usual thing that comes up when you work with C. Of course there are techniques in C and in C how to avoid these sort of errors, but Rust makes it easier to avoid them by adding specific mechanisms for making it actually impossible to free memory twice. Okay, so this sort of thing. So we have very thorough control on the memory management in Rust. So compiler knows exactly where memories are located, where it has to be freed, and so there is no burden of trying to remember this stuff from a programmer.
- [05:03]
Lee Acheson
But unlike languages like Java and Ruby and other languages, it does it by keeping track of the memory usage real time versus cleaning up afterwards.
- [05:16]
Vitaly Bragalevsky
So it does it by tracking it at compile time. And this is very important. So when you write code in Rust, you have to provide the compiler with sufficient information about these locations, memory allocation and the locations where you don't need that memory anymore. So at compile time everything is decided and then you just run your program. There is no overhead, right, in terms of runtime memory management here, because everything was decided at compile time.
- [05:50]
Lee Acheson
So interestingly that it solves the memory management problem, but yet it really never took off as a system programming replacement language. You don't see Linux kernel drivers written in Rust too often.
- [06:03]
Vitaly Bragalevsky
Let me disagree here. Okay, so first Rust was introduced as a language for Linux kernel, I think a year ago, something like that, it was introduced officially. So it is a supported language. But for projects which are like big enough, of course it's very difficult and impossible and useless to rewrite everything to Rust, but it is possible to implement something in Rust. And of course there are issues with like coexisting several languages in one project, like in Linux kernel, you have C as a first class programming language and then some other languages which are not that first class. But still it is possible. And I don't know where we are going to be like in 10 years. So chances are like some parts of Linux will be implemented in Rust. I think it will be like that. But of course. So it's all about replacement. And I know that many C or C developers actually don't like this attitude of Rust developers who try to persuade everyone to rewrite everything to Rust. That's not a good idea. So the goal of programming language is to solve some issues and to write new software, to write new components of software. So this is something we need Rust for so we can add some code to Linux kernel to make it safer in some cases because of these memory safety features of Rust. But there is no goal to rewrite everything.
- [07:38]
Lee Acheson
So describe a sweet spot project. What would be a project that is right in the middle of the sweet spot of what Rust is good at as well as what is popular at?
- [07:48]
Vitaly Bragalevsky
It's difficult to choose one such project. So when I say that Rust is popular for web development, I don't think it's the main application area right now. Like if you look at practical applications, we see for example software for vehicles, they use Rust there, or some software for companies who run some Internet infrastructure, for example proxy servers or CDN applications. That stuff is also implemented in Rust. So we can easily imagine some audio processing software implemented with Rust and get like a lot of like very good performance and very nice safety. Predictable performance. Exactly. Predictable performance, exactly. And also like financial applications, we can do that in Rust. And I know that Rust is very popular in blockchain technology for implementing things. So all these applications are, well, I would say they are pretty ready for using Rust as a programming language.
- [08:54]
Lee Acheson
You mentioned web apps again and I know it's not the sweet spot application, but you say it is usable in that environment. Does Rust have a solid web framework like Rails is for Ruby or Django is for Python or all the thousand different ones that exist for Java? Is there a web framework for Rust that works for web applications?
- [09:19]
Vitaly Bragalevsky
Well, there are thousands of them. Well, maybe not thousands, it's not that old like Java, but dozens for sure. And of course if you compare them with those very old projects like Ruby on Rails, of course they are much younger and they are not that sophisticated, they're not that mature, but there are a lot of them. And what is interesting, actually there is a lot of research in this area when people try to come up with new ideas like look, I would say that web is a sweet spot for us because, well, it is doable and also you can get amazing performance. And in terms of performance, of course it's incomparable with everything you've just said. Much better in terms of performance than Ruby or like PHP or even Java. So you have some like big plus, like performance and then of course you have this sort of immaturity of ecosystem. But then it takes like a lot of years, like many years to actually to come up with something like really like winner in terms of web frameworks. We're not there yet in Rust.
- [10:31]
Lee Acheson
It's just too young of a language really is the problem. It's not that there's any limitations, it's just a maturity issue.
- [10:38]
Vitaly Bragalevsky
Yes, yes, I would say so.
- [10:40]
Lee Acheson
That makes sense. So where do Rust developers come from today? Are they typically XC developers that discover Rust? Are they ex Java people that discover Rust or are they new developers who typically comes to Rust commonly?
- [10:59]
Vitaly Bragalevsky
This is a great question, especially because I have a very good answer. Okay, so look, they are mostly surprisingly not C or C developers. So we don't see many C and C developers converted to Rust, but in fact we see a lot of Python and JavaScript developers coming into Rust ecosystem and this is very interesting actually. So they know how to use programming languages already. I would say it is very difficult to start programming career with Rust. So Rust as the first programming language in one's life, this is something. Well, it is possible, but it is very difficult. But if you already have some experience in programming, mainly Python and JavaScript as the most popular languages these days, then it's relatively easy for you to grasp several new concepts, especially about this memory management system and then you are ready to write code in Rust. So those folks, I think in Stack Overflow Developer Survey there is very nice diagram about people who are using one programming language and want to start working with other programming language. And if we look at this diagram, it's very visible that python folks and JavaScript folks come to Rust. And I also see this like on conferences, Rust conferences, they are full of people with this background and not that many C and C developers.
- [12:38]
Lee Acheson
Yeah, if I can read between the lines there for a moment, it seems like if you're a native C C developer, you've already, you know, bit the learning curve, so to speak, and you already deal with the shortcomings of the languages and you've, you consider them just things you have to deal with and you already have your tools for dealing with them. And maybe even there's a religious language, religious war aspect to that as well too. But bottom line is there's no strong motivation for somebody who is very knowledgeable in C and C to move to Rust, but there is for someone who's in like Python or JavaScript to move those sorts of languages to move to Rust. Because predictability and performance is something that you may not see early in your career, but very quickly you will start running into problems with predictability issues depending on your types of programs you're writing and your applications you're developing, of course. And very quickly you realize that languages like JavaScript and, and Python and Java and similar languages aren't very predictable and have all sorts of issues associated with them because of garbage collection primarily. Does that make sense as far as the rationale for why you're seeing that, or am I just blowing smoke with that?
- [13:58]
Vitaly Bragalevsky
Well, actually I agree with you. So this is exactly the case. Like in C and C, if you work professionally with those languages, you know how to deal with those issues. So you have linters, you have static analysis tools, you have a lot of stuff to get the job done without those issues. And of course, if you work With Python and JavaScript, you might want some more performance. And another thing here is that if you come from one of those languages, you're already exposed to some Rust because Rust is slowly becoming like the main language for implementing tooling for other programming language. We see that in JavaScript where we have several JavaScript runtimes implemented with Rust. For example, Deno. In Python we have these tools like UV or package management, replemented package management for Python implemented in Rust. So if you are using those tools and you see how efficient those tools are, then you might think that it might be the case that it makes sense to learn some.
- [15:10]
Lee Acheson
Rust makes sense, yeah. So what's the competition to Rust is Go competition or are the use cases different?
- [15:20]
Vitaly Bragalevsky
Well, Go is definitely competitor to Rust and maybe it's not. Well, it's definitely visible. A couple of weeks ago I was at Rust China conference, so I had a discussion about exactly this. Like Go is extremely popular in China and Rust is not that popular. But folks there say that, well, it depends on big companies switching to Rust. So if some big companies start switching to Rust and they use mostly Go these days, then this might be a signal for many others to switch to Rust as well. So at least this is like doable. So if you have Go in your projects, you can switch to Rust and other competitors. Well, there are like newer programming languages like Zig for example, which sometimes which tries to solve like similar problems to Rust. So more both traditional and newer languages can be those competitors.
- [16:27]
Lee Acheson
That makes sense. So let's switch gears a little bit. Let's move from Rust to Rust Rover. Rust Rover of course being the development environment created by JetBrains and for Rust project development. So tell me a little bit about Rust Rover.
- [16:44]
Vitaly Bragalevsky
So at JetBrains we had for many years IntelliJ Rust plugin. It was a plugin for other IDEs such as IntelliJ Idea or Shelion. But then two years ago, maybe a year and a half, we decided to launch dedicated IDE. And for JetBrains it was quite a bold move because studying launching an IDE for new programming language, it can be risky. And there were other tools available for us as well. But still we decided to do that. So for us it is a IDE which allows you to do everything you might need to do with Rust. So it's not only about writing code, but it's also about all other stuff that you might need. Like you can develop database applications we have support for that might be like web publication. We have support for that, we have powerful debugger and all sorts of tools that you expect from full featured. So yeah, so this project, we launched it one year ago and now it's I would say like. Well for me, of course for me I am from JetBrains so for me it is very important tool for doing Rust and there are others as well. But still I think that there is a lot of things that make Rust Strover very useful.
- [18:15]
Lee Acheson
I have to tell you, I'm a big fan of the JetBrain tool set. That's my main development environment is the JetBrain toolsets I use personally just for your reference, I use Rubymine, I use Pycharm, I use Webstorm and I also use DataGrip a lot. And yes, I use DataGrip as a separate tool versus the ones that are integrated in all the other ones. That's just my own personal preference, but everyone has their own preference. But anyway, I love the JetBrains tools, but I've never used Rust and so I've never used Rust Rover. So if I did start to use Rust, how would I find Rust Rover compared to those other jetbrain tools that I may be familiar with?
- [18:57]
Vitaly Bragalevsky
Well, first and foremost it's a tool which is built on IntelliJ platform, which means that everything you already know. So you know those shortcuts, you know how to change your color themes. Like you see all familiar panels and tabs and everything is very familiar to you. So the only new thing is actually your experience when it comes to coding in Rust and everything else is just what you're used to. So we actually see that those folks who have prior exposure to jetbraid stools, of course they like rustrower because it's very familiar to them and it gives them new opportunities regarding Rust.
- [19:40]
Lee Acheson
Right, right. So if you're not familiar with the tools, what other tools might you be using for Rust? And why is Rust Rover better?
- [19:47]
Vitaly Bragalevsky
You know, personally, I talk once again about this word better, so avoid that word better.
- [19:54]
Lee Acheson
So what are some other tools that people use and what do you offer that's different than what they offer?
- [20:02]
Vitaly Bragalevsky
Yeah, so mostly we have there is so called Rust Analyzer which is LSP implementation implementation for language server protocol. And this implementation is used in almost all other code editors like Visual Studio Code or neovim or Helix or other editors available out there. But all of them have extensions or plugins based on Rust Analyzer. And Rust Trover has its own code analysis engine, so it doesn't use Rust Analyzer. So we basically written front end part of Rust compiler and analyze everything by ourselves. But in terms of features, I don't think that like we or Rust Analyzer have more features regarding Rust. So what we actually promote with rustraw is the overall experience because, well, of course you need to write code, you need code completion, you need some error highlighting, you need automatic imports for example, so you don't want to do some boring stuff. And both Rust Analyzer and rustrover provide them. This is like basic features when it comes to writing code, but then you also need other stuff, you need a debugger and we have it at rustroa we have, as I said, database support. We have tools for looking into your memory and analyze what's going on in memory. We have Profiler, so a lot of stuff which is already available in Rostrova. So it is out of the box experience that we actually deliver. And then of course we provide a lot of small features and we are trying to make difference with them. Like for example, one line of development that we actually have in rustrow is supporting developers coming from other programming languages. So like in technical terms we implement our own parser for us code which is very permissive. So we allow all sorts of constructs which are not actually Rust, but we can parse them, we can analyze them and we can suggest fixes like. Well, we know that Python developers coming to Rust, they are used to some things like, I don't know, list add, like they're adding elements to a list. And we know that they meant to use Vector, which is ubiquitous and Rust and we know that. Well, it's a good idea at this location to suggest changing their code to using vectors, right? Or like in C there is increment operator and there is no such thing in Rust, but we know that. Well of course if you write, chances are you want to have something like plus equals one, which is a Rust way to do that. So a lot of small features how we try to understand what was intended and we suggest fixes Introducing Height, the.
- [23:20]
Unknown
Only autonomous project management tool. Backlog grooming, bug triage, keeping documentation up to date. Those aren't why you got into product building, right? Well, height handles all that grunt work for you. Using a first of its kind AI approach, height proactively takes care of time consuming workflows without you lifting a finger. Hyte recognizes when you've agreed to trim, scope and handles, mapping the necessary edits back to your product brief. When new tickets are added to your backlog, height combs through them, adding feature tags, time estimates and more. And it's not just you. Everyone on your team manages projects, tracking updates, scoping work, balancing priorities. But whether or not your product succeeds shouldn't depend on project management. With height, autonomous workflows handle that mundane upkeep so your team can focus on building great products. If you're ready to stop managing projects, it's time for height join the new era of product building where projects manage themselves. Visit Height app sedaily to get started.
- [24:15]
Lee Acheson
One thing you didn't mention though, which actually is something that Jetbrains does focus a lot on, is well, you kind of started getting to it is your AI automation system. Some of what you're talking about is part of that AI ecosystem, but you have within the Jetbrains universe a pretty powerful generative AI environment in general, I'm assuming that same environment that's available in Rubymine, Pycharm, et cetera is also available in Rust Rover. Can you talk a little bit about that ecosystem, what that provides?
- [24:50]
Vitaly Bragalevsky
Yes, we have the same system which is called AI assistant. It works across all our IDEs. And the goal of AI assistant is to integrate AI with your IDE as much as possible. So we know these days like I am old school guy. Maybe I'm not a big fan of AI, but I realized that it really helps a lot in many cases. So the goal of Any professional should be like, if there is a tool, well, let's apply it. If it helps, why not using it, right? So we have this AI and then we work on integrating it into basic software development workflows. Like of course it can generate code for you and we have like several ways to ask AI Assistant to generate that code. Of course we have chat, which is like ubiquitous these days, but it is also like the most recent development which is not, I think it is not released yet, but it is available in early access previews. When you just write your inside your code, just some basic words like implement this and that and then we generate code from this instruction. So you don't use additional tool, right? You write exactly in your editor and then you get a result. So very, very cool feature. And it simplifies everything a lot. And like if you've got a mistake, there's some error in your code, then we can ask AI Assistant to explain that code. If you want to do some refactoring, we can suggest you refactoring and then like IntelliJ platform was famous for refactorings for many years and now we integrate these capabilities with AI Assistant. So we know that in many cases AI in general it can give you like wrong recommendations or it can like break your code. But if you integrate AI Assistant with powerful refactoring tools, then you can make it easier to come up with correct code as a result of applying AI. So that's what we do in Rostrova as well. But I would also mention here we have code completion. And one recent addition to AI tooling is so called full line code completion where you can run. So we run local model local LLM to generate code for you. This is something which doesn't require accessing some external servers, AI providers, it runs locally and if model is able to suggest something, then we show it in your code and you can either apply this suggestion or refuse applying it. So yeah, these are like main stuff. Like main idea, as I said, is integrating AI into basic software development workflow. So this is what we do. We do that in other tools as well, but we also do that in Rastrova.
- [28:05]
Lee Acheson
I'm very impressed with your AI tools. I've used several of the different, you know, GitHub's tools. I've used Amazon Q which has its own set of pros and cons. But I settled on using the the JetBrains AI not only because of its integration. I mean Amazon Q integrates with Jetbrains too, but not only because of Its better integration but because it seems to one, generate seems to be fewer incorrect answers in context because it seems to know the context better. And two, it tends to generate examples based on again, context awareness of what you're currently doing. So you can do things like when you suggest to write a sample of a code segment, it'll write it using variable names and naming structures that's consistent with what you're currently working on. So a lot more likely it's compatible and be able to plug it in and all that sort of stuff. So that all comes back to you have a pretty deep context aware knowledge of the developer's environment at the time you run AI. And I do a lot of AI development, so I know how hard that is to do. REG isn't easy and things beyond REG is very, very difficult. But how deep is your context aware capabilities today? And where do you see that going as far as improving your context awareness to be able to do even more interesting things?
- [29:37]
Vitaly Bragalevsky
When you write something in chat, AI Assistant chat, we add a lot of different information about that because we know that information from your project configuration files. For example, in Rust there is kaggle toml file and from that we know that you already use this and that dependency and it means that we can provide this additional information without you mentioning it explicitly. So we add that information implicitly. So we try to come up with mostly like as full context as possible. So these days I think the main issue with providing context is just about size. So it's impossible to load just millions of bytes of context. Right. So one of the things we do, we try carefully to limit that context, but we also try to include as relevant information as possible.
- [30:38]
Lee Acheson
So for instance, whatever editors you have open the code for, those editors are likely con things to be included into the context of an AI request or as well as the configuration. And you know that they're writing a Python app versus writing a C app or they're in an HTML file and so you know they're writing HTML or JavaScript or CSS or something like that, you know that context and you provide as much of that as you can, but based on where the developer is. So you could ask the exact same question while editing one file compared to a completely different part of your application. And you'd get a completely different context associated with that.
- [31:21]
Vitaly Bragalevsky
Exactly, exactly.
- [31:23]
Lee Acheson
The other tools tend to do that too, but I don't find they do nearly as good of a job as you do on that. I think you're saying that's probably related to the Intellij backend knowledge of what you have with the development environment. But you seem to have a really good knowledge outside of the AI environment of what the code is that's being worked on currently besides just open editors and things like that. And you tend to include that. And I really find that, I guess I'm saying I'm impressed with how you do that and what you're able to accomplish. And I guess the follow on question I would have is you already do a great job there. What's next?
- [32:01]
Vitaly Bragalevsky
Well, you know we have a lot of research going on inside Jetbrains, especially in terms of AI and additional things that we can do. You mentioned this deep knowledge about the context. I think it comes from research as well. So it is very difficult to choose whatever goes to that context. And we try, we compare different approaches, we. We try new ways to integrate that. I don't think that I actually fully aware about particular roadmap that we have. I think it's something that it shouldn't be published because it's part of the game in this area. Right. But what I know for sure from the side of Rostrova team, so what I know for sure is that we also try to find the solution to this problem. How to make AI better at Rust. So how we can help Rust developers to work around their error messages, for example. So this is something what we are thinking about. So we can use a lot of traditional tools to explain errors like some, some sort of highlighting, some special sorts of highlighting which is like directly related to what is going on in Rust code. But then we also think how we can help in terms of AI to explain that error. So maybe how to ask AI to add additional details which are more relevant for us and may be less relevant for other programming languages. For example, in Rust it is important, as we discussed earlier, this stuff about memory safety, memory management, like whether you copy data or clone it or want to avoid that stuff. So it might be a good idea while explaining errors to provide additional detail about how to avoid such situation. So this is something that we are focused right now because we would like to see AI not as a general tool, but also as a tool targeted at Rust developers. So that's what we're doing.
- [34:31]
Lee Acheson
Rustrove team so the context aware language aware, of course, yeah. That's basically what you do. That all makes perfect sense. One of the things that I do notice which I like is whatever tool I'm using, I tend to have access to the parts I need of other languages when I need them for Instance, when I'm using rubymine and developing a Rails app, or I'm using pycharm and I'm developing a Django application, I still edit a lot of HTML files, JavaScript files, CSS files, all of the environment I need to develop that. And by the way, all the AI support I need for that is all available to me. And that's actually wonderful to the point where I only go to something like Webstorm when I'm doing a heavy JavaScript specific project for a front end. I only use Webstorm for that. Otherwise all the other front end editing that I do I'll do within the Ruby Mine or the pycharm environments. And that's a great way for all that to work together. And Data Grip does the same sort of thing. But what's interesting is it's kind of made the lines between these tools a little bit blurry, right? So when should you be using Webstorm vs Rubymine? When should you be using Rust Rover vs Webstorm or pick another tool? When should you be doing that? And I know Jetbrains has kind of gone pendulum. Shift, maybe is a great way to say it on this topic. Before, for a long time, Jetbrains focus was on creating another tool, creating another tool, creating another tool. And that's when you started doing Rust over. You were creating a tool for Rust and you've done the same thing with Ruby and Python and everything else as well. But now you're kind of swinging the other way. You're looking at integrating all these tools back together again into a single development environment that can be shared and used. And what I'm leading to here is a discussion about your project called Fleet. Can you tell me what Fleet is and how it kind of represents the shift and where you see it going? And where do you see Jetbrains going with it?
- [36:50]
Vitaly Bragalevsky
First, I should mention that besides those separate tools like PyCharm or Rostrova, we also have IntelliJ Idea Ultimate. And there you can install all those plugins as well and have exactly the same experience. Like you can install rust plugin into IntelliJ Idea ultimate and then you can work with Java, Kotlin or Rust and you will have the same experience as in rustrova. So it's up to you whether you want a standalone tool or you may want to have like everything included here you choose whatever works better for you. Like I have intellij Idea ultimate with like almost all plugins installed. Like today I was writing code in Scala, for example, with our IntelliJ Scala plugin and I have Rust installed there as well. But if I work on just precisely on Rust project, then I would choose rustroa just because like when you create new projects you see only what's relevant to Rust development. When you have those actions or quick fixes, you just see whatever you might use for Rust and not anything else. So it's, it's. Well it's personal choice. So if we are moving to Fleet, then with Fleet there was the like a little bit different idea behind it. So first Fleet is Polyglot development tool. Like some time ago I published blog posts about Polyglot development in Fleet and there was like very funny project there where I tried to use as many programming languages as possible and I end up with a dozen of them, like almost all languages supported by Fleet. And it was like Microservice application where different microservices are implemented in different programming languages. Like there is Rust, there is C, there is C and also JavaScript and other languages as well. And this kind of development is much easier in Fleet because you use exactly the same interface, you have a single editor and on top of that with the so called Smart mode, if you enable it, you don't have to, but if you enable it you get much more sophisticated support for other programming language technologies. So not just basic editing stuff. So the idea behind Fleet was to make this very smooth experience when it comes to work with many programming languages. So Fleet is under Preview right now. So it's not a released product. So it is available for free for everyone because it is preview so everyone can try it. It uses very lightweight ui. We consider Fleet as a platform for experimenting with ui. We know a lot about ui. For example, in a couple of years we've implemented so called new UI for IntelliJ idea and other IntelliJ based tools. And we're experimenting much more with Fleet. When you have like not yet a product, not commercially released product, you can experiment a lot. So we try to find new horizons in UI for software development. So this is Fleet. So many languages, new ideas in UI making it. For example, we have keymaps there and when we were developing keymaps for Fleet, we tried to make them as smooth as possible for particular operating systems. Like if you work on macOS then you are used to use some particular shortcuts for any other applications. And we respect all that in Fleet and the same for Linux and Windows. Okay, so big huge experiment in this area of editors for software development. There are many others and we try to make our own very new project.
- [41:17]
Lee Acheson
This actually answers one of my follow on questions too, I think. And let me see if I can get this right. And the follow on question was, how does fleet compare to IntelliJ idea, which is your universal based product that's language independent and has all these plugins you were talking about? It sounds like the way to think about it is the universe of IntelliJ tools. Whether we're talking about Idea or we're talking about, you know, rubymind, pycharm, rustrover, et cetera, they're all in the same class, they all work together. The difference isn't whether or not you can program in HTML in one but not in the other. The difference is which ones do they focus on? So Rust Rover focuses on Rust, yet you can still do Rust development and other environments. But Fleet is different than all of that because the idea behind Fleet is to try and create a new environment with new ideas and new thoughts that are different than the way people have used the IntelliJ tools in the past. Is that a fair way to compare it?
- [42:23]
Vitaly Bragalevsky
Yes. And also we don't try to include many intelligent idea features in Fleet, so we are not trying to reimplement them for Fleet. It's not our goal. And we know that some developers prefer feature rich environment where like you can access almost everything with a shortcut and you have menu item for everything basically. And we don't do that in Fleet. So it's not only about being new, of course it's new, but it's also about providing new experience in terms of chances are many developers just don't use those advanced features. So we try to distinguish, so we have integrated development environment with everything included, with everything implemented, new features every month, new additional tools for you and then something which is like more basic, but it might work better for many developers out there, those who just don't need all those advanced features. So we want to make the experience better.
- [43:40]
Lee Acheson
Yeah, that makes sense. This has been a great conversation and I want to thank you for joining me today. Thank you for coming on Software Engineering Daily.
- [43:49]
Vitaly Bragalevsky
Thank you, thank you very much.