Say I have a file with some words in it, and I don't like those words:

moist responsibility yeet

Lets delete them. So if the cursor is at the front:

|moist responsibility yeet

What you want to do is Delete Word, or in vim terms dw

|moist responsibility yeet
--> type 'dw', this document becomes
|responsibility yeet

Hell yeah, moist is gone. We can just repeat this two more times and we're out of hated words:

|responsibility yeet
--> type 'dw', this document becomes
|yeet
--> type 'dw', this document is now empty
|

We did it! But that was actually inefficient. We forget about <repeat>. We could have just deleted words three times!

|moist responsibility yeet
--> type '3dw', this document is now empty 
|

That was fast, but not fast enough. If we notice that all of the words are on the same line, we could have used the "End of Line" object (in vim its $)

|moist responsibility yeet
--> type 'd$', this document is now empty 
|

…and that's not even fast enough. If you've noticed that all of the vim terms we've used are lower-case, a cookie for you. There's generally an uppercase version of everything. For example, D is usually defined to be d$, so we can do this with once key!

|moist responsibility yeet
--> type 'D', this document is now empty 
|

So, as we saw above, there's a bunch of ways to delete text. There's also some good ways to select text.

Say, for example, you have the rust struct below you'd like to copy to another file. Again, we'll use the pipe character | to denote the cursor.

// file: foo.rs
  |struct FooBar {
    baz: String,
    jaz: u32,
  }
// file: bar.rs

We have a couple of options. The easiest is probably Visually Selection (v), Move down a few lines(j a few times), and Copy (y,"yank"), then goto bar.rs (SPACE+f+f bar.rs), and paste (p). Phew, lets see it in action:

// file: foo.rs
  |struct FooBar {
     baz: String,
     jaz: u32,
   }
//-> press v, j j j (the |> means this line is visually selected)
  |>struct FooBar {
  |>  baz: String,
  |>  jaz: u32,
  |>}
//-> press y to copy it
  |struct FooBar {
    baz: String,
    jaz: u32,
   }
//-> SPACE+f+f bar.rs, enter, and paste it (p)
// file: bar.rs
  |struct FooBar {
    baz: String,
    jaz: u32,
   }

We did it! It made it. This probably takes me a few seconds, where the longest delay is opening bar.rs. As before, we could have used 3j to move three lines down, or notice that FooBar is at the end of the file, so G ("goto bottom") would move us to the bottom of the file to select it.

As making these diagrams is distracting me from writing about spacemacs, I'll just do one more quick example.

Returning to our previous example, plus complications, lets quickly add pub to each struct field. We could just use h/j/k/l to move around (like arrow keys), or mash w, but lets look at a more elegant method.

As baz and jaz, and the rest are parallel, we can use Visual-Block mode to add pub before each of them. If you've heard of multiple cursors (seperate concept), this is kind of like having multiple cursors. We'll first position our cursor at baz, then enter Visual-Block mode, then select all the rows rows, and then insert "pub " (that's a space at the end). Lets see it:

// file: foo.rs
 |struct FooBar {
    baz: String,
    jaz: u32,
    kaz: u32,
    haz: u32,
  }
//-> Lets move the cursor to baz, j w
  struct FooBar {
   |baz: String,
    jaz: u32,
    kaz: u32,
    haz: u32,
  }
//-> Enter visual select mode, CTRL+V, move down to select rows j j j
  struct FooBar {
   |baz: String,
   |jaz: u32,
   |kaz: u32,
   |haz: u32,
  }
//-> Insert text, I (capital i), type pub(space)
  struct FooBar {
   |pub baz: String,
   |jaz: u32,
   |kaz: u32,
   |haz: u32,
  }
//-> Press escape to enter normal mode, vim will repeat each action
  struct FooBar {
   |pub baz: String,
    pub jaz: u32,
    pub kaz: u32,
    pub haz: u32,
  }

Nice!

org-mode is an emacs mode for the markdown format org. It's quite amazing.

Literally anything you need to do can be done in org-mode

1. Create blog articles (you're reading an org-mode document right now, rendered on my website)
2. Create large, complicated design documents. Oh, you need to export to confluence? There's an export for that org-export-as-confluence
3. Write all of your assignments in Latex? Organize them in a nice tree structure with org-mode, inline latex where needed, and export as a beautiful pdf.
4. Need to do some credit card calculations? There's spreadsheet functionality built into org's tables.
5. Need a calendar? org-calendar
6. Need an agenda? org-agenda
7. Need a quick, per-project to-do list, that integrates with your agenda + calendar? org-agenda-todo
8. Need a simple, github render-able markdown format? org-mode.
9. Need a nice, simple presentation? org-present

The list goes on and on. org-mode and .org is an example of a highly productive format. Nothing I've encountered comes close to the level of integration and quality that org-mode offers.

You can add org-mode to spacemacs by adding the org layer.

Magit is probably the best git porcelain to date. It's a lightweight way to manage your git repos. It offers everything one could need:

1. A nice way to preview diffs, stage hunks, and commit them (no more git add . and have a messy history)
2. A nice way to deal with merge conflicts, with an emacs-integrated side-by-side viewer.
3. Zero thought pushing/pulling/branching/etc. It's just a SPACE+g+s p p to push your local commits.
4. Need to see what commit a particular line was edited in? SPACE+g+b to inline git blame

Seriously, if you use emacs, or are planning to, make this a must have package.

You can add magit to spacemacs by adding the git layer.

As a software developer, you're often surrounding stuff with brackets or quotes or something.

Spacemacs comes with vim-surround emulation out of the box. The grammar is something like <verb>s <repreat> <modifier> <object> <surrouding-object>" The most useful verbs are y, d, and c. y lets you surround something, d lets you delete something, and c changes the surrounding thing.

So the sequence ysiw) would say "Surround (in) this word with ()". Eg. Hello -> (Hello).

d is the opposite, so ds) would delete the parentheses. Eg. (Hello) -> Hello.

