 Courses from Dimitri Ivashchuk

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

In this lesson you will learn how to write an interview coding task which challenges you with reversing the integer and keeping the original sign intact. You will use different methods like `toString`, `reverse`, `split` and `join` to achieve the needed functionality using functional programming approach.


Write a reverse integer function using string and array methods

Recursive functions are inherently hard concept to grasp for many beginners. `reduce` array method shares the same title of being the hardest among the methods. Let's bring it up a notch and create a recursive reduce function that flattens a nested array in JavaScript to finally figure how both of them work!

Flatten nested array using recursive reduce function

In this lesson we will use functional programming approach to solve the challenge which requires you to capitalize all the letters of the string passed to the function. We will employ ` array.map` together with `string.split` and `string.join` to achieve this functionality.

Write a capitalize string function with array and string methods

In this lesson you will learn how to write an anagram check function with 'array.filter' and 'array.sort' methods. We will use functional programming approach to compare if two string have the same letters but in different order, excluding all special characters like spaces, exclamation marks etc.

Write anagram check function with array and string methods

Reduce is one of the of the hardest array methods to understand for beginners, mastering it gives you better chances to shine at the interview when asked a question regarding it! 

Let's implement one of the easiest array methods (map) with the hardest one (reduce).

Implement array map function with array.reduce method

This collection gathers lessons that resemble JavaScript interview coding assignments and teaches you to write quality, readable and reusable code. It's always frustrating when you learn the language for months and then some tricky question at the interview stops you from getting a job. Follow the lessons in this collection and be prepared for tricky coding challenges!

Although solving coding assignments is pretty important the true value of the collection lies in the approaching problems correctly, using shortcuts where it's needed and writing verbose code where necessary.

This collection starts with an overview of how to set up a scratchpad in VSCode using quokka.js, so you can follow the lesson in an easier fashion, as this is the technology used to explain concepts! It is followed with an explanation of how to write arrow functions as those are also frequently used throughout the playlist. 

!!! New content is still getting added to the collection !!!

JavaScript interview: Learn functional programming with solving coding challenges

Bite-size video tutorials for badass web developers.

egghead

Learn how write a function that capitilizes words in the string from the scratch. We will use map array method, some native string functions and overall apply functional programming approach to solve this popular interview question.

Capitalize words in the string with array.map and string methods

In this lesson you will learn how to answer a typical beginner interview question of writing a function that check for a string to be a palindrome(reads the same backward as forward). 

We will employ string methods like split() and toLowerCase() as well as array methods like reverse() and join(). After writing a step by step function to perform the check we refactor it to be shorter but still readable and working.

Write a Palindrome Check function in JavaScript using string and array methods

In this lesson you will learn how to remove duplicates from the flat array which is a common coding challenge for beginner JavaScript interviews. 

We will learn how to write a duplicate removal function using functional programming approach with reduce array method. You will see how we can remove duplicates by checking whether the accumulator in reduce already contains a value that is trying to be added to the resulting array.

Remove Duplicates from Flat Array with array.reduce in JavaScript

In this lesson you will learn how to remove duplicates from the flat array which is a common coding challenge for beginner JavaScript interviews. 

We will learn how to write a duplicate removal function using functional programming approach with filter. The array filter method allows you to create a new array out of elements that pass a certain condition within the filter. You'll see how we can use `indexOf` to filter out any duplicates.

Filter out Duplicates from Flat JavaScript Array with array.filter 

In this lesson you will learn how to remove duplicates from the flat array which is a common coding challenge for beginner JavaScript interviews. 

We will employ the easiest and one of the fastest duplicate removal methods with the help of Set. Set is a data structure in JavaScript that only allows unique elements to be stored within it. By converting an Array to a Set and then back to an Array you'll see how we can easily filter out duplicates.

Remove Duplicates from Flat Array in with JavaScripts Set Data Structure

In this lesson you will learn how to solve a beginner interview question, namely how to rewrite a normal function as an arrow function. We go trough syntactical peculiarities, explicit and implicit return versions of arrow functions and touch the non-syntactical distinguishing features of arrow functions.

Rewrite a JavaScript Function as an Arrow Function

Gatsby is a blazing fast static site generator built with React. Gatsby gives you all of the modern JavaScript tools you want; set up and ready to go out of the box.

gatsby

Gatsby is super fun technology, so are Telegram and Netlify! As a frequent telegram user I find it the fastest to have notifications from my websites to be delivered directly to telegram as messages.

It is very convenient and easy to implement the transport for the messages from the static website directly to the telegram. Learn how in this lesson!

Send notification from Gatsby to Telegram with Netlify lambda functions

In this lesson you will learn how to create a minimalistic JavaScript playground with quokka.js and zen mode. You will also get an overview of some cool features quokka provides.

[Download quokka.js here](https://marketplace.visualstudio.com/items?itemName=WallabyJs.quokka-vscode)

Create JavaScript Scratchpad with quokka.js in VSCode

In this lesson you will learn how to increase performance of the images used in your website built with Gatsby.js. Img component provided by Gatsby enables lazy loading, applies cool visual effects on image loads and is virtually everything you need to comfortably work with images.


Load Images in Gatsby.js with gatsby-source-filesystem

React is one of the web’s most popular frameworks for building JavaScript applications. 

If you know what you’re doing, React can drastically simplify how you build, use, and maintain code.

Whether you’re a React newbie or you’re ready for advanced techniques, you can level-up with egghead. Explore our in-depth courses, lessons, and community resources to build more powerful applications and crack open your career.

react

In this lesson you will learn how to add native-like animation to the projects built with Gatsby.js. This lesson uses gatsby-plugin-layout to inject location property to the pages of the website and react-transition-group to add smooth animations when navigating between them.

Animate Page Transitions in Gatsby.js using react-transition-group

In this lesson we will learn how to animate SVGs(Scalable Vector Graphics) imported as React components. As most SVGs are built with different shapes and paths we can use this and apply specific animations to them.

 The whole idea is not 100% dependent on styled components as the same result can be achieved without using CSS-in-JS.

Animate complex SVG in React with styled components

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.

Dimitri Ivashchuk

Search Results