JavaScript

CHALLENGE

function makeCounter(start = 0, step = 1) {
  let count = start;
  const history = [];

  return {
    increment() {
      count += step;
      history.push(count);
      return this;
    },
    decrement() {
      count -= step;
      history.push(count);
      return this;
    },
    getHistory: () => history,
    getCount: () => count,
  };
}

const counter = makeCounter(10, 3);
counter.increment().increment().decrement();

console.log(counter.getCount());
console.log(counter.getHistory());

🤖 Eve: A Next.js-Style Framework for Building Agents A new framework from Vercel that provides Next.js-esque structure for building AI-powered agents using TypeScript and Markdown. It's quite Vercel-flavored by default, but I found you can run it entirely independently of Vercel with a few settings tweaks and your own keys. Project homepage. Vercel

🌲 Node.js 26.4 Adds Package Maps A minor release whose headline feature is the (experimental) implementation of package maps (which let Node resolve packages from a static JSON file rather than walking node_modules). Matteo Collina’s node:vfs subsystem also begins to make an appearance. Antoine du Hamel

CHALLENGE

class EventEmitter {
  #listeners = new Map();

  on(event, listener) {
    if (!this.#listeners.has(event)) {
      this.#listeners.set(event, []);
    }
    this.#listeners.get(event).push(listener);
    return this;
  }

  emit(event, ...args) {
    const handlers = this.#listeners.get(event) ?? [];
    handlers.forEach(fn => fn(...args));
    return this;
  }

  once(event, listener) {
    const wrapper = (...args) => {
      listener(...args);
      this.off(event, wrapper);
    };
    return this.on(event, wrapper);
  }

  off(event, listener) {
    const updated = (this.#listeners.get(event) ?? []).filter(fn => fn !== listener);
    this.#listeners.set(event, updated);
    return this;
  }
}

const emitter = new EventEmitter();
const log = [];

emitter.on("data", val => log.push(`on:${val}`));
emitter.once("data", val => log.push(`once:${val}`));
emitter.on("data", val => log.push(`on2:${val}`));

emitter.emit("data", "A");
emitter.emit("data", "B");

console.log(log.join(", "));

CHALLENGE

class AppError extends Error {
  constructor(message, code) {
    super(message);
    this.name = 'AppError';
    this.code = code;
  }
}

function riskyOperation(value) {
  if (value < 0) throw new AppError('Negative value', 'NEG_ERR');
  if (value === 0) throw new TypeError('Zero is not allowed');
  return value * 2;
}

function process(value) {
  try {
    return riskyOperation(value);
  } catch (err) {
    if (err instanceof AppError) {
      return `AppError [${err.code}]: ${err.message}`;
    }
    throw err;
  } finally {
    console.log(`Processed: ${value}`);
  }
}

try {
  console.log(process(-3));
  console.log(process(0));
} catch (err) {
  console.log(`Caught: ${err.constructor.name} - ${err.message}`);
}

CHALLENGE

class BankAccount {
  #balance;
  #transactionHistory = [];

  constructor(initialBalance) {
    this.#balance = initialBalance;
  }

  deposit(amount) {
    this.#balance += amount;
    this.#transactionHistory.push(`+${amount}`);
    return this;
  }

  withdraw(amount) {
    this.#balance -= amount;
    this.#transactionHistory.push(`-${amount}`);
    return this;
  }

  get summary() {
    return `Balance: ${this.#balance} | Transactions: ${this.#transactionHistory.join(", ")}`;
  }

  static hasPrivateBalance(obj) {
    return #balance in obj;
  }
}

const account = new BankAccount(100);
account.deposit(50).deposit(25).withdraw(30);

console.log(account.summary);
console.log(BankAccount.hasPrivateBalance(account));
console.log(BankAccount.hasPrivateBalance({}));

CHALLENGE

console.log('1: start');

setTimeout(() => console.log('2: setTimeout'), 0);

Promise.resolve()
  .then(() => {
    console.log('3: promise 1');
    return Promise.resolve('chained');
  })
  .then((val) => console.log(`4: ${val}`));

queueMicrotask(() => console.log('5: microtask'));

new Promise((resolve) => {
  console.log('6: executor');
  resolve();
}).then(() => console.log('7: promise 2'));

console.log('8: end');

CHALLENGE

const balance = 9007199254740991n; // Number.MAX_SAFE_INTEGER as BigInt
const fee = 1n;
const multiplier = 2n;

const total = (balance + fee) * multiplier;
const asNumber = Number(total);

const isSafe = Number.isSafeInteger(asNumber);
const isExact = BigInt(asNumber) === total;

console.log(`${total}n | safe: ${isSafe} | exact: ${isExact}`);

CHALLENGE

function Vehicle(make, model, year) {
  this.make = make;
  this.model = model;
  this.year = year;
  this.describe = function () {
    return `${this.year} ${this.make} ${this.model}`;
  };
}

Vehicle.prototype.age = function (currentYear) {
  return currentYear - this.year;
};

const car = new Vehicle("Toyota", "Supra", 1998);
const truck = new Vehicle("Ford", "Raptor", 2021);

console.log(car.describe());
console.log(truck.age(2025));
console.log(car.constructor === Vehicle);
console.log(Object.getPrototypeOf(car) === Vehicle.prototype);

CHALLENGE

function* range(start, end) {
  while (start < end) {
    yield start++;
  }
}

function* labeled(prefix, gen) {
  for (const val of gen) {
    yield `${prefix}:${val}`;
  }
}

function* pipeline() {
  yield* labeled("A", range(1, 4));
  yield* labeled("B", range(10, 12));
}

const results = [...pipeline()];
console.log(results.length, results[0], results[results.length - 1]);

CHALLENGE

const compose = (...fns) => x => fns.reduceRight((acc, fn) => fn(acc), x);
const pipe = (...fns) => x => fns.reduce((acc, fn) => fn(acc), x);

const double = x => x * 2;
const addTen = x => x + 10;
const square = x => x ** 2;
const negate = x => -x;

const transform1 = compose(negate, square, addTen, double);
const transform2 = pipe(negate, square, addTen, double);

console.log(transform1(3));
console.log(transform2(3));

🤔 Tabulator 6.5 (above) – Create interactive tables from any HTML table, JS array or JSON data.

🥶 Flow for TypeScript Users in 2026 Flow is Meta's mature typed dialect of JavaScript, and over the years its syntax has converged closely with TypeScript's. This post walks through where the two now differ: Flow's stricter defaults reject several crash-prone patterns TypeScript's strict mode accepts, and it adds features of its own, like exhaustive match expressions. George Zahariev (Meta)