DEV Community: Piyush Chauhan

Backtracking Unveiled: Mastering Depth-First Search and Pruning Techniques

Piyush Chauhan — Sat, 22 Feb 2025 09:04:27 +0000

Backtracking is a systematic way to iterate through all possible configurations of a problem. It is often used to solve problems where a sequence of decisions must be made, and each decision leads to a new set of possibilities. Backtracking uses depth-first search (DFS) to explore the state space, and it employs pruning functions to eliminate invalid or suboptimal paths early in the search process.

Components of Backtracking Problems

Initial State: The starting point of the problem.
Target/Goal State: The desired solution.
Intermediate States: States generated while moving from the initial state to the target state.
Path: The sequence of states from the initial state to the target state.
Operators: Rules or actions that transform one state into another.
Pruning Function: A heuristic to eliminate invalid or suboptimal states early.

Backtracking Algorithm

Start with the initial state.
Use DFS to explore all possible states.
If a state is invalid (based on the pruning function), backtrack and try another path.
If a state is the goal state, return the solution.
Repeat until all possible states are explored or a solution is found.

Example Problems Solved Using Backtracking

1. 3-Digit Lock Problem

Initial State: "111"
Target State: The correct combination (e.g., "352")
Operators: Increment each digit by 1 (from 1 to 9).
Pruning Function: If a digit is correct (e.g., produces a "click"), fix it and move to the next digit.

Implementation:

function findLockCombination(target) {
    function backtrack(combination, index) {
        if (combination === target) {
            console.log("Found combination:", combination);
            return true;
        }
        if (index >= 3) return false;

        for (let i = 1; i <= 9; i++) {
            const newCombination = combination.slice(0, index) + i + combination.slice(index + 1);
            if (newCombination[index] === target[index]) {
                console.log("Click at position", index + 1, "with digit", i);
                if (backtrack(newCombination, index + 1)) return true;
            }
        }
        return false;
    }

    backtrack("111", 0);
}

const targetCombination = "352";
findLockCombination(targetCombination);

2. Monks and Demons Problem

Initial State: 3 monks, 3 demons, and the boat on the left shore.
Target State: All monks and demons on the right shore.
Operators: Move 1 or 2 people in the boat.
Pruning Function: Ensure that monks are never outnumbered by demons on either shore.

Implementation:

function solveMonksAndDemons() {
    const initialState = { left: { monks: 3, demons: 3 }, right: { monks: 0, demons: 0 }, boat: "left" };
    const visited = new Set();

    function isSafe(state) {
        const { left, right } = state;
        return (
            (left.monks === 0 || left.monks >= left.demons) &&
            (right.monks === 0 || right.monks >= right.demons)
        );
    }

    function backtrack(state, path = []) {
        const key = JSON.stringify(state);
        if (visited.has(key)) return false;
        visited.add(key);

        if (state.left.monks === 0 && state.left.demons === 0) {
            console.log("Solution found:", path);
            return true;
        }

        const { left, right, boat } = state;
        const moves = [
            { monks: 1, demons: 0 },
            { monks: 2, demons: 0 },
            { monks: 0, demons: 1 },
            { monks: 0, demons: 2 },
            { monks: 1, demons: 1 },
        ];

        for (const move of moves) {
            if (
                (boat === "left" && left.monks >= move.monks && left.demons >= move.demons) ||
                (boat === "right" && right.monks >= move.monks && right.demons >= move.demons)
            ) {
                const newLeft = {
                    monks: left.monks - (boat === "left" ? move.monks : -move.monks),
                    demons: left.demons - (boat === "left" ? move.demons : -move.demons),
                };
                const newRight = {
                    monks: right.monks - (boat === "right" ? move.monks : -move.monks),
                    demons: right.demons - (boat === "right" ? move.demons : -move.demons),
                };
                const newState = {
                    left: newLeft,
                    right: newRight,
                    boat: boat === "left" ? "right" : "left",
                };

                if (isSafe(newState) && backtrack(newState, [...path, newState])) {
                    return true;
                }
            }
        }
        return false;
    }

    backtrack(initialState);
}

solveMonksAndDemons();

3. Farmer, Goat, Cabbage, and Wolf Problem

Initial State: Farmer, goat, cabbage, and wolf on the left shore.
Target State: All on the right shore.
Operators: Farmer can take one item (goat, cabbage, or wolf) in the boat.
Pruning Function: Ensure the goat is not left alone with the cabbage, and the wolf is not left alone with the goat.

Implementation:

function solveFarmerProblem() {
  const initialState = {
    left: ["farmer", "goat", "cabbage", "wolf"],
    right: [],
    boat: "left",
  };
  const visited = new Set();

  function isSafe(state) {
    const unsafe = (side) =>
      (side.includes("goat") &&
        side.includes("cabbage") &&
        !side.includes("farmer")) ||
      (side.includes("wolf") &&
        side.includes("goat") &&
        !side.includes("farmer"));

    return !(unsafe(state.left) || unsafe(state.right));
  }

  function stateKey(state) {
    return JSON.stringify(state);
  }

  function backtrack(state, path = []) {
    if (state.left.length === 0) {
      console.log("Solution found:", path);
      return true;
    }

    const key = stateKey(state);
    if (visited.has(key)) return false;
    visited.add(key);

    const { left, right, boat } = state;
    const fromShore = boat === "left" ? left : right;

    // Possible moves: Farmer alone or Farmer + one item
    for (const item of [...fromShore, null]) {
      if (item === null || item !== "farmer") {
        let newLeft = [...left];
        let newRight = [...right];

        if (boat === "left") {
          newLeft = newLeft.filter((x) => x !== "farmer" && x !== item);
          newRight = [...newRight, "farmer"];
          if (item) newRight.push(item);
        } else {
          newRight = newRight.filter((x) => x !== "farmer" && x !== item);
          newLeft = [...newLeft, "farmer"];
          if (item) newLeft.push(item);
        }

        const newState = {
          left: newLeft,
          right: newRight,
          boat: boat === "left" ? "right" : "left",
        };

        if (isSafe(newState) && backtrack(newState, [...path, newState])) {
          return true;
        }
      }
    }

    return false;
  }

  backtrack(initialState);
}

solveFarmerProblem();

4. Water Jug Problem

Initial State: Both jugs are empty.
Target State: 2 gallons in the 4-gallon jug.
Operators: Fill, empty, or pour water between jugs.
Pruning Function: Avoid revisiting states.

Implementation:

function solveWaterJug() {
    const initialState = { jug4: 0, jug3: 0 };
    const target = 2;
    const visited = new Set();

    function backtrack(state, path = []) {
        const key = `${state.jug4},${state.jug3}`;
        if (visited.has(key)) return false;
        visited.add(key);

        if (state.jug4 === target) {
            console.log("Solution found:", path);
            return true;
        }

        const { jug4, jug3 } = state;
        const moves = [
            { jug4: 4, jug3 }, // Fill jug4
            { jug4, jug3: 3 }, // Fill jug3
            { jug4: 0, jug3 }, // Empty jug4
            { jug4, jug3: 0 }, // Empty jug3
            { jug4: Math.max(0, jug4 - (3 - jug3)), jug3: Math.min(3, jug3 + jug4) }, // Pour jug4 to jug3
            { jug4: Math.min(4, jug4 + jug3), jug3: Math.max(0, jug3 - (4 - jug4)) }, // Pour jug3 to jug4
        ];

        for (const move of moves) {
            if (backtrack(move, [...path, move])) {
                return true;
            }
        }
        return false;
    }

    backtrack(initialState);
}

solveWaterJug();

Key Points:

Backtracking is a systematic way to explore all possible solutions.
It uses depth-first search and pruning functions to eliminate invalid paths.
It is useful for solving NP-hard problems like puzzles, constraint satisfaction problems, and combinatorial optimization.

A* Search Algorithm and Iterative Deepening A* in JavaScript

Piyush Chauhan — Sat, 08 Feb 2025 05:44:55 +0000

1. Introduction

Search algorithms play a crucial role in solving problems across computer science, robotics, game development, and beyond. Among them, heuristic-based search algorithms stand out for their ability to efficiently find solutions by leveraging additional knowledge about the problem domain. This article delves into two such algorithms: the widely used A* search algorithm and its memory-efficient counterpart, Iterative Deepening A* (IDA*).

By the end of this article, you will:

Understand the core principles of A* and IDA*.
Learn how these algorithms work through code implementations in JavaScript.
Explore their mathematical underpinnings and use cases.

**2. Understanding A* Search Algorithm**

What is A*?

A* is a best-first search algorithm that aims to find the shortest path from a start node to a goal node. It uses an evaluation function:

f (n) = g (n) + h (n)

Where:

$g (n)$ : The cost of the path from the start node to the current node $n$ .
$h (n)$ : A heuristic estimate of the cost to reach the goal node from $n$ .

The algorithm prioritizes nodes with the smallest $f (n)$ value, making it both optimal and complete, provided the heuristic $h (n)$ is admissible (never overestimates the true cost).

Properties of A*

Completeness: Guaranteed to find a solution if one exists.
Optimality: Finds the shortest path with an admissible heuristic.
Admissibility and Consistency: Ensures the heuristic is reliable for optimal solutions.

Wikipedia Pseudocode for A*

function reconstruct_path(cameFrom, current)
    total_path := {current}
    while current in cameFrom.Keys:
        current := cameFrom[current]
        total_path.prepend(current)
    return total_path

