Learn Bash, Ionic and Nginx

Get started building web applications with Angular and Firebase.

In this course, you'll learn how to set up and use Firebase in your Angular applications using the AngularFire library.

We choose the AngularFire library because it is an official library created by the Firebase and Angular teams to work better with Angular.

It helps you by wrapping everything into observables and helps update zones. 

By the end of this course, you'll be able to build web applications using Cloud Firestore as your database, Firebase Authentication as your Auth system, Cloud Storage to save files, and Firebase Hosting to deploy your applications to the web.

TypeScript is a typed superset of JavaScript that compiles to plain JavaScript.

typescript

Build Full Stack Web Applications with Angular and Firebase

Ionic is the beautiful, free and open source mobile SDK for developing native and progressive web apps with ease.

ionic

Now that file uploading works, we want to actually show that a task has files associated with it. To do this we will need to update the task object with a file property that we'll push files too.

In this lesson, we'll use Cloud Storage methods like getDownloadUrl() to get the file's download URL from our bucket.

Then we'll add that file's information to our task and persist it in the database to show the list of files in a task to the user.

While we do this, you'll see how we can easily add a spinner when files are being uploaded using Ionic loadingController.


Save and Display Tasks Files Utilizing Firebase Cloud Storage getDownloadUrl

A scenario you will inevitably run into is users needing to reset their passwords for security reasons or they lost and forgot their password.

We'll learn how to send our users an email to reset their passwords, after we send the email, we'll display a notification alert with ionic alertController to the user and redirect them to the login page.


Send a Password Reset Email Using Firebase Authentication with sendPasswordResetEmail

Now it's time to create a template for our authentication page using Ionics page generation CLI.

We'll show how to use the same page for all of our authentication operations by reading the parameters from the URL and displaying the right form elements and buttons depending on the parameters present.


Create an Authentication Page Template with Ionic Page Generation

We'll learn how to delete documents from the database. This action is pretty straight forward, we'll add a delete button that will call Firestore `deleteDoc` and pass in the task id.

We'll also explore a good practice when performing destructive operations (__like deleting database objects__) of adding a confirmation step to make sure our users don't delete objects by accident. We'll do this with the Ionic Alert Controller.


Delete a Document with a Confirmation Step from Firestore

We'll evaluate 2 good practices when adding a new task.

First, we'll show the users a toast alert to notify them that their document was saved in the database. We'll do this with a toast component that ionic makes available to us

And second, we'll use Angular's router to navigate the user back to the task list.

Notify Users Their Database Operation Worked with a Toast Alert

We'll create the template for our new page and set everything up so that we can use this page to create new tasks. The first thing we will do is create a BehaviorSubject task variable that we'll store form values in to send to Firebase.

Because we are using the ionic framework we'll lean heavily into this when creating our templates. You'll see how we bind text values to the object we'll send to Firebase as well as a selector component that will use `ion-segment`.

We'll also see a tip on handling the `async` pipe in a top container in our template so that we don't have to manually add it everywhere we'll render a property from an observable


Create a New Task Form Page Template with Ionic

firebase

There are 2 different ways to get a document's ID when using `@angular/fire`.

You can add the parameter `{ idField: 'id' }` to your collection when using the `collectionData()` observable.

You can also use the observable `collectionChanges()` and access the internal metadata of the document to manually get the ID and add it to the resulting object.

Code sample: https://github.com/javebratt/angularfire-idField

Access a Firebase Document's ID Even when It's Not Stored in the Document with angularfire

Node.js is a platform built on Chrome's JavaScript runtime for easily building fast, scalable network applications. Node.js uses an event-driven, non-blocking I/O model that makes it lightweight and efficient, perfect for data-intensive real-time applications that run across distributed devices.

node

Ghost has two hard dependencies which need to be installed before it can run. Those are Nginx and Node.js.

We will start by installing Nginx and set Nginx up to control the traffic coming into the EC2 server. After this, we'll install NVM using the raw install script that they provide on GitHub. With NVM installed we can then install the latest version of Node.js


Install Nginx and Node.js on a AWS EC2 Server

Docker containers wrap a piece of software in a complete filesystem that contains everything needed to run: code, runtime, system tools, system libraries – anything that can be installed on a server. This guarantees that the software will always run the same, regardless of its environment.

docker

This lesson uses some advanced concepts and some bash scripting to build a better Dockerfile. By using the concepts showed here, you will be able to build more future-proof and production-ready containers. If you prefer to focus on the content about containers, feel free to ignore this lesson and come back to it later on if needed.

Currently, we use `sed` to overwrite the hard-coded path to the API. This works well when there is a single value to replace. Now if one of your team members replaced the value of localhost:3000, your build will break.

