Learn Css, Electron and Turborepo

Bootstrap is an incredibly popular CSS framework designed to make your website look great on mobile and desktop.

By the end of this course, you'll be familiar with many of the popular classes and components that Bootstrap uses to apply in your own projects.

For each feature you build in the course, you'll get a sense for what the relevant classes do for those components and links to documentation for further exploration.

For the course demo application, we will analyze the landing pages of Microsoft and Apple to identify common components that are implemented. When these are identified, you'll implement these components yourself with Bootstrap.

You'll build several common UI elements such as a nav bar, a carousel of images, Cards, and Forms.

Through building these components, you'll understand what is behind the different classes Bootstrap gives you and get familiar with how it exposes flex and grid layout for you.

Cascading Style Sheets bring order and beauty to our applications.

Create Professional Responsive Websites using Bootstrap

Now that we have a project, we need a Pin input to work with. We'll create 4 inputs and style them so they look like a security code pin input that you would expect to see.

Style a Pin Input through Data Attributes in React

Turborepo is a fast build system for JavaScript and TypeScript.

turborepo

Turborepo is a task runner that helps speed up and manage your Monorepos. It's not a dependency management tool. It knows nothing about your dependencies. 

It speeds up Monorepos by using local and remote caching as well as incremental builds. It helps to manage your repo with very handy and easy-to-use scripts. 

