Difference Between bin and sbin

Ever been curious about the difference between bin and sbin? The ‘s’ in sbin means ‘system’. Therefore, system binaries reside in sbin directories.

As you may have noticed, there are a number of different bin directories in Linux. The best reference I’ve found for an understanding of various Linux folders is man hier. It provides a brief explanation of the Filesystem Hierarchy Standard (FHS) in Linux. I’ve included a summary of the various bin and sbin definitions below:

    This directory contains executable programs which are needed
    in single user mode and to bring the system up or repair it.

    Like /bin, this directory holds commands needed to boot the 
    system, but which are usually not executed by normal users.

    This is the primary directory for executable programs. Most
    programs executed by normal users which are not needed for 
    booting or for repairing the system and which are not
    installed locally should be placed in this directory.

    This is where programs which are local to the site typically

    Binaries for programs local to the site.

    Locally installed programs for system administration.

If you want to create your own scripts and make them available to all users, you’re pretty safe adding them to /usr/local/bin. If you want to run scripts using cron or crontab, simply use the full path to the command (i.e. /home/user/command).

What I do is add my scripts to my local bin (~/bin) and then I create a symbolic link in /usr/local/bin to the commands I want to make public. As a result, I can manage all my scripts from the same directory but still make some of them publicly available since /usr/local/bin is added to $PATH.

Customize Your Shell & Command Prompt

As mentioned in a previous post, we received some new MacBooks and a Mac Mini at work. Since most of my team prefers using PCs, I was able to get my hands on one. I immediately noticed how different it was from the one I use at home, so I started customizing it right away. I found I had forgotten how to do a couple things and it took me longer than I would have liked to search the web, so I’ve decided to dedicate a short post on how to customize your shell and command prompt in Mac OS X.

If you use Linux or Windows (think cygwin or git bash) this may apply to you too. If you don’t use any sort of shell, well, then you might just want this for future reference.


Terminal is the default app that comes with Mac OS X. Another great app is iTerm 2 (Free). It adds a lot of functionality that some users find lacking in Terminal.

General Preferences

Some programs that run the shell allow you to set the window size and buffer (essentially scrolling inside the limitations of the window). This is really helpful to setup before hand since lines that are too long will word wrap if you don’t have a large window buffer. This will inevitably happen at some point and it’s really annoying when it does, so take steps to prevent it now.

If you find you navigate to a specific directory every time you open the shell, it may be a good idea to tell the app to navigate to that directory when you open the shell. In Terminal, this can be found at Preferences >> Settings >> Shell; in iTerm 2 this can be found at Preferences >> Profiles >> General. There are a lot of other cool features (like window groupings) that you should checkout.


The next thing you’re going to want to do is customize your shell’s color. I like the traditional black background with white or light gray text and some colorful highlighting like green or even just a plain grey.

For my shell’s font, I like to use Monaco 10pt.  Smaller text let’s me see more on the screen since I usually only let my shell take up one half of the screen. I enable bold fonts and bright colors for bold fonts, but I disable anti-aliasing (smooth edges) because I like that raw hacker feel ;).

.profile, .bash_profile or .bashrc

Some of the most important customization takes place in the .profile file. Every time your shell loads, it will run the commands found in the “profiles.” There are a number profiles some system-wide (e.g. /etc/profile), others personal (e.g. .profile). The bash man page provides useful information about the differences under the “INVOCATION” section:

When bash is invoked as an interactive login shell, or as a non-
interactive shell with the --login option, it first reads and executes
commands from the file /etc/profile, if that file exists. After
reading that file, it looks for ~/.bash_profile, ~/.bash_login, and
~/.profile, in that order, and reads and executes commands from the
first one that exists and is readable. The --noprofile option may be
used when the shell is started to inhibit this behavior.

When a login shell exits, bash reads and executes commands from the
file ~/.bash_logout, if it exists.

When an interactive shell that is not a login shell is started, bash
reads and executes commands from /etc/bash.bashrc and ~/.bashrc, if
these files exist. This may be inhibited by using the --norc option.
The --rcfile file option will force bash to read and execute commands
from file instead of /etc/bash.bashrc and ~/.bashrc.

