Ali Torki ali-master

Concurrency, Parallelism, and Multi-threading in Node.js

In the world of computing, the terms "concurrency" and "parallelism" are often used interchangeably, but they represent distinct concepts with significant implications for optimizing performance and efficiency. To understand better how Node.js, with its single-threaded event loop, works with concurrency and parallelism, let's first explore the fundamental differences between concurrency and parallelism and then dive into the event loop in Node.js, its role in implementing concurrency and parallelism, and how it differs from traditional multithreading approaches.

Concurrency: "Simultaneous" Execution

Concurrency refers to the ability of a computer system to execute multiple tasks concurrently. It involves breaking down a complex problem into smaller, independent tasks that can be executed in overlapping time intervals. While the tasks may appear to be executing simultaneously, they are actually taking turns running on a single processor or core. Co

In defense of blocks for local scopes (Part 1)

[EDIT: I've added a part 2 to this blog post, to address some of the feedback that has come up: https://gist.github.com/getify/706e5e10822a298375da40f9cc1fa295]

Recently, this article on "The JavaScript Block Statement" came out, and it received some good discussion in a reddit thread. But the general reaction seems to be against this approach. That saddens me.

PostgreSQL 13 Master-Standby Streaming Replication

PostgreSQL has various types of replication available and it could be a little bit confusing to figure out what has to be done to just configure a simple master-standby replicated database setup. Digging my way through documentation I decided to write my own little guide on how to setup simple replication in PostgreSQL 13.

How it works

Streaming replication works by streaming the contents of WAL (Write-Ahead Logging) file from one server to another. Each transaction is first written into the WAL file, so essentially every change on the primary server will be replicated on the standby server. Standby server could be used for read-only operations, but can't be written to. Ofcourse, transferring data over the network takes time and there is a small lag before data written to one server becomes available on the other. To guarrantee data consistency on both servers at the time of read operation we can enable synchronous replication mode. This way, datab

	// Types for the result object with discriminated union
	type Success<T> = {
	data: T;
	error: null;
	};

	type Failure<E> = {
	data: null;
	error: E;
	};

	// Usage:
	// Replace React.lazy(() => import('x'));
	// with retryDynamicImport(() => import('x'));

	import { ComponentType, lazy } from 'react';

	const MAX_RETRY_COUNT = 15;
	const RETRY_DELAY_MS = 500;

	// Regex to extract the module URL from the import statement

	it("should get the client timezone as a string", () => {
	const DateTimeFormat = Intl.DateTimeFormat;
	vi.spyOn(global.Intl, "DateTimeFormat").mockImplementation(
	(locale, options) =>
	new DateTimeFormat(locale, { ...options, timeZone: "Asia/Tehran" })
	);

	const date: MyDate = new MyDate("2023-03-28T11:06:48+00:00");

	expect(date.getClientTZ()).toEqual("Asia/Tehran");

	import {
	Injectable,
	CanActivate,
	ExecutionContext,
	HttpStatus,
	BadRequestException,
	UnauthorizedException,
	} from '@nestjs/common';
	import { Request } from 'express';
	import { ConfigService } from '@nestjs/config';

	// abstract class, not intended to be instantiated directly
	class CalendarItem {
	static #UNSET = Symbol("unset")
	static #isUnset(v) {
	return v === this.#UNSET;
	}
	static {
	for (let [idx,msg] of [
	"ID is already set.",
	"ID is unset.",

	from binance.client import Client
	from binance.exceptions import BinanceAPIException, BinanceRequestException
	#incomplete but i just need a useful regex
	client = Client("apikey", "secret")

	coininfo = client.get_all_coins_info()
	for coin in coininfo:
	for network in (coin['networkList']):
	print(coin['name'],network['addressRegex'])

	-- Based off IETF draft, https://datatracker.ietf.org/doc/draft-peabody-dispatch-new-uuid-format/

	create or replace function uuid_generate_v7()
	returns uuid
	as $$
	begin
	-- use random v4 uuid as starting point (which has the same variant we need)
	-- then overlay timestamp
	-- then set version 7 by flipping the 2 and 1 bit in the version 4 string
	return encode(