DEV Community: Julian Iaquinandi

My Keyboard Journey

Julian Iaquinandi — Tue, 14 Dec 2021 23:56:33 +0000

A couple of years ago I went down the rabbit hole of custom mechanical keyboards and I had no idea I was about to uncover a mountain of ideas, concepts, layouts and boards that I never considered!

It started with gaming. I was looking for a smaller keyboard to give me more mousing room after getting back into PC gaming and found myself in awe of the crazy keyboards I was coming across like this beast!

After ALOT of research, my focus shifted from gaming to programming and my everyday use of the interface to my world. The first board I got was a Niu Mini I really liked the feel of this board and was excited to try something new where the layout dictated that I wouldn't have to move my fingers more than the length of one key away to produce any keystroke I desired. How is that achieved? With layers! You can think of these as extra shift keys that allow you to move any keystroke or even macros to your desired location.

This seemed long-winded at first, having to learn a whole new layout but seeing as I plan to use my digits to earn money for the foreseeable future I thought I better start looking after them!

Learning to type.... again

At this point, I could type at a modest 40-60 words per minute but I knew that I wasn't typing correctly. My fingers would press keys on the far side of the keyboard and it felt like my hands were floating around causing lots of incorrect key presses. I had built up some pretty shocking muscle memory over the years.

First on the agenda was to learn how to type correctly. I used sites to try and learn the 'correct' way to type, Typeracer was the first I found. Although this was good for training speed it wasn't teaching me how to do things correctly. This is where Typing Club came in. It teaches you what fingers should go where and builds you up slowly by issuing challenges that only use a certain set of keys to slowly retrain your muscle memory.

Typing Club allows you to do so much before you hit a paywall. I did buy the full version but the free version is more than suitable to get you going and you can use other sites once you hit the wall.

I found these sites very useful but found my fingers still moving across to the wrong side every now and again, Damn muscle memory! It was getting better but I would hit keys like y, b and n with my left hand. The solution to rid my fingers of this curse was to use a split board so I had no choice in the matter other than furiously hitting my desk with my index finger.

Split boards

I had read quite a bit about split boards after seeing a video about the Kenesis advantage 2 but didn't fancy a rubber dome style board after feeling the feedback that mechanical keys had to offer.

The first split board was a let's split.

This worked great for retraining my muscle memory and the benefits of split boards started to become more apparent to me. It's a great feeling leaning back in your chair, arms shoulder-width apart, not only is it far comfier than keeping your hands centre stage constantly but it really gives you that feeling of being a Hackerman :D

Less is more!

Over my iterations of keyboards, I had realised that I didn't need as many keys as I thought, in fact, a lot less which led me to the mini version of the CRKBD/Corne style board.

This had the right amount of keys that I was looking for and for extra ergonomic points has keys that are staggered vertically to closer match the shape of your hand!

It foregoes the end rows that normally have your modifiers buttons and tab when compared to the Let's Split. This helped my typing by removing the 'distractions' for my fingers, in the same way, removing the number row had when getting the Let's Split.

The reduction in keys has meant more layer gymnastics and layout changes to accommodate the smaller number of keys, that was until I found out about home row modifiers. These changed the game for me, if you aren't familiar with home row mods I implore you to read this article as it doesn't get any better:

A guide to home row mods

They allow you to bind the hold function of any key to act as a modifier. I cannot tell you how liberating this felt after building up all this knowledge about how my fingers should live on the home row and it felt great! Not only can you bind modifiers but also layer shifts to ANY button! There are lots of other features software like QMK, ZMK and KMonad provide but this for me is by far the most useful.

Software and controllers

As mentioned I've tried a few boards and it's the microcontroller that will dictate what software you can and can't use with your new board. The most common is QMK which is the OG of the mechanical keyboard world as most microcontrollers will support it. With my latest board, I wanted to go wireless which either requires a fair bit of modding/overhead to get going with your standard Arduino micro so I opted for the NiceNano! This board supports Bluetooth as a first-party feature so was perfect for what I wanted to achieve.

Up until this point I had only used QMK but Nice!nano doesn't support it which led me to ZMK. It is very similar but like the Nice!nano it supports wireless keyboards out of the box, perfect!

I mentioned Kmonad earlier, this software lets you remap any keyboard that's attached as an OS level. I use this on my laptop to replicate the layout of my mechanical board the best I can. I'm not going to go into Kmonad here but it does mention it in the home row mods article mentioned earlier. Here's a peek at my config

