Database Reference
In-Depth Information
CHAPTER 4
Creating Reusable Command-Line Tools
Throughout the topic, we use a lot of commands and pipelines that basically fit on
one line (let's call those
one-liners
). Being able to perform complex tasks with just a
one-liner is what makes the command line powerful. It's a very different experience
from writing traditional programs.
Some tasks you perform only once, and some you perform more often. Some tasks
are very specific and others can be generalized. If you foresee or notice that you need
to repeat a certain one-liner on a regular basis, it's worthwhile to turn this into a
command-line tool of its own. Both one-liners and command-line tools have their
uses. Recognizing the opportunity requires practice and skill. The advantage of a
command-line tool is that you don't have to remember the entire one-liner and that it
improves readability if you include it into some other pipeline.
The benefit of working with a programming language is that you have the code in a
file. This means that you can easily reuse that code. If the code has parameters it can
even be applied to problems that follow a similar pattern.
Command-line tools have the best of both worlds: they can be used from the com‐
mand line, accept parameters, and only have to be created only once. In this chapter,
we're going to get familiar with creating reusable command-line tools in two ways.
First, we explain how to turn one-liners into reusable command-line tools. By adding
parameters to our commands, we can add the same flexibility that a programming
language offers. Subsequently, we demonstrate how to create reusable command-line
tools from code you've written in a programming language. By following the Unix
philosophy, your code can be combined with other command-line tools, which may
be written in an entirely different language. We'll focus on two programming lan‐
guages: Python and R.
