Visualize different pathfinding algorithms

Pathfinding Algorithm Visualizer


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. 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! 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 \*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

Using Readline like a pro


At some point in your career, it's likely you'll need to write scripts for the command line – there are cases where it makes sense to use vanilla bash scripting for this and that will usually work just fine for simple tasks like renaming things and deleting folders.

If you're anything like me though, it's much more enjoyable and productive to write these tools in a familiar language like Javascript, or even better – Typescript.

You get all the niceties of a modern language without any of the weird gotchas of bash and terminal syntax/behaviour.

In this article I'll cover a simple method for writing command line scripts in Typescript.

So! First things first. we need to create a directory where our scripts will live.

If you're on a mac or linux machine, I recommend creating a directory in your `home` folder `~` simply called `scripts`.

Within this folder we'll create a file called `hello-world.ts` and globally install our 2 required dependencies (If you haven’t already, download and install [node](https://nodejs.org/), but you probably knew that!)

```bash
mkdir ~/scripts && cd ~/scripts
npm i -g typescript ts-node
tsc --init
touch hello-world.ts
```

[Learn about the handy npm shortcuts above](https://codinal.co/npm-tips-and-tricks-to-make-your-life-easier/)

Note: If you know of a clean way to do this without  
globally installing ts-node and typescript, I'd love to hear about it!

Now we can place the following code in our `hello-world.ts` file

```typescript
#!/bin/sh 
":" //#; exec /usr/bin/env ts-node -P ~/scripts/tsconfig.json "$0" "$@"

console.log('Hello, World!');
```

Credit to [Sam over at sambal.org for this clever shebang trick](http://sambal.org/2014/02/passing-options-node-shebang-line/)

Finally, we need to make this file executable with `chmod`

```bash
chmod +x hello-world.ts
```

And now we can run it!

```bash
./hello-world.ts
Hello, World!
```

Note: You may see an error from ts-node about an unrecognized  
option 'esModuleInterop' – if this happens to you, you can simply  
remove that line from `~/scripts/tsconfig.json`

* * *

So far we've created our scripts directory where our scripts will live, installed the required dependencies to run them and set up a simple script to get us started.

Next we'll do some housekeeping to make our lives easier as our library of scripts grows over time.

One of the first things I do when I write a new script is create an alias to run it – I'll assume we're all running bash, but if you're using zsh or some other shell the steps here will be very similar.

First we'll edit our .bashrc to add an alias for our new script

```bash
echo "alias hello_world='~/scripts/hello-world.ts'" >> ~/.bashrc
source ~/.bashrc
```

Now we can run `hello_world` from anywhere on our machine and get the same script!

```bash
cd some/other/directory
hello_world
Hello, World!
```

## More advanced scripts

So we've created a simple script for outputting to the console, what if we want something a little more useful?

Let's create a script that prints out the 'scripts' portion of the package.json for whatever directory we're in. This can be useful if you're not sure what package scripts are available for any given project.

First we create our script file – I'll call it `list-package-scripts.ts`

Within `list-package-scripts.ts` I'll add the following code:

```typescript
#!/bin/sh 
":" //#; exec /usr/bin/env ts-node -P ~/scripts/tsconfig.json "$0" "$@"

import { readFile } from 'fs';

readFile(`${process.cwd()}/package.json`, (err, data) => {
    if (err) {
        throw err;
    }
    const parsed = JSON.parse(data.toString('utf-8'));
    console.log(parsed.scripts);
});

```

Now we need to make this script executable!

```bash
chmod +x list-package-scripts.ts
```

now we can run this command in any node project and see what npm scripts are available to us:

```bash
cd some/other/node/project
~/scripts/list-package-scripts.ts
# example output, will be different for every project!
{ start: 'npm run watch',
  'build:ts': 'tsc',
  'watch:ts': 'tsc --watch',
  watch: 'npm run clean && npm run build:ts & npm run watch:ts & gulp watch & wait',
  test: 'gulp test' }

```

Hopefully this article provides a good jumping off point for your own scripts!

Please leave a comment or share the article if you found this useful – happy coding!


At some point in your career, it's likely you'll need to write scripts for the command line – there are cases where it makes sense to use vanilla bash scripting for this and that will usually work just fine for simple tasks like renaming things and deleting folders. If you're anything like me though, it's much more enjoyable and productive to write these tools in a familiar language like Javascript, or even better – Typescript. You get all the niceties of a modern language without any of the weird gotchas of bash and terminal syntax/behaviour. In this article I'll cover a simple method for writing command line scripts in Typescript. So! First things first. we need to create a directory where our scripts will live. If you're on a mac or linux machine, I recommend creating a directory in your home folder ~ simply called scripts. Within this folder we'll create a file called hello-world.ts and globally install our 2 required dependencies (If you haven’t already, download and install node, but you probably knew that!) mkdir ~/scripts && cd ~/scripts npm i -g typescript ts-node tsc --init touch hello-world.ts Learn about the handy npm shortcuts above Note: If you know of a clean way to do this without globally installing ts-node and typescript, I'd love to hear about it! Now we can place the following code in our hello-world.ts file #!/bin/sh ":" //#; exec /usr/bin/env ts-node -P ~/scripts/tsconfig.json "$0" "$@" console.log('Hello, World!'); Credit to Sam over at sambal.org for this clever shebang trick Finally, we need to make this file executable with chmod chmod +x hello-world.ts And now we can run it! ./hello-world.ts Hello, World! Note: You may see an error from ts-node about an unrecognized option 'esModuleInterop' – if this happens to you, you can simply remove that line from ~/scripts/tsconfig.json So far we've created our scripts directory where our scripts will live, installed the required dependencies to run them and set up a simple script to get us started. Next we'll do some housekeeping to make our lives easier as our library of scripts grows over time. One of the first things I do when I write a new script is create an alias to run it – I'll assume we're all running bash, but if you're using zsh or some other shell the steps here will be very similar. First we'll edit our .bashrc to add an alias for our new script echo "alias hello_world='~/scripts/hello-world.ts'" >> ~/.bashrc source ~/.bashrc Now we can run hello_world from anywhere on our machine and get the same script! cd some/other/directory hello_world Hello, World! More advanced scripts So we've created a simple script for outputting to the console, what if we want something a little more useful? Let's create a script that prints out the 'scripts' portion of the package.json for whatever directory we're in. This can be useful if you're not sure what package scripts are available for any given project. First we create our script file – I'll call it list-package-scripts.ts Within list-package-scripts.ts I'll add the following code: #!/bin/sh ":" //#; exec /usr/bin/env ts-node -P ~/scripts/tsconfig.json "$0" "$@" import { readFile } from 'fs'; readFile(${process.cwd()}/package.json, (err, data) => { if (err) { throw err; } const parsed = JSON.parse(data.toString('utf-8')); console.log(parsed.scripts); }); Now we need to make this script executable! chmod +x list-package-scripts.ts now we can run this command in any node project and see what npm scripts are available to us: cd some/other/node/project ~/scripts/list-package-scripts.ts example output, will be different for every project! { start: 'npm run watch', 'build:ts': 'tsc', 'watch:ts': 'tsc --watch', watch: 'npm run clean && npm run build:ts & npm run watch:ts & gulp watch & wait', test: 'gulp test' } Hopefully this article provides a good jumping off point for your own scripts! Please leave a comment or share the article if you found this useful – happy coding!

Write CLI scripts with Typescript


The Singleton pattern is one of the most basic and powerful patterns for creating shared class instances. You may consider using the singleton pattern when you have a class that is a shared dependency for many other classes - such as an ORM(Object Relational Mapper) or database connection, which may be costly to recreate each time you need access to the database.

The basic idea behind the Singleton pattern is to store a reference to the instance of a class, and return that reference each time something asks for a new instance of that class, instead of creating a new instance each time.

We'll look at an old school example of a Javascript singleton before moving on to a typescript version, and finally a decorator that can turn almost any class into a singleton!

In traditional Javascript you might see something similar this:

```javascript
const Store = (function() {
    const data = [];

    function add(item) {
        data.push(item);
    }

    function get(id) {
        return data.find((d) => d.id === id);
    }

    return {
        add, get
    };
}());
```

Note: the code above is making use of the [iife pattern](https://developer.mozilla.org/en-US/docs/Glossary/IIFE) as well

When this code runs, `Store` will be set to the return value of `Store` — an object that exposes two functions, `add` and `get` but that does not grant direct access to the collection of data.

This is beneficial enough, but it is more verbose than we really need and it doesn't give us any safety guarantees since this is just vanilla Javascript – there's nothing to prevent us from doing nefarious things!

This code is also not reusable, which means we will have to reimplement the same code for any object that needs to be a Singleton!

For the Typescript version, we will do essentially the same thing, but with a class.

```typescript
class Store {
    private static instance: Store;
    private data: {id: number}[];
    private constructor() {}

    public static getInstance() {
        if (!Store.instance) {
            Store.instance = new Store();
        }
        return Store.instance;
    }

    public add(item: {id: number}) {
        this.data.push(item);
    }

    public get(id: number) {
        return this.data.find((d) => d.id === id);
    }
}

const wontWork = new Store() // throws an Error: constructor of 'Store' is private

const myStore = Store.getInstance();
myStore.add({id: 1});
myStore.add({id: 2});
myStore.add({id: 3});

const anotherStore = Store.getInstance();
anotherStore.get(2); // returns `{id: 2}`!
```

This is slightly improved over the pure javascript version. We now have type safety through the Typescript compiler and I think it's a little more readable, but this code is still verbose and could be drastically simplified.

Another problem with this version is that you have to use that weird `getInstance` method instead of the normal `new Store()` syntax we're all used to.

So now that we've compared the vanilla Javascript method to the Typescript method, let's make the concept of a Singleton reusable! One of the best ways to accomplish this is through the use of a [decorator](https://www.typescriptlang.org/docs/handbook/decorators.html)!

The next example is going to go over how to implement a `@Singleton` decorator that is reusable.

The first thing we're going to do is use a Javascript [Symbol](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol) to create a unique key that represents the instance of whatever class we are converting to a singleton. We do this because otherwise, we have to worry about the possibility of overwriting a field or method name on the original class.

```typescript
export const SINGLETON_KEY = Symbol();
```

Next we define the type for a Singleton – a class that is the same as the original class, which also uses the `SINGLETON_KEY` to create a unique field that represents the instance.

```typescript
export type Singleton<T extends new (...args: any[]) => any> = T & {
    [SINGLETON_KEY]: T extends new (...args: any[]) => infer I ? I : never
};
```

Finally, we implement a function that will act as the decorator itself. There's a lot going on here, but at its core this is a simple process.

 Note: You can read more about [decorators and their syntax here](https://www.typescriptlang.org/docs/handbook/decorators.html)

Our Singleton decorator function takes in a single parameter called `type`.  
`type` represents a class, before it has been initialize - a type indeed!

It then returns a new Javascript [Proxy](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy) which we use to build a [construct trap](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/construct) - essentially we hijack the original constructor of `type` and replace it with our own implementation which will create the instance if it doesn't exist, or return the existing instance!

```typescript
export const Singleton = <T extends new (...args: any[]) => any>(type: T) =>
    new Proxy(type, {
        // this will hijack the constructor
        construct(target: Singleton<T>, argsList, newTarget) {
            // we should skip the proxy for children of our target class
            if (target.prototype !== newTarget.prototype) {
                return Reflect.construct(target, argsList, newTarget);
            }
            // if our target class does not have an instance, create it
            if (!target[SINGLETON_KEY]) {
                target[SINGLETON_KEY] = Reflect.construct(target, argsList, newTarget);
            }
            // return the instance we created!
            return target[SINGLETON_KEY];
        }
    });
```

Put that all together in a file called Singleton.ts and this is what is should look like:

```typescript
export const SINGLETON_KEY = Symbol();

export type Singleton<T extends new (...args: any[]) => any> = T & {
    [SINGLETON_KEY]: T extends new (...args: any[]) => infer I ? I : never
};

export const Singleton = <T extends new (...args: any[]) => any>(type: T) =>
    new Proxy(type, {
        // this will hijack the constructor
        construct(target: Singleton<T>, argsList, newTarget) {
            // we should skip the proxy for children of our target class
            if (target.prototype !== newTarget.prototype) {
                return Reflect.construct(target, argsList, newTarget);
            }
            // if our target class does not have an instance, create it
            if (!target[SINGLETON_KEY]) {
                target[SINGLETON_KEY] = Reflect.construct(target, argsList, newTarget);
            }
            // return the instance we created!
            return target[SINGLETON_KEY];
        }
    });
```

Now we can use this decorator on our Store class and remove all of the Singleton specific code from it!

Note: You will need to enable the experimental decorator   
flags for typescript in order for this to work!

```typescript
// in tsconfig.json add the following
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true,
```

```typescript
import {Singleton} from './Singleton';

@Singleton
class Store {
    private data: {id: number}[];

    public add(item: {id: number}) {
        this.data.push(item);
    }

    public get(id: number) {
        return this.data.find((d) => d.id === id);
    }
}

const myStore = new Store();
myStore.add({id: 1});
myStore.add({id: 2});
myStore.add({id: 3});

const anotherStore = new Store();
anotherStore.get(2); // returns `{id: 2}`!
```

I don't know about you, but that's much more readable to me - and as a bonus, `@Singleton` is reusable across our entire codebase! We won't have to write Singleton specific logic in each class that needs to be a Singleton!

This is just one of many design patterns available to us today. If you found this article helpful, let me know in a comment or share it around!


The Singleton pattern is one of the most basic and powerful patterns for creating shared class instances. You may consider using the singleton pattern when you have a class that is a shared dependency for many other classes - such as an ORM(Object Relational Mapper) or database connection, which may be costly to recreate each time you need access to the database. The basic idea behind the Singleton pattern is to store a reference to the instance of a class, and return that reference each time something asks for a new instance of that class, instead of creating a new instance each time. We'll look at an old school example of a Javascript singleton before moving on to a typescript version, and finally a decorator that can turn almost any class into a singleton! In traditional Javascript you might see something similar this: const Store = (function() { const data = []; function add(item) { data.push(item); } function get(id) { return data.find((d) => d.id === id); } return { add, get }; }()); Note: the code above is making use of the iife pattern as well When this code runs, Store will be set to the return value of Store — an object that exposes two functions, add and get but that does not grant direct access to the collection of data. This is beneficial enough, but it is more verbose than we really need and it doesn't give us any safety guarantees since this is just vanilla Javascript – there's nothing to prevent us from doing nefarious things! This code is also not reusable, which means we will have to reimplement the same code for any object that needs to be a Singleton! For the Typescript version, we will do essentially the same thing, but with a class. class Store { private static instance: Store; private data: {id: number}[]; private constructor() {} public static getInstance() { if (!Store.instance) { Store.instance = new Store(); } return Store.instance; } public add(item: {id: number}) { this.data.push(item); } public get(id: number) { return this.data.find((d) => d.id === id); } } const wontWork = new Store() // throws an Error: constructor of 'Store' is private const myStore = Store.getInstance(); myStore.add({id: 1}); myStore.add({id: 2}); myStore.add({id: 3}); const anotherStore = Store.getInstance(); anotherStore.get(2); // returns {id: 2}! This is slightly improved over the pure javascript version. We now have type safety through the Typescript compiler and I think it's a little more readable, but this code is still verbose and could be drastically simplified. Another problem with this version is that you have to use that weird getInstance method instead of the normal new Store() syntax we're all used to. So now that we've compared the vanilla Javascript method to the Typescript method, let's make the concept of a Singleton reusable! One of the best ways to accomplish this is through the use of a decorator! The next example is going to go over how to implement a @Singleton decorator that is reusable. The first thing we're going to do is use a Javascript Symbol to create a unique key that represents the instance of whatever class we are converting to a singleton. We do this because otherwise, we have to worry about the possibility of overwriting a field or method name on the original class. export const SINGLETON_KEY = Symbol(); Next we define the type for a Singleton – a class that is the same as the original class, which also uses the SINGLETON_KEY to create a unique field that represents the instance. export type Singleton any> = T & { [SINGLETON_KEY]: T extends new (...args: any[]) => infer I ? I : never }; Finally, we implement a function that will act as the decorator itself. There's a lot going on here, but at its core this is a simple process. Note: You can read more about decorators and their syntax here Our Singleton decorator function takes in a single parameter called type. type represents a class, before it has been initialize - a type indeed! It then returns a new Javascript Proxy which we use to build a construct trap - essentially we hijack the original constructor of type and replace it with our own implementation which will create the instance if it doesn't exist, or return the existing instance! export const Singleton = any>(type: T) => new Proxy(type, { // this will hijack the constructor construct(target: Singleton, argsList, newTarget) { // we should skip the proxy for children of our target class if (target.prototype !== newTarget.prototype) { return Reflect.construct(target, argsList, newTarget); } // if our target class does not have an instance, create it if (!target[SINGLETON_KEY]) { target[SINGLETON_KEY] = Reflect.construct(target, argsList, newTarget); } // return the instance we created! return target[SINGLETON_KEY]; } }); Put that all together in a file called Singleton.ts and this is what is should look like: export const SINGLETON_KEY = Symbol(); export type Singleton any> = T & { [SINGLETON_KEY]: T extends new (...args: any[]) => infer I ? I : never }; export const Singleton = any>(type: T) => new Proxy(type, { // this will hijack the constructor construct(target: Singleton, argsList, newTarget) { // we should skip the proxy for children of our target class if (target.prototype !== newTarget.prototype) { return Reflect.construct(target, argsList, newTarget); } // if our target class does not have an instance, create it if (!target[SINGLETON_KEY]) { target[SINGLETON_KEY] = Reflect.construct(target, argsList, newTarget); } // return the instance we created! return target[SINGLETON_KEY]; } }); Now we can use this decorator on our Store class and remove all of the Singleton specific code from it! Note: You will need to enable the experimental decorator flags for typescript in order for this to work! // in tsconfig.json add the following "experimentalDecorators": true, "emitDecoratorMetadata": true, import {Singleton} from './Singleton'; @Singleton class Store { private data: {id: number}[]; public add(item: {id: number}) { this.data.push(item); } public get(id: number) { return this.data.find((d) => d.id === id); } } const myStore = new Store(); myStore.add({id: 1}); myStore.add({id: 2}); myStore.add({id: 3}); const anotherStore = new Store(); anotherStore.get(2); // returns {id: 2}! I don't know about you, but that's much more readable to me - and as a bonus, @Singleton is reusable across our entire codebase! We won't have to write Singleton specific logic in each class that needs to be a Singleton! This is just one of many design patterns available to us today. If you found this article helpful, let me know in a comment or share it around!

How to create a Typescript Singleton Decorator


If you've been using npm and Node for any amount of time, it's likely you've grown tired of typing out `install` or `--save-dev` every time you want to add a package. This article will cover some quality of life tips and tricks to make using npm a breeze!

| Command/flag | Shortcut |
| --- | ----------- |
| `install` | `i` |
| `test` | `t` |
| `--save-dev` | `-D` |
| `--save` | `-s` |
| `--save-exact` | `-E` |
| `--global` | `-g` |
| `--version` | `-v` |
| `--help` | `-h` |
| `--silent, --loglevel silent` | `-s` |
| `--quiet, --loglevel warn` | `-q` |
| `--loglevel info` | `-d` |
| `--verbose --loglevel verbose` | `-dd` |

## Install multiple npm packages at once

Most people know this trick, but here it is!

```bash
npm i express typescript react
```

_NOTE: `--save` or `-S` are not required if you are adding dependencies in_ [_npm version 5 or above_](https://github.com/npm/npm/issues/5108)_._

```bash
npm i -D express typescript react
```

```json
// package.json
"devDependencies": {
    "express": "^x.x.x",
    "typescript": "^x.x.x",
    "react": "^x.x.x"
}
```

You can also install multiple packages that start with the same prefix using the following syntax

```bash
npm i react{-router-dom,-bootstrap,-redux}
```

## Install a package from a Github repository

Similarly to packages hosted by NPM, you can install packages directly from GitHub repositories.  
NPM understands how a Github repo works and knows what to do if you only specify the username and repo.

```bash
npm i https://github.com/microsoft/TypeScript.git
npm i microsoft/TypeScript  
```

You can even specify a branch name in this manner!

```bash
npm i microsoft/TypeScript#add-gdpr-annotations
```

## Open a package's home page

```bash
npm home packagename
```

The `home` command will open the homepage specified in a package's `package.json`.

if you run `npm home typescript` it will open the http://www.typescriptlang.org website.

This command can be run without having the package installed locally or globally, so it's a nice way to verify that the package you're trying to install is the one you think it is!

## Open a package’s GitHub repository

```
npm repo packagename
```

The `repo` command will open the Github repository of the package. This command is similar to the `home` command and doesn't require the package to be installed.

## Npm init Defaults

Tired of manually entering your information every time you type `npm init`? You can easily set some defaults using `npm config`

```bash
npm config set init.author.name yourname
npm config set init.author.email youremail
npm config set save-prefix="~"
```

The ~ prefix tells npm to only upgrade the minor version when you install something, so it's much less likely to have breaking changes.

## Check for outdated dependencies

```bash
npm outdated
```

The `outdated` command will check with the npm registry and compare package versions - if it finds any that are out-of-date locally it will print them in a list with the current installed version, the 'wanted' version (the version specified in your package.json) and the latest version published.

## List all installed packages

```bash
npm ls --depth 0
```

To list the globally-installed packages, run the same command with `-g` flag

```bash
npm ls -g --depth 0
```

## Run node modules outside of npm

Occasionally, we find ourselves in need of a tool or library installed via npm in some other application, such as a Dockerfile, CI configuration or a shell script.

The traditional way to run `node_modules` in this way, is to execute them directly via the `node_modules/.bin` folder. While this method does still work, there's now an easier way!

Enter npx – npx is another utility that is now included with npm by default! Using npx is simple:

```bash
npx packagename
```

this will run whatever package you passed it as if it were a script in package.json! Let's look at another example:

```bash
npm i rimraf -D    # install rimraf as a dev dependency
npx rimraf ./build # delete the build directory
```

Now you can easily run node scripts and tools from your CI system or other CLI scripts.

* * *

These are just some of the cool things you can do with npm. While this is not an exhaustive list of everything it can do, I hope it was helpful and makes your life easier in some small way!


If you've been using npm and Node for any amount of time, it's likely you've grown tired of typing out install or --save-dev every time you want to add a package. This article will cover some quality of life tips and tricks to make using npm a breeze! | Command/flag | Shortcut | | --- | ----------- | | install | i | | test | t | | --save-dev | -D | | --save | -s | | --save-exact | -E | | --global | -g | | --version | -v | | --help | -h | | --silent, --loglevel silent | -s | | --quiet, --loglevel warn | -q | | --loglevel info | -d | | --verbose --loglevel verbose | -dd | Install multiple npm packages at once Most people know this trick, but here it is! npm i express typescript react NOTE: --save or -S are not required if you are adding dependencies in npm version 5 or above. npm i -D express typescript react // package.json "devDependencies": { "express": "^x.x.x", "typescript": "^x.x.x", "react": "^x.x.x" } You can also install multiple packages that start with the same prefix using the following syntax npm i react{-router-dom,-bootstrap,-redux} Install a package from a Github repository Similarly to packages hosted by NPM, you can install packages directly from GitHub repositories. NPM understands how a Github repo works and knows what to do if you only specify the username and repo. npm i https://github.com/microsoft/TypeScript.git npm i microsoft/TypeScript You can even specify a branch name in this manner! npm i microsoft/TypeScript#add-gdpr-annotations Open a package's home page npm home packagename The home command will open the homepage specified in a package's package.json. if you run npm home typescript it will open the http://www.typescriptlang.org website. This command can be run without having the package installed locally or globally, so it's a nice way to verify that the package you're trying to install is the one you think it is! Open a package’s GitHub repository npm repo packagename The repo command will open the Github repository of the package. This command is similar to the home command and doesn't require the package to be installed. Npm init Defaults Tired of manually entering your information every time you type npm init? You can easily set some defaults using npm config npm config set init.author.name yourname npm config set init.author.email youremail npm config set save-prefix="~" The ~ prefix tells npm to only upgrade the minor version when you install something, so it's much less likely to have breaking changes. Check for outdated dependencies npm outdated The outdated command will check with the npm registry and compare package versions - if it finds any that are out-of-date locally it will print them in a list with the current installed version, the 'wanted' version (the version specified in your package.json) and the latest version published. List all installed packages npm ls --depth 0 To list the globally-installed packages, run the same command with -g flag npm ls -g --depth 0 Run node modules outside of npm Occasionally, we find ourselves in need of a tool or library installed via npm in some other application, such as a Dockerfile, CI configuration or a shell script. The traditional way to run nodemodules in this way, is to execute them directly via the nodemodules/.bin folder. While this method does still work, there's now an easier way! Enter npx – npx is another utility that is now included with npm by default! Using npx is simple: npx packagename this will run whatever package you passed it as if it were a script in package.json! Let's look at another example: npm i rimraf -D # install rimraf as a dev dependency npx rimraf ./build # delete the build directory Now you can easily run node scripts and tools from your CI system or other CLI scripts. These are just some of the cool things you can do with npm. While this is not an exhaustive list of everything it can do, I hope it was helpful and makes your life easier in some small way!

NPM tips and tricks to make your life easier


If you've done any work with typescript, it's likely you've come across the [TSLint](https://palantir.github.io/tslint/) project. TSLint is a Typescript specific linting tool that ensures you and your team write high quality code that conforms to a particular style.  

> The strategic direction of the TypeScript team is to enable “types on every desk, in every home, for every JS developer”. In other words, the direction is to incrementally enrich the JavaScript developer experience with TypeScript features like types and /assets analysis until, maybe, the TypeScript and JavaScript developer experience converge.
> 
> [Palantir on Medium](https://medium.com/palantir/tslint-in-2019-1a144c2317a9)

![](/assets/2019/08/index.png)

Up til now, TSLint has been the primary way to keep typescript code bases in check.  
But in 2019, the Typescript team decided to put their efforts into expanding ESLint with support for typescript.  
With this decision made, Palantir has decided to sunset TSLint and do away with the project entirely.

> 🚧 warning TSLint will be deprecated some time in 2019. [See this issue for more details](https://github.com/palantir/tslint/issues/4534)
> 
> Palantir on Github

With this change coming soon, it's important to update your projects to keep up code quality. With this post we'll go over that migration process step by step.

## Setup

First things first, we need to install ESLint and a couple extra dependencies to get things working.

First up is @typescript-eslint/parser

this module takes typescript code and produces an Abstract Syntax Tree, or AST for that code.

We then use the @typescript-eslint/eslint-plugin to parse that AST for ESLint rules!

```bash
npm install --save-dev eslint @typescript-eslint/parser @typescript-eslint/eslint-plugin
```

Once that's installed, we need to create a `.eslintrc` file in the root of our project and add the following code to it:

```json
{
  "parser": "@typescript-eslint/parser",
  "plugins": ["@typescript-eslint"],
  "extends": [
    "eslint:recommended",
    "plugin:@typescript-eslint/eslint-recommended",
    "plugin:@typescript-eslint/recommended"
  ],
    "parserOptions": {
      "project": "./tsconfig.json",
      "includes": [
        "src/**/*.ts"
      ]
  }
}
```

This does a couple things.

- First, we are telling ESLint to use the Typescript specific parser we installed earlier.
- We then add the typescript-eslint plugin and extend the recommended default rulesets. (that last part is optional, you can also create any configuration you want in the rules section)
- finally, we are setting up some specific options that tell ESLint what files to scan through, and where our tsconfig.json is

Please note that this is just extending the default rulesets and will not handle migrating your existing TSLint settings. you will need to add a 'rules' section to the above config and manually add each rule or the equivalent.

You can find a list of the ESLint Typescript [supported rules here](https://github.com/typescript-eslint/typescript-eslint/tree/master/packages/eslint-plugin#supported-rules)

## Configure your Editor

### VScode

You will need to add a configuration option in VScode's settings so that it knows to run ESLint on typescript files:

```json
"eslint.validate": [
  "javascript",
  "javascriptreact",
  "typescript",
  "typescriptreact"
]
```

## Intellij

Open the settings window and navigate to:

preferences > Language & Frameworks > JavaScript > Code Quality Tools > ESlint

- choose manual ESLint Configuration
- set the ESLint package field to ~/path/to/project/node\_modules/eslint

After following these steps, you should be able to see ESlint start highlighting your code that violates the rules automatically!

[Further reading](https://github.com/typescript-eslint/typescript-eslint)


If you've done any work with typescript, it's likely you've come across the TSLint project. TSLint is a Typescript specific linting tool that ensures you and your team write high quality code that conforms to a particular style. > The strategic direction of the TypeScript team is to enable “types on every desk, in every home, for every JS developer”. In other words, the direction is to incrementally enrich the JavaScript developer experience with TypeScript features like types and /assets analysis until, maybe, the TypeScript and JavaScript developer experience converge. > > Palantir on Medium Up til now, TSLint has been the primary way to keep typescript code bases in check. But in 2019, the Typescript team decided to put their efforts into expanding ESLint with support for typescript. With this decision made, Palantir has decided to sunset TSLint and do away with the project entirely. > 🚧 warning TSLint will be deprecated some time in 2019. See this issue for more details > > Palantir on Github With this change coming soon, it's important to update your projects to keep up code quality. With this post we'll go over that migration process step by step. Setup First things first, we need to install ESLint and a couple extra dependencies to get things working. First up is @typescript-eslint/parser this module takes typescript code and produces an Abstract Syntax Tree, or AST for that code. We then use the @typescript-eslint/eslint-plugin to parse that AST for ESLint rules! npm install --save-dev eslint @typescript-eslint/parser @typescript-eslint/eslint-plugin Once that's installed, we need to create a .eslintrc file in the root of our project and add the following code to it: { "parser": "@typescript-eslint/parser", "plugins": ["@typescript-eslint"], "extends": [ "eslint:recommended", "plugin:@typescript-eslint/eslint-recommended", "plugin:@typescript-eslint/recommended" ], "parserOptions": { "project": "./tsconfig.json", "includes": [ "src/*/.ts" ] } } This does a couple things. First, we are telling ESLint to use the Typescript specific parser we installed earlier. We then add the typescript-eslint plugin and extend the recommended default rulesets. (that last part is optional, you can also create any configuration you want in the rules section) finally, we are setting up some specific options that tell ESLint what files to scan through, and where our tsconfig.json is Please note that this is just extending the default rulesets and will not handle migrating your existing TSLint settings. you will need to add a 'rules' section to the above config and manually add each rule or the equivalent. You can find a list of the ESLint Typescript supported rules here Configure your Editor VScode You will need to add a configuration option in VScode's settings so that it knows to run ESLint on typescript files: "eslint.validate": [ "javascript", "javascriptreact", "typescript", "typescriptreact" ] Intellij Open the settings window and navigate to: preferences > Language & Frameworks > JavaScript > Code Quality Tools > ESlint choose manual ESLint Configuration set the ESLint package field to ~/path/to/project/node\_modules/eslint After following these steps, you should be able to see ESlint start highlighting your code that violates the rules automatically! Further reading

TSLint is going to be deprecated this year, here's what you can do about it


[Full working code examples are available on github](https://github.com/trevor-atlas/Typescript-Inject)


Sometimes our classes rely on other services or values that need to be initialized on their own before our class interacts with it, or we want to use a mock implementation of a service or value for testing purposes. A common solution to this problem is dependency injection through a factory. (Sometimes called IOC or Inversion of Control). Today, I'll show you how to use typescript decorators along with a lazy factory to inject dependencies into your classes at runtime. This makes it easy to test your code and have precise control over runtime dependencies without having to spread that logic out across many different places.

To start things off, lets make sure our `tsconfig.json` is set up and ready to work with decorators by enabling two optional flags:

```json
...
"experimentalDecorators": true,
"emitDecoratorMetadata": true,
...
```

Now in our source code we can set up a lazy factory. This class will be responsible for creating instances of whatever we want and can be as flexible as we need! We'll use the singleton pattern to ensure there's only ever one instance of the factory at a time to avoid duplication.

`di/LazyFactory.ts`
```ts
export class LazyFactory {

    // this is where we store our singleton reference to this class instance
    private static instance: LazyFactory;

    // hide constructor, must use getInstance
    private constructor() {}

    // if there is not yet an instance of this class, create it. Otherwise return that instance
    public static getInstance() {
        if (!LazyFactory.instance) {
            LazyFactory.instance = new LazyFactory();
        }
        return LazyFactory.instance;
    }
}
```

That's all we need to get rolling! now we can add methods to the `LazyFactory` to return whatever we need at runtime. Let's add one now to return an instance of `MyService`.
One of the benefits of our lazy factory is we can easily swap out implementations of what it returns for mocking purposes. We'll use an interface to define `MyService`'s public methods and fields, then we can implement that interface with a mock and real implementation. Our `LazyFactory` can then determine which version of the service to give us dynamically!

First we'll define the `IMyservice` interface like so:

`services/IMyService.ts`
```ts
export interface IMyService {
    sayHello(name: string): void;
}
```

Now we can define a mock and real implementation of the service using this interface:

`services/MyService.ts`
```ts
export class MyService implements IMyService {
    public sayHello(name: string): void {
       console.log(`Hello from the real service, ${name}!`);
    }
}
```

`services/MockMyService.ts`
```ts
export class MockMyService implements IMyService {
    public sayHello(name: string): void {
        console.log(`Hello from the mock service, ${name}!`);
    }
}
```

Back in our `LazyFactory` we can create a method to return the correct implementation of `IMyService` - in this case I'll use the current environment to determine which instance to return:

`di/LazyFactory.ts`
```ts
export class LazyFactory {
    ...
    public myService() {
        if (process.env.ENV === 'production') {
            return new (require('../service/MyService')).MyService();
        }
        return new (require('../service/MockMyService')).MockMyService();
    }
}
```

> NOTE: You might be wondering why we're using this odd require syntax - it's not always necessary but I've seen some strange behaviour pop up when using this factory with some webpack configurations. it might not be necessary but your mileage may vary!

Phew! That's a lot - but we're almost done! The last thing we need to do is actually use our `LazyFactory`!

for this example, we'll be working in `app.ts` which has need of our `MyService`:

`app.ts`
```ts
import {LazyFactory} from './LazyFactory';

class App {
    private myService: IMyService;

    constructor() {
        this.myService = LazyFactory.getInstance().myService();
    }
    
    public main() {
        this.myService.sayHello('internet');
    }
}

new App().main();
```

and we're done! `LazyFactory` will look up the correct version of our `MyService` and return it. This makes testing code in isolation much easier to do since you can keep the mock versions of your services dumb.

You might be wondering about those decorator options we set up earlier, and I've not forgotten that - I just wanted to illustrate that this is completely possible to achieve without using decorators.

Now we'll define an `@Inject` typescript decorator that will handle the construction and assignment in `App` for us!

The code for `@Inject` looks like this:

`decorators/Inject.ts`
```ts
import {LazyFactory} from '../di/LazyFactory';

export const Inject = (target: any, key: string) => {
    let val = target[key]

    if (delete target[key]) {
        Object.defineProperty(target, key, {
            get: () => {
                // an ugly cast :(
                // if you know a good way to do this without converting LazyFactory to an object literal please let me know!
                const concrete = (LazyFactory.getInstance() as any)[key];
                if (concrete) {
                    val = concrete();
                }
                return val;
            },
            enumerable: true,
            configurable: true
        });
    }
};
```

What this does is look for `key` in `target` - `target` will be whatever class we use the `@Inject` decorator in. if it finds that key in `target` and our `LazyFactory` has a matching key, it will replace `key` with the match found in the `LazyFactory`. Sounds like a lot, but It's fairly simple, let's write some code that uses this decorator to get a better understanding of what's going on.

back in `app.ts`:

```ts
import {Inject} from './Inject';

class App { // <-- App will be the `target` referenced in the Inject function
    @Inject
    private myService!: IMyService; // <-- this field `myService` will be the key

    constructor() { /*...this is empty now! */ }

    public main() {
        this.myService.sayHello('internet');
    }
}

new App().main();
```

We can now add as many other services to our `LazyFactory` as we want, and `@Inject` them! As long as the method name in `LazyFactory` matches the field name where it's being injected it will work no problem.

But wait! There's more!

`LazyFactory` doesn't actually care what we return from any method - this is super useful because it lets us swap out any kind of data we want. I've used it to return a `baseURL` that differs locally vs in production:

```ts
export class LazyFactory {
    ...
    public baseURL() {
        if (process.env.ENV === 'production') {
            return 'https://prod.myAPI.com';
        }
        return 'https://stage.myAPI.com';
    }
}
```

now back in `MyService` and `MockMyService` we can inject this baseURL as well!

`services/MyService.ts`
```ts
export class MyService implements IMyService {

    @Inject
    private baseURL: string; // <-- 'https://prod.myAPI.com'

    public sayHello(name: string): void {
        console.log(`Hello from the real service, ${name}!`);
        console.log('baseURL is ', this.baseURL);
    }
}
```

`services/MockMyService.ts`
```ts
export class MockMyService implements IMyService {

    @Inject
    private baseURL: string; // <-- 'https://stage.myAPI.com'

    public sayHello(name: string): void {
        console.log(`Hello from the mock service, ${name}!`);
        console.log('baseURL is ', this.baseURL);
    }
}
```

[Full working code examples are available on github](https://github.com/trevor-atlas/Typescript-Inject)

I hope this has been a useful explanation of some of the benefits of dependency injection. While this method is not perfect, it is very flexible and lets you fine tune its behaviour as much as you want/need. 


Full working code examples are available on github Sometimes our classes rely on other services or values that need to be initialized on their own before our class interacts with it, or we want to use a mock implementation of a service or value for testing purposes. A common solution to this problem is dependency injection through a factory. (Sometimes called IOC or Inversion of Control). Today, I'll show you how to use typescript decorators along with a lazy factory to inject dependencies into your classes at runtime. This makes it easy to test your code and have precise control over runtime dependencies without having to spread that logic out across many different places. To start things off, lets make sure our tsconfig.json is set up and ready to work with decorators by enabling two optional flags: ... "experimentalDecorators": true, "emitDecoratorMetadata": true, ... Now in our source code we can set up a lazy factory. This class will be responsible for creating instances of whatever we want and can be as flexible as we need! We'll use the singleton pattern to ensure there's only ever one instance of the factory at a time to avoid duplication. di/LazyFactory.ts export class LazyFactory { // this is where we store our singleton reference to this class instance private static instance: LazyFactory; // hide constructor, must use getInstance private constructor() {} // if there is not yet an instance of this class, create it. Otherwise return that instance public static getInstance() { if (!LazyFactory.instance) { LazyFactory.instance = new LazyFactory(); } return LazyFactory.instance; } } That's all we need to get rolling! now we can add methods to the LazyFactory to return whatever we need at runtime. Let's add one now to return an instance of MyService. One of the benefits of our lazy factory is we can easily swap out implementations of what it returns for mocking purposes. We'll use an interface to define MyService's public methods and fields, then we can implement that interface with a mock and real implementation. Our LazyFactory can then determine which version of the service to give us dynamically! First we'll define the IMyservice interface like so: services/IMyService.ts export interface IMyService { sayHello(name: string): void; } Now we can define a mock and real implementation of the service using this interface: services/MyService.ts export class MyService implements IMyService { public sayHello(name: string): void { console.log(Hello from the real service, ${name}!); } } services/MockMyService.ts export class MockMyService implements IMyService { public sayHello(name: string): void { console.log(Hello from the mock service, ${name}!); } } Back in our LazyFactory we can create a method to return the correct implementation of IMyService - in this case I'll use the current environment to determine which instance to return: di/LazyFactory.ts export class LazyFactory { ... public myService() { if (process.env.ENV === 'production') { return new (require('../service/MyService')).MyService(); } return new (require('../service/MockMyService')).MockMyService(); } } > NOTE: You might be wondering why we're using this odd require syntax - it's not always necessary but I've seen some strange behaviour pop up when using this factory with some webpack configurations. it might not be necessary but your mileage may vary! Phew! That's a lot - but we're almost done! The last thing we need to do is actually use our LazyFactory! for this example, we'll be working in app.ts which has need of our MyService: app.ts import {LazyFactory} from './LazyFactory'; class App { private myService: IMyService; constructor() { this.myService = LazyFactory.getInstance().myService(); } public main() { this.myService.sayHello('internet'); } } new App().main(); and we're done! LazyFactory will look up the correct version of our MyService and return it. This makes testing code in isolation much easier to do since you can keep the mock versions of your services dumb. You might be wondering about those decorator options we set up earlier, and I've not forgotten that - I just wanted to illustrate that this is completely possible to achieve without using decorators. Now we'll define an @Inject typescript decorator that will handle the construction and assignment in App for us! The code for @Inject looks like this: decorators/Inject.ts import {LazyFactory} from '../di/LazyFactory'; export const Inject = (target: any, key: string) => { let val = target[key] if (delete target[key]) { Object.defineProperty(target, key, { get: () => { // an ugly cast :( // if you know a good way to do this without converting LazyFactory to an object literal please let me know! const concrete = (LazyFactory.getInstance() as any)[key]; if (concrete) { val = concrete(); } return val; }, enumerable: true, configurable: true }); } }; What this does is look for key in target - target will be whatever class we use the @Inject decorator in. if it finds that key in target and our LazyFactory has a matching key, it will replace key with the match found in the LazyFactory. Sounds like a lot, but It's fairly simple, let's write some code that uses this decorator to get a better understanding of what's going on. back in app.ts: import {Inject} from './Inject'; class App { // <-- App will be the target referenced in the Inject function @Inject private myService!: IMyService; // <-- this field myService will be the key constructor() { /...this is empty now! / } public main() { this.myService.sayHello('internet'); } } new App().main(); We can now add as many other services to our LazyFactory as we want, and @Inject them! As long as the method name in LazyFactory matches the field name where it's being injected it will work no problem. But wait! There's more! LazyFactory doesn't actually care what we return from any method - this is super useful because it lets us swap out any kind of data we want. I've used it to return a baseURL that differs locally vs in production: export class LazyFactory { ... public baseURL() { if (process.env.ENV === 'production') { return 'https://prod.myAPI.com'; } return 'https://stage.myAPI.com'; } } now back in MyService and MockMyService we can inject this baseURL as well! services/MyService.ts export class MyService implements IMyService { @Inject private baseURL: string; // <-- 'https://prod.myAPI.com' public sayHello(name: string): void { console.log(Hello from the real service, ${name}!); console.log('baseURL is ', this.baseURL); } } services/MockMyService.ts export class MockMyService implements IMyService { @Inject private baseURL: string; // <-- 'https://stage.myAPI.com' public sayHello(name: string): void { console.log(Hello from the mock service, ${name}!); console.log('baseURL is ', this.baseURL); } } Full working code examples are available on github I hope this has been a useful explanation of some of the benefits of dependency injection. While this method is not perfect, it is very flexible and lets you fine tune its behaviour as much as you want/need.

Typescipt Dependency Injection


Typescript is a really powerful tool for making javascript more maintainable, easier to refactor and faster to write.
one of Typescript's strengths is that any javascript code is also valid Typescript so the migration of a legacy js codebase is easy!
While using any is about convenience, I consider it a code smell. Why?

### No advantage over vanilla js

When you use the `any` type, you are saying "please don't typecheck this" typescript will ignore any error you may make in using this type,

### Harder to change in the future

When you use `any`, you change the contract for your application and make it harder to refactor in the future. since there is no type safety, it's inherently harder to reason about and change.

### Makes you look lazy

Using `any` (except in the cases listed below) makes me think you were too lazy to do this the right way and provide a minimal typedef for your code.

## What to do instead

instead of using `any` I recommend fleshing it out as much as possible:

```ts
type MyType = {
    someField: number,
    otherFunc(): void
    // ...maybe other stuff
}
```

you can also use the optional operator for more flexibility:

```ts
type MyType = {
    someField?: number,
    otherFunc()?: void
    // ...maybe other stuff
}
```

The benefits here are numerous, namely that:

 1. This is MUCH easier to refactor, even if it is incomplete
 2. I get basic intellisense now when I use this type
 3. The compiler will now complain if we use it incorrectly
 4. You don't look lazy, yay!


Typescript is a really powerful tool for making javascript more maintainable, easier to refactor and faster to write. one of Typescript's strengths is that any javascript code is also valid Typescript so the migration of a legacy js codebase is easy! While using any is about convenience, I consider it a code smell. Why? No advantage over vanilla js When you use the any type, you are saying "please don't typecheck this" typescript will ignore any error you may make in using this type, Harder to change in the future When you use any, you change the contract for your application and make it harder to refactor in the future. since there is no type safety, it's inherently harder to reason about and change. Makes you look lazy Using any (except in the cases listed below) makes me think you were too lazy to do this the right way and provide a minimal typedef for your code. What to do instead instead of using any I recommend fleshing it out as much as possible: type MyType = { someField: number, otherFunc(): void // ...maybe other stuff } you can also use the optional operator for more flexibility: type MyType = { someField?: number, otherFunc()?: void // ...maybe other stuff } The benefits here are numerous, namely that: This is MUCH easier to refactor, even if it is incomplete I get basic intellisense now when I use this type The compiler will now complain if we use it incorrectly You don't look lazy, yay!

Typescipt 'any' is a code smell


I recently had the opportunity to use Vue.js in one of the backend WordPress plugins I was creating. I've used both React and Angular in past projects but I wanted something lightweight and quick to set up and use, Vue seemed like the perfect tool for the job.

This plugin was being created to make it easier for content and SEO team members to view information about different posts/pages in the back-end of WordPress. They needed to be able to see the ID, Slug and Title of each post on the site and quickly sort through them. The default WordPress admin view for pages is incredibly slow and the search is not very accurate so I set out to improve it.

To start out, I get the plugin initialized by adding our admin page. It's important to namespace our plugin as well to prevent global scope pollution.

```php 
<?php namespace PageInfo;

// We can pass add_action a closure instead of passing it a function name.
add_action('admin_menu', function() {
  add_menu_page(
    'All of the pageinfo',
    'Pageinfo',
    'edit_pages',
    'pageinfo',
    __NAMESPACE__.'\\createAdminPage',
    'dashicons-clipboard',
    6);
});
```

*read more about what [add_menu_page()](https://developer.wordpress.org/reference/functions/add_menu_page/) does.*

This will create our page in the backend of WordPress and adds a link to it in the admin sidebar. Anyone with permission to edit pages can access it.

Next, we need to set up the "createAdminPage()" function. We'll use it to build the content of our page. To start with, we need to make a new WP_Query that will grab all of the posts and pages on the site.

(In the future, I may just use the WordPress REST api to do this, since it saves a step.)

```php
function createAdminPage() {
  ?><div class="wrap"><?php

    /**
    * This queries WordPress for every page and post.
    * We need to use a '\' before WP_Query to tell php to use the global namespace, since that function does not exist in this scope.
    */
    $pageInfo = new \WP_Query([
      'post_type' => [
        'post',
        'page'
      ],
      'posts_per_page' => -1,
      'orderby' => 'ID',
      'order' => 'ASC'
    ]);
```

*read more about [namespaces](http://www.phptherightway.com/#namespaces)*

Now that we have that, we can create a new javascript object that contains all of those post's data and get our Vue object initialized.

```php

<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/vue/2.0.3/vue.min.js"></script>

<script>
new Vue({
  el: '#pageInfo',
  computed: {
    filteredPages: function () {
      return this.pages.filter(function(item){
        return item.url.indexOf(this.searchQuery) > -1;
      }.bind(this));
    }
  },
  data: {
    searchQuery: '',
    pages: [
      <?php if ($pageInfo->have_posts()): while($pageInfo->have_posts()):
        $pageInfo->the_post();
        $url = parse_url(get_the_permalink());
        ?>
        {
          url: '<?php echo $url['path']; ?>',
          id: '<?php the_ID(); ?>',
          title: '<?php the_title(); ?>',
        },
        <?php endwhile; endif; ?>
      ]
    }
  });
  </script>
```

With this we can construct our view layout in html with Vue tags.

```html
<div id="pageInfo" style="margin: 0 auto;width: 80%; max-width: 1024px;">

  <h1>Pages &amp; Posts</h1>
  <p><small><em>
    This page shows all of the existing posts and pages in an easy to read format. You can also filter by the page url.
  </em></small></p>

  <strong><label for="search">Filter</label></strong>
  <input v-model="searchQuery" name="search">
  <h2 v-if="!filteredPages.length">No results, sorry</h2>
  <p>{{ filteredPages.length }} result(s)</p>
  <table style="margin: 2em 0;" cellspacing="0" cellpadding="0">
    <thead>
      <tr>
        <th><strong>TITLE</strong></th>
        <th><strong>URL</strong></th>
        <th><strong>ID</strong></th>
      </tr>
    </thead>
    <tbody>
      <tr v-for="page in filteredPages">
        <td v-html="page.title"></td>
        <td><a v-bind:href="page.url">{{ page.url.slice(1).length > 0 ? page.url.slice(1) : "home" }}</a></td>
        <td>{{ page.id }}</td>
      </tr>
    </tbody>
  </table>
</div>
```

Add it all together, and you get something like this (I've added a few css styles to clean it up)

{% gist 44604a5a3aa63acef155cda7647ddbea pageinfo.php %}

You can drop this plugin file into the wp-content/mu-plugins/ folder and forget about it.


I recently had the opportunity to use Vue.js in one of the backend WordPress plugins I was creating. I've used both React and Angular in past projects but I wanted something lightweight and quick to set up and use, Vue seemed like the perfect tool for the job. This plugin was being created to make it easier for content and SEO team members to view information about different posts/pages in the back-end of WordPress. They needed to be able to see the ID, Slug and Title of each post on the site and quickly sort through them. The default WordPress admin view for pages is incredibly slow and the search is not very accurate so I set out to improve it. To start out, I get the plugin initialized by adding our admin page. It's important to namespace our plugin as well to prevent global scope pollution. [ 'post', 'page' ], 'postsperpage' => -1, 'orderby' => 'ID', 'order' => 'ASC' ]); read more about namespaces Now that we have that, we can create a new javascript object that contains all of those post's data and get our Vue object initialized. new Vue({ el: '#pageInfo', computed: { filteredPages: function () { return this.pages.filter(function(item){ return item.url.indexOf(this.searchQuery) > -1; }.bind(this)); } }, data: { searchQuery: '', pages: [ haveposts()): while($pageInfo->haveposts()): $pageInfo->the_post(); $url = parseurl(getthe_permalink()); ?> { url: '', id: '', title: '', }, ] } }); With this we can construct our view layout in html with Vue tags. Pages &amp; Posts This page shows all of the existing posts and pages in an easy to read format. You can also filter by the page url. Filter No results, sorry {{ filteredPages.length }} result(s) TITLE URL ID {{ page.url.slice(1).length > 0 ? page.url.slice(1) : "home" }} {{ page.id }} Add it all together, and you get something like this (I've added a few css styles to clean it up) {% gist 44604a5a3aa63acef155cda7647ddbea pageinfo.php %} You can drop this plugin file into the wp-content/mu-plugins/ folder and forget about it.

Vue.js and WordPress


# Functional Programming in ES6

Since I migrated one of the bigger projects at work to ES6, I've been more and more interested in functional programming and the idea of having little to no state mutation.

I feel that Javascript lends itself very well to functional programming paradigms, especially with the changes presented in ES6. You can use the basic prototype methods of the existing data structures right out of the box and be 90% of the way there. You just have to understand what's happening internally.

One of the ways that I've been improving my understading and skills recently has been with [CodeWars](https://www.codewars.com). Free code kata are a great way to challenge yourself with new problems and creative solutions. Since the problems presented on CodeWars are designed by the community, I've seen unique solutions to problems that I never would have dreamed of.

For example I saw one particular problem solved in 1 line of code with a reverse lookup RegEx. While it wasn't entirely practical since you would have to explain how it worked to almost everyone else on the team, it was exciting to see such a creative solution.

_Here's one example of a recent problem I solved:_


### Convert number to reversed array of digits
<blockquote>Given a random number, You have to return the digits of this number within an array in reverse order.
example: 348597 -> [7,9,5,8,4,3]</blockquote>


And my solution could look like this (there are shorter methods, but this is the one I wrote):

```js
const digitize = n => n.toString().split('').reverse().map(s => parseInt(s));
```


No variables are created, no existing data is mutated. It operates like a coin machine, data in, data out.



Here's another problem:

### Double String

<blockquote>Given a string, you have to return a string in which each character (case-sensitive) is repeated once.
example: doubleChar("String") ==> "SSttrriinngg"</blockquote>

And my solution:

```js
const doubleChar = str => str.split('').map((t) => t+t).join('');
```


Simple and easy to understand.

If you haven't given it a try, I highly recommend CodeWars as a place to improve your skills and see new ways to solve old problems.


Functional Programming in ES6 Since I migrated one of the bigger projects at work to ES6, I've been more and more interested in functional programming and the idea of having little to no state mutation. I feel that Javascript lends itself very well to functional programming paradigms, especially with the changes presented in ES6. You can use the basic prototype methods of the existing data structures right out of the box and be 90% of the way there. You just have to understand what's happening internally. One of the ways that I've been improving my understading and skills recently has been with CodeWars. Free code kata are a great way to challenge yourself with new problems and creative solutions. Since the problems presented on CodeWars are designed by the community, I've seen unique solutions to problems that I never would have dreamed of. For example I saw one particular problem solved in 1 line of code with a reverse lookup RegEx. While it wasn't entirely practical since you would have to explain how it worked to almost everyone else on the team, it was exciting to see such a creative solution. Here's one example of a recent problem I solved: Convert number to reversed array of digits Given a random number, You have to return the digits of this number within an array in reverse order. example: 348597 -> [7,9,5,8,4,3] And my solution could look like this (there are shorter methods, but this is the one I wrote): const digitize = n => n.toString().split('').reverse().map(s => parseInt(s)); No variables are created, no existing data is mutated. It operates like a coin machine, data in, data out. Here's another problem: Double String Given a string, you have to return a string in which each character (case-sensitive) is repeated once. example: doubleChar("String") ==> "SSttrriinngg" And my solution: const doubleChar = str => str.split('').map((t) => t+t).join(''); Simple and easy to understand. If you haven't given it a try, I highly recommend CodeWars as a place to improve your skills and see new ways to solve old problems.

Functional Programming


<span class="muted">This post was heavily inspired by a great article written by [Brianna Wiest](https://medium.com/personal-growth/avoiding-negativity-doesnt-make-you-more-positive-217e2bcf822f#.21ahd955u)</span>

I spend a lot of time thinking about how perception shapes my ideas and experiences.

What I see as a negative experience may be very positive to another individual, but why is that? What makes some people more capable of letting the irritations of life roll off their back.

<blockquote>“Inner peace is not the insistence that you can’t tolerate "negative" people, places or situations, it is having the ability to cope with them.”</blockquote>

For some people it's a natural inclination. You may be a more relaxed person and, as a side effect, you are less apt to become upset.

For others it may be a hard fought battle, requiring energy and self-awareness just to keep things at a bearable level.

I think one of the major contributing factors to unhappiness is being too bought in to one way of thinking. Your perception of an event is always going to be biased, but if you can view things as objectively as possible it may be easier to forget about what irked you in the first place.

One thought experiment I get to try this line of thinking on quite frequently is when ordering food.
Sometimes my order isn't quite right, or the people preparing the food are taking a long time. Maybe my sandwich has some ingredient I asked them to remove, or there's an overabundance of lettuce and hardly any meat. These are small but commonly annoying things that can't really be avoided.

It is in these moments that I will often pause and think for a moment:

Does my anger improve the situation? Is the person preparing my food that petty?

Probably not.

Am I able to fix the problem with minimal effort? Will they offer a solution?

Most likely.

It seems almost commonplace to assume malicious intent any time we perceive someone to have wronged us. We are creating the reason for our own unhappiness and allowing external situations beyond our control to determine our experience.


This post was heavily inspired by a great article written by Brianna Wiest I spend a lot of time thinking about how perception shapes my ideas and experiences. What I see as a negative experience may be very positive to another individual, but why is that? What makes some people more capable of letting the irritations of life roll off their back. “Inner peace is not the insistence that you can’t tolerate "negative" people, places or situations, it is having the ability to cope with them.” For some people it's a natural inclination. You may be a more relaxed person and, as a side effect, you are less apt to become upset. For others it may be a hard fought battle, requiring energy and self-awareness just to keep things at a bearable level. I think one of the major contributing factors to unhappiness is being too bought in to one way of thinking. Your perception of an event is always going to be biased, but if you can view things as objectively as possible it may be easier to forget about what irked you in the first place. One thought experiment I get to try this line of thinking on quite frequently is when ordering food. Sometimes my order isn't quite right, or the people preparing the food are taking a long time. Maybe my sandwich has some ingredient I asked them to remove, or there's an overabundance of lettuce and hardly any meat. These are small but commonly annoying things that can't really be avoided. It is in these moments that I will often pause and think for a moment: Does my anger improve the situation? Is the person preparing my food that petty? Probably not. Am I able to fix the problem with minimal effort? Will they offer a solution? Most likely. It seems almost commonplace to assume malicious intent any time we perceive someone to have wronged us. We are creating the reason for our own unhappiness and allowing external situations beyond our control to determine our experience.

Is it worth it?


## Let’s try a thought exercise.

Say we have a client with an established business who wants an eCommerce website that will sell their products and services.

You are told the budget is $5,000 and they don’t want to spend more than that. You accept the project and after some time, the shiny new bobslocalgoods.xyz is launched to the public.

The website is received well and the established customer base loves the ability to buy their favorite products online. Good Job! Within the first 2 months of operation the website generated $20,000 of revenue!

But wait, why did we think $5,000 was a fair price for a project that generated $20,000 in revenue in the first 2 months it was operational?  We could have charged much more than the original $5,000 and it still would’ve been a great investment for the client.

## Web Development and value

According to [BusinessDictionary.com](http://www.businessdictionary.com/), perceived value is defined as a customer’s opinion of a product’s value. It may have little or nothing to do with the product’s market price or realized value and depends entirely on their perception of the product’s ability to satisfy their needs.

If you don’t show your clients how valuable what you can do is, they will continue to perceive it as an expense and not an investment. This is a huge mistake! Don’t sell yourself short because the client doesn’t understand how valuable their project actually is.

The idea of hiring a web developer is daunting enough without thinking about the associated cost. People who don’t buy websites every day might not know all the options available, or how they might affect the price. It’s our job to help them figure that out. Most people have bought a car at some point, comparatively very few have bought a website or know how much one should cost.

__Charge for value, not time.__

## Figure out what the client really wants

Most clients will approach you with a wish list of features or desires. (If they don’t you should work with them to make one) Assign a cost and benefit to each one, then figure out which ones are crucial and which ones are nice to have. Not only does this help you scope the project, but you’ll have a nice list of priorities if you need to adjust something.

As an added benefit, they will feel like they have more ownership of what you’re building and it will be much easier to see the value you are providing them with.


Let’s try a thought exercise. Say we have a client with an established business who wants an eCommerce website that will sell their products and services. You are told the budget is $5,000 and they don’t want to spend more than that. You accept the project and after some time, the shiny new bobslocalgoods.xyz is launched to the public. The website is received well and the established customer base loves the ability to buy their favorite products online. Good Job! Within the first 2 months of operation the website generated $20,000 of revenue! But wait, why did we think $5,000 was a fair price for a project that generated $20,000 in revenue in the first 2 months it was operational? We could have charged much more than the original $5,000 and it still would’ve been a great investment for the client. Web Development and value According to BusinessDictionary.com, perceived value is defined as a customer’s opinion of a product’s value. It may have little or nothing to do with the product’s market price or realized value and depends entirely on their perception of the product’s ability to satisfy their needs. If you don’t show your clients how valuable what you can do is, they will continue to perceive it as an expense and not an investment. This is a huge mistake! Don’t sell yourself short because the client doesn’t understand how valuable their project actually is. The idea of hiring a web developer is daunting enough without thinking about the associated cost. People who don’t buy websites every day might not know all the options available, or how they might affect the price. It’s our job to help them figure that out. Most people have bought a car at some point, comparatively very few have bought a website or know how much one should cost. Charge for value, not time. Figure out what the client really wants Most clients will approach you with a wish list of features or desires. (If they don’t you should work with them to make one) Assign a cost and benefit to each one, then figure out which ones are crucial and which ones are nice to have. Not only does this help you scope the project, but you’ll have a nice list of priorities if you need to adjust something. As an added benefit, they will feel like they have more ownership of what you’re building and it will be much easier to see the value you are providing them with.

Web Development and Perceived Value


Since starting my new job at Knucklepuck Media in December, we’ve had a weekly book club where we discuss what we’re reading and anything that’s come up recently related to it. Dale Carnegie’s “How to Win Friends & Influence People” is what we’re working on now.

I really like this book, a lot of what’s discussed seems obvious but it’s really nice to have someone remind you once in a while. The fact that this is still a bestselling book is testament to just how relevant the content is.

The premise is simple: be kind to others, listen to what’s said and carefully consider their point of view. Admit your own faults quickly and ask questions instead of commanding. Lead by example with encouragement and  praise.

On a personal level, I regularly fail to do many of these things. Being reminded by such a thoughtful and well written book is not only good for day-to-day life but also helps set a precedent for myself going forward.

<blockquote>“The world is full of people who are grabbing and self-seeking. So the rare individual who unselfishly tries to serve others has an enormous advantage. He has little competition.”</blockquote>


Since starting my new job at Knucklepuck Media in December, we’ve had a weekly book club where we discuss what we’re reading and anything that’s come up recently related to it. Dale Carnegie’s “How to Win Friends & Influence People” is what we’re working on now. I really like this book, a lot of what’s discussed seems obvious but it’s really nice to have someone remind you once in a while. The fact that this is still a bestselling book is testament to just how relevant the content is. The premise is simple: be kind to others, listen to what’s said and carefully consider their point of view. Admit your own faults quickly and ask questions instead of commanding. Lead by example with encouragement and praise. On a personal level, I regularly fail to do many of these things. Being reminded by such a thoughtful and well written book is not only good for day-to-day life but also helps set a precedent for myself going forward. “The world is full of people who are grabbing and self-seeking. So the rare individual who unselfishly tries to serve others has an enormous advantage. He has little competition.”

How to Win Friends and Influence People


This week’s work playlist is brought to us by Jonathan Shariat

<iframe allowtransparency="true" frameborder="0" height="380" src="https://embed.spotify-current.ts.com/?uri=spotify-current.ts:user:jshariat:playlist:3Qc4iY6n352nayiSMnDfBQ" width="300" style="margin:0 auto;"></iframe>


This week’s work playlist is brought to us by Jonathan Shariat

Rdio is dead, long live Spotify

Tiny steps


Working on websites regularly leaves you needing certain things automated from time to time. Scripts minified and concatenated, Scss compiled autoprefixed and minified, code linted and built for production.

Our team at [The Wired Mouse](http://www.thewiredmouse.com/) had been using the default tools included with the [Omega 4](https://www.drupal.org/project/omega) starter theme. While it does get the job done, much of it is extremely slow and cumbersome when compared to the task runners of today, namely [GulpJS](http://gulpjs.com/). Gulp is great because you can write a simple package.json to cover all of your dependencies, and all of your tasks are written in simple Javascript.

---

After several months lamenting over the sad state of our build system I was finally able to take some time and get a basic Gulpfile set up.
In that short amount of time I was able to completely remove our dependency on [Compass](http://compass-style.org/), have all of our scripts concatenated, tested and minified into one master file and set up a watch task to recompile everything whenever a change is detected.

I am hoping to add [Browsersync](http://www.browsersync.io/) soon and [Gulp-sass](https://github.com/dlmanning/gulp-sass) when [LibSass](http://libsass.org/) reaches feature parity with the Ruby based Sass branch.


Working on websites regularly leaves you needing certain things automated from time to time. Scripts minified and concatenated, Scss compiled autoprefixed and minified, code linted and built for production. Our team at The Wired Mouse had been using the default tools included with the Omega 4 starter theme. While it does get the job done, much of it is extremely slow and cumbersome when compared to the task runners of today, namely GulpJS. Gulp is great because you can write a simple package.json to cover all of your dependencies, and all of your tasks are written in simple Javascript. After several months lamenting over the sad state of our build system I was finally able to take some time and get a basic Gulpfile set up. In that short amount of time I was able to completely remove our dependency on Compass, have all of our scripts concatenated, tested and minified into one master file and set up a watch task to recompile everything whenever a change is detected. I am hoping to add Browsersync soon and Gulp-sass when LibSass reaches feature parity with the Ruby based Sass branch.

GulpJS


Seeing recent trends with animation and how they increase overall esthetic and engagement is really cool. I love that the web is finally reaching a stage where animations and content live together natively.

That said, I am not a huge fan of the work required to write large animation sequences in Sass/css.
Hover and other simple effects are easy and performant to implement and use, but everything else gets complex and unweildy very quickly.

To solve this I've been using [Julian Shapiro's](https://twitter.com/Shapiro) [VelocityJS](http://julian.com/research/velocity/) in all of my recent projects.

One of the really great features of Velocity is that it is decoupled from other libraries, so you can use it with or without jQuery.(I used [Zepto](http://zeptojs.com/) on this site.) Having that much animation power in such a simple drop in syntax is really nice.

Since there are plenty of demos using VelocityJS around the web (many of them conveniently on Julian's [Codepen](http://codepen.io/julianshapiro/)) I am not going to go over demos. I will cover some use cases I've run into and places I would recommend avoiding use of Velocity in favor of sass/css.


### Where I find Velocity particularly useful:

---

* Page load animations (slideDownBigIn, fadeIn etc...) Just don't have animations that are long enough to slow down the apparent speed of your page.
+ Task completion such as submitting a form, placing an order or clicking a call to action.
+ Complex multi part animations (Multiple elements doing several things at specific intervals)
* Callouts and items that will conditionally need to be animated (missed form fields, important information/links etc...)


### Where I find velocity is unnecessary:

---


* Hover animations. Generally are easy to accomplish in css and shouldn't be overly complex anyway.
* Animations that happen continually. Unless they are complex, css is probably better suited to this.

I try to keep animations under 400ms(ideally <300ms) from start to finish. Go over that and you start to adversly affect user experience and it becomes an annoyance rather than a cool feature.

Before you animate something, really consider if it's actually adding anything or if you're just doing it because you can. Weigh the possible benefits vs the potential hits to performance, whether or not it's going to be "spammy" (happening very frequently and becoming an annoyance) or any other negative factors. The golden rule here is usually "Less is more".


Seeing recent trends with animation and how they increase overall esthetic and engagement is really cool. I love that the web is finally reaching a stage where animations and content live together natively. That said, I am not a huge fan of the work required to write large animation sequences in Sass/css. Hover and other simple effects are easy and performant to implement and use, but everything else gets complex and unweildy very quickly. To solve this I've been using Julian Shapiro's VelocityJS in all of my recent projects. One of the really great features of Velocity is that it is decoupled from other libraries, so you can use it with or without jQuery.(I used Zepto on this site.) Having that much animation power in such a simple drop in syntax is really nice. Since there are plenty of demos using VelocityJS around the web (many of them conveniently on Julian's Codepen) I am not going to go over demos. I will cover some use cases I've run into and places I would recommend avoiding use of Velocity in favor of sass/css. Where I find Velocity particularly useful: Page load animations (slideDownBigIn, fadeIn etc...) Just don't have animations that are long enough to slow down the apparent speed of your page. Task completion such as submitting a form, placing an order or clicking a call to action. Complex multi part animations (Multiple elements doing several things at specific intervals) Callouts and items that will conditionally need to be animated (missed form fields, important information/links etc...) Where I find velocity is unnecessary: Hover animations. Generally are easy to accomplish in css and shouldn't be overly complex anyway. Animations that happen continually. Unless they are complex, css is probably better suited to this. I try to keep animations under 400ms(ideally <300ms) from start to finish. Go over that and you start to adversly affect user experience and it becomes an annoyance rather than a cool feature. Before you animate something, really consider if it's actually adding anything or if you're just doing it because you can. Weigh the possible benefits vs the potential hits to performance, whether or not it's going to be "spammy" (happening very frequently and becoming an annoyance) or any other negative factors. The golden rule here is usually "Less is more".

Integrating VelocityJS

Vör is a CLI tool that makes it easy to connect Jira and Git/Github - all without leaving the command line!

Vör – Jira & Git made simple

A tree-walking interpreter for the Monkey programming language, written in golang

Monkey Interpreter

A simple DI library based on decorators, for Typescript

Latest Posts

Top Apps for Productivity in MacOS

6 Useful Shell Utilities to Make You More Productive

Using Readline like a pro

Write CLI scripts with Typescript

How to create a Typescript Singleton Decorator