Forem: Mike Turck

Forget Everything You Know About String Searching - Tries Will Blow Your Mind!

Mike Turck — Fri, 20 Sep 2024 20:09:27 +0000

Introduction to Trie Data Structure

A trie, also known as a prefix tree, is an efficient tree-like data structure used for storing and retrieving strings. It's particularly useful for tasks involving string searches, prefix matching, and autocomplete functionality.

Pronunciation:

It is a single syllable word
The "ie" at the end is pronounced as a long "e" sound, similar to "see" or "tree"
It does not rhyme with "pie" or "die" This pronunciation helps distinguish it from other similar-looking words and emphasizes its connection to data retrieval operations.

When to Use a Trie

Tries are ideal in scenarios where you need to:

Perform prefix-based searches quickly
Implement autocomplete features
Store a dictionary of words for spell-checking
Efficiently store and retrieve strings with common prefixes ## Visualizing a Trie

Let's visualize a trie containing the words "cat", "car", and "dog":

       root
     /   |   \
    c    d    ...
   /     |
  a      o
 / \     |
t   r    g

Each node represents a character, and the paths from root to leaf nodes form complete words.

Implementing a Trie in JavaScript

Let's implement a basic trie structure in JavaScript:

class TrieNode {
  constructor() {
    this.children = {};
    this.isEndOfWord = false;
  }
}

class Trie {
  constructor() {
    this.root = new TrieNode();
  }

  // Insert a word into the trie
  insert(word) {
    let node = this.root;
    for (let char of word) {
      if (!node.children[char]) {
        node.children[char] = new TrieNode();
      }
      node = node.children[char];
    }
    node.isEndOfWord = true;
  }

  // Search for a word in the trie
  search(word) {
    let node = this.root;
    for (let char of word) {
      if (!node.children[char]) {
        return false;
      }
      node = node.children[char];
    }
    return node.isEndOfWord;
  }

  // Check if any word starts with the given prefix
  startsWith(prefix) {
    let node = this.root;
    for (let char of prefix) {
      if (!node.children[char]) {
        return false;
      }
      node = node.children[char];
    }
    return true;
  }
}

// Example usage
const trie = new Trie();

// Insert words
trie.insert("apple");
trie.insert("app");
trie.insert("banana");

console.log(trie.search("apple"));    // Output: true
console.log(trie.search("app"));      // Output: true
console.log(trie.search("appl"));     // Output: false
console.log(trie.startsWith("app"));  // Output: true
console.log(trie.startsWith("ban"));  // Output: true
console.log(trie.startsWith("cat"));  // Output: false

Explanation of the Code

class TrieNode: Represents a node in the trie. Each node has:: An object to store child nodes: A boolean flag to mark the end of a word
class Trie: The main trie structure with methods:
- insert: Adds a word to the trie
- search: Checks if a word exists in the trie
- startsWith: Checks if any word in the trie starts with the given prefix
The method traverses the trie, creating new nodes for characters that don't exist and marking the last node as the end of a word.
The method traverses the trie along the path of the given word, returning if the entire word is found and marked as a complete word.
The method is similar to but only checks if the given prefix exists in the trie, regardless of whether it's a complete word.

Time and Space Complexity

Time Complexity:
- Insert: O(m), where m is the length of the word
- Search: O(m), where m is the length of the word
- StartsWith: O(m), where m is the length of the prefix
Space Complexity:O(n * m), where n is the number of words and m is the average length of words

Tries offer excellent performance for string-related operations, especially when dealing with a large set of words with common prefixes. They provide fast lookups and prefix matching, making them invaluable in various applications such as autocomplete systems, IP routing tables, and dictionary implementations.