// A* finds a path from start to goal.
// h is the heuristic function. h(n) estimates the cost to reach goal from node n.
function A_Star(start, goal, h)
    // The set of discovered nodes that may need to be (re-)expanded.
    // Initially, only the start node is known.
    // This is usually implemented as a min-heap or priority queue rather than a hash-set.
    openSet := {start}

    // For node n, cameFrom[n] is the node immediately preceding it on the cheapest path from the start
    // to n currently known.
    cameFrom := an empty map

    // For node n, gScore[n] is the currently known cost of the cheapest path from start to n.
    gScore := map with default value of Infinity
    gScore[start] := 0

    // For node n, fScore[n] := gScore[n] + h(n). fScore[n] represents our current best guess as to
    // how cheap a path could be from start to finish if it goes through n.
    fScore := map with default value of Infinity
    fScore[start] := h(start)

    while openSet is not empty
        // This operation can occur in O(Log(N)) time if openSet is a min-heap or a priority queue
        current := the node in openSet having the lowest fScore[] value
        if current = goal
            return reconstruct_path(cameFrom, current)

        openSet.Remove(current)
        for each neighbor of current
            // d(current,neighbor) is the weight of the edge from current to neighbor
            // tentative_gScore is the distance from start to the neighbor through current
            tentative_gScore := gScore[current] + d(current, neighbor)
            if tentative_gScore < gScore[neighbor]
                // This path to neighbor is better than any previous one. Record it!
                cameFrom[neighbor] := current
                gScore[neighbor] := tentative_gScore
                fScore[neighbor] := tentative_gScore + h(neighbor)
                if neighbor not in openSet
                    openSet.add(neighbor)

    // Open set is empty but goal was never reached
    return failure

**3. Implementing A* in JavaScript**

Below is a JavaScript implementation of A* for a grid-based shortest path problem:

const assert = require("assert");

class PriorityQueue {
  constructor() {
    this.elements = [];
  }

  enqueue(item, priority) {
    this.elements.push({ item, priority });
    this.elements.sort((a, b) => a.priority - b.priority);
  }

  dequeue() {
    return this.elements.shift().item;
  }

  isEmpty() {
    return this.elements.length === 0;
  }
}

function aStar(start, goal, grid, heuristic) {
  const rows = grid.length;
  const cols = grid[0].length;

  const openSet = new PriorityQueue();
  openSet.enqueue(start, 0);

  const cameFrom = {};
  const gScore = Array.from({ length: rows }, () => Array(cols).fill(Infinity));
  gScore[start[0]][start[1]] = 0;

  const fScore = Array.from({ length: rows }, () => Array(cols).fill(Infinity));
  fScore[start[0]][start[1]] = heuristic(start, goal);

  while (!openSet.isEmpty()) {
    const current = openSet.dequeue();
    const [x, y] = current;

    if (current[0] === goal[0] && current[1] === goal[1]) {
      return reconstructPath(cameFrom, current);
    }

    for (const [dx, dy] of [
      [0, 1],
      [1, 0],
      [0, -1],
      [-1, 0],
    ]) {
      const neighbor = [x + dx, y + dy];
      const [nx, ny] = neighbor;

      if (nx >= 0 && nx < rows && ny >= 0 && ny < cols && grid[nx][ny] === 0) {
        const tentative_gScore = gScore[x][y] + 1;

        if (tentative_gScore < gScore[nx][ny]) {
          cameFrom[neighbor] = current;
          gScore[nx][ny] = tentative_gScore;
          fScore[nx][ny] = tentative_gScore + heuristic(neighbor, goal);

          openSet.enqueue(neighbor, fScore[nx][ny]);
        }
      }
    }
  }
  return "No path found";
}

function heuristic([x1, y1], [x2, y2]) {
  return Math.abs(x1 - x2) + Math.abs(y1 - y2);
}

function reconstructPath(cameFrom, current) {
  const path = [current];
  while (cameFrom[current]) {
    current = cameFrom[current];
    path.unshift(current);
  }
  return path;
}

// Test A* Algorithm
const grid = [
  [0, 0, 0, 0],
  [1, 1, 1, 0],
  [0, 0, 0, 0],
  [0, 1, 1, 1],
  [0, 0, 0, 0],
];

const start = [0, 0];
const goal = [4, 3];
const path = aStar(start, goal, grid, heuristic);
console.log("Found Path:", path);
assert.notStrictEqual(path, "No path found");
assert.strictEqual(Array.isArray(path), true);

// Test for no path
const blockedGrid = [
  [0, 1, 0],
  [1, 1, 0],
  [0, 1, 0],
];
const noPathResult = aStar([0, 0], [2, 2], blockedGrid, heuristic);
assert.strictEqual(noPathResult, "No path found");

4. Mathematical Proofs and Analysis

Proof of Optimality

A* guarantees the shortest path if the heuristic $h (n)$ is admissible and consistent.

