
Atom Reaches One Million Active Users - SiVal
http://blog.atom.io/
======
FooBarWidget
Them being able to tell how many active users they have means that they track
this in the Atom app. Atom never told me about this during startup. I'm
personally not bothered by this, but I know that a lot of techies are against
phoning-home practices. Is there anybody here who IS bothered by this?

~~~
bottled_poe
It's pretty much expected at this point. I gave up online privacy last decade.

~~~
vetinari
I didn't give up my online privacy yet. Apps have no business to phone home.
Little Snitch FTW ;)

------
casperc
I would really like to use it too, but the latency while typing is killing me
whenever I try.

~~~
scriptproof
Atom is in competition with Brackets (Ace), Visual Studio Code (CodeMirror),
Advanced Editor (Ace), to cite only the free software. All the others are
quicker. I wonder how they get all these users.

~~~
chr1
Small correction: Brackets uses Codemirror, Visual Studio Code uses its own
editor called monaco, Advanced Editor (if you mean the wordpress plugin) uses
Codemirror as well, Ace is used by c9.io and RStudio for example.

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.

~~~
scriptproof
You are right, Adobe Brackets is in the list of CodeMirror users. But I mean
Advanced Editor based on Node.js and Ace
([https://github.com/Scriptol/Advanced-
Editor](https://github.com/Scriptol/Advanced-Editor)). VSC uses Electron,
hence the confusion, but not Atom and Codemirror.

------
swang
I stopped using Atom after I ran into this issue:[0]

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.

[0][https://github.com/atom/find-and-
replace/issues/550](https://github.com/atom/find-and-replace/issues/550)

~~~
adrianN
I agree that this is an annoying issue, but doesn't your version control take
care about undoing things like that?

~~~
Matt3o12_
I don't really use version control for text because it is often pointless (how
helpful are one or two commits when I will never touch the text again after
getting graded). And yet I still use More tradition text ediots for that
(WYSIWYG editors can get really annoying). Though i personal vim over atom but
that is not the point. The point is that undoing things is really important.

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

~~~
yAnonymous
You can add files to the index before doing find/replace and then go back to
that if something goes wrong.

When you only add files to the index right before you commit, you are wasting
a lot of your VCS' potential.

~~~
Matt3o12_
I sometimes do that for as a kind of backup, when there is a chance that
something disastrous could happen but that requires that I use a version
control system (which is pointless for text documents with less then 2000
Words IMO) or that I remember doing that. Because once I add files to the
index, i might as well create a commit and squash it later.

------
hit8run
Yet I need to find one area where Atom is best of breed in. HTML + JS + CSS =>
Brackets because of the preview function or Webstorm; Golang => SublimeText or
vscode; Java => IntelliJ or Netbeans or Eclipse; Atom UI is nice and I can
imagine Atom becoming a superpower editor within the next years but it just
isn't there yet.

~~~
yAnonymous
>I need to find one area where Atom is best of breed in.

It has the best collection of packages for web development.

------
nickysielicki
Serious question: why don't Atom users use other products?

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?

~~~
arvinsim
> Vim or Emacs -- UI is too foreign > JetBrains or Sublime - not free

Some people just want a free Sublime clone.

~~~
BigJono
Sublime isn't free?

~~~
dagw
Nope. Commercial software that cost $70. However they don't disable or cripple
the software after your 30 day trial is up, they just pop up regular
reminders.

------
SiVal
Atom is a madhouse. It's what you might expect from Github, a company with no
experience in deep, complex IDE tools but lots of experience bringing together
a small army of amateurs to contribute to a stone soup, open source project.
It's wide with wonderful, useful conveniences, and not very deep in the kind
of tools that take CS PhDs years to get right at places like Microsoft.

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.

------
arvinsim
The one thing putting me off Atom is that it is a battery hog on laptops.

