As developers, we use different apps every day to get the job done. Finding a good tool is worth its weight in gold if it can make you more productive and efficient. Today I'm going to go over some of my favorite tools for MacOS.

<section>

## [1\. Alfred](https://www.alfredapp.com/)

**Price:** free with paid option for expanded customization features (£23.00/~$28.00)

Alfred is a tool I use every day. It has so much packed in that I can't even cover all of it in this post – but investing a little time here to familiarize yourself with Alfred will pay off big time down the road.


![alfred math](/assets/2019/09/Screenshot-2019-09-03-20.03.13-1024x185.png)

Alfred is like spotlight search on steroids – it knows how to do all kinds of useful things like calculating numbers, searching google and your local filesystem and it's incredibly extensible. Alfred has many workflows you can install that the community creates which can add a whole new layer of power to the app with custom code!

![alfred workflow](/assets/2019/09/Screenshot-2019-09-03-20.03.48-1024x544.png)

There are workflows for converting common units like miles and kilometers, opening specific apps with special arguments (for example, opening the terminal in the current finder window) and just about anything else you can think of, since you can write your own workflows in your language of choice.

![alfred create custom workflow](/assets/2019/09/Screenshot-2019-09-02-10.52.10-1024x761.png)

</section>

<section>

## [2\. Rectangle](https://rectangleapp.com/)

