Get the top HN stories in your inbox every day.
robenkleene
msgodel
Ten years ago I threw out my massive multi-file, multi-package vim config and have been slowly building up a much simpler vimrc about 1-2 lines a year. I completely agree, defaults in old software are almost always there for a reason and you should try to understand that before changing them.
eviks
That would be true if you had universally great designers back then, which wasn't the case, thus the defaults are universally bad, so it's a bad heuristic to stick to them and force a waste in trying to understand them.
For example, why is the default vim cursor hjkl? Well, it's just that the arrows on the physical keyboard of one of the vim designers were drawn there. That's it. There is no deep thought in search of the best cursor position, and understanding the why is just learning a useless piece of trivia.
sakjur
That seems quite harsh. Just because the designers aren’t perfect doesn’t mean the design is universally bad.
To address your example: Why were the arrow keys on those particular keys? Who put them there? hjkl are on the home row, and touch typists end up having the movement keys under their right hand’s resting fingers. That’s suddenly quite convenient.
_Algernon_
The fact that the tools have survived and are still used today is at least somewhat indicative of their quality though. A lot of worse designs have likely been selected away due to nobody even bothering to use them.
P(old thing being good | old thing still being used after N years) is pretty high. Certainly higher than the base rate of P(new design fad being good).
notarobot123
> defaults in old software are almost always there for a reason
Keeping your fingers on the home row is great design for keyboard-first navigation.
All software design is historically contingent so you do have a point but assuming that old design = bad design is just wrong. Some things haven't changed.
ulbu
and then we have C-n C-p of emacs. it should come with a health hazard warning.
qn9n
It makes a lot of sense as they are on the home row... Via this argument you could suggest moving it to `jkl;` in order to minimise movement further.
kannanvijayan
I haven't had to in a while as I've lapsed into IDE usage as of late, but my vimrc is something I committed to memory a long time ago.
set tabstop=4
set shiftwidth=4
set expandtab
set showmatch
set nohlsearch
set background=dark
syntax on
mtlmtlmtlmtl
No accounting for taste, but my similarly terse vim config includes relativenumber and number. Relativenumber is just so damn useful for doing things to larger chunks of code without having to count lines or anything.
I'm also an IDE user though. I tend to maintain a dichotomy between emacs(with evil-mode, of course) as the "kitchen sink" set up, with all the fixings, and vim with a config so short I can type it in as commands if I need to.
Vanilla vim is really perfect for quick edits to config files, scripts on random servers/VMs etc.
Bigger projects, at least for my usage, all happen on the same system , and having a bit more involved of an emacs set up makes sense there.
I suppose one could do a similar dichotomy with vim/neovim, if one had a distaste for emacs.
deathanatos
… why `memory commit` what you can `git commit` and then just `git clone`.
(I keep most of my dotfiles in a repository called "dotfiles".)
I get the emotional value/desire for a minimalistic .vimrc, but I also need the usefulness, and that necessitates, e.g., pulling in some plugins. E.g., lang-servers are just so valuable for immediate feedback in the editor.
Over time, someone of my vimrc has been pruned away just by development that has happened in/on vim itself, which is always lovely to see.
patcon
I would love a generative llm script that looks at my command history (or something comparable), and adds a new zsh config (or other dotfile) every day, explaining itself via a reliable motd-type screen that flashes on-screen during the first session of the day, explaining what was added and allowing me to play with it and decide to keep it or not by the end of the day :)
Basically, slowly "evolving" my environment by forcing me to try new things daily, without my doing massive "learning" runs where I try batches of new things at once
safety1st
Closest thing you'll find, I think, would be some creative use of ShellGPT features...
jmbwell
A wise elder once advised me that if I learned to work quickly and comfortably with an application’s defaults, I would be just as quick and comfortable on any system I would likely encounter. Very zen. Great advice.
deathanatos
Is it? I should just purposefully bind myself?
Seems like using a tool to its fullest potential to get more work done is better advice.
> I would be just as quick and comfortable on any system I would likely encounter.
How often are we encountering other systems…? And even where I am rarely ssh'd into something else … are we doing so much editing of code (live in production…?) that it matters? (I heavily customize my vim, but it isn't like I'm lost on a remote system with stock vim, or nano. ed is another matter.)
But if I need tons and tons of editing, … sshfs+local vim/terminal? But this just such a rare case, it seems like one of those "we should optimize for the common case" — which this is not.
codyb
I also find creating my own little shortcuts to be super satisfying and of course very transferable since they work out of the box.
```some examples " Quick access to commonly edited config files (and a directory for my Shell scripts!) map <leader>v :e ~/.vimrc<cr> map <leader>V :source ~/.vimrc<cr> map <leader>w :e ~/Workspace/myCo/tmuxp-session.yaml<cr> map <leader>W :e ~/.tmux.conf<cr> map <leader>z :e ~/Shell<cr>
" Super simple in editor note setup, amazing map <leader>x :vs<cr>:e ~/Documents/notepad.txt<cr> map <leader>X :vs<cr>:e ~/Documents/notes<cr>
" Quick terminal pane map <leader>t :vs<cr><c-w>l:term<cr><c-w>j:q<cr> " Pull file path into clipboard nmap <leader>b :let @+ = expand("%")<cr> " Pull current line into clipboard nmap <leader>B "*yy ```
Quick disposable terminals, tons of short cuts to get me into the config files that make it all happen (vimrc, zshrc, tmux.conf, a tmuxp session file) and to reload them, and super quick access to a well organized directory of notes are all huge boons during my workday.
baby
Some defaults suck massively, emacs in tmux basically doesn't work due to hijacking C-b. The one that catches me every time is whatsapp that hijacks C-p.
johnmaguire
> (`vim -c cb -` is my favorite feature in Vim; I find it strange that it's so rarely used or talked about).
Care to explain what it does? Trying `ls | vim -` and `ls | vim -c cb -` I don't immediately see a difference.
robenkleene
`cb[uffer]` processes the current buffer as a compile buffer, which will find `grep` format matching lines (i.e., at a minimum starting with `<path>:<line-number>:<column-number>`) and populate the quickfix list with them, and jump to the first match.
E.g., your example doesn't do anything because `ls` doesn't output `grep` format lines. So try piping the output of `grep` (you'll need flags for the line number and column number with `grep`, hence the `--vimgrep` flag above) matching the above format (or you could try `ls | sed 's/$/:0:0/' | vim -c cb -`, which will hack `ls` output to grep, and is occasionally useful).
(Note that the above hints at another useful tip, `grep` parsing is only part of what `cb[uffer]` does, it can also parse compile output, e.g., something like `gcc foo.c | vim -c cb -` will jump to the first compile error in your program and put the rest of the errors in the quickfix list).
WorldMaker
You get similar buffer behavior if you use :make inside Vim and Vim as your build terminal. Despite being named :make it isn't hardcoded to just make as build tool (there's a bunch of out-of-the box settings you can pick with :compiler or you can update individual settings like makeprg).
Similar behavior with :grep inside Vim which you can change your grepprg to rg if you like.
I've got a feeling the `| vim -c cd -` isn't as commonly known because the Vim-initiated versions are somewhat more commonly known. It's handy to know that vim can do it in both "directions" (initiated from the external shell / initiated to the internal shell support).
heavyset_go
Can someone sell vim to me?
I can't help but see it as the tiling window manager of text editors.
Even with plugins it's less featureful than Kate or Jetbrains IDEs. And the last time I really gave it a go, it was slow, which is surprising for a terminal text editor.
If I need to edit text via the terminal, micro has mouse support and keybindings that match what you'd expect in any OS.
I don't like the idea of thinking people who use vim are insane, it obviously has value and people who use it have good reasons for using it, but I can't see it as more than a niche nerd thing a la tiling window managers.
agarsev
I use both (neovim instead of vim, i3 as wm) and you got me thinking. I think the point of both is actually not having to use the mouse. But the mouse is not the problem per se, probably is the spatial/visual interaction paradigm. I don't care where the window exactly goes, I just want it right/on top/minimized. I don't want to search visually for a button that does what I want, I know what I want, I can just "tell" the computer. It's not about keybindings as shortcuts to do something, it's talking to the computer via keyboard using my language center without the intermediary of the gesture/spatial metaphor. Maybe? I just thought of this sorry.
vladxyz
It's this. I make the analogy to playing a game with a controller. At some point you stop thinking what combination of physical button presses and holds you need to have your character go from a running start to a crouch-jump, you just think in terms of goals for you want your character to accomplish. vim motions put you in the same sort of connection with the text you're editing.
skydhash
Vim has it’s advantages:
- Fast and precise navigation (jumping to files and jumping to some point in the file)
- Fast editing command (there’s no need to select first, and when you need to selection is fast due to the above)
- Easy extensibility (either custom commands which you can bind to keys, or hooking some logic to editor’s event)
- Integration with external tooling (using the text as input, collecting the output, intepret the output to find location to jump to)
All of these are first citizen in Vim, whereas in some editors, it can only be done with plugins.
undefined
xk_id
Vim existed before Jetbrains IDEs. It’s also much more general. I use Vim to write literary works and manage my knowledge base. There was also a guy who was using Vim as his IRC client. Vim can be the only program you need for editing text, which turns out is most of what we do on a computer. It’s nice to have a single tool for this, that never resists when you try to adapt it. Vim is actually a great example of the practicality of a good philosophy.
Edit: I doubt there’s any feature in the more specialised editors, which you can’t also get from Vim.
thesuperbigfrog
Vim and related vi-based editors have a built-in 'grammar' for editing text that is concise:
https://stackoverflow.com/questions/1218390/what-is-your-mos...
With a bit of practice, vim/vi-style editing can be developed into muscle memory which makes it incredibly fast to use.
There is a reason why most popular text editors and IDEs have a vim plugins.
maleldil
> And the last time I really gave it a go, it was slow, which is surprising for a terminal text editor.
There was likely something wrong with your configuration. It's really hard to be faster than vanilla vim, but you can get weird performance issues from external plugins sometimes.
heavyset_go
I used some Vim IDE plugins and I assume the bottleneck was there.
The problem is without some IDE-like features, I don't have a need for a text editor. Micro supports LSP servers by default and that gets me pretty far, before jumping to Kate or a real IDE.
bonoboTP
I think the sort of person who likes it values the "test of time" aspect of it and trust that vim will still be there in the next three decades, just as it was there for the last three. It's super easy to install, and is indeed preinstalled on almost every Linux installation. So people can learn its ins and outs and do extremely fine-grained customization to their desire. People who get annoyed by tiny details and don't want to put up with it. The downside is that you need to carry around your config files and if you sit at a colleague's computer you don't get the same standard experience. And the fragmentation.
There's of course also the "hacker street cred" aspect of it, to feel like a real serious developer. Or simply being fed up with churn and saying "I'm too old for this shit". JetBrains IDEs might change next year due to some new design fad. Or they may go bankrupt.
In my opinion, valuing boring old tech is good, but you shouldn't make a crusade of it. I choose to put up with some churn and inevitable tool changes for practicality. Yeah, some things have to be relearned this way, some changes seem pointless, but the overall effort may be less if you just learn to be flexible and say "ok if JetBrains goes bankrupt, I'll just learn the next popular IDE like everyone else and be done with it" instead of prepping in my bunker with my vim config files.
heavyset_go
I definitely get that, I feel the same way about Bash. It's stood the test of time, is everywhere and will be everywhere for the foreseeable future.
Thanks for the perspective.
rhinoceraptor
vim and tmux both have mouse support as well, it's nice to be able to resize vim splits and tmux windows with the mouse.
jez
This is cool, I learned about `:cb` today (populate quickfix from current buffer)
I find that if I’m already piping into a buffer, I just leave it as a buffer. Vim’s gf and gf keybindings let me jump to the filename under the cursor, and it being a buffer makes it easier for me to edit (reorganize, group, further filter, etc).
I do think people undervalue the quickfix buffer though!
lenkite
Isn't `rg --vimgrep restore_tool | vim -q -` better though ?
-q [errorfile] QuickFix mode. The file with the name [errorfile] is read
and the first error is displayed. See |quickfix|.
If [errorfile] is not given, the 'errorfile' option is used
for the file name. See 'errorfile' for the default value.
rg --vimgrep restore_tool | vim -q - -c 'copen'magarnicle
Is this the same/similar to 'vim -q <(ripgrep --vimgrep restore_tool)'?
robenkleene
Similar enough, minor semantic differences (e.g., I don't think `-q` creates a buffer containing the matches)
anticodon
I use fish and neovim, thanks to the thread, created the following alias:
nvim -q (rg --vimgrep needle --color=never | psub) -c copenlynx97
"rg --vimgrep restore_tool | vim -c cb -" looks like I want to use it. However, it doesn't work for me. vim says it had errors while processing, and says I haven't saved the buffer. I get the rg result displayed, but how do I navigate to a place?
covoeus
Use `cb!` instead of `cb`:
rg --vimgrep restore_tool | vim -c cb! -
rg --vimgrep restore_tool | vim -c cb! -c copen -
_sharp
This is amazing! Thank you!!
The quickfix window is so small, so I added the "-c only" option to make it the only window that first pops up. Then made it a function so it's easier to call:
``` vgrep() { rg --vimgrep "$1" | vim -c cb! -c copen -c only - } ```
$> vgrep "restore_tool"
sam_lowry_
I tried searching how to open the quickfix window in a vertical split, but found nothing. Any ideas?
palata
I had never heard of the quickfix list! Thanks a lot!
benreesman
This is a nice setup. It's got tmux and fzf and rg and zoxide and clean-looking nvim. I'd recommend atuin, starship, bat, glow, duf, dogdns, viddy, gum/sesh, dust, btop et all if you don't have them, there's a long tail. The Awesome Terminal XYZ lists on Github have them all.
atuin is make-or-break, its a bigger deal than zoxide and being a coder without zoxide is like being an athlete with shoes for a different sport.
asciinema is a better way to do terminal videos.
Its weird that this is weird now: having your tools wired in used to be called "being a programmer". VSCode and Zed and Cursor and shit are useful additions to the toolbox, you gotta know that stuff by heart now too and you have to know which LLM to use for what, but these things are the new minimum, they aren't a replacement for anything. Even with Claude Code running hot at 4am when the PID controller is wide open, sometimes its going to trash your tree (and if it doesnt youve got it on too short a leash to be faster than gptel) and without magit? gl.
If you think you're faster than OP with stock Cursor? Get them to make a video of how to use an LLM with chops.
kragen
Being a programmer is not about configuring your development environment. It never has been. I know a relatively accomplished programmer whose preferred development environment is Unix with the ex editor, and plenty of beginners whose whizbang IDEs completely fail to compensate for their lack of understanding.
That's not to say that tooling doesn't matter at all. Just that, historically, it's been a relatively minor factor. Maybe LLMs have changed that, or are about to.
An athlete with shoes for a different sport might run 5% slower. In a winner-takes-all competitive environment, that's fatal; a sprinter that ran 5% slower than the gold medalist is just another loser. Most programmers, however, win by collaboration, and on a relatively smooth fitness landscape, not a winner-takes-all spike. Even in winner-takes-all regions like startups, failure always results from bigger errors. I think nobody has ever said, "My startup would have succeeded if we'd used Dvorak keyboards instead of QWERTY", or vim instead of VSCode, or vice versa. It's always things like feuding cofounders, loss of motivation, never finding product-market fit, etc.
iLemming
> Being a programmer is not about configuring your development environment.
You sure? Programming is an act of creation. Any [good] creative worker - artists, sculptors, novelists, potters, bakers, et al. would agree that being an artist means finding joy in refining your technique, investing in your tools, searching for new recipes, and experimenting. Being a programmer is not about achieving better productivity percentages. As far as I know, most of the best-known programmers have never participated in competitive programming challenges. Tooling may not matter to building a product, yet the product is built by programmers, and tooling is very much everything to them. Good programmers do invest in their tooling, not because it's a universal rule they have to follow or because it gives them a competitive edge. They do it simply because they enjoy the process.
Though it's challenging to determine whether someone who loves exploring and refining their tools will excel in a specific team, one truth remains: those who don't engage with their tools likely aren't strong programmers, as they most likely fundamentally lack passion for programming itself.
cole-k
That's kind of a weird point to make. I don't see why it would be a universal truth that a good programmer is someone who invests in their tools.
I could just as easily say that good programmers are the ones who don't have sophisticated tooling setups because it means that they spend more time programming.
I'm inclined to agree with other comments that the baseline for productivity is probably lower than we think. It's fine to enjoy the process of making a perfect setup, but I don't see it as a prerequisite or strong indicator for being a strong programmer.
kragen
> You sure? Programming is an act of creation. Any [good] creative worker - artists, sculptors, novelists, potters, bakers, et al. would agree...
Yes, I'm sure. Being a painter is not about decorating your studio and choosing paints and paintbrushes. Being a sculptor is not about using the best chisels and rasps. Being a novelist is not about configuring your word processor. Being a potter is not about the selection of clay bodies and kiln accessories in your workshop. Being a baker is not about where you place your oven or what brand of mixing bowls you use.
It's surely true that any accomplished potter will have enough opinions about clay bodies, glazes, wheels, scrapers, and other tools to talk about all afternoon. But that's not what being a potter is about. 99% of potters have never made anything as beautiful or as useful as many of the pots that María Poveka Montoya Martínez coil-built from clay she dug up near her house and pit-fired with dried cow manure. She engaged with her tools, and I bet she would have yelled at you if you left one of them in the wrong place, but she wasn't defined by them.
That's what being a potter is about.
It's the same for programmers.
pjmlp
Not in enterprise consulting, there is very little room for creation on the software sausage factory, it is all about social skills, and outputing something that mostly works within the project budget.
The craftmanship is better left for small businesses, or FAANGS with engineers playgrounds.
williamdclt
Meh. You can spend hundreds of hours honing your programming environment to get a slight edge on others, or you can learn a few basic (or not so basic) soft skills and blow most other engineers out of the water because they’re all obsessed with tech and don’t realise it’s not their bottleneck
macspoofing
>Being a programmer is not about configuring your development environment.
I know what OP is referring to. Back in the day, a programmer was expected to have built their own toolbox of utility scripts, programs and configurations that would travel with them as they moved from project to project or company to company. This is akin a professional (craftsman, photographer, chef, electrician, etc.) bringing their own tools to a jobsite.
kragen
Sure, I have ~/bin and a .emacs.d that I've been working on since last millennium, and various other tools I've written that I use regularly. It's certainly a handicap to work in an environment that's unfamiliar, especially for the first day or two. And sometimes spending five minutes automating something can save you five minutes a day. Making grep output clickable like in Emacs, as demonstrated here, is a good example of that.
But, on the other hand, time spent on sharpening your tools is time not spent using them, or learning how to use them, and the sharpest tools won't cut in the hands of the dullest apprentice. And sometimes spending five hours automating something will save you five seconds a week. All the work I spent customizing window manager settings in the 90s, or improving my Perl development experience early this millennium, produced stuff I don't use now—except for the skills.
benreesman
I find this line of argument really weird. Obviously mastering his tools is only one of many things required of a master craftsman, but the relentless pursuit of excellence in all dimensions of ones craft is the minimum possible criteria for ever attaining it, almost tautologically.
It's like when people complain that leetcode is nothing like the job: yeah, it's a pretty bad test, but you're making a bad argument about that because CS knowledge is extremely relevant to the job, unless the job is assembly-line library composition.
I've consulted for companies that had all their dev boxes on coder or something, and you get really good at vscode really fast or you don't have much luck. It's more than 5%, but even stipulating that it's 5%, whoa, 5 percent?! By installing a bunch of stuff off a list on GitHub and dropping some aliases in your bashrc or zshrc? in a few weeks you're five percent more effective? Anyone in any field from banking to bioinformatics would think you were joking or a scam artist if you offered them 5% more efficient outcomes at that price.
Regarding OG editors like ed and ex and sam and stuff? I can absolutely believe that someone with a lifetime mastery of one of those tools could smoke a VSCode user, it's not at all obvious that VSCode is an upgrade to vim/etc. along any dimension other than low barrier to entry. ditto emacs which is about 1000x more powerful than vscode and the difference in library/extension ecosystem is not measured by size: the emacs one is identical to the vscode one with bottom 90% by quality sliced off the vscode one.
And this stuff compounds, you get a bit better at the tools and you can read more code faster, read the right code faster, start moving the derivative of the derivative.
It's also extremely non-obvious that collaboration at the kinds of scales and complexities that make exceptional skills or experience in it a top 3-5 core competency for people doing most software. Study after study going back to Fred Brooks and the Mythical Man Month have demonstrated that relatively small teams of people who get along very well coordinated by a relatively small number of highly technical managers who take the offload on the high-complexity cross-org collaboration is the golden ticket. It's the same reason computers have dedicated routing tables in the NIC and that those things talk to even bigger and more specialized machines that do all routing all day: you don't want to scale O(n^M) with the communication overhead.
A hacker needs to work really well with their immediate team, and have a good dialog with a manager who is both technical (to understand the work) and who devotes a lot of energy to complex collaboration.
imiric
> I can absolutely believe that someone with a lifetime mastery of one of those tools could smoke a VSCode user
> And this stuff compounds, you get a bit better at the tools and you can read more code faster, read the right code faster, start moving the derivative of the derivative.
I think you're overestimating how much tool choice impacts developer productivity.
Yes, using good tools is important. Being comfortable with and knowing your way around your toolset will make your life easier. But it won't make you a better programmer. It won't "smoke" anyone else. It's not a competition.
The time we spend reading and writing code is relatively minor compared to the time we spend thinking, designing, communicating, and collaborating with others. Reading and writing code is not the productivity bottleneck. It's understanding what you're reading, making a mental model of the system, and thinking about how to translate your thoughts into working code. The mechanical aspects of it are relatively insignificant. Especially nowadays when we have LLMs to automate those mechanical parts, for better or worse.
smlavine
Being a programmer is absolutely about knowing how to configure your development environment, though.
helloplanets
All completely true. But I also wouldn't voluntarily run a marathon in tennis shoes.
deafpolygon
Refreshing to see logic among the sea of your shell "bros".
groby_b
I think you're overindexing on tools.
A good dev can produce excellent results rapidly in an entirely "naked" environment. Sure, good tools might help, but you're looking at improvements in the margins - and a lot of this is about your personal joy, not productivity.
If the rate at which you generate value is noticeably gated by which IDE you use... well, you've got a long and exciting journey ahead of you. It's going to be fun, and I don't mean that facetiously.
"knowing your tools" was never called "being a programmer". Best devs I've ever worked with all did absolutely amazing work with more/grep/vi and a lot of thinking. And the thinking is where the value was created. That's still true, even if you throw an LLM into the mix.
benreesman
I completely agree that being comfortable with basic tools is critical to a versatile software professional because you're routinely in situations where you don't have your kit with you, for every tool on that list there is a GNU userland equivalent that's had basically the same core behavior since the 90s and I switched from DOS and Windows to Linux and GNU, and I am routinely glad that I know how to write useful `find` and `awk` and all that because I'm trying to get some box brought up.
I'm not knocking the classic tooling, it was designed by geniuses who obsessed about tools and tools that build tools (everyone from Ken Thompson to John Carmack are on the record about the importance of tooling).
It's the stock VSCode and Cursor people with an extension or two that are accepting a totally voluntary handicap. Someone in the thread called me a "shell bro", and I mean, that's just asking to get rocked if it's ever on the line against someone serious.
zahlman
> It's got tmux and fzf and rg and zoxide and clean-looking nvim. I'd recommend atuin, starship, bat, glow, duf, dogdns, viddy, gum/sesh, dust, btop
While I get your point, please consider how absurd this sounds to someone who doesn't recognize most of the names.
yard2010
Few hours later, 2 of these tools are in the front page of hackernews. So it's not that absurd! Sometimes you can just reference stuff here in the comments in order to summon them.
I love this place.
zahlman
> Sometimes you can just reference stuff here in the comments in order to summon them.
I know. It was more a commentary on how whimsical and uninformative all the names are.
tmountain
Nice list of commands. I would add fd (author: sharkdp) to the list. It’s a find replacement, and it has great ergonomics. Also, atuin is probably the single biggest upgrade to my cli. It helps me dig up esoteric incantations that I ran six months ago with ease.
benreesman
+1 fd, use it all the time.
thom
Every vim/tmux user has created an ad hoc, informally-specified, bug-ridden, admittedly probably quite fast implementation of half of Emacs.
grep_name
As someone who uses both vim/tmux and emacs for certain things (and spent years configuring and working only in emacs), my emacs setup is WAY more ad hoc, informally specified, and bug ridden than my vim+tmux setup ;)
iLemming
The key point you're missing from the parent comment is "half of".
Maybe you have no idea how much Elisp code is out there in the wild. There is a LOT of things written in Emacs Lisp. Elisp is probably the most widely used Lisp, with the global total codebase amount exceeding both Clojure and Common Lisp combined.
There are things built into Emacs that some specialized apps don't even have. Did you know that Emacs has built-in lunar and solar calendars, for example?
Just by comparing the sheer amount of code, of course vim+tmux may feel less complicated - they give you fewer opportunities to encounter complexity because they offer significantly less functionality out of the box.
grep_name
I'm aware! I used emacs exclusively in professional development roles for years. I still use it for a handful of things that nothing else can touch emacs' workflows for.
That said, there is something nice about composing simple programs and keeping things small. With vim + tmux, I have terminal multiplexing and text editing done and haven't touched that configuration in at least 5 years for vim, over 12 for tmux. I know they offer 'less functionality' out of the box, but after years of tweaking and tons of installed packages I was never able to get that same functionality in Emacs, try as I might.
The main pain points were: - Not having tmux's <c-b z> functionality. You can kinda-sorta-almost jerryrig it with some custom bindings and winner-undo, but you'll still have weird edge cases to think about because you're technically doing a weird undo-tree thing, and all the context (projects, windows, buffers, etc) that emacs maintains will have something to say about that. - ACTUAL vim emulation. Evil mode is really not good enough, and I never had a package that was so hard to integrate without bugs, and when it breaks you have to usually peel back a massive layer cake of competing configurations to try to make it work. Even then, evil-magit has tons of issues, the dot operator doesn't work correctly, and none of the ctrl-i/ctrl-o plugins work across enough contexts to make it make sense like it does in vim. That's a killer feature for me - Embedded terminals that feel anything like tmux in wezterm. In the emacs terminals, there was always so much shit going on navigating in them (and again the layer of evil there) that it felt like walking on egshells using them, they tended to have performance issues and usually couldn't run TUI programs properly. I ended up having a separate drop-down terminal I used in tandem with emacs - Process management. It was always a huge headache for me keeping track of the processes Emacs was spinning up / down through its various plugins and debugging them.
I'd say most tmux+vim setups have something more like 0.00001% of emacs implemented, but sometimes that's a good thing. And again, I love and use both setups for various things.
skydhash
The only thing missing from emacs is some (opengl) 2d surface api like the browser’s canvas, to rival the rest of the OS.
bloppe
I even wrote a little terminal emulator turn my 2-key tmux prefix into the single-key ctrl modified for every command, including the ones that are normally impossible on other terminal emulators
ivanjermakov
I felt that. In my current workflow I run :Term inside of nvim.
b0a04gl
vim+tmux setups usually lean on system primitives = pipes, files, signals, scrollback so the tooling tends to stay transparent across environments. that gives them an edge in portability and debugging, especially over ssh or in constrained shells. it's just lets your workflows shaped around different guarantees so natively, it naturally makes building your own vim config an obvious choice
iLemming
> especially over ssh
Emacs has TRAMP mode - stands for “Transparent Remote (file) Access, Multiple Protocol", it lets you:
- Edit files as if they were local: /ssh:user@host:/path/to/file
- Chain connections: /ssh:jumphost|ssh:target:/file for bastion hosts
- Access Docker containers: /docker:container:/etc/config
- Edit Kubernetes pods: /kubectl:pod:/app/settings
- Sudo seamlessly: /sudo::/etc/hosts or /ssh:host|sudo::/etc/config
- And even combine them: /ssh:server|docker:container|sudo::/etc/nginx/nginx.conf
What you get? Transparent integration - Dired, Magit, etc, they just work. There's no context switching - you stay in your configured Emacs environment. Your keybindings, packages, customizations remain the same. It's multiprotocol: Supports SSH, FTP, SMB, ADB (Android), and more.
onetom
yeah, magit via TRAMP kinda works, just slow af: https://news.ycombinator.com/item?id=44356346
not really TRAMP's fault, of course...
it also doesn't quite work with macOS remotes usually.
again, not purely TRAMP's fault, but a default config and habits issue with ~/.zshrc vs ~/.zprofile and maybe /etc/sshd/config settings, i think. i hasn't fully figured it out yet.
using this kind of "full-screen terminal screen sharing" approach has a more predictable experience, because of the amount of data transferred is usually 1 screen worth of characters (and colors) max, on most keystrokes.
that's both a pro and a con.
it imposes a fixed, network connection dependent input lag and the output is also often redrawn by retransmitting the same data over and over again...
onetom
i would have explicitly mentioned shell & eshell too.
ansi-term however doesn't work thru TRAMP, out of the box, though there are workarounds, like https://github.com/cuspymd/tramp-term.el (hasn't tried it yet)
huimang
Hi Jyn.
"i don't use Nix partly because all my friends who use Nix have even weirder bugs than they already had and partly because i don't like the philosophy of not being able to install things at runtime."
The first part is mostly true. Nix installs things in a readonly store (/nix/store) so regular dynamically linked binaries don't work. Packaging takes a different approach and when things break, it can be difficult to work around. That said, I've run NixOS for over a year now and I find the benefits are far preferable to these downsides. It's not often I run into bugs, let alone show-stopping ones. What is annoying is how many tools are distributed without the source, so I have to run patchelf on them or use something like nix-ld.
As for the latter part, I think that using Nix will change that mentality. (Note that you can do `nix-env -iA $pkg` but it's not recommended). See, I don't even install things like rust at a global level anymore. I can always do `nix-shell -p $pkg` for an ephemeral shell if I need that, or I encode that dependency directly in the project's flake.nix. If I end up using that program a lot I will make the effort to add it to my NixOS config.
jynelson
"at runtime" is not the same as "globally". i would love to install things locally at runtime, but the nix evaluator can't manage things that aren't packaged through a nix derivation, and i don't want to have to figure out how to package a random tool on the internet just to be able to run it at all.
huimang
Ah I misunderstood. Yes that's a bit more complex. Your options boil down to a) using pkgs.autoPatchelfHook [0], b) learning some nix and writing a derivation yourself, c) using nix-ld [1]. There's also pkgs.steam-run which provides a typical environment expected for games.
A great deal of things are already packaged, but for the most part I find it pretty fast to package something. Once you write a derivation [2] or two, it's not that bad. I never packaged for other distros because they all seemed quite tedious, but the nixpkgs reference [3] lists most things and I can look at the source of similar packages in nixpkgs. It is a time commitment though to learn so it's understandable that it's not really appealing.
[0]: https://github.com/svanderburg/nix-patchtools
[1]: https://blog.thalheim.io/2022/12/31/nix-ld-a-clean-solution-...
aequitas
I use Nix exactly because it doesn't allow installing things at runtime. This keeps me from hitting surprises where the runtime environment changes from under me. Containers can partially solve this problem as well but have their own usability issues.
Nowadays I start every project with `nix flake init --template templates#utils-generic`. And put everything in that related to the project. I even had some projects where I had to put 'ssh' as a pinned package as it was used in some scripting and the default macOS and Linux versions accepted different flags.
I also do love that I can do something like `nix run nixpkgs#nmap` on any machine I'm on to instantly run a program with worrying where to get it from. I also use this feature in some of our projects so you can click a link in the admin web interface which is a 'command url' for iTerm2[0] like: `nix run gitlab.com/example/example/v1.0 -- test http://example.com` which will prompt to run that specific version of the command in your terminal, without have to checkout the source repo. In this case it is to rerun specific task locally for debugging purposes.
knlb
My similar trick is to rely on the tmux scrollback and pipe tokenized output into fzf so I can easily autocomplete in zsh against anything on the visible tmux screen
https://www.threads.com/@kunalb_/post/C6ZQIOVpwMd https://gist.github.com/kunalb/abfe5757e89ffba1cf3959c9543d9...
which has been really useful.
ttsiodras
I have been using xterm's default dabbrev-expand to do the same via "Alt-/" ( https://github.com/ttsiodras/dotfiles/blob/master/.Xresource... ) - which works regardless of what shell you're in.
But I was curious for your approach... so I asked Claude to convert it to bash: https://claude.ai/public/artifacts/01a49347-1617-4afe-8476-0...
Works like a charm - pinned it to Ctrl-k, which was free in my setup. I guess I don't have to depend on XTerm for this any more :-)
Thanks!
tra3
Fantastic. Thanks for sharing!
dustypotato
love it!
gertlex
I really appreciate this method of sharing workflows. Well catered to the audience. Actually was slightly hoping there'd be sound to the vid, too, but reading the list of actions after-the-fact was reasonable. I learned a few things I could do and/or approach differently in my own flows.
You mentioned the arcane keyboard shortcuts of tmux. I'm curious if you or others here have tried/use byobu (which I think of as a wrapper around tmux, basing most commands on the F# row). I was shown it a decade ago and have used it since (after a couple prior years of primitive tmux use).
jynelson
glad you've enjoyed it :) i was trying to find something that was clear while still being easy to skim.
> You mentioned the arcane keyboard shortcuts of tmux.
oh, i've remapped almost all the shortcuts in tmux. `ctrl-k` is not the default prefix and `h` is not the default key for "select pane left".
i haven't tried byobu but from skimming the readme i expect it not to have a ton other than nicer default key bindings, and i'd rather not add more layers to my terminal.
gertlex
Gotcha! My main reason for advocating for byobu is it's more beginner/defaults-friendly. I've never customized it, nor fully learned its hotkeys.
In my case, we have dev robots with byobu installed, and it's much easier to train non-SW engineers (i.e. HW folks, technicians, QA) on its use (primarily for remote session persistence).
(This is also why I don't do much/heavy customization these days: for uniformity between local and robot machines...)
pjmlp
As someone that was happy that I could finally afford owning computers with a graphics display on them, this going back to the terminal doesn't stop surprising me.
We still do horses, but hardly anyone is favouring them for travelling around the continent delivering mail.
Kudos to the people that would rather experience that, I guess.
mcdow
Zoomer terminal maximalist here.
My thing is that most UIs use such poor use of the screen real estate. I get it, pretty is the priority. But when I want to do work, the padding on everything gets to be excessive. Additionally, it’s really nice to be able to host my dotfiles in GitHub and I can be in a 100% familiar environment within a couple minutes. I have a variety of machines I work on. Same thing goes for mouse usage. I’m much faster operating the keyboard, whereas I switch between mice and trackpads and sensitivities when I switch devices. Keyboards are mostly the same. Maybe it’s a skill issue on my part but oh well ;)
orbital-decay
My issue with the terminal is the exact opposite, everything is monospaced, hard to read, and space-inefficient due to that. Keyboard use is not a terminal-only thing either, it's a problem with some modern UIs that are hostile to power users. I feel it's at least partly because power users that create their own tools removed themselves from serious GUI development and are too busy with fancy TUI doodads and dark themes instead.
qn9n
I feel like the point of monospace is to be easier to read in text dense environments. I find it much easier to read a monospaced font in the terminal and it makes editing commands much nicer to work with.
globular-toast
The point isn't really the lack of graphics, it's more about the use of a keyboard and text as a universal data format.
Graphical programs look nice but are a nightmare for interoperability.
Having said that, as an Emacs user I'm surprised that anyone goes to this much effort to not use Emacs. This is what it's made for and it's all built in the most hacker-friendly way imaginable.
spauldo
It's difficult to express how amazing Emacs is to someone that hasn't used it long enough to really learn it. I used vi for 20 years before switching, and I'll never go back, but the me then just didn't realize what Emacs could do for me.
globular-toast
Yeah, I've given up trying to be evangelical about Emacs. It makes me think of the red pill in the Matrix: noone can be told what Emacs is, you have to see it for yourself. People who want to take the pill will find someone like me to help them, but it has to start with them, not me.
Back in '05 I realised how crazy it was that everyone was using these shitty editors built in to bloated IDEs, all slightly different from each other. It's all just text! This caused me to discover vim and Emacs. This was about 10 years before editors like Atom and then VS Code caught on.
I tried vim for a while, did the tutorials and tried to believe that if I practised the keys I'd become a wizard. But it never paid off. But I'm glad I learnt to enter insertion mode and exit vi/m at least.
Emacs was not presented as well back then. It had (has?) a terrible looking GUI by default. But once I'd switched that off the keyboard interface and major/minor modes made so much sense. No surprise that VS Code uses the same model.
But then when I got into Elisp I can say I truly fell in love. I liked GNU/Linux before, but Emacs is what Free Software was always meant to be. Not just technically hackable but practically so. How many people edit their VS Code plugins to do exactly what they want? With Emacs you can hack everything right there in Emacs while it's running and then just go right back to where you were.
pjmlp
Now extrapolate the experience to a complete operating system, instead of only the editor.
This is what systems like those from Xerox PARC, TI, Genera, ETHZ, Inferno had to offer, and we aren't still quite there in mainstream systems.
pjmlp
Easily solved with scripting languages and REPL environments.
No need to experience like MS-DOS, CP/M, VMS and UNIX without X, is all that we can get hold of.
akimbostrawman
The horse and car comparison really doesn't work since if anything terminals are higher performance and efficiency than guis. They just have a learning curve and no eye candy.
pjmlp
On case per case basis, depending on what tools one makes use of.
akimbostrawman
Sure there are bad clis and good guis but that's the minority from my experience
oneeyedpigeon
> We still do horses, but hardly anyone is favouring them for travelling around the continent delivering mail.
Most alternatives are much faster, easier to use, and more reliable than the horse. Just like the terminal, in fact: your metaphor was prefect, you just had it the wrong way round :)
hbn
You can't possibly argue that a terminal is easier to use than a GUI.
It's literally what brought computing into the mainstream, so you can click options that are presented to you rather than memorize a bunch of incantations.
yoz-y
I started coding using Borland Pascal on DOS. I went through many tools and in the end split the terminal / UI work depending on whether the language is actually bound to an IDE or a build system.
E.g.: not using Xcode for iOS dev doesn’t make much sense to me. At work we have a fully set-up IDE that works with our build system. I like QtCreator for C++.
But for web dev, scripting and blog writing, I find programs like VSCode extremely slow even with just minimal plugins. After a couple of years I got fed up and went back to vim in terminal.
anticodon
> As someone that was happy that I could finally afford owning computers with a graphics display on them, this going back to the terminal doesn't stop surprising me.
GUI is not a superset or complete replacement of TUI. For many reasons, one of the reasons is that GUI is much harder and finicky to automate.
orbital-decay
What makes TUI easier to automate?
anticodon
Every command can be manipulated as text and repeated as many times as you wish. Every command is also stored in the history, can be saved to any notepad for future, shared with the community.
Every GUI automation is highly non-standard, ad hoc, finicky (usually, depends on exact pixel positions), possibly Turing complete, but even if it is, it's harder to use compared to writing a script.
hollerith
Same here. I'm also amused that the people that do like the experience haven't by this time replaced the protocol (termcap entries, escape sequences, etc) now that memory sizes and network speeds are many orders of magnitude higher than they were when the protocol they are using was designed.
graemep
I think horses are the wrong comparison.
I think its more like walking. For some things walking is preferable to driving there. its even less effort for things that are nearby, it uses fewer resources, I can do it after having drink, I can go through places that are not accessible by car (foot paths)....
pxc
If you don't want to write a giant regex like this yourself, there are some ready-made tmux plugins that add things like this to copy-mode.
https://github.com/tmux-plugins/tmux-fpp
https://github.com/tmux-plugins/tmux-copycat
https://github.com/Morantron/tmux-fingers
https://github.com/tmux-plugins/tmux-urlview
Any configuration or plugin that leans on the built-ins is probably going to be faster, so consider that w/r/t tmux-copycat.
I also really like tmux-resurrect, which saves and restores sessions for you; tmux-continuum, which runs those automatically; and the tmux-zen plugin for Oh-My-Fish:
https://github.com/tmux-plugins/tmux-resurrect
https://github.com/tmux-plugins/tmux-continuum
https://github.com/sagebind/tmux-zen/tree/master
It's pretty easy to get a very nice tmux setup going!
laktak
buf
TOME can be natively performing with tmux panes.
Steps:
1. have two panes open
2. In pane 0, have your cursor or a line or multiple lines of code
3. :VtrSendLinesToRunner
4. In pane 1, the lines are performed
jynelson
yeah, i got the original regex from tmux-copycat. but a) that regex doesn't handle `:` and b) copycat builds its own "viewer" abstraction on top of saving and restoring the pane state, which means that you can only have one action per search. my thing allows you to use normal tmux configuration syntax to bind actions to the files that are highlighted, because it reuses tmux's built-in search. note how all these plugins are either only supporting copy/paste or building their own "modes" on top, because tmux gives you very little control over highlights unless you use the built-in search.
pxc
That's great info! Thanks for filling me in.
I used tmux for everything many years ago, but when I started the current job, I decided to try to do everything natively with Kitty instead. (IIRC one of my main reasons was that Kitty supports macOS' "secure input" features.)
But tbh I never got around to making my Kitty setup as nice as my old tmux one. I think I may switch back soon. It sounds like I may want to set things up differently in light of these new features!
jynelson
note that these are not features built in to tmux, they’re things i built on top because tmux allows doing meta-programming on the terminal scrollback.
i expect that kitty allows doing this kind of thing too, kitty and wezterm both seem very programmable. the main thing they’re both missing compared to tmux is session persistence, but if you don’t need that, tmux doesn’t gain you a lot.
jonjacky
The article title is actually "How I use my terminal"
progbits
This is a HN "feature" removing How if it's the first word in the title. It serves no purpose other than generating confusion, with mods saying this somehow stops clickbait. How, you wonder? Nobody knows.
Stratoscope
Reminder to anyone submitting an article: you have two hours to edit the title to fix these alterations.
rbanffy
I believe these changes are intended to defang some clickbaity titles, but you are right that it maims some perfectly good ones.
littlerbooks
Weird. I see a post titled "How to store Go pointers from assembly" literally three posts below this one.
happytoexplain
I believe the submitter can manually reject the auto-modified title, but they have to notice that it was modified.
(I could be wrong about that)
undefined
adastra22
You wonder?
Hard_Space
Thought that this was going to be a 'There Will Be Blood' spoof.
(In case not obvious, current title is 'I use my terminal')
undefined
osmsucks
I thought this was going to be a blog post about somebody using a terminal emulator they wrote.
philwelch
And I thought this was going to be a blog post about someone hooking up an old fashioned hardware terminal to their PC.
fitsumbelay
noticed this too after skimming the post, feels like the full title = "I use my terminal (and so should you )"
Plus one for pro-terminal posts. As a chromebooker I've found that all I need is terminal and browser. Switching to my Mac OS seems kinda maximalist and I rarely use much outside of the terminal and, you know, more browsers
babelfish
HN will automatically trim some common prefixes and suffixes from title submissions
happytoexplain
The entire blog post being in lowercase distracted me more than I thought it would.
gouggoug
It's also interesting to see that the author themselves are clearly fighting against their own instinct to use uppercase: the first 2 items in the "here's what happens in that video:" list use uppercase.
jynelson
that's voice-to-text on iOS, i haven't found a way to turn off the auto-caps yet.
latexr
But why are you doing it in the first place? This is a genuine question, what do you gain by actively fighting against proper writing rules which aid in readability and comprehension? What’s the rationale for making it harder for users to follow your post?
I know I’m far from alone in having skipped your post entirely upon opening. Nothing personal, but I have yet to find a single post by anyone written in this style where the content was worth the effort of parsing non-existing capitalisation.
You go through the trouble of adding aids like syntax highlighting, lists, coloured titles, and even differentiated notes and timestamps. Presumably those are there to help the reader. But then you throw away a lot of readability by making everything lowercase.
RestartKernel
It's a stylistic choice you sometimes see people commit to. Porter Robinson (a DJ) does the same thing, and it's always struck me as a bit indulgent.
imiric
Yeah, it seems immature to me.
I used to write like that when I was a teenager. I guess it's a subtle way of rebelling against "the system". But seeing adults do that, especially in a professional setting, is cringey.
dr_kiszonka
I am with you when it comes to texts for humans.
However, for speed, I have recently abandoned capitalization and punctuation when interacting with LLMs, unless they are critical for clarity. I wonder if this is why many folks in the AI crowd write everything in lowercase.
amonith
I was under the impression that LLMs do tokenize upper and lower case differently so prompting all in lowercase would yield different results. Is this incorrect?
incognito124
Huh interesting, I didn't even notice that
furyofantares
Kids these days. That's how many of us who grew up online in the 90s to early aughts have been doing things for 30+ years.
I think many of us abandoned it when we went professional. Or abandoned it in those contexts but still do it in others. I don't do it on HN, clearly - but I do it almost everywhere else. It's much more natural to me to skip capitals.
I believe there was also a period in the transition to ubiquitous smartphones where it wasn't an option to turn off auto-caps, or maybe there just wasn't the fine-grained control of which auto-correct you use on mobile devices that there is now. I suspect that killed some all-lowercase habits. I think that's why I ended up with a "normal" style on HN where I use caps and normal punctuation (I don't usually use periods for sentences that terminate a paragraph outside of HN.)
happytoexplain
I'm 40, but the only place I have ever abandoned proper casing is in the specific case of single-sentence text/chatroom messages (and later, 4chan posts), where I also omit the period. And even then, I only abandon sentence-casing - e.g. "I", proper nouns, etc are still capitalized. I never adopted that style in other places though, like forums. And I'm definitely not used to seeing entire chunks of prose in this more extreme version of that format (no uppercases at all, rather than just no sentence-casing).
furyofantares
Well I certainly didn't say all of us! Most people our age didn't live their whole life on forums/IRC/etc and even those who did, didn't necessarily pick that up. But also many of us did! I don't recall any forums back then where everyone did it; but I don't recall any where nobody did either.
globular-toast
I never wrote full sentences or capitalised in my msn messenger convos. I'm not sure if I always did, but certainly at some point I started capitalising my IRC messages. Still don't always write in full sentences, though.
For me it wasn't about being professional, it was just about learning to type. As my typing speed improved it just became second nature to capitalise where appropriate. In other words, I capitalise everywhere out of laziness.
o11c
All writing is about managing the "surprise" budget. Strictly following the rules of grammar (subject to the specific dialect and field) minimizes surprise, so the author can spend more budget on (and the reader still has the focus for) the interesting part. Deliberately using a non-default style draws the reader's attention to that particular point.
jynelson
i see a bunch of people saying things like "you can do this in vim or emacs". it's true, you can do fuzzy finding and panes/tabs in an editor. but then you are in a box. anything that involves interacting with the terminal requires either a dedicated plugin or opening another nested terminal emulator (e.g. `:terminal` in vim). one of the things i get from my setup that's not mentioned in this post is that i can hit `git show HEAD` <highlight files and choose one> <tab> and that will put the file name in the command. this works for arbitrary commands, not just git, because it works by doing meta-processing on the terminal.
gloosx
When you're working with a computer, you are in a some kind of a box by definition.
>interacting with the terminal requires either a dedicated plugin or opening another nested terminal emulator
This is not true, you can run any terminal command in vim's command mode like :!git show HEAD, you can autocomplete it, pipe output where you need it etc without ever getting away from the file you're currently editing. You can also use % to substitute the current open file path in the command like :!git add %
umanwizard
Just to be clear, although you can use emacs from a terminal, it’s not the default and not what most people do. So a terminal emulator opened in emacs isn’t really “nested”
jynelson
sure. this still ties you to emacs as an editor though. the interesting part of emacs to me is the meta-programming with buffers, not the editor itself; i want to be able to plug-and-play editors and keep the meta-programming.
markasoftware
to be pedantic, if you're using `tmux`, you're already in a "box" and are using what amounts to a "nested terminal emulator"
Emacs and Vim are perfectly capable of taking arbitrary strings (which can be lines from the same terminal buffer that match a given regex) and putting them onto the command line of a terminal buffer. And more importantly, you can customize that whole process without writing C.
codethief
> i don't use Nix partly because all my friends who use Nix have even weirder bugs than they already had, and partly because i don't like the philosophy of not being able to install things at runtime.
Huh, I install things at runtime all the time.
Get the top HN stories in your inbox every day.
I love this, I've been iterating on workflows like this for something like a decade now. Over time I've tried to peel back as many of my custom layers as possible, because all of those layers have a maintenance cost.
Stock Vim (without `tmux`) can actually do most of what's shared in this post with `rg --vimgrep restore_tool | vim -c cb -` (`vim -c cb -` is my favorite feature in Vim; I find it strange that it's so rarely used or talked about).
(Since re-running the `rg` search can be undesirable, and I often like to analyze results in a terminal before opening them in Vim. I use a custom `tmux` command to copy the output of the last command [using this trick that involves adding a Unicode character to your prompt https://ianthehenry.com/posts/tmux-copy-last-command/], then I send that into Vim with e.g., `tmux saveb - | vim -c cb -`.)