DEV Community: Michael R. Taylor

Making Snake Case More Convenient

Michael R. Taylor — Sun, 27 Aug 2023 03:49:28 +0000

One thing that I've always hated about snake_case naming style is that I've always found typing an underscore (_) to be an awkward keystroke. The best thing that I've done to make snake_case typing easier is to use AutoHotkey to create a hotkey to insert an underscore when typing Shift-Space. Here is the AutoHotkey script:

; Make typing the underscore '_' easier for snake_case_names while programming (now Shift+SpaceBar)
+space::_

After some practice, using Shift-Space to insert an underscore becomes natural.

One minor issue is that I sometimes accidentally type an underscore when I type a capital letter before a space by leaving the shift key down a bit too long. This can be worked around by making the hotkey above only active when certain programming applications (Visual Studio Code, Vim, etc.) have focus.

Here is an example that makes the hotkey active only if Visual Studio Code or Notepad has focus:

#HotIf WinActive("ahk_exe Code.exe") or WinActive("ahk_class Notepad")
+space::_

I hope this tip is as valuable to others as it has been for me.

Making the Portable Toolkit More Portable

Michael R. Taylor — Fri, 18 Aug 2023 06:44:00 +0000

One problem that may appear when creating a toolkit with Scoop to be used between computers is the minor configuration differences necessary on different computers. For instance, your home directory may be different on a work computer vs your personal computer.

A simple solution is to create template files with placeholders that can be replaced with proper values after cloning the Scoop persist directory.

Making template files

For any configuration file in your persist directory that will need to be different on different computers, create a duplicate of that file with the suffix .template. The original file should be added to the .gitignore file, and the .template file should be added to source control instead.

Scripting the customizations

Two scripts can be created and then stored in the persist repository. One script will replace the machine-dependent values with some placeholder, and another script will expand the placeholder text with its proper value.

The following examples will replace a hard-coded user profile directory with the placeholder %USERPROFILE%. However, they can be expanded to cover more variables. I've chosen Powershell for the scripts because that is what Scoop already uses.

I refer to the script that replaces the hard-coded values with placeholders as the compact script, and the script that replaces the hard-coded values is the expand script.

The compact script

Here is an example of a compact script. It simply recursively finds all files with a .template suffix. Then, it opens the original file (by removing the suffix) and scans for specific values that need to be replaced with placeholders.

$files = Get-ChildItem -Recurse -Filter '*.template'

foreach ($f in $files) {
    $config = [System.Io.Path]::Join([System.Io.Path]::GetDirectoryName($f), [System.Io.Path]::GetFileNameWithoutExtension($f))
    Write-Host "$config -> $f"
    $winStyle = $env:USERPROFILE
    $unixStyle = $env:USERPROFILE.Replace('\', '/')
    (Get-Content $config).Replace($winStyle, "%USERPROFILE%", 'OrdinalIgnoreCase').Replace($unixStyle, "%USERPROFILE%", 'OrdinalIgnoreCase') | Set-Content $f
}

In this case, it uses the environment variable USERPROFILE to determine the home directory, which is a string that should be genericized. These strings are replaced with the placeholder %USERPROFILE%.

It is important to remember that on Windows, both '/' and '\' can be used for directory path separators. That, along with case insensitivity, must be accounted for.

When any configuration changes are made, re-run the compact script to update the template file and then commit the changes.

The expand script

The expand script does the reverse of the compact script, but it's a bit simpler because differences in path separators and case insensitivity don't need to be accounted for. Here is an example to complement the above compact script.

$files = Get-ChildItem -Recurse -Filter '*.template'

foreach ($f in $files) {
    $config = [System.Io.Path]::Join([System.Io.Path]::GetDirectoryName($f), [System.Io.Path]::GetFileNameWithoutExtension($f))
    Write-Host "$f -> $config"
    $unixStyle = $env:USERPROFILE.Replace('\', '/')
    (Get-Content $f).Replace("%USERPROFILE%", $unixStyle) | Set-Content $config
}

Note that Unix-style directory separators are used. I find that these cause fewer problems since they won't need to be escaped ever.

Summary

Hopefully, a couple of scripts like these can make your Scoop persistent configuration files more versatile. The ability to use the same developer tools and configurations on each computer you work on will lead to better efficiency and productivity. Thus, reducing any friction in making this happen is very valuable.

Using Scoop to Create a Portable Toolkit

Michael R. Taylor — Tue, 15 Aug 2023 15:04:36 +0000

Scoop provides a wonderful foundation for creating a portable developer's toolkit on Windows systems.

What is Scoop?

Scoop is a command-line installer for Windows. It is created from Powershell scripts, so it installs easily with few dependencies on Windows-powered systems. The premier benefit of Scoop over other Windows installers (e.g., Chocolaty, Winget, etc.) is that it installs everything to a single directory under the user profile.

Scoop stores configuration data that should persist between software updates in a persistent data directory. This directory is an excellent candidate to store in a private repository somewhere. (Of course, this repository can be public. I tend to store license/registration keys in this directory, so I made mine private.)

Creating your toolkit

To create your toolkit, first, install Scoop and then use it to install the utilities--development or otherwise--that you use.

Once everything is installed and configured to your liking, create a Git repository in the Scoop persist directory. It should be located under scoop/persist in your Windows home directory.

This repository will allow you to back up your application configurations and import them on other machines, giving you an identical work environment across devices.

Before pushing your Git repository to some remote server, save a list of all the apps installed in Scoop to make them easy to install on other machines. Do this by running scoop export > scoopfile.json in the persist directory. Make sure to commit the scoopfile.json file. On other devices, you can install all your apps by running scoop import scoopfile.json.

Cloning your toolkit

The process to create a copy of your work environment is as simple as the following steps:

Install Scoop
Install Git via Scoop: scoop install git
Checkout your Scoop persist repository to $HOME/scoop/persist
Install your Scoop packages: scoop import $HOME\scoop\persist\scoopfile.json

Enjoy!

I find that using the same tools and configurations on any machine I work on allows me to become as efficient as possible with these tools. In my opinion, Scoop provides the easiest way to create an environment that can be easily synced across all of my development computers.