**Price:** free 
Rectangle is an open source app from [github user rxhanson](https://github.com/rxhanson)

Rectangle does one thing really well – it organizes your windows with keyboard shortcuts. That's it! here's what that looks like

![spectacle example](/assets/2019/09/spectacle.gif)

Rectangle can even move apps across different monitors!

I've remapped it to use the vim movement keys (h j k l) for super intuitive resizing and movement.

</section>

<section>

## [3\. Sensible Side Buttons](https://sensible-side-buttons.archagon.net/)

**Price:** free

Sensible Side Buttons is an open source app from [github user](https://github.com/archagon) [archagon](https://github.com/archagon)

If you use an external mouse with 'back' and 'forward' buttons, this app makes those buttons work as you would expect in MacOS

<img src="/assets/2019/09/sensible-side-buttons.png" width="250"/>

To ensure SensibleSideButtons opens whenever you start your computer:

1. Go to System Preferences
2. Click Users & Groups
3. Click your username in the left panel
4. Click Login Items at the top
5. Click the plus button at the bottom
6. Go to wherever you put the app (probably your Applications folder) and double-click it

</section>

<section>

## [4\. Quick Look Tools](https://github.com/sindresorhus/quick-look-plugins)

**Price:** free

An open source collection from [github user Sindresorhus](https://github.com/sindresorhus) 
This isn't so much a single app as a series of extensions to the built in MacOX quick look/preview and there's a bunch of really great stuff in here

![json syntax highlighting](/assets/2019/09/Screenshot-2019-09-02-13.06.14-978x1024.png)

- [QLColorCode](https://github.com/anthonygelibert/QLColorCode) – Preview source code files with syntax highlighting
- [QLStephen](https://github.com/whomwah/qlstephen) – Preview plain text files without or with unknown file extension. Example: README, CHANGELOG, index.styl, etc.
- [QLMarkdown](https://github.com/toland/qlmarkdown) – Preview Markdown files
- [QuickLookJSON](http://www.sagtau.com/quicklookjson.html) – Preview JSON files
- [BetterZipQL](https://macitbetter.com/downloads/) – Preview archives Note: The BetterZipQL plugin was integrated with the BetterZip app
- [qlImageSize](https://github.com/Nyx0uf/qlImageSize) – Display image size and resolution
- [Suspicious Package](http://www.mothersruin.com/software/SuspiciousPackage/) – Preview the contents of a standard Apple installer package
- [QuickLookASE](https://github.com/rsodre/QuickLookASE) – Preview Adobe ASE Color Swatches generated with Adobe Photoshop, Adobe Illustrator, [Adobe Color CC](https://color.adobe.com/), [Spectrum](http://www.eigenlogik.com/spectrum/mac), [COLOURlovers](http://www.colourlovers.com/), [Prisma](http://www.codeadventure.com/), among many others
- [QLVideo](https://github.com/Marginal/QLVideo) – Preview most types of video files, as well as their thumbnails, cover art and metadata

</section>

<section>

## [5\. Dozer](https://github.com/Mortennn/Dozer)

**Price:** free

Dozer is an open source app from [github user Mortennn](https://github.com/Mortennn) 
If you run enough apps, the menu bar can get too cluttered to even use – this really kills my productivity when there are so many icons

![an ugly menu bar ](/assets/2019/09/Screenshot-2019-09-02-13.15.38-1024x34.png)

Dozer is a free app that lets you hide all of these icons when you don't need them

![dozer's options menu](/assets/2019/09/Screenshot-2019-09-03-14.12.03.png)

![a beautiful menu bar – good job!](/assets/2019/09/Screenshot-2019-09-03-19.39.02-1024x43.png)

A simple utility that really cleans everything up nicely.

## [](https://github.com/jwilm/alacritty)[](https://github.com/jwilm/alacritty)[](https://github.com/jwilm)[](https://github.com/jwilm/alacritty)[6\. Alacritty](https://github.com/jwilm/alacritty)

**Price:** free

An open source project by [github user jwilm](https://github.com/jwilm) 
I've been a diehard iTerm user for a long time, but Alacritty is obligatory at this point – it's such a good piece of software. There are fewer options and 'fluffy' features than iTerm, but at its core Alacritty is a rock solid blazing fast terminal. It makes tmux and vim (two tools I am incredibly fond of) a pleasure to use with almost no input delay. It also looks great and supports all platforms, something iTerm doesn't even try to do.

![mmmm, terminals](/assets/2019/09/Screenshot-2019-09-03-19.56.29-1024x624.png)

</section>


These are some of the tools I use every day. Please leave a comment or share this post if you found something useful here.

As developers, we use different apps every day to get the job done. Finding a good tool is worth its weight in gold if it can make you more productive and efficient. Today I'm going to go over some of my favorite tools for MacOS.
<section>
<h2><a href="https://www.alfredapp.com/">1. Alfred</a></h2>
Price: free with paid option for expanded customization features (£23.00/~$28.00)
Alfred is a tool I use every day. It has so much packed in that I can't even cover all of it in this post – but investing a little time here to familiarize yourself with Alfred will pay off big time down the road.
<img src="/assets/2019/09/Screenshot-2019-09-03-20.03.13-1024x185.png" alt="alfred math">
Alfred is like spotlight search on steroids – it knows how to do all kinds of useful things like calculating numbers, searching google and your local filesystem and it's incredibly extensible. Alfred has many workflows you can install that the community creates which can add a whole new layer of power to the app with custom code!
<img src="/assets/2019/09/Screenshot-2019-09-03-20.03.48-1024x544.png" alt="alfred workflow">
There are workflows for converting common units like miles and kilometers, opening specific apps with special arguments (for example, opening the terminal in the current finder window) and just about anything else you can think of, since you can write your own workflows in your language of choice.
<img src="/assets/2019/09/Screenshot-2019-09-02-10.52.10-1024x761.png" alt="alfred create custom workflow">
</section>
<section>
<h2><a href="https://rectangleapp.com/">2. Rectangle</a></h2>
Price: free 
Rectangle is an open source app from <a href="https://github.com/rxhanson">github user rxhanson</a>
Rectangle does one thing really well – it organizes your windows with keyboard shortcuts. That's it! here's what that looks like
<img src="/assets/2019/09/spectacle.gif" alt="spectacle example">
Rectangle can even move apps across different monitors!
I've remapped it to use the vim movement keys (h j k l) for super intuitive resizing and movement.
</section>
<section>
<h2><a href="https://sensible-side-buttons.archagon.net/">3. Sensible Side Buttons</a></h2>
Price: free
Sensible Side Buttons is an open source app from <a href="https://github.com/archagon">github user</a> <a href="https://github.com/archagon">archagon</a>
If you use an external mouse with 'back' and 'forward' buttons, this app makes those buttons work as you would expect in MacOS
<img src="/assets/2019/09/sensible-side-buttons.png" width="250"/>
To ensure SensibleSideButtons opens whenever you start your computer:
<ol>
<li>Go to System Preferences</li>
<li>Click Users &#x26; Groups</li>
<li>Click your username in the left panel</li>
<li>Click Login Items at the top</li>
<li>Click the plus button at the bottom</li>
<li>Go to wherever you put the app (probably your Applications folder) and double-click it</li>
</ol>
</section>
<section>
<h2><a href="https://github.com/sindresorhus/quick-look-plugins">4. Quick Look Tools</a></h2>
Price: free
An open source collection from <a href="https://github.com/sindresorhus">github user Sindresorhus</a> 
This isn't so much a single app as a series of extensions to the built in MacOX quick look/preview and there's a bunch of really great stuff in here
<img src="/assets/2019/09/Screenshot-2019-09-02-13.06.14-978x1024.png" alt="json syntax highlighting">
<ul>
<li><a href="https://github.com/anthonygelibert/QLColorCode">QLColorCode</a> – Preview source code files with syntax highlighting</li>
<li><a href="https://github.com/whomwah/qlstephen">QLStephen</a> – Preview plain text files without or with unknown file extension. Example: README, CHANGELOG, index.styl, etc.</li>
<li><a href="https://github.com/toland/qlmarkdown">QLMarkdown</a> – Preview Markdown files</li>
<li><a href="http://www.sagtau.com/quicklookjson.html">QuickLookJSON</a> – Preview JSON files</li>
<li><a href="https://macitbetter.com/downloads/">BetterZipQL</a> – Preview archives Note: The BetterZipQL plugin was integrated with the BetterZip app</li>
<li><a href="https://github.com/Nyx0uf/qlImageSize">qlImageSize</a> – Display image size and resolution</li>
<li><a href="http://www.mothersruin.com/software/SuspiciousPackage/">Suspicious Package</a> – Preview the contents of a standard Apple installer package</li>
<li><a href="https://github.com/rsodre/QuickLookASE">QuickLookASE</a> – Preview Adobe ASE Color Swatches generated with Adobe Photoshop, Adobe Illustrator, <a href="https://color.adobe.com/">Adobe Color CC</a>, <a href="http://www.eigenlogik.com/spectrum/mac">Spectrum</a>, <a href="http://www.colourlovers.com/">COLOURlovers</a>, <a href="http://www.codeadventure.com/">Prisma</a>, among many others</li>
<li><a href="https://github.com/Marginal/QLVideo">QLVideo</a> – Preview most types of video files, as well as their thumbnails, cover art and metadata</li>
</ul>
</section>
<section>
<h2><a href="https://github.com/Mortennn/Dozer">5. Dozer</a></h2>
Price: free
Dozer is an open source app from <a href="https://github.com/Mortennn">github user Mortennn</a> 
If you run enough apps, the menu bar can get too cluttered to even use – this really kills my productivity when there are so many icons
<img src="/assets/2019/09/Screenshot-2019-09-02-13.15.38-1024x34.png" alt="an ugly menu bar ">
Dozer is a free app that lets you hide all of these icons when you don't need them
<img src="/assets/2019/09/Screenshot-2019-09-03-14.12.03.png" alt="dozer&#x27;s options menu">
<img src="/assets/2019/09/Screenshot-2019-09-03-19.39.02-1024x43.png" alt="a beautiful menu bar – good job!">
A simple utility that really cleans everything up nicely.
<h2><a href="https://github.com/jwilm/alacritty"></a><a href="https://github.com/jwilm/alacritty"></a><a href="https://github.com/jwilm"></a><a href="https://github.com/jwilm/alacritty"></a><a href="https://github.com/jwilm/alacritty">6. Alacritty</a></h2>
Price: free
An open source project by <a href="https://github.com/jwilm">github user jwilm</a> 
I've been a diehard iTerm user for a long time, but Alacritty is obligatory at this point – it's such a good piece of software. There are fewer options and 'fluffy' features than iTerm, but at its core Alacritty is a rock solid blazing fast terminal. It makes tmux and vim (two tools I am incredibly fond of) a pleasure to use with almost no input delay. It also looks great and supports all platforms, something iTerm doesn't even try to do.
<img src="/assets/2019/09/Screenshot-2019-09-03-19.56.29-1024x624.png" alt="mmmm, terminals">
</section>
These are some of the tools I use every day. Please leave a comment or share this post if you found something useful here.

As developers, we use different apps every day to get the job done. Finding a good tool is worth its weight in gold if it can make you more productive and efficient. Today I'm going to go over some of my favorite tools for MacOS. 1\. Alfred Price: free with paid option for expanded customization features (£23.00/~$28.00) Alfred is a tool I use every day. It has so much packed in that I can't even cover all of it in this post – but investing a little time here to familiarize yourself with Alfred will pay off big time down the road. alfred math Alfred is like spotlight search on steroids – it knows how to do all kinds of useful things like calculating numbers, searching google and your local filesystem and it's incredibly extensible. Alfred has many workflows you can install that the community creates which can add a whole new layer of power to the app with custom code! alfred workflow There are workflows for converting common units like miles and kilometers, opening specific apps with special arguments (for example, opening the terminal in the current finder window) and just about anything else you can think of, since you can write your own workflows in your language of choice. alfred create custom workflow 2\. Rectangle Price: free Rectangle is an open source app from github user rxhanson Rectangle does one thing really well – it organizes your windows with keyboard shortcuts. That's it! here's what that looks like spectacle example Rectangle can even move apps across different monitors! I've remapped it to use the vim movement keys (h j k l) for super intuitive resizing and movement. 3\. Sensible Side Buttons Price: free Sensible Side Buttons is an open source app from github user archagon If you use an external mouse with 'back' and 'forward' buttons, this app makes those buttons work as you would expect in MacOS To ensure SensibleSideButtons opens whenever you start your computer: Go to System Preferences Click Users & Groups Click your username in the left panel Click Login Items at the top Click the plus button at the bottom Go to wherever you put the app (probably your Applications folder) and double-click it 4\. Quick Look Tools Price: free An open source collection from github user Sindresorhus This isn't so much a single app as a series of extensions to the built in MacOX quick look/preview and there's a bunch of really great stuff in here json syntax highlighting QLColorCode – Preview source code files with syntax highlighting QLStephen – Preview plain text files without or with unknown file extension. Example: README, CHANGELOG, index.styl, etc. QLMarkdown – Preview Markdown files QuickLookJSON – Preview JSON files BetterZipQL – Preview archives Note: The BetterZipQL plugin was integrated with the BetterZip app qlImageSize – Display image size and resolution Suspicious Package – Preview the contents of a standard Apple installer package QuickLookASE – Preview Adobe ASE Color Swatches generated with Adobe Photoshop, Adobe Illustrator, Adobe Color CC, Spectrum, COLOURlovers, Prisma, among many others QLVideo – Preview most types of video files, as well as their thumbnails, cover art and metadata 5\. Dozer Price: free Dozer is an open source app from github user Mortennn If you run enough apps, the menu bar can get too cluttered to even use – this really kills my productivity when there are so many icons an ugly menu bar Dozer is a free app that lets you hide all of these icons when you don't need them dozer's options menu a beautiful menu bar – good job! A simple utility that really cleans everything up nicely. 6\. Alacritty Price: free An open source project by github user jwilm I've been a diehard iTerm user for a long time, but Alacritty is obligatory at this point – it's such a good piece of software. There are fewer options and 'fluffy' features than iTerm, but at its core Alacritty is a rock solid blazing fast terminal. It makes tmux and vim (two tools I am incredibly fond of) a pleasure to use with almost no input delay. It also looks great and supports all platforms, something iTerm doesn't even try to do. mmmm, terminals These are some of the tools I use every day. Please leave a comment or share this post if you found something useful here.

Top Apps for Productivity in MacOS

If you are a developer, you probably spend a decent chunk of time interacting with a terminal Shell. Today We'll look at 6 different tools that will make your work that much easier!

## [1\. Ripgrep](https://github.com/BurntSushi/ripgrep)

You've probably used grep before – it's one of the most ubiquitous tools in any devs toolbelt, and it gets the job done.

But what if there was something even better? Ripgrep is purpose-built for searching over large amounts of files recursively. It knows how to read your .gitignore file and automatically skips hidden files/directories as well as binary files.

Ripgrep is supported on all major operating systems! There are binaries available for every release. it's also 2-5 times faster than other searching tools – they have benchmarks listed on [their github repo](https://github.com/BurntSushi/ripgrep).

Enough about Ripgrep, let's give it a whirl:

```bash
# Recursively search the current directory for a regex pattern:
rg pattern

# Search for pattern including all .gitignored and hidden files:
rg -uu pattern

# Search for a pattern only in a certain filetype (e.g., html, css, etc.):
rg -t filetype pattern

# Search for a pattern only in a subset of directories:
rg pattern set_of_subdirs

# Search for a pattern in files matching a glob (e.g., `README.*`):
rg pattern -g glob

# Only list matched files -- useful when piping to other commands:
rg --files-with-matches pattern

# Show lines that do not match the given pattern:
rg --invert-match pattern
```

## [2\. Bat](https://github.com/sharkdp/bat)

![](/assets/2019/08/Screenshot-2019-08-26-19.23.29.png)

A `cat` clone with syntax highlighting and Git integration.

`bat` supports syntax highlighting for a large number of programming and markup languages such as markdown 
`bat` is  `git` aware, and can show modified lines as well

![](/assets/2019/08/Screenshot-2019-08-26-19.28.27-1024x256.png)

Bat also has a super nice feature where if the output is too large for the screen, it will smartly pipe its output to your default pager (probably `less` unless you changed this yourself)

```bash
# Print the contents of a file to the standard output:
bat file

# Concatenate several files into the target file:
bat file1 file2 > target_file

# Append several files into the target file:
bat file1 file2 >> target_file

# Number all output lines:
bat -n file

# Syntax highlight a json file:
bat --language json file.json

# Display all supported languages:
bat --list-languages
```

## [3\. Exa](https://the.exa.website/)

`exa` is a modern replacement for the command-line program `ls` that ships with \*nix operating systems.

`exa` has more features and better defaults – It uses colour to distinguish files and metadata. It understands symlinks, extended attributes, and Git. And it’s small, fast, and contained within a single binary.

![](/assets/2019/08/Screenshot-2019-08-27-17.28.15-1024x413.png)

`exa -glam --group-directories-first`

exa is a nice drop-in replacement for the default ls command. I've set an alias for it

```bash
alias ls="exa -glam --group-directories-first"
```

## [4\. JQ](https://stedolan.github.io/jq/)

jq is like `sed` for JSON data - you can use it to slice, filter, map and transform structured data with the same ease that `sed`, `awk`, `grep` and friends let you play with text in the shell.

```bash
# list all of the commands under the 'scripts' key in package.json
jq '.scripts' package.json
```

```bash
# Output a JSON file, in pretty-print format:
jq . file.json

# Output all elements from arrays (or all key-value pairs from objects) in a JSON file:
jq '.[]' file.json

# Read JSON objects from a file into an array, and output it (inverse of `jq .[]`):
jq --slurp . file.json

# Output the first element in a JSON file:
jq '.[0]' file.json

# Output the value of a given key of the first element in a JSON text from `stdin`:
cat file.json | jq '.[0].key_name'

# Output the value of a given key of each element in a JSON text from `stdin`:
cat file.json | jq 'map(.key_name)'

# Combine multiple filters:
cat file.json | jq 'unique | sort | reverse'

# Output the value of a given key to a string (and disable JSON output):
cat file.json | jq --raw-output '"some text: \(.key_name)"'
```

## [5\. Hub](https://hub.github.com/)

`hub` is a command line tool that wraps `git` in order to extend it with extra features and commands that make working with GitHub easier.

`hub` can be safely aliased as `git` so you can type `$ git <command>` in the shell and get all the usual `hub` features.

One of the things hub does that I love, is provide a clickable url to create a PR in your terminal when you push to a remote repository!

```bash
# Clone a repository you own, using just the repository name rather than the full URL:
hub clone repo_name

# Clone another user's repository, using their github username and the repository name:
hub clone username/repo_name

# Create a fork of the current repository (cloned from another user) under your github profile:
hub fork

# Push the current local branch to github and create a PR for it in the original repository:
hub push remote_name && hub pull-request

# Create a PR of the current (already pushed) branch, reusing the message from the first commit:
hub pull-request --no-edit

# Create a new branch with the contents of a pull request and switch to it:
hub pr checkout pr_number

# Upload the current (local-only) repository to your github account:
hub create
```

## [6\. FZF](https://github.com/junegunn/fzf)

fzf is a general-purpose fuzzy finder for your terminal shell.

It can be used with any list; files, command history, processes, hostnames, bookmarks, git commits, etc.

FZF is Portable and has no dependencies, is Blazingly fast and provides a flexible layout. 
It also has some really great features out of the box such as Vim/Neovim plugins, key bindings and fuzzy auto-complete.

By default FZF runs in 'full-screen' mode, but you can pass flags to resize and change the layout

```bash
# handy function to search for a file, with a nice preview window!
select_file() {
	given_file="$1"
	fzf --preview="cat {}" --preview-window=right:70%:wrap --query="$given_file"
}

# open a fuzzy searched file with vim
vim $(select_file)

# Start finder on all files from arbitrary locations:
find path/to/search -type f | fzf

# Start finder on running processes:
ps aux | fzf

# Select multiple files with `Shift + Tab` and write to a file:
find path/to/search_files -type f | fzf -m > filename

# Start finder with a given query:
fzf -q "query"

# Start finder on entries that start with core and end with either go, rb, or py:
fzf -q "^core go$ | rb$ | py$"

# Start finder on entries that not match pyc and match exactly travis:
fzf -q "!pyc 'travis"

```

Hopefully you find some of these shell tools as useful as I do, please leave a comment and share the article if you found it useful!

If you are a developer, you probably spend a decent chunk of time interacting with a terminal Shell. Today We'll look at 6 different tools that will make your work that much easier!
<h2><a href="https://github.com/BurntSushi/ripgrep">1. Ripgrep</a></h2>
You've probably used grep before – it's one of the most ubiquitous tools in any devs toolbelt, and it gets the job done.
But what if there was something even better? Ripgrep is purpose-built for searching over large amounts of files recursively. It knows how to read your .gitignore file and automatically skips hidden files/directories as well as binary files.
Ripgrep is supported on all major operating systems! There are binaries available for every release. it's also 2-5 times faster than other searching tools – they have benchmarks listed on <a href="https://github.com/BurntSushi/ripgrep">their github repo</a>.
Enough about Ripgrep, let's give it a whirl:
<pre><code class="hljs language-bash"># Recursively search the current directory for a regex pattern:
rg pattern

# Search for pattern including all .gitignored and hidden files:
rg -uu pattern

# Search for a pattern only in a certain filetype (e.g., html, css, etc.):
rg -t filetype pattern

# Search for a pattern only in a subset of directories:
rg pattern set_of_subdirs

# Search for a pattern in files matching a glob (e.g., `README.*`):
rg pattern -g glob

# Only list matched files -- useful when piping to other commands:
rg --files-with-matches pattern

# Show lines that do not match the given pattern:
rg --invert-match pattern</code></pre>
<h2><a href="https://github.com/sharkdp/bat">2. Bat</a></h2>
<img src="/assets/2019/08/Screenshot-2019-08-26-19.23.29.png">
A <code>cat</code> clone with syntax highlighting and Git integration.
<code>bat</code> supports syntax highlighting for a large number of programming and markup languages such as markdown 
<code>bat</code> is  <code>git</code> aware, and can show modified lines as well
<img src="/assets/2019/08/Screenshot-2019-08-26-19.28.27-1024x256.png">
Bat also has a super nice feature where if the output is too large for the screen, it will smartly pipe its output to your default pager (probably <code>less</code> unless you changed this yourself)
<pre><code class="hljs language-bash"># Print the contents of a file to the standard output:
bat file

# Concatenate several files into the target file:
bat file1 file2 > target_file

# Append several files into the target file:
bat file1 file2 >> target_file

# Number all output lines:
bat -n file

# Syntax highlight a json file:
bat --language json file.json

# Display all supported languages:
bat --list-languages</code></pre>
<h2><a href="https://the.exa.website/">3. Exa</a></h2>
<code>exa</code> is a modern replacement for the command-line program <code>ls</code> that ships with *nix operating systems.
<code>exa</code> has more features and better defaults – It uses colour to distinguish files and metadata. It understands symlinks, extended attributes, and Git. And it’s small, fast, and contained within a single binary.
<img src="/assets/2019/08/Screenshot-2019-08-27-17.28.15-1024x413.png">
<code>exa -glam --group-directories-first</code>
exa is a nice drop-in replacement for the default ls command. I've set an alias for it
<pre><code class="hljs language-bash">alias ls="exa -glam --group-directories-first"</code></pre>
<h2><a href="https://stedolan.github.io/jq/">4. JQ</a></h2>
jq is like <code>sed</code> for JSON data - you can use it to slice, filter, map and transform structured data with the same ease that <code>sed</code>, <code>awk</code>, <code>grep</code> and friends let you play with text in the shell.
<pre><code class="hljs language-bash"># list all of the commands under the 'scripts' key in package.json
jq '.scripts' package.json</code></pre>
<pre><code class="hljs language-bash"># Output a JSON file, in pretty-print format:
jq . file.json

# Output all elements from arrays (or all key-value pairs from objects) in a JSON file:
jq '.[]' file.json

# Read JSON objects from a file into an array, and output it (inverse of `jq .[]`):
jq --slurp . file.json

# Output the first element in a JSON file:
jq '.[0]' file.json

# Output the value of a given key of the first element in a JSON text from `stdin`:
cat file.json | jq '.[0].key_name'

# Output the value of a given key of each element in a JSON text from `stdin`:
cat file.json | jq 'map(.key_name)'

# Combine multiple filters:
cat file.json | jq 'unique | sort | reverse'

# Output the value of a given key to a string (and disable JSON output):
cat file.json | jq --raw-output '"some text: \(.key_name)"'</code></pre>
<h2><a href="https://hub.github.com/">5. Hub</a></h2>
<code>hub</code> is a command line tool that wraps <code>git</code> in order to extend it with extra features and commands that make working with GitHub easier.
<code>hub</code> can be safely aliased as <code>git</code> so you can type <code>$ git &#x3C;command></code> in the shell and get all the usual <code>hub</code> features.
One of the things hub does that I love, is provide a clickable url to create a PR in your terminal when you push to a remote repository!
<pre><code class="hljs language-bash"># Clone a repository you own, using just the repository name rather than the full URL:
hub clone repo_name

# Clone another user's repository, using their github username and the repository name:
hub clone username/repo_name

# Create a fork of the current repository (cloned from another user) under your github profile:
hub fork

# Push the current local branch to github and create a PR for it in the original repository:
hub push remote_name &#x26;&#x26; hub pull-request

# Create a PR of the current (already pushed) branch, reusing the message from the first commit:
hub pull-request --no-edit

# Create a new branch with the contents of a pull request and switch to it:
hub pr checkout pr_number

# Upload the current (local-only) repository to your github account:
hub create</code></pre>
<h2><a href="https://github.com/junegunn/fzf">6. FZF</a></h2>
fzf is a general-purpose fuzzy finder for your terminal shell.
It can be used with any list; files, command history, processes, hostnames, bookmarks, git commits, etc.
FZF is Portable and has no dependencies, is Blazingly fast and provides a flexible layout. 
It also has some really great features out of the box such as Vim/Neovim plugins, key bindings and fuzzy auto-complete.
By default FZF runs in 'full-screen' mode, but you can pass flags to resize and change the layout
<pre><code class="hljs language-bash"># handy function to search for a file, with a nice preview window!
select_file() {
	given_file="$1"
	fzf --preview="cat {}" --preview-window=right:70%:wrap --query="$given_file"
}

# open a fuzzy searched file with vim
vim $(select_file)

# Start finder on all files from arbitrary locations:
find path/to/search -type f | fzf

# Start finder on running processes:
ps aux | fzf

# Select multiple files with `Shift + Tab` and write to a file:
find path/to/search_files -type f | fzf -m > filename

# Start finder with a given query:
fzf -q "query"

# Start finder on entries that start with core and end with either go, rb, or py:
fzf -q "^core go$ | rb$ | py$"

# Start finder on entries that not match pyc and match exactly travis:
fzf -q "!pyc 'travis"
</code></pre>
Hopefully you find some of these shell tools as useful as I do, please leave a comment and share the article if you found it useful!

If you are a developer, you probably spend a decent chunk of time interacting with a terminal Shell. Today We'll look at 6 different tools that will make your work that much easier! 1\. Ripgrep You've probably used grep before – it's one of the most ubiquitous tools in any devs toolbelt, and it gets the job done. But what if there was something even better? Ripgrep is purpose-built for searching over large amounts of files recursively. It knows how to read your .gitignore file and automatically skips hidden files/directories as well as binary files. Ripgrep is supported on all major operating systems! There are binaries available for every release. it's also 2-5 times faster than other searching tools – they have benchmarks listed on their github repo. Enough about Ripgrep, let's give it a whirl: Recursively search the current directory for a regex pattern: rg pattern Search for pattern including all .gitignored and hidden files: rg -uu pattern Search for a pattern only in a certain filetype (e.g., html, css, etc.): rg -t filetype pattern Search for a pattern only in a subset of directories: rg pattern setofsubdirs Search for a pattern in files matching a glob (e.g., README.*): rg pattern -g glob Only list matched files -- useful when piping to other commands: rg --files-with-matches pattern Show lines that do not match the given pattern: rg --invert-match pattern 2\. Bat A cat clone with syntax highlighting and Git integration. bat supports syntax highlighting for a large number of programming and markup languages such as markdown bat is git aware, and can show modified lines as well Bat also has a super nice feature where if the output is too large for the screen, it will smartly pipe its output to your default pager (probably less unless you changed this yourself) Print the contents of a file to the standard output: bat file Concatenate several files into the target file: bat file1 file2 > target_file Append several files into the target file: bat file1 file2 >> target_file Number all output lines: bat -n file Syntax highlight a json file: bat --language json file.json Display all supported languages: bat --list-languages 3\. Exa exa is a modern replacement for the command-line program ls that ships with \*nix operating systems. exa has more features and better defaults – It uses colour to distinguish files and metadata. It understands symlinks, extended attributes, and Git. And it’s small, fast, and contained within a single binary. exa -glam --group-directories-first exa is a nice drop-in replacement for the default ls command. I've set an alias for it alias ls="exa -glam --group-directories-first" 4\. JQ jq is like sed for JSON data - you can use it to slice, filter, map and transform structured data with the same ease that sed, awk, grep and friends let you play with text in the shell. list all of the commands under the 'scripts' key in package.json jq '.scripts' package.json Output a JSON file, in pretty-print format: jq . file.json Output all elements from arrays (or all key-value pairs from objects) in a JSON file: jq '.[]' file.json Read JSON objects from a file into an array, and output it (inverse of jq .[]): jq --slurp . file.json Output the first element in a JSON file: jq '.[0]' file.json Output the value of a given key of the first element in a JSON text from stdin: cat file.json | jq '.[0].key_name' Output the value of a given key of each element in a JSON text from stdin: cat file.json | jq 'map(.key_name)' Combine multiple filters: cat file.json | jq 'unique | sort | reverse' Output the value of a given key to a string (and disable JSON output): cat file.json | jq --raw-output '"some text: \(.key_name)"' 5\. Hub hub is a command line tool that wraps git in order to extend it with extra features and commands that make working with GitHub easier. hub can be safely aliased as git so you can type $ git in the shell and get all the usual hub features. One of the things hub does that I love, is provide a clickable url to create a PR in your terminal when you push to a remote repository! Clone a repository you own, using just the repository name rather than the full URL: hub clone repo_name Clone another user's repository, using their github username and the repository name: hub clone username/repo_name Create a fork of the current repository (cloned from another user) under your github profile: hub fork Push the current local branch to github and create a PR for it in the original repository: hub push remote_name && hub pull-request Create a PR of the current (already pushed) branch, reusing the message from the first commit: hub pull-request --no-edit Create a new branch with the contents of a pull request and switch to it: hub pr checkout pr_number Upload the current (local-only) repository to your github account: hub create 6\. FZF fzf is a general-purpose fuzzy finder for your terminal shell. It can be used with any list; files, command history, processes, hostnames, bookmarks, git commits, etc. FZF is Portable and has no dependencies, is Blazingly fast and provides a flexible layout. It also has some really great features out of the box such as Vim/Neovim plugins, key bindings and fuzzy auto-complete. By default FZF runs in 'full-screen' mode, but you can pass flags to resize and change the layout handy function to search for a file, with a nice preview window! select_file() { given_file="$1" fzf --preview="cat {}" --preview-window=right:70%:wrap --query="$given_file" } open a fuzzy searched file with vim vim $(select_file) Start finder on all files from arbitrary locations: find path/to/search -type f | fzf Start finder on running processes: ps aux | fzf Select multiple files with Shift + Tab and write to a file: find path/to/search_files -type f | fzf -m > filename Start finder with a given query: fzf -q "query" Start finder on entries that start with core and end with either go, rb, or py: fzf -q "^core go$ | rb$ | py$" Start finder on entries that not match pyc and match exactly travis: fzf -q "!pyc 'travis" Hopefully you find some of these shell tools as useful as I do, please leave a comment and share the article if you found it useful!

6 Useful Shell Utilities to Make You More Productive


Readline is a tool you've probably used many times without even noticing - it's the default text interface for most terminals in [\*nix based operating systems](https://en.wikipedia.org/wiki/Unix-like)! Any time you type stuff into a terminal prompt, you're using Readline!

A little known fact is that Readline comes configured out-of-the-box with some extremely useful commands and shortcuts. Today we will examine some of those shortcuts and do some customization of our own.

## The Basics

Readline's default function is to enter text. You do this simply by typing commands into the terminal:

```bash
➜  ~ ls         
bin        Desktop  Music     projects
Documents  org      Public    Templates
Downloads  go	    Pictures  Videos

```

Whatever you type appears where the cursor was and the cursor advances to the right. If you mistype characters you can erase them with backspace. But this is not where Readline ends!

## A technical note for MacOS users

MacOS has a 'feature' where the alt/option key does not work as expected in the terminal. it will output funky characters instead of running the desired command. Depending on your terminal, you will need to set an option to enable the legacy keycodes to work correctly.

![](/assets/2019/08/iterm-config-1024x572.png)

iTerm 2

![](/assets/2019/08/terminal-config-1024x904.png)

Terminal app (default MacOS terminal)

## Movement Commands 🏃

Readline comes with a handful of useful shortcuts for us to use. The table below lists each shortcut and what it does.

Shortcut

What it does

`ctrl-a`

Move to the start of the line

`ctrl-e`

Move to the end of the line

`alt-f`

Move forward one word

`alt-b`

Move backward one word

`ctrl-f`

Move forward one character

`ctrl-b`

Move backward one character

`ctrl-d`

delete the character under the cursor

Here are some examples of these commands in action

![](/assets/2019/08/Large-GIF-508x130.gif)

ctrl-a and ctrl-e

![](/assets/2019/08/Large-GIF-480x122.gif)

alt-b and alt-f

## Killing Commands ✋

Killing in the context of Readline means to delete that text and save it in a buffer for later use (very similar to the standard `ctrl/cmd-x` cut command other text editors have)

When you use a 'kill' command, Readline saves the 'killed' text in a 'kill-ring' (you can think of this as a circular array) Any number of consecutive kills are combined, so that when you yank it back, you get it all. The kill ring is also not line specific - the text that you killed on a previous line is available to be yanked back later, when you are typing another line.

**Note:** _'Cut' and 'Paste' are a more user friendly way to say 'kill' and 'yank'_

If a command listed in the following table says that it 'kills' something, we know that means we can get it back later!

Command Shortcut

What it does

`ctrl-k`

kill the text from the current cursor position to the end of the line

`alt-d`

kill from the cursor to the end of the current word, or, if between words, to the end of the next word

`alt-DEL`

Kill from the cursor to the start of the current word, or, if between words, to the start of the previous word

`ctrl-w`

Kill from the cursor to the previous whitespace

`ctrl-y`

Yank the most recently killed text back into the buffer at the cursor

`alt-y`

rotate the kill-ring, and yank the new top to the buffer at the cursor. This will only work if your prior command was `ctrl-y` or `alt-y`

* * *

## Searching for previous commands in history

You probably already know you can use the history command to list commands you've typed in the past:

```bash
➜  ~ history
1 ls
2 cd ~
```

But did you know you can search history easily with Readline?

press `ctrl-r` to search backwards in history, and `ctrl-s` to search forward.

![](/assets/2019/08/Large-GIF-484x122.gif)

search back in history

## Readline configuration

Readline comes configured out-of-the-box to use a set of Emacs-like keybinds as we've highlighted above. But what if we want to change those?

Readline is configurable through a `.inputrc` file – by convention it will look for this file in your home directory ~

```bash
➜  ~ touch .inputrc
```

If that file does not exist or cannot be read, the ultimate default is `/etc/inputrc` (we should not edit that file though!)

There are only a few basic constructs allowed in the Readline init file – The syntax is as follows:

- Blank lines are ignored
- Lines beginning with a `#` are comments
- Lines beginning with a `$` indicate conditional constructs (see the [Readline docs](https://tiswww.case.edu/php/chet/readline/rluserman.html#SEC11) for specifics)
- Other lines denote variables and key bindings

changing the configuration is done by setting specific variables in this file. Let's change readline to use vim keybinds!

```bash
// in .inputrc

set editing-mode vi

```

Now we need to add a line to our `~/.bash_profile` or it's equivalent if we are using another shell such as `~/.zshrc`

```bash
echo "set -o vi" >> ~/.bash_profile
source ~/.bash_profile
```

We should now have working vi commands in Readline! Check it out:

![](/assets/2019/08/Large-GIF-766x296.gif)

Vastly improved search

Vi commands in Readline

I hope you learned something from this article – there's lots more you can configure in readline that I did not cover here! [Check out the full documentation here](https://tiswww.case.edu/php/chet/readline/rluserman.html#SEC_Top)


Readline is a tool you've probably used many times without even noticing - it's the default text interface for most terminals in <a href="https://en.wikipedia.org/wiki/Unix-like">*nix based operating systems</a>! Any time you type stuff into a terminal prompt, you're using Readline!
A little known fact is that Readline comes configured out-of-the-box with some extremely useful commands and shortcuts. Today we will examine some of those shortcuts and do some customization of our own.
<h2>The Basics</h2>
Readline's default function is to enter text. You do this simply by typing commands into the terminal:
<pre><code class="hljs language-bash">➜ ~ ls 
bin Desktop Music projects
Documents org Public Templates
Downloads go	 Pictures Videos
</code></pre>
Whatever you type appears where the cursor was and the cursor advances to the right. If you mistype characters you can erase them with backspace. But this is not where Readline ends!
<h2>A technical note for MacOS users</h2>
MacOS has a 'feature' where the alt/option key does not work as expected in the terminal. it will output funky characters instead of running the desired command. Depending on your terminal, you will need to set an option to enable the legacy keycodes to work correctly.
<img src="/assets/2019/08/iterm-config-1024x572.png">
iTerm 2
<img src="/assets/2019/08/terminal-config-1024x904.png">
Terminal app (default MacOS terminal)
<h2>Movement Commands 🏃</h2>
Readline comes with a handful of useful shortcuts for us to use. The table below lists each shortcut and what it does.
Shortcut
What it does
<code>ctrl-a</code>
Move to the start of the line
<code>ctrl-e</code>
Move to the end of the line
<code>alt-f</code>
Move forward one word
<code>alt-b</code>
Move backward one word
<code>ctrl-f</code>
Move forward one character
<code>ctrl-b</code>
Move backward one character
<code>ctrl-d</code>
delete the character under the cursor
Here are some examples of these commands in action
<img src="/assets/2019/08/Large-GIF-508x130.gif">
ctrl-a and ctrl-e
<img src="/assets/2019/08/Large-GIF-480x122.gif">
alt-b and alt-f
<h2>Killing Commands ✋</h2>
Killing in the context of Readline means to delete that text and save it in a buffer for later use (very similar to the standard <code>ctrl/cmd-x</code> cut command other text editors have)
When you use a 'kill' command, Readline saves the 'killed' text in a 'kill-ring' (you can think of this as a circular array) Any number of consecutive kills are combined, so that when you yank it back, you get it all. The kill ring is also not line specific - the text that you killed on a previous line is available to be yanked back later, when you are typing another line.
Note: 'Cut' and 'Paste' are a more user friendly way to say 'kill' and 'yank'
If a command listed in the following table says that it 'kills' something, we know that means we can get it back later!
Command Shortcut
What it does
<code>ctrl-k</code>
kill the text from the current cursor position to the end of the line
<code>alt-d</code>
kill from the cursor to the end of the current word, or, if between words, to the end of the next word
<code>alt-DEL</code>
Kill from the cursor to the start of the current word, or, if between words, to the start of the previous word
<code>ctrl-w</code>
Kill from the cursor to the previous whitespace
<code>ctrl-y</code>
Yank the most recently killed text back into the buffer at the cursor
<code>alt-y</code>
rotate the kill-ring, and yank the new top to the buffer at the cursor. This will only work if your prior command was <code>ctrl-y</code> or <code>alt-y</code>
<hr>
<h2>Searching for previous commands in history</h2>
You probably already know you can use the history command to list commands you've typed in the past:
<pre><code class="hljs language-bash">➜ ~ history
1 ls
2 cd ~</code></pre>
But did you know you can search history easily with Readline?
press <code>ctrl-r</code> to search backwards in history, and <code>ctrl-s</code> to search forward.
<img src="/assets/2019/08/Large-GIF-484x122.gif">
search back in history
<h2>Readline configuration</h2>
Readline comes configured out-of-the-box to use a set of Emacs-like keybinds as we've highlighted above. But what if we want to change those?
Readline is configurable through a <code>.inputrc</code> file – by convention it will look for this file in your home directory ~
<pre><code class="hljs language-bash">➜ ~ touch .inputrc</code></pre>
If that file does not exist or cannot be read, the ultimate default is <code>/etc/inputrc</code> (we should not edit that file though!)
There are only a few basic constructs allowed in the Readline init file – The syntax is as follows:
<ul>
<li>Blank lines are ignored</li>
<li>Lines beginning with a <code>#</code> are comments</li>
<li>Lines beginning with a <code>$</code> indicate conditional constructs (see the <a href="https://tiswww.case.edu/php/chet/readline/rluserman.html#SEC11">Readline docs</a> for specifics)</li>
<li>Other lines denote variables and key bindings</li>
</ul>
changing the configuration is done by setting specific variables in this file. Let's change readline to use vim keybinds!
<pre><code class="hljs language-bash">// in .inputrc

set editing-mode vi
</code></pre>
Now we need to add a line to our <code>~/.bash_profile</code> or it's equivalent if we are using another shell such as <code>~/.zshrc</code>
<pre><code class="hljs language-bash">echo "set -o vi" >> ~/.bash_profile
source ~/.bash_profile</code></pre>
We should now have working vi commands in Readline! Check it out:
<img src="/assets/2019/08/Large-GIF-766x296.gif">
Vastly improved search
Vi commands in Readline
I hope you learned something from this article – there's lots more you can configure in readline that I did not cover here! <a href="https://tiswww.case.edu/php/chet/readline/rluserman.html#SEC_Top">Check out the full documentation here</a>

Readline is a tool you've probably used many times without even noticing - it's the default text interface for most terminals in \*nix based operating systems! Any time you type stuff into a terminal prompt, you're using Readline! A little known fact is that Readline comes configured out-of-the-box with some extremely useful commands and shortcuts. Today we will examine some of those shortcuts and do some customization of our own. The Basics Readline's default function is to enter text. You do this simply by typing commands into the terminal: ➜ ~ ls bin Desktop Music projects Documents org Public Templates Downloads go Pictures Videos Whatever you type appears where the cursor was and the cursor advances to the right. If you mistype characters you can erase them with backspace. But this is not where Readline ends! A technical note for MacOS users MacOS has a 'feature' where the alt/option key does not work as expected in the terminal. it will output funky characters instead of running the desired command. Depending on your terminal, you will need to set an option to enable the legacy keycodes to work correctly. iTerm 2 Terminal app (default MacOS terminal) Movement Commands 🏃 Readline comes with a handful of useful shortcuts for us to use. The table below lists each shortcut and what it does. Shortcut What it does ctrl-a Move to the start of the line ctrl-e Move to the end of the line alt-f Move forward one word alt-b Move backward one word ctrl-f Move forward one character ctrl-b Move backward one character ctrl-d delete the character under the cursor Here are some examples of these commands in action ctrl-a and ctrl-e alt-b and alt-f Killing Commands ✋ Killing in the context of Readline means to delete that text and save it in a buffer for later use (very similar to the standard ctrl/cmd-x cut command other text editors have) When you use a 'kill' command, Readline saves the 'killed' text in a 'kill-ring' (you can think of this as a circular array) Any number of consecutive kills are combined, so that when you yank it back, you get it all. The kill ring is also not line specific - the text that you killed on a previous line is available to be yanked back later, when you are typing another line. Note: 'Cut' and 'Paste' are a more user friendly way to say 'kill' and 'yank' If a command listed in the following table says that it 'kills' something, we know that means we can get it back later! Command Shortcut What it does ctrl-k kill the text from the current cursor position to the end of the line alt-d kill from the cursor to the end of the current word, or, if between words, to the end of the next word alt-DEL Kill from the cursor to the start of the current word, or, if between words, to the start of the previous word ctrl-w Kill from the cursor to the previous whitespace ctrl-y Yank the most recently killed text back into the buffer at the cursor alt-y rotate the kill-ring, and yank the new top to the buffer at the cursor. This will only work if your prior command was ctrl-y or alt-y Searching for previous commands in history You probably already know you can use the history command to list commands you've typed in the past: ➜ ~ history 1 ls 2 cd ~ But did you know you can search history easily with Readline? press ctrl-r to search backwards in history, and ctrl-s to search forward. search back in history Readline configuration Readline comes configured out-of-the-box to use a set of Emacs-like keybinds as we've highlighted above. But what if we want to change those? Readline is configurable through a .inputrc file – by convention it will look for this file in your home directory ~ ➜ ~ touch .inputrc If that file does not exist or cannot be read, the ultimate default is /etc/inputrc (we should not edit that file though!) There are only a few basic constructs allowed in the Readline init file – The syntax is as follows: Blank lines are ignored Lines beginning with a # are comments Lines beginning with a $ indicate conditional constructs (see the Readline docs for specifics) Other lines denote variables and key bindings changing the configuration is done by setting specific variables in this file. Let's change readline to use vim keybinds! // in .inputrc set editing-mode vi Now we need to add a line to our ~/.bash_profile or it's equivalent if we are using another shell such as ~/.zshrc echo "set -o vi" >> ~/.bash_profile source ~/.bash_profile We should now have working vi commands in Readline! Check it out: Vastly improved search Vi commands in Readline I hope you learned something from this article – there's lots more you can configure in readline that I did not cover here! Check out the full documentation here

Latest Posts

Top Apps for Productivity in MacOS

6 Useful Shell Utilities to Make You More Productive

Using Readline like a pro