My layout

Layouts are very personal to each user but looking at what other people have done is always a good starting point. I remembered an article that I had read a while back that really started me off on this journey of creating my own shift keys/layers so I used that as a starting point.

And boyyy how it's changed over the years. We are always looking for an endgame but I feel accepting your ever-changing fate is part and parcel of wandering down this road. I will say that for the last 6 months to a year the layout hasn't changed that much but you will always find things to improve the ergonomics of your layout, at the time of writing this I have updated my layout just a few days previous!

Here are my layers:

Mac(base)

Windows
Windows(base)

Punctuation

Numbers

For the full config check it out here

This is my most 'sane' layout so far with the latest edition being placing the Punctuation buttons under my pinkies and moving either the Windows or Control keys to the Z and / keys depending on the OS I'm using. This lessens the dependency on my thumbs (which I'm not 100% on yet) to switch layers as much as I was starting to feel like it was breaking my flow when programming too much. The same goes for the Numbers keys although I had moved them some time ago. You will notice I still have these layer swaps on my thumbs but the plan is to remove them once I'm a bit more used to it or if it doesn't work rollback!

I originally had the Numbers and Punctuation layers split across even more layers but with the intro to home row modifiers, I was able to condense four extra layers to two. Doesn't seem that bad right?

Having home row mods means having to utilise the correct modifier with the opposite hand to where your desired key lives. This at first was jarring as I did a lot of one hand combos but I'm falling in love with Vim more and more each day and working like this means keeping both hands firmly on the board which is one of my goals.

I know I should swap to I3 or another tiling window manager to get there fully but I've found my setup intuitive enough.... for now.

Wrapping it up

Now, if you have read all of this and think the intention was so to become a faster typer, this was never the goal. I would argue that my typing speed is now a little higher than it was before but the goal of this journey has always been ergonomics. My hands move exponentially less than they did before and it feels a great deal comfier and I feel better knowing I'm looking after my work tools better XD

To take that to the next level I'm considering learning a new layout like Colemak or Workman but one step at a time... and I don't have the time at the moment to take a typing holiday to readjust but I know I'm going there at some point. I may even learn Stenography, the method used in courtrooms and on live subtitles to type at speeds of up to 240 words per minute!?! Here's a great talk by the creator of the Plover software that vastly reduces the barrier to entry.

I hope you have enjoyed my journey and if the mood strikes please leave a comment! For example: 'Hey Julian, nice article but your layout is trash and here's why!' I don't put myself out there nearly enough and really appreciate any and all feedback!

VSCode Neovim Theme Modifier 🎨

Julian Iaquinandi — Mon, 26 Oct 2020 18:09:08 +0000

To commit to a mouse-less future I've been working to make a workflow that doesn't have me moving away from the home row.

Over the years I've tried my hardest to get into Vim. I love the idea of it but my interest ends up trailing off... Not this time!!

I've also got into mechanical keyboards in a big way and now type on a 40% split! Getting rid of over half the keys has sped me up quite a bit - I may write an article just on this. This felt like the perfect time to give Vim a proper go.

I had used the VSCodeVim plugin in my previous futile attempts in moving to the Vim workflow. It works great, but what piqued my interest (and sent me back down this rabbit hole) in Vim again was finding Neovim.

I hadn't used Neovim and proceeded to download the GUI app. After seeing how rich the feature set is and the extensive plugin library it started to appeal to me as it didn't feel like I was comprising vs using VSCode. In researching it further I found the Neovim Extension which seemed to be what VSCodeVim is to Vim, but it was much more.

VSCodeVim works by emulating Vim in VSC
Neovim Extension differs in that it's communicating with a real instance of Neovim via its API.

This gives us the best of both worlds, not only is it really fast ⚡ but we now have the full feature sets (almost) of both editors.

For more info on the Neovim Extension extension and how to get it up and running see Chris@Machine's Blog and Video which really helped me get going.

An interesting feature of VSCodeVim is that you can change the status bar colour based on what mode you are in. This is handy with VSC's status bar being quite small, especially on high res monitors:

Yes I know I can zoom in 😛

I couldn't find a solution to this functionality for Neovim. This problem paired with my interest to finally make a VSC extension is why I created NeoVim UI Modifier.

It takes changing the colour of the status bar one step further by changing the colour of a few key UI elements:

