DEV Community: Sergey Korsik

Fix Your Slow ESLint: 3 Quick Tips

Sergey Korsik — Mon, 22 Sep 2025 16:28:14 +0000

If your linting takes 3-4 minutes, it's a bottleneck. Here are three ways to fix it.

1. Use the Cache

The --cache flag tells ESLint to only check files that have changed. It's the biggest win for local development. Add it to your package.json script. For more details, see the ESLint CLI documentation.

// package.json
"scripts": {
  "lint": "eslint . --cache"
}

2. Add Concurrency in CI

Use the --concurrency flag to run ESLint on multiple threads. This helps most in CI environments. Add it to your CI run command.

Warning: A value that's too high can exhaust your runner's memory. Start with 2 or 4. You can find the flag in the same ESLint CLI documentation.

3. Integrate Oxlint

If it's still slow, use Oxlint. It's a linter written in Rust and is 50-100x faster. It doesn't replace every ESLint plugin, but it covers the most common rules instantly.

You can find the project on GitHub at the Oxc repository. Just install the oxlint package and run it.

times(n, fn) in JS/TS + Python.

Sergey Korsik — Fri, 13 Jan 2023 13:59:01 +0000

Hey! Did you know that in JS not only null and undefined but some ephemerical empty value is existing? :)

But let's first talk about not very common, but few times appieared in the real life during my programming career.

Let's take a look on a different implementations of a function when we need to do something N times in a row (i.e. generate random chars by executing provided algorithm).

I will introduce some score system to more easily describe pros and cons of the solutions such as readability and efficiency with score rate from 1 (no) to 5 (yeah!).

Using pad function and array spreading

const times = (n, fn) => [...''.padEnd(n)].map(fn);

readability: 2 - it's readable, but after some time :)
efficiency: 2 - everytime is a new array created, spreading functionality, padEnd function, map function

Array Array

const times = (n, fn) => Array.from(Array(n), fn);

readability: 3 - better then before, but still looks fancy. Let's do a short break of all that happend here:

Array(n) gives us an empty array. Not null, not undefined, but empty.
Array.from an empty array will convert values from empty to undefined.
The second argument for Array.from is a funtion that will be executed against every value in the array.

efficiency: 3 - here we creating array of undefined from an empty array (what should be cheap at least memory wise).

for

const times = (n, fn) => {
  for (let i = 0; i < n: i++) {
    fn();
  }
}

readability: 4 - for me it's not the best approach from the fancy code point of view, but it's really readable and similar to many other languages structures. Yeasy for beginners and new-comers
efficiency: 4 - everytime is a new array created, spreading functionality, padEnd function, map function

Python bonus

As I've started to learn Python - there is an additional example in this language. It's always interesting to compare syntaksis when learning a new language :)

def times(n, fn):
  [fn() for _ in range(n)]

Not too much hacks, super concise, readable and much relays on the language core abilities itself. Love it!

readability: 5
efficiency: 5

Conclusion

As we can see - the function implementation can be short and easy to re-use, without any 3rd party libs needed.
Please, provide your solutions and scores in the comments!

Meanwhile you can take a look (on your own risk!) on how code can be bloated and shrink in the sope of one simple task/chank of functionality. From 180 to 6 lines ;)

Refactoring. From 6 to 180 lines.

Sergey Korsik — Sat, 07 Jan 2023 12:09:31 +0000

Hi there!

In this article I will try to show how different the solution can be for one not super hard task and also want to show you some tricks (maybe hacky, but it works in JS, not TS ;)) with reduce function.

First, let's take a look on the task and a super long, a bit crazy solution where I've tried to

Initial task (Book store)

As usual - this is a task from lovely and useful exercism.org portal and there is an instruction:

To try and encourage more sales of different books from a popular 5 book series, a bookshop has decided to offer discounts on multiple book purchases.
One copy of any of the five books costs $8.
If, however, you buy two different books, you get a 5% discount on those two books.
If you buy 3 different books, you get a 10% discount.
If you buy 4 different books, you get a 20% discount.
If you buy all 5, you get a 25% discount.
...the rest of instructions are here
The goal - find the better discount for the customer depends on the set of the books he or she is buying.

Looong solution with BookDispenser class

