Hacker News Reader

Comment by brettermeier | Hacker News Reader

I mean open source IDE's, real full featured developer environments for writing code. I don't talk about Open Source projects in general, but about competition for VS Code or Eclipse. There is something like Sublime Text, but it's not really open source and free.

Edit: With Vim and stuff I get your point, but I would say it's not really comparable to an UI-based IDE, it is command line stuff. Even if many people prefer that, it may not be as convenient as a GUI-based IDE for some of us.

Or am I missing something here? I really love(d) atom.io, but I need to find something else... (https://github.blog/2022-06-08-sunsetting-atom/)

View on HN

Emacs is not "command line stuff", it has a fully featured GTK based GUI interface, it even runs natively on Wayland today!

I just wanted to point this out because it's extremely common for people to assume that Emacs is a terminal based program since it's often grouped together with and compared to (Neo)Vi(m).

It's not really logical to compare Emacs with the Vi style editors since they are completely different things. It's kind of annoying that it gets grouped in with them, since it probably causes a lot of people to never even give it a fair chance.

Modern Emacs, at least, works better in GUI mode than in terminal mode. It's got a different style and design philosophy than VSCode et al—which results in a steeper learning curve for most people—but it's absolutely comparable in capabilities and general experience.

Pretty sure the same is true for Vim or Neovim, but can't vouch for them because I do not use them myself.

Pretty sure the same is true for Vim or Neovim

Yes; especially Neovim, which not only has several GUI’s but it's designed to be embeddable, including into VS Code or a web browser. Neovim has native support for LSP and Treesitter, which enables it to IDE-like things.

Neovim is extensible using Lua 5.1 and comes with LuaJIT for speed.

It’s not just a command line thing.

No, it is a command line thing. Neovim and vim are just the editor component of the bigger tools that is something like vscode.

To get Neovim kind of things to be anywhere near usable for modern day development work, you need to bolt a file browser, intellisense, command line section, remote editing section, container plugins, plugin installer, settings section etc etc on top of it, and is not really a trivial job for everybody to do this from scratch. Hence the use is by and large restricted to one off server side editing(This itself is getting rarer these days with containers).

In cases where Neovim is plugged into thing like vscode the experience is less than seamless. You have to keep moving between mouse and keyboard modes, formatting plugins like black for Python don't autoformat on save like they do on normal vscode editor. The intellisense doesn't work, etc.. Apart from bare minimal modal editing you really get nothing much.

To make vim/Neovim/emacs nearly as usable you need to reinvent these editing ideas but in the paradigm of modern day development workflow. And it needs be as ubiquitous as vscode. There must be little configuration work and things must work out of the box.

And lets be honest typing speed is not even relevant to software development speed so the editing efficiency gains in vim/emacs, while might save your day in heavy lifting text tasks via macros. They don't add that much gains to your workflow in normal development scenarios.

> To get Neovim kind of things to be anywhere near usable for modern day development work, you need to bolt a file browser, intellisense, command line section, remote editing section, container plugins, plugin installer, settings section etc etc on top of it

Why?

Neovim has multiple package managers. It has GUIs like https://github.com/neovide/neovide, it has support for LSP which can do something? Many people are comfortable with programming in an environment like that

It also has a terminal (even though if you use neovim you probably prefer to open terminals outside the IDE) and support remote editing too

Here are some links

https://github.com/wbthomason/packer.nvim & https://github.com/junegunn/vim-plug

https://neovide.dev/

https://neovim.io/doc/user/nvim_terminal_emulator.html

https://neovim.io/doc/user/remote.html

Yeah its basically a Do it Yourself kit, not sure if you got the message I wrote in my comment. That is a negative, not a positive. Majority of the people don't have the time, or in many cases competence to spend several man months/years building things like these. Even if you do, you still won't be close to the complete vscode experience.

It's a negative for you, but not for me :) I guess that's why different editors exist.

You're not the target audience.

There's not much difference between installing LSPs in VSCode and adding plugins to Vim using Pathogen, vim-plug, or the built-in plugin manager. It's not as if I wrote Pylint myself, I added "dense-analysis/ale" to my config and I was done.

I think you're coming from a place of strong familiarity with IDEs, but less familiarity with Vim. From my point of view, if you asked me to switch to VSCode, I probably wouldn't ever be as productive as I am now. This isn't because I was forced to spend hundreds of hours configuring--I was one of those people with a 5 line .vimrc for years--rather, it's because I have the ability to conform Vim to my way of thinking and working.

Some people do go ham with their configs, and it's super cool that that's possible (something you can't really do with IDEs). But I think most people probably install a few plugins/language servers, set a few variables for modelines or whatever, and they're good.

>>There's not much difference between installing LSPs in VSCode and adding plugins to Vim using Pathogen, vim-plug, or the built-in plugin manager. It's not as if I wrote Pylint myself, I added "dense-analysis/ale" to my config and I was done.

You just explained the difference in this very statement yourself. Installing a plugin in vscode is a one step process. Installing it in vim is going on shopping spree for a car first, then using the car to go on shopping spree using that car. Along the way being knowledgeable enough to occasionally service the car.

>>I think you're coming from a place of strong familiarity with IDEs, but less familiarity with Vim.

Nearly my whole career is basically writing ginormous quantities of Perl/Python/C over terminals, and I happen to be one of the heaviest users of vi(m)/emacs, on Solaris/AIX machines, then FreeBSD and now Linux. I still believe macros are the most magical things you can every touch in any piece of tech.

These days I do nearly every other kind of development, and on several different platforms. And honestly speaking, merely hours of using vscode was enough to convince to use better tools to do my job, nothing wrong with that. Its just vscode does a lot more than being a code palette.

>>This isn't because I was forced to spend hundreds of hours configuring--I was one of those people with a 5 line .vimrc for years--rather, it's because I have the ability to conform Vim to my way of thinking and working.

As a old vi(m) user, my biggest productivity steals come from learning the native design choices, and learning to use them well.

This is the same philosophy I carry over to vscode as well. The thing here is magically enough vscode does a lot of things really well out of the box.

> Installing it in vim is going on shopping spree for a car first, then using the car to go on shopping spree using that car.

Again, I think you're coming from a place of a lot of experience w/ VSCode and less in Vim. I needed PlantUML for something, so I:

- Googled for 'vim plantuml'

- Went to https://github.com/weirongxu/plantuml-previewer.vim

- Added "Plug 'weirongxu/plantuml-previewer.vim'" and "Plug 'akit/plantuml-syntax'" to my init.vim

- Ran ":source ~/.config/nvim/init.vim"

- Ran ":PlugInstall"

At least to me, this is the same as opening up the plugin catalog in VSCode and picking stuff.

---

I do a lot of varied development across different tech too: React, C, Svelte, Python/FastAPI/Django, Go, Lua, various SQLs, protobufs, JSON, CSVs... just all kinds of stuff. I've found Vim to not only be adequate, but excel. Maybe VSCode is great at all of these things, but that's not my point. My point is Vim works for me in the case you're describing, lots of different kinds of development on several different platforms.

> The thing here is magically enough vscode does a lot of things really well out of the box.

I think this is maybe the crux of our disagreement: you're pretty anti-config. I'm not wild about config either, some people's .vimrc files make me shudder, and when I learned about EMACS config bankruptcy I laughed out loud haha. But like, I like that I can set my default tabstop and shiftwidth, or change it per-language. I like that I can set hlsearch and incsearch. And I like that I can drop my config on almost any machine running and I'm in my element. There's a balance to strike, for sure, and maybe it is nice to sort of live out of a suitcase for your work life as it were. But for me, I've enjoyed decorating my work home.

To get Neovim kind of things to be anywhere near usable for modern day development work… blah blah

We don’t roll like that anymore; you can just use one of several distributions that are pre-configured; most of these are 1-line installs:

    bash <(curl -s https://raw.githubusercontent.com/lunarvim/lunarvim/master/utils/installer/install.sh)

It’s basically the best of both worlds—-IDE--like functionality all set and ready to go out of the box but totally customizable. And blazingly fast; launch times are < 1 second in most cases.

* LunarVim: https://www.lunarvim.org

* VaporNvim: https://github.com/VapourNvim/VapourNvim

* NvChad: https://nvchad.com

* AstroNvim: https://astronvim.github.io

Tried to install LunarVim a few months back and it stubbornly refused to install because I had to manually install some dependencies, and then it had issues with the versions of those dependencies. It didn't even have a brew package.

Life is too short to waste working around these issues, when there is already vscode, why should one go about wasting hours to weeks of time working around these tools which don't even give a full experience.

In some cases, like this this tool in current discussion 'Lite' aren't even actively maintained(a.k.a abandonware).

Much ado about nothing

- William Shakespeare

I like Zed currently. It seems to get closest to my IDE needs by natively integrating with LSP while still being ridiculously fast (that <1 startup time).

JetBrains is building Fleet, which is also nice, but by comparison to their existing suite extremely lacking.

Both closed source though :/

Zed talks about those two IDE's I mentioned in their FAQ, so I really would like to try it. But you can't as a normal user for now. But I'm looking forward to try it some day.

What's Zed business model? It's going to be closed source, right? :(

https://lapce.dev/ is looking better every time I check

If a code editor does not support custom binding to sequences of keys (rather than single key presses), then its not really good for programmers.

https://eclipseide.org/

Yes, I mentioned that in my edit. A shame that I forgot it in the first place :P But after VS Code and Eclipse there isn't much else...

Reply on news.ycombinator.com