Statusbar + Panel outline:

Sidebar icons:

Cursor + Tab underline:

It currently supports picking colours for Normal, Insert and Visual mode;

I'm looking to expand this to Replace and Search modes as my Vim knowledge grows, there have been a few unsuccessful attempts so far. If you have any ideas please let me know/create a pull request: Github.

By default the colours used are to match the theme I use Cobalt2 by

Wes BosFollow

I'm a full stack developer

and have done for over a year now! To make sure it works for your theme you can change to colours in settings.json:

I'm open to any feedback so if you use NeoVim for VSCode please give it a try!

Available in the VSC marketplace, search for: Neovim

or click Here

How to extend your keyboard in Windows

Julian Iaquinandi — Thu, 28 Nov 2019 11:01:32 +0000

I am a massive proponent of streamlining my workflow and I feel one of the biggest improvements I've made in this area is simply navigating my computer. It's something I don't hear about much, in fact I know a few devs that don't even learn the hotkeys that come with Windows or their IDE and are happy to point and click their way through the day. Although there is nothing wrong with this I personally feel that there are massive benefits in shortcuts, hotkeys and macros.

Why would you do this? 🤷‍

I've fallen in and out of favour with Vim over the last couple of years, having only been developing for 3-4 years Vim keeps sucking back into its black hole. I manage to stay out of it most of the time nowadays but what's really appealing about Vim for me is the mouseless operation, I really took to the idea of not having to move your hands away from the home row.

Apart from looking like a 90's hacker

there are productivity gains in not using the mouse or even the arrow keys.

Prep 📖

I set out originally only looking for a solution to move my arrow keys to the home row permanently. To do this there were a few problems that had to be solved:

How to implement it (What program?)
How would the keys be activated? (What modifier?)

I had used AutoHotKey in the past but had drastically underestimated the power of this tool by only using it to create the odd macro for repeating tasks at work or for games. After researching other options (AutoIt and Kantu) I decided to go with AutoHotKey as it seemed well documented, mature and I had previous experince.

Small Aside

It's worth noting I did find a handy browser extension that does fulfil some of my requirements (re mapping of arrow keys) but only in chrome. Vimium adds basic vim-like navigation to the browser but unfortunately I couldn't leverage it as it only works in the browser. Definitely worth a look as it's a plugin I still use daily.

The modifier hidden in plain sight 🙈

I had started to address what key would be used to modify the home row to allow for the input of arrow keys in a vim-like style:

Key	Direction
H	Left
J	Down
K	Up
L	Right

After debating for what seemed like an age if to use CTRL, ALT or WIN/META keys I came across an article which was talking about swapping the escape and CAPSLOCK and there it was... staring me right in the face gathering dust...

Caps Lock!

I started practising hotkeys with the caps under my little digit and it was a pure penny drop moment. It felt so comfortable and natural compared to anything that lives on the bottom row.

Let's be honest, it's probably the most wasteful key on the keyboard:

It's massive
The functionality it brings can be achieved by holding shift
It's used much less than other more useful keys that are harder to reach like ESCAPE and most of the keys on the bottom row

CAPSLOCK === new modifier 💡💡💡

This was probably the trickiest part of setting this up. I wanted this new modifier to work well, as a modifier. The issue with this is that there are only a few keys that work as modifiers namely:

CAPSLOCK
CTRL
ALT
WIN/META
ALT GR (CTRL + ALT (most of the time))
SHIFT

We could just swap CTRL and CAPS which isn't a bad deal, you don't have to learn any new combinations/macros and get all the accessibility benefits of using CAPS. The issue with this approach is that I want to make my own macros and it's much easier to start with a blank slate then it is to figure out which commands you might be overwriting in different programs by remapping CTRL + whatever to your own macro.

I attempted to create this functionality in AutoHotKey and after hours of messing around and then the subsequent google session I found the following snippet to do what I wanted:

#Persistent
SetCapsLockState, AlwaysOff
; Caps Lock Disable
capslock::return
; Caps Lock with shift+caps
+Capslock::
If GetKeyState("CapsLock", "T") = 1
  SetCapsLockState, AlwaysOff
Else
  SetCapsLockState, AlwaysOn
Return

The snippet achieves two things:

It turns CAPSLOCK off so it doesn't work as CAPSLOCK
Enables SHIFT + CAPSLOCK to recreate normal CAPSLOCK functionality

THIS IS AMAZING

