Item — HN Reader

Most programmers come to appreciate a single fundamental truth about their field way too late into their careers. That the most basic foundational unit, the substrate they need to conquer is text. Everything stems from it. We have to deal with text our entire lives. It doesn't matter where that text appears - in web browsers, in Jira, in Slack, terminal, in PDFs, Word or LaTeX documents. Code is just structured text. The feeling of empowerment and liberation when you can deal with text on your own terms is a disproportionate multiplier.

Vendors are designed to own you and ownership can have different forms. Slack.app that doesn't let you easily extract code snippets from a thread - owns you. Jira that forces you to use their imbecilic, quirky wysiwyg owns you. Note taking app that keeps the data in their db and not your files - ain't your friend. The friction is the ownership. When extraction of text requires effort, the tool has leverage over you. It's a subtler form than data lock-in - behavioral lock-in. You adapt your workflow to what the tool makes easy, and gradually the tool's affordances shape what you even think to do. Information gets buried in threads, search is mediocre, export is hostile. The "solution" they offer is to stay there longer - search in Slack, link to Slack, screenshare in Slack, summarize with AI in Slack, don't ever leave Slack. The tool becomes the answer to the problems the tool creates. It doesn't become "invisible" like the article says, you just don't realize that you're "lost" yourself in it.

Most popular editors and IDEs don't give you direct leverage over plain text either, at least not without the effort from your side. Shortcuts, popups, UI elements in the IDE at best are local drivers - you can't easily grab a thing from the outside and feed it to your LLM context in the middle of a task, or insert within a comment in the code - you have to switch, copy, paste, deal with format inconsistencies, manual conversion, etc. Then we keep bargaining what method is the best, fastest and most convenient - using the mouse or keeping the fingers on the home row, modality or complex shortcuts. All for the sake of the problem that's artificially enforced on your workflows.

Terminal-heavy users eventually start appreciating the leverage Unix philosophy grants them over text, but that's still contained within locality, they still have to constantly jump around, while eventually figuring out ways for automating some aspects of it.

Anyway, this should be a little more of a deeper discussion than a forum comment. Point is - do not give in to the status quo. Liberate your text - deal with it on your terms. Get annoyed whenever you need to switch back and forth just for the sake of finding the piece you need and moving it around - it should be instantaneous and instinctual. Like boxers moving on a ring and casually throwing punches. Long time Vim and Emacs users "get it", even though often don't follow true - some things never become gratifying instincts. Sometimes, even the opposite forms - redundant muscle memories.

3 comments

> Anyway, this should be a little more of a deeper discussion than a forum comment.

You should turn this into a post of its own, it's probably the most insightful thing I've taken away from this entire conversation.

I realized that I was typing the comment above in the middle of the night; finally, brain fatigue hit and I wrapped it too soon (thus some typos, sorry). That all was some "poetry." Now let me give you some concrete example cases.

1. You're typing a message to your colleague, and you're doing it in Slack, Teams, etc. Why? Why not use your trusted editor where you probably already have smart completions, quick spellchecking, thesaurus, definition and etymology lookup, translation and dictionaries, LLM integration and more.

Years ago I realized that and stopped typing anything longer than three words in anything else but my editor. But that forced me to copy-n-paste a lot, so I automated the process. I'd press a key in the middle of typing - regardless of what the current app is, the script simulates pressing Cmd/Ctrl+a Cmd/Ctrl+c; opens the editor buffer; inserts the text; I'll do editing; press a key - it goes back to the app; pastes the text. Stupidly simple, deviously efficient. Suddenly, my entire OS is my editor and my tool is "invisible" - like the article describes.

2. You're typing a message to your colleague. Now you're doing it in your editor, you want to share the url to the thing opened in your browser. What do you do? Normally, you'd switch to the browser, press another key to focus on the navbar, copy the link, switch back, paste the link. Goddammit, the url is cryptic. You, being a good teammate, want to add a description, now you have to go back to the browser to copy it. Then you have to make it into a markdown link format. Darn it. Was it parens and square brackets, or the other way around? We don't even realize how often we do this, because this simple action has become a routine. What's the point of arguing if mouse or vim or shortcuts is faster if the action is fundamentally flawed? For me, inserting a link in the middle of typing, from any tab in my browser is within a keystroke. It intelligently and properly formats it while retrieving the document.title.

3. Your colleague sends you a message: "Hey Jon, what about FOOBAR-41234?..." You know it's a Jira ticket number. But between FOOBAR-41345 and -41234 and a bunch of other recent ones you have no mental recollection of what that number is about. You go to your browser, navigate to the Jira instance, darn thing says you have to re-login, now you're going through 2FA - it won't even let you-in unless you find your phone and confirm it. All that effort just to look at the title. We all recognize this familiar flow, don't we?

Why even deal with this BS at all? Jira, Asana, Trello, etc. - all have CLI tools, you should leverage that. In my editor, whenever the cursor stumbles on a pattern like above, it immediately fetches the ticket description and shows it in a popup. I can quickly convert the plain "FOOBAR-41234" into a markdown, org-mode, whatever link format that has a description.

4. You're looking at FOOBAR-41234, you even see the description (because your editor is smart now), but how do you answer questions like: "what are the PRs related to this ticket?", "find slack threads that mention it", etc.? That stuff should be quick and easy. Do get annoyed whenever it takes longer than two seconds to answer any of these or similar questions.

5. You are pair-programming over Zoom. Alice (your colleague) is sharing the screen, you are reviewing some big unit of work. She's scrolling through the code changes, occasionally opening documentation, navigating to different sites, etc. You just can't bear constantly interrupting her with "slow down, I'm taking notes", "please, share this link", etc. After the session you frantically try to recall, but most of it is gone now, your notes are whacky, containing a bunch of broken urls and half-typed nonsense. Three weeks later it is a complete and utter garbage. Then you spend years debating of note-taking strategies trying to figure out what "works" and what doesn't.

That should annoy you. Darn it, if I can see it on the screen, why can't the computer "see" it too? It irked me, so I hooked up Flameshot, Tesseract, and Emacs and now I can select any area of my screen and the text gets OCRed and pops in a buffer. It's not always accurate, but it is quick and I don't even have to tell Alice to slow down anymore.

---

These are just a handful of examples, and I haven't even touched anything code related. Hopefully you can already see what I meant in my post above. Do liberate your text from the tyranny of complex GUIs, do get annoyed when you have to manually retrieve any piece of whatever. You're a damn programmer, computers and computer programs should obey your command, never forget that.

preach, brotha