Admissibility: $h (n)$ never overestimates the true cost to the goal. This ensures that A* will not bypass the optimal path.
Consistency: For every pair of nodes $n$ and $n^{'}$ , the heuristic satisfies: $\leq c(n, n') + h(n')$ where $c (n, n^{'})$ is the cost of transitioning from $n$ to $n^{'}$ . This property ensures that the $f (n)$ values along a path are non-decreasing.

Time and Space Complexity

Time Complexity: In the worst case, A* explores all nodes with $f (n)$ less than the cost of the optimal solution. This can grow exponentially with the branching factor $b$ and the depth $d$ of the solution: $O(b^d)$ .
Space Complexity: A* stores all explored nodes in memory, leading to $O(b^d)$ space usage.

5. Limitations of A*

While A* is highly efficient for many problems, it has significant limitations:

Memory Requirements: Storing all explored nodes can become infeasible for large graphs.
Performance: On graphs with high branching factors or inaccurate heuristics, A* may perform poorly.

**6. Iterative Deepening A* (IDA*)**

Why IDA*?

IDA* addresses A*'s memory limitations by combining the benefits of A*'s heuristic-guided search with the memory efficiency of depth-first search. Instead of maintaining a priority queue, IDA* performs iterative depth-first searches with increasing $f$ -cost thresholds.

How It Works

Initialize the threshold to $h (s t a r t)$ .
Perform a depth-first search, pruning paths with $f (n) >$ threshold.
If no solution is found, increase the threshold to the smallest $f (n)$ value that exceeded the current threshold.
Repeat until the goal is reached.

Wikipedia Pseudocode for IDA*

path              current search path (acts like a stack)
node              current node (last node in current path)
g                 the cost to reach current node
f                 estimated cost of the cheapest path (root..node..goal)
h(node)           estimated cost of the cheapest path (node..goal)
cost(node, succ)  step cost function
is_goal(node)     goal test
successors(node)  node expanding function, expand nodes ordered by g + h(node)
ida_star(root)    return either NOT_FOUND or a pair with the best path and its cost

procedure ida_star(root)
    bound := h(root)
    path := [root]
    loop
        t := search(path, 0, bound)
        if t = FOUND then return (path, bound)
        if t = ∞ then return NOT_FOUND
        bound := t
    end loop
end procedure

function search(path, g, bound)
    node := path.last
    f := g + h(node)
    if f > bound then return f
    if is_goal(node) then return FOUND
    min := ∞
    for succ in successors(node) do
        if succ not in path then
            path.push(succ)
            t := search(path, g + cost(node, succ), bound)
            if t = FOUND then return FOUND
            if t < min then min := t
            path.pop()
        end if
    end for
    return min
end function

**7. Implementing IDA* in JavaScript**

function idaStar(start, goal, grid, heuristic) {
  let threshold = heuristic(start, goal);

  while (true) {
    const cameFrom = {};
    const result = dfs(
      start,
      0,
      threshold,
      goal,
      grid,
      heuristic,
      cameFrom,
      new Set()
    );
    if (result.found) {
      return reconstructPath(cameFrom, goal);
    }
    if (result.threshold === Infinity) {
      return "No path found";
    }
    threshold = result.threshold;
  }
}

function dfs(node, g, threshold, goal, grid, heuristic, cameFrom, visited) {
  const f = g + heuristic(node, goal);
  if (f > threshold) return { threshold: f, found: false };
  if (node[0] === goal[0] && node[1] === goal[1])
    return { found: true, cameFrom };

  visited.add(node.toString());
  let minThreshold = Infinity;
  for (const [dx, dy] of [
    [0, 1],
    [1, 0],
    [0, -1],
    [-1, 0],
  ]) {
    const neighbor = [node[0] + dx, node[1] + dy];
    const [nx, ny] = neighbor;

    if (
      nx >= 0 &&
      nx < grid.length &&
      ny >= 0 &&
      ny < grid[0].length &&
      grid[nx][ny] === 0 &&
      !visited.has(neighbor.toString())
    ) {
      cameFrom[neighbor] = node;
      const result = dfs(
        neighbor,
        g + 1,
        threshold,
        goal,
        grid,
        heuristic,
        cameFrom,
        visited
      );
      if (result.found) return result;
      if (result.threshold < minThreshold) minThreshold = result.threshold;
    }
  }
  visited.delete(node.toString());
  return { threshold: minThreshold, found: false };
}

const grid = [
  [0, 0, 0, 0],
  [1, 1, 1, 0],
  [0, 0, 0, 0],
  [0, 1, 1, 1],
  [0, 0, 0, 0],
];

const start = [0, 0];
const goal = [4, 3];

const pathIdaStar = idaStar(start, goal, grid, heuristic);
console.log("IDA* Found Path:", pathIdaStar);
assert.notStrictEqual(pathIdaStar, "No path found");
assert.strictEqual(Array.isArray(pathIdaStar), true);

const blockedGrid = [
  [0, 1, 0],
  [1, 1, 0],
  [0, 1, 0],
];

const noPathResultIdaStar = idaStar([0, 0], [2, 2], blockedGrid, heuristic);
assert.strictEqual(noPathResultIdaStar, "No path found");

**8. Comparing A* and IDA***

Feature	A*	IDA*
Memory Usage	High (stores all nodes)	Low (depth-first search)
Speed	Faster for smaller graphs	Slower due to iterative nature
Implementation Complexity	Moderate	Higher
Suitability for Large Graphs	Limited	More suitable

9. Use Cases

Game Development: Pathfinding for characters and AI in games (e.g., NPC movement).
Robotics: Navigation for autonomous robots in real-world environments.
Network Routing: Finding the shortest paths in network graphs.
Puzzle Solving: Solving puzzles like the 8-puzzle or 15-puzzle efficiently.

10. Common Pitfalls and Best Practices

When implementing and applying A* or IDA*, it’s essential to avoid common mistakes and adopt best practices to ensure optimal performance.

1. Choosing Heuristics Wisely

Admissibility: Ensure that the heuristic never overestimates the cost to reach the goal. This guarantees that A* will find the optimal solution.
Consistency (Monotonicity): Verify that the heuristic satisfies the triangle inequality: $\leq c(n, n') + h(n')$ . This ensures that the algorithm’s $f (n)$ values are non-decreasing.
Common heuristics include:
- Manhattan Distance: Suitable for grid-based problems where movement is restricted to horizontal or vertical directions.
- Euclidean Distance: Best for problems allowing diagonal or free movement in a continuous space.
- Domain-Specific Heuristics: Tailor heuristics based on specific problem knowledge to improve performance.

2. Balancing $g (n)$ and $h (n)$

Assign appropriate weights to $g (n)$ (path cost so far) and $h (n)$ (estimated cost to goal).
Overemphasizing $h (n)$ might lead to suboptimal solutions or longer paths.
Relying heavily on $g (n)$ might degrade performance, as the algorithm explores more nodes unnecessarily.

3. Debugging and Visualization Techniques

Visualization: Tools like heatmaps or animations of the search process can help debug and optimize the algorithm.
Logging: Track $f (n)$ , $g (n)$ , and $h (n)$ values for each node to identify anomalies.
Unit Testing: Validate heuristic functions and graph structures with simple test cases to ensure correctness.
Benchmarking: Test the implementation on different datasets to measure performance and identify bottlenecks.

11. Advanced Topics

1. Variants of A*

A* has inspired several variants tailored to specific scenarios or performance needs:

Weighted A*:
- Modifies the evaluation function to $\cdot h(n)$ , where $w$ (weight) adjusts the heuristic's influence.
- Used to trade optimality for speed by biasing the search toward the goal.
Memory-Bounded A*:
- Examples include Simplified Memory-Bounded A* (SMA*) and Recursive Best-First Search (RBFS).
- These variants limit memory usage by discarding or revisiting nodes as needed.
Hierarchical A*:
- Splits large graphs into smaller subgraphs, solves each independently, and combines results.
- Ideal for complex environments like city navigation.

2. Integration with Machine Learning

Machine learning can enhance A* by dynamically adjusting heuristics or guiding the search process:

Dynamic Heuristics: Use neural networks or reinforcement learning to predict better heuristic values for each state.
Adaptive Pathfinding: Train models to optimize paths based on historical data or changing environments.
Hybrid Models: Combine A* with ML-driven approaches for problems like real-time strategy games or robotics.

3. Parallelizing A* for Performance Optimization

Parallelization can significantly speed up A* for large graphs:

Parallel Open Set: Divide the open set among multiple threads or processes, each exploring a subset of nodes.
Distributed Search: Use distributed systems to partition the graph and execute search concurrently.
GPU Acceleration: Leverage GPUs for massive parallelism, especially for heuristic computations and large-scale graph traversal.

12. Conclusion

The A* search algorithm and Iterative Deepening A* are powerful tools for solving pathfinding and graph traversal problems. While A* excels in speed and guarantees optimality with sufficient memory, IDA* offers a memory-efficient alternative for large graphs. By understanding their principles, properties, and implementations, you can leverage these algorithms to tackle a wide range of computational problems effectively.

How I Use AI, Sticky Notes, and Pomodoro to Stay Productive as a Software Engineer

Piyush Chauhan — Fri, 24 Jan 2025 15:43:44 +0000

As a software engineer juggling frontend and backend tasks, I’ve found that staying organized and focused is key to delivering quality work without burning out. Over time, I’ve developed a workflow that combines AI assistance, sticky notes, and the Pomodoro Technique to break down tasks, track progress, and maintain my sanity. In this article, I’ll share my process and how you can adapt it to your own workflow.

The Problem: Overwhelming Tasks and Context Switching

When working on a new feature or story, I often start with a vague set of requirements. Breaking these down into actionable steps can be overwhelming, especially when I’m still figuring out the details. Add in the constant context switching between frontend and backend work, and it’s easy to lose track of what’s done and what’s left.

To tackle this, I needed a system that:

Helps me break down tasks into manageable chunks.
Keeps me aware of my progress.
Allows me to adapt as I learn more about the problem.
Ensures I stay focused and hydrated (because, let’s be honest, we all forget to drink water sometimes).

My Workflow: AI, Sticky Notes, and Pomodoro

Here’s how I’ve structured my workflow to address these challenges:

1. Generate an Initial To-Do List with AI

When I start a new subtask, I use AI tools (like Perplexity.ai or Continue.dev with Codellama) to generate an initial to-do list based on the requirements. For example, if I’m working on a user login feature, I might ask:

"Generate a to-do list for implementing a user login feature with email and password authentication. Include frontend and backend tasks."

The AI might suggest:

Set up login API endpoint.
Create frontend login form.
Add input validation for email and password.
Implement error handling for invalid credentials.

This gives me a solid starting point with 2–5 high-level tasks.

2. Create a Feature Branch

Once I have my initial to-do list, I create a feature branch for the subtask. For example:

git checkout -b feature/user-login

This keeps my work isolated and makes it easier to manage changes.

3. Work Incrementally and Extend the To-Do List

I start by tackling the first task on my list. As I work, I often uncover additional subtasks or edge cases. This is where AI comes in again. I’ll share my current progress and ask for suggestions:

"I’m working on implementing the login API. Here’s what I’ve done so far: [details]. What additional tasks should I consider?"

The AI might suggest:

Add rate limiting to prevent brute force attacks.
Log failed login attempts for security monitoring.
Write unit tests for the login functionality.

I add these tasks to my to-do list and continue working incrementally.

4. Track Progress with Sticky Notes

I’m a big fan of sticky notes for tracking progress. Whether physical or digital, they give me a visual representation of what’s done and what’s left.

Physical Sticky Notes: I place them on my desk or monitor, moving completed tasks to a "Done" section.
Digital Tools: If I’m working remotely, I use tools like Trello, Notion, or Todoist to manage my to-do list.

Crossing off tasks gives me a sense of accomplishment and keeps me motivated.

5. Stay Focused with the Pomodoro Technique

To maintain focus, I use the Pomodoro Technique:

Work for 25 minutes, then take a 5-minute break.
After four Pomodoros, take a longer break (15–30 minutes).

I assign specific to-do items to each Pomodoro session. For example:

Pomodoro 1: Set up login API endpoint.
Pomodoro 2: Add input validation for email and password.

During breaks, I make sure to hydrate, stretch, or take a short walk.

6. Create a Pull Request and Request Review

Once all tasks are completed, I create a pull request (PR) for my feature branch. I write a detailed PR description summarizing:

What was implemented.
Any challenges faced.
Testing performed.

I then request a review from my team and iterate based on feedback.

Tools I Use

Here are some tools and methods that have been invaluable in my workflow:

AI Tools

Perplexity.ai: For generating initial to-do lists and brainstorming solutions.
Continue.dev: For seamless integration with my IDE and local development environment.
Local AI Models: I use Qwen2.5-Coder 7B and CodeLlama 7B for code completion, debugging, and extending my to-do lists as I work. Running these models locally ensures privacy and customization.

Task Management

Trello: For visual task tracking with boards, lists, and cards.
Notion: For documenting requirements, progress, and reference materials.
JIRA: For aligning my tasks with team-wide project management and sprint planning.

Pomodoro Timers

Manual iPhone Timer: I use the built-in timer on my iPhone for Pomodoro sessions. It’s simple and effective.
Paper Checklist: I keep a handwritten checklist on paper to track tasks for each Pomodoro session. There’s something satisfying about physically crossing off completed tasks.

Hydration Tracking

Manual iPhone Timer: I set recurring reminders to drink water throughout the day.
Paper Drawing: I draw circles on paper and color them in to track my hydration progress. Each circle represents a glass of water, and filling them in gives me a visual sense of accomplishment.

Why This Works for Me

This workflow works because it:

Breaks down complex tasks into manageable chunks.
Adapts to new information as I learn more about the problem.
Keeps me focused with the Pomodoro Technique.
Provides a visual representation of progress with sticky notes.
Ensures I stay hydrated and energized throughout the day.

Example Workflow in Action

Scenario: Implementing a User Login Feature

Initial To-Do List (AI-Generated):
- Set up login API endpoint.
- Create frontend login form.
- Add input validation for email and password.
- Implement error handling for invalid credentials.
Feature Branch: feature/user-login
Incremental Work:
- Start with "Set up login API endpoint."
- Commit: git commit -m "Add login API endpoint with email/password validation"
- Ask AI: "What else should I consider for the login API?"
- AI suggests: Add rate limiting, log failed attempts, and write unit tests.
- Add these tasks to your to-do list.
Sticky Notes:
- Move "Set up login API endpoint" to "Done."
- Add new tasks: "Add rate limiting," "Log failed attempts," "Write unit tests."
Pomodoro Sessions:
- Session 1: Work on "Add rate limiting."
- Session 2: Work on "Log failed attempts."
PR and Review:
- Create PR with title "feat: implement user login" and description: "Implemented user login feature with email/password authentication. Added rate limiting and logging for security. Unit tests included."
- Request review and iterate based on feedback.

Key Benefits of This Workflow

Clarity: Breaking tasks into smaller chunks makes complex work manageable.
Focus: Pomodoro sessions and sticky notes help maintain focus and track progress.
Adaptability: AI assistance allows you to dynamically adjust your plan as you learn more.
Wellness: Regular breaks and hydration keep you energized and productive.

By formalizing and refining this workflow, you can enhance your productivity, reduce stress, and deliver high-quality work consistently.

Try It Out!

If you’re feeling overwhelmed by your tasks or struggling to stay focused, give this workflow a try. Start small—use AI to generate a to-do list, create a feature branch, and work incrementally. Experiment with sticky notes and the Pomodoro Technique to see what works best for you.

I’d love to hear how you stay productive in your day-to-day work. Share your tips and tools in the comments below!

Happy coding! 🚀

Introduction to WebAssembly (WASM)

Piyush Chauhan — Fri, 10 Jan 2025 16:21:06 +0000

WebAssembly (WASM) is a binary instruction format for a stack-based virtual machine, designed as a portable target for high-performance applications. In this article, we'll explore how to compile a simple C program to WebAssembly, load it into a web browser, and interact with it using JavaScript. We'll also explore some useful tools and commands for working with WASM outside the dev container environment.

Setting Up the Development Environment

Create the necessary folder structure and files for your WebAssembly project.

Create Project Folder:

Begin by creating a new directory for your project. Inside this folder, you'll add the necessary files and configurations.

mkdir wasm-web-example
cd wasm-web-example

Set Up Dev Container:

In the wasm-web-example directory, create the .devcontainer folder to store the dev container configuration files. These files will set up a container with Emscripten installed to compile C code into WebAssembly.

Inside the .devcontainer folder, create the following files:

devcontainer.json: The devcontainer.json file configures VSCode to use the Docker container with the necessary extensions and environment settings.

{
    "name": "Emscripten DevContainer",
    "build": {
        "dockerfile": "Dockerfile"
    },
    "customizations": {
        "vscode": {
            "settings": {
                "terminal.integrated.shell.linux": "/bin/bash",
                "C_Cpp.default.configurationProvider": "ms-vscode.cmake-tools",
                "C_Cpp.default.intelliSenseMode": "gcc-x64"
            },
            "extensions": [
                "ms-vscode.cpptools",
                "ms-vscode.cmake-tools"
            ]
        }
    },
    "postCreateCommand": "emcc --version"
}

Dockerfile: The Dockerfile will set up the Emscripten environment. Here's the content for that file:

# Use the official Emscripten image
FROM emscripten/emsdk:3.1.74

# Set the working directory
WORKDIR /workspace

# Copy the source code into the container
COPY . .

# Install any additional packages if necessary (optional)
# Ensure to clean up cache to minimize image size
RUN apt-get update && \
    apt-get install -y build-essential && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/*

Create VSCode Settings:

In the root of your project, create a .vscode folder with the following files:

c_cpp_properties.json: This file configures the C++ IntelliSense and include paths for your project.

{
    "configurations": [
        {
        "name": "Linux",
        "includePath": [
            "${workspaceFolder}/**",
            "/emsdk/upstream/emscripten/system/include"
        ],
        "defines": [],
        "compilerPath": "/usr/bin/gcc",
        "cStandard": "c17",
        "cppStandard": "gnu++17",
        "configurationProvider": "ms-vscode.cmake-tools"
        }
    ],
    "version": 4
}

settings.json: This file includes specific VSCode settings for language associations.

{
    "files.associations": {
        "emscripten.h": "c"
    },
    "[javascript]": {
        "editor.defaultFormatter": "vscode.typescript-language-features"
    },
    "[typescript]": {
        "editor.defaultFormatter": "vscode.typescript-language-features"
    },
    "[jsonc]": {
        "editor.defaultFormatter": "vscode.json-language-features"
    },
    "[json]": {
        "editor.defaultFormatter": "vscode.json-language-features"
    },
    "[html]": {
        "editor.defaultFormatter": "vscode.html-language-features"
    }
}

Create C, JavaScript, and HTML Files:

Now, create the following files for your project:

test.c: This C file contains the simple function that will be compiled to WebAssembly.

// test.c
int add(int lhs, int rhs) {
    return lhs + rhs;
}

test.html: This HTML file will load the WebAssembly module using JavaScript.

<!DOCTYPE html>
<html lang="en">

<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>WebAssembly Example</title>
</head>

<body>
  <h1>WebAssembly Example</h1>
  <div id="output"></div>

  <script src="test.js"></script>
</body>

</html>

test.js: This JavaScript file will fetch the WebAssembly module and call the exported function.

// test.js
// Path to the .wasm file
const wasmFile = 'test.wasm';

// Load the WebAssembly module
fetch(wasmFile)
  .then(response => {
    if (!response.ok) {
      throw new Error(`Failed to load ${wasmFile}: ${response.statusText}`);
    }
    return response.arrayBuffer();
  })
  .then(bytes => WebAssembly.instantiate(bytes))
  .then(({ instance }) => {
    // Access exported functions
    const wasmExports = instance.exports;
    console.log({ wasmExports })

    // Example: Call a function exported from the WebAssembly module
    if (wasmExports.add) {
      const result = wasmExports.add(5, 3); // Example function call
      document.getElementById('output').textContent = `Result from WebAssembly: ${result}`;
    } else {
      document.getElementById('output').textContent = 'No "add" function found in the WebAssembly module.';
    }
  })
  .catch(error => {
    console.error('Error loading or running the WebAssembly module:', error);
    document.getElementById('output').textContent = 'Error loading WebAssembly module.';
  });

Now that you've set up all the necessary files and configurations, you can move on to compiling and interacting with WebAssembly.

The project structure looks like following now:

➜  wasm-web-example: tree . -a
.
├── .devcontainer
│   ├── Dockerfile
│   └── devcontainer.json
├── .vscode
│   ├── c_cpp_properties.json
│   └── settings.json
├── test.c
├── test.html
├── test.js

Compiling C Code to WebAssembly Using Emscripten

Basic C Program:

The file test.c contains a simple function add that adds two integers. We will compile this C function into WebAssembly using Emscripten.

// test.c
int add(int lhs, int rhs) {
    return lhs + rhs;
}

Emscripten Command:

Inside the dev container, open the terminal (use cmd+j in VSCode) and run the following Emscripten command to compile the C code to WebAssembly:

emcc test.c -O3 -s STANDALONE_WASM -s EXPORTED_FUNCTIONS='["_add"]' --no-entry -o test.wasm

Breakdown of the Command

emcc: This is the Emscripten C/C++ compiler command. It compiles C/C++ source files into WebAssembly or asm.js.
test.c: This specifies the input C source file that you want to compile.
-O3: This flag enables aggressive optimizations during the compilation process. The -O3 optimization level is typically used for performance-critical applications, as it applies various optimization techniques that can significantly improve runtime performance.
-s STANDALONE_WASM: This option instructs Emscripten to generate a standalone WebAssembly module. A standalone WASM module does not depend on any JavaScript glue code and can be executed independently in environments that support WebAssembly.
-s EXPORTED_FUNCTIONS='["_add"]': This flag specifies which functions from the C code should be exported and made available for calling from JavaScript. In this case, the function named _add will be accessible in the resulting WASM module.
--no-entry: This option tells the compiler that there is no entry point (like a main() function) in the program. This is useful for libraries or modules that are intended to be used by other code rather than executed directly.
-o test.wasm: This specifies the output file name for the compiled WebAssembly module. In this case, it will create a file named test.wasm.

This command will generate test.wasm, the WebAssembly binary, and ensure that the add function is exported for use in JavaScript.

Loading and Interacting with WebAssembly in the Browser

HTML Setup:

The file test.html contains a simple HTML page that loads the WebAssembly binary using JavaScript. The JavaScript code in test.js fetches the .wasm file and instantiates it.

<!-- test.html -->
<!DOCTYPE html>
<html lang="en">

<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>WebAssembly Example</title>
</head>

<body>
  <h1>WebAssembly Example</h1>
  <div id="output"></div>

  <script src="test.js"></script>
</body>

</html>

JavaScript Setup:

The JavaScript file test.js loads the test.wasm file and calls the exported add function:

// test.js
// Path to the .wasm file
const wasmFile = 'test.wasm';

// Load the WebAssembly module
fetch(wasmFile)
  .then(response => {
    if (!response.ok) {
      throw new Error(`Failed to load ${wasmFile}: ${response.statusText}`);
    }
    return response.arrayBuffer();
  })
  .then(bytes => WebAssembly.instantiate(bytes))
  .then(({ instance }) => {
    // Access exported functions
    const wasmExports = instance.exports;
    console.log({ wasmExports })

    // Example: Call a function exported from the WebAssembly module
    if (wasmExports.add) {
      const result = wasmExports.add(5, 3); // Example function call
      document.getElementById('output').textContent = `Result from WebAssembly: ${result}`;
    } else {
      document.getElementById('output').textContent = 'No "add" function found in the WebAssembly module.';
    }
  })
  .catch(error => {
    console.error('Error loading or running the WebAssembly module:', error);
    document.getElementById('output').textContent = 'Error loading WebAssembly module.';
  });

This will display the result of the add function in the HTML page when the module is loaded successfully.

Using External Tools on macOS

Outside the dev container, there are several useful commands you can run to work with WebAssembly on your Mac.

Install `wabt`:

wabt (WebAssembly Binary Toolkit) provides utilities for working with WebAssembly, including converting .wasm files to the human-readable WAT (WebAssembly Text) format. Install it via Homebrew:

brew install wabt

Convert WASM to WAT:

Once wabt is installed, you can use the wasm2wat tool to convert your WebAssembly binary (test.wasm) to the WAT format:

wasm2wat test.wasm

This will output a text representation of the WebAssembly module that you can read and inspect.

(module
  (type (;0;) (func))
  (type (;1;) (func (param i32 i32) (result i32)))
  (type (;2;) (func (param i32)))
  (type (;3;) (func (result i32)))
  (func (;0;) (type 0)
    nop)
  (func (;1;) (type 1) (param i32 i32) (result i32)
    local.get 0
    local.get 1
    i32.add)
  (func (;2;) (type 2) (param i32)
    local.get 0
    global.set 0)
  (func (;3;) (type 3) (result i32)
    global.get 0)
  (table (;0;) 2 2 funcref)
  (memory (;0;) 258 258)
  (global (;0;) (mut i32) (i32.const 66560))
  (export "memory" (memory 0))
  (export "add" (func 1))
  (export "_initialize" (func 0))
  (export "__indirect_function_table" (table 0))
  (export "_emscripten_stack_restore" (func 2))
  (export "emscripten_stack_get_current" (func 3))
  (elem (;0;) (i32.const 1) func 0))

Serve the HTML Page:

To view the HTML page that interacts with the WebAssembly module, you can use Python’s simple HTTP server:

python -m http.server

This command will start a local web server on http://localhost:8000, where you can open index.html in your browser to see the WebAssembly module in action.

Conclusion

By following the steps outlined in this article, you can set up a development environment to compile C code to WebAssembly, interact with it using JavaScript, and convert the resulting WebAssembly binary to the WAT format for inspection. The use of external tools like wabt and Python’s HTTP server makes it easier to manage and explore WebAssembly modules on your macOS system.

Functional Programming in Go with IBM fp-go: Error Handling Made Explicit

Piyush Chauhan — Fri, 27 Dec 2024 14:43:19 +0000

Functional programming (FP) principles are gaining popularity in modern software development due to their emphasis on immutability, composability, and explicitness. While Go is traditionally an imperative language, the fp-go library, developed by IBM, introduces FP abstractions such as Option, Either, Fold, and utilities for functional composition. In this article, we will explore how to use fp-go to handle errors explicitly, define function signatures with multiple error types, and build a real-world CRUD API example demonstrating these concepts.

Why Functional Error Handling?

Error handling is crucial for building reliable software. Traditional Go error handling relies on returning error values, which can be unintentionally ignored or mishandled. Functional error handling introduces abstractions like:

Option: Represents optional values, akin to Some and None in other FP languages.
Either: Encapsulates a value that can either be a Right (success) or Left (failure), making error propagation explicit.
Tagged Unions: Allow function signatures to clearly define possible error types.
Composition: Enables chaining operations while handling errors naturally.

Let’s dive into these concepts and see how fp-go facilitates them in Go.

Getting Started with fp-go

First, add fp-go to your Go project:

go get github.com/IBM/fp-go

Import the necessary modules:

import (
    either "github.com/IBM/fp-go/either"
    option "github.com/IBM/fp-go/option"
)

`Option`: Handling Optional Values

Option represents a value that may or may not exist. It is either Some(value) or None.

Example: Parsing an Integer

func parseInt(input string) option.Option[int] {
    value, err := strconv.Atoi(input)
    if err != nil {
        return option.None[int]()
    }
    return option.Some(value)
}

func main() {
    opt := parseInt("42")

    option.Fold(
        func() { fmt.Println("No value") },
        func(value int) { fmt.Printf("Parsed value: %d\n", value) },
    )(opt)
}

Key Takeaways:

Option eliminates nil values.
Fold is used to handle both cases (Some or None).

`Either`: Handling Errors Explicitly

Either represents a computation that can result in two possibilities:

Left: Represents an error.
Right: Represents a successful result.

Example: Safe Division

type MathError struct {
    Code    string
    Message string
}

func safeDivide(a, b int) either.Either[MathError, int] {
    if b == 0 {
        return either.Left(MathError{Code: "DIV_BY_ZERO", Message: "Cannot divide by zero"})
    }
    return either.Right(a / b)
}

func main() {
    result := safeDivide(10, 0)

    either.Fold(
        func(err MathError) { fmt.Printf("Error [%s]: %s\n", err.Code, err.Message) },
        func(value int) { fmt.Printf("Result: %d\n", value) },
    )(result)
}

Key Takeaways:

Either separates success and failure paths.
Fold simplifies handling both cases in one place.

Function Signatures with Multiple Error Types

Real-world applications often need to handle multiple types of errors. By using tagged unions, we can define explicit error types.

Example: Tagged Union for Errors

type AppError struct {
    Tag     string
    Message string
}

const (
    MathErrorTag    = "MathError"
    DatabaseErrorTag = "DatabaseError"
)

func NewMathError(msg string) AppError {
    return AppError{Tag: MathErrorTag, Message: msg}
}

func NewDatabaseError(msg string) AppError {
    return AppError{Tag: DatabaseErrorTag, Message: msg}
}

func process(a, b int) either.Either[AppError, int] {
    if b == 0 {
        return either.Left(NewMathError("Division by zero"))
    }
    return either.Right(a / b)
}

func main() {
    result := process(10, 0)

    either.Fold(
        func(err AppError) { fmt.Printf("Error [%s]: %s\n", err.Tag, err.Message) },
        func(value int) { fmt.Printf("Processed result: %d\n", value) },
    )(result)
}

Benefits:

Tagged unions make errors self-documenting.
Explicit types reduce ambiguity in error handling.

Real-World Example: CRUD API

Let’s implement a simple CRUD API with explicit error handling using Either.

Model and Error Definitions

type User struct {
    ID    int
    Name  string
    Email string
}

type AppError struct {
    Code    string
    Message string
}

const (
    NotFoundError    = "NOT_FOUND"
    ValidationError  = "VALIDATION_ERROR"
    DatabaseError    = "DATABASE_ERROR"
)

func NewAppError(code, message string) AppError {
    return AppError{Code: code, Message: message}
}

Repository Layer

var users = map[int]User{
    1: {ID: 1, Name: "Alice", Email: "alice@example.com"},
}

func getUserByID(id int) either.Either[AppError, User] {
    user, exists := users[id]
    if !exists {
        return either.Left(NewAppError(NotFoundError, "User not found"))
    }
    return either.Right(user)
}

Service Layer

func validateUser(user User) either.Either[AppError, User] {
    if user.Name == "" || user.Email == "" {
        return either.Left(NewAppError(ValidationError, "Name and email are required"))
    }
    return either.Right(user)
}

func createUser(user User) either.Either[AppError, User] {
    validation := validateUser(user)
    return either.Chain(
        func(validUser User) either.Either[AppError, User] {
            user.ID = len(users) + 1
            users[user.ID] = user
            return either.Right(user)
        },
    )(validation)
}

Controller

func handleGetUser(id int) {
    result := getUserByID(id)

    either.Fold(
        func(err AppError) { fmt.Printf("Error [%s]: %s\n", err.Code, err.Message) },
        func(user User) { fmt.Printf("User: %+v\n", user) },
    )(result)
}

func handleCreateUser(user User) {
    result := createUser(user)

    either.Fold(
        func(err AppError) { fmt.Printf("Error [%s]: %s\n", err.Code, err.Message) },
        func(newUser User) { fmt.Printf("Created user: %+v\n", newUser) },
    )(result)
}

func main() {
    handleGetUser(1)
    handleCreateUser(User{Name: "Bob", Email: "bob@example.com"})
    handleGetUser(2)
}

Conclusion

Using fp-go in Go, we can:

Model errors explicitly using Either.
Represent optional values with Option.
Handle multiple error types via tagged unions.
Build maintainable and composable APIs.

These patterns make your Go code more robust, readable, and functional. Whether you’re building a CRUD API or complex business logic, fp-go empowers you to handle errors cleanly and consistently.

Mastering Trampolining: A Deep Dive into Recursive Optimization

Piyush Chauhan — Wed, 25 Dec 2024 17:02:44 +0000

Mastering Trampolining: A Deep Dive into Recursive Optimization

In the world of programming, recursion is a powerful tool that allows functions to call themselves to solve complex problems. However, deep recursion can lead to stack overflow errors, especially in languages that do not optimize recursive calls. Enter trampolining, a technique that transforms recursive calls into an iterative process, allowing for infinite recursion without the risk of exhausting the call stack. In this article, we will explore trampolining in detail, providing implementations in multiple programming languages, including Java, C++, JavaScript, and Go.

Understanding Trampolining

What is Trampolining?

Trampolining is a method used to optimize recursive functions by converting them into iterations. Instead of a function calling itself directly, it returns another function (or "thunk") to be executed later. This allows the program to manage function calls without piling them up on the call stack.

Why Use Trampolining?

Using trampolining has several benefits:

Improved Performance: It enhances the execution speed of your code by converting recursive calls into iterations.
Preventing Stack Overflow: By avoiding deep recursion, it prevents stack overflow errors, especially in functions that call themselves repeatedly.

How Trampolining Works

The basic principle of trampolining involves converting recursive calls into iterations. Instead of a function calling itself directly, it returns another function to be executed. This process continues until a final value is produced.

Example Code

To illustrate how trampolining works, let's look at an example in JavaScript.

Before Trampolining:

function factorial(n) {
    if (n === 0) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}

After Trampolining:

function trampoline(fn) {
    return function(...args) {
        let result = fn(...args);
        while (typeof result === 'function') {
            result = result();
        }
        return result;
    };
}

function factorial(n, acc = 1) {
    if (n === 0) {
        return acc;
    } else {
        return () => factorial(n - 1, n * acc);
    }
}

const trampolinedFactorial = trampoline(factorial);
console.log(trampolinedFactorial(5)); // Output: 120

Technical Explanation

Trampolining leverages continuations and tail-call optimization. Continuations allow the function to pause and resume, while tail-call optimization ensures that the function doesn’t add new frames to the call stack.

Preparing Your Functions

Not all functions need trampolining. Identify functions that involve deep recursion or are likely to cause stack overflow.

Refactoring for Trampolining

Identify the Recursive Function: Find the function that repeatedly calls itself.
Modify the Function: Change it to return another function instead of making a direct recursive call.
Wrap with a Trampoline: Use a trampoline function to execute the modified function iteratively.

Common Pitfalls and How to Avoid Them

Common pitfalls include infinite loops and performance overhead. Ensure your base case is correct to avoid infinite loops, and test and optimize performance as needed.

Advanced Trampolining Techniques

Trampolining can be further enhanced with techniques like memoization and lazy evaluation. These techniques can help improve performance further by caching results or delaying computations until necessary.

Real-World Applications

Many large-scale applications use trampolining to handle recursive tasks efficiently. Examples include:

Parsing Complex Data Structures: For instance, when dealing with nested JSON objects or XML.
Functional Programming Paradigms: Languages like Scala and Haskell often utilize trampolining for efficient recursion.

Implementing Trampolining in Other Languages

Java Implementation

In Java, trampolining can be implemented using interfaces or functional programming constructs available in Java 8 and later.

import java.util.function.Supplier;

public class TrampolineExample {

    public static <T> T trampoline(Supplier<T> supplier) {
        Supplier<T> current = supplier;
        while (current != null) {
            T result = current.get();
            if (result instanceof Supplier) {
                current = (Supplier<T>) result;
            } else {
                return result;
            }
        }
        return null;
    }

    public static Supplier<Integer> factorial(int n, int acc) {
        if (n == 0) {
            return () -> acc;
        } else {
            return () -> factorial(n - 1, n * acc);
        }
    }

    public static void main(String[] args) {
        int number = 5;
        int result = trampoline(() -> factorial(number, 1));
        System.out.println("Factorial of " + number + " is: " + result); // Output: 120
    }
}

C++ Implementation

In C++, trampolining can be achieved using std::function and lambda expressions.

#include <iostream>
#include <functional>

std::function<int()> trampoline(std::function<int()> func) {
    while (func) {
        func = func();
    }
    return nullptr;
}

std::function<int()> factorial(int n, int acc) {
    if (n == 0) {
        return [acc]() { return acc; };
    } else {
        return [n, acc]() { return factorial(n - 1, n * acc); };
    }
}

int main() {
    int number = 5;
    auto result = trampoline(factorial(number, 1));
    std::cout << "Factorial of " << number << " is: " << result() << std::endl; // Output: 120
}

Go Implementation with Generics

Go provides an elegant way to implement trampolining using generics introduced in Go 1.18.

package main

import (
    "fmt"
)

// Define the thunk type for generic functions
type thunk[T any] func() (T, thunk[T])

// Trampoline function that executes the supplied thunk
func trampoline[T any](fn thunk[T]) T {
    for {
        result, next := fn()
        if next == nil {
            return result // Final result
        }
        fn = next // Continue with the next thunk
    }
}

// Fibonacci function using trampolining with generics
func fib(n int, prev int, curr int) thunk[int] {
    if n == 0 {
        return func() (int, thunk[int]) {
            return prev, nil // Return final accumulated value
        }
    }
    if n == 1 {
        return func() (int, thunk[int]) {
            return curr, nil // Return final accumulated value
        }
    }
    return func() (int, thunk[int]) {
        return 0, fib(n-1, curr, curr+prev) // Return next step as a thunk
    }
}

func main() {
    n := 10 // fib(10) == 55
    fibThunk := fib(n, 0, 1) // Initialize with starting values
    result := trampoline(fibThunk)
    fmt.Printf("Fibonacci(%d) = %d\n", n, result) // Output: 55
}

Conclusion

Trampolining is a powerful technique for optimizing recursive functions across various programming languages. It improves performance and prevents stack overflow errors by transforming recursive calls into an iterative process. By mastering this technique and implementing it in your codebase—whether in JavaScript, Java, C++, or Go—you can enhance the robustness and efficiency of your applications.

As you explore more complex algorithms and data structures in your programming journey, consider incorporating trampolining where appropriate. This approach not only helps manage recursion effectively but also encourages cleaner and more maintainable code.

Happy coding!

Citations:
[1] https://rdinnager.github.io/trampoline/
[2] https://www.geeksforgeeks.org/es6-trampoline-function/
[3] https://gcc.gnu.org/onlinedocs/gccint/Trampolines.html

Mastering Quick Sort: A Fundamental Algorithm in Computer Science

Piyush Chauhan — Wed, 25 Dec 2024 13:46:12 +0000

Introduction to Quick Sort

In the vast world of algorithms and data structures, Quick Sort stands as one of the most elegant and efficient sorting methods. Its simplicity and effectiveness make it a favorite among developers and researchers alike. Whether you're working on optimizing code or just curious about how modern computing systems handle large datasets, understanding Quick Sort is invaluable.

The Essence of Quick Sort

Quick Sort is based on the divide-and-conquer strategy, which involves breaking down a complex problem into smaller sub-problems that are easier to solve.
In the context of sorting algorithms, this means dividing an array or list of elements into two parts, such that the left part contains elements less than a chosen pivot and the right part contains elements greater than the pivot.

How It Works

Choose a Pivot: Select an element from the array as the pivot.
Partitioning: Rearrange the array so that all elements with values less than the pivot come before it, while all elements with values greater than the pivot come after it. The pivot is now in its final position.
Recursively Apply to Sub-arrays: Repeat the process for both sub-arrays formed by partitioning.

Implementing Quick Sort

Here’s a basic Python implementation of Quick Sort:

def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    else:
        pivot = arr[len(arr) // 2]
        left = [x for x in arr if x < pivot]
        middle = [x for x in arr if x == pivot]
        right = [x for x in arr if x > pivot]
        return quick_sort(left) + middle + quick_sort(right)

# Example usage
arr = [3, 6, 8, 10, 1, 2, 1]
print(quick_sort(arr))

This implementation is straightforward and leverages list comprehensions for simplicity. However, it's important to note that in practice, the choice of pivot can significantly impact performance.

Performance Analysis

The efficiency of Quick Sort varies based on the chosen pivot:

Average Case: $O (n l o g n)$ , where n is the number of elements.
Best Case: $O (n l o g n)$ .
Worst Case: $O(n^2)$ , which occurs when the smallest or largest element is always chosen as the pivot.

The worst-case scenario can be mitigated by choosing a good pivot, such as the median-of-three method (choosing the median of the first, middle, and last elements).

Applications

Quick Sort is widely used in real-world applications due to its efficiency. It's particularly useful for:

Sorting Large Datasets: Quick Sort handles large datasets well, making it suitable for big data processing.
Memory Usage: It uses $O (l o g n)$ extra space if implemented with recursion.

Practical Examples

Imagine you have a dataset of millions of records that need to be sorted. By leveraging the quick sort algorithm, you can efficiently manage and sort this data in a way that minimizes memory usage and processing time.

Example: Sorting Financial Data

In a financial application, where transactions are processed in real-time, Quick Sort can help quickly process and analyze large volumes of transaction data to identify trends or anomalies.

Conclusion

Quick Sort is an essential algorithm for any programmer or computer scientist. Its elegance lies not only in its simplicity but also in its ability to handle complex datasets efficiently. Whether you're optimizing code, analyzing algorithms, or just curious about the underlying principles, mastering Quick Sort provides a solid foundation in computational thinking and problem-solving.

Functional Programming with fp-ts in Node.js

Piyush Chauhan — Sun, 22 Dec 2024 10:26:06 +0000

Introduction

Functional programming (FP) has gained popularity for its composability, testability, and robustness. In the JavaScript ecosystem, libraries like fp-ts bring powerful FP concepts to TypeScript, allowing you to write cleaner and more reliable code.

This article explores fp-ts concepts like Option, Either, Task, Reader, and ReaderTaskEither. We’ll build a basic CRUD app using fp-ts, pg (PostgreSQL client), and Express.js to see how these abstractions shine in real-world applications.

Key Concepts

Before diving into the app, let’s briefly discuss the main concepts:

Option: Models the presence or absence of a value (Some or None).
Either: Represents computations that can succeed (Right) or fail (Left).
Task: Represents lazy asynchronous computations.
Reader: Injects dependencies into computations.
ReaderTaskEither: Combines Reader, Task, and Either for async operations with dependencies and error handling.

Setting Up the Project

Initialize the Project

mkdir fp-ts-crud && cd fp-ts-crud
npm init -y
npm install express pg fp-ts io-ts
npm install --save-dev typescript @types/express ts-node-dev jest @types/jest ts-jest

Setup TypeScript

Create a tsconfig.json:

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "CommonJS",
    "outDir": "dist",
    "strict": true,
    "esModuleInterop": true
  },
  "include": ["src/**/*"]
}