c changes the surrounding thing, cs)] would change () to []. Eg. (Hello) -> [Hello]

Vim/Emacs macros are a life saver. This is very similar to an Excel macro, if you've used one.

You start recording a macro with the grammar q<reg>, where reg is a vim register (I'll get to that). Most people use qq (store macro in the q reg). You record some actions, then store in that register. You can call it again later with the grammar @<reg>, which is usually @q.

For example, you can quickly convert a json object to a list of variables with a macro. Just record transforming one, and replay it on the rest:

{
   |"foo": "bar"
   "baz": "yaz"
   "haz": "bab"
}
//-> qq ds" v$ s/:/ =/ j 0 w q
//-> 2@q
//-> This will transform into
{
   foo = "bar"
   baz = "yaz"
   haz = "bab"
}
//-> And of course you can use ds{ to remove the outer curly braces.

All said, macros are the perfect way to trade physical effort for mental effort. This is especially important if you're prone to RMI (like me).

Like we say with macros, we can record stuff to registers. This are just temporary ways to store text. You can prefix a command with "<reg> <rest of the sentence>" and it will record into that register.

Vim automatically places yanked text (basically any text deleted or explicity copied) into registers "0 through "9.

So if you want to paste something you had deleted a two operations ago, it'll probably be in the "1 register.

I personally don't use registers much after I discovered Spacemacs had a paste transient mode, where I could just CTRL-j through my history.

Sometimes you're editing a super large file, and you need to keep coming back to the same area. You could guesstimate where it'll be by jumping to its line 415gg, or you could search for it.

A better, more stable way is with marks. You mark a location with m<reg>, edit somewhere else, and jump back with `<reg>. I mostly use a as my first register, then b, and so on. Lowercase registers are specific to a particular file, and uppercase registers are global. So if I have a spot I keep jumping into in a file, I just use mA, and then jump to it when I need to with `A.

Like before, vim automatically populates the anonymous register ` with the last cursor location. So if you jump to the end of a file with G, jump back with ``.

Similarly, CTRL-o will undo your navigation history. So you jump three files deep finding something, use CTRL-o to jump backward through your navigation history.

Have you ever CTRL+z'd a bunch of things, wrote some more stuff, and realized you needed something you undid?

Most editors have a linear undo-redo history. Not emacs with undo-tree (which Spacemacs comes with).

Just run undo-tree-visualize, and you'll have an entire tree of edits to jump through, where you can grab your changes, and then traverse back and paste it.

Spacemacs comes with some baked in features to manage "Projects". A project is sort of loosely defined, but it's usually a source control repo (eg. a git repo).

Some useful features:

• projectile-replace replace a particular identifier EVERYWHERE
• projectile-find-file opens a fuzzy finder for every file in the project.

But yeah, all told: I'm a fan of Spacemacs, and I will probably be using it for years to come. Seriously, take the dive and try it out. I haven't even scratched the surface in this article.