Not only can I now assign whatever I want to CAPSLOCK + my_desired_key but I can turn caps lock back on if needed with SHIFT + CAPS.

I don't know how to measure how much time I had put into finding a way to "Add" a modifier up until this point, all I can tell you is when I found this my head didn't leave my desk for 10 minutes 🤦‍♂ As always the simplest solutions prevail!

For example to assign CTRL + c to CAPSLOCK + c it would look like this:

Capslock & c::send, ^c

If you're not familiar with AutoHotKey the part on left-hand side of the '::' is the combo you would like to press. On the right-hand side is the command to execute, so 'send, ^c' means Send keys CTRL + C.

In this context ^ = CTRL see here for a full reference

Putting it all together 🥳

So now we can define custom hotkey combos to do tasks for us this is what it looks like to remap the directional buttons to the home row:

CapsLock & h::Left
CapsLock & j::Down
CapsLock & k::Up
CapsLock & l::Right

Easy, right? So let's take it a bit further. Above the arrow keys, I like to have some of the keys you would typically find in between the main set of keys and the Numpad.

Adding those in is as easy as

Capslock & y::Home
CapsLock & o::End
CapsLock & u::PgDn
CapsLock & i::PgUp

This, in combination with the arrows not only is more comfy but has levelled up my navigation skills in a big way 💪

While we are on the topic of navigation here are the other useful commands I use for navigating my computer:

Capslock & space::Escape
CapsLock & <::BackSpace
CapsLock & >::Delete

CapsLock & 1::switchDesktopByNumber(1)
CapsLock & 2::switchDesktopByNumber(2)
CapsLock & 3::switchDesktopByNumber(3)
CapsLock & 4::switchDesktopByNumber(4)
CapsLock & 5::switchDesktopByNumber(5)

CapsLock & s::switchDesktopByNumber(CurrentDesktop + 1)
CapsLock & a::switchDesktopByNumber(CurrentDesktop - 1)

See here for the desktop switching function

Wrapping Up 🏁

Now you have the basics of creating your own layer of hotkeys what will you do with it?

If you're interested in learning how to do this on Linux let me know with a comment below and I will show you how I translated this to my Linux rig.

📕 TLDR: Remap useful keys to a custom layer/new modifier using AutoHotKey

How I automate my OS 💻

Julian Iaquinandi — Wed, 27 Nov 2019 11:06:36 +0000

When I started developing, in particular on servers I started writing scripts to get them set up which mainly stemmed from the fact I didn’t know what I was doing. I would boot up a virtual machine or VPS and start tinkering with Apache or Nginx, change a setting nonchalantly not thinking about it. 10 minutes later I’m desperately trying to find which setting has changed, most of the time leaving me feeling like this:

I thought there has to be a better way and there is! Enter Bash Scripts!

Using Linux at the time made it easy to write scripts to install everything I needed for a new instance. I started to take what I called the destructible approach whereby I don’t install anything on an instance unless it’s in the script. What that meant is I could tear down my server and get it back to where it was in less than 10 minutes. Beautiful.

Then it clicked. Why not use this pattern in my normal setup? 🤯🤯🤯

Below I will explain how I achieved this on Linux and Windows.

Linux 💻

Jump to windows

I got to it and started creating what I now know as “Linux Tools” which is my set of scripts that do the above and more.

Installs ⚡

As Linux is a command-line driven which means apps can be installed via the command-line, for example, to install a package/app the most common approach is to use a package manager, we call the one that comes with Ubuntu apt.

To install git you will issue the following commands (in an Ubuntu flavoured distribution):

sudo apt update
sudo apt install git

First command updates repositories
Second installs git

The advantage of installing programs in this way is that it is scriptable. We can put the above into a script(.sh) file and then run from the command line.

If we saved the above into the file “installGit.sh” there are 2 commands used to get the script ready to execute and then run.

sudo chmod u+x ./installGit.sh
sh ./installGit

The first command makes the script executable and only needs to be run once on each script.
The second command runs the script as if we had run the commands in the terminal ourselves.

Any command that can be executed in the terminal can be scripted this way allowing us to set up our environment extremely quickly.

Functions 🛠

I use functions to organise code, I call update at the start of the script to avoid having to call it in each function:

sudo apt-get update

# function definition
GIT_INSTALL () {
  sudo apt-get install git
}

# function call
GIT_INSTALL