Project Structure

src/
  index.ts        # Entry point
  db.ts           # Database setup
  models/         # Data models and validation
  services/       # Business logic
  controllers/    # CRUD operations
  utils/          # fp-ts utilities
  errors/         # Custom error classes

Implementing the CRUD App

Database Setup (`db.ts`)

import { Pool } from 'pg';

export const pool = new Pool({
  user: 'postgres',
  host: 'localhost',
  database: 'fp_ts_crud',
  password: 'password',
  port: 5432,
});

Define Models and Validation (`models/User.ts`)

import * as t from 'io-ts';
import { isRight } from 'fp-ts/Either';

export const User = t.type({
  id: t.number,
  name: t.string,
  email: t.string,
});

export const validateUser = (data: unknown): t.TypeOf<typeof User> | null => {
  const result = User.decode(data);
  return isRight(result) ? result.right : null;
};

Custom Error Handling (`errors/AppError.ts`)

export class AppError extends Error {
  constructor(public statusCode: number, public code: string, public message: string) {
    super(message);
    this.name = 'AppError';
  }
}

export const createAppError = (statusCode: number, code: string, message: string): AppError => {
  return new AppError(statusCode, code, message);
};

Service Layer (`services/UserService.ts`)

import { pool } from '../db';
import { ReaderTaskEither, right, left } from 'fp-ts/ReaderTaskEither';
import { pipe } from 'fp-ts/function';
import { createAppError, AppError } from '../errors/AppError';
import { validateUser } from '../models/User';