If you liked this tutorial follow me here and on X/Twitter at @turckalicious. This article was made with the help of Wonderfall (https://wonderfall.xyz), an AI-powered interactive document editor that helps you research, write, and iterate faster.

Comparing UUID, CUID, and Nanoid: A Developer's Guide

Mike Turck — Fri, 20 Sep 2024 04:00:00 +0000

When it comes to generating unique identifiers in your applications, developers have several options to choose from. In this tutorial, we'll compare and contrast three popular choices: UUID, CUID, and Nanoid. We'll explore their characteristics, implementation in TypeScript, and recommend use cases for each.

UUID (Universally Unique Identifier)

UUID is a standardized 128-bit identifier that's widely used across various systems and applications.

Key Features:

128-bit length (36 characters including hyphens)
Extremely low collision probability (5.3x10^36 possible UUIDs)
Multiple versions and variants available

Usage:

import { v4 as uuidv4 } from 'uuid';

const id = uuidv4();
console.log(id); // e.g., '1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed'

Best Use Cases:

Distributed systems where uniqueness across multiple systems is crucial
Applications requiring a standardized, widely recognized identifier format

CUID (Collision-resistant Unique Identifier)

CUID is designed to be collision-resistant, sortable, and more compact than UUID.

Key Features:

25 characters long
Sequential for easy sorting
Designed for horizontal scaling in distributed systems

Usage:

import cuid from 'cuid';

const id = cuid();
console.log(id); // e.g., 'ckqtls7040000h3d8suihro21'

Best Use Cases:

Applications requiring sortable IDs
Distributed systems with a focus on collision resistance
Scenarios where slightly shorter IDs than UUID are preferred

Nanoid

Nanoid is a tiny, secure, URL-friendly unique string ID generator.

Key Features:

Customizable length (default 21 characters)
URL-friendly (uses A-Za-z0-9_- characters)
Extremely fast generation

Usage:

import { nanoid } from 'nanoid';

const id = nanoid();
console.log(id); // e.g., 'V1StGXR8_Z5jdHi6B-myT'

Best Use Cases:

Front-end applications requiring client-side ID generation
Scenarios where small bundle size is crucial
Applications needing short, URL-friendly IDs

Comparison of ID Generation Capacity

UUID: 2^128 ≈ 3.4 x 10^38 possible IDs
CUID: Theoretically unlimited, but practically limited by timestamp precision
Nanoid: 2^126 (with default settings) ≈ 9.5 x 10^37 possible IDs

Recommendations

Choose UUID when standardization and wide recognition are important, especially in enterprise or cross-system scenarios.
Opt for CUID when you need sortable IDs or are working in a distributed system with a focus on collision resistance.
Select Nanoid for client-side generation, URL-friendly IDs, or when you need a balance between uniqueness and ID length.

Remember, the best choice depends on your specific use case, system architecture, and performance requirements. Consider factors like ID length, generation speed, collision resistance, and sortability when making your decision.

If you enjoyed this content then check out Wonderfall, an interactive document editor with AI tools for parsing documents, viewing PDFs, saving highlights, and generating text.

Ultimate guide for problem solving in coding interviews

Mike Turck — Thu, 19 Sep 2024 23:31:10 +0000

Common Strategies for Coding Interview Questions

Two Pointers

The two pointers technique is often used to solve array-related problems efficiently. It involves using two pointers that either move towards each other or in the same direction.

Example: Finding a pair of numbers in a sorted array that sum up to a target value.

/**
 * Finds a pair of numbers in a sorted array that sum up to a target value.
 * Uses the two-pointer technique for efficient searching.
 * 
 * @param {number[]} arr - The sorted array of numbers to search through.
 * @param {number} target - The target sum to find.
 * @returns {number[]|null} - Returns an array containing the pair if found, or null if not found.
 */
function findPairWithSum(arr, target) {
  // Initialize two pointers: one at the start and one at the end of the array
  let left = 0;
  let right = arr.length - 1;

  // Continue searching while the left pointer is less than the right pointer
  while (left < right) {
    console.log(`Checking pair: ${arr[left]} and ${arr[right]}`);

    // Calculate the sum of the current pair
    const sum = arr[left] + arr[right];

    if (sum === target) {
      // If the sum equals the target, we've found our pair
      console.log(`Found pair: ${arr[left]} + ${arr[right]} = ${target}`);
      return [arr[left], arr[right]];
    } else if (sum < target) {
      // If the sum is less than the target, we need a larger sum
      // So, we move the left pointer to the right to increase the sum
      console.log(`Sum ${sum} is less than target ${target}, moving left pointer`);
      left++;
    } else {
      // If the sum is greater than the target, we need a smaller sum
      // So, we move the right pointer to the left to decrease the sum
      console.log(`Sum ${sum} is greater than target ${target}, moving right pointer`);
      right--;
    }
  }

  // If we've exhausted all possibilities without finding a pair, return null
  console.log("No pair found");
  return null;
}

// Example usage
const sortedArray = [1, 3, 5, 7, 9, 11];
const targetSum = 14;
findPairWithSum(sortedArray, targetSum);

Sliding Window

The sliding window technique is useful for solving problems that involve contiguous sequences in arrays or strings.

Example: Finding the maximum sum of a subarray of size k.

/**
 * Finds the maximum sum of a subarray of size k in the given array.
 * @param {number[]} arr - The input array of numbers.
 * @param {number} k - The size of the subarray.
 * @returns {number|null} The maximum sum of a subarray of size k, or null if the array length is less than k.
 */
function maxSubarraySum(arr, k) {
  // Check if the array length is less than k
  if (arr.length < k) {
    console.log("Array length is less than k");
    return null;
  }

  let maxSum = 0;
  let windowSum = 0;

  // Calculate sum of first window
  for (let i = 0; i < k; i++) {
    windowSum += arr[i];
  }
  maxSum = windowSum;

  console.log(`Initial window sum: ${windowSum}, Window: [${arr.slice(0, k)}]`);

  // Slide the window and update the maximum sum
  for (let i = k; i < arr.length; i++) {
    // Remove the first element of the previous window and add the last element of the new window
    windowSum = windowSum - arr[i - k] + arr[i];
    console.log(`New window sum: ${windowSum}, Window: [${arr.slice(i - k + 1, i + 1)}]`);

    // Update maxSum if the current window sum is greater
    if (windowSum > maxSum) {
      maxSum = windowSum;
      console.log(`New max sum found: ${maxSum}, Window: [${arr.slice(i - k + 1, i + 1)}]`);
    }
  }

  console.log(`Final max sum: ${maxSum}`);
  return maxSum;
}

// Example usage
const array = [1, 4, 2, 10, 23, 3, 1, 0, 20];
const k = 4;
maxSubarraySum(array, k);

Hash Table

Hash tables are excellent for solving problems that require quick lookups or counting occurrences.

Example: Finding the first non-repeating character in a string.

/**
 * Finds the first non-repeating character in a given string.
 * @param {string} str - The input string to search.
 * @returns {string|null} The first non-repeating character, or null if not found.
 */
function firstNonRepeatingChar(str) {
  const charCount = new Map();

  // Count occurrences of each character
  for (let char of str) {
    charCount.set(char, (charCount.get(char) || 0) + 1);
    console.log(`Character ${char} count: ${charCount.get(char)}`);
  }

  // Find the first character with count 1
  for (let char of str) {
    if (charCount.get(char) === 1) {
      console.log(`First non-repeating character found: ${char}`);
      return char;
    }
  }

  console.log("No non-repeating character found");
  return null;
}

// Example usage
const inputString = "aabccdeff";
firstNonRepeatingChar(inputString);

These strategies demonstrate efficient ways to solve common coding interview problems. The verbose logging in each example helps to understand the step-by-step process of the algorithms, which can be crucial during interviews to explain your thought process.

Here's a code block demonstrating how to use maps to better understand some of these operations:

// Create a new Map
const fruitInventory = new Map();

// Set key-value pairs
fruitInventory.set('apple', 5);
fruitInventory.set('banana', 3);
fruitInventory.set('orange', 2);

console.log('Initial inventory:', fruitInventory);

// Get a value using a key
console.log('Number of apples:', fruitInventory.get('apple'));

// Check if a key exists
console.log('Do we have pears?', fruitInventory.has('pear'));

// Update a value
fruitInventory.set('banana', fruitInventory.get('banana') + 2);
console.log('Updated banana count:', fruitInventory.get('banana'));

// Delete a key-value pair
fruitInventory.delete('orange');
console.log('Inventory after removing oranges:', fruitInventory);

// Iterate over the map
console.log('Current inventory:');
fruitInventory.forEach((count, fruit) => {
  console.log(`${fruit}: ${count}`);
});

// Get the size of the map
console.log('Number of fruit types:', fruitInventory.size);

// Clear the entire map
fruitInventory.clear();
console.log('Inventory after clearing:', fruitInventory);

This example demonstrates various Map operations:

Creating a new Map
Adding key-value pairs with
Retrieving values with
Checking for key existence with
Updating values
Deleting key-value pairs with
Iterating over the Map with
Getting the size of the Map
Clearing the entire Map with These operations are similar to the ones used in the firstNonRepeatingChar function, where we use a Map to count character occurrences and then search for the first character with a count of 1.

Dynamic Programming Tutorial

Dynamic programming is a powerful algorithmic technique used to solve complex problems by breaking them down into simpler subproblems. Let's explore this concept with an example of calculating Fibonacci numbers.

/**
 * Calculates the nth Fibonacci number using dynamic programming.
 * @param {number} n - The position of the Fibonacci number to calculate.
 * @returns {number} The nth Fibonacci number.
 */
function fibonacci(n) {
  // Initialize an array to store Fibonacci numbers
  const fib = new Array(n + 1);

  // Base cases
  fib[0] = 0;
  fib[1] = 1;

  console.log(`F(0) = ${fib[0]}`);
  console.log(`F(1) = ${fib[1]}`);

  // Calculate Fibonacci numbers iteratively
  for (let i = 2; i <= n; i++) {
    fib[i] = fib[i - 1] + fib[i - 2];
    console.log(`F(${i}) = ${fib[i]}`);
  }

  return fib[n];
}

// Example usage
const n = 10;
console.log(`The ${n}th Fibonacci number is:`, fibonacci(n));

This example demonstrates how dynamic programming can efficiently calculate Fibonacci numbers by storing previously computed values and using them for future calculations.

Binary Search Tutorial

Binary search is an efficient algorithm for finding an element in a sorted array. Here's an implementation with detailed logging:

/**
 * Performs a binary search on a sorted array.
 * @param {number[]} arr - The sorted array to search.
 * @param {number} target - The value to find.
 * @returns {number} The index of the target if found, or -1 if not found.
 */
function binarySearch(arr, target) {
  let left = 0;
  let right = arr.length - 1;

  while (left <= right) {
    const mid = Math.floor((left + right) / 2);
    console.log(`Searching in range [${left}, ${right}], mid = ${mid}`);

    if (arr[mid] === target) {
      console.log(`Target ${target} found at index ${mid}`);
      return mid;
    } else if (arr[mid] < target) {
      console.log(`${arr[mid]} < ${target}, searching right half`);
      left = mid + 1;
    } else {
      console.log(`${arr[mid]} > ${target}, searching left half`);
      right = mid - 1;
    }
  }

  console.log(`Target ${target} not found in the array`);
  return -1;
}

// Example usage
const sortedArray = [1, 3, 5, 7, 9, 11, 13, 15];
const target = 7;
binarySearch(sortedArray, target);

This implementation shows how binary search efficiently narrows down the search range by half in each iteration, making it much faster than linear search for large sorted arrays.

Depth-First Search (DFS)
Breadth-First Search (BFS)
Heap (Priority Queue)
Trie (Prefix Tree)
Union-Find (Disjoint Set)
Topological Sort

Depth-First Search (DFS)

Depth-First Search is a graph traversal algorithm that explores as far as possible along each branch before backtracking. Here's an example implementation for a graph represented as an adjacency list:

class Graph {
  constructor() {
    this.adjacencyList = {};
  }

  addVertex(vertex) {
    if (!this.adjacencyList[vertex]) this.adjacencyList[vertex] = [];
  }

  addEdge(v1, v2) {
    this.adjacencyList[v1].push(v2);
    this.adjacencyList[v2].push(v1);
  }

  dfs(start) {
    const result = [];
    const visited = {};
    const adjacencyList = this.adjacencyList;

    (function dfsHelper(vertex) {
      if (!vertex) return null;
      visited[vertex] = true;
      result.push(vertex);
      console.log(`Visiting vertex: ${vertex}`);

      adjacencyList[vertex].forEach(neighbor => {
        if (!visited[neighbor]) {
          console.log(`Exploring neighbor: ${neighbor} of vertex: ${vertex}`);
          return dfsHelper(neighbor);
        } else {
          console.log(`Neighbor: ${neighbor} already visited`);
        }
      });
    })(start);

    return result;
  }
}

// Example usage
const graph = new Graph();
['A', 'B', 'C', 'D', 'E', 'F'].forEach(vertex => graph.addVertex(vertex));
graph.addEdge('A', 'B');
graph.addEdge('A', 'C');
graph.addEdge('B', 'D');
graph.addEdge('C', 'E');
graph.addEdge('D', 'E');
graph.addEdge('D', 'F');
graph.addEdge('E', 'F');

console.log(graph.dfs('A'));

Breadth-First Search (BFS)

BFS explores all vertices at the present depth before moving to vertices at the next depth level. Here's an implementation:

class Graph {
  // ... (same constructor, addVertex, and addEdge methods as above)

  bfs(start) {
    const queue = [start];
    const result = [];
    const visited = {};
    visited[start] = true;

    while (queue.length) {
      let vertex = queue.shift();
      result.push(vertex);
      console.log(`Visiting vertex: ${vertex}`);

      this.adjacencyList[vertex].forEach(neighbor => {
        if (!visited[neighbor]) {
          visited[neighbor] = true;
          queue.push(neighbor);
          console.log(`Adding neighbor: ${neighbor} to queue`);
        } else {
          console.log(`Neighbor: ${neighbor} already visited`);
        }
      });
    }

    return result;
  }
}

// Example usage (using the same graph as in DFS example)
console.log(graph.bfs('A'));

Heap (Priority Queue)

A heap is a specialized tree-based data structure that satisfies the heap property. Here's a simple implementation of a min-heap:

class MinHeap {
  constructor() {
    this.heap = [];
  }

  getParentIndex(i) {
    return Math.floor((i - 1) / 2);
  }

  getLeftChildIndex(i) {
    return 2 * i + 1;
  }

  getRightChildIndex(i) {
    return 2 * i + 2;
  }

  swap(i1, i2) {
    [this.heap[i1], this.heap[i2]] = [this.heap[i2], this.heap[i1]];
  }

  insert(key) {
    this.heap.push(key);
    this.heapifyUp(this.heap.length - 1);
  }

  heapifyUp(i) {
    let currentIndex = i;
    while (this.heap[currentIndex] < this.heap[this.getParentIndex(currentIndex)]) {
      this.swap(currentIndex, this.getParentIndex(currentIndex));
      currentIndex = this.getParentIndex(currentIndex);
    }
  }

  extractMin() {
    if (this.heap.length === 0) return null;
    if (this.heap.length === 1) return this.heap.pop();

    const min = this.heap[0];
    this.heap[0] = this.heap.pop();
    this.heapifyDown(0);
    return min;
  }

  heapifyDown(i) {
    let smallest = i;
    const left = this.getLeftChildIndex(i);
    const right = this.getRightChildIndex(i);

    if (left < this.heap.length && this.heap[left] < this.heap[smallest]) {
      smallest = left;
    }

    if (right < this.heap.length && this.heap[right] < this.heap[smallest]) {
      smallest = right;
    }

    if (smallest !== i) {
      this.swap(i, smallest);
      this.heapifyDown(smallest);
    }
  }
}

// Example usage
const minHeap = new MinHeap();
[3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5].forEach(num => minHeap.insert(num));
console.log(minHeap.heap);
console.log(minHeap.extractMin());
console.log(minHeap.heap);

Trie (Prefix Tree)

A Trie is an efficient information retrieval data structure, commonly used for string searching:

class TrieNode {
  constructor() {
    this.children = {};
    this.isEndOfWord = false;
  }
}

class Trie {
  constructor() {
    this.root = new TrieNode();
  }

  insert(word) {
    let current = this.root;
    for (let char of word) {
      if (!current.children[char]) {
        current.children[char] = new TrieNode();
      }
      current = current.children[char];
    }
    current.isEndOfWord = true;
    console.log(`Inserted word: ${word}`);
  }

  search(word) {
    let current = this.root;
    for (let char of word) {
      if (!current.children[char]) {
        console.log(`Word ${word} not found`);
        return false;
      }
      current = current.children[char];
    }
    console.log(`Word ${word} ${current.isEndOfWord ? 'found' : 'not found'}`);
    return current.isEndOfWord;
  }

  startsWith(prefix) {
    let current = this.root;
    for (let char of prefix) {
      if (!current.children[char]) {
        console.log(`No words start with ${prefix}`);
        return false;
      }
      current = current.children[char];
    }
    console.log(`Found words starting with ${prefix}`);
    return true;
  }
}

// Example usage
const trie = new Trie();
['apple', 'app', 'apricot', 'banana'].forEach(word => trie.insert(word));
trie.search('app');
trie.search('application');
trie.startsWith('app');
trie.startsWith('ban');

Union-Find (Disjoint Set)

Union-Find is a data structure that keeps track of elements which are split into one or more disjoint sets:

class UnionFind {
  constructor(size) {
    this.parent = Array(size).fill().map((_, i) => i);
    this.rank = Array(size).fill(0);
    this.count = size;
  }

  find(x) {
    if (this.parent[x] !== x) {
      this.parent[x] = this.find(this.parent[x]);
    }
    return this.parent[x];
  }

  union(x, y) {
    let rootX = this.find(x);
    let rootY = this.find(y);

    if (rootX === rootY) return;

    if (this.rank[rootX] < this.rank[rootY]) {
      [rootX, rootY] = [rootY, rootX];
    }
    this.parent[rootY] = rootX;
    if (this.rank[rootX] === this.rank[rootY]) {
      this.rank[rootX]++;
    }
    this.count--;

    console.log(`United ${x} and ${y}`);
  }

  connected(x, y) {
    return this.find(x) === this.find(y);
  }
}

// Example usage
const uf = new UnionFind(10);
uf.union(0, 1);
uf.union(2, 3);
uf.union(4, 5);
uf.union(6, 7);
uf.union(8, 9);
uf.union(0, 2);
uf.union(4, 6);
uf.union(0, 4);

console.log(uf.connected(1, 5)); // Should print: true
console.log(uf.connected(7, 9)); // Should print: false

Topological Sort

Topological sorting is used for ordering tasks with dependencies. Here's an implementation using DFS:

class Graph {
  constructor() {
    this.adjacencyList = {};
  }

  addVertex(vertex) {
    if (!this.adjacencyList[vertex]) this.adjacencyList[vertex] = [];
  }

  addEdge(v1, v2) {
    this.adjacencyList[v1].push(v2);
  }

  topologicalSort() {
    const visited = {};
    const stack = [];

    const dfsHelper = (vertex) => {
      visited[vertex] = true;
      this.adjacencyList[vertex].forEach(neighbor => {
        if (!visited[neighbor]) {
          dfsHelper(neighbor);
        }
      });
      stack.push(vertex);
      console.log(`Added ${vertex} to stack`);
    };

    for (let vertex in this.adjacencyList) {
      if (!visited[vertex]) {
        dfsHelper(vertex);
      }
    }

    return stack.reverse();
  }
}

// Example usage
const graph = new Graph();
['A', 'B', 'C', 'D', 'E', 'F'].forEach(vertex => graph.addVertex(vertex));
graph.addEdge('A', 'C');
graph.addEdge('B', 'C');
graph.addEdge('B', 'D');
graph.addEdge('C', 'E');
graph.addEdge('D', 'F');
graph.addEdge('E', 'F');

console.log(graph.topologicalSort());

These implementations provide a solid foundation for understanding and using these important algorithms and data structures in coding interviews and real-world applications.

If you liked this tutorial follow me here and on X/Twitter at @turckalicious. This article was made with the help of Wonderfall (https://wonderfall.xyz), an AI-powered interactive document editor that helps you research, write, and iterate faster.

Never worry about environment variables again with direnv

Mike Turck — Thu, 19 Sep 2024 22:02:29 +0000

Unlock the Power of Dynamic Environments with direnv

Are you tired of juggling multiple environment configurations for your projects? Say hello to direnv, your new best friend in development productivity!

What is direnv?

direnv is a powerful, lightweight tool that automatically loads and unloads environment variables depending on your current directory. It's like having a personal assistant that sets up your development environment for you, every time you change projects.

Installation: Quick and Easy

Getting started with direnv is a breeze. For Mac users, it's as simple as:

brew install direnv

Setting Up Your First .envrc File

Unlike traditional .env files, direnv uses .envrc files. Here's a quick example:

# .envrc
export NODE_ENV=development
export FAVORITE_COLOR=blue

The Magic Command: direnv allow

After creating your .envrc, run:

direnv allow

This command tells direnv that it's safe to load the environment variables from your .envrc file. It's a security feature to prevent unauthorized scripts from modifying your environment.

Why direnv is a Game-Changer

Monorepo Friendly: Share environment configurations across multiple projects in a monorepo with ease.
No Special Packages Required: direnv works with your shell, no need for language-specific environment managers.
Automatic Switching: Walk into a project directory, and your environment is instantly configured.
Version Control Friendly: Commit your .envrc files to ensure consistent environments across your team.

Pro Tips

Use direnv edit . to safely edit your .envrc file.
Combine with tools like nvm or pyenv for ultimate flexibility.

Embrace the power of direnv and watch your development workflow transform. Say goodbye to manual environment switching and hello to seamless, project-specific configurations!

If you liked this tutorial follow me here and on X/Twitter at @turckalicious. This article was made with the help of Wonderfall (https://wonderfall.xyz), an AI-powered interactive document editor that helps you research, write, and iterate faster.

JavaScript For Loop Examples

Mike Turck — Thu, 19 Sep 2024 21:57:56 +0000

Standard For Loop

for (let i = 0; i < 5; i++) {
  console.log(`Iteration ${i + 1}`);
}

For...of Loop (Iterating over Arrays)

const fruits = ['apple', 'banana', 'orange'];
for (const fruit of fruits) {
  console.log(fruit);

For...in Loop (Iterating over Object Properties)

const person = {
  name: 'John',
  age: 30,
  job: 'Developer'
};

for (const key in person) {
  console.log(`${key}: ${person[key]}`);
}

forEach Loop (Array Method)

const numbers = [1, 2, 3, 4, 5];
numbers.forEach((number, index) => {
  console.log(`Index ${index}: ${number}`);
});

While Loop (Not technically a for loop, but worth mentioning)

let count = 0;
while (count < 3) {
  console.log(`Count: ${count}`);
  count++;
}

These examples demonstrate various ways to iterate in JavaScript, each suited for different scenarios and data structures.

Tutorial: Getting Started with @kubernetes-client/node

Mike Turck — Wed, 18 Sep 2024 20:52:46 +0000

Tutorial: Getting Started with @kubernetes-client/node

Introduction

@kubernetes-client/node is the official Node.js client library for Kubernetes. It provides a powerful and flexible way to interact with Kubernetes clusters programmatically. This tutorial will guide you through the basics of using @kubernetes-client/node in your Node.js applications.

Installation

To get started, install the @kubernetes-client/node package using npm:

npm install @kubernetes-client/node

Setting up the Client

First, let's import the necessary modules and create a Kubernetes client:

const k8s = require('@kubernetes-client/node');

async function main() {
  const kc = new k8s.KubeConfig();
  kc.loadFromDefault();
  const client = kc.makeApiClient(k8s.CoreV1Api);

  // Your code here
}

main().catch(console.error);

This code creates a KubeConfig object, loads the default configuration (usually from ~/.kube/config), and creates an API client for the Core V1 API.

Listing Pods

Let's start with a simple example of listing pods in the default namespace:

async function listPods() {
  const kc = new k8s.KubeConfig();
  kc.loadFromDefault();
  const client = kc.makeApiClient(k8s.CoreV1Api);

  try {
    const res = await client.listNamespacedPod('default');
    console.log('Pods in default namespace:');
    for (const item of res.body.items) {
      console.log(`  - ${item.metadata.name}`);
    }
  } catch (err) {
    console.error('Error listing pods:', err);
  }
}

listPods();

This function will list all pods in the default namespace.

Creating a Deployment

Now, let's create a simple deployment:

const k8s = require('@kubernetes-client/node');

async function createDeployment() {
  const kc = new k8s.KubeConfig();
  kc.loadFromDefault();
  const client = kc.makeApiClient(k8s.AppsV1Api);

  const deployment = {
    metadata: {
      name: 'nginx-deployment'
    },
    spec: {
      replicas: 3,
      selector: {
        matchLabels: {
          app: 'nginx'
        }
      },
      template: {
        metadata: {
          labels: {
            app: 'nginx'
          }
        },
        spec: {
          containers: [{
            name: 'nginx',
            image: 'nginx:1.14.2',
            ports: [{
              containerPort: 80
            }]
          }]
        }
      }
    }
  };

  try {
    const res = await client.createNamespacedDeployment('default', deployment);
    console.log('Deployment created');
  } catch (err) {
    console.error('Error creating deployment:', err);
  }
}

createDeployment();

This function creates a deployment with three replicas of an Nginx container.

Watching Resources

@kubernetes-client/node also supports watching resources for changes:

const k8s = require('@kubernetes-client/node');

async function watchPods() {
  const kc = new k8s.KubeConfig();
  kc.loadFromDefault();
  const watch = new k8s.Watch(kc);

  try {
    const req = await watch.watch('/api/v1/namespaces/default/pods',
      {},
      (type, apiObj) => {
        console.log(`Pod ${apiObj.metadata.name} ${type}`);
      },
      (err) => {
        console.log(err);
      }
    );

    // Stop the watch after 30 seconds
    setTimeout(() => {
      req.abort();
    }, 30000);
  } catch (err) {
    console.error('Error watching pods:', err);
  }
}

watchPods();

This function sets up a watch on pods in the default namespace and logs any changes for 30 seconds.

Conclusion

This tutorial has covered the basics of using @kubernetes-client/node, including setting up the client, listing resources, creating deployments, and watching for changes. The library offers many more capabilities for interacting with your Kubernetes clusters. For more advanced usage and a complete API reference, check out the @kubernetes-client/node documentation.

Remember to handle errors appropriately and consider using TypeScript for better type checking and autocompletion when working with the Kubernetes API objects.

If you enjoyed this content then check out Wonderfall, an interactive document editor with AI tools for parsing documents, viewing PDFs, saving highlights, and generating text.

Create An Animated VR Site With 30 Lines Of Code

Mike Turck — Fri, 24 Jul 2020 22:09:00 +0000

Note: The live code for this tutorial can be found here

Adding VR Into Your Site Is Easy

Adding virtual reality into a website is as simple as using regular HTML thanks to a library called A-Frame, which is a framework for building virtual reality in the web.

In the same way that you initiate HTML content with the <body> tag and add text using something like the <h1> tag, A-Frame lets you initiate a VR scene using the <a-scene> tag and you can add 3D content into your scene using tags like <a-box>, <a-sphere>, and more.

It's worth checking out the A-frame starter example to see just how easily this is done.

What we are building

My example will be slightly more complex than the A-Frame starter scene. Instead of building a pure VR scene, I want to overlay 2D content on top of the VR scene. In this way, the VR aspect acts as a fun background and you can still display 2D content on the screen. Pretty cool, let's get started!

High Level Code Overview

There are three core tasks to be accomplished here:

Create the VR Scene
Create the HTML overlay container
Add HTML into the container

I recommend following along with the live code here.

Create the VR Scene

First we must load the A-Frame library into the HTML code. Second, we will load aframe-extras which is a user created library that adds a few additional components we can use. In this case, we want to use the <a-ocean> component.

To import these libraries, add the following into the HTML <head> section:

 <script src="https://aframe.io/releases/1.0.4/aframe.min.js"></script>
 <script src="//cdn.rawgit.com/donmccurdy/aframe-extras/v3.13.1/dist/aframe-extras.min.js"></script>

Now we are ready to create a VR scene.

The <a-scene></a-scene> tags are used to initiate a VR scene, and 3D objects are placed inside of these tags. The basic components of any 3D scene are: a camera, lights, and of course some 3D objects. <a-scene> creates a camera and basic lighting by default.

Our scene will consist of the <a-ocean> tag which has a cool wave animation, and a few lights to add some color into the scene. To create the lights, the <a-light> tag is used and properties are added to set the color and position.

Adding a property to an A-Frame element is the same as adding a property to an HTML element. Below is an example of how to set the color property to "red" on a <a-light> element.

<a-light color="red"><a-light>

The code for the entire seen in only six lines of code and shown below:

  <a-scene>
    <a-ocean color="#ffffff" rotation="0 0 0" width="50" depth="50" density="80" position="0 0 -4"></a-ocean>
    <a-light type="point" color="#ffef00" intensity="0.7" position="0 0 0"></a-light>
    <a-light type="point" color="#0815fa" intensity="0.7" position="10 0 0"></a-light>
    <a-light type="point" color="#ff0000" intensity="0.7" position="-10 0 0"></a-light>
  </a-scene>

Create the Overlay Container

By default, the VR scene takes up the whole screen. In order to overlay 2D content, we must create a new set of <div> tags and use CSS to tell the browser that we want that div and all of its contents to sit above the VR scene.

We will first create an overlay class using CSS. Note I've added additional styling that uses CSS flexbox to center everything inside of this overlay container.

.overlay {
  /* To create the overlay   */
  position: absolute;
  z-index: 10;
  /* To center all elements inside the overlay  */
  width: 100%;
  height: 100%;
  display: flex;
  justify-content: center;
  align-items: center;
  flex-direction: column;
}

Add Some HTML

Lastly, we need to some content into the overlay container. For this example, I'll just add some text.

The full HTML for our overlay section is:

  <div class="overlay">
    <h1>Totally Rad Title</h1>
    <p>Try this on mobile for a neat VR effect</p>
  </div>

And that's it! With this, we have created a 2D overlay on top of a VR scene. The full HTML code (with comments) for this example is:

<!DOCTYPE html>
<html lang="en" class="no-js">

<head>
    <!-- load aframe   -->
  <script src="https://aframe.io/releases/1.0.4/aframe.min.js"></script>
    <!--  load aframe-extras to get access to the <ocean> component  -->
  <script src="//cdn.rawgit.com/donmccurdy/aframe-extras/v3.13.1/dist/aframe-extras.min.js"></script>
    <!--  import a funky font  -->
  <link href="https://fonts.googleapis.com/css2?family=Lobster&display=swap" rel="stylesheet"> 
    <!--  load styling to enable html overlay  -->
  <link rel="stylesheet" type="text/css" href="style.css">
</head>

<body>
    <!--  overlay any html over aframe scene  -->
  <div class="overlay">
    <h1>Totally Rad Title</h1>
    <p>Try this on mobile for a neat VR effect</p>
  </div>
    <!-- create animated ocean scene using aframe.io   -->
  <a-scene>
    <a-ocean color="#ffffff" rotation="0 0 0" width="50" depth="50" density="80" position="0 0 -4"></a-ocean>
      <!-- lighting determines color of ocean animation -->
    <a-light type="point" color="#ffef00" intensity="0.7" position="0 0 0"></a-light>
    <a-light type="point" color="#0815fa" intensity="0.7" position="10 0 0"></a-light>
    <a-light type="point" color="#ff0000" intensity="0.7" position="-10 0 0"></a-light>
  </a-scene>
</body>
</html>

Next Steps: Customize This Code

Glitch is one of the best sites for quickly creating and sharing projects. Remix the code for this project here.

Some inspiration for how to tweak this example:

Change the lighting: Try using different color properties on the a-light elements (lines 25-27) for different effects.
Change the ocean density: The spacing of the "ocean waves" are determined by the density property of the a-ocean component (line 23). Use a small value for larger waves, and a large value for smaller waves.
Add more 3D objects: Feel free to add more shapes into the scene. Maybe rotate the ocean 90 degrees and add some new components to create an island. See the A-Frame documentation to see components are readily available.
Move things around: Try changing the rotation and position of different elements. Both of these properties accept a text string consisting of three values i.e. "90 0 0". The three values represent the x, y, and z axis, respectively.

Useful resources

Learn more about building VR in the web with A-Frame
Learn more about position HTML elements with CSS Flexbox

Easily work across multiple config environments in your React / Node.js app

Mike Turck — Thu, 23 Jul 2020 00:36:34 +0000

Use Case

You work on a React or Node.js app that exists in multiple environments i.e. dev, staging, production.

Each environment has a unique configuration. Perhaps your dev environment calls localhost to simulate external API calls while your production environment calls a live server.

In these types of scenarios, you'd like an easy way to switch between environment configurations during development/deploymnet without modifying your app code. Ideally, you would like to store all your environment variables in a single config file based on environment i.e. your might use env.dev, env.staging, env.prod. Then you can activate these environment variables on app startup.

The `env-cmd` package saves the day!

env-cmd allows you to select a desired config file to be used in your package.json startup scripts.

For example, you might use yarn start:dev to select your .env.dev configuration for testing on your local machine.

How To use `env-cmd`

You will want to navigate to a sample project or create a new one. For this example, I will create a new project using create-react-app

# create a new project
npx create-react-app multiple-env-example

# navigate into the project folder
cd multiple-env-example

bash

Install the `env-cmd` package

yarn add env-cmd

Create your `.env` files

For this example, we'll create two environment files: one for dev, and one for production. Each file will list a single REACT_APP_TEST_VAR variable.

DO NOT STORE SENSITIVE INFO IN THESE FILES. This configuration is intended for public info such as API endpoints and urls. Secret keys should be stored separately and not placed into version control.

Note: If you are using React, your environment variables must start with REACT_APP_

# create a .env.dev file with one env var
cat >> .env.dev << EOF 
REACT_APP_TEST_VAR=development 
EOF

# create a .env.prod file with one env var
cat >> .env.prod << EOF
REACT_APP_TEST_VAR=production
EOF

Add `env-cmd` into your `package.json` start scripts

In your package.json file, add the following into scripts

"scripts": {
    "start:prod": "env-cmd -f .env.prod react-scripts start",
    "start:dev": "env-cmd -f .env.dev react-scripts start",
}

Add the environment variable into your file

Environment variables should be prepended with process.env.

For this example, replace src/App.js ( if using create-react-app ) with the following:

import React from 'react'

const App = () => <h1>{process.env.REACT_APP_TEST_VAR} environment</h1>


export default App;

Now start the app!

Run

yarn start:dev

Your screen should say development environment!

Likewise, if you run yarn start:prod it will say 'production environment`!

Conclusion

Working with multiple environment configurations in your app doesn't need to be difficult. The env-cmd package makes it easy to declare which environment file you would like to use.

These environment configurations can be version controlled as a way of documenting external services over time. Just remember not to store sensitive information in these files as they will be public.

Quick Guide to Destructuring in ES6

Mike Turck — Tue, 21 Jul 2020 01:12:11 +0000

Basic Destructuring

Destructuring is a feature of ES6 that lets you extract variables from larger json objects

const viewState = {
  latitude: -122.4,
  longitude: 37.78,
  zoom: 12
}

// Grab latitude and longitude from the viewState json object
const { latitude, longitude } = viewState;

console.log(latitude)  // -122.4
console.log(longitude) // 37.78

Destructure and rename

// Grab latitude and longitude. 
// Rename them to lat and long, respectively
const { latitude:lat, longitude:long } = viewState;

console.log(lat)       // -122.4
console.log(lon)       // 37.78

Destructure props passed to a React component

// sample props
{
    title: 'My Article Title',
    subTitle: 'A story of Destructuring'
}

// Without destructuring
const SimpleTitle = (props) => <h1>{props.title}</h1>

// With destructuring
const SimpleTitle = ({title}) => <h1>{title}</h1>

Forem: Mike Turck

Forget Everything You Know About String Searching - Tries Will Blow Your Mind!

Introduction to Trie Data Structure

Pronunciation:

When to Use a Trie

Implementing a Trie in JavaScript

Explanation of the Code

Time and Space Complexity

Comparing UUID, CUID, and Nanoid: A Developer's Guide

UUID (Universally Unique Identifier)

Key Features:

Usage:

Best Use Cases:

CUID (Collision-resistant Unique Identifier)

Key Features:

Usage:

Best Use Cases:

Nanoid

Key Features:

Usage:

Best Use Cases:

Comparison of ID Generation Capacity

Recommendations

Ultimate guide for problem solving in coding interviews

Common Strategies for Coding Interview Questions

Two Pointers

Sliding Window

Hash Table

Dynamic Programming Tutorial

Binary Search Tutorial

Depth-First Search (DFS)

Breadth-First Search (BFS)

Heap (Priority Queue)

Trie (Prefix Tree)

Union-Find (Disjoint Set)

Topological Sort

Never worry about environment variables again with direnv

Unlock the Power of Dynamic Environments with direnv

What is direnv?

Installation: Quick and Easy

Setting Up Your First .envrc File

The Magic Command: direnv allow

Why direnv is a Game-Changer

Pro Tips

JavaScript For Loop Examples

Standard For Loop

For...of Loop (Iterating over Arrays)

For...in Loop (Iterating over Object Properties)

forEach Loop (Array Method)

While Loop (Not technically a for loop, but worth mentioning)

Tutorial: Getting Started with @kubernetes-client/node

Tutorial: Getting Started with @kubernetes-client/node

Introduction

Installation

Setting up the Client

Listing Pods

Creating a Deployment

Watching Resources

Conclusion

Create An Animated VR Site With 30 Lines Of Code

Adding VR Into Your Site Is Easy

What we are building

High Level Code Overview

Create the VR Scene

Create the Overlay Container

Add Some HTML

Next Steps: Customize This Code

Useful resources

Easily work across multiple config environments in your React / Node.js app

Use Case

The env-cmd package saves the day!

How To use env-cmd

Install the env-cmd package

Create your .env files

Add env-cmd into your package.json start scripts

Add the environment variable into your file

Now start the app!

Conclusion

Quick Guide to Destructuring in ES6

Basic Destructuring

The `env-cmd` package saves the day!

How To use `env-cmd`

Install the `env-cmd` package

Create your `.env` files

Add `env-cmd` into your `package.json` start scripts