Learn Javascript, Node and Prisma

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

The new [cause](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/cause) data property that you can add to a thrown `Error` can be used to retain access to the original error caught in a promise rejection. 

Improve Application-wide Error Handling rethrowing JavaScript Error with the Error Cause

You can finally make your numbers more readable in JavaScript. Add underscores in all types of numbers including BigInt, floats, hexes, octals, and binary to improve their readability. 

Just don't add the underscores to the beginning or end!

Make JavaScript Numbers more readable using Numeric Separators

[Promise.any](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/any) takes an iterable of promises and returns a promise that fulfills with the first promise that fulfills, and rejects when ALL of the promises in the iterable reject. 

[Promise.allSettled](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/allSettled) takes an iterable of promises, and returns an array of objects. The objects have a `status` property which is a string that is either `"fulfilled"` or `"rejected"`. If the `status` is `"fulfilled"` the object will contain a `value` property with the resolved value of the promise, and if the `status` is `"rejected"` the object will have a `reason` property with the reason for the promise's rejection. 

Manage Asynchronous JavaScript code with any, allSettled new Promise Methods

If we want to be able to modify the state of a promise from outside the constructor, we can use the [Promise.withResolvers](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers) method to get access to the promise, and its `resolve` and `reject ` functions. 



Manually settle a promise using Promise.withResolvers

The [Logical Assignment Operators](https://github.com/tc39/proposal-logical-assignment) bring syntactic sugar over verbose syntax which enforced us to write explicit `if` statements. Thanks to the new operators `||=`, `&&=` and `??=` we can express the conditional logic in a more concise way.

Simplify JavaScript code with Logical, Assignment and Optional Operators

The new [Array.with](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/with) method gives you an immutable syntax for changing values of an array at a specified index. 

Sometimes `.map` will be more efficient. So, in this lesson we'll compare both methods while replacing an object at a specific index.


Simplify array immutable changes with the new array.with method

You no longer need to write generator functions to create basic lazy iterator functions.

Now, ECMAScript supports iterator helpers that you can call on `Array.values()`. With these helpers, the values of an array will be operated on lazily, and will only run when the values are needed.



Make JavaScript computations lazy using Iterator Helpers

The ["Set Methods"](https://github.com/tc39/proposal-set-methods) proposal introduces 7 new methods to JavaScript/ECMAScript:
- `union`
- `intersection`,
- `difference`,
- `symmetricDifference`,
- `isSubsetOf`
- `isSupersetOf`
- `isDisjointFrom`

Thanks to them, complex operations using JavaScript sets will become much easier.

Perform Set Operations using JavaScript Set Methods

Finding elements starting from the end of an array has gotten a lot easier with the introduction of the `at`, `findLast`, and `findLastIndex` methods!

With `at` you no longer need to remember to access the end of the array like `array[array.length - 1]` trick. You can just call `.at[-1]` to get the last element!

`findLast` and `findLastIndex` work the same as their `find` and `findIndex` counterparts. But, they work backwards from the end of the array. This is useful if you know what you're accessing is going to be closer to the end.

Find Items from the end of the JavaScript Array using at, findLast and findLastIndex

[Array Grouping](https://github.com/tc39/proposal-array-grouping) is the new feature of JavaScript/ECMAScript, which splits an array (or, generally, an iterable), into smaller sub-arrays. Grouping is different than other JS array methods - it's *not* a part of the array prototype, but a static method.

Group data by keys using JavaScript Array Grouping (Object.groupBy)

Learn how the latest JavaScript features can help you improve your codebase. 

Learn the Latest ECMAScript Features (ES2024, ES2023, ...)

Next.js is a minimalistic framework for server-rendered React applications.

Define where Keystatic should store your content

In this video, you'll write some logic to toggle between local and Cloud storage modes for Keystatic, based on whether the site is running in development or production mode.

Change The Keystatic Storage Mode Based on NODE_ENV

In this video, you'll learn how to manually configure Keystatic to work in GitHub mode. 

You'll walk through the GitHub App creation flow, and then copy the environment variables over to the deployed instance to be able to edit content remotely.

Manually Connect a Keystatic Project To A GitHub Repo

In this video, you'll connect your project with Keystatic Cloud, so that content can be created and edited directly from the deployed URL.

No need to touch the codebase — the changes integrate directly with the GitHub repository!

Setup GitHub Collaboration With Keystatic Cloud

In this video, you'll add a generateStaticParams function in the individual author page, so that a static HTML page is generated at build time, so we can access those on Vercel.

Generate Static Pages From Keystatic Entries With generateStaticParams in Next.js 14

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

In this video, you'll deploy the Keystatic project to Vercel. You'll find out that not everything is working properly — and there are two different ways (both covered in the next videos) we can improve the situation.

Deploy a Keystatic Project To Vercel

In this video, you'll change the logo and site title for the Keystatic Admin UI, by using the brand options in the User Interface settings of the config file.

Change The Site Title and Logo In The Keystatic Admin UI

In this video, you'll customise the Keystatic Admin UI Navigation Sidebar and Dashboard by using the User Interface options in the config file.

Customise the Keystatic Admin UI Navigation Sidebar And Dashboard

In this video, you'll create a Keystatic Singleton to store social media links for the site's footer.

You'll also render these links in the root layout of the Next.js site.

Creating One-Off Datasets with Singletons in Keystatic

In this video, you'll discover how you can switch the Keystatic Admin UI to a "zen mode" content-focused layout for a given collection or singleton, by setting the Entry Layout option to "content".

Switch To a Content-Focused Layout In Keystatic

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

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!

Search

Search Results