This may seem like a lot of boilerplate but the advantage is that there may be many steps to installing an app that can be encapsulated into a single function, the above is the most simple example.

Dotfiles 📁

The above explains the automation of installing packages but what blew my mind when first getting into this is being able to restore the apps the state I had them in previous to a reinstall 🤯 This is where Dotfiles come in. I’m not going to go into lots of detail about Dotfiles as you can find that on this awesome post:

How I increased my productivity using dotfiles [updated]

Mpho Mphego ・ Mar 3 '19

#dotfiles #linux #bash #docker

Simply put Dotfiles are user configuration files 🔧. This would hold any changes to settings you the user has made the program/app in question. One of the most common you may have come across is .gitconfig which stores info about your git account on your local system. When you run:

git config credential.username “new_username”

It will update your .gitconfig with:

[user]
    email = julianiaquinandi@gmail.com

As mentioned I have a set of files that get copied to where they need to go as part of my install, you can find my dotfiles here

Aliases 👻

I use aliases to quickly perform commands without having to type the whole thing out. So in this scenario, you could map the alias “installOs” to run your installer script. It’s not a practical example as you're not likely to need to run your installer script all the time, although I thought it was worth mentioning because:

Aliases are awesome and save me lots of time
Part of my install script copies my aliases file from a repo to my local install ready to be consumed by the command line.

If you haven’t used them before I would recommend checking this article for a primer:

Bash Aliases (aka part 1 of 2000 of how to get more done in less time)

Aniket Kadam ・ May 31 '19

#programming #timemanagement #bash #shortcuts

Windows 💻

Jump to linux

Granted I have a lot more developer experience on Linux but I was able to recreate what I do to automate my OS on Windows with less effort than expected.

Installs ⚡

Unfortunately, Windows does not have a built-in package manager by default but there is a way to achieve command-line installs. Chocolatey touts itself as “The Package Manager for Windows”.

To replicate the git install from above we will run the following:

choco install git

That’s it.

Seems easy and it is. The biggest issue I’ve found with chocolatey is it not having everything I need. You can search the registry here

To turn it into a script you could put the above into a Powershell script: “installGit.ps1” and run it from the command-line like any other script:

./installGit.ps1

Dotfiles 📁

Dotfiles work the same in Windows as they do in Linux. They are user configuration files that I save to a repo and then copy to their required location to restore an app’s settings.

To backup your git config on windows it’s as simple as copying C:\Users\YOUR_USERNAME.gifconfig to a backup location/repo. If you want to restore it simply copy it back to its original location 😉

Aliases 👻 & Functions 🛠

I found creating aliases a bit confusing at first but then I realised you can use functions that are defined in your Powershell default profile.

Here’s a couple of examples from mine, the first is used to install packages from chocolatey by typing “install” The second to clone a repo by typing its name:


function install() {
  choco install -y $args
}

function clone() {
  clear
  echo “Enter repo name”
  echo “-----------------“
  $repo = Read-Host -Prompt ‘|=>‘

  $start=$repo.substring(0, 4)

  clear

  if ($start -eq “http”) {
    git clone $repo
  } Else {
    git clone git@github.com:kensleDev/$repo
  }

}

With the above in your Powershell profile, you can simply type the name of the function to call it e.g.

install git

clone

Wrapping Up 🏁

I love scripting away menial tasks and this was a little look into how I achieve that within my OS. I am constantly refining my scripts and finding better ways to save time and concentrate on what’s important.

TLDR - An overview of how I automate the setup/maintenance of my OS/Environment via Bash/Powershell scripts.

My VSCode Setup

Julian Iaquinandi — Fri, 18 Oct 2019 10:55:15 +0000

Like most of us, my setup is ever-changing, I tend to install and uninstall plugins based on the projects that I'm doing but there are staples that get used regardless and the aim of this post is to document the settings/plugins/shortcuts that I can't go without.

You can check out my full settings here: Gist

If you want to give them a whirl then install Settings Sync and use the above gists id

Keyboard Shortcuts

I "go in" when it comes to keyboard shortcuts. I enjoy remapping programs to bend them to my will but what it really does for me is allows me to get acquainted with all the features of the tool at hand. I also have an AutoHotKey script that allows me to navigate windows via the caps lock key but I will save that for another post.

After many, many iterations I've landed on the following config/system:

File Navigation - ALT

