DEV Community: Aaron Brown

Recreating Math.floor without the Math object? Here is my manual approach.

Aaron Brown — Sun, 10 May 2026 10:15:47 +0000

Ever tried to solve a problem while someone tied your hands behind your back? I recently took on a challenge to rebuild JavaScript's rounding methods without using any of the built in Math functions, no bitwise operators, and not even the % operator.It sounds easy until you realize how many shortcuts we take for granted.

The Logic:
Finding the Floor, the biggest hurdle was performance. If you just loop 1 by 1 from zero, you'll crash the browser on large numbers. I decided to use a "fast-forward" while loop to jump by 100,000 at a time before using a for loop to find the exact integer.Here is the full implementation I came up with:

function floor(num) {
  if (num >= 0) {
    let i = 0
    while(num > i+100000){
        i = i+100000
    }
    for (i; ; i++) {
      if (i + 1 > num) return i
    }
  } else {
    for (let i = 0; ; i--) {
      if (i <= num) return i
    }
  }
}

function ceil(num) {
  let f = floor(num)
  return f === num ? num : f + 1
}

function trunc(num) {
  return num >= 0 ? floor(num) : ceil(num)
}

function round(num) {
  if (num >= 0) {
    return num - floor(num) >= 0.5 ? ceil(num) : floor(num)
  } else {
    return num - floor(num) >= 0.5 ? ceil(num) : floor(num)
  }
}

Breakdown of the approach:

The "Big Jump":
In the floor function, I used while(num > i+100000) to skip through huge ranges. This keeps the execution time low even for values in the millions.

*Infinite Loops for recision: *
I used for(i; ; i++) without a middle condition. Since I know I’ll eventually hit a number larger than num, the if statement handles the return and breaks the loop safely.

Reusability:
Once floor was solid, ceil and trunc became easy extensions. They just lean on the core logic of finding that base integer.

Why do this?
It’s easy to call Math.round() and move on. But building it manually makes you think about how numbers are actually stored and compared. It's a great exercise in control flow and manual optimization.How would you have handled the jump logic? Would you go bigger than 10,000? Comment below! 👇

javascript #coding #webdev #algorithms

The Hidden Beauty of JavaScript’s findExpression Problem

Aaron Brown — Sun, 10 May 2026 09:09:24 +0000

In programming, we often look for the shortest path between two points. But sometimes, the journey itself is the logic.I recently worked on a puzzle: Start at 1, and reach a target number using only two operations: +4 and *2. This isn’t just a math game; it’s a perfect introduction to Recursive Backtracking.

The Approach
When you use recursion to solve a path finding problem, the code behaves like an explorer in a cave. It tries every left turn until it hits a dead end, then it walks back and tries every right turn.

function search(current, path) {
  if (current === target) return path;
  if (current > target) return undefined;

  return search(current + 4, path + " +4") || 
         search(current * 2, path + " *2");
}

Why it matters
This logic is the foundation of AI pathfinding, game development, and even how some search engines crawl the web. It teaches us that "failing" a recursive branch isn't an error it's just a way to narrow down the truth.

Next time you're stuck on a complex nested loop, ask yourself: Could recursion make this a more elegant journey?

[Boost]

Aaron Brown — Fri, 08 May 2026 10:06:25 +0000

Huseyin Gumus

Dec 21 '22

Understanding the Role of Arrow Functions in JavaScript

#discuss #programming

Comments

2 min read