You're probably like me, and you have an insatiable thirst for new software to quench your curiosity. There is a wealth of useful applications out there. Some applications are powerful enough to change how you think and perform. Here are three tools that fundamentally changed me as a programmer.
Neovim: A Tinkerer's Dream
Whether it's features, extensibility, or ease of editing, Neovim enables me to create the exact environment that I want and allows me to focus solely on the code—improving my efficiency and overall developer experience.
Endless Tinkering and a Personalized Setup
Neovim is a highly customizable text editor with some advanced code editing features that are on par with other code editors like VS Code. Not every single one of VS Code's features is matched, but Neovim's answer is infinite configurability.
Neovim has an expansive plugin system, and there's always fresh plugins making their way into the ecosystem. The endless tinkering of my system has fully immersed me in programming; I don't just write code to make applications, but I write code to write code better. If there's an annoyance that's hindering me, I can install a plugin, or write the code myself.
Effortless Editing
The biggest win for Neovim is how easy it makes text editing. Moving, changing, and deleting words without much thinking is truly liberating. I feel like the typical graphical UI approach to editing is clunky and just gets in the way. Neovim enables me to concentrate solely on the meaning of the code rather than the editing process itself. I feel closer to the code. My ideas manifest on the page without me having to think about the mechanics of editing. But it doesn't stop there, because Neovim has first-class support for Tree-sitter, and it only makes editing much better.
Tree-sitter is a special language that can be configured to understand just about any structured text imaginable—programming languages, markdown, and even specialized syntaxes like Typst. Tree-sitter enables its users to manipulate text in a way that's specific to the language. For example:
-
Navigation: jumping from function to function or to specific parts of a function.
-
Selecting and moving entire if-else blocks without copying and pasting.
-
Switching arguments in a function around, without copying and pasting.
Only your ability limits what you can do. Neovim comes with many Tree-sitter configurations (called dialects), and there are many more out in the wild.
A Ticketing System: Set Your Tickets Up, Then Knock Them Down
When managing a big project, it's impossible to remember every single task that you need to do. When you're writing a small script (< 1000 lines), you know what's directly in front of you: what you're writing and what you need to write—you have a clear goal in mind, and you can see the finish line.
For larger projects that span multiple packages, repositories, and tens of thousands of lines, it's impossible to remember all the ever-growing list of tasks you need to complete. In fact, even just frequently switching between packages to make small edits often causes you to lose concentration. This is where a ticketing system comes in handy.
For those unfamiliar with the term, a ticket system is much like a to-do system: each to-do item is a ticket, which describes a discrete problem—for example, a bug or feature. The power comes from how you organize those tickets; you can tag them or place them onto a Kanban board.
A Kanban board consists of a set of columns, and each column represents the state of the ticket. I like to use the states: backlog, next, doing, and done. The Kanban board itself represents a project or a goal—for example, "implement authentication." Each ticket is a small unit of work that contributes to that goal. For example, "create database tables." When you create a ticket, it will land in the "backlog" column. When you want to process the ticket soon, it goes into the "next" column. I am sure you can guess the rest.
Pikovit/Shutterstock
Over time, as you're working on your code, you will inevitably discover issues that take too long to fix at the present time. That is when you create a ticket, tag it, and if it belongs to a specific goal, add it to the relevant Kanban board.
I usually have 1–2 projects (Kanban boards) open, which are things I plan to do in the immediate future.
Planning too far ahead can make your work inflexible, and you spend more time rearranging your plan than you would like.
Using a ticketing system is essential if your project takes more than a week or two. Before I used one, I would often start the day by staring blankly at my code, trying to think of what the next logical step is. That is the wrong way to organize your software project, and prearranging your tasks liberates you from constantly stalling. You do the thinking up front and free yourself to focus on the code.
GitHub offers a great ticketing system with a Kanban board—they call them projects. You can create global or repository-specific projects. In addition, if you use a flexible note-taking system (like Org-Mode, covered next) that allows you to rearrange your tasks easily, that's also suitable; however, collaboration with others is something to keep in mind.
Org-Roam: An Advanced Note-Taking System
In the last section, I made reference to Org-Mode, an Emacs package that allows you to quickly rearrange headings, tag them, and even turn them into to-do items. Org-Mode is an absolutely gigantic package, which has hundreds of features—after six years of using it, I have yet to learn everything on offer.
Org-Roam is another Emacs package that's built upon Org-Mode. Org-Mode provides the basic document layout and an endless list of features to manipulate them; Org-Roam provides linking capabilities, allowing you to link together notes in a graph. It works much like hyperlinks do on the World Wide Web.
While being a programmer, you're always learning. Whether you're learning a new framework, library, or language—these are all absolutely gigantic topics, and they take years to master. There are many facets and quirks about these technologies, which means your learning is never complete. To remember everything that you learn, you need an efficient way to file individual ideas into places where they're easy to retrieve. Using a traditional note-taking system is unsuitable; instead, you need to draw clear boundaries around each idea, much like webpages do on the web. Also, you need a way to quickly search through your notes. Org-Roam provides both of these.
Everyone's workflow will be different, but mine is to create one note for each idea and to place links into multiple other notes that act like indexes. Below you can see a toy example
The details in the summaries would be much more useful in a real sample. The descriptive summaries help maintain your grasp of the learned ideas, especially as you regularly review your notes.
That approach enables me to obtain a summarized, well-organized, and topical overview of everything I've learned. When I revisit these notes later, I often relearn much of a topic in just 10 minutes. Unlike traditional note-taking systems, brushing up on a language I haven't used in a long time never fatigues my mind, because the information is so accessible.
What's more is that the graph-based notes system enables a two-way linking process. You highlight certain keywords in your notes and link them to other notes. These links are called backlinks, and they make the block of text visible in the other note. Backlinking is very powerful, because it often unearths long-buried information.
Org-Roam is not the only note-taking system that provides a powerful backlinking feature. However, it uniquely integrates with the Org-Mode package. These two packages combine to integrate my to-do lists with my personal knowledge base.
As you can see in the screenshot above, to-dos are just Org-Mode headings with a "TODO" keyword prefixed to them. Org Agenda (part of the Org-Mode package) picks these up and displays them in a special buffer. Since we also use Org-Roam, we can interlink them with any other Org-Roam note.
Other similar systems that are much easier to use are Obsidian and Logseq—both are suitable for those who just want a functioning system. Org-Roam and Emacs are for those who want a highly tailored workflow—i.e., programmers.
I have an entire article dedicated to why I prefer to use Neovim that you may find useful. We also have articles on using Obsidian to take notes or using Obsidian to keep a journal ; both of these serve as a good introduction to Obsidian.
If Org-Roam has piqued your interest, visit the Org-Roam landing page to learn more about it. You may also want to explore Org-Mode as well. If you're new to Emacs, configuring it isn't easy, but Doom Emacs makes the process much simpler, and it's my Emacs distribution of choice.