We'll use `jq` to fix this issue. Jq is a command-line tool that makes it easy to change values in a JSON file. The base image that we used for building the application does not contain this tool, but that is not an issue. To install `jq`, you will need to download the [binary](https://github.com/stedolan/jq/releases/download/jq-${JQ_VERSION}/jq-linux64.), we'll need that to execute `jq` commands in our Dockerfile. This will allow us to update specific properties i

Modify a JSON Configuration File with jq

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

In this lesson, we'll use the power of awk to select the columns and rows of data that match our condition. We'll pass a `,` (comma) to the `-F` flag (the F stands for field separator), to tell awk to split on commas. From there, the world is our oyster and we can tell awk to only return rows that match whatever parameters we pass.

Extract Columns of Data from a CSV with awk

`awk` is a specialized tool and programming language for querying and transforming text.   In this lesson, we’ll scratch the surface of the possibilities it provides by leveraging it in one of its most common use cases: extracting data from columns of text. Awk makes it easy to select and print just the columns and rows that we want from commands, like `ps`, that return a table of data.

Extract Data From Columns of Text with awk in Bash

Pandoc is a command-line tool built in Haskell that can convert almost any markup or word processing format interchangeably. You specify the input and the output types and pandoc will do the rest.

In this lesson we will convert a few markdown files to pdf. You will see how to convert a single file and then we'll write a script to loop through a couple files and convert them dynamically.

This lesson requires that you install `pandoc` and have `pdflatex` available.

You can install `pandoc` with brew: `brew install pandoc`
To access `pdflatex`, you can install `basictex` and set the path for `--pdf-engine` to `pdflatex`

Convert a File from Markdown to PDF with pandoc

🚀 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.

Upgrade Your Terminal and Make It a Joy to Work with

`fzf` is a fast cli finder tool. The `fzf` command will launch an interactive find session. You can type a path to a file and see a list of possible results.

Piping the output of commands (such as git branch) to `fzf` makes it easy to find the line you are looking for.

Interactively Find Anything By Piping it to fzf in the terminal

Many people just drop all of their Zsh functions inside of their .zshrc and forget about it. But as your collection of functions begins to grow, you start looking for a better way to organize everything. Since Zsh provides `autoload` for loading in functions dynamically, we can drop all of our functions into individual files, loop through that directory, then autoload each file as a function.

Store Zsh Functions in Individual Files Inside a Directory

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

When working with multiple GitHub accounts on the same system, you want to ensure that your commits have the proper author information. 

To do this, we'll create a global `git` configuration on our system that uses our personal account's information. Then, in our work-specific repositories, we'll add a local `git` configuration to override our global values.

We will be using the following commands in this lesson:

- `code`
- `git config`

Update gitconfig to Work with Multiple Accounts and SSH Keys

In this lesson, we have two local SSH keys: one associated with our personal GitHub account, the other with our work account. 

To more easily manage them, we will use `ssh-add` to add our keys to our system's key manager `ssh-agent`. Then, we will create a SSH configuration file, which will determine what key to use when connecting to GitHub based upon the URL. 

Once we have set up our configuration file, we can test our connections using `ssh -T` and clone repositories with `git clone`.

Commands we will be using in the lesson:

- `ls`
- `ssh-add`
- `touch`
- `ssh`
- `git clone`

Manage Keys with ssh-agent and Add SSH Configuration

In some cases, you may have multiple GitHub accounts that you need to interact with from the same system. For example, you could have an account for work and another for personal projects, but you don't want to re-authenticate each time you switch between then. By using public SSH keys for each account, you can eliminate this part of the process.

In this lesson, we will create two SSH keys in our terminal using `ssh-keygen` , copy them to our clipboard using `pbcopy` and then add them to our respective GitHub accounts.

Commands we'll be using include:

- `ssh-keygen`
- `ls`
- `pbcopy`

Generate SSH Keys for your GitHub Accounts

Gemini 2.0 has a context window of a million tokens, and this means that you can upload hundreds of files and allow it to inspect and analyze massive refactors across entire code bases. 

This lesson demonstrates concatenating an entire code base into a single file and then uploading it to AI Studio. Once within AI Studio, we ask it to find the types of tasks that it can evaluate for us. Then we select one of the tasks and ask it to generate instructions for that task. Once those instructions are complete, we then turn them over to Windsurf's Cascade agent, and we allow Windsurf's Cascade to do all of the work for us as we sit back, relax, and let the AI do our jobs.

Use Gemini 2.0 to Create Agent Instructions to Refactor an Entire Codebase