So, in this solution I've tried to focused not on the descent algorithm itself, but mostly on OO approach using BookDispenser machine

const getDiscountMultiplier = (discountInPercent) => 100 - discountInPercent;

const ONE_COPY_COST = 8;
const TWO_COPIES_DISCOUNT_PERCENT = 5;
const TWO_COPIES_DISCOUNT = getDiscountMultiplier(TWO_COPIES_DISCOUNT_PERCENT);

const TWO_COPIES_COST = 2 * ONE_COPY_COST * TWO_COPIES_DISCOUNT;
const THREE_COPIES_DISCOUNT_PERCENT = 10;
const THREE_COPIES_DISCOUNT = getDiscountMultiplier(THREE_COPIES_DISCOUNT_PERCENT);

const THREE_COPIES_COST = 3 * ONE_COPY_COST * THREE_COPIES_DISCOUNT;
const FOUR_COPIES_DISCOUNT_PERCENT = 20;
const FOUR_COPIES_DISCOUNT = getDiscountMultiplier(FOUR_COPIES_DISCOUNT_PERCENT);

const FOUR_COPIES_COST = 4 * ONE_COPY_COST * FOUR_COPIES_DISCOUNT;
const FIVE_COPIES_DISCOUNT_PERCENT = 25;
const FIVE_COPIES_DISCOUNT = getDiscountMultiplier(FIVE_COPIES_DISCOUNT_PERCENT);

const FIVE_COPIES_COST = 5 * ONE_COPY_COST * FIVE_COPIES_DISCOUNT;
const bestPriceForOneBook = Math.min(1 * ONE_COPY_COST * 100);
const bestPriceForTwoBooks = Math.min(
  2 * bestPriceForOneBook,
  1 * TWO_COPIES_COST
)
const bestPriceForThreeBooks = Math.min(
  3 * bestPriceForOneBook,
  1 * bestPriceForTwoBooks + 1 * bestPriceForOneBook,
  1 * THREE_COPIES_COST
)
const bestPriceForFourBooks = Math.min(
  4 * bestPriceForOneBook,
  2 * bestPriceForTwoBooks,
  1 * bestPriceForThreeBooks + 1 * bestPriceForOneBook,
  1 * FOUR_COPIES_COST
)
const bestPriceForFiveBooks = Math.min(
  5 * bestPriceForOneBook,
  2 * bestPriceForTwoBooks + 1 * bestPriceForThreeBooks,
  1 * bestPriceForThreeBooks + 1 * bestPriceForTwoBooks,
  1 * bestPriceForFourBooks + 1 * bestPriceForOneBook,
  1 * FIVE_COPIES_COST
)
//TODO: try to make it countable itself
const bestPricePerBookAmount = new Map([
  [1, bestPriceForOneBook],
  [2, bestPriceForTwoBooks],
  [3, bestPriceForThreeBooks],
  [4, bestPriceForFourBooks],
  [5, bestPriceForFiveBooks],
])
class BookDispenser {
  _booksByCount;
  _dispenserOrder;
  constructor(books) {
    this._booksByCount = BookDispenser._getBooksByCount(books);
    this._dispenserOrder = BookDispenser._countDispenserOrder(this._booksByCount);
  }
  _booksLeft() {
    let stillBooksLeft = false;
    for (let book = 1; book <= 5; book++) {
      const booksLeft = this._booksByCount.get(book);
      if (booksLeft > 0) {
        stillBooksLeft = true;
        break;
      }
    }
    return stillBooksLeft;
  }

  dispense(numberOfBooks) {
    let numberOfDispersedBooks = 0;
    for (let index = 0; index < this._dispenserOrder.length; index++) {
      const bookToDispense = this._dispenserOrder[index];
      numberOfDispersedBooks += this.dispenseBook(bookToDispense);

      if (numberOfDispersedBooks == numberOfBooks) break;
    }
    return numberOfDispersedBooks;
  }
  dispenseBook(bookNumber) {
    const booksCount = this._booksByCount.get(bookNumber);
    if (booksCount > 0) {
      this._booksByCount.set(bookNumber , booksCount - 1);
      return 1;
    }
    return 0;
  }