Then at the bottom of the man page:

              The bash executable
              The systemwide initialization file, executed for login shells
              The systemwide per-interactive-shell startup file
              The systemwide login shell cleanup file, executed when a login shell exits
              The personal initialization file, executed for login shells
              The individual per-interactive-shell startup file
              The individual login shell cleanup file, executed when a login shell exits
              Individual readline initialization file

In essence, .bash_profile is read upon login and .bashrc is read for each new shell opened since you can have multiple shell sessions running at once without logging in again. In Mac OS X, the .bash_profile overrides the .profile. I’ve run into some problems with .profile in the past, so I’ve actually switched everything to .bash_profile.

The next four sections will discuss:

  • How to change prompt escapes (bash)
  • How to change prompt color (bash)
  • How to create your personal “bin”
  • How to create aliases

Change Prompt Escapes

First, I like to customize the prompte e. I can’t stand it when the prompt is white and blends in with the rest of the text in the shell. The appearance of the prompt is stored in the environment variable $PS1. Try typing echo $PS1 in your shell. The text you see is a string coded with the display setting for your shell’s prompt. It might look something like this:

\h:\W \u$

In this example, the \h represents the host computer, \W the working directory and \u the current user. All this information makes sense if you were to use the CLI a lot. “Back in the old days,” people would interface between various servers or computers over a network (esp. in business scenarios). When you’d change to a different server, you’d want to know the host computer you were accessing. Not all the computers had GUIs. Thus \h would let you know which computer you were on; whether you were on yours or another.

The \u is common for similar reasons. Sometimes you use the su command to substitute user and you’ll want to know which user you are acting as.

The \W should be self explanatory. You don’t want to have to type pwd or ls all the time to know where you are at in the file hierarchy.

In my prompt, I’ve gotten rid of the host symbol (I don’t switch hosts often and when I do, the other prompt is usually different enough that I can tell I’m on a different machine) and replaced it with the history number prompt escape (\!). This escape let’s you know which number in the command history you have just typed. That way if you see a previous command that you’d like to repeat a couple lines up you just type !<number>. To view your complete command history, type the command history. A simplified version of my prompt looks like this:

\! \u:\W$

Here’s a comprehensive list of prompt escapes to add to your prompt:

\a         # an ASCII bell character (07)
\d         # the date in "Weekday Month Date" format (e.g., "Tue May 26")
\D{format} # the format is passed to strftime(3) and the result
           # is inserted into the prompt string an empty format
           # results in a locale-specific time representation.
           # The braces are required
\e         # an ASCII escape character (033)
\h         # the hostname up to the first '.'
\H         # the hostname
\j         # the number of jobs currently managed by the shell
\l         # the basename of the shell's terminal device name
\n         # newline
\r         # carriage return
\s         # the name of the shell, the basename of $0 (the portion following
           #   the final slash)
\t         # the current time in 24-hour HH:MM:SS format
\T         # the current time in 12-hour HH:MM:SS format
\@         # the current time in 12-hour am/pm format
\A         # the current time in 24-hour HH:MM format
\u         # the username of the current user
\v         # the version of bash (e.g., 2.00)
\V         # the release of bash, version + patch level (e.g., 2.00.0)
\w         # the current working directory, with $HOME abbreviated with a tilde
\W         # the basename of the current working directory, with $HOME
           # abbreviated with a tilde
\!         # the history number of this command
\#         # the command number of this command
\$         # if the effective UID is 0, a #, otherwise a $
\nnn       # the character corresponding to the octal number nnn
\\         # a backslash
\[         # begin a sequence of non-printing characters, which could be used
           #   to embed a terminal control sequence into the prompt
\]         # end a sequence of non-printing characters

Change Prompt Color

To color code your prompt on a Mac, use the following template:


Most Linux distributions use a little different format:


The first portion before the desired prompt escape or text only begins painting the chosen color (e.g., \[\033[1;34m\]). To stop painting a color, you have to reset to another color or turn color off (e.g., \[\033[0m\]).

Here’s a comprehensive list of color encoding:

# Regular Colors
\[\033[0;30m\] # Black
\[\033[0;31m\] # Red
\[\033[0;32m\] # Green
\[\033[0;33m\] # Yellow
\[\033[0;34m\] # Blue
\[\033[0;35m\] # Purple
\[\033[0;36m\] # Cyan
\[\033[0;37m\] # White

# High Intensty
\[\033[0;90m\] # Black
\[\033[0;91m\] # Red
\[\033[0;92m\] # Green
\[\033[0;93m\] # Yellow
\[\033[0;94m\] # Blue
\[\033[0;95m\] # Purple
\[\033[0;96m\] # Cyan
\[\033[0;97m\] # White

# Background
\[\033[40m\] # Black
\[\033[41m\] # Red
\[\033[42m\] # Green
\[\033[43m\] # Yellow
\[\033[44m\] # Blue
\[\033[45m\] # Purple
\[\033[46m\] # Cyan
\[\033[47m\] # White

# High Intensty backgrounds
\[\033[0;100m\] # Black
\[\033[0;101m\] # Red
\[\033[0;102m\] # Green
\[\033[0;103m\] # Yellow
\[\033[0;104m\] # Blue
\[\033[10;95m\] # Purple
\[\033[0;106m\] # Cyan
\[\033[0;107m\] # White

#Replace any leading leading 0; with 1; for bold colors
#Replace any leading 0; with 4; to underline

Once you’ve decided on the appropriate prompt add export PS1=”<custom prompt>” to your .profile. For example, this is what the line in my .profile looks like:

export PS1="\[\033[1;34m\]\!\[\033[0m\] \[\033[1;35m\]\u\[\033[0m\]:\[\033[1;35m\]\W\[\033[0m\]$ "

Add Personal “bin” to the PATH Variable

Every now and again you may want to create your own custom commands, scripts or programs for the CLI. Instead of mixing these in with the rest of the OS’s, just create your own personal “bin” folder and add it to your PATH variable so that you can run those commands from any folder in the shell.

export PATH=$PATH:/Users/Taylor/bin

Create & Use Aliases

Aliases are really nifty. They can save you a lot of extra effort for frequently used and/or lengthy commands. For example, I found that I liked to use ls -lhaG a lot more than just ls as follows:

alias ls='ls -lhaG'

Alias long commands that you’d forget or never want to type. I use Git to version my code. The git log command is very powerful and can include a lot of options. Instead of typing the various options every time, I use an alias called glg:

alias glg='git log --date-order --all --graph --format="%C(green)%h%Creset %C(yellow)%an%Creset %C(blue bold)%ar%Creset %C(red bold)%d%Creset%s"'


At the end of the day, this is what my .bash_profile looks like:

UPDATED 2014-04-02

### MY ALIASES ###

# git command autocompletion script
source ~/bin/git-completion.bash

# git commamands simplified
alias gst='git status'
alias gco='git checkout'
alias gci='git commit'
alias grb='git rebase'
alias gbr='git branch'
alias gad='git add -A'
alias gpl='git pull'
alias gpu='git push'
alias glg='git log --date-order --all --graph --format="%C(green)%h%Creset %C(yellow)%an%Creset %C(blue bold)%ar%Creset %C(red bold)%d%Creset%s"'
alias glg2='git log --date-order --all --graph --name-status --format="%C(green)%H%Creset %C(yellow)%an%Creset %C(blue bold)%ar%Creset %C(red bold)%d%Creset%s"'

# ls alias for color-mode
alias lh='ls -lhaG'

# lock computer
alias lock='/System/Library/CoreServices/"Menu Extras"/User.menu/Contents/Resources/CGSession -suspend'

# hibernation and sleep settings
alias hibernate='sudo pmset -a hibernatemode 25'
alias sleep='sudo pmset -a hibernatemode 0'
alias safesleep='sudo pmset -a hibernatemode 3'
alias smartsleep='sudo pmset -a hibernatemode 2'

# up 'n' folders
alias ..='cd ..'
alias ...='cd ../..'
alias ....='cd ../../..'
alias .....='cd ../../../..'

# simple ip
alias ip='ifconfig | grep "inet " | grep -v | cut -d\ -f2'
# more details
alias ip1="ifconfig -a | perl -nle'/(\d+\.\d+\.\d+\.\d+)/ && print $1'"
# external ip
alias ip2="curl -s http://www.showmyip.com/simple/ | awk '{print $1}'"

# grep with color
alias grep='grep --color=auto'

# proxy tunnel
#alias proxy='ssh -D XXXX -p XXXX USER@DOMAIN'
# ssh home
#alias sshome='ssh -p XXXX USER@DOMAIN'

# processes
#alias ps='ps -ax'

# refresh shell
alias reload='source ~/.bash_profile'


# Add homebrew sbin to PATH variable
export PATH=$PATH:/usr/local/sbin

# Add personal bin to PATH variable
export PATH=$PATH:/Users/Taylor/bin    # May be redundant; check ~/.bash_profile, /etc/profile, /etc/paths, /etc/bashrc

# Show dirty state in prompt when in Git repos

# Change prompt
export PS1='\[\033[1;34m\]\!\[\033[0m\] \[\033[1;35m\]\u\[\033[0m\]:\[\033[1;35m\]\W\[\033[0m\] \[\033[1;92m\]$(__git_ps1 "(%s)")\[\033[0m\]$ '

What have you done to customize your shell or change your command prompt?

Can’t Sleep? Blame Your LED Backlit Screen

Blue Lightwaves Disrupt Sleep But Improve CognitionA lot of studies have explored the potential negative effects of light pollution and overexposure to light. Some studies suggest excess exposure is related to insomnia (this might come as a shock…not) and diseases like Alzheimer’s or Breast Cancer. With regard to light wavelengths, the blue wavelength is one of particular interest, especially for those of us who use mobile electronics on a daily basis.

Melatonin & Blue Light

The New York Times published an article that quotes researchers who discuss some of the effects blue light has on our eyes and the chemical imbalance of melatonin. Melatonin is a hormone that responds directly to any kind of light. As night approaches and the amount of light decreases, the body releases melatonin, which “promotes sleep and alerts a variety of biological processes to the approximate hour of the day.” However, when light strikes the retina, or back of the eye, melatonin is suppressed.

…there lies the rub. In this modern world, our eyes are flooded with light well after dusk, contrary to our evolutionary programming. Scientists are just beginning to understand the potential health consequences. The disruption of circadian cycles may not just be shortchanging our sleep, they have found, but also contributing to a host of diseases.

Scientists like George Brainard, a neurologist at Thomas Jefferson University in Philadelphia, have observed that blue light is especially effective at suppressing melatonin. Why is this relevant? Many backlit electronic screens implement LED technology that uses blue wavelength emitting diodes.

The Experiments

A group of researchers at the University of Basel in Switzerland conducted a study using 13 men that were asked to sit in front of different types of computer screens before retiring to bed. During one week, they spent five hours in front a fluorescent, red-based screen that emitted little blue light. During another week, they spent five hours in front of a LED, blue-based screen that emitted twice as much blue light. Notice the first screen emitted barely any blue, so twice as much blue light is significantly more, but it doesn’t mean the screen was screaming blue. This is significant to me because it seems to indicate that the study was more realistic and not taken out of context from the kinds screens people actually look at. So what were the results?

Melatonin levels in volunteers watching the LED screens took longer to rise at night, compared with when the participants were watching the fluorescent screens, and the deficit persisted throughout the evening.

And this is the most intriguing part:

The subjects also scored higher on tests of memory and cognition after exposure to blue light, Dr. Cajochen and his team reported in the May issue of The Journal of Applied Physiology. While men were able to recall pairs of words flashed across the fluorescent screen about half the time, some scores rose to almost 70 percent when they stared at the LED monitors.

My first impression after reading that was that I’ll continue to study for tests using my computer. Maybe that explains higher tests scores when I do use my computer? I haven’t looked into it but it’s an interesting thought.


Again, why is this relevant? Because we are readily replacing old red light technology like incandescent bulbs with new energy-efficient blue light technology like LEDs. Most of our new electronic screens use LED technology (TVs, laptops, flat screen monitors, mobile phones, etc.).

Research isn’t absolutely conclusive since this is a relatively immature field of study, but the findings are starting to lead scientists to more concrete conclusions. Health agencies are starting to make statements. The World Health Organization concluded that irregularities in biological clock patterns “can alter sleep-activity patterns, suppress melatonin production and disregulate genes involved in tumor development.” The Journal of the American Medical Directors Association made conclusions regarding the boost in cognitive processes made by subjects exposed to blue light as opposed to red light.

Technological Solutions

If you’re a little paranoid about your health, or maybe you want to ensure you’re sleeping your best, there are some technological solutions. f.lux (Mac, iPhone/iPad, Windows & Linux) is a free program that automatically adjusts the amount of blue light emitted by your screen depending on the time of day. So in the evening the screen changes to redder tones. During morning hours, screen color is designed to emulate natural sunlight. Don’t worry, your whole screen won’t turn red; you’ll just notice a it feels a bit warmer with regard to color temperature. You can also customize it for the best experience by adjusting how fast it transitions, how much the color changes and what kind of lighting you are surrounded with.

I suggest you give f.lux a try as today’s mini-app of the day. I’ve found it rests my eyes a bit more in the evening if nothing else.

Another Mac only alternative is a prefpane app called Shades.

f.lux Screenshot

Examples of Other Light Related Studies

If you’re interested in learning a bit more you can check out the articles listed on Stereopsis’s research link (the group that developed f.lux) or read some of the studies listed below.

Compare Files Line-by-Line (or Image-to-Image)

Two of my favorite tools for line-by-line text comparison are diff and FileMerge. One reason why I like them so much is because they are lightweight alternatives for word processors like Microsoft Word, which you wouldn’t be inclined to open for coding (that’s one of my primary uses).

diff is a simple CLI-based tool accessible on most *nix systems. The basic format is diff <options> <file1> <file2>. It comes with a lot of powerful options too. To list a few:

  • Ignore tab expansion, blank lines, and other white space
  • Ignore case
  • Ignore matching lines
  • Side-by-side output
  • Compare files in directories
  • Recurse through subdirectories
  • Reporting identical files or simply whether or not differences exist

FileMerge is as simple as it gets for file comparison with a GUI. FileMerge comes with any installation of Xcode so it’s basically free. However, you’ll have to download the whole Xcode package (~1 GB) to get it unless you can find it floating around on the net alone.

FileMerge Screenshot

FileMerge allows you to select the changes you want to keep through a menu at the bottom-right that designates the favored document. By default, the right (as opposed to left) document is selected. Below the two separate documents is the final output that will result from the merge. FileMerge also allows you to edit/add content in this section before merging and saving.

As I was writing this post, I got a referral from Russ to a cross-platform comparison tool called Perforce. The cool thing about Perforce (besides being platform agnostic) is it compares not only files and folders, but images too. Not to mention it’s FREE. I only briefly read about it and watched some sample videos on the site, but it’s pretty powerful. It also can be used in parallel with Git. Read about it here.

After the recommendation to checkout Perforce, I started doing some more research and stumbled upon a couple other tools. First off, free code editor TextWrangler (Mac) includes file comparison. Diffmerge seems like a really cool alternative. It’s also free, available on multiple pllatforms and includes merging of 3 files and integration with Windows Explorer. Kaleidoscope is another option, though you’ll have to pay ~$40. It includes many of the same features as Perforce.

What do you use when you need to compare files? Have any recommendations?

App of the Day: Sublime Text 2

Sublime Text 2 IconThere are a lot of different text/code editors out there. Some people swear by Coda ($99) or TextMate (~$50). Others prefer TextWrangler because it’s free and still has plenty of power to get the job done. If your a PC person, Notepad++ may be your weapon of choice. This post isn’t meant to be a review or comparison of the different text editors out there, but simply an introduction to another awesome alternative that I think is more unheard of than not.

Last summer a close friend referred me to Sublime Text 2. Before Sublime, I used TextWrangler, and I gotta say, the wrangler is great, but I just didn’t connect with it for some reason. I’ll admit, I didn’t really research all its functionality or install very many plugins, but I’ve heard great things. Regardless, Sublime resonated with me instantly.

Sublime is clean; no buttons all over the place. It’s got this awesome “1000 ft” distance view that can be used to scroll fast through code or find a section of your code through pattern recognition in the line structure. I’ve found it very helpful since I often use it to look through error stack traces, which are very pattern prone and are often thousands of lines long. Sublime has syntax highlighting for just about every language possible (much like other editors). You can control the preferences really easily too, changing just about any functionality. For example if you don’t like the “1000 ft view,” you can turn that off. Did I mention autocomplete? Yup…and while this isn’t language specific, it’s surprisingly smart and very helpful. Not nearly as powerful as autocomplete in Xcode, NetBeans or the like, but still a very useful feature.

These are just a few of the features that came to mind first and that I’ve found very helpful. Here’s a list of a few more (This comes straight from the documentation):





Oh and…Sublime is pretty platform agnostic. It’s available on Mac OS X, Linux and Windows (32- & 64-bit). You can also download “portable” versions for Windows that are self-contained so if you just want to try it out or keep it lite, you don’t have to worry about it installing extra garbage in your registry or system folders.

Sublime isn’t technically “free.” Here’s what the author has to say about that:

Sublime Text 2 may be downloaded and evaluated for free, however a license must be purchased for continued use. There is currently no enforced time limit for the evaluation.

So in other words, you can use it indefinitely without any limitations. I think it asks you to buy a license after every 25 saves or something? I didn’t find it very annoying personally. After I realized I really liked it, I just asked my company to buy me a license for work. The downside is that if you can’t work a deal like that then it costs $59 for one license.

Try it out and tell me what you think. What’s it missing? Would you switch?

*UPDATE* You should really check out Tuts+ for a list of very useful tips and tricks for Sublime Text 2. It will blow your mind if you don’t know about these features already.

Sublime Syntax Spell Checking

Syntax Spell Checking

Sublime Syntax Highlighting Javascript in HTML in PHP

Syntax Highlighting Javascript in HTML in PHP? No problem...

Sublime Multiple Selections

Make Multiple Selections

Sublime Find and Replace with Regex

Find and Replace with Regex

Sublime Edit Side-by-Side

Editing side-by-side

App of the Day: Console

ConsoleI currently work as a Quality Engineer at Palantir Technologies. I do a lot of feature and product testing. As a result, one of the most common tools for testing is the POSIX tool tail.

Linux/Unix/Mac users may be familiar with tail. In layman terms, tail allows you to grab a number of lines at the end of a text based file. In testing, we use tail -f <filename> a lot because the “f” option immediately and automatically updates the CLI with the most recently written lines of text in the file you are tailing. Testers love this because they like to see the stack traces printed on their screen the moment something errors in a program or system. Many development environments have consoles built in for errors and system printing and logging (think Eclipse, NetBeans, etc.). Java based programs also have the option of having the Java console automatically open when you run a Java based program.

On my Windows box at work, I use Cygwin to run the tail command. Cygwin is a Linux-like environment for Windows that allows users to port software running on POSIX systems (such as Linux, BSD, and Unix systems) to Windows. On my Mac, I just use Terminal. However, more recently I’ve discovered an even greater tool called Console. Console actually comes as a pre-installed utility with the Mac OS X operating system. I’ve found that the Utilities folder is full of great (whadoyaknow!) utility apps. I suggest you take a gander through that folder if you haven’t already. I’ve used the Grapher app in my ECON 110 class this semester a couple times (back when I used to take notes on my computer; I’ve since switched to paper since we do more graphing than anything else. Which reminds me about a great note taking app for iPad called Notes Plus. Alas, I digress. I will save that discussion for another post.).

The reason I love Console most, is because you can tell it to bounce in the dock when stack traces print to it. You don’t have to have it open on a second monitor so it’s always visible, or worse yet peaking out on the side of the screen behind the program you are testing. Better yet, you can actually choose to have it come to the forefront for a limited amount of time (say 5 seconds) and then disappear in the background again. I’ve searched for something like this on Windows and haven’t seen anything like it. Probably because there are IDE’s and stuff, but regardless, it’s a beaut. It has other great functions for console type stuff too. Check it out if you’re a tester or programmer. It might be pretty handy.

Console for Mac OS X