Mastering the Terminal: How to Navigate Like a Pro with iTerm2 and Word Jumping

As developers, we spend a huge portion of our day working in the terminal. Whether it‘s managing git repositories, SSHing into servers, running build tools and scripts, or countless other tasks, the command line is at the heart of our workflow.

In fact, a survey of over 25,000 developers by Stack Overflow found that 55% use the terminal for more than half of their professional coding time. For those of us who live and breathe in the terminal all day, even small optimizations in how we navigate and interact with the command line can have a huge impact on our productivity.

One such optimization that I‘ve found invaluable is the ability to jump between words in the command line using keyboard shortcuts. By default, moving the cursor in the terminal is a character-by-character affair, holding down the arrow keys to slowly step through long commands and file paths. But with a bit of configuration in iTerm2 (or your terminal emulator of choice), you can enable shortcuts to jump word-by-word, making navigation a breeze.

Why Bother With Word Jumping?

To illustrate why this is so useful, let‘s look at some common tasks that require a lot of cursor movement in the terminal:

Git Commands

As an example, consider the following Git command:

$ git push --set-upstream origin feature/new-database-schema

If you notice a typo in the branch name and need to change "feature" to "bugfix", you‘d normally have to hold down the left arrow key until the cursor reaches the "f" in "feature". Depending on how long the command is, this can be quite tedious.

With word jumping, you can simply press Option + Left a few times to quickly jump back to the branch name, make your edit, and jump forward again.

File Paths

Another common scenario is navigating file paths in the terminal. Let‘s say you want to open a deeply nested configuration file:

$ vim ~/projects/myapp/src/config/database.yml

After opening the file, you realize you actually needed the test configuration instead. To change "database.yml" to "database.test.yml", you‘d again need to carefully arrow over to the end of the file name.

Or, with word jumping, you can press Option + Left to hop back to the start of "database.yml", then Option + Right to jump over the entire "database" word, drop in ".test", and you‘re done!

Long Command Options and Flags

A third area where word jumping shines is in dealing with verbose command options and flags. Take this Docker Compose command for example:

$ docker-compose --env-file ./config/.env.dev --project-name myproject up --build --remove-orphans

With so many long options, editing parts of this command means a lot of holding down arrow keys. But with word jumping, you can quickly hop between the –env-file, –project-name, –remove-orphans flags to make changes.

Sure, in any one of these examples you might only be saving a second or two compared to arrowing over. But over the course of the day, the time savings from word jumping can really add up, not to mention the reduction in cognitive load and frustration. It‘s the cumulative effect of all these small optimizations that can make a big difference in your command line productivity.

Enabling Word Jumping in iTerm2

So how do we actually set up word jumping in iTerm2? It‘s a reasonably straightforward process of mapping Option + Left and Option + Right to send special escape sequences that bash and zsh recognize as word jumping commands. Here‘s the full step-by-step:

1. Open iTerm2 Preferences (⌘,)
2. Go to Profiles → Keys
3. Click the Left option key and select "Esc+"
4. Click the Right option key and also select "Esc+"
5. Click the + icon to add a new keymapping
6. Set the Keyboard Shortcut to ⌥← (Option + Left Arrow)
7. Set the Action to "Send Escape Sequence"
8. In the Esc+ field, type: b
9. Click the + icon again to add another keymapping
10. Set the Keyboard Shortcut to ⌥→ (Option + Right Arrow)
11. Set the Action again to "Send Escape Sequence"
12. In the Esc+ field this time, type: f
13. Close preferences and restart iTerm2 for the changes to take effect

What‘s happening under the hood here is that we‘re telling iTerm2 to send the escape sequences Esc+b and Esc+f when we press Option + Left and Option + Right respectively. These Esc+b and Esc+f sequences are what the Readline library in bash and zsh binds to the backward-word and forward-word actions by default.

In other words, when you press Option + Left, iTerm2 sends Esc+b to your shell, which Readline interprets as "move the cursor back one word". Similar for Option + Right and Esc+f for "move the cursor forward one word".

We have to map the Option key to send escape sequences first because normally Option + Left/Right just types the special characters "∫" and "ƒ". By changing the behavior of the Option key in iTerm2‘s preferences, we‘re able to repurpose it for our word jumping shortcuts.

How Does This Compare to Other Methods?

Now you might be wondering, is this iTerm2-specific configuration really necessary? Couldn‘t we just set up the word jumping shortcuts directly in bash or zsh?

Well, yes and no. Because the bash and zsh shells use the Readline library for command line editing by default, you can absolutely configure word jumping shortcuts directly in your ~/.inputrc file (which is Readline‘s configuration file). In fact, if you look at the default ~/.inputrc, you‘ll see these lines:

# mappings for Ctrl-left-arrow and Ctrl-right-arrow for word moving
"\e[1;5C": forward-word
"\e[1;5D": backward-word
"\e[5C": forward-word
"\e[5D": backward-word
"\e\e[C": forward-word
"\e\e[D": backward-word

These bindings map various escape sequences for Ctrl + Left/Right to the forward-word and backward-word actions. In theory, you could just add additional bindings here for Option + Left/Right and be done:

"\eb": backward-word
"\ef": forward-word

However, the problem is that not every terminal emulator sends the same escape sequences for Option + Left/Right by default. So while adding those bindings to ~/.inputrc would work in iTerm2 (because we‘ve configured it to send Esc+b and Esc+f for Option + Left/Right), it wouldn‘t necessarily work in other terminals.

By setting up the keybindings in iTerm2 directly, we can ensure that the correct escape sequences are being sent regardless of what the underlying shell or ~/.inputrc has defined. It‘s a more portable solution, especially if you use multiple terminal emulators.

That said, there are other methods for enabling word jumping and optimizing your command line navigation beyond just configuring iTerm2 and Readline. Some popular options include:

Using Vi or Emacs Editing Modes

Both bash and zsh support using Vi or Emacs-style keybindings for command line editing as an alternative to the default Readline keybindings. These modes have their own set of navigation commands, often with more advanced capabilities.

In Vi mode for example, you can use "w", "b", "e" to jump forward/backward by words, "0" and "$" to jump to the start/end of the line, "f" and "F" to jump to specific characters, and so on. Many developers who are used to using Vi/Vim as their text editor find using Vi mode in their shell very natural.

To enable Vi editing mode, you can add set -o vi to your ~/.bashrc or ~/.zshrc file. For Emacs mode, it‘s set -o emacs, though this is usually the default.

Shell Frameworks and Add-Ons

Another approach is to use a shell framework or add-on that provides enhanced command line productivity features out of the box. Some popular options include:

• Oh My Zsh: A framework for managing Zsh configuration that includes many productivity plugins and themes. Has plugins for Vi mode, syntax highlighting, autosuggestions, and more.
• Prezto: A configuration framework for Zsh similar to Oh My Zsh but more lightweight and modular. Also has modules for enhancing navigation and productivity.
• Fish Shell: An alternative shell to bash and zsh that aims to be more interactive and user-friendly out of the box. Has features like autosuggestions, web-based configuration, and its own Vim-like editing mode.

These frameworks can be a great way to get a more optimized command line experience without having to manually configure every aspect yourself. They do have a bit of a learning curve and may change your shell environment more than you‘re comfortable with, but they‘re worth exploring.

Looking to the Future

As command line interfaces continue to evolve, it will be interesting to see how navigation paradigms and productivity features change as well. Even in the past few years, we‘ve seen the rise of new terminal emulators like Alacritty and Kitty that leverage GPU rendering for better performance, as well as projects like Zellij that bring multi-pane and multi-tab capabilities to the terminal.

On the shell side, new options like Nushell are exploring alternative approaches to the traditional Unix pipeline model, with structured data and built-in support for common data manipulation tasks. And even the venerable Readline library is getting new features, like bracketed paste mode for more intelligent handling of pasted text.

Perhaps in the future our terminals will have even more advanced navigation and editing capabilities built-in, without the need for as much manual configuration. But for now, setting up word jumping shortcuts in iTerm2 is a small but mighty optimization that can make a big difference in your day-to-day command line workflow.

Conclusion

As a developer, investing in your command line productivity is one of the highest leverage ways to boost your efficiency and reduce friction in your workflow. By taking the time to configure your terminal environment to work the way you want, you can unlock new levels of speed and fluidity in your interactions with the shell.

Word jumping is just one example of how a simple customization can have an outsized impact on your productivity. With just a few minutes of configuration in iTerm2 (or your terminal of choice), you can enable fast, intuitive navigation that can save you time and keystrokes on every command you type.

But it doesn‘t stop there. By exploring other productivity-enhancing features like shell frameworks, Vim mode, and alternative shells, you can continue to iterate on and optimize your command line experience.

The key is to always be on the lookout for these kinds of opportunities to streamline your workflow, whether big or small. Over time, the cumulative effect of all these optimizations can be truly transformative.

So give word jumping a try, and see how it feels. I think you‘ll quickly find it indispensable. And from there, keep exploring and experimenting with new ways to level up your command line productivity. Your future self will thank you!