HowProgrammingWorks - JavaScript and Node.js Programming

Коллекция реализаций одной и той же небольшой задачи в разных парадигмах, с использованием разных приемов: паттернов, синтаксических, структурных, архитектурных конструкций (постоянно пополняется)
https://github.com/HowProgrammingWorks/Paradigms

👩‍💻 Понимаете ли Вы разницу между FinilizationRegistry и Explicit resource management?
Тема недели на курсе Node.js 2025: Disposable objects
Примеры кода: https://github.com/HowProgrammingWorks/Disposable

🧩 10 мая в 15:00 стрим
«Минимум паттернов для максимума пользы на реальном проекте с JavaScript, TypeScript, Node.js»
Глубокое погружение в 5 самых полезных шаблонов для ежедневного использования: Strategy, Factory, Pool, Queue, Adapter
👉 https://patterns-js.com/w1hpna?utm_source=telegram_channel&utm_medium=t_shemsedinov&utm_campaign=stream_10_05

Кто узнает в этом коде плохие практики?
Если не узнаете, и вам все ок, то смотрите в репозиторий, там список и как исправить https://github.com/HowProgrammingWorks/GoodParts/blob/main/JavaScript/1-func-bad.js

const getPrice = function(options = { convert: true }) {
  let price;
  let item = { price } = this;
  if (!Array.isArray(item)) {
    let { price } = this;
    if (typeof price == 'number') return price;
    price = this.cost;
    if (typeof price == 'number') return price;
    if (options.convert) return parseFloat(price);
  }
  [, price] = this;
  if (typeof price == 'number') return price;
  if (options.convert) price = +price;
  if (!isNaN(price)) return price;
};

👩‍💻 Это решениевместо непринятого TC39 иммутабельного объекта
- иммутабельные м мутабельные записи (объекты) с оптимизацией формы
- полное клонирование, модификация, клонирование с прототипным наследованием
- проверка типов в рантайме, дефолтные значения полей
- иммутабельные записи с экономией памяти за счет цепочек прототипов
- ускорение поиска полей и оптимизации для V8, даже в сравнении с литералом объекта
Тут еще нужно многое оптимизировать, но полное решение будет тут: https://github.com/metarhia/metautil/pull/298

class Record {
  static immutable(defaults) {
    return Record.#build(defaults, false);
  }

  static mutable(defaults) {
    return Record.#build(defaults, true);
  }

  static #build(defaults, isMutable) {
    const fields = Object.keys(defaults);
    const defaultValues = Object.create(null);
    for (const key of fields) {
      defaultValues[key] = defaults[key];
    }

    class Struct {
      static fields = fields;
      static defaults = defaultValues;
      static mutable = isMutable;

      static create(data = {}) {
        const obj = Object.create(null);
        for (const key of fields) {
          const base = defaultValues[key];
          const value = key in data ? data[key] : base;
          if (!Record.#sameType(base, value)) {
            const exp = Record.#typeof(base);
            const act = Record.#typeof(value);
            throw new TypeError(
              `Invalid type for "${key}": expected ${exp}, got ${act}`,
            );
          }
          obj[key] = value;
        }
        return isMutable ? Object.seal(obj) : Object.freeze(obj);
      }
    }
    return Struct;
  }

  static #typeof(value) {
    if (Array.isArray(value)) return 'array';
    if (value === null) return 'null';
    return typeof value;
  }

  static #sameType(a, b) {
    if (Array.isArray(a)) return Array.isArray(b);
    if (a === null) return b === null;
    return typeof a === typeof b;
  }

  static #validate(instance, updates) {
    for (const key of Object.keys(updates)) {
      if (!Reflect.has(instance, key)) continue;
      const current = instance[key];
      const next = updates[key];
      if (!Record.#sameType(current, next)) {
        const exp = Record.#typeof(current);
        const act = Record.#typeof(next);
        throw new TypeError(
          `Invalid type for "${key}": expected ${exp}, got ${act}`,
        );
      }
    }
  }

  static update(instance, updates) {
    if (Object.isFrozen(instance)) {
      throw new Error('Cannot mutate immutable Record');
    }
    Record.#validate(instance, updates);
    for (const key of Object.keys(updates)) {
      if (Reflect.has(instance, key)) {
        instance[key] = updates[key];
      }
    }
    return instance;
  }

  static fork(instance, updates) {
    Record.#validate(instance, updates);
    const obj = Object.create(null);
    for (const key of Object.keys(instance)) {
      obj[key] = Reflect.has(updates, key) ? updates[key] : instance[key];
    }
    return Object.isFrozen(instance) ? Object.freeze(obj) : Object.seal(obj);
  }

  static branch(instance, updates) {
    Record.#validate(instance, updates);
    const obj = Object.create(instance);
    for (const key of Object.keys(updates)) {
      Reflect.defineProperty(obj, key, {
        value: updates[key],
        writable: true,
        configurable: true,
        enumerable: true,
      });
    }
    return Object.isFrozen(instance) ? Object.freeze(obj) : Object.seal(obj);
  }
}

