Atom Reaches One Million Active Users
blog.atom.io
blog.atom.io
Edit: Not saying I like this "freedom advancement" much either; even databases like InfluxDB defaults to phoning home nowadays -- but this one is pretty simple to both find and disable.
Yes it did: http://i.imgur.com/rVEs02x.png
I have started using Brackets more and more for HTML and CSS editing, however.
"Given enough eyeballs, all bugs are shallow." - Linus Torvalds
At any rate, I downloaded it to try it out for a few days. I didn't notice any initial latency. My current editors are Sublime and Xcode but I still use Emacs and vim on occasion.
Atom, from github has no "we also make" worries the developers might wedge in there.
VS Code was last to the party.
I still use brackets but I installed Atom last week to have a go with. I was pleased with what comes out of the box. (context): I used to use sublime since (roughly) just before 3.0 builds were announced then used brackets from around 1.0.
sublime and brackets used to really crawl until I excluded things like .git and node_modules form their search tools. Perhaps Atom is similar for people?
I'd expect some part of their users are people who have it installed, and check from time to time if it became faster or not, but the main thing making it popular is the promise of being easily extensible.
Are you using the latest version? Performance did increase quite a lot since 1.0.
I suppose it's subjective/a matter of habit. I have a colleague who uses Atom and I tried it on his workstation, because I desperately wanted to like Atom so that I can finally put Emacs away and leave the 1980s behind. He swears it's fine, but the lag is driving me mad.
I'm not a super fast typist (110-120 wpm on a good keyboard, and I certainly don't type that fast when I'm coding because I don't think that fast). But I don't look at the keyboard when I'm typing and the lag is very triggering.
Basically it's possible to accidentally do a mass replace of a word you did not intend to. In sublime, if you do a mass find/replace, it doesn't save the file. However by default atom saves all the files you make a find/replace in. So you could lose a lot of time undoing an accidental replace. Given my habits (listed in the issue) while in a text editor, this was unacceptable risk for using atom, so of course I filed a ticket which promptly died out.
I would like to continue using atom, even with the latency startup issue, but there's too much risk for me in accidentally wasting a lot of time getting bit by this issue.
2) You can only use mass replace after doing a search first, so you can see what is going to be replaced.
3) You should look at the input before doing a find/replace.
4) Better use of version control would have made your problem a non-issue, even after 3).
Both of these features enable you to get stuff done faster. It's only different, yet you're acting as if it's wrong. If you like the Sublime Text way more, keep using it. But please, don't act all entitled and try to make Atom exactly like Sublime Text in every way.
That's funny, because Sublime Text opens all currently not opened files with matches for you to review before saving them individually. Having all that in a single search window is definitely faster.
Again, you cling to a single use case (having all files with matches already open) and demand changes, because you think your way of doing it is "right" when in fact there are many use cases that benefit from the way Atom currently handles find/replace.
"Ooops, I didn't mean to do that" is one of the primary reasons why "Undo" was invented. It's something that should be fixed in the editor, not offloaded to the version control system, especially since there's no reason to assume that every single plain text file you'll ever edit is under version control.
I've also often been in a position where I do big commits that contain about 200 lines of code and messed up by using replace/etc in the wrong way
When you only add files to the index right before you commit, you are wasting a lot of your VCS' potential.
It has the best collection of packages for web development.
If you just need a free text editor that works well with source code, why not Vim or Emacs? With the right plugin (or a terminal) it probably integrates better with what you're doing than Atom-- excepting React Native with their Atom plugin.
If you're willing to pay, why not JetBrains or Sublime?
I just don't understand the middle ground that Atom seems to exist in. What is it best at?
Some people just want a free Sublime clone.
Nothing, but it doesn't have to be. It's pretty good at most things, terrible at nothing, has a very shallow learning curve, comes with a pretty sane default setup, lots of useful plugins and is easy to configure.
2. Really fast release scedule. While this may trade of some stability here and there, it cetainly adds new features quicker than Sublime or Vim (AFAIK).
--If you're willing to pay, why not JetBrains or Sublime?
3. Why should you pay for other Editors if you don't have to with atom? :D I'm a CS student and a lot of people I know are using atom because they can't afford/ are not willing to pay ~50 bucks for an IDE/ text editor.
Learning to use vim and emacs requires large effort, and customizing them requires learning languages/apis that are not useful for anything else and are not interesting.
That's why many people prefer to endure some slowness, but use something with nice ui and based on web tech they know and love.
It's a perfect reflection of the madness that is front-end web dev: a crazy quilt of evolving technologies on which a significant portion of its functionality is built by stacking up extensions like Jenga blocks, and each day some of those blocks are upgraded, the ones causing the latest 100% CPU issue are identified and deactivated for the next version or two, another stab is made at resolving conflicts between independent autocompleters with undefined priority, a wonderful new extension is discovered, it gradually gets slower and slower until you restart it, then it's nice and quick doing whatever it can do today....
Then there's Visual Studio Code from Microsoft, which is also what you might expect given their background. These people know how to build a deep, powerful IDE, and it's an amazing statement about their technical depth that they managed to build such a snappy, solid-feeling editor (that never needs to be restarted and opens multiMB files with aplomb) on top of the same Electron base Atom is built on, and doubly amazing when you consider that Electron itself was built by Github.
But in contrast to their technical depth, MS seems out of their depth when dealing with an open community of developers. In contrast to Atom's chaotic, buzzing discussion forum, Visual Studio Code's forum is...well, actually it doesn't even exist. The closest they have is an "issues" list hosted by, yes, Github, and a list of feature requests you can vote on which can accommodate comments, but which the MS team warns candidly that they never look at. (They only look at the vote count and even then, there's little evidence they look beyond the top 5% or so of requests.) Neither of these is a discussion forum where users get together and help each other, and MS doesn't seem to have the resources to both do what they want with VS Code and find out what users want, so they stick to the former.
VS Code lacks so many common editing conveniences available in Atom (a minimap, drag and drop text editing, a project switcher, indentation lines, a way to make the faint bracket matching highlight visible....) and adds these so slowly if at all that, for these fairly shallow but very useful features, you seem to have some poor guy volunteering his 20% time at MS vs. a small army of volunteer developers contributing to Atom.
And yet, the MS people are talking about deep, ambitious, full-blown IDE features planned for VS Code--and these people understand how to build such things--while Github can't seem to get past the challenge of how to open a big file and say they aren't interested in ever becoming a powerful IDE.
So, will Atom's furious beehive of JavaScript-style chaos eventually evolve deep tools and a fast, solid base? Or will Microsoft's old school, tiny team of experts figure out a way to get the conveniences done by others without undermining the foundation while they build a serious, deep dev tool?
I hope it won't take too long for at least one of them to be solid, wide, and deep.