I picked up Build Websites with Hugo because I’m a PragProg loyalist with plans to revive my old blog, and if they have a book on something I’m using, I like to have an opinion on it. My opinion is that it’s fine, but barely. The book is from 2020, and Hugo has changed enough since then that half the examples either don’t work or generate deprecation warnings. I was running Hugo 0.164 against a book written for 0.68, and the scaffolding generated by hugo new theme is completely different now, so it actively conflicted with the book’s instructions at nearly every step.

Worse, the entire book has you building a custom theme from scratch, which is a reasonable way to teach, except that anyone graduating from this book is going to immediately throw that theme away for something maintained by people who actually know CSS, so you spend 200 pages building something disposable. What you do get out of it is an understanding of how Hugo thinks, with the template hierarchy, partials, taxonomies, front matter, and the asset pipeline, and that did turn out to be worth something, so just go in knowing you’re reading it for the concepts and not the site. Honestly, you’d probably learn as much in an afternoon of playing with Hugo directly and asking an AI assistant when you get stuck.

There wasn’t much else in it worth remembering, except maybe how to make a cool “This page will take X minutes to read” summary.

Chapter 10, Copy and Paste

First, the repetition of the insert mode <C-r>{register} command later in the book was something I found useful. I think that’s a pretty handy way to paste the contents of a register. I never knew that "+ let’s you access the system clipboard either. If you put the two together, you can quickly paste from the system clipboard without leaving insert mode with <C-r>+. The fact that yank stores a copy of what it copies in the 0 register is pretty handy too. Nice to have an alternate way to access the last yank if I’ve clobbered it.

Chapter 11, Macros

Most of the macros chapter was fairly new to me. I knew the basics of how to record and playback macros, and have used them before when in native vim and not using an emulator. But I’ve never given macros intense thought or tried to be terribly clever with them. He goes into the idea of crafting resilient reusable macros in some depth in the tips focused on them and covers a handful of macro best practices. As he puts it, “The golden rule is this: when recording a macro, ensure that every command is repeatable.”

The author sums up macro advice with the phrase “Normalize, Strike, Abort” The first question to ask when crafting a macro is, “where am I, where have I come from, and where am I going.” Make sure the cursor is positioned so the next command does as expected where expected. You shouldn’t use the mouse when recording a macro, so make sure to take advantage of the full range of available motion commands to maneuver to the right location to strike. If a motion fails while a macro is executing, Vim will abort the rest of the macro. This is a feature! You don’t want to execute your command when you aren’t in the right location. Motions can act as a simple test as to whether or not the macro should be executed. Remember that search is a motion too. You can do a lot with a macro that uses the n key to go to the next search item and perform an action. Once no matches remain, n will fail and the macro will stop.

Tip 67 points out how a simple two key macro can be useful to move and perform the dot command multiple times. You can’t repeat with dot, and if you could the number would either repeat the move multiple times or repeat the dot multiple times in the same place, so a simple macro of a movement command and dot is a clever trick tie a move and repeat together and replay it multiple times. Again, you can count on the motion failing at the end if you choose the right motion, so you don’t have to worry about the exact count. The example is as follows:

{start} x = “("+a+”,"+b+","+c+","+d+","+e+")";

And we want to change it to:

{goal} x = “(” + a + “,” + b + “,” + c + “,” + d + “,” + e + “)”;

And it can be achieved with the following keystrokes:

1. f+
2. s + <Esc>
3. qq;.q
4. 22@q

That’s much simpler than adding the spaces around the + marks by hand. Since the f+ movement will fail after we are out of +’s, it is safe to run the macro 22 times. The author admits to being lazy like this often. 22 is his go to repeat number, since 2 is the same key as @ to run the macro. That’s a great example of making use of “Abort”.

Appending keystrokes to macros works just like appending yanks to registers. qA will append commands on the end of the macro in register a. That’s a small but handy tip for getting more from macros. The next tip covers how to apply a macro to a series of files, either with :argdo normal @a or by manually advancing with :next to act across the argument list. The example he uses is a pretty handy one of wrapping several classes in a module declaration and adding proper indentation. The next tip seems handy, but I doubt it’s general enough use for me to remember it. It covers how to prepend an incrementing line count to multiple lines. The final tip of the chapter covers the fact that you can put a macro from a register, then edit the macro text, then yank the macro back to the register. An interesting option for editing macros! One note is to be careful to use a character-wise yank like "ay$", or else you might get an extra <CR> at the end of your macro.

Chapter 12 - Matching Patterns and Literals

First off, I learned the handy tidbit that using \c in a search pattern causes it to ignore case, and \C to be case sensitive, regardless of ignorecase settings. You can put them anywhere in the pattern, including just tacking them on the end. I like the default smartcase where if you include an uppercase letter it is case sensitive, otherwise not.

The \v switch anywhere in a regex makes it “very magic”, or more like what you might be used to from Perl, Python, or Ruby. It makes all characters assume a special meaning except for “_”, letters, and numbers, so you don’t need to escape all your braces, brackets, and parentheses. It makes the difference between #\([0-9a-fA-F]\{6}\|[0-9a-fA-F]\{3}\) and \v#([0-9a-fA-F]{6}|[0-9a-fA-F]{3}) to match CSS color codes, a regex that can be made slightly even better using the \x hex class as \v#(\x{6}|\x{3}). The \V or verynomagic option makes a search only search by the literal meaning of symbols provided, even ., *, and ?. Only the \ character has special meaning in a verynomagic search. So ultimately, both the \v and \V search options are terribly useful and worth remembering. A good example of the \V option is searching for “a.k.a.” with /\Va.k.a. instead of /a\.k\.a\. I think the argument has won me over well enough to use \v most of the time and \V on special occasions.

Another handy fact for regular expressions is that in verymagic search mode, the < and > keys match word boundaries. So a search for \v<the> will find all the “the” occurrences without any “their” or “these” being matched. It goes on to cover some ways to handle search field terminators in the final tip of the chapter.

Chapter 13 - Searching, 14 - Substitution, 15 - Global Commands

I didn’t find anything in these two chapters particularly worthwhile, except the fact that you can leave the search part of a substitute command blank to use whatever the last successful search was as the pattern. That decouples finding the right search pattern from the overall substitute command, and you normally want to search first anyway to make sure you got your pattern right before making changes. The search and replace across a project tip was possibly useful. Everything about the global command was new to me and worth playing with.

Chapter 16 - Index and Navigate Source Code with ctags

This whole chapter is about ctags and was all new to me. It looks like an excellent way to get the ability to jump to definitions in vim. Apparently I’ve been living under a rock, since I was unaware of this feature. This looks like a key step into making Vim into a development environment instead of just an editor.

Chapter 17 - Compile Code and Navigate Errors with the Quickfix List

The quickfix and location lists seem handy, assuming you map navigating them to something more convenient than typing :cnext and :cprev. I’ll have to checkout the unimpaired plugin he mentions that makes the quicklist navigable by [q and ]q. It has a number of other handy mappings, so it’s worth checking out instead of just putting the one set of mappings in my vimrc. I think I’ll use the Tip 108 that has you make :make run JSLint and populate the quickfix list with any linting errors. I didn’t fully understand how to do it from the tip, but this github project looks useful: vim-nodelist.

Chapter 18 - Search Project-Wide with grep, vimgrep, and Others

There’s so many neat random things in this book. Today I learned that there’s a version of grep optimized for programmers called ack. Ack. To relate it back to vim, the book explains how to make the vim :grep command use ack instead, but then tells you not to, since there is an ack plugin for vim ack.vim that will use it with the :ack command.

Chapter 19 - Dial X for Autocompletion

There’s plugins for better autocompletion than what’s built in. It looks like you can complete based off ctags with <C-x><C-]> or use <C-x><C-i> to complete based off your imports in various languages. Generic autocompletion is based off <C-n> and is probably best of the built-ins. You use <C-n> and <C-p to choose next or previous.

Chapter 20 - Find and Fix Typos with Vim’s Spell Checker

This one starts out simple, with how to use the built in spell checker. First think I learned is that z= on a misspelled word will bring up suggestions and [s and ]s let you jump between misspelled words. I was able to try those out successfully while writing this blog post. zg adds a word to the spell file, which worked great to add “blog”. Apparently, you can fix misspelled words without leaving Insert mode with <C-x>s to enable autocomplete misspelled mode. It will jump you back to the last misspelled word and offer suggestions from the dictionary. Pretty handy!

