A project to create a new kind of an IDE, a 'transforming' IDE that is meant to adapt to your workflows and your projects, instead of being general or specialised for a single language.
~3,202 words.
to read at 250 WPM.
IDEs are an integral part of programming and development, sure some people say that you don't need them, you could just open up a very primitive text editor, and use a CLI for building and/or running your program, but you're just gonna hate yourself for it (unless you enjoy the pain of course). And to those people, I say that they've clearly never used a proper specialised IDE that made it a pleasure to program.
(A rare heaven).
Specialised IDEs are great, and when used instead of a general IDE, they make it feel as if your tooling has just took a deep breath of fresh air and it came back to life.
Specialised IDEs (as the name suggests) are indeed specialised. Typically for a single language. Which means that the development process can end up feeling much much much more polished, streamlined, and exactly what you want for working with that language.
The entire experience will usually get a big boost, along with having extra tooling that is relevant for working with the language that the IDE is aimed at, (Such as profiling tools, testing tools, live previews for documents, e.t.c).
However, specialised IDEs take a lot of time and effort to make, and so good quality ones are unfortunately rare to come by. And somewhat surprisingly, it seems that quite a few of more niche languages end up having some sort of a specialised IDE, (usually a low quality one), that was written by either the developers of the language, by one of the fans, or by the community.
And it's great to see that the thought was there, however usually those IDEs are written by people who haven't ever written an IDE before, who's passion isn't the IDE, but the language that they made, and the IDE is just something they see as a necessity.
In the end however, the worst part about specialised IDEs is probably that they end up being so different from each other, without offering any sort of coherent design. This also make it hard to switch away from them, or to learn a language that they don't support, simply because you're so used to them and learning a new IDE ends up being quite challenging.
As a C# programmer that used to use Windows, my experience with specialised IDEs primarily consists of Visual Studio. And in my experience, VS did quite a good job.
There were of course times where it absolutely sucked so god damn much (I'm looking at you VS 2019 - *insert angry man shouting at clouds*), however overall I've had much more positive experiences with it than bad ones, everything just worked as it should.
It's downside however, is that it's Windows only, and Windows sucks (for several large reasons that have nothing to do with this article), so I switched away from it.
If you're in the C# space, then you're going to be recommended to either use VS, or Rider. VS being the Windows-only one that has a free community edition along with paid enterprise versions, and Rider being the cross-platform one that, that has paid version and a (very questionable) free version.
My experience with Rider is in fact quite limited, and maybe it has improved since I've tried it out, however my very first experience with it left an incredibly bad impression, it's key binds (which it said it imported from VS) didn't work as expected, the auto-hide panel feature that I was incredibly used to in VS just didn't work, there wasn't an easy way to switch between project configurations like there was in VS (but I'm told that feature was now added).
And overall, I just really didn't like it's UI and UX.
(A jumbled up mess).
In my opinion, general IDEs are a wishful idea, and in a perfect world they might have ended up being the best option. However, from my experience, I never wanted to burn anything to the ground so badly before.
In all fairness, the idea behind general IDEs is a solid one: focus on making a good text editor, that can then be easily configured and upgraded with extensions written by the community. There are usually several different types of extensions in this case, primarily either ones that add support for new languages, or ones that modify the IDE itself in some way.
This means that they can support virtually any language that exists out there, as long as someone is willing to make an extension for it, therefore you can keep on using the same IDE that you've become used to for developing different things.
Another good part of general IDEs, is that if you're using an extension for something, and you don't like it, then you can generally just switch to a different extension, or even make one yourself if you need a more custom solution.
However, in reality (at least from my experience), what ends up happening is that you get a plethora of lacklustre extensions (rarely are there any good ones), along with an IDE that you have to configure in weird ways that lack polish.
Along with that, in my experience the extensions don't work together as well as they could, for example spell checking, with code this can be difficult to get correctly, as there are several places that should be spell checked, and some places that shouldn't ever be spell checked, and some where it depends on the context.
And typically a good spell checker will need to have decent integration with whatever programming language you're using, at least so that it can understand the structure of the code file. Because this isn't as simple as "spell check all comments", since in some languages (such as in C#), you have documentation comments that use XML markup, and obviously neither the XML tags themselves, nor the attributes should be spell checked (here I mean the name of the attribute itself, whether the value should be spell checked is more contextual). Only the contents of some elements should be spell checked.
Ah dear VSCode, the bane of my existence. I was first forced to use it when I switched over from Windows to Linux (no, not Arch), since as I've explained earlier, I don't particularly like Rider, and most of the other alternatives I've been suggested sounded a bit crazy (why would I ever want to use OnlineGDB as my primary IDE for C#!?!?).
And I honestly still miss VS sometimes, which is why I desperately want to make this project, the C# experience in VSCode sucks so god damn much it makes me wonder whether the devs require a mental evaluation, and if they're even proud of the code that they've written, and this goes for both the VSCode developers, and for the developers of the C# Dev Kit extension.
I have many, many gripes with the experience that I've had so far, and some of the bugs and/or missing features that I've encountered have either been ignored for years, or they've been marked as a low priority. (Polish your software god damn it!!!)
When in fact, they're quite important if you don't want to be tearing out your hair. And honestly the next part is probably gonna sound like an incoherent rant, because I'm just too fed up with it.
DeterministicSourcePaths property. Rider handles this properly, and I'm assuming VS will do as well. End key on your keyboard) ends up moving the cursor to the end of the function signature, rather than to the end of the implementation. So if you want to add a new line break (and then more code) after the function, you gotta expand it, then move to the end, add the line break, (optionally) collapse the function again, and only then can you add more code after it. DynamicDataAttribute) aren't properly displayed or counted.{ in my case), and then I'll be able to run the test. It doesn't work if I have my cursor on the name of the test function. Damn, that's a lot of issues, and I've only been using VSCode for half a year so far, definitely not leaving a good impression. And that's mostly the issues I've had when trying it with C#, not the issue I've had with it in general.
In my opinion, the settings menu leaves a bit to be desired (now I don't know whether it's VSCode that's to blame for this, or the developers of the extensions that add in the settings, either way, it's the VSCode experience). The settings over all end up being not that bad compared to what I've seen in a lot of other pieces of software, however sometimes you're just forced to edit the JSON settings file manually, which isn't great.
Particularly because their JSON tooling doesn't even let you format the file nicely, so you're stuck with manually editing a large JSON object without any ability to make it a nicer, more organised experience for yourself.
Overall I absolutely despise the experience I've had with VSCode, and once I make my own IDE then I hope it burns in a trash can and is never seen again (or at least that I never have to look at it or use it ever again in my entire life).
(A new contender enters the arena?)
So what exactly do I mean by a 'transforming' IDE? Well in my view, it would be a mix between a specialised IDE and a general one, with the main distinction being that it's the IDE that provides all of the general re-usable functionality (as opposed to just providing the functionality necessary for a text editor, which is what general IDEs commonly do) and components like: spell checking; middle-ware for customising how the built-in language support works; CI/CD integration; source control; e.t.c.
Imagine the IDE dutifully keeping those components up to the highest standard and polish, and giving them to you as a mix & match of functionality that you can pick out and customise for the needs of your specific project.
Where there's no need to have random sub-par extensions just to add mediocre support for very general and expected features. The only extensions being the ones that you can easily create yourself, to further tailor the IDE to your own projects (such as if you need to add in support for a bespoke language, or a new workflow).
Let me paint a picture for you (or try to at least, I suck at it... why am I even attempting this? Eh whatever, it'll hopefully be good enough).
Imagine opening up your IDE, and seeing a blank slate, no extensions being loaded or being updated in the background, just your IDE starting up real quick. No panels, no status bars, just the simple IDE window asking you if you want to open a previous project, or start a new one.
Imagine opening up one of your latest projects, a game perhaps (a game is required for this example, deal with it), a game in one of the lesser known engines, or perhaps your own bespoke one (doubt it, we all know game engine devs never actually end up working on the game itself).
Imagine having a texture atlas system in your game, perhaps one where the id of the texture is a mangled version of the texture's path (I don't actually know how texture atlases work, I'm just making this up as I go along, I definitely should've picked a better example than this, but whatever I'm sticking with it).
Then imagine trying to get the texture from your atlas some place in your code, and getting auto-complete suggestions for the texture atlas ids, but only in the contexts where it actually makes sense, you won't be getting those suggestions in every place that you type something, but only when it's a value that you'd want to use in that context.
Imagine having real-time validation for any texture ids that you use in your code, telling you when you've accidentally used the wrong one, (or perhaps you've removed a texture and it's id is no longer valid), and getting suggestions for which id you most likely meant to use.
Imagine renaming a texture, and it's id automatically updating across your code base, or perhaps you've changed the code for generating the texture ids, and then the IDE asks you if you'd like to automatically update all of the texture ids that have been used in your code, to the ones that your new algorithm will generate.
Imagine having your IDE actually adapt to your project, not just a random template you've found online and had to follow, or through a very general purpose extension that you've installed, that sort of, kinda, generally works, but really you'd like something better.
Imagine having an IDE that cares about your bespoke project, where you can modify the IDE to your liking, so that all of the tooling is just perfect for your particular needs.
Imagine customising the IDE to have all of that functionality, and it only taking you a maximum of an hour. And then it just works, and you can easily re-use it across your other projects if you'd like to.
Or as a different example, imagine writing a blog that uses your own custom format or notation, and then converting it to HTML. (I'm currently writing in an XML file - for lack of easier options - and having that be converted to HTML).
Imagine making the IDE aware of your specific format and notation, and having all of the tools to be able to easily make the IDE capable of understanding the entire CST (and that means proper support and tooling, not just having a bunch of hellish regex patterns everywhere), making it easy to specify which areas need checking for spelling and grammar (something I could definitely use right now), and which areas should be ignored (I just love it when general spell checkers decide to spell check my links).
Imagine the IDE also knowing which parts of your format refer to links, and being able to verify whether they still point to actual pages, or if they've turned into dead links.
Imagine having accurate word counts that are calculated after extracting the actual plain-text of your notation, and ignoring any markup related syntax.
And that's all on top of being able to verify that you've actually used your own format correctly. It would even be possible for you to have a live preview of what content will be generated at real time without having to run your entire pipeline.
This project is currently very theoretical and hypothetical, there is no proper write up anywhere yet, and as such it is subject to change, maybe even dramatically so.
However initially I only plan to add in the features that I require for my own needs, and only then will I slowly work on adding in extra features that other people might find useful, since this project is definitely going to be a massive undertaking.
But I'm not in a rush, I want to explore and experiment, and the main purpose of this IDE will be to focus on exploring this new approach (it's new as far as I know, I haven't heard of anything similar before), rather than just trying out the same old established approaches.
The hope is that the transforming IDE will be capable of resembling a specialised IDE, but for several different languages, rather than just one.
A specialised IDE is also typically focused on the language itself, and the tooling around it, whereas the transforming IDE will focus more on how you're using the language(s), and what your development process looks like.
Both IDEs follow the idea of being able to have an IDE that can be configured and extended, however the main difference lies in the responsibilities.
General IDEs tend to focus on providing the primary text editor features, and leaving everything else up to the extensions, which the user then has to find, install and then configure them (assuming an extension that they need even exists).
The transforming IDE will focus on providing all of the general functionality that is typically expected in feature full IDEs (this means things like spell checking, source control, e.t.c on top of the functionality needed for a good text editor), along with making it incredibly easy to configure them, and provide a lot of tooling to help create custom extensions (in cases where you want to add in support for a bespoke language, or if for example you want to customise the auto-complete suggestions).
The user then is offered a plethora of polished components and workflows that they can pick and choose to use, depending on what their current project needs.