Here is the [npm-workspaces repo](https://github.com/alejandronanez/npm-workspaces)

So let's hop in and learn about Turborepo!

Note: This course is a continuation of the course [Introduction to Monorepos with NPM Workspaces](https://egghead.io/courses/introduction-to-monorepos-with-npm-workspaces-c03f500b) where we initially build out the Monorepo that is used in this course. It is highly suggested to watch that course first before jumping into this one. 

What is Turborepo?

At the root of our project, we'll run `npm install turbo --save-dev` to install Turborepo.

We'll also look at how to configure Turborepo in the `turbo.json` file. We'll look into the [$schema](https://turborepo.org/schema.json) and how it affects our configuration. 

Install Turborepo in an Existing Monorepo

With our npm scripts, if utils can't build, then the dashboard and blog can't build or run their tests. Turborepo Pipelines changes that. Using the pipeline, we can set up caching, what our scripts depend on, and where we want our logs to be output. 

Also since we now have Turborepo installed and configured our pipelines, we can remove concurrently from our scripts and dependencies. 

Migrate NPM Scripts to Turborepo Pipelines

We are going to be going through Turborepo speeds up your builds and testing with caching. When a command is first run in Turborepo, it gets cached. This way if something has changed in one of your repos in your Monorepo, it will detect that change. For the repos that haven't changed, it will pull their info from the cache inside of `node_modules` instead of fully re-running that command. For the repo that has changed, it will run that command solely on that repo. 

Understand Turborepo Local Cache

It's fairly straight forward to create repo specific pipelines with Turborepo. The script goes like this: `{monorepo-name}/{repository}#{script-name}`. For example, if we wanted to run the typecheck command in just the dashboard repo, it would look like this: `@monorepo/dashboard#typecheck`. Lastly, we will make sure that it `dependsOn` the `utils#typecheck` pipeline. 

Create Repository Specific Turborepo Pipelines

A dependency graph is exactly what it sounds like! A visual graph created by Turborepo to show you your dependencies and what dependencies the projects rely on. For our Monorepo, we'll run `npx turbo run build --graph` in the root of our project and that will build the dependency graph for all of our projects.

We can also do one with a graphic but that requires the [Graphviz](https://graphviz.org/download/) library. We can edit our command to have some arguments: `npx turbo run build --graph=graph.pdf` and it will create a graphic in a .pdf file. 

Generate a Dependency Graph for Monorepos Using Turborepo

You can set up all of your specific pipelines in the turbo.json file, or you can filter through your pipelines in the terminal. If we wanted to run the `typecheck` command in just the `utils` package, our command would look like this: `npx turbo run typecheck --filter=@monorepo/utils`. You can remove `@monorepo` as long as the `utils` package is unique. 

Turborepo also gives you the option to filter your commands based on what files have changed on your branch using `--filter="[HEAD^1]". 

Now that we know a bit more about Turborepo, we can edit all of the scripts that we build in the previous course to use `turbo` instead of `npm`. 

Filter Pipeline Tasks Using Turborepo

By default, Turborepo will stop its execution if it runs into an error. We may not want that if we want Turborepo to continue in the projects that don't have an error. We can do this by adding the `--continue` flag to the end of our command. 

Prevent Turborepo Exiting Early on Failing Tasks

Another really good tool that Turborepo offers is the `--dry` flag. The `dry` flag will display details about the affected workspaces and tasks that would be run. It will help you to know what Turborepo is doing under the hood. 

Preview Turborepo Tasks at the Pipeline Level

The logs produced by Turborepo can get really really long. Turborepo give us a flag, `--output-logs` and if we add on the argument `new-only`, it shortens the logs to just the new information for the repositories that have changed. 

Shorten Turborepo Logs using --output-logs

Remote caching is key when coworking on a project. Using Turborepo, you can upload your cache to the cloud and use it everywhere else. For example, if your coworker switches to your branch and runs the build, they can have your most recent cache saving them time. 

We will start off by logging into Vercel and Turborepo then linking our Turborepo account to our Vercel account. Once that is done, we run `npx turbo link` to connect to our remote cache. Then in our Vercel dashboard, we will need to do some configuring to finish it up. 

Enable Remote Caching in Vercel

Now that we have Turborepo installed, configured, and we have some knowledge about it, let's deploy our two client-side applications, dashboard and blog, to Vercel. We'll link our Github to Vercel and point it towards our Monorepo. We'll then run through all of the configurations and commands needed to get our apps deployed. 

Deploy the Client-Side Apps in a Turborepo Monorepo to Vercel

Github Actions helps to automate the building, testing, and deploying of your applications. We'll configure our actions in the `ci.yml` file in a new directory called `.github/workflows`. When that file is configured, we can update our scripts in our package.json to run off of those. We will also need to make/set up our `TURBO_TOKEN` and our `TURBO_TEAM` which we will create on Vercel and Github. 

Enable Github Actions with Turbporepo Remote Caching

Now you might have a project that currently isn't in your Monorepo that you want to add to it. We can copy that project over into our `apps` folder and then update the `package.json` to update the name to make it consistent across our apps. We'll update the dev port to make sure it's not going to run on the same port as one of our other applications. Lastly, we'll update the build pipeline to include our new application. 

Migrate a VueJS Application to an Existing Turborepo Monorepo

JavaScript® (often shortened to JS) is a lightweight, interpreted, object-oriented language with first-class functions, most known as the scripting language for Web pages, but used in many non-browser environments as well such as node.js or Apache CouchDB. It is a prototype-based, multi-paradigm scripting language that is dynamic, and supports object-oriented, imperative, and functional programming styles.

javascript

We'll discuss the minimum set of files that are required to get up and running with Vue.

We'll add an `index.html` file as our entry point, a `main.js` file that will contain our JavaScript code and a `styles.css` that will contain all of our CSS. We also load Vue into our project with UNPKG which exposes the Vue object to us.

Set up the Minimum Files Needed to Run Vue 3

Using the open-source project ComfyJS, display a response to chat commands overlaid on the Twitch scenes. We'll use Eleventy templating to create a partial holding the initial command HTML. Then, using [the cicada principle](https://lea.verou.me/2020/07/the-cicada-principle-revisited-with-css-variables/), we'll enable visuals of each command word to appear in a seemingly random order across the scene. We'll use the `ComfyJS.onCommand` method to enable cloning the command template nodes and adding them as the commands are triggered through Twitch chat. CSS transitions will be used to apply a fade and zoom in/out effect for the added command nodes.

Respond to Twitch Chat Commands With Scene Elements and ComfyJS

To embed Twitch chat, we'll use the open-source project [ComfyJS](https://github.com/instafluff/ComfyJS) which is a JavaScript API to interface with the Twitch API. It offers features like responding to incoming chat messages and chat commands and other events like new subscriptions.

Using ComfyJS, we'll set up a section in the Twitch scenes to show incoming chat messages. This lesson covers the CSS needed to style the chat messages and make older ones scroll out of view once new ones are received. We'll take advantage of Eleventy templating to include the necessary scripts.

Embed Twitch Chat in Scenes Using ComfyJS

Add three Twitch scenes for preshow, host, and main, and style them using CSS. Learn how to include transparent background areas with CSS gradients that will mask capture areas for a webcam and desktop display.

Create Twitch Scene Templates and Style

Chrome Devtools can be really powerful, when it comes to debug JavaScript, inspect DOM nodes and their properties as well as CSS styling. in this lesson we're quickly having a look at the "CSS Overview" feature of Chrome Devtools, that allows you to debug the CSS design of a website, starting from the used color palette, fonts and much more.

Use Chrome Devtools' CSS Overview to debug the CSS Design of a website

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

This TypeScript tutorial explains how to use generics, allowing for different types to be passed as arguments. It discusses the use of shorthand syntax in generics and illustrates with examples. This method is useful for library creation, providing type safety and control to the user.

```typescript
interface PhotoMetadata<T> {
  title: string;
  takenAt: Date;
  customData: T;
}

// Function that processes a photo with custom metadata
function processPhoto<T>(photo: PhotoMetadata<T>): {
  processedTitle: string;
  daysSinceCapture: number;
  customDataSummary: T;
} {
  const today = new Date();
  const daysSinceCapture = Math.floor(
    (today.getTime() - photo.takenAt.getTime()) / (1000 * 60 * 60 * 24)
  );

  return {
    processedTitle: photo.title.toUpperCase(),
    daysSinceCapture,
    customDataSummary: photo.customData
  };
}

// Example usage with different custom data shapes
type CameraSettings = {
  iso: number;
  aperture: string;
  shutterSpeed: string;
}

type LocationData = {
  latitude: number;
  longitude: number;
  locationName: string;
}

// Using with camera settings
const photoWithCamera: PhotoMetadata<CameraSettings> = {
  title: "Sunset at beach",
  takenAt: new Date('2024-01-15'),
  customData: {
    iso: 100,
    aperture: "f/2.8",
    shutterSpeed: "1/1000"
  }
};

// Using with location data
const photoWithLocation: PhotoMetadata<LocationData> = {
  title: "Mountain vista",
  takenAt: new Date('2024-02-01'),
  customData: {
    latitude: 45.5231,
    longitude: -122.6765,
    locationName: "Mount Hood"
  }
};

const processedCameraPhoto = processPhoto(photoWithCamera);
const processedLocationPhoto = processPhoto(photoWithLocation);

processedCameraPhoto.customDataSummary.iso
processedLocationPhoto.customDataSummary.longitude

```

Basic Explanation of Typescript Generics

A very basic explanation of generic function arguments

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.

Build a Word Game with Windsurf's Cascade AI Agent



Discover how to harness the power of Cursor IDE's Composer Agent feature to optimize your code. In this lesson, you'll witness an AI agent doing all the work to generate test suites, implement performance benchmarks, and create optimized function variations - all without writing a single line of code. You'll learn how to validate performance improvements through data-driven benchmarking, ensuring that optimizations are backed by concrete metrics rather than speculation. This hands-on demonstration showcases a groundbreaking approach to automated function development that combines the precision of test-driven development with the efficiency of AI-powered optimization.


Agent-Driven Development in Cursor: Testing, Benchmarking, and Optimizing Functions

This course is aimed for using `zod` effectively in projects based on TypeScript (both browser and node.js). The benefits you gain with this course is not just simply coding, but also understanding when/why/how should you perform runtime validation.

`zod` is the missing piece to TypeScript's capabilities, which can guarantee type-safety only in compile-time.

`zod` can be used whenever the compiler cannot guarantee what happens in runtime. And... it's a very frequent usecase, such as HTTP calls, websockets, etc.

In this course you get quickly up and running by:
1. using `zod` with primitives and objects
2. adapting `zod` quickly to existing projects thanks to automatic generators
3. changing the strategy frm type-first to schema-first
4. using error-throwing `parse` or non-error-throwing `safeParse` basing on your needs
5. applying `zod` to the most common usecase - validating API responses
6. handling errors the most convenient way (out of many!)

Take advantage of runtime validation with `zod`. Take advantage of the detailed lessons in this course 🔥

Effective Runtime Type Checks with Zod


Cursor can now automatically run commands in the terminal and walk step-by-step towards building out your entire project. You give it a goal, then it will suggest the commands you need to run and the files that you need to create and you can work with it to achieve what you're building. This lesson does a quick walkthough of using a Cursor Agent to build a project from scratch and guide it along the way. Cursor Agents definitely feel like a sneak peek at the future of programming!

Cursor Agents Initial Impressions - Allow an AI to Build Your Entire Project

Mock Service Worker is an API mocking library that allows you to write client-agnostic mocks and reuse them across any frameworks, tools, and environments.



Mocking WebSocket APIs with Mock Service Worker


While using anonymous functions might seem convenient, they can create difficulties when trying to identify performance bottlenecks during profiling. This lesson will demonstrate how named functions make it easier to pinpoint and address performance issues, ultimately leading to more efficient and debuggable code. Learning this practice will greatly improve your ability to locate and fix performance issues in complex projects.

Search

Search Results