Summary

Overall, I think I picked up more tips than I can reasonably integrate into my workflow at once from my first reading of Practical Vim, Second Edition. That’s why I put a lot of them here on my blog, to remind me to try them out. I believe there’s still enough that I didn’t mention to make the book worth another read, or at least a re-read several spots in it. I highly recommend it if you are already comfortable using Vim and want to pickup tricks to take your Vim workflow to the next level.

The author recommends skipping around rather than reading the book from beginning to end, however, I still found the book quite readable. The tips vary in difficulty from very basic (Ex: Tip 47 is “Keep Your Fingers on the Home Row” and covers h, j, k, and l) to fairly advanced (Ex: Edit the Contents of a Macro). I really enjoy the way the author doesn’t repeat any content readily available in the manual. In the electronic copy, he links any manual references to a website with the vim manual. For people reading along, he provides the proper keyword to use with :h in order to lookup the topic via vim help. This allows him to not spend a lot of time on prerequisite info and get directly to useful tips.

Some tidbits that I’ve found useful so far are the keystrokes that he mentions being available in Insert mode. I never paid attention to the fact that you can use <C-w> to delete back one word without leaving insert mode, <C-r>{register} to quickly paste the contents of a register, and <C-v>u{1234} to insert unicode character #1234, all without leaving insert mode. In both the previous examples, the selection in curly brackets is replaced with just a register or just a four digit number, the curly brackets are not typed literally. I generally like hitting my keys one at a time while in vim, but those are a couple of useful chords to use in insert mode. I’m not sure I’ll use the unicode one often enough to remember it, but the other two are pretty easy to remember and of general use. There is no tip like “Here are some keystrokes for Insert mode.” but the author instead worked providing these keystrokes into the explanation of how to do something. The <C-r>{register} keystroke was provided in the “Paste from a Register Without Leaving Insert Mode” tip which focused on it and <C-v>u{1234} was from the “Insert Unusual Characters by Character Code” tip, but the <C-w> keystroke was provided in the more general “Make Corrections Instantly from Insert Mode” tip.

I learned a lot that I didn’t know before in the section on Command-Line Mode. As the author puts it, “Ex commands strike far and wide.” I was unaware of how the range worked with ex commands and of the variety of ex commands available. There are commands to delete, yank, put, copy, move, join, normal (execute Normal mode commands on a specified or range of lines), substitute, and global (execute and ex command where a pattern matches). I’ve used substitute a decent bit, but never remember knowing about the others and how you can make them all work flexibly with a range without having to move the cursor there first. It’s especially convenient that you can use V to switch into visual line mode and select some lines, then it will prepopulate the range of lines into your : for executing an ex command. You can also use % to target the whole file with a command, which is how I’m accustomed to working with substitute. As an example, :%normal A; will append a semicolon to every line in a file or %normal i// will comment out every line in a file given a language where // starts comments. You can even write a script of ex commands and load it into vim with :source {filename}.

I also learned that in you can use :edit %:h to load the working directory of the currently active buffer as a parameter to edit, and then tab complete it to the name of another file in the same directory. The book recommends you alias %% to %:h since this is so handy. That remap made it into my vimrc. You can even open a file in a nonexistant directory and then use :!mkdir -p %:h to create the directory so you can save the file.

The only obvious problem I had with some of the content is that some of it (like the ex commands) is too vim specific to work with vim emulators. Anymore, I spend a lot more time using IdeaVIM in IntelliJ than I clock with real vim, but that’s largely a personal problem. The author doesn’t avoid forward references, which is only a problem if you’re trying to read the book through rather than skip around as recommended. Also, the author sometimes punts further explanation to VimCasts. VimCasts is an excellent resource, and the author of this book is the man behind the site, but I like having explanations in the book I bought rather than having to look to outside video for them. In his defense, he only does it for some of the more graphical tasks like splitting windows and such. Also, around midway through the book when it gets to motion keys, it feels like backtracking to such simple topics to have a Tip 47 that covers h, j, k, and l keys and keeping your hands on home row. This leads to a number of other rather simplistic motion tips that are not new to anyone that’s used vim very long. Fortunately these are all kept to one chapter, Chapter 8. The fact that these complaints are all pretty nitpicky goes to show that overall, I didn’t find many problems with this book.

