
Atom 1.29 - one-more-minute
http://blog.atom.io/2018/07/31/atom-1-29.html
======
saagarjha
I see a GIF of someone going deleting a couple lines of code, with a meter
showing that the application is maintaining 60 FPS. Was this not something
Atom could do before? It seems to me that the bare minimum should be
maintaining 60 FPS while performing basic editing tasks…is there some nuance
here I'm missing?

~~~
paulddraper
> bare minimum should be maintaining 60 FPS

Yours would be a nice world to live in.

I've seen IntelliJ and Eclipse both crawl when doing "basic editing tasks".
Hell, Vim does it too if your line length is long.

~~~
redisman
But IntelliJ and Eclipse (depending on the language) run compilers to do code
checking right? Certainly too many text editors don't work very well with
large text files which is a bit funny.

~~~
paulddraper
Yes, Intellij and Eclipse are IDEs, like Atom.

------
statictype
I haven't used Atom for at least an year and a half now - After trying out
Visual Studio Code I haven't looked back. Has the performance improved? Is it
at the level of VS Code?

~~~
mraison
The one reason I'm still using Atom is because of the remote editing
experience with Nuclide + Watchman server-side. No other editor that I've
tried comes even close (the connection drops, files get out of sync, new files
don't show up, etc, etc)

Given the huge number of people who work on remote servers, I find it
surprising that proper solutions are still so hard to find. A "file system
provider API" for VSCode is in the works so I'm hopeful for the future.

~~~
kristiandupont
I am curious about your situation that causes you to edit files remotely. I've
never had to edit files anywhere but my local file system. Are you developing
or is it more of a devops/sysadmin kind of role?

~~~
giancarlostoro
I have to do it all the time cause I want to develop on a VM that matches the
target platform for my project. Usually involves figuring out how to debug
things. My solution is to install VS Code on remote system and use X
forwarding depending on project. I also use PyCharm Pro so in such case I use
Vagrant and it does its thing but it syncs awfully as OP mentions so debugging
can become extremely painful idk why JetBrains has not fixed said issue
customers have complained (remote SSH / Vagrant support is part of their paid
tier).

~~~
ElCapitanMarkla
This is my scenario at the mo, I've tried syncing the code dirs between the VM
and my local machine but I haven't found a nice solution for that.

My current solution is just SSH/Vim but I think I'd like to go back to a
graphical editor. I like Vim but sometimes it's a hassle on the big projects.

~~~
giancarlostoro
I use Vagrant w/ VirtualBox and setup shared folders, but it's not as nice
when you want to _debug_ or _execute_ code. PyCharm Pro has great support for
Vagrant though it sucks at updating certain things on the server end.

------
mpolichette
I don't understand the desire for all the git integration into the editor. I
mean, it might make sense because Atom is owned by Github, but why otherwise?

I feel like a lot of their resources are being put towards git integration
instead of improving the editor and performance... which are some of the
primary reasons people leave for VSCode.

Maybe I'm the odd man out though, since I like to use CLI git directly.

~~~
Smotko
I felt the same way as you do, I used the git CLI directly and could never use
a git GUI.

But then I figured out that Atom's git integration is actually quite neat and
I started using it mostly to do `git add -i` as it makes staging files or
parts of files really easy.

I still don't trust it with pushing/pulling, switching branches etc. so I
still drop to the command line for those, but the atom git integration is
incredibly useful for seeing your changes and committing a particular part of
them.

~~~
dvlsg
I agree. I use the command line for everything but staging, and I often only
stage parts of files while discarding a few leftover pieces I forgot about. I
use sourcetree, but the concept is the same. GUI git is really nice for
staging parts of changes. And then I usually commit via the GUI too, since I'm
in there anyways.

------
glutamate
Will Atom and Visual Studio Code merge into one project now that Microsoft
bought GitHub? Or at least stop sharing extensions?

I would vote yes! I would love to see better GitHub integration in VS Code.

~~~
helb
The "future CEO of GitHub" said they will continue to develop and support both
VSCode and Atom:
[https://www.reddit.com/r/AMA/comments/8pc8mf/im_nat_friedman...](https://www.reddit.com/r/AMA/comments/8pc8mf/im_nat_friedman_future_ceo_of_github_ama/e0a235q/)

HN discussion here:
[https://news.ycombinator.com/item?id=17258114](https://news.ycombinator.com/item?id=17258114)

~~~
the_duke
I just really hope they continue with this experiment:
[https://github.com/atom/xray](https://github.com/atom/xray).

It's reducing Electrons job to the view / plugin layer and have most
processing done in a Rust backend.

~~~
013a
There's also a similar project hosted by Google, Xi, which seems significantly
more promising than xray.

[1] [https://github.com/google/xi-editor](https://github.com/google/xi-editor)

~~~
ksec
So Xi, is basically like an OpenSourced Version of Sublime Text in Rust?

If that is case, why Google doesn't just acquire Sublime Text and open source
it?

Edit: Turns out Xi was burned out of Fuchsia, the next generation Android. So
I guess Xi is tool for testing concept in Fuchsia. And it doesn't look like Xi
will be amiable for general usage in the next 2 to 3 years time.

~~~
the_duke
No Xi existed before Fuchsia became a thing.

It's a generic editor backend with an official GUI for OS X.

------
jokoon
It's crazy that so fewer editors can fold code blocks in a compact manner, so
that it hides line returns that are inside curly braces (might be a little
trickier with python) including the ones which are just after and before those
braces.

So far only visual studio (not code) can do it properly, and one which name I
forget. I posted issues everywhere about it. I'm still disappointed, or it
might be difficult to implement.

~~~
paulclinger
Scintilla (and scintilla-based editors) do this when `fold.compact` is set.

------
gonmf
I wish I could use Atom but I work with very large files at time and it is
very slow at some tasks (like selecting all selections of text and editing
them all at once), forcing me to use Sublime Text.

Can some kind user tell me if this latest version performs better now?

~~~
cjohansson
User-interface is still very laggy compared to Emacs but it opened large files
much better than I expected, though it disabled syntax coloring for larger
files and scrolling is really slow. I wonder how this compares to VS Code and
Oni which are also built in Electron..

~~~
gonmf
I've tested it myself as well. It is still as laggy as I remember, such a
shame. I really want a simple graphical editor that can color the files that
have been modified in Git.

------
hartator
> ensuring that parsing can never impact the frame rate.

This is exciting. Anyone has feedback anout how it actually impact
performance?

~~~
Klathmon
I've been using 1.29 for a while in the beta with the new tree-sitter
syntaxes, and i've noticed some changes.

It's not groundbreaking, but folding is definately better and more responsive,
and using tons of cursors (which often happens from using a plugin that gives
me sublime-style click-and-drag to place cursors ability) is improved by a
noticeable amount.

The new parsers do regress when it comes to opening minified files though, so
a 300kb file with the whole file "on one line" will drop the editor to 1fps
(interestingly it only happens when something syntax highlighted is on the
screen, so if I'm scrolling through a minified file and hit a large enough
string that's not highlighted, the FPS picks back up to 60!), but opening
500mb+ logfiles isn't really an issue any more (meaning as long as there are
linebreaks at reasonable points, and you don't mind waiting a second for it to
open, it's pretty consistently fast). I'm not sure if that was the tree-sitter
parser or other updates made in the last year, but at some point it stopped
slowing down with "logfile" style large files.

Please keep in mind I have an... absurd... amount of plugins installed. I use
this editor to do heavy javascript/flow development, as well as python and go
and a bit of PHP, with a ton of "nice to have" plugins like automatic test
runners, coverage reporters, "intellisense" style IDE stuff, and more for each
language. It's also running on a pretty beefy 8-core 32GB machine. so
interpret my experience through that lens.

~~~
hartator
Cool, I'll try again today, and try to update this thread.

------
vorpalhex
What packages are folks using these days?

------
welly
Is it still unbearably slow?

------
DC-3
Honest question: can someone explain why everyone loves emoji these days,
especially with regards to 'modern' programming communities such as those
around JS and Rust? Is it just a celebration of the fact that we have Unicode
support everywhere now?

~~~
omeid2
I find the whole trend very childish and unprofessional. Why? Because emojis
don't convey much meaning and borders on child-talk, worst yet, they're very
vague and so makes for very poor and unprofessional form of communication.

~~~
Aeolun
I am baffled by your assertion that they convey little meaning. Do facial
expressions also convey little meaning?

To me the combination of both gives a hell of a lot more to base
interpretation of tone on.

~~~
toomanybeersies
The issue I have with emojis is that they are rendered different on different
fonts/devices, and because of this they can convey a different meaning.

~~~
Klathmon
And text is read wildly differently depending on the readers's culture, mood,
font, and how well they know the language.

Communication is messy as hell, and the fact that emoji's render differently
doesn't add that much confusion in most cases (of course there are the odd
watergun vs revolver emoji problems, but the worst offenders are slowly being
brought into line)

~~~
toomanybeersies
If I send a text message from Android to iPhone, the message is the same.
Obviously there's cultural differences etc. but I can usually work with those
if I know the person I'm sending a message to.

However, emojis can change when sending them from my Android phone to an
iPhone, changing the meaning of the message inadvertently.

