The high-level design of different systems, from URL shorteners to YouTube.

A 500ish page instruction on how to dream big.

This is my 2022 review. For obvious reasons, this year has a titanium shit shovel as a mascot. 

benchmarking array methods vs for loop vs iterators vs generators

export interface Entity {
  groupId: number;
  value: number;
}

export interface SuperEntity {
  groupId: number;
  value: number;
  groupLength: number;
}

export function getEntities(size: number): Entity[] {
  const result: Entity[] = new Array(size);
  for (let i = 0; i < size; i++) {
    result[i] = {
      groupId: getRandomInt(0, Math.ceil(size / 100)),
      value: getRandomInt(0, 100),
    };
  }
  return result;
}

export function createLookupMap(entities: Entity[]): Map<number, Entity[]> {
  let result: Map<number, Entity[]> = new Map();
  for (let i = 0; i < entities.length; i++) {
    const entity = entities[i];
    const val = result.get(entity.groupId);
    if (val) {
      val.push(entity);
    } else {
      result.set(entity.groupId, [entity]);
    }
  }
  return result;
}

export function convertToSuperEntities(
  lookup: Map<number, Entity[]>,
  entities: Entity[]
): SuperEntity[] {
  const groupSizeFilter = isEntityGroupBig.bind(null, lookup, entities.length);
  return entities
    .filter(isValueGreaterThatTwo)
    .filter(groupSizeFilter)
    .map((entity) => mapToSuperEntity(lookup, entity))
    .filter(isSuperEntity);
}

export function convertToSuperEntitiesWithLoop(
  lookup: Map<number, Entity[]>,
  entities: Entity[]
): SuperEntity[] {
  const result: SuperEntity[] = new Array(entities.length);
  const groupSizeFilter = isEntityGroupBig.bind(null, lookup, entities.length);
  let j = 0;
  for (let i = 0; i < entities.length; i++) {
    const entity = entities[i];
    if (isValueGreaterThatTwo(entity) && groupSizeFilter(entity)) {
      const superEntity = mapToSuperEntity(lookup, entity);
      if (isSuperEntity(superEntity)) {
        result[j] = superEntity;
        j++;
      }
    }
  }
  return result.slice(0, j);
}

export function* map<Input, Output>(
  functor: (args: Input) => Output,
  entries: Iterable<Input>
): Iterable<Output> {
  for (const entry of entries) {
    yield functor(entry);
  }
}

type TypeguardPredicate<InputType, OutputType extends InputType> = (
  value: InputType
) => value is OutputType;
type BooleanPredicate<InputType> = (value: InputType) => boolean;
type Predicate<InputType, OutputType extends InputType> =
  | TypeguardPredicate<InputType, OutputType>
  | BooleanPredicate<InputType>;

export function* filter<InputType, OutputType extends InputType>(
  predicate: Predicate<InputType, OutputType>,
  entries: Iterable<InputType>
): Iterable<OutputType> {
  for (const entry of entries) {
    if (predicate(entry)) {
      yield entry;
    }
  }
}

export function convertToSuperEntitiesWithGenerators(
  lookup: Map<number, Entity[]>,
  entities: Entity[]
): SuperEntity[] {
  const groupSizeFilter = isEntityGroupBig.bind(null, lookup, entities.length);
  const greaterThanTwoIterable = filter(isValueGreaterThatTwo, entities);
  const andHasABigGroupIterable = filter(groupSizeFilter, greaterThanTwoIterable);
  const mappedIterable = map(
    (entity) => mapToSuperEntity(lookup, entity),
    andHasABigGroupIterable
  );
  return [...filter(isSuperEntity, mappedIterable)];
}

async function run(n: number) {
  const entities = getEntities(n);
  const lookup = createLookupMap(entities);
  return suite(
    `Entity(${n}) to SuperEntity transformer`,
    add("array methods", () => {
      return convertToSuperEntities(lookup, entities);
    }),
    add("for loop", () => {
      return convertToSuperEntitiesWithLoop(lookup, entities);
    }),
    add("generators", () => {
      return convertToSuperEntitiesWithGenerators(lookup, entities);
    }),
    cycle()
  );
}

