Today I learned

You can have string unions that allows any type of string, but with actual autocompletion. You can do this with a loose string union:

type AutocompleteLoosenStatus = "active" | "inactive" | (string & {});

If you do like "et cetera" | string you will lose autocomplete.

Why?

The union with string & {} widens acceptance without collapsing the union into plain string.

LooseString

You can create your own loose string union:

type LooseString<T extends string> = T | (string & {});
 
type Status = LooseString<"idle" | "loading" | "success" | "error">;
 
const a: Status = "idle";        // autocomplete
const b: Status = "customValue"; // allowed

In settings.json you can change the defaults from activeEditorShort to activeEditorMedium, so it properly displays the full workspace’s realative path to the file you’re editing. This really helps me to navigate in codebases that have several index.tsx in it.

{
  "window.title": "${activeEditorMedium}${separator}${rootName}${separator}${profileName}"
}

You can use watch to run a command periodically. I used this to see how many active connections on Redis using redis-cli as well:

watch -n 1 "redis-cli CLIENT LIST | wc -l"

While reading Stop Building for “Scale.” You Don’t Have Users Yet by Shayan, I realized what just PostgreSQL has to offer:

• Real-time updates: Instead of Reids pub/sub, use Postgres LISTEN/NOTIFY
• Background jobs: Instead of RabbitMQ or Kafka, use Postgres as queue
• Full-text search using Postgres instead of Elasticsearch
• Vector search: Just use pgvector

If you’re wondering if this will not scale, I recommend reading the original post before jumping to conclusions.

git worktree is a Git feature that allows you to have multiple working directories linked to the same Git repository. This means you can simultaneously have different branches checked out in separate directories, enabling seamless context switching between tasks without having to stash changes or constantly switch branches within a single working directory.

• git docs: https://git-scm.com/docs/git-worktree

I tried doing this because I’m currently using Pop!_OS and the version of alacritty available in the apt is outdated. I want to use the latest features and improvements.

One cool way to install it is through Cargo, which allows you to get the latest version directly from the source.

For up-to-date dependencies for your OS and instructions, refer to the official Alacritty installation guide

Install .deb dependencies:

sudo apt install cmake g++ pkg-config libfontconfig1-dev libxcb-xfixes0-dev libxkbcommon-dev python3

If you’re using Wayland on Nvidia GPU, you should also install libegl1-mesa-dev on Ubuntu.

You should have rust installed. Instructions here.

Install Alacritty using Cargo:

cargo install alacritty

You’ll probably have to add it as an alternative (skip it if it appears as alternative already)

sudo update-alternatives --install /usr/bin/x-terminal-emulator x-terminal-emulator $HOME/.cargo/bin/alacritty 50

Set as default terminal:

sudo update-alternatives --config x-terminal-emulator

An aggregation in MongoDB is used when you want to:

• Group values from multiple documents together
• Perform operations on the grouped data to return a single result
• Analyze data changes over time

The best way of using aggregation is with aggregation pipelines, where you can have multiple stages. And in each stage you can process documents, from the docs:

• Each stage performs an operation on the input documents
  • For example, a stage can filter documents, group documents, and calculate values.
• The documents that are output from a stage are passed to the next stage.
• An aggregation pipeline can return results for groups of documents.
  • For example, return the total, average, maximum, and minimum values.

I faced an issue when trying to see if a script of my blog was running directly or being imported.

Before ESM I would try:

if (require.main === module) {
  run();
}
// otherwise, I could use the import/exports without worrying about it running other stuff

But this throws ReferenceError: require is not defined in ES module scope, you can use import instead if you’re using ESM.

In order to fix it, you can use the following snippet:

import path from 'node:path';
import fs from 'node:fs';
import { fileURLToPath } from 'node:url';
 
if (process.argv[1] === fileURLToPath(import.meta.url)) {
  run();
}

• nothing gets easier by itself
• my brain starts automating what I do most, or what I spend most of my energy doing
• something becomes progressively easier each time I do it
• this means that if I learn a mathematic topic and do exercises about it every day, it will be progressively easier to do these mathematic exercises; it also means that if I complain about my life and do absolutely nothing about it every day, I will get better at it (start making more sophisticated, more convincing, for example)
• the answer for getting better and making something become easier is simple: do more.
• reference: Eslen Delanogare (doctorate in Neurosciences from the Federal University of Santa Catarina) - Limiar de percepção de esforço

• For SSH keys you create the ~/.ssh/config file

Host gh_personal
  User git
  Hostname ssh.github.com
  Port 443
  IdentityFile ~/.ssh/personal
 
 
Host work
  User git
  Hostname altssh.gitlab.com
  Port 443
  IdentityFile ~/.ssh/work

• In .gitconfig you can include different config files based on the path you’re on

.gitconfig

[user]
    name = Your Name
    email = your-email@example.com
 
[includeIf "gitdir:~/www/work"]
    path = ~/.gitconfig-work

.gitconfig-work

[user]
    email = work-email@example.com

• For example

Personal key

git clone gh_personal:username/dsa.git

Work key

git clone gh_work:username/dsa.git

You can throw errors in Express and handle them correctly.

In this gist I put an example of how you can use it with Zod to customize the ZodError to a readable error message.

Before Express V5 you had to use express-async-errors, but now you can do this automatically.

You can pass --experimental-strip-types to enable Node.js to run TS files:

node --experimental-strip-types

• Use --watch flag to run on watch mode (no need for nodemon anymore!)
• Use --env-file=.env to handle the dotenv file

For more information about type stripping, TypeScript in Node.js and other stuff, see this

I once struggled with updating the updatedAt date of the post on my previous attempts to blog.

simple-git enables me to do this and many other cool stuff with git.

For example, on /now page the updated time can be fetched by passing the file:

const git = simpleGit();
let lastCommit: GitLogCommit | null = null;
const file = path.join(process.cwd(), 'src', 'pages', 'now.astro');
 
try {
  const log = await git.log({ file });
  lastCommit = log.latest;
} catch (err) {
  console.error(err);
}

Then just format it with dayjs:

dayjs(lastCommit?.date).format('YYYY-MM-DD HH:mm');