  getBatch(booksPerBatch, numberOfDispenses) {
    const booksBatches = [];
    let dispenses = 0;
    let batch;
    while ((!numberOfDispenses || dispenses < numberOfDispenses) &&
           (batch = this.dispense(booksPerBatch))
          ) {
      dispenses++;
      // log({booksPerBatch, batch, dispenses, still: dispenses < numberOfDispenses });
      booksBatches.push(batch);
    }
    return booksBatches;
  }

  getBatchReduced(booksPerBatch,  dispenses = 1) {
    const basketVariants = [];
    const batch = this.getBatch(booksPerBatch, dispenses);
    if (booksPerBatch >= 1) {
      const reducedBatch = this.getBatch(
        booksPerBatch === 1 ? 1 : booksPerBatch - 1
      );
      if (reducedBatch.length > 0) {
        batch.push(...reducedBatch);
      }
    }
    if (batch.length !== 0) {
      basketVariants.push(...batch);
    }
    return basketVariants;
  }
  static _getBooksByCount = (books) => {
    const booksByCount = new Map();
    for (let book = 1; book <= 5; book++) {
      const booksInBasket = books.filter(bookInBasket => bookInBasket === book).length;
      booksByCount.set(book, booksInBasket);
    }

    return booksByCount;
  }
  static _countDispenserOrder(booksByCount) {
    const bookEntries = [];
    for (let entry of booksByCount.entries()) {
      bookEntries.push(entry)
    }
    return bookEntries
      .sort((a, b) => b[1] - a[1] )
      .map(({0:a}) => a)
  }
}

const cost = (books) => {
  if (books.length === 0) return 0;

  const basketVariants = [];
  const addBatchIfNotAlreadyInVariants = (batch) => {
    const isExists = basketVariants.some(basket => {
        return ''+basket === ''+batch;
      })
    if (!isExists) {
      basketVariants.push(batch);
    }
  }

  for (let booksBatch = 5; booksBatch >= 1; booksBatch--) {
    // TODO: fix dispenses; should be calculated, not constant
    for (let dispenses = 1; dispenses < 10; dispenses++) {
      const bookDispenser = new BookDispenser(books);

      const reducedBatch = bookDispenser.getBatchReduced(booksBatch, dispenses);
      addBatchIfNotAlreadyInVariants(reducedBatch);
    }
    const batch = new BookDispenser(books).getBatch(booksBatch);
    addBatchIfNotAlreadyInVariants(batch);
  }

  log({ basketVariants });
  return Math.min(...basketVariants.map(basket => {
    return basket.reduce((sum, b) => sum + bestPricePerBookAmount.get(b), 0);
  }))
};

const log = value => console.log(value);

Yep, it's a bit of over, I know :)
What maybe here can be pointed is a usage of Maps not objects, the benefit/different of which you can read on mozilla web site. The different...

Super short solution

Based on the great super concise solution from LittleArmstrong!

const cost = (books) => books.reduce((grouped, book) => {
    grouped[book-1] = (grouped?.[book-1] ?? 0) + 1; return grouped;
  }, []).reduce((grouped, amount) => {
    for (let i = 0; i < amount; i++) grouped[i] = (grouped?.[i] ?? 0) + 1; return grouped;
  }, []).map(
    (amount, _ , group)  => (amount === 5 & group.includes(3)) ? (group[group.indexOf(3)] += 1, amount - 1) : amount).map(amount => 800 * amount * (1 - ({2: 0.05, 3: 0.1, 4: 0.2, 5: 0.25}?.[amount] ?? 0))).reduce((acc, cur) => acc += cur, 0);

Yes, this is hardly readable, I know :)

Conclusion

In this example I show you two polar solutions for the same task and of course the truth is somewhere between :)

Notice the usage of reduce function with the initial value as an accumulator. It's absolutely not trivial but possible.
Pros? The code looks a bit more functional and chained.
Cons? It's just looks hacky, hard to read and not highlighted in the MDN specification.

Please, feel free to provide your solution(s) in the comments or even better on exercism.org site.

Happy programming and refactoring! Let's stay tuned!

Refactoring. RegExp.

Sergey Korsik — Sat, 31 Dec 2022 10:08:53 +0000

Hi! Today we will take a look on the competition between reg exps or.. their non-existence.

Atbash Cipher