# npx ts-node src/benchmark.ts
Running "Entity(100000) to SuperEntity transformer" suite...
Progress: 100%

  array methods:
    4.5 ops/s, ±20.12%   | 6.25% slower

  for loop:
    4.8 ops/s, ±20.66%   | fastest

  generators:
    3.9 ops/s, ±18.90%   | slowest, 18.75% slower


export function map<InputType, OutputType>(
  functor: (arg: InputType) => OutputType,
  iterable: Iterable<InputType>
): Iterable<OutputType> {
  return {
    [Symbol.iterator]() {
      const iterator = iterable[Symbol.iterator]();
      return {
        next() {
          const { value, done } = iterator.next();
          if (done) {
            return { value: undefined, done: true };
          } else {
            return { value: functor(value), done: false };
          }
        },
      };
    },
  };
}

type TypeguardPredicate<InputType, OutputType extends InputType> = (
  value: InputType
) => value is OutputType;
type BooleanPredicate<InputType> = (value: InputType) => boolean;
type Predicate<InputType, OutputType extends InputType> =
  | TypeguardPredicate<InputType, OutputType>
  | BooleanPredicate<InputType>;

export function filter<InputType, OutputType extends InputType>(
  predicate: Predicate<InputType, OutputType>,
  iterable: Iterable<InputType>
): Iterable<OutputType> {
  return {
    [Symbol.iterator]() {
      const iterator = iterable[Symbol.iterator]();
      return {
        next() {
          let { value, done } = iterator.next();
          while (done === false && !predicate(value)) {
            const result = iterator.next();
            value = result.value;
            done = result.done;
          }
          if (done) {
            return { value: undefined, done: true };
          } else {
            return { value, done };
          }
        },
      };
    },
  };
}

export function convertToSuperEntitiesWithIterators(
  lookup: Map<number, Entity[]>,
  entities: Entity[]
): SuperEntity[] {
  const groupSizeFilter = isEntityGroupBig.bind(null, lookup, entities.length);
  const greaterThanTwoIterable = filter(isValueGreaterThatTwo, entities);
  const andHasABigGroupIterable = filter(groupSizeFilter, greaterThanTwoIterable);
  const mappedIterable = map(
    (entity) => mapToSuperEntity(lookup, entity),
    andHasABigGroupIterable
  );
  return [...filter(isSuperEntity, mappedIterable)];
}

async function run(n: number) {
  const entities = getEntities(n);
  const lookup = createLookupMap(entities);
  return suite(
    `Entity(${n}) to SuperEntity transformer`,
    add("array methods", () => {
      return convertToSuperEntities(lookup, entities);
    }),
    add("for loop", () => {
      return convertToSuperEntitiesWithLoop(lookup, entities);
    }),
    add("generators", () => {
      return convertToSuperEntitiesWithGenerators(lookup, entities);
    }),
    add("iterators", () => {
      return convertToSuperEntitiesWithIterators(lookup, entities);
    }),
    cycle()
  );
}

# npx ts-node src/benchmark.ts
Running "Entity(100000) to SuperEntity transformer" suite...
Progress: 100%

  array methods:
    4.8 ops/s, ±17.19%   | 2.04% slower

  for loop:
    4.9 ops/s, ±21.21%   | fastest

  generators:
    4 ops/s, ±19.09%     | slowest, 18.37% slower

  iterators:
    4.4 ops/s, ±12.05%   | 10.2% slower

In one of the first posts, I promised to post the music here. This time has come.

Idiomatic programming for experienced developers.

Hike the Austrian section of the E5 with detours and fun.

This year was my turn to come up with a vacation plan. And guess what? This September, we will hike from Germany to Italy.