 Courses from Cameron Nokes

Extracting meaningful data from strings is a crucial skill when working with bash, and bash gives us powerful tools to do so: `head`, `tail`, `cut`, `sed`, and `awk`. But these tools can be hard to understand without spending time to learn them, so many developers fall into a rut of blindly copying and pasting commands. No more! With this mini-course, you'll understand the basic ins and outs of these commands in under 15 minutes. 


Bash is a Unix shell and command language written by Brian Fox for the GNU Project as a free software replacement for the Bourne shell. Bash is a command processor that typically runs in a text window, where the user types commands that cause actions. Bash can also read and execute commands from a file, called a shell script.

bash

Manipulating strings in bash

Bash makes automation easy. Just a few lines of code can take care of repetitive tasks for you and your teammates. 

In this course, we’ll dive deep into the automation potential of bash. You’ll learn to leverage common hooks that open up interesting automation possibilities, like git hooks, adding functions and aliases in your bash_profile, and running scheduled jobs in launchd.

For example, we’ll write a git hook that checks package.json for changes, and if there are changes, the hook runs npm install for you automatically. 

Along the way, you’ll also learn:

- more advanced bash commands like exec
- syntax such as redirecting stdout and stderr to the same destination
- timesaving tricks like brace expansions

Automation is all about saving you time — and at only 52 minutes, this course is well worth yours. Enjoy!

Advanced Bash Automation for Web Developers



Humans were never meant to repeat joyless tasks in a precise manner, over and over and over. Computers are meant precisely for these types of tasks.

Bash is a ubiquitous technology in web development that gives you the immense power of automating repetitive tasks you find yourself performing throughout the day.

The topics we cover will give you confidence in creating build scripts that run on continuous integration servers or quickly testing and debugging an API with `curl`. We’ll go over:  - Interacting with the file system - Creating, moving, copying, and deleting files and folders - Finding files and text patterns in files - Creating and running scripts - Language syntax like variables and conditionals.

Automate Daily Development Tasks with Bash

In this lesson, we’ll learn how to change the working directory using `cd` and list a directory's contents using `ls`. We'll see how `ls`'s `-l` and `-a` flags work. 

Navigate the Filesystem in Bash

Sometimes when working at the command line, it can be handy to view a file’s contents right in the terminal, or open a file with a certain application. We’ll learn how to view files in the terminal using `cat` and `less` and we’ll learn how to open them with `open`.

View Files and Folders in Bash

One of the most useful things you can automate with bash is creating and deleting files and folders. We’ll learn how to create a file with `touch` and append content to it with `echo`. Then we’ll create a directory with `mkdir`. Using `rm`, we’ll then remove files and folders. 

Create and Delete Files and Folders in Bash

In this lesson we’ll learn how to move and rename files (`mv`) and copy (`cp`) them. 

Move and Copy Files and Folders with Bash

`find` is a powerful tool that can not only find files but it can run a command on each matching file too. In this lesson, we’ll learn how to find all the images that match a pattern and run an image optimization tool on them. 

Find Files and Folders with `find` in Bash

A Unix command used to search files for the occurrence of a string of characters that matches a specified pattern.

grep

In this lesson, we’ll use `grep` to find text patterns. We’ll also go over some of the flags that `grep` has that can be combined together to make it more powerful and easier to read.

Search for Text with `grep`

In the lesson, we’ll learn how to encapsulate some logic we want to easily run later in a script. After creating the script, we have to use `chmod u+x` to give it execute permissions. If we want our script to make use of parameters passed to it when it's invoked, we can reference them using the syntax `$1`, `$2`, etc. (also known as positional parameters). 

We’ll also learn about what `$PATH` is, and move our script to a folder already on the `$PATH` so that it can be executed in any folder in our shell. 

Create and Run Bash Scripts with Command Line Arguments

The Hypertext Transfer Protocol (HTTP) is an application-level protocol for distributed, collaborative, hypermedia information systems. It is a generic, stateless, protocol which can be used for many tasks beyond its use for hypertext, such as name servers and distributed object management systems, through extension of its request methods, error codes and headers.

http

`curl` is how you make HTTP requests from the command line. It's awesome for testing out APIs because you have full control over all the headers that are sent, and you don't have to interact with a UI to send a request. 

We’ll learn how to make requests and change the HTTP method, set headers, and send JSON and url encoded form data. We'll also see how to increase readability by splitting long requests into multiple lines and formatting JSON responses with `jsome`, a node module.