Let's take a look on a quite interesting, but still simple task - to write Atbash Cipher

Create an implementation of the atbash cipher, an ancient encryption system created in the Middle East.
The Atbash cipher is a simple substitution cipher that relies on transposing all the letters in the alphabet such that the resulting alphabet is backwards. The first letter is replaced with the last letter, the second with the second-last, and so on.
An Atbash cipher for the Latin alphabet would be as follows:
Plain: abcdefghijklmnopqrstuvwxyz
Cipher: zyxwvutsrqponmlkjihgfedcba

First let's take a look on excellent solution from Bob.

Bob's solution

Link to solution in Exercism:

export function encode(plainText: string, isDecoding:boolean = false): string {
  let output: number[] = [];
  let count = 0;
  const aAscii = 'a'.charCodeAt(0);
  const zAscii = 'z'.charCodeAt(0);
  let cAscii: number;

  for (let c of [...plainText.toLowerCase()]){
    if (c >= 'a' && c <= 'z')
      cAscii = zAscii - (c.charCodeAt(0) - aAscii);
    else if (c >= '0' && c <= '9')
      cAscii = c.charCodeAt(0);
    else
      continue;
    if (count == 5) {
      if (!isDecoding) output.push(32);
      count = 0;
    }
    output.push(cAscii);
    count ++;
  }
  return String.fromCharCode.apply(null, output);
}
export function decode(cipherText: string): string {
  return encode(cipherText, true);
}

Pros

The code is well structured.

Cons

The method encode includes an additional flag as a parameter which looks redundant and make logic more complex.
All logic at one place. The method can be easily splitted into few smaller.
Some values can be presented as consts to remove "magic" chars and numbers from the code.
we can make function more functional by replacing lets with consts and providing chaining for greater readability.
Let's introduce Reg Exps to remove redundant logic!

Possible refactoring

As we can see - the list of possible changes quite big. But the question is - will it help to the end user? Let's take a look!

After some changes

After all mentioned above things applied - the new code is looking like that:

const PUNCTUATION_AND_SPACE_REGEX = /[\s,.!?]/g;
const GROUP_OF_FIVE_REGEX = /(.{1,5})/g;
const A_CODE = 'a'.charCodeAt(0);
const Z_CODE = 'z'.charCodeAt(0);

const groupText = (text: string) => (text.match(GROUP_OF_FIVE_REGEX) ?? []).join(" ");

const isAlphabeticChar = (code: number) => code >= A_CODE && code <= Z_CODE;

const encodeChar = (char: string) => {
  const charCode = char.charCodeAt(0);
  const newCharCode = isAlphabeticChar(charCode) ? A_CODE + (Z_CODE - charCode) : charCode;
  return String.fromCharCode(newCharCode);
}

const cleanText = (text: string) => text
  .toLowerCase()
  .replaceAll(PUNCTUATION_AND_SPACE_REGEX, "");

const applyCipher = (text: string) => [...cleanText(text)]
  .map(encodeChar)
  .join("")

const encode = (plainText: string): string => groupText(applyCipher(plainText));
const decode = (cipherText: string): string => applyCipher(cipherText);

Please, put in comments what solution you prefer more. Also do not hesitate to left links in Exercism for your own solutions - sharing is caring ;)

Possible improvement: encapsulate logic inside class. Waitting for your links to solutions in the comments!

Meanwhile you can take a look on the task where I did some useful things regarding TS types.

Refactor. Improving Types.

Sergey Korsik — Sat, 24 Dec 2022 13:45:03 +0000

Hi!
Today we will take a look on the planets and age on them (relative).

Instructions

Given an age in seconds, calculate how old someone would be on:
Mercury: orbital period 0.2408467 Earth years
Venus: orbital period 0.61519726 Earth years
Earth: orbital period 1.0 Earth years, 365.25 Earth days, or 31557600 seconds
...[omitted, full list in the task]
So if you were told someone were 1,000,000,000 seconds old, you should be able to say that they're 31.69 Earth-years old.

First solution

As a basement we will take quite nice solution and will see what can be improved from the types perspective (i.e. make them more restrictive and "extracted") as well as we will apply clean code practices:

