Learn Alpine, Angularfire and Bash

🚀 In this collection, I will be going over some command line tools I use on a daily basis that make my life a lot easier.

[First up is fzf](https://github.com/junegunn/fzf).

> fzf is a general-purpose command-line fuzzy finder.

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

Upgrade Your Terminal and Make It a Joy to Work with

“Setting up remote server authentication” will never be on your job description. It’s not one of those desirable responsibilities that convinces talented people to move across the country and pursue the job of their dreams.

But at that dream job, you might be asked to set up an SSH key. You’d better be ready.

In this course, we will learn the fundamentals of creating SSH keys and configuring them for connectivity to a remote server. We’ll figure out how to:

- tunnel SSH connections for easier local debugging
- set up configuration files to simplify the aspect of connecting to remote servers
- use security features like blocking incoming connections

Being prepared is key. Learn the skills now!

SSH for Remote Server Authentication

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. 


Manipulating strings in bash

SSH provides a secure way for your to [connect to and authenticate with GitHub's servers](https://help.github.com/en/github/authenticating-to-github/about-ssh). While HTTPS connections use usernames and passwords as credentials, SSH instead uses public and private key pairs. These can be generated on your system using a CLI like [`ssh-keygen`](https://help.github.com/en/github/authenticating-to-github/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent) and then associated with your GitHub account using the public key.

In some cases, you may need to connect to more than one GitHub account from the same system. For example, you may have [separate accounts for personal and professional projects](https://ryanharris.dev/managing-ssh-keys-for-github/), which can be difficult to manage manually. Using `ssh-agent` and a SSH configuration file, you can alleviate this pain point by automatically determining which key to use based on your GitHub repository's `git` URL.

Secure GitHub connections with SSH

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

Welcome to this beginner level series on Alpine JS! 👋🏞

Alpine JS is a rugged, minimal framework for composing JavaScript behaviour in your markup. It brings declarative, reactive, data-driven nature of libraries like React or Vue to your HTML templates.

In this series, you will learn about Alpine's handy **directives**. You'll discover how to define a component scope with `x-data`, run code on mount with `x-init`, attach event listeners with `x-on`, display data with `x-text`, decide wether or not to show an element with `x-show`, iterate through data with `x-for`, retrieve a DOM element with `x-ref`, learn how to achieve _two-way data binding_ with `x-model`, and much more.

You'll also learn how **"modifiers"** can be applied and chained to directives to provide additional functionality: control the animation transition of entering and leaving DOM elements, debounce an event listener, etc.

We'll also touch on what Alpine calls **"magic properties"**, which give you access to native browser events (`$event`), reference to DOM elements (`$refs`), and more.

You'll gradually discover Alpine's API and syntax, from building simple tabs to a mini app that fetches a dog picture based on a "breed" search field. 🐶

**Get ready to breathe some fresh air** - it's time to walk into cool, green Alpine pastures! 🏞

Alpine.js offers you the reactive and declarative nature of big frameworks like Vue or React at a much lower cost.

You get to keep your DOM, and sprinkle in behavior as you see fit.

alpine

Sprinkle declarative, reactive behaviour on your HTML with Alpine JS



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

AngularJS is an open-source JavaScript framework, maintained by Google, that assists with running single-page applications. Its goal is to augment web-based applications with model–view–controller (MVC) capability, in an effort to make both development and testing easier.

angularjs

Firebase provides a real-time syncing backend for your AngularJS applications in very few lines of code. In this lesson, you'll learn how to get started integrating it into your app.

Get Started with Firebase and AngularFire

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. 

Search

Search Results