I’m always interested in learning more about useful development tools. In college, most programmers get an intro to the Linux command line environment, but I wanted to share some commands I use daily that I’ve learned since graduation.

Being comfortable on the command line is a great skill to have when a customer is looking over your shoulder on a Webex. They could be watching a software demo or deployment to their environment. It can also be useful when learning a new code base or working with a product with a large, unfamiliar directory structure with lots of logs.

If you’re on Windows, you can use Cygwin to get a Unix-like CLI to make these commands available.

Useful Linux commands


The command find helps you find files by recursively searching subdirectories. Here are some examples:

find .    Prints all files and directories under the current directory.

find . -name ‘*.log’   Prints all files and directories that end in “.log”.

find /tmp -type f -name ‘*.log’   Prints only files in the directory “/tmp” that end in “.log”.

find . -type d   Prints only directories.

find . -maxdepth 2     Prints all files and directories under the current directory, and subdirectories (but not sub-subdirectories).

find . -type f -exec ls -la {} \;      The -exec flag runs a command against each file instead of printing the name. In this example, it will run ls -la filename  on each file under the current directory. The curly braces take the place of the filename.


The command grep lets you search text for lines that match a specific string. It can be helpful to add your initials to debug statements in your code and then grep for them to find them in the logs.

grep foo filename  Prints each line in the file “filename” that matches the string “foo”.

grep foo\\\|bar filename Grep supports regular expressions, so this prints each line in the file that matches “foo” or “bar”.

grep -i foo filename  Add -i for case insensitive matching.

grep foo *  Use the shell wildcard, an asterisk, to search all files in the current directory for the string “foo”.

grep -r foo *  Recursively search all files and directories in the current directory for a string.

grep -rnH foo filename  Add -n to print line numbers and -H to print the filename on each line.

find . -type f -name ‘*.log’ -exec grep -nH foo {} \;  Combining find and grep can let you easily search each file that matches a certain name for a string. This will print each line that matches “foo” along with the file name and line number in each file that ends in “.log” under the current directory.

ps -ef | grep processName  The output of any command can be piped to grep, and the lines of STDOUT that match the expression will be printed. For example, you could use this to find the pid of a process with a known name.

cat file.txt | grep -v foo  You can also use -v to print all lines that don’t match an expression.


The command ln lets you create links. I generally use this to create links in my home directory to quickly cd into long directory paths.

ln -s /some/really/long/path foo  The -s is for symbolic, and the long path is the target. The output of ls -la  in this case would be foo -> /some/really/long/path .


The Bashrc is a shell script that gets executed whenever Bash is started in an interactive terminal. It is located in your home directory, ~/.bashrc . It provides a place to edit your $PATH, $PS1, or add aliases and functions to simplify commonly used tasks.

Aliases are a way you can define your own command line commands. Here are a couple useful aliases I’ve added to my .bashrc that have saved a lot of keystrokes on a server where I’ve installed Oracle WebCenter:

alias assets="cd /var/www/html"
alias portalLogs="cd $WC_DOMAIN/servers/WC_Spaces/logs"
alias domain="cd $WC_DOMAIN"
alias components="cd $WC_DOMAIN/ucm/cs/custom"
alias rpl="portalLogs; vim -R WC_Spaces.out"

After making changes to your .bashrc, you can load them with source ~/.bashrc . Now I can type rpl , short for Read Portal Logs, from anywhere to quickly jump into the WebCenter portal log file.

alias grep=”grep –color”

This grep alias adds the –color option to all of my grep commands.  All of the above grep commands still work, but now all of the matches will be highlighted.


Knowing Vim key bindings can be convenient and efficient if you’re already working on the command line. Vim has many built-in shortcuts to make editing files quick and easy.

Run vim filename.txt  to open a file in Vim. Vim starts in Normal Mode, where most characters have a special meeting, and typing a colon, : , lets you run Vim commands. For example, typing Shift-G  will jump to the end of the file, and typing :q  while in normal mode will quit Vim. Here is a list of useful commands:

:q  Quits Vim

:w  Write the file (save)

:wq  Write and quit

:q!  Quit and ignore warnings that you didn’t write the file

:wq!  Write and quit, ignoring permission warnings

i  Enter Insert Mode where you can edit the file like a normal text editor

a  Enter Insert Mode and place the cursor after the current character

o  Insert a blank line after the current line and enter Insert Mode

[escape]  The escape button exits insert mode

:150  Jump to line 150

shift-G  Jump to the last line

gg  Jump to the first line

/foo  Search for the next occurrence of “foo”. Regex patterns work in the search.

?foo  Search for the previous occurrence of “foo”

n  Go to the next match

N Go to the previous match

*  Search for the next occurrence of the searched word under the cursor

#  Search for the previous occurrence of the searched word under the cursor

w  Jump to the next word

b  Jump to the previous word

  Jump to the last action

dw  Delete the word starting at the cursor

cw  Delete the word starting at the cursor and enter insert mode

c$  Delete everything from the cursor to the end of the line and enter insert mode

dd  Delete the current line

D  Delete everything from the cursor to the end of the line

u  Undo the last action

ctrl-r ctrl-r  Redo the last action

d[up]  Delete the current line and the line above it. “[up]” is for the up arrow.

d[down]  Delete the current line and the line below it

d3[down]  Delete the current line and the three lines below it

r[any character]  Replace the character under the cursor with another character

~  Toggle the case (upper or lower) of the character under the cursor

v  Enter Visual Mode. Use the arrow keys to highlight text.

shift-V  Enter Visual Mode and highlight whole lines at a time.

ctrl-v  Enter Visual Mode but highlight blocks of characters.

=  While in Visual Mode, = will auto format highlighted text.

c  While in Visual Mode, c will cut the highlighted text.

y  While in Visual Mode, y will yank (copy) the highlighted text.

p  In Normal Mode, p will paste the text in the buffer (that’s been yanked or cut).

yw  Yank the text from the cursor to the end of the current word.

:sort  Highlight lines in Visual Mode, then use this command to sort them alphabetically.

:s/foo/bar/g  Highlight lines in Visual Mode, then use search and replace to replace all instances of “foo” with “bar”.

:s/^/#/  Highlight lines in Visual Mode, then add # at the start of each line. This is useful to comment out blocks of code.

:s/$/;/ Highlight lines in Visual Mode, then add a semicolon at the end of each line.

:set paste  This will turn off auto indenting. Use it before pasting into Vim from outside the terminal (you’ll want to be in insert mode before you paste).

:set nopaste  Make auto indenting return to normal.

:set nu  Turn on line numbers.

:set nonu  Turn off line numbers.

:r!pwd  Read the output of a command into Vim. In this example, we’ll read in the current directory.

:r!sed -n 5,10p /path/to/file  Read lines 5 through 10 from another file in Vim. This can be a good way to copy and paste between files in the terminal.

:[up|down]  Type a colon and then use the arrow keys to browse through your command history. If you type letters after the colon, it will only go through commands that matched that. (i.e., :se  and then up would help find to “:set paste” quickly).


The Vimrc is a configuration file that Vim loads whenever it starts up, similar to the Bashrc. It is in your home directory.

Here is a basic Vimrc I’d recommend for getting started if you don’t have one already. Run vim ~/.vimrc and paste in the following:

set backspace=2         " backspace in insert mode works like normal editor
syntax on               " syntax highlighting
filetype indent on      " activates indenting for files
set autoindent          " auto indenting
set number              " line numbers
colorscheme desert      " colorscheme desert
set listchars=tab:>-,trail:.,extends:>,precedes:<
set list                " Set up whitespace characters
set ic                  " Ignore case by default in searches
set statusline+=%F      " Show the full path to the file
set laststatus=2        " Make the status line always visible



Perl comes installed by default on Linux, so it is worth mentioning that it has some extensive command line capabilities. If you have ever tried to grep for a string that matches a line in a minified Javascript file, you can probably see the benefit of being able to filter out lines longer than 500 characters.

grep -r foo * | perl -nle’print if 500 > length’


I love learning the tools that are available in my development environment, and it is exciting to see how they can help customers as well.

Recently, I was working with a customer and we were running into SSL issues. Java processes can be run with the option -Djavax.net.ssl.trustStore=/path/to/trustStore.jks  to specify which keystore to use for SSL certificates. It was really easy to run ps -ef | grep trustStore to quickly identify which keystore we needed to import certificates into.

I’ve also been able to use various find and grep commands to search through unfamiliar directories after exporting metadata from Oracle’s MDS Repository.

Even if you aren’t on the command line, I’d encourage everyone to learn something new about their development environment. Feel free to share your favorite Vim and command line tips in the comments!

Further reading