This course is for learners just starting out as well as for those who want to get up to speed on Vue 3. You'll learn all the foundational skills of web development in Vue. 

Kevin Cunningham

The Beginner's Guide to Vue 3

Using WordPress as a headless CMS turns it into a data source ready to work with Gatsby, Next.js, or whatever else you want to build with. Learn Headless WordPress today!

WordPress as a Headless Content Management System (CMS) and GraphQL API

Learn the fundamentals of building a modern API in JavaScript. This course will explore concepts that will be helpful in building a wide variety of applications.

Building an API with Express

 Courses from Kevin Cunningham

Rather than installing someone else's complete component library or building your own one from scratch, you can leverage shadcn-vue to create accessible, functional components with great defaults.

In this video, we'll add shadcn to a new Vue 3 project and get one of the components up and running.

You can find out more and find all of the commands needed at the [shadcn-vue website](https://www.shadcn-vue.com/examples/playground.html).

Enjoy your building!

Getting setup with shadcn-vue in Vue 3

Shadcn component library is a great option for building out UIs as it gives you full control while setting you up with reasonable defaults. Learn how to install and get started with Shadcn in a Vue 3 project.

Creating a hidden text button in Astro allows developers to conceal certain text elements, unveiling them only with user interaction.

This hidden text button feature is not just a novelty; it adds a layer of interactivity to your website. Whether it's for hiding punchlines, quiz answers, or exclusive content, this feature enhances the user experience, making your website more engaging and interactive.

The initial state of these text elements is set to invisible through CSS. They exist on the page but remain unseen, like transparent elements. 

The reveal occurs when the user hovers or clicks on them, bringing the text into view through a smooth transition.

A common challenge arises when integrating multiple hidden text buttons on a single page. Initially, standard implementation may result in only the first button being functional. However, with a bit of strategy, you can ensure each button operates independently and maintain the functionality across multiple components.

Create an Interactive Spoiler Component in Astro

Lean how to build an interactive spoiler component in Astro, enhancing web user engagement. Learn to set up, style, and script the component for hover/click reveals, ensuring smooth functionality across multiple instances. 

`console.log` is one of the handiest tools in the JavaScript developers toolkit. You can use it to inspect the data you are working with during different points in the data flow you're exploring. 

But...

If you're only using `console.log`, you are missing out on the full power of the console object. There are many properties that `console` comes with and we'll be doing a brief exploration of each: 

- **console.info**: Outputs an informational message to the console. In the browser, these messages are typically unstyled.
- **console.warn**: Outputs a warning message. In the browser, it's usually accompanied by an exclamation mark and a stack trace.
- **console.error**: Outputs an error message with a stack trace.
- **console.assert**: Takes a condition and outputs a message if the condition is false, useful for assertions in code.
- **console.clear**: Clears the console, useful when the console is overcrowded with logs.
- **console.count**: Logs the number of times that this particular call to count() has been called, useful for tracking how often a block of code is executed.
- **console.time** / **console.timelog** / **console.timeEnd**: Allows for basic performance monitoring by starting a timer, logging the elapsed time, and stopping the timer.
- **console.group** / **console.groupEnd**: Groups together a series of console messages, indenting them for better readability.
- **console.table**: Displays tabular data as a table, making it easier to read complex object structures.
- **console.dir**: Provides an interactive listing of the properties of a specified JavaScript object, useful for inspecting objects.
- **console.trace**: Outputs a stack trace to the console, which can help track down where a function was called.

Each of these methods can be used to streamline the process of debugging JavaScript code, whether you're working in a browser or in a Node.js environment. Using these methods appropriately can help you understand your code's behavior and find errors more quickly.

Explore the Console Object for Enhanced JavaScript Debugging

The console object can be used for much more than simply logging a value out. Learn the various ways you can use it to level up your debugging prowess.

vitest is a versatile testing tool that provides various options to run tests. Here's a breakdown of how you can use it:

**Running Tests in Watch Mode**

By default, vitest runs in watch mode. This means that the tests will re-run automatically whenever there are changes in your functions.

For example, if you have a script defined in your package.json as:
```json
{
  "scripts": {
    "test": "vitest"
  }
}
```

You can run it with the following command:

```bash
npm run test
```

If your function fails and you update it, vitest will run again, giving you immediate feedback.

**Running Tests Once**

If you wish to run the tests just once without entering the watch mode, you can use the `vitest run` command.

You can add this to your package.json scripts as:

```json
{
  "scripts": {
    "test": "vitest",
    "test:once": "vitest run"
  }
}
```

And then run it with:
```bash
npm run test:once
```

**Accessing the vitest UI**

vitest comes with a built-in UI which can be accessed using the `--UI` flag. 

In your package.json, you can have a script like:
```json
{
  "scripts": {
    "test": "vitest",
    "test:ui": "vitest --ui"
  }
}
```

To launch the dashboard along with the tests in watch mode, use:
```bash
npm run test:ui
```

![vitest ui](https://res.cloudinary.com/dg3gyk0gu/image/upload/v1698440916/tips/kevin-cunningham/vitest-ui.png)

This dashboard provides insights into:

each test and its report:

![single test](https://res.cloudinary.com/dg3gyk0gu/image/upload/v1698440916/tips/kevin-cunningham/vitest-single-test.png)

the module graph:

![module graph](https://res.cloudinary.com/dg3gyk0gu/image/upload/v1698440916/tips/kevin-cunningham/vitest-module-graph.png)

the code where the test originates from:

![code tested](https://res.cloudinary.com/dg3gyk0gu/image/upload/v1698440917/tips/kevin-cunningham/vitest-code-test.png)

**Passing Flags to Package Scripts**

When you want to pass additional flags to the script with `npm run`, you might encounter an issue. For instance, running:
```bash
npm run test --ui
```

Won't work as expected. This is because the `--UI` flag is being passed to npm and not to the vitest command.

To correctly pass the flag, use an additional double dash `--` before your flags, like so:
```bash
npm run test -- --ui
```

This tells npm that the subsequent flags should be passed to the script and not npm itself.

In conclusion, vitest offers a rich set of features to help you run and monitor your tests effectively. Whether you prefer the watch mode for continuous feedback or need the UI dashboard for detailed insights, vitest has you covered. Remember to use the double dash `--` when passing flags to your npm scripts to ensure they work as intended.

Enhance Your Testing Workflow with vitest

Improve your testing process by understanding how to run vitest in different modes and launch the UI dashboard using NPM package scripts.

There are various ways to embed PDFs into your HTML document. Let's explore three of them:

### 1. Using the `embed` Tag

The `embed` tag is a part of the HTML5 specification, making it compatible with most modern browsers. You can embed a PDF using the `embed` tag as follows:

```html
<embed src="home.pdf" type="application/pdf" width="100%" height="100%">
```

However, there's a catch. If the browser does not support PDF embedding (common with some mobile devices), your users might see nothing.

### 2. Using the `iframe` Tag

A safer option to ensure that your users can access the PDF is by using an `iframe`. If a browser fails to render the PDF, it usually triggers a download:

```html
<iframe src="home.pdf" width="100%" height="100%">
  <a href="home.pdf">Download the PDF</a>
</iframe>
```

The message "Download the PDF" will only be displayed if the browser does not support the `iframe` tag. Still, it's not the best experience if the PDF isn't available.

### 3. Using the `object` Tag

The `object` tag offers even more flexibility. If the PDF isn't found, you can provide a fallback, such as an image or a message:

```html
<object data="home.pdf" type="application/pdf" width="100%" height="100%">
  <img src="broken.png" alt="PDF not found">
  <p>Download the PDF <a href="home.pdf">here</a></p>
</object>
```

This way, you can provide a more appropriate error message or an alternative for your users when the PDF isn't available.

In conclusion, while there are multiple ways to embed a PDF in your HTML document, it's essential to consider the user experience, especially in scenarios where the PDF might not be accessible. Using fallback options ensures your users can still access the content one way or another.


Embed PDFs in HTML with embed, iframe, and object tags

Learn three different ways to embed PDFs into your HTML document without using JavaScript, and understand the pros and cons of each method, including fallback mechanisms.

Bite-size video tutorials for badass web developers.

egghead

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

From Node 18.3 and above, there is a new command line parser. Before, we would either have to use custom logic or a third-party library to explore process.argv.

I create an `options` object with a key of `add` that has an object of key `type`, which is a boolean, and a key of `short` which we pass the value of `"a"`. Now, I pass that to `parseArgs`, set that to a variable, and console.log it to show you more about how `parseArgs` works. 

Use parseArgs to Parse your Command Line

Our CLI can be run from anywhere on the system but we have a critical error. The script is trying to find a `data.json` file that is relative to where it is being called. This will throw an error if you aren't actually in the script directory. 

The fix for this in an ECMAScript project like we are in is to use a `import.meta.url` variable that will give use the directory that the script is executed in. We can append our `data.json` to this path and call that throughout our script and we've fixed our error!


Handle Relative Paths in a Node.js ESM Project with import.meta.url

A CLI isn't super useful if you have to be inside of the project to start the script. 

To fix this, we can add a `#!` (shebang) to the top of our entry file. On linux and MacOS systems you'll also have to make the file executable as well. Then we can use a symbolic link to add a custom `quizme` command to our path that points at our scripts entry file.

We'll need to fix one more thing though! If you try to run the script in a different directory, the file it references for `./data.json` will be incorrect, we'll fix this in the next lesson.


Make a Node.js Script Globally Executable with a Shebang and a Symbolic Link

One issue with our script is that the answer that is checked needs to be exactly the same string as the answer in the file system. This can be brittle because your user might not capitalize or forget a space. There are ways we could sanitize user data but this can introduce quite a lot of complex logic into our script.

A great work around is to use Inquirer to check with the user if they got the answer right or wrong, this way you know you are logging correct values and you don't need to worry about sanitizing data as the user is determining for themself if they were right.


Offload Complex Logic and Confirm a Correct Answer with the User

All of our questions have been hard coded so far. We want the user to be able to add a question when they pass the `--add` flag.

We will need to use inquirer to ask for a question and it's answer. Once we have a question and answer in hand we will read our data.json file and then write to it with our new question. While we do this, we will assign a unique id to the question based on the length of the array being stored in our file. 


Add Question/Answer Object to our Data with Node.js writeFile

Currently we are grabbing the first element in the array that our JSON data gives us back. We want a random element (or question) from our file.

To get a random element from an array we will use Math.Floor and Math.Random in combination with the array length to get a random question returned to us.


Find a Random Element in a JSON File in Node.js

Now that we have the basic question/answer functionality working, that being we can ask a question of the user and check if the users answer is correct, we want to log the results of the users answers back to the file.

To log the results, we'll assign the question we got to from our file to a variable and add `lastAnsweredCorrect` (that is true if the user answers the question correctly and false if not) and `lastAsked` (the current date) properties to that object. We will then add that question object back to the array of questions we got from the file system and use `readFile` to write our results.

Note: `checkAnswer` was refactored into its own function for easier visibility in our script.


Log Question Results by using Node.js to Filter and Write to a File

Now that we can read from files, we don't need to hardcode any data in our script. Instead, we can import a json file and use `readFile` to access questions and answers from the contents within.

We can then prompt the user with the question from the file and check the users answer against the answer that is stored.

Note: Checking the answer is just JavaScript! I set up this logic for you so we can focus on the scripting/file system side of things.


Read a File with Node.js readFile from the File System and Parse Question and Answer

There are a handful of ways you can read and write to the File System in Node.js. 

We will look at `readFileSync`, `readFile`, and a promise based version of `readFile`.

Each have there use-cases and we will discuss the pros and cons of each one. For instance `readFileSync` is a blocking operation which if you were developing a web server with Node.js would be a huge problem. With this project being in the CLI for one user, this is a ok option to consider.  On the other hand, `readFile` is a non-blocking operation that uses promises/callbacks to interact with the file system.


Assess and Choose Three Approaches to Reading from the File System in Node.js

Now that we've chosen Inquirer as the library to use in our project, we need to use it! To do so the current questions in the CLI will be swapped out with inquirer `prompt` API. You'll see some immediate benefits in styling and functionality that we get for free now that inquirer is being used.

Process User Input with Inquirer in Node.js

You want to focus your development efforts on the actual business logic of the application, not procedural aspects of the code like parsing inputs. 

This is why we'll look for a 3rd party tool to parse user input. We'll look at 4 different libraries and walk through how to decide which will be best for this specific project.


Assess and Choose a 3rd Party Library for your Node.js CLI Tool

Reading user input is a big aspect of this project because we will be asking for a question or an answer for the CLI to work with.

Node has some internal options for parsing user input. We will check out the `readline` module and how it parses input. We will also see the promise driven version of the module and use a top level await to ask questions in the CLI.

This package has some limitations in how you present questions to your user though so if presentation is important to you, you will want to consider using a 3rd party library.


Parse User Input in Node.js with readline

When you run Node.js, you'll have access to the `process` object. If you console log it out you'll see that it has quite a bit of information stored on it. Dig through there and check it out!

We will focus on the `argv` property. This property is an array that has the path to node and our script as the first and second values. When we pass in arguments or flags to our script, argv include the values that we will pass.

We will see how we can check for flags and run conditional logic based on the flags that are passed.   


Parse User Input through Node.js process argv for Flags

Node.js projects have two ways that you can import and export code into different files. This is through CommonJS (CJS) and ECMAScript modules (ESM).

CommonJS is Node's default way to import modules but because I like to have my Node.js code similar to my frontend code, we will use ESM for this project.

To do so we will set a project `type` in our `package.json`.


Set the Node.js Project to ECMAScript Modules (ESM)

When comparing two visually similar websites, it can often be challenging to precisely identify the subtle differences between them. To facilitate a rapid analysis of these discrepancies, a practical technique involves leveraging Chrome's integrated developer tools to capture full-page screenshots of each site. Subsequently, these screenshots can be uploaded to a platform like AI Studio. There, the AI can analyze the images and generate a report detailing the variations. This entire process, leveraging a few quick shortcuts, can be completed in under a minute, delivering a comprehensive breakdown of the differences for efficient comparison and analysis.

Quickly Compare Two Sites Using AI Studio with Chrome Full Page Screenshots

It's fairly trivial to create a React project, but there's always a big hurdle between creating it locally and making it shareable so that someone else can run it. This lesson walks you through the process of automating creating a React project locally, creating the repository where it's going to be hosted, and creating shareable links where it can be run so that you can quickly and easily create single one-off demos and shoot them over to your friends and coworkers for sharing your code ideas in a working environment.


```bash
share-react-project() {
  if [[ -z "$1" ]]; then
    echo "Usage: share-react-project <project_name>"
    return 1
  fi

  local project_name="$1"
  local github_username=$(gh api /user --jq '.login')

  echo "Creating Vite project: $project_name"
  pnpm create vite "$project_name" --template react

  cd "$project_name"

  echo "Initializing Git repository"
  git init

  echo "Adding all files to Git"
  git add .

  echo "Creating initial commit"
  git commit -m "Initial commit"

  local codesandbox_link="https://codesandbox.io/p/github/${github_username}/${project_name}"

  echo "Adding CodeSandbox link to README.md"
  echo "" >> README.md
  echo "## CodeSandbox" >> README.md
  echo "[![Open in CodeSandbox](https://assets.codesandbox.io/github/button-edit-blue.svg)](${codesandbox_link})" >> README.md

  echo "Adding README.md to Git"
  git add README.md

  echo "Committing README.md changes"
  git commit -m "Add CodeSandbox link"

  echo "Creating GitHub repository: $github_username/$project_name"
  gh repo create "$github_username/$project_name" --public

  echo "Pushing to remote 'origin'"
  git push -u origin main

  echo "Project '$project_name' created successfully!"
  echo "GitHub repository: https://github.com/$github_username/$project_name"
  echo "CodeSandbox link: $codesandbox_link"
}
```

Automate Creating a Local React Project, GitHub Repository, and Live Hosted Demo in a Single Command

[Verdaccio](https://verdaccio.org/) is a fully featured NPM registry that you can run locally on your machine. It’s a great tool for testing your release process, running end-to-end tests, and simulating real-world scenarios like deploying packages, installing them, and verifying functionality as an end user would.

Nx includes a [generator](https://nx.dev/features/generate-code) that simplifies setting up Verdaccio. To configure it, run:

```shell
npx nx g @nx/js:setup-verdaccio   
```

This command installs the necessary NPM packages and creates a `project.json` file with a `local-registry` target. To start the local registry, open a new terminal window and run:

```shell
npx nx local-registry
```

This will:
- Launch the Verdaccio registry.
- Configure NPM to point to the local Verdaccio server at `http://localhost:4873`.

> **Note:** A `project.json` file provides an advanced way to define scripts, offering more flexibility than a traditional `package.json` for managing complex targets.

Setup local Verdaccio server to release NPM packages

Learn how to spin up a local NPM registry powered by Verdaccio to test deploy your NPM packages.

In TypeScript, developers often begin by defining the structure of their data using type definitions or interfaces, which is a powerful way to ensure type safety. However, as applications grow and become more complex, simply defining the shape of an object might not be enough to guarantee its consistent creation and behavior throughout the codebase. This often leads to situations where objects that are intended to be of a certain "type" might be missing crucial properties or have incorrect data, which can be difficult to track down and debug.

This lesson tackles the question of when and why to move beyond basic type definitions and embrace classes in TypeScript. It demonstrates how classes provide a more robust mechanism for defining object structure, enforcing type constraints, and ensuring consistent object creation. By establishing a clear blueprint for objects, classes not only improve compile-time type safety but also offer runtime benefits and better code organization, ultimately helping developers avoid common pitfalls associated with loosely structured objects in larger TypeScript projects.

Stop Avoiding Classes in TypeScript

Karabiner isn't only for your keyboard. It can also hijack your mouse buttons and enable them to be similar to layers on your keyboard, where holding down a mouse button can allow you to tap keys on your keyboard to trigger commands and macros that can completely revolutionize your workflows. For example, you can hold down the right mouse button and tap on R to go to references in VS Code. Or hold down the right mouse button and tap the left mouse button to chop up videos and Screenflow.

This completely unlocks a whole new world of possibilities and use cases for your mouse as you can hover your mouse over anywhere on the page. And just tapping keys on your keyboard allows you to trigger mouse actions, to trigger keyboard actions, or to trigger macros and applications and terminal commands. and anything that your imagination can come up with. 

Karabiner: Rethinking Right-Click as a Macro Command Center

Make an HTML table more readable on mobile devices by using the ::before pseudo-element. We add labels to each cell, so they appear like cards when the table is viewed on smaller screens. The ::before content is set using a data-label attribute for each cell to enhance mobile viewability without horizontal scrolling.



Create a mobile friendly table with the before pseudo-element

Learn to use CSS ::before pseudo-element for mobile-friendly HTML tables. Add labels to cells for enhanced readability on mobile, avoiding horizontal scroll.

Any app of a decent size has event flows and messages being passed around. At a certain point it becomes complicated to explain it through prose and you want to turn towards diagrams. Now setting aside the time to create diagrams that accurately describe what's happening in your codebase can be quite time consuming. Luckily, with today's AI tools, we can now just do basic walkthroughs with rough recordings over codebase dictating what's going on along the way and then upload that to tools like AI Studio and then ask it to generate diagrams in a text-based format such as Mermaid that will then generate the flowcharts and diagrams for us. So this video walks us through this process of recording a rough video, uploading it to AI Studio and then asking AI Studio to generate the proper Mermaid diagram syntax.

Generate Mermaid Flow Chart Diagrams with Gemini 2.0 from Rough Screen Recordings

I'm a diehard Karabiner user and anytime I start doing something repetitively I always move it into my Karabiner configuration. Sometimes I'll fall into scenarios where I want to trigger a command, but I also want to know if that command succeeded or failed. Since Karabiner can trigger any command, setting up the command is fairly straightforward, but knowing whether it succeeded or failed became much more difficult. Luckily for me there is a package called terminal-notifier that you can install from homebrew and you can pipe the output of your command to terminal-notifier. And have a seamless way of triggering your keyboard shortcut which runs a command and you can be notified of the results.

Use Karabiner to Trigger a Terminal Command and Get Notified of the Results

There are a lot of scenarios when inspecting a site in Chrome where you don't want any click events to fire and you don't want any scripts to run. Or maybe something is animating in and out of the page and you want to capture it at a certain moment. This is a great use case for pausing script execution, which is kind of using the debugger manually by going into the Chrome DevTools and the Sources tab and clicking the pause button to essentially pause the entire page. This will give you a chance to inspect any of the elements and styles you want to inspect. And you don't have to worry about fire and click events or anything that might interrupt your investigation into the elements and styles that you want to find.

Pause Script Execution in Chrome to Easily Inspect Elements

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.

Kevin Cunningham

The Beginner's Guide to Vue 3

Featured Resources

WordPress as a Headless Content Management System (CMS) and GraphQL API

Building an API with Express

Search Results

Getting setup with shadcn-vue in Vue 3

Create an Interactive Spoiler Component in Astro

Explore the Console Object for Enhanced JavaScript Debugging

Enhance Your Testing Workflow with vitest

Embed PDFs in HTML with embed, iframe, and object tags

Getting setup with shadcn-vue in Vue 3

Create an Interactive Spoiler Component in Astro

Use parseArgs to Parse your Command Line

Handle Relative Paths in a Node.js ESM Project with import.meta.url

Make a Node.js Script Globally Executable with a Shebang and a Symbolic Link

Offload Complex Logic and Confirm a Correct Answer with the User

Add Question/Answer Object to our Data with Node.js writeFile

Find a Random Element in a JSON File in Node.js

Log Question Results by using Node.js to Filter and Write to a File

Read a File with Node.js readFile from the File System and Parse Question and Answer

Assess and Choose Three Approaches to Reading from the File System in Node.js

Process User Input with Inquirer in Node.js

Assess and Choose a 3rd Party Library for your Node.js CLI Tool

Parse User Input in Node.js with readline

Parse User Input through Node.js process argv for Flags

Set the Node.js Project to ECMAScript Modules (ESM)