Bash shell

The Bourne-Again SHell (source code), almost always referred to simply as "Bash", interprets and executes input entered from a source such as the user or a program. Bash is an implementation of the shell concept and is often used during Python software development as part of a programmer's development environment.

How do Python developers use Bash?

If you are programming in the terminal on macOS or Linux, or using the Windows Subsystem for Linux on Windows 10, you can easily gain access to Bash if it is not already your default shell.

You can show what shell you are currently using by echoing the SHELL environment variable, like so:

$ echo "$SHELL"

Which will then print the shell you are currently using. For example, on macOS I am using Bash by default so the echo command prints:

/bin/bash

How much you use Bash or any shell will likely depend on your development environment, especially if you are using an editor like Vim instead of an IDE like PyCharm, because it is often easier to do certain tasks in the shell. For example, most developers I know who use PyCharm will search for some instance of source code right in their IDE, whereas I use a combination of Vim and tmux so I frequently flip between panes to use commands like grep to do my source code searches.

There is no right way to perform a task like source code searching, it's really just what works for your brain as a developer that will guide how often you interact with the Bash shell.

Getting started with Bash

Working with a shell, Bash or otherwise, is intimidating the first time you try to get started. You are staring at the $ prompt without a whole lot of direction.

When you are completely new to using Bash, it is a good idea to at least scan, if not take some additional time for in-depth reading of the documentation for commands that every developer uses. The following commands are used so frequently in Bash that an experienced developer probably does not even think about them anymore, they become just a natural part of your workflow:

• echo: print text to the command line
• ls: list the contents of a directory
• cd: change the working directory
• cp: copy a file or directory
• mv: move one or more files
• rm: delete one or more files or directories

If you know how to use the above commands then you will at least be able to move around the file system, create, move and update files and know what is on your storage device(s).

The following commands are somewhat more advanced but also frequently used by developers:

• su: run comamnds as different users or groups
• whoami: print which user you are currently logged in as
• grep: searches for patterns in files

The above lists are not even close to exhaustive for what commands you need to know when working with Bash. Read some of the following introductory tutorials to gain a better understanding of working with this shell:

• The Linux command line for beginner by Ubuntu will provide you with context for how to use the command line, working with files and directories, and handling superuser commands.

• Bash Guide for beginners is an entire book for those new to working with command lines. It covers commands, paths, Bash shell scripting, variables and many other critical topics that are necessary to move from beginner to advanced Bash user.

• 101 Bash Commands and Tips for Beginners to Experts gives a well-done laundry list of tricks to explore.

• Bash Quick References is a cheat sheet for common operators and signals that come up when working with scripts.

Bash scripting

Bash is used not only as an interactive prompt but also for scripting, which makes it possible to execute one or more Bash commands stored within a file. These scripts can be short, with only a single command, or very complicated with control-flow logic, for loops, and almost anything you want to automate or compute because Bash is a Turing-complete programming language.

Complex Bash scripts sometimes get a negative reputation because they can be difficult to read and understand if you are not the original author (or you are reading your own script after a significant period of time has elapsed). There are many ways to accomplish the same tasks with Bash so the files are often confusing to read unless the author of a script included clear documentation. This readability problem is typically less of an issue with Python scripts because spacing is enforced and the standard library encapsulates common tasks.

It's a good idea to think about how you want to structure your Bash scripts as they grow larger. The following resources provide insight into what you should consider while coding Bash scripts.

• This minimal safe Bash template contains an 86-line Bash script that the author claims once you understand and use it as a base then it will make your scripts easier to maintain over time.

• Creating a bash completion script is a great tutorial that walks you through a reasonably complex Bash script for completing syntax in other Bash shell scripts.

• Anybody can write good bash (with a little effort) covers the basics of shell scripting and provides some recommendations for creating more maintainable scripts such as using linters and formatters.

• Google's Shell Style Guide covers how to write consistent, maintainable shell scripts, which is particularly important if you have ever tried to debug a hacky shell script that was never meant to be used by anyone other than the original author.

• Bash scripting quirks & safety tips explains Bash basic programming constructs like for loops and variable assignment then goes into ways to avoid weird issues in your code.

• If all else fails when you're trying to use Bash scripts, this article on replacing Bash scripts with Python is a guide on swapping in Python for administrative scripting, including what to do about replacing invaluable command line tools such as awk, sed and grep.

Additional Bash resources

The following resources cover more advanced Bash use cases and what pitfalls to try to avoid as you work with the shell or write scripts.

• Advancing in the Bash shell covers important concepts such as bang syntax, movement commands, tab completion and aliases.

• Mastering Bash and Terminal shows methods for repeating commands, changing directories and handling background processes.

• Ten Things I Wish I’d Known About Bash covers some edge cases that are very useful to know about such as proper exit code usage and configuration options through the set command. There is also a great follow up post called Ten MORE Things I Wish I'd Known About Bash that covers new topics such as on-the-fly command re-execution using the carrot character. The Seven Surprising Bash Variables post continues the series by examining built-in variables such as PROMPT_COMMAND, CDPATH and REPLY which can simplify your scripts by using values that Bash already has stored for you.

• Safe ways to do things in bash shows you how to not shoot yourself in the foot by using safe coding practices with your shell scripts.

• The Bash Infinity Framework source code provides boilerplate and a standard library for Bash projects so they are easier to read and maintain. If you have ever tried to read someone else's Bash scripts or even your own after setting them aside for a couple of months, you know that anything which makes readability better is a major step up from vanilla Bash.

• Static status is a Bash application that generates a hostable, customizable status page for your services.

• Using Aliases to Speed Up Your Git Workflow has a bunch of shell aliases that make it easier for you to execute complicated or uncommon Git commands.

• 6 Tips Before You Write Your Next Bash Cronjob covers starting your scripts with shebang, redirecting output, timeouts and sudo privileges.

• Better Bash history shows how to make your Bash history more useful by having it store more previous commands (which takes up more persistent storage but is not a huge deal in 2019) and add timestamps to the history command.

• 9 Evil Bash Commands Explained presents a list of commands you should never run, but can learn about their destructive abilities by reading through the descriptions provided by the author.

• Faster bash startup and Even faster bash startup are two great tutorials that will save you a bunch of time if you frequently open new Bash shells. On many systems you can easily cut down the startup time for the shell which can be unnecessarily sluggish.

• Bash HTTP monitoring dashboard (source code) is a useful application fully written in Bash shell scripts that monitors the health of one or more websites to make sure they are up and running.

What do you want to learn about Python development?