In general, I especially enjoy how the author explains his thinking behind the use of certain commands. He’ll sometimes show how to do something in multiple ways that use the same number of keystrokes, and then explain why one way better fits the general vim mindset (which often means its better for re-use via the . command). He does a lot of this early on in the book, but the tips later in the book he tends to show the one way to perform an operation.

I’m only halfway through the book now, but this post is getting long enough. I’ll go ahead and post what I’ve written about the first half of the book, and add another post later if I find some awesome tips worth mentioning in the latter half of this book.

Second Half

The first video is seven minutes of basics that are really basic. He advised it was skippable, and I should have taken his advice. He recommends installing iTerm 2 in OS X, which is what I use already on my Macbook. He recommends cygwin for Windows, but I tend to prefer babun on Windows. I’m watching these on the Macbook anyway. He recommends installing zshell and oh-my-zsh, which I already use and enjoy. So we’re about to where I learn some stuff.

The fifth video is about colors. It has some annoying flicking going on. Fortunately that went away. I was wrong about when I would learn something. He’s just focusing on how to edit your zshrc in video six. Ooo, in video seven I learned you can CMD+click links in terminal to open them in browser; that’s new. Being able to use take to make a directory and create it at the same time is new to me also. Next video is covering command history, which is a pretty standard zshell feature. At least it’s short.

Video nine is about zsh plugins. I never remember to use my plugins often enough, but I have a lot enabled. I didn’t like most of the plugins he showed off, but it’s useful to get people thinking about looking at the plugins to find something they’ll find useful. It reminds me to lookup commands of some of the ones I have installed. Video ten is about z, which is unrelated to zshell and completely new to me. It’s pretty cool. It tracks frequently and recently used directories and lets you switch to them via z regex where regex is a partial match for the directory name. It will switch across multiple directories with the one command easily. I see from the video that I could’ve installed it via homebrew rather than by hand, but it’s already installed manually now. It has some handy options that are covered in the manpage. The final tip is about trash, which is like rm, but it puts what is deleted in your Trash. I think I’m accustomed enough to rm not to worry about that, but those might be words I regret someday.

Overall, I think there was a lot of useful stuff if you aren’t already familiar with zshell and oh-my-zsh. It was a little long for the little bit that I got out of it, but I picked up a couple of useful tips. Overall, his teaching style is reasonable. I didn’t feel like falling asleep during either of his videos, and he doesn’t come off like he’s just directly reading from notes or anything. I might try the JavaScript 30 series when I’m in the mood to code some JS, since it’s free also. It should be a bit more substantial. Hopefully it doesn’t start out as slow.

Good to see that he isn’t opinionated about editors. He says use whatever editor you’re most comfortable with, even vim. He uses Sublime Text though and recommends a package for it, if you use it. I went ahead and installed it in my copy of Sublime Text. It’s called MarkdownEditing and has a lot more features than the built in Sublime Markdown package. I spent almost as much time reading the Package Control Messages as the runtime of these videos, but oh well, sometimes I open stuff up in Sublime, so I might as well get it working alright. I took this chance to toggle some settings in vim-markdown while I was thinking about it.

It’s a little annoying that his video player jumps down to the video list when it advances videos. Each one, I have to scroll back up after it advances to see the video again. Probably wouldn’t be so bad on my big monitor instead of the laptop screen. It’s made even more annoying by how short the videos are. Video quality is good, and it is nice that it saves the fact that I’ve set the speed up to 1.25 when it switches videos. I learned something about footnote links that I had forgotten, and a cool feature that lets you highlight a code block as a diff, so it wasn’t time wasted. He talks a little fast anyway, so I probably wouldn’t need the speed increase for something that I didn’t already know.

Overall, I thought the video was OK. I’ll try the Command Line Power User course too and see what I think of it. Currently I just use zshell with oh-my-zsh and a couple of plugins enabled, so maybe I can learn some more zshell tricks.