Make HTTP Requests in Bash with `curl`

Bash, like any programming language, can set and unset variables. Global environment variables also play a big role in bash scripting. In this lesson, we'll learn how to declare and use variables, `export` them to other processes spawned from our current shell, and go through a quick example of how to leverage them in a script. 

Store and Use Values with Bash Variables

In this lesson, we'll go over how bash functions work. Bash functions work like mini bash scripts--you can pass parameters and invoke them just like a bash command. You can also define local variables within a bash function using the `local` keyword. Local variables follow similar scope rules present in most programming languages. 

Understand and Use Functions in Bash

Every command in bash returns an exit status, which is an integer between 0 and 255 that represents whether the command succeeded or failed, and if it failed, what kind of error occurred. Functions also can return an exit status via the `return` keyword. The exit status can be checked using bash's special `$?` variable, which always stores the exit status of the last command run. 

Understand Exit Statuses in Bash

Knowing how conditionals work in bash open up a world of scripting possibilities. We’ll learn the basic syntax, including `if`, `else`, and `elif`. Then we'll look at a few of the "primary" operators you can leverage in a conditional statement such as `=` for string equality, `-eq` for numeric equality, and `-e` to check if a file exists. After that, we'll use conditional statements to create a function that asserts that the HTTP status of a given URL is between 200 and 299. 

Use Conditional Statements in Bash

Pipes (`|`) are one of the most powerful features in bash and allow you to efficiently chain commands together and send data through it. We'll also look at how output redirection works using the stdout redirect operator (`>`). This allows us to take the output of a command and send it to a file. You can also append to a file using `>>`. 

Read [this article](https://www.tldp.org/LDP/abs/html/io-redirection.html) for more information on bash redirection. 

Chain Commands with Pipes and Redirect Output in Bash

Bash may seem like a strange tool to invest time into learning—it’s old (like literally as old as I am) and doesn’t have the appeal of learning that new framework everyone’s talking about. But in my experience, whenever I’ve invested time into learning more about it , whether it’s just a few commands or it’s core language syntax, it’s always paid off for me by increasing my productivity and enhancing my ability to contribute to my team at work. 

In this course, you'll learn the essentials of what every front-end developer should know about bash. The topics we cover will give you confidence in doing things like creating build scripts that run on continuous integration servers, quickly testing and debugging an API with curl, and more—the automation possibilities with bash are endless. 

By the end of the course, you’ll be able to use bash to interact with the file system, search text patterns in files, create scripts, pipe and redirect output, and use variables and conditionals. 

Enjoy the course! 

Course Overview: Automate Daily Development Tasks with Bash

`.bash_profile` is a file that bash invokes (or more technically `source`s) before the start of a new bash session. In `.bash_profile`, we have the opportunity to add variables, functions, and aliases to customize our bash environment and provide reusable functionality.

In this lesson, we’ll look at adding a `git_sync` alias as well as a `ll` alias. Aliases act like shortcuts and save us time and typing at the terminal. `.bash_profile` is a good spot for smaller functions and aliases.

Note that on most linux distributions you'll use `.bashrc` instead of `.bash_profile`.

Create Aliases in .bash_profile for Common Bash Commands

`PATH` is a global environment variable that represents a list of directories bash looks in for executable files. The executable files for bash commands like `grep` are all somewhere on your OS’s `PATH`. We can add our own folders to `PATH` to make our executables available as a command to bash. In this lesson we’ll learn how to add a new folder to our `PATH` in .bash_profile and how to symlink an executable file into /usr/local/bin, which is in `PATH` by default. 

Note that in zsh, when modifying your PATH you to provide an absolute path, `~` is not expanded. 

Add Executable Files to $PATH with Bash

Brace expansions are commonly used with the `cp` or `mv` commands in order to dynamically generate strings. In this lesson, we'll use a brace expansion to shorten a command like `cp index.js index.js.backup` to `cp index.js{,.backup}`. We'll also see how brace expansions can generate sequences. For example, `touch test-{1..10}` will generate the arguments to `touch` to create 10 test files. 

Note that the `tree` command that I use in this lesson has to be installed. 

Create and Copy Multiple Files with Brace Expansions in Bash

History expansions let you interact with bash's history. For example, if you forgot to run a command with `sudo`, you can `sudo !!` to rerun the last command with it. `!$` can be used to access the last argument of the last command. 

Cameron Nokes

Search Results