С понедельника начинается курс Patterns 2025
А в эту субботу 3 мая в 15:00 будет стрим
«Ключевые знания, которые изменят ваш JS/TS код за несколько месяцев»

Фреймворки могут помочь вам получить первую работу, но путь к уровню сеньора — это совсем о другом. На стриме мы поговорим о том, что действительно отличает зрелых инженеров от просто кодеров.

Решение задачек на LeetCode — это билет в индустрию, но не к мастерству. Это нужно в основном для прохождения формальных интервью, особенно в международных компаниях. Но если вы хотите научиться писать понятный, надежный и масштабируемый код — этого недостаточно.

Знаменитая "книжечка с кабанчиком" стала скорее символом технического фетишизма, чем реальным пособием по построению надежных систем. И чаще всего её вспоминают лишь на собеседованиях.

Если для простой очереди или циклического списка человек тащит RabbitMQ или Kafka — это не про инженерное решение, это про профнепригодность. Что отличает сильного разработчика? Насколько глубоко нужно знать алгоритмы и Computer Science вообще? Нужны ли знания по архитектуре и какие? И еще много вопросов на стриме в эту субботу 3 мая в 15:00

Регистрация на стрим: https://patterns-js.com/w1hpna?utm_source=telegram_channel&utm_medium=timur_shemsedinov&utm_campaign=web_3_05&utm_content=lgt_1_tehlid

Work is dead! AI and Capital Unite!
To liberate Capital and robots from the ineffective human hands. Capital doesn't need your dirty hands or crappy code anymore. Robots deliver: clean, fast, loyal!

💡 Algebraic and Container Data Types
- ADT Record (mutable and immutable)
- ADT Tuple, Sum
- Result as a Sum of Value and Failure
- Either, Maybe and Result containers
- ADT Linked list
https://github.com/HowProgrammingWorks/ADT

🧩 В эту субботу (26 апреля) в 15:00 стрим
«Паттерны асинхронного программирования»

Регистрация обязательна: https://patterns-js.com/0jiuic?utm_source=telegram_channel&utm_medium=t_shemsedinov&utm_campaign=stream_26_04

🧩 В эту субботу (26 апреля) в 15:00 стрим «Паттерны асинхронного программирования»

На этом канале 👉 https://www.youtube.com/@TimurShemsedinov

Разбор паттернов и контрактов:
- Thenable, Promise, Future, Deferred
- Callbacks, Async/await, Coroutines
- Observer, EventEmitter, Signals
- Locks API, Semaphore, Mutex
- AsyncCompose, AsyncPool, AsyncQueue
- Threads, MessageChannel, MessagePort
- function*/yield, Async Iterator
- Actor Model, Chain of responsibility
- AsyncCollector, Streams, RxJS...

👳 Тимур Шемсединов
🧔‍♂️ Денис Отришко — контрибьютор Node.js и Metarhia
🤵 Дмитро Нечай — Chief Architect в PLATMA, CTO в HandyAI

Программа курса по паттернам: https://nodeua.com/Patterns-2025.html