Action	Shortcut
Next Tab	ALT + S
Previous Tab	ALT + A
Toggle Editor Pane	ALT + D
Full Screen Editor Pane	ALT + F
Center Editor Panes	ALT + C
Focus Editor Pane	ALT + Q

Expand current selection	ALT + K
Shrink current selection	ALT + J
Navigate Backward (cursor)	ALT + L
Navigate Foward (cursor)	ALT + H

Terminal / Output Navigation - ALT

Action	Shortcut
Focus Terminal 1	ALT + W
Focus Terminal 2	ALT + E
Fullscreen Terminal	ALT + R
Toggle Terminal Pages	ALT + T
Kill Terminal	ALT + 4
New Terminal	ALT + 5

Focus Problems Panel	ALT + 1
Focus Output Panel	ALT + 2
Focus Debug Console Panel	ALT + 3

Macros - ALT + M

Action	Shortcut
Comment Down	ALT + M, ALT + C
Delete Current Line	ALT + M, ALT + D
Go to next Error w/ suggestion	ALT + M, ALT + E

Misc

Action	Shortcut
Copy File Path	CTRL + SHIFT + C, C
Copy Relative File Path	CTRL + SHIFT + C, V
Toggle Sidebar	CTRL + B
Toggle Activity Bar	CTRL + ALT + B

Extensions

I love the plugin architecture that VSCode has adapted and now you can install most plugins without a reload 😍

When writing this up, in fact, every time I check my plugins I uninstall a handful and come to the realisation I don't need 90% of what I've installed. So after my cleanup, there's not that much to shout about which isn't necessarily a bad thing as I'm always trying to cut down my dependencies but here are the few that I actually use daily.

Framework specific tools - Dependant on the stack I'm using: Angular Essentials, Azure Tools, Vetur, AWS Toolkit

Settings Sync - Keeps my config consistent across multiple machines with ease and syncs via a Github gist. I code across 3 machines and previous to finding this plugin did it manually

Nightlight - This is a new addition as I found myself constantly switching themes this plugin will automatically switch themes either at a set time or when it's getting dark.

Palenight Theme - Day time theme

Night Owl - Night time theme

Macros - Allows you to create custom macros - Lots of potential here. Check out "Go to next Error w/ suggestion" in keyboard shortcuts

Settings

I've not included all of my settings file but I have included what I think you may be interested in, The full file can be found here: Gist

There's nothing too special here but:

Prefer setting the sidebars to the right, that way when toggling the sidebars the leftmost editor stays in the same place.
The title bar shows the file path as described here: https://bit.ly/2MSb94n
Like using Fira Code for font ligatures
Minimap disabled by default and doesn't render characters when open

{
  terminal.integrated.fontSize": 12,
  "terminal.integrated.fontSize": 12,
  "editor.fontFamily": "Fira Code, Hasklig Light, Hack, Menlo, Monaco, 'Courier New', monospace",
  "editor.fontLigatures": true,
  "editor.tabSize": 2,
  "editor.fontSize": 12,
  "editor.lineHeight": 22,
  "editor.letterSpacing": 0.5,
  "editor.formatOnPaste": true,
  "editor.formatOnType": false,
  "files.trimTrailingWhitespace": true,
  "editor.cursorBlinking": "phase",
  "editor.cursorSmoothCaretAnimation": true,
  "editor.renderWhitespace": "all",
  "editor.insertSpaces": true,
  "editor.smoothScrolling": true,
  "window.zoomLevel": 0,
  "files.insertFinalNewline": true,

  "workbench.editor.enablePreviewFromQuickOpen": false,
  "explorer.openEditors.visible": 0,
  "window.title": "${dirty} ${activeEditorMedium}${separator}${rootName}",

  "editor.minimap.enabled": false,
  "editor.minimap.renderCharacters": false,
  "editor.minimap.maxColumn": 200,
  "editor.minimap.showSlider": "mouseover",

  "telemetry.enableCrashReporter": false,
  "telemetry.enableTelemetry": false,

  "workbench.settings.enableNaturalLanguageSearch": false,
  "workbench.sideBar.location": "right",

  "macros": {
    "commentDown": [
      "editor.action.copyLinesDownAction",
      "cursorUp",
      "editor.action.addCommentLine",
      "cursorDown"
    ],
    "nextErr": [
      "editor.action.marker.nextInFiles",
      "editor.action.addSelectionToNextFindMatch",
      "editor.action.triggerSuggest"
    ]
  },

}