const RATIOS: {
  [key: string]: number
} = {
    mercury: 0.2408467,
    venus: 0.61519726,
    earth: 1,
    mars: 1.8808158,
    jupiter: 11.862615,
    saturn: 29.447498,
    uranus: 84.016846,
    neptune: 164.79132
}
export function age(planet: string, seconds: number): number {
    return Number((seconds / 31557600 / RATIOS[planet]).toFixed(2))
}

What to improve

Extract [key: string]: number to a separate type;
Update age function planet parameter type to more specific;
extract fix of result in the separate function;
add 31557600 as constant;
change function to an arrow function (just love it!);

some typing.. and...

Second solution

Here I've tried to reflect all the above mentioned points. There is a result:

type PlanetCoefsType = {
  [key: string]: number
};

const PlanetCoefs: PlanetCoefsType = {
  mercury: 0.2408467,
  venus:  0.61519726,
  earth: 1.0,
  mars: 1.8808158,
  jupiter: 11.862615,
  saturn: 29.447498,
  uranus: 84.016846,
  neptune: 164.79132,
}

type Planet = keyof typeof PlanetCoefs;

const YEAR_ON_EARTH_IN_SEC = 31557600;

const fixToTwo = (rawValue: number): number => Number(rawValue.toFixed(2));

export const age = (planet: Planet, seconds: number): number => {
  const planetCoef = PlanetCoefs[planet];
  const result = seconds / YEAR_ON_EARTH_IN_SEC / planetCoef;
  return fixToTwo(result);
}

All the changes I would assume quite trivial and easy to follow, except maybe this one (at least for me it took some time to understand):
type Planet = keyof typeof PlanetCoefs;

In this case the intention is to extract on programmatic level all already listed in PlanetCoefs object names of planets and strict our code to this list as we do not support others, i.e. "pluto", "solaris" and so on.

Hope it was a bit useful and interesting!
In the next post I will put an example with RegExp (how to add them or remove if too scared:)).

Meanwhile you can take a look on interesting example from the previous post (crazy one-liner and easy readable solution).

Refactoring. The beginning.

Sergey Korsik — Wed, 21 Dec 2022 11:28:35 +0000

Hi everyone!
This article will be dedicated to refactoring and clean code practices.
Let's start with the task I kindly took from the awesome project for developers and the possibility to mentor, learn different practices and languages and polish your skills instantly - Exercism.org.

So, here is the task related to clarifying whether the provided year is a leap or not:
Given a year, report if it is a leap year.
The tricky thing here is that a leap year in the Gregorian calendar occurs:

on every year that is evenly divisible by 4
except every year that is evenly divisible by 100
unless the year is also evenly divisible by 400

For example, 1997 is not a leap year, but 1996 is. 1900 is not a leap year, but 2000 is.

My first solution was the next:

function isLeap(year: number) {
  return year % 400 === 0 ? true : year % 100 === 0 ? false : year % 4 === 0 ? true : false
}

Pros:

One liner?
Not actually, but quite concise I would say. The true one-liner can look like this (Close your eyes!):

const isLeap = (y: number) => !(y % 400) || (!!(y % 100) && !(y % 4));

Cons:

Hard to understand.
As you can probably agree - it's long and barely readable and easily understandable.
Redundant code in the end (did it mainly to the love to ternary operators)

Possible improvements:

We can provide a bit of formatting and grouping, though it will not be a liner anymore. And it's ok. Also, it can be helpful for future refactoring when more logic or improvements need to be done

const isLeap = (year: number) => 
  year % 400 === 0 ? true : 
    year % 100 === 0 ? false : 
      year % 4 === 0;

Not that it's still concise but more readable and logically split (pov). If evenly divisible by 400 then it's a leap. If by 100 - not and so on.

The Second solution (Clean Code):

After the Clean Code (the site is a bit outdated, but the practices are still valuable as never before) approach applying it would look like this:

const isLeap = (year: number): boolean => {
  const isDividedBy = (divider: number): boolean => year % divider === 0;

  return isDividedBy(400) || (!isDividedBy(100) && isDividedBy(4));
}

As you can see - there is not so much more code added, but readability is much higher. Now I can simply read: "Year has leapt if it's divided evenly by 400 OR NOT divided by 100 WHILE divided by 4".

Hope it was a bit of fun for you!