Learn how to display custom components in a [Tanstack Table cell](https://tanstack.com/table/latest/docs/guide/cells), including how to render capitalized text, apply conditional styling with class helper functions, and format dates using the `Intl` API for readable display. 

`flexRender` allows you to utilize the `cell` callback method in your column definitions. Tanstack table will call this function to render the custom component you defined.

Render Custom JSX in a Tanstack Table cell

Use tanstack table flexRender method to render custom components in a table component. Capitalize letters, apply conditional styling, and render dates with Intl

I'm extremely excited for the potential of AI watching your screen while you work. I decided to take Google's AI Studio for a spin, which just introduced a feature called "Stream Realtime", which allows AI Studio to observe your screen and listen to your microphone while you work.

This video is my initial attempt to try and coach AI Studio through the process of building a site from a reference site, essentially trying to build egghead.io from a Next.js starter template. And we'll explore the various attempts we make and what works and what doesn't.

Let AI Watch Your Screen: Build Next.js Pages with AIStudio's Stream Realtime


[Shadcn](https://ui.shadcn.com/docs) is a popular component library that allows you to install components into your codebase.

Learn how to install the [Table component](https://ui.shadcn.com/docs/components/table) and use that presentational component with [Tanstack table](https://tanstack.com/table/latest).


Display Tabular Data in React with Tanstack Table

Build a dynamic table component in React using shadcn component library and tanstack react table.

TypeScript's satisfies operator finally clicked for me when I realized it's almost always used for specific implementations of configuration objects. So this lesson walks you through the naive approaches I've taken before and how to solve them using the satisfies operator. After this, satisfies will be another tool in your belt in TypeScript. To clean up all the TypeScript code you have around configuration.

TypeScript's "satisfies" for Configuration

Windsurf and Cursor are both able to take an image and then use an agent to build out what it sees in that image. This lesson is going to compare Windsurf and Cursor by uploading the same image to both and giving them the same prompt. Comparing not only the results, but also the steps that they take to get there. We'll also try uploading additional images throughout the process to see what they do as far as revising along the way and improving the site as they go along. 

Windsurf Cascade vs. Cursor Composer Agent: Build a Site from an Image

In this lesson, you'll discover how to style View Transitions using CSS pseudo-selectors to create custom animation effects. We'll transform the default cross-fade into a smooth slide transition by targeting the ::view-transition-old and ::view-transition-new pseudo-elements. You'll learn how these powerful selectors give you precise control over your transition animations, allowing you to create more engaging and personalized user experiences with just a few lines of CSS.

Customize View Transitions with CSS Using view-transition-old and view-transition-new

In this lesson, you'll learn how to implement smooth state transitions in your web applications using the browser's built-in View Transitions API. We'll create a simple example that demonstrates how to animate between different text states with just a few lines of code - no external libraries required. This powerful native API makes it easy to add professional-looking transitions to your user interface, enhancing the user experience with minimal effort.

Create Smooth UI Transitions with the Native View Transitions API

I've been using Cursor for a very long time and their "Agent" feature in Composer is fairly new, so I'm still getting used to it. But since Windsurf recently got onto the stage with their Cascade agent, they've slowly been gaining the mind share on the UX for coding agents. I decided to put them to the test by putting Windsurf and Cursor on the exact same screen side by side trying to accomplish the same task and to see which workflow I would prefer. I've been a diehard Cursor user for over a year now, so it's going to take a lot for me to switch to a different IDE. But I just have to say, even from this simple demo, Windsurf is looking pretty nice.

This lesson is just going to walk through creating a CLI using both tools to print out inspirational quotes and to explore how they approach the step-by-step of installing packages and running commands and setting up all the files we need to get this running.

Windsurf Cascade vs. Cursor Composer Agent Side-by-Side Comparison

I've been using Cursor as my primary editor for over a year now, but recently I've heard wonderful things about Windsurf AI Agent features. I decided to record myself building out something I've always wanted to make, but never made the time for.

In this lesson, I demonstrate how to leverage Windsurf's powerful agent process to create a fun word-guessing game inspired by Heads Up. Watch as I build an interactive application featuring category selection and word navigation, complete with data hosting on GitHub Gists and deployment to GitHub Pages - all in under 30 minutes (before editing the lesson down to 12 minutes)!

What makes this project particularly exciting is how Windsurf eliminates the typical friction points of development. While this game was always on my project wishlist, the overhead of setup, configuration, and deployment made it hard to justify the time investment. Windsurf's agent process handles all these pain points seamlessly, from managing URLs to orchestrating deployment.

This lesson perfectly showcases how AI agents can help developers bring their backlog of project ideas to life, transforming what would typically be time-consuming tasks into efficient, enjoyable development experiences.

Search

Search Results