Howdy folks! 🎉 I'm Simon Owen, and over the years, I've loved being a part of and learning from the dotfiles community. I spend a lot of time teaching developers and running workshops. In those sessions, demonstrating how I set up my development environment is often one of things that folks appreciated the most.
Dotfiles are a key part of my development environment. Havenât heard of them? Well, even if you have, itâs a good idea to walk through what they are and the benefits of using them.
Last year, I set myself a goal to create a screencast series. If you like this article and want to find out more, please subscribe to the mailing list and get the download link. If you really like it, you can also 🦄 donate here! 🦄
A dot-what-file?
If youâre hearing about dotfiles for the first time, itâs totally fine to be confused about what they are and what they do. I recall that it took me a considerable amount of time before I realized a dotfile is simply a file that has a dot in front of the file name!
There are two common examples of dotfiles. First, the ones you might already be familiar with are those often found at the root of many open source projects â for example, .editorconfig
contains code editor preferences to help maintain consistent coding styles for a project. You may also have seen .stylelintrc
and .eslintrc
floating around, which set CSS and JavaScript rules, respectively.
Second (and the ones weâre looking at today), are dotfiles that can live at the root level of a user directory (i.e. /Users/<username>
). One such dotfile is .aliases
, which contains custom named commands that can speed up work in the Terminal. Another is .bash_prompt
, which is used to change the $
in Terminal to something a little more fun. In my case, I set it so this dude pops up to make me smile when things get tough:
ŕźź 㤠â_â ŕź˝ă¤
Hopefully, youâre already starting to get a good sense of how useful dotfiles can be. Theyâre sort of like hidden gems (literally, since theyâre hidden from views by default) that unlock superpowers for your machine to help with development. Weâre talking about automation, optimizations, and efficient workflows, among other things.
First, I want to give props to the dotfiles community
Before we dig into dotfiles, itâs worth calling out how great the community behind them is. When I first forked Paul Irishâs dotfile repo, there was a lot going on in there I didnât understand. Mathias Bynens and Paul Irish helped me immensely by answering questions about the code and it was their willingness to help that served as one of the reasons I became drawn to both the concept and the community.
Sometimes, Iâll post something to the community that Iâd like to automate, but canât figure it out for the life of me. And, without fail, Iâll get a helpful reply. Case in point: Eric Czarny wrote an app for me to automate my Spectacle settings and Mathias also contributed a code snippet. How cool is that?!
Then there are things like macOS updates. The dotfiles community is often on top of this and provide useful advice on GitHub comments regarding anything that no longer works or other useful information. You can then amend your dotfiles accordingly, such as adding the following code that increases the sound quality for Bluetooth headphones/headsets:
defaults write com.apple.BluetoothAudioAgent "Apple Bitpool Min (editable)" -int 40
Digging into dotfiles
The code example above might look a bit familiar to you. Itâs along the same lines as this often-used one to show hidden files:
defaults write com.apple.finder AppleShowAllFiles -bool true
...or this one to add spaces to the dock:
defaults write com.apple.dock persistent-apps -array-add '{"tile-type"="spacer-tile";}'; killall Dock
These commands can be pasted directly into the Terminal. As you might expect, something like -bool true
will change a boolean value from false
to true
and reset the command for later use.
If youâe like me and have a lot of these commands, then this is where the .macos
(previously .osx
) dotfile becomes especially useful. Instead of copying and pasting each command individually, we can automate and run all of them in one go.
Letâs walk through some examples
There are so many awesome things we can do in dotfiles. Here are some practical use cases that I rely on for my day-to-day work.
Setting aliases for default commands (.aliases)
Navigating between directories in the Terminal can be cumbersome and itâs easy to get lost in cd
madness.
We can replace the standard âchange directory" (cd
) command with a custom command in the .aliases
dotfile. For example, use this alias to ditch the cd
prefix altogether when using the command cd ..
to move up a directory in favor of ..
by itself.
alias ..="cd .."
Sure, itâs only dropping two letters, but how much easier is that to remember?
We can do the same thing to make shortcuts to certain directories:
alias dl="cd ~/Downloads"
Or, create aliases for shorthand command tasks:
alias hs="hexo serve"
Oh, hereâs another one! List only directories:
alias lsd="ls -lF ${colorflag} | grep --color=never '^d'"
Make a custom bash prompt for a personal touch to the Terminal (.bash_prompt)
I referenced this a little earlier, but hereâs how I turned my bash prompt ($
) into a little dude thatâs way more fun to look at it. This is done directly in the .bash_prompt
dotfile.
PS1="ŕźź 㤠â_â ŕź˝ă¤"
Create Git shortcuts to speed up commits (.gitconfig)
We can make it a little more efficient to commit all changes at once in the .gitconfig
dotfile. Using ca
is a lot more concise than !git add -A && git commit -av
.
ca = !git add -A && git commit -av
Another handy shortcut: find commits by commit message.
fm = "!f() { git log --pretty=format:'%C(yellow)%h %Cblue%ad %Creset%s%Cgreen [%cn] %Cred%d' --decorate --date=short --grep=$1; }; f"
Automate common Homebrew tasks (brew.sh)
Use Homebrew for package management? Although not strictly a dotfile (it doesnât have a dot before the file name), Homebrew gives us the brew.sh
shell script file. This file automates the installation and management of Apps and Tools:
brew install git
brew install tree
brew cask install google-chrome
brew cask install iterm2
brew cask install sublime-text
Protect your Git credentials (.extra)
Hide information you don't want to share publicly in one file in a private repo and bring it in for you alone. For example, a good idea for this file is anything thatâs specific to you, such as your Git credentials. This will prevent people from cloning, running your dotfiles, then committing as you!
# Git credentials
# Not in the repository, to prevent people from accidentally committing under my name
GIT_AUTHOR_NAME="Simon Owen"
GIT_COMMITTER_NAME="$GIT_AUTHOR_NAME"
git config --global user.name "$GIT_AUTHOR_NAME"
GIT_AUTHOR_EMAIL="<ADD-YOUR-EMAIL-HERE>"
GIT_COMMITTER_EMAIL="$GIT_AUTHOR_EMAIL"
git config --global user.email "$GIT_AUTHOR_EMAIL"
Write custom functions for tasks (.functions)
Dotfiles are more than shortcuts and aliases. We can also make custom functions in .functions
that do more advanced lifting. For example, create a new directory and change directory to it:
function mkd() {
mkdir -p "$@" && cd "$_";
}
Or, we can open a given location in Finder with a one-letter command (o
):
function o() {
if [ $#-eq 0 ]; then
open .;
else
open "$@";
fi;
}
Specify your $PATH and keep private (.path)
$PATH
allows the running of executable files. Instead of navigating to each path manually in Terminal, here we can set the file paths so they can run the executable files directly. It might be the case that this file contains sensitive information. As such, this file is often kept in a private repo.
Hereâs an example adding ~/utils
to the $PATH
:
export PATH="$HOME/utils:$PATH"
Force Vim to use a particular theme (.vimrc)
Editor config files are great for ensuring consistent formatting across projects, but we can also tell a Vim editor to use a specific theme in a .vimrc
file:
" Use the Solarized Dark theme
set background=dark
colorscheme solarized
let g:solarized_termtrans=1
Bonus: Helpful Terminal recipes for macOS
OK, so hereâs a little bit of a bonus for Mac users that isnât related to dotfiles, but are things we can do in the Terminal to give macOS superpowers to do pretty awesome things that make day-to-day use a little easier and more pleasant.
First off, we can show hidden files by default in the Finder so dotfiles are visible all the time by typing this into the Terminal:
defaults write com.apple.finder AppleShowAllFiles -bool true
Find the way that scrollbars toggle on and off in Finder jarring? Letâs make them visible at all times:
defaults write NSGlobalDomain AppleShowScrollBars -string "Always"
By default, macOS checks for software updates once per week. But maybe we want to check once a day or at some other interval:
defaults write com.apple.SoftwareUpdate ScheduleFrequency -int 1
You know how holding down on a keyboard key repeats that character? Well, it repeats at a determined speed that we can supercharge to blazingly fast:
defaults write NSGlobalDomain KeyRepeat -int 0
Some people love the way macOS includes a box shadow when taking a screenshot of a window. Others donât. Hereâs how to turn it off:
defaults write com.apple.screencapture disable-shadow -bool true
And, in this example, we can automate the size of icons in the Dock:
defaults write com.apple.dock tilesize -int 36
This is only the tip of the iceberg! In my screencast series I go over more than one hundred of them.
Conclusion
Web development is increasingly more complicated as time goes on. We all have ways of making our development workflow a little easier and comfortable based on personal preferences.
You may be a seasoned developer and aware of such things as Node, npm, and Git but still find yourself stuck in a Terminal window with a bunch of errors. Or, you might be starting out and find these, and other tools, complex and tough to grasp.
Either way, hopefully knowing more about dotfiles and what theyâre capable of doing gives you a new weapon in your arsenal to make your development environment tailored to you, speed up your workflow and give your machine added superpowers!
As a reminder, my screencast series will give you more tips and tricks, plus a good idea of how to get your development environment set up. This is the first in the series. Going forwards, I'm going to look at expanding on it, so please let me know if there's anything else you'd like me to cover!
The post Using Dotfiles for Managing Development and Many Other Magical Things appeared first on CSS-Tricks.