type Dependencies = { db: typeof pool };
type User = { name: string; email: string };

export const createUser = (
  user: User
): ReaderTaskEither<Dependencies, AppError, string> => (deps) => async () => {
  // Validate the incoming user data
  const validatedUser = validateUser(user);

  if (!validatedUser) {
    return left(createAppError(400, 'INVALID_USER_DATA', 'Invalid user data provided'));
  }

  try {
    const result = await deps.db.query(
      'INSERT INTO users (name, email) VALUES ($1, $2) RETURNING id',
      [validatedUser.name, validatedUser.email]
    );
    return right(`User created with ID: ${result.rows[0].id}`);
  } catch (error) {
    return left(createAppError(500, 'USER_CREATION_FAILED', 'Failed to create user'));
  }
};

export const getUser = (
  id: number
): ReaderTaskEither<Dependencies, AppError, { id: number; name: string; email: string }> => (deps) => async () => {
  try {
    const result = await deps.db.query('SELECT * FROM users WHERE id = $1', [id]);
    return result.rows[0]
      ? right(result.rows[0])
      : left(createAppError(404, 'USER_NOT_FOUND', 'User not found'));
  } catch {
    return left(createAppError(500, 'USER_FETCH_FAILED', 'Failed to fetch user'));
  }
};

CRUD Operations (`controllers/UserController.ts`)

import { pipe } from 'fp-ts/function';
import { createUser, getUser } from '../services/UserService';
import { pool } from '../db';
import { AppError } from '../errors/AppError';

const errorHandler = (err: unknown, res: express.Response): void => {
  if (err instanceof AppError) {
    res.status(err.statusCode).json({ error: { code: err.code, message: err.message } });
  } else {
    res.status(500).json({ error: { code: 'UNKNOWN_ERROR', message: 'An unexpected error occurred' } });
  }
};

export const createUserHandler = (req: express.Request, res: express.Response): void => {
  pipe(
    createUser(req.body),
    (task) => task({ db: pool }),
    (promise) =>
      promise.then((result) =>
        result._tag === 'Left'
          ? errorHandler(result.left, res)
          : res.json({ message: result.right })
      )
  );
};

export const getUserHandler = (req: express.Request, res: express.Response): void => {
  pipe(
    getUser(parseInt(req.params.id, 10)),
    (task) => task({ db: pool }),
    (promise) =>
      promise.then((result) =>
        result._tag === 'Left'
          ? errorHandler(result.left, res)
          : res.json(result.right)
      )
  );
};

Express API (`index.ts`)

import express from 'express';
import { createUserHandler, getUserHandler } from './controllers/UserController';

const app = express();
app.use(express.json());

// Routes
app.post('/users', createUserHandler);
app.get('/users/:id', getUserHandler);

// Start Server
app.listen(3000, () => {
  console.log('Server running on http://localhost:3000');
});

Running the App with Docker and Docker Compose

Dockerfile

# Stage 1: Build
FROM node:22 AS builder
WORKDIR /app
COPY package*.json .
RUN npm install
COPY . .
RUN npm run build

# Stage 2: Run
FROM node:22
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY package*.json ./
RUN npm install --production
CMD ["node", "dist/index.js"]

docker-compose.yml

version: '3.8'
services:
  db:
    image: postgres:15
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: password
      POSTGRES_DB: fp_ts_crud
    ports:
      - "5432:5432"
    volumes:
      - db_data:/var/lib/postgresql/data
volumes:
  db_data:

Run the App - Development Mode

# Start the database
docker-compose up -d

# Run the app
npx ts-node-dev src/index.ts

Run the App - Production Mode

# Build the docker image
docker build -t fp-ts-crud-app .

# Start the database
docker-compose up -d

# Run the container
docker run -p 3000:3000 fp-ts-crud-app

Writing Tests

Setup Jest

Update package.json scripts:

"scripts": {
  "test": "jest",
  "test:watch": "jest --watch"
}

Example Test (`tests/UserService.test.ts`)

import { createUser, getUser } from '../services/UserService';
import { pool } from '../db';

jest.mock('../db', () => ({
  pool: {
    query: jest.fn(),
  },
}));

describe('UserService', () => {
  afterEach(() => {
    jest.clearAllMocks();
  });

  it('should create a user', async () => {
    (pool.query as jest.Mock).mockResolvedValueOnce({ rows: [{ id: 1 }] });

    const result = await createUser({ name: 'Alice', email: 'alice@example.com' })({ db: pool })();

    expect(result._tag).toBe('Right');
    if (result._tag === 'Right') {
      expect(result.right).toBe('User created with ID: 1');
    }
  });

  it('should return error if user not found', async () => {
    (pool.query as jest.Mock).mockResolvedValueOnce({ rows: [] });

    const result = await getUser(1)({ db: pool })();

    expect(result._tag).toBe('Left');
    if (result._tag === 'Left') {
      expect(result.left.message).toBe('User not found');
    }
  });

  it('should return error for invalid user data during creation', async () => {
    const invalidData = { name: 123, email: 'invalid-email' };
    const result = await createUser(invalidData)({ db: pool })();
    expect(result._tag).toBe('Left');

    if (result._tag === 'Left') {
      expect(result.left.message).toBe('Invalid user data provided');
    }
  });
});

Conclusion

By leveraging fp-ts, Docker, and robust error handling, we built a functional, scalable, and maintainable Node.js CRUD application. Using functional programming patterns makes your code more predictable and reliable, especially when handling asynchronous workflows.

Building a Basic Testing Framework in Bash 🐚

Piyush Chauhan — Sat, 21 Dec 2024 17:21:40 +0000

In the world of software development, testing is crucial for ensuring that your code behaves as expected. In this article, we'll explore a simple yet effective Bash script that serves as a basic testing framework. This framework will help you track test results, log outcomes, and summarize the results of your tests. Let's dive in! 🚀

Overview of the Script

The script consists of several components that work together to facilitate testing:

Variables for Tracking Test Results: These variables keep count of the total tests, passed tests, and failed tests.
Logging Function: A function to log the results of each test.
Assertion Functions: Functions to check for equality and command success.
Summary Function: A function to display the overall results after running the tests.

Breakdown of the Script

1. Variables for Tracking Test Results

total_tests=0
passed_tests=0
failed_tests=0

These variables initialize counters for tracking how many tests have been run, how many have passed, and how many have failed.

2. Logging Function

log_result() {
    local status=$1
    local message=$2

    if [ "$status" -eq 0 ]; then
        echo "✅ PASS: $message"
        ((passed_tests++))
    else
        echo "❌ FAIL: $message"
        ((failed_tests++))
    fi
}

The log_result function takes a status code and a message. If the status is 0, it logs a pass; otherwise, it logs a failure and increments the respective counters.

3. Assertion Functions

Assert Equality

assert_equal() {
    local expected=$1
    local actual=$2
    local test_name=$3

    ((total_tests++))
    if [ "$expected" == "$actual" ]; then
        log_result 0 "$test_name"
    else
        log_result 1 "$test_name (Expected: '$expected', Got: '$actual')"
    fi
}

This function checks if two values are equal. It logs the result and updates the total test count.

Assert Command Success

assert_command_success() {
    local command="$1"
    local test_name=$2

    ((total_tests++))
    eval "$command" &> /dev/null
    if [ $? -eq 0 ]; then
        log_result 0 "$test_name"
    else
        log_result 1 "$test_name (Command failed)"
    fi
}

This function runs a command and checks its exit status. If the command succeeds, it logs a pass; otherwise, it logs a failure.

4. Summary Function

summary() {
    echo
    echo "Total Tests: $total_tests"
    echo "Passed: $passed_tests"
    echo "Failed: $failed_tests"

    if [ "$failed_tests" -eq 0 ]; then
        echo "🎉 All tests passed!"
    else
        echo "⚠️ Some tests failed."
    fi
}

After all tests are executed, this function summarizes the results, indicating how many tests passed or failed.

Example Usage

Below is an example of how to use this testing framework:

echo "Running Tests..."
assert_equal "hello" "hello" "Check if strings are equal"
assert_equal "1" "2" "Check if integers are equal"
assert_command_success "ls /" "Check if 'ls /' command succeeds"
assert_command_success "invalid_command" "Check if invalid command fails"

# Display the summary
summary

In this example:

We check string equality.
We validate integer equality (which will fail).
We run a valid command (ls /) and an invalid command (invalid_command).

Conclusion 🎊

This basic testing framework in Bash provides a simple way to automate your testing process. By using functions to assert conditions and log results, you can easily track the health of your scripts. Feel free to expand upon this framework by adding more complex assertions or incorporating additional features as needed!

Happy scripting! 🖥️✨

🚀 Unlocking Sprint Success with Jira Versions: A Strategic Guide

Piyush Chauhan — Sat, 21 Dec 2024 16:41:21 +0000

Jira versions are powerful tools that help teams organize and track project milestones more effectively. Here's a comprehensive breakdown of leveraging versions for sprint success:

🎯 What Are Versions?
Versions represent specific points-in-time for a project, serving as external milestones that focus on customer-facing outputs. Unlike sprints, which are internal time-boxes, versions help teams prioritize and organize work with a clear end goal.

🌟 Key Benefits of Using Versions

📍 Milestone Tracking: Create clear project checkpoints
🏷️ Issue Organization: Assign and prioritize tasks within specific releases
📊 Progress Monitoring: Visualize project advancement through version timelines

🛠️ Overcoming Common Challenges

🧩 Complexity: Start simple and gradually customize your version workflow
📚 Training: Invest time in understanding Jira's version management features
🧹 Maintenance: Regularly review and clean up outdated versions

💡 Pro Tips for Effective Version Management

Use versions to align team efforts towards specific project goals
Integrate versions with sprint planning for seamless workflow
Leverage Jira's reporting tools to track version progress

By embracing Jira versions, teams can transform their project management approach, delivering more structured and focused increments with greater efficiency. 💪✨

Precise Allocations with Big.js: Handling Rounding and Leftover Redistribution

Piyush Chauhan — Sat, 21 Dec 2024 16:34:29 +0000

When dealing with fractional allocations of large amounts, rounding errors and leftover redistributions become significant challenges. These problems are not confined to financial calculations; they can occur in other domains like resource distribution, task scheduling, or budget allocation. In this article, we demonstrate a verified and tested method using the big.js library in JavaScript to achieve precise allocations while handling rounding and leftover redistribution effectively.

Problem: Allocating Funds Among Stocks

Imagine a scenario where you need to allocate a very large amount of money among multiple stocks based on their respective percentages. For example:

Stock A: 50.5%
Stock B: 30.3%
Stock C: 19.2%

The requirements are:

Perform calculations in cents to avoid floating-point errors.
Distribute leftover cents fairly after initial rounding.
Convert the final allocations back to dollars with two decimal places.

The Solution

Using the big.js library, we can handle these challenges with arbitrary-precision arithmetic. Here is the complete solution:

1. Initialize Inputs and Convert Percentages to Ratios

const Big = require("big.js");

function allocateMoney(amount, allocations) {
  // Step 1: Convert percentages to rational numbers
  let totalPercent = new Big(0);
  for (let key in allocations) {
    totalPercent = totalPercent.plus(new Big(allocations[key]));
  }

  const allocationRatios = {};
  for (let key in allocations) {
    allocationRatios[key] = new Big(allocations[key]).div(totalPercent);
  }

2. Calculate Initial Allocation in Cents

Convert the total amount to cents and perform initial rounding:

  const totalCents = new Big(amount).times(100).toFixed(0); // Convert amount to cents
  const allocatedCents = {};
  for (let key in allocationRatios) {
    allocatedCents[key] = allocationRatios[key].times(totalCents).toFixed(0, 0); // Convert to int (round down)
  }

3. Redistribute Remaining Cents

Calculate the leftover cents and distribute them fairly based on fractional remainders:

  let distributedTotal = new Big(0);
  for (let key in allocatedCents) {
    distributedTotal = distributedTotal.plus(new Big(allocatedCents[key]));
  }

  const remainingCents = new Big(totalCents).minus(distributedTotal).toFixed(0);

  // Sort allocations by fractional remainder descending for redistribution
  const fractionalRemainders = {};
  for (let key in allocationRatios) {
    const allocated = allocationRatios[key].times(totalCents);
    const fractionalPart = allocated.minus(allocated.toFixed(0));
    fractionalRemainders[key] = fractionalPart;
  }

  const sortedKeys = Object.keys(fractionalRemainders).sort((a, b) => {
    if (fractionalRemainders[b].gt(fractionalRemainders[a])) {
      return 1;
    }
    if (fractionalRemainders[b].lt(fractionalRemainders[a])) {
      return -1;
    }
    return 0;
  });

  for (let i = 0; i < remainingCents; i++) {
    const key = sortedKeys[i % sortedKeys.length];
    allocatedCents[key] = new Big(allocatedCents[key]).plus(1).toFixed(0);
  }

4. Convert Back to Dollars

Finally, convert the allocations back to dollars:

  const allocatedDollars = {};
  for (let key in allocatedCents) {
    allocatedDollars[key] = new Big(allocatedCents[key]).div(100).toFixed(2); // Convert cents to dollars with 2 decimals
  }

  return allocatedDollars;
}

Example Usage

Here’s how you can use the allocateMoney function to allocate funds among stocks:

const totalAmount = "1234567890123456.78"; // A very large total amount
const stockAllocations = {
  "Stock A": "50.5", // 50.5%
  "Stock B": "30.3", // 30.3%
  "Stock C": "19.2", // 19.2%
};

const result = allocateMoney(totalAmount, stockAllocations);
console.log("Allocation:");
console.log(result);

// Calculate total allocated
let totalAllocated = new Big(0);
for (let key in result) {
  totalAllocated = totalAllocated.plus(new Big(result[key]));
}

console.log(`Total Allocated: $${totalAllocated.toFixed(2)}`);

Output for the Example

For the given inputs, the output is:

Allocation:
{
  'Stock A': '623456784512345.67',
  'Stock B': '374074070707407.41',
  'Stock C': '237037034903703.70'
}
Total Allocated: $1234567890123456.78

Key Takeaways

Precise Arithmetic with big.js:
The big.js library ensures accuracy by avoiding floating-point errors.
Handle Leftovers Fairly:
Use fractional remainders to distribute leftover units deterministically and fairly.
Reconcile Totals:
After all adjustments, ensure that the total allocation matches the original amount.
Scalable for Large Values:
This approach works seamlessly for very large amounts, making it suitable for financial and resource allocation problems.

By following this method, you can achieve precise and fair allocations in any scenario requiring high numerical accuracy.

DEV Community: Piyush Chauhan

Backtracking Unveiled: Mastering Depth-First Search and Pruning Techniques

Components of Backtracking Problems

Backtracking Algorithm

Example Problems Solved Using Backtracking

1. 3-Digit Lock Problem

Implementation:

2. Monks and Demons Problem

Implementation:

3. Farmer, Goat, Cabbage, and Wolf Problem

Implementation:

4. Water Jug Problem

Implementation:

Key Points:

A* Search Algorithm and Iterative Deepening A* in JavaScript

1. Introduction

2. Understanding A* Search Algorithm

What is A*?

Properties of A*

Wikipedia Pseudocode for A*

3. Implementing A* in JavaScript

4. Mathematical Proofs and Analysis

Proof of Optimality

Time and Space Complexity

5. Limitations of A*

6. Iterative Deepening A* (IDA*)

Why IDA*?

How It Works

Wikipedia Pseudocode for IDA*

7. Implementing IDA* in JavaScript

8. Comparing A* and IDA*

9. Use Cases

10. Common Pitfalls and Best Practices

1. Choosing Heuristics Wisely

2. Balancing g(n)g(n) g(n) and h(n)h(n) h(n)

3. Debugging and Visualization Techniques

11. Advanced Topics

1. Variants of A*

2. Integration with Machine Learning

3. Parallelizing A* for Performance Optimization

12. Conclusion

How I Use AI, Sticky Notes, and Pomodoro to Stay Productive as a Software Engineer

The Problem: Overwhelming Tasks and Context Switching

My Workflow: AI, Sticky Notes, and Pomodoro

1. Generate an Initial To-Do List with AI

2. Create a Feature Branch

3. Work Incrementally and Extend the To-Do List

4. Track Progress with Sticky Notes

5. Stay Focused with the Pomodoro Technique

6. Create a Pull Request and Request Review

Tools I Use

AI Tools

Task Management

Pomodoro Timers

Hydration Tracking

Why This Works for Me

Example Workflow in Action

Scenario: Implementing a User Login Feature

Key Benefits of This Workflow

Try It Out!

Introduction to WebAssembly (WASM)

Setting Up the Development Environment

Create Project Folder:

Set Up Dev Container:

Create VSCode Settings:

Create C, JavaScript, and HTML Files:

Compiling C Code to WebAssembly Using Emscripten

Basic C Program:

Emscripten Command:

Breakdown of the Command

Loading and Interacting with WebAssembly in the Browser

HTML Setup:

JavaScript Setup:

Using External Tools on macOS

Install wabt:

Convert WASM to WAT:

Serve the HTML Page:

Conclusion

Functional Programming in Go with IBM fp-go: Error Handling Made Explicit

Why Functional Error Handling?

**2. Understanding A* Search Algorithm**

**3. Implementing A* in JavaScript**

**6. Iterative Deepening A* (IDA*)**

**7. Implementing IDA* in JavaScript**

**8. Comparing A* and IDA***

2. Balancing $g (n)$ and $h (n)$

Install `wabt`:

`Option`: Handling Optional Values

`Either`: Handling Errors Explicitly

Database Setup (`db.ts`)

Define Models and Validation (`models/User.ts`)

Custom Error Handling (`errors/AppError.ts`)

Service Layer (`services/UserService.ts`)

CRUD Operations (`controllers/UserController.ts`)

Express API (`index.ts`)

Example Test (`tests/UserService.test.ts`)