Return to Answer

having to leave insert mode, move then re-enter insert mode is incredibly tedious

I imagine most of the tedious part is leaving insert mode, which implies reaching for the Esc key. Personally, I have my CapsLock mapped to Esc (with setxkbmap -option caps:escape), but there are multiple alternatives, like mapping jj to leaving insert mode, etc.

I actually switch more than necessary, and don't see it as a hassle. It's because I'm thinking of a series of actions and my fingers just translate. Let me give you an example. Let's say that I want to

1. call foo
2. pass it an object
3. make it a multiline object
4. pass it field bar with value "baz"

I don't foo({EnterTabbar: "baz"EnterBackspace}).

Instead I do:

1. foo()Caps (call foo)
2. i{}Caps (pass it an object)
3. iEnterCaps (make it a multiline object)
4. koTabbar: ""Caps (add field bar)
5. ibazCaps (with value "baz")

I think I don't see it as a hassle because:

1. I've made it easier to exit insert mode, by using Caps
2. Typing like that allows me to take advantage that opening and closing braces of all types are right next to each other on a QWERTY keyboard. This also allows me to hit " twice in succession when typing strings. It limits how many times I need to move from typing words to "weird" keys.
3. This is the big one for me: It better maps editing actions I have in mind to key sequences I need to type. It's like it makes typing more composable. I think this allows me to use muscle memory better when editing text.

_{* I use ko because O immediately after Esc corresponds to a terminal escape sequence, so weird stuff happens.}

having to leave insert mode, move then re-enter insert mode is incredibly tedious

I imagine most of the tedious part is leaving insert mode, which implies reaching for the Esc key. Personally, I have my CapsLock mapped to Esc (with setxkbmap -option caps:escape), but there are multiple alternatives, like mapping jj to leaving insert mode, etc.

I actually switch more than necessary, and don't see it as a hassle. It's because I'm thinking of a series of actions and my fingers just translate. Let me give you an example. Let's say that I want to

1. call foo
2. pass it an object
3. make it a multiline object
4. pass it field bar with value "baz"

I don't foo({EnterTabbar: "baz"EnterBackspace}).

Instead I do:

1. foo()Caps (call foo)
2. i{}Caps (pass it an object)
3. iEnterCaps (make it a multiline object *)
4. koTabbar: ""Caps (add field bar) **
5. ibazCaps (with value "baz")

I think I don't see it as a hassle because:

1. I've made it easier to exit insert mode, by using Caps
2. Typing like that allows me to take advantage that opening and closing braces of all types are right next to each other on a QWERTY keyboard. This also allows me to hit " twice in succession when typing strings. It limits how many times I need to move from typing words to "weird" keys.
3. This is the big one for me: It better maps editing actions I have in mind to key sequences I need to type. It's like it makes typing more composable. I think this allows me to use muscle memory better when editing text.

_{* When I know from the get-go that I want a multiline object, I'll just {Enter} directly. Since it's just a common thing to do and the keys are so close to one another, it's already in my muscle memory. I would do it like I listed above if I wasn't sure at first, though, or if the keys were different.}

_{** I use ko because O immediately after Esc corresponds to some terminal escape sequence, so weird stuff happens.}

having to leave insert mode, move then re-enter insert mode is incredibly tedious

I imagine most of the tedious part is leaving insert mode, which implies reaching for the Esc key. Personally, I have my CapsLock mapped to Esc (with setxkbmap -option caps:escape), but there are multiple alternatives, like mapping jj to leaving insert mode, etc.

I actually switch more than necessary, and don't see it as a hassle. It's because I'm thinking of a series of actions and my fingers just translate. Let me give you an example. Let's say that I want to

1. call foo
2. pass it an object
3. make it a multiline object
4. pass it field bar with value "baz"

I don't foo({Enter})CapskoTab.

Instead I do:

1. foo()Caps (call foo)
2. i{}Caps (pass it an object)
3. iEnterCaps (make it a multiline object)
4. koTabbar: ""Caps (add field bar)
5. ibazCaps (with value "baz")

Anyways, I think I don't see it as a hassle because:

1. I've made it easier to exit insert mode, by using Caps
2. Typing like that allows me to take advantage that opening and closing braces of all types are right next to each other on a QWERTY keyboard. This also allows me to hit " twice in succession when typing strings. It limits how many times I need to move from typing words to "weird" keys.
3. This is the big one for me: It better maps editing actions I have in mind to key sequences I need to type. It's like it makes typing more composable. I think this allows me to use muscle memory better when editing text.

_{* I use ko because O immediately after Esc corresponds to a terminal escape sequence, so weird stuff happens.}

having to leave insert mode, move then re-enter insert mode is incredibly tedious

I imagine most of the tedious part is leaving insert mode, which implies reaching for the Esc key. Personally, I have my CapsLock mapped to Esc (with setxkbmap -option caps:escape), but there are multiple alternatives, like mapping jj to leaving insert mode, etc.

I actually switch more than necessary, and don't see it as a hassle. It's because I'm thinking of a series of actions and my fingers just translate. Let me give you an example. Let's say that I want to

1. call foo
2. pass it an object
3. make it a multiline object
4. pass it field bar with value "baz"

I don't foo({EnterTabbar: "baz"EnterBackspace}).

Instead I do:

1. foo()Caps (call foo)
2. i{}Caps (pass it an object)
3. iEnterCaps (make it a multiline object)
4. koTabbar: ""Caps (add field bar)
5. ibazCaps (with value "baz")

I think I don't see it as a hassle because:

1. I've made it easier to exit insert mode, by using Caps
2. Typing like that allows me to take advantage that opening and closing braces of all types are right next to each other on a QWERTY keyboard. This also allows me to hit " twice in succession when typing strings. It limits how many times I need to move from typing words to "weird" keys.
3. This is the big one for me: It better maps editing actions I have in mind to key sequences I need to type. It's like it makes typing more composable. I think this allows me to use muscle memory better when editing text.

_{* I use ko because O immediately after Esc corresponds to a terminal escape sequence, so weird stuff happens.}

having to leave insert mode, move then re-enter insert mode is incredibly tedious

I imagine most of the tedious part is leaving insert mode, which implies reaching for the Esc key. Personally, I have my CapsLock mapped to Esc (with setxkbmap -option caps:escape), but there are multiple alternatives, like mapping jj to leaving insert mode, etc.

I actually switch more than necessary, and don't see it as a hassle. It's because I'm thinking of a series of actions and my fingers just translate. Let me give you an example. Let's say that I want to

1. call foo
2. pass it an object
3. prepare to fill that object in a new line

I don't foo({Enter})CapskoTab.

Instead I do:

1. foo()Caps (call foo)
2. i{}Caps (pass it an object)
3. iEnterCaps (in a new line ...)
4. koTab (prepare to fill it)

Well, that's a bit dishonest in that a line break between {} is so common and the Enter key is touching the } key, so I actually already have the muscle memory to type {Enter}. However, I would do it as I listed above if I needed different braces like (<>).

Anyways, I think I don't see it as a hassle because:

1. I've made it easier to exit insert mode, by using Caps
2. Typing like that allows me to take advantage that opening and closing braces of all types are right next to each other on a QWERTY keyboard. This also allows me to hit " twice in succession when typing strings. It limits how many times I need to move from typing words to "weird" keys.
3. This is the big one for me: It better maps editing actions I have in mind to key sequences I need to type. It's like it makes typing more composable. I think this allows me to use muscle memory better when editing text.

_{* I use ko because O immediately after Esc corresponds to a terminal escape sequence, so weird stuff happens.}

having to leave insert mode, move then re-enter insert mode is incredibly tedious

I imagine most of the tedious part is leaving insert mode, which implies reaching for the Esc key. Personally, I have my CapsLock mapped to Esc (with setxkbmap -option caps:escape), but there are multiple alternatives, like mapping jj to leaving insert mode, etc.

I actually switch more than necessary, and don't see it as a hassle. It's because I'm thinking of a series of actions and my fingers just translate. Let me give you an example. Let's say that I want to

1. call foo
2. pass it an object
3. make it a multiline object
4. pass it field bar with value "baz"

I don't foo({Enter})CapskoTab.

Instead I do:

1. foo()Caps (call foo)
2. i{}Caps (pass it an object)
3. iEnterCaps (make it a multiline object)
4. koTabbar: ""Caps (add field bar)
5. ibazCaps (with value "baz")

Anyways, I think I don't see it as a hassle because:

1. I've made it easier to exit insert mode, by using Caps
2. Typing like that allows me to take advantage that opening and closing braces of all types are right next to each other on a QWERTY keyboard. This also allows me to hit " twice in succession when typing strings. It limits how many times I need to move from typing words to "weird" keys.
3. This is the big one for me: It better maps editing actions I have in mind to key sequences I need to type. It's like it makes typing more composable. I think this allows me to use muscle memory better when editing text.

_{* I use ko because O immediately after Esc corresponds to a terminal escape sequence, so weird stuff happens.}