A sun sets, a pulsar is born

Recently Microsoft announced that the destruction of the Atom editor – I already posted about that, but I want to say that the community response for the sunset was really wonderful – in the beginning, I really thought that the Atom editor would die with the Microsoft announcement. But after posting on a lot of channels, and a very organized “call for arms”, we were able to organize ourselves and create something wonderful – the atom-community is now more active than ever, and indeed there is work being done right now.

People decided join our discord servers; we are reimplementing the API that will be discarded by Microsoft, and modernizing the editor like, for example, bumping tree-sitter and Electron (we now can run Atom on Electron 12); we also will need to rebrand it, and the name chose – Pulsar – could not be more fitting: it’s easy to remember, it basically means a “star that dies, but starts to spin faster and give bursts of radiation”.

I also was able to somehow bootstrap the editor without the original “bootstrap script” from Atom (that is famous to not work correctly, and also need an older version of Node.JS). I was also able to build binaries of Atom with “electron builder” – it’s library from the electron community to build the binaries instead of the way Atom do today (that is a bunch of scripts).

So this makes 5000 lines of code less that we have to keep of Electron scripts – except for the fact that there’s actually a lot of things in Atom that depends on things that these 5k lines do – like some plug-ins that misbehave when you don’t run the scripts, and all the test code that currently will not even run if you don’t bootstrap things.

So what this means for the Saturn editor? Is it the death of the product, like, will Pulsar will be basically the editor that I want to have? And unfortunately, it seems the answer for that question is “no”.

The reason for that is some disagreement with how we want to develop Pulsar – the atom-community wants to modernize things slowly, keep the current structure as much as possible, and fix tests – basically, keep the editor stable as it is today, which means not changing too much code and not changing the scripts and everything if we don’t have a good reason.

I, on the other hand, feel that Atom/Pulsar needs to change a lot – there is still lots of CoffeeScript, the way package management is done is weird (it delegates to the external command apm that tries to find packages both on Atom HOME and on some metadata in package.json that’s added after bootstrapping everything), there’s some issues with how one can programatically create a Text Editor with the Atom API (if you manually create an editor, most plug-ins simply do not activate) and finally, there are some hardcoded issues that make things difficult if one wants to change the layout of the editor (which means, my experiments with Code Bubbles are harder than it seems). I also want to separate the Text Editor from the rest of the package, so we can update things independently (and also test faster alternatives for the editor, like changing the library etch for something better), etc. But my most important reason is: bootstrap.

I already saw at least five posts of people wanting to help hack the core of the editor, and not finding success on doing so. This needs to change: it’s a Node.JS project with Electron, it should not be that hard to start developing. Best of all worlds, you install the packages and run npm start – opening a “Pulsar” editor for development; acceptable, you run something watch and it precompiles/incrementally compiles the Javascript that we have in a specific directory, and then npm start will start this precompiled version. The current way is:

1. Install Node.JS 12
2. Run ./script/boostrap. Hope it passes (it takes quite a lot of time)
3. Open the directory out/atom-<something>
4. Run the atom script that’s in this directory
5. Hope the editor opens correctly and without errors

I actually never had any luck on running this correctly. Also, as of now, Node LTS (Long-term Support) is version 16 – which means we’re four versions behind the node that still gets security patches – and to bump Electron more than the 12 version, we’ll need to handle even newer versions of Node. The boostrap script do lots of things that NPM do – even things that were undocumented and discontinued (hurray for the inexistent backwards compatibility of Javascript! Again!) so, it can be quite hard to know what’s even wrong.

But worst part is if you want to change some code. I actually have no idea what one is supposed to do when you change code. The only thing that actually works for me is to run ./script/clean and ./script/bootstrap which is completely unacceptable considering how long it takes and how unstable it is…

So what I’m currently doing is trying to push as far as Electron updates I can, push as far as experiments I can, while trying to do pull requests on atom-community repository. And I do believe Pulsar will be successful, that we will be able to push to recent Electron versions (I already am running Atom/Pulsar on Electron 12, and I feel I can make it work on Electron 15) but honestly, I think that will be it. Maybe there will be a time when we’ll be able to modernize the whole structure, the scripts, etc, but I fear that when this time comes, people that are now excited to hack on Atom’s core will be gone and we’ll be back to a few contributors that want to “get their hands dirty” on a codebase that is dated for a while, received no modernizations for at least two years, and it’s currently lacking behind almost everything else.

This means that the idea of the Saturn text editor is still a very real one – provided that I can build it, that is. I’ll just wait to see if Pulsar will indeed bring a new life for the editor, and make package authors publish newer versions of their packages, to see which APIs I’ll support – if I will keep the original idea of supporting both Atom API and VSCode (with specific Saturn extensions to make it more hackable) or only the VSCode one. So for now, there are some possible outcomes on my saga of a Hackable Text Editor:

1. Pulsar becomes the hackable experience I want – maybe I’m just reading too much on our disagreements, and indeed after we survive after the sunset we actually work on changing the code to become less cluttered, more modern, and easier to hack?
2. Pulsar keeps the same idea of Atom, but with more recent updates, Electron version bumps, updates to modern libraries, but without making too many bold modifications to the core – in this case, I’ll either:
   2.1 – Keep developing Saturn by cannibalizing some parts of the Atom. Then I’ll have to decide how much of the Atom API I want to implement – most of it (if Pulsar becomes popular-ish and people start to develop extensions to it), only sufficient to re-use Atom fragments (so I’ll keep using Atom/Pulsar UI elements but not sufficient to actually implement a plug-in on it), or none at all (either by replacing all UI elements for something self-made, or not exposing what I have to implement to support Atom/Pulsar UI)
   2.2 – Keep a fork of Pulsar – with a different name, but removing the things I feel that are dated, maybe even replacing some of the native extensions, to see if I can make it easier to develop, to build, with a different set of tests and everything. I actually want to remove the whole “Resources Path” and the “custom-made scripts”, the “external APM” and other things that I feel are dated. Finally, maybe it is possible to add a VSCode API Layer over this version of Pulsar, maybe even with the “extended API for hackable editors” that I was originally thinking for Saturn; if this proves possible, maybe even slowly migrate away this version of Pulsar to ClojureScript, effectively creating “Saturn” from it, who knows?

The only thing I know is – there must be a reason for 2.2 to exist. If Atom dies, even with all the work we’re doing, with all the rebranding and propaganda we’re trying, and people move away to VSCode, none of this will actually matter. There is already a bunch of Atom extensions that were archived with the announcement of Microsoft – but we’ll have to wait and see.

One thing does not change: even with all disagreements, I’m actually excited to see the community take action and not let the editor die!