DEV Community: delv.

Understanding goroutines in Go

delv. — Thu, 22 May 2025 08:21:41 +0000

In Go, a goroutine is a fundamental concept used to achieve concurrency. It allows functions or methods to run independently alongside other functions. Goroutines are lightweight, managed by the Go runtime, and provide a simple way to handle tasks that can operate concurrently.

What is a Goroutine?

A goroutine is a function that runs concurrently with other functions in the same address space. It is created by placing the keyword go before a function call. For example:

go doWork()

This statement starts a new goroutine to execute the doWork() function, allowing the current program to continue executing without waiting for doWork() to complete.

Why Goroutines?

Goroutines are a key part of Go’s approach to concurrency. They are ideal for tasks such as:

Handling multiple incoming network connections
Performing I/O operations without blocking
Running background computations

Communication using Channels

To coordinate and share data between goroutines, Go provides a feature called channels. Channels allow safe communication between goroutines and help prevent issues like race conditions.

ch := make(chan string)

go func() {
    ch <- "Task completed"
}()

message := <-ch
fmt.Println(message)

In this example, the goroutine sends a message through the channel, and the main function receives it. This synchronization ensures that data is passed safely between concurrent tasks.

Promise.race: The best method to implement time limit on Promises. ⏳

delv. — Sat, 01 Jun 2024 10:59:33 +0000

Whenever a Promise request happens, it is common for it to have a timeout. If the time limit is exceeded, it'll cancel the request and throw a timeout error.

How would you implement that fallback? Do you use setTimeout? Or, at worst, do you use performance.now to calculate whether the request exceeded the time limit?

This is where Promise.race comes in. According to MDN:

The Promise.race() static method takes an iterable of promises as input and returns a single Promise.

As the name suggests, it triggers the iterable (such as an Array) of Promise objects, and whichever resolves the fastest will be returned.

So, using Promise.race, you can implement a time limit fallback with minimal code.

// Where fn is the promise, and
// ms is the time limit in milliseconds
function timeLimit(fn, ms) {
  const fallback = new Promise((_, reject) => {
    setTimeout(() => {
      reject("Time limit exceeded");
    }, ms);
  });
  return Promise.race([fn, fallback]);
}

This function simultaneously executes the fn argument and the fallback promise. The fallback promise creates a timeout with ms as the delay time. Therefore, it rejects the promise after the delay time.

Since Promise.race returns the first promise to finish, the "Time limit exceeded" rejection can be returned if the fn promise is late.

Conversely, if fn finishes earlier, it will return its result, either resolved or rejected.

That's it. Thank you for reading! Would you mind giving this post a reaction?

You might want to replace cd command with Zoxide 🎉 — a smarter and trainable cd alternative 🗂️

delv. — Sat, 09 Mar 2024 04:19:34 +0000

Have you ever encountered a problem where you kept changing directories, costing you a lot of time? I certainly have.

But guess what? I found something called Zoxide, and it has revolutionized the way I navigate through my directories. It saves me time, helps me stay focused, and boosts my productivity.

How does it work?

Essentially, it's no different from the cd command. However, after using it for a while, you'll come to appreciate its efficiency.

Let's say you want to open your project directory. This is how you'd do it with the cd command:

$ cd creuserr/projects/my_project

With Zoxide, it's just as simple:

$ z creuserr/projects/my_project

As I mentioned earlier, it's essentially the same as cd.

$ cd -
$ z -

$ cd ..
$ z ..

$ cd /
$ z /

However, after navigating through these directories, Zoxide will remember them all.

For example, after navigating to the my_project directory and closing the terminal, you can return to it using just keywords:

$ z my_project
creuserr/projects/my_project $

Pretty cool, right? Give it a try!

Installation

Head over to ajeetdsouza/zoxide and install it now! It's innovative, free, and flexible!

How to use it?

You can only use shortcuts if Zoxide recognizes the directory.

$ z blah blah
zoxide: no match found

You can also navigate with multiple keywords.

$ z creuserr my_project
creuserr/projects/my_project $

Moreover, there are some algorithms you should know about:

Algorithms

1. Case Insensitivity

Zoxide is case insensitive when searching for directories by keywords.

$ z My_PROJECT
creuserr/projects/my_project $

2. Two or More Keywords Do Not Recognize Sub-directories

It's a bit tricky, but here's an example:

$ z foo/bar/baz/lorem/ipsum
foo/bar/baz/lorem/ipsum $

$ z bar
foo/bar $

$ z baz ipsum
foo/bar/baz/lorem/ipsum $

$ z foo baz
zoxide: no match found

Basically, you can only navigate with two or more keywords if the last keyword corresponds to a recognized directory.

3. Unordered Keyword Stacks Are Not Supported

$ z foo/bar/baz/lorem/ipsum
foo/bar/baz/lorem/ipsum $

$ z baz foo
zoxide: no match found

$ z lorem foo
zoxide: no match found

Navigation with keywords must follow a left-to-right order.

How It Works Under the Hood

Recognized directories are stored with a frecency score, which determines their priority level when the user searches for something.

Frecency: Frequency + Recency

Frecency is a term coined from frequency and recency. Frecency scores are determined by how frequently the user navigates to a directory and how long ago the last visit was.

When a user navigates to a directory, its frecency score increases by 1, and the recency is determined by the last time it was accessed.

Last Time Access	Frecency
Within the Last Hour	`score * 4`
Within the Last Day	`score * 2`
Within the Last Week	`score / 2`
Otherwise	`score / 4`

$ z foo/bar/baz
$ z lorem/ipsum/baz

Imagine foo/bar/baz has a higher frecency score than lorem/ipsum/baz.

$ z baz
foo/bar/baz $

Thank you for reading this blog! I hope you find it helpful! Please consider leaving a react or a comment; I would really appreciate it! ❤️

📨 Building your Email API with Fastmail for free!

delv. — Fri, 01 Mar 2024 09:57:26 +0000

Have you ever wondered how to host an email system without paying even a single penny? Well, this blog will guide you through the process of building your own email system on Node.js with the integration of fastmail.com.

GIST: https://gist.github.com/creuserr/97a78069be7e33069f14b179d7bc3a9f

Step 1: Creating the project

You need to create a new private repository for this API service, and soon we'll be deploying it on Vercel.

The file structures must be like this:

/
├── api
│   └── index.js
│   └── .env
└── vercel.json

Now, we need to install nodemailer and dotenv on npm.

$ npm install dotenv
$ npm install nodemailer

Step 2: Creating the email

Now, go ahead to https://fastmail.com and create your new email.

After that, go to Settings > Privacy & Security > Integrations > New App Password. Then, set the access to SMTP, and save the app password.

Step 3: Building the basics

In your vercel.json file, enter the following code:

{
  "version": 2,
  "builds": [{
    "src": "api/index.js",
    "use": "@vercel/node"
  }],
  "rewrites": [{
    "source": "/api/(.*)",
    "destination": "/api/index.js"
  }],
  "headers": [{
    "source": "/api/index.js",
    "headers": [{
      "key": "Access-Control-Allow-Origin",
      "value": "*"
    }, {
      "key": "Access-Control-Allow-Methods",
      "value": "POST"
    }]
  }]
}

In your .env file, enter the following code:

EMAIL=example@fastmail.com
PASSWORD=password

Where EMAIL is your fastmail address, and PASSWORD is the app password you generated earlier.

Step 4: Building the API

We need to import nodemailer library and initialize the environment variables.

const { createTransport } = require("nodemailer")
require("dotenv").config()

Now, we need to handle the client request and validate it.

module.exports = (req, res) => {
  // if the client is within the server,
  // you can remove this header to
  // prevent outside access.
  res.setHeader("Access-Control-Allow-Origin", "*")
  res.setHeader("Content-Type", "text/plain")
  if(req.method != "POST") {
    return res.status(400).end("400 Bad Request: Invalid method")
  }
  if(req.body.length < 5) {
    return res.status(400).end("400 Bad Request: Body is too short (min 5)")
  }
  var reciever = req.headers["x-mail-reciever"]
  var subject = req.headers["x-mail-subject"]
  if(reciever == null || subject == null) {
    return res.status(400).end("400 Bad Request: Incomplete headers")
  }
}

Now, after the validation, we need to create a transport. Basically, we need to log onto the email.

const sender = process.env.EMAIL
const password = process.env.PASSWORD
try {
  var transporter = createTransport({
    host: "smtp.fastmail.com",
    port: 465,
    auth: {
      user: sender,
      pass: password
    }
  })
  const options = {
    from: sender,
    to: reciever,
    subject,
    html: req.body
  }
} catch(e) {
  res.status(500).end(`500 Internal Error: Failed to initialize transporter: ${e}`)
}

And lastly, after logging in, we will now send the mail to reciever.

try {
  transporter.sendMail(options, function(e, i) {
    if(e) {
      res.status(400).end(`400 Bad Request: Failed to send mail: ${e}`)
    } else {
      res.status(200).end("200 Success")
    }
  })
} catch(e) {
  res.status(400).end(`400 Bad Request: Failed to send mail: ${e}`)
}

Step 5: Deploying the API

Now, go ahead to Vercel and deploy the API.

And congrats, you have just created your own email system!

But wait! How to use it though?

Usage

To send an email, you need to create a POST request to your API, with the following headers:

X-Mail-Subject: Lorem Ipsum Dolor Sit Amet, Consectetur
X-Mail-Reciever: johndoe@example.com

Where X-Mail-Subject is the subject of the mal and X-Mail-Reciever is the email address you want this mail to recieve.

Moreover, the body is the content of the mail, which supports HTML.

If the API responded with 200 Success, then your mail was sent to the reciever and your API works perfectly fine.

Wait.. Where is the mail? I can't find it?
.

Disadvantages

One of the biggest disadvantage of this method is:

It is considered as spam. I believe it's because we used SMTP directly without any additional credentials to tell incoming servers that our mail is not a spam.

Thank you for reading this blog! I hope you like it! Please leave me a single react or comment; I will appreciate it so much! ❤️

🗃️ Building a Pocket Database with Telegra.ph — create your non-local database in just a single function! 😱

delv. — Wed, 24 Jan 2024 08:20:32 +0000

Telegra.ph, an open-source publishing tool by Telegram, not only allows basic HTML writing but also provides an API. My ingenious project involves utilizing Telegra.ph as a pocket database.

// create new database
var mydb = await pocketdb();
console.log("Access Token:", mydb.token);

// create new data
await mydb.set("users", {
  name: "John Doe",
  email: "johndoe@gmail.com"
});

// retrieve the data
var data = await mydb.get("users");
console.log("Data (Users):", data);

I still can't believe how awesome this concept really is. You can literally create a non-local database by just triggering a single function. How cool is that?

Structure

A database consists of multiple data, and each data contains a single JSON-compatible value (key-value structure).

For initialization, you can either use an existing database by providing the access key or create a new database by passing undefined.

await pocketdb(); // create new database
await pocketdb("258a7dcd77c81..."); // use an existing database

After initializing, an instance will return with this structure:

{
  cache: Array,
  token: String,
  list: Array,
  async get: Function,
  async set: Function
}

Codebase

Before returning an instance, we need to find the requested database or create a new one.

if(token != null) {
  // use existing database
} else {
  // create new database
}

According to Telegra.ph, we need to create a new account to be able to write a story. To do this, we fetch the endpoint createAccount.

try {
  var req = await fetch(`https://api.telegra.ph/createAccount?short_name=${Math.random()}`);
  req = await req.json();
} catch(e) {
  throw `Failed to connect (${e})`;
}
if(req.ok != true) throw `Failed to connect (${req.error})`;
// set the access token
token = req.result.access_token;

Creating new database is done. Let's move on initializing an existing database.

According to telegra.ph, the endpoint getPageList will return the list of pages created by the account. We will be using this to list all the stored data.

try {
  var req = await fetch(`https://api.telegra.ph/getPageList?access_token=${token}&limit=200`);
  req = await req.json();
} catch(e) {
  throw `Failed to connect (${e})`;
}
if(req.ok != true) throw `Failed to connect (${req.error})`;

Now, after the initialization, we need to update the cache and list properties.

var cache = [];
var list = [];
(req.result.pages || []).forEach(page => {
  list.push(page.title);
  cache.push({
    title: page.title,
    path: page.path
  });
});

Okay, we're done on initializing an existing database. We will move on to get and set function.

Data relies on pages, so we will use the endpoint createPage to create a page and editPage to modify a page. set handles both modification and creation. Thus, we need to check if the data exists. If it does, we will modify the data; otherwise, we will create a new one. list and cache come in as heroes to reduce HTTP request usage.

async set(key, val) {
  // parse the value
  var content = JSON.stringify([{
    tag: "p",
    children: [JSON.stringify(val)]
  }]);
  if(this.list.includes(key)) {
    // edit a page
    var path = this.cache.find(i => i.title == key).path;
    try {
      var req = await fetch(`https://api.telegra.ph/editPage?access_token=${token}&title=${encodeURI(key)}&path=${path}&content=${encodeURI(content)}`);
      req = await req.json();
    } catch(e) {
      throw `Failed to perform the operation (${e})`;
    }
    if(req.ok != true) throw `Failed to perform the operation (${req.error})`;
    // update the cache
    var that = this;
    this.cache.forEach(function(c, i) {
      if(c.title == key) {
        that.cache[i].content = val;
      }
    });
  } else {
    // create new page
    try {
      var req = await fetch(`https://api.telegra.ph/createPage?access_token=${token}&title=${encodeURI(key)}&content=${encodeURI(content)}`);
      req = await req.json();
    } catch(e) {
      throw `Failed to perform the operation (${e})`;
    }
    if(req.ok != true) throw `Failed to perform the operation (${req.error})`;
    // update the cache and list
    this.cache.push({
      title: req.result.title,
      path: req.result.path,
      content: val
    });
    this.list.push(req.result.title);
  }
}

Now, the last part is get. Let's start by using the endpoint getPage.

async get(key, def, nocache) {
  // if the key does not exist on the list, return the default value
  if(!this.list.includes(key)) return def;
  // find the cache
  var cache = this.cache.find(i => i.title == key);
  // if nocache is not true and the cache exists, use the cache
  if(!nocache && cache?.content != null) {
    return cache.content;
  }
  // get the page
  try {
    var req = await fetch(`https://api.telegra.ph/getPage?access_token=${token}&path=${cache.path}&return_content=true`);
    req = await req.json();
  } catch(e) {
    throw `Failed to perform the operation (${e})`;
  }
  if(req.ok != true) throw `Failed to perform the operation (${req.error})`;
  // parse the content
  var val = JSON.parse(req.result.content[0].children[0]);
  // update the cache
  var that = this;
  this.cache.forEach(function(c, i) {
    if(c.title == key) {
      that.cache[i].content = val;
    }
  });
  return val;
}

And we're done! Now, let's finish it up by combining all the code.

async function pocketdb(token) {
  if (token != null) {
    // use existing database
    try {
      var req = await fetch(`https://api.telegra.ph/getPageList?access_token=${token}&limit=200`);
      req = await req.json();
    } catch(e) {
      throw `Failed to connect (${e})`;
    }
    if (req.ok != true) throw `Failed to connect (${req.error})`;
  } else {
    try {
      var req = await fetch(`https://api.telegra.ph/createAccount?short_name=${Math.random()}`);
      req = await req.json();
    } catch(e) {
      throw `Failed to connect (${e})`;
    }
    if (req.ok != true) throw `Failed to connect (${req.error})`;
    // set the access token
    token = req.result.access_token;
  }
  var cache = [];
  var list = [];
  (req.result.pages || []).forEach(page => {
    list.push(page.title);
    cache.push({
      title: page.title,
      path: page.path
    });
  });
  return {
    cache,
    list,
    token,
    async set(key, val) {
      // parse the value
      var content = JSON.stringify([{
        tag: "p",
        children: [JSON.stringify(val)]
      }]);
      if (this.list.includes(key)) {
        // edit a page
        var path = this.cache.find(i => i.title == key).path;
        try {
          var req = await fetch(`https://api.telegra.ph/editPage?access_token=${token}&title=${encodeURI(key)}&path=${path}&content=${encodeURI(content)}`);
          req = await req.json();
        } catch(e) {
          throw `Failed to perform the operation (${e})`;
        }
        if (req.ok != true) throw `Failed to perform the operation (${req.error})`;
        var that = this;
        this.cache.forEach(function(c, i) {
          if(c.title == key) {
            that.cache[i].content = val;
          }
        });
      } else {
        // create new page
        try {
          var req = await fetch(`https://api.telegra.ph/createPage?access_token=${token}&title=${encodeURI(key)}&content=${encodeURI(content)}`);
          req = await req.json();
        } catch(e) {
          throw `Failed to perform the operation (${e})`;
        }
        if (req.ok != true) throw `Failed to perform the operation (${req.error})`;
        // update the cache and list
        this.cache.push({
          title: req.result.title,
          path: req.result.path,
          content: val
        });
        this.list.push(req.result.title);
      }
    },
    async get(key, def, nocache) {
      // if the key does not exist on the list, return the default value
      if (!this.list.includes(key)) return def;
      // find the cache
      var cache = this.cache.find(i => i.title == key);
      // if nocache is not true and the cache exists, use the cache
      if (!nocache && cache?.content != null) {
        return cache.content;
      }
      // get the page
      try {
        var req = await fetch(`https://api.telegra.ph/getPage?access_token=${token}&path=${cache.path}&&return_content=true`);
        req = await req.json();
      } catch(e) {
        throw `Failed to perform the operation (${e})`;
      }
      if (req.ok != true) throw `Failed to perform the operation (${req.error})`;
      // parse the content
      var val = JSON.parse(req.result.content[0].children[0]);
      // update the cache
      var that = this;
      this.cache.forEach(function(c, i) {
        if (c.title == key) {
          that.cache[i].content = val;
        }
      });
      return val;
    }
  }
}

// Example usage:
(async function() {
  // create new database
  var db = await pocketdb();
  console.log(db);
  // create a data
  await db.set("users", {
    name: "John Doe",
    email: "johndoe@example.com"
  });
  console.log(db);
  // get the data (skip cache by setting true on 'nocache')
  var data = await db.get("users", null, true);
  console.log(data);
  // total http requests: 3
})();

Extra

If you want to add the string compressor that I made, update the code of get and set:

// parse the content
var val = JSON.parse(this.decompress(unescape(atob(req.result.content[0].children[0]))));

// parse the value
var content = JSON.stringify([{
  tag: "p",
  children: [btoa(escape(this.compress(JSON.stringify(val))))]
}]);

Remember to define compress and decompress on the instance!

{
  compress: Function,
  decompress: Function,
  cache: Array,
  token: String,
  list: Array,
  async get: Function,
  async set: Function
}

This extra feature might not effectively compress a string but it will provide a efficient usage as it properly encode the value on the URL.

That's it, thank you for reading this blog. If you are interested, visit the gist of this project.

🗜️Using Cantor-Pairing as a String Compression

delv. — Mon, 22 Jan 2024 16:37:06 +0000

This compression method may have already been invented, but I'll share it nonetheless.

Cantor-Pairing, an algorithm combining two numbers into one, proves effective for string compression. Through experimentation in JavaScript, I discovered a solution.

During compression, characters are grouped into pairs (or singles):

hello => he, ll, o
world! => wo, rl, d!

These pairs convert to paired numbers using corresponding character Unicode. The resulting string includes non-Latin characters like Chinese, hieroglyphics, Arabic, emojis, etc.

function pair(a, b) {
  return 0.5 * (a + b) * (a + b + 1) + b;
}

For decompression, characters' Unicode reverses via the inverse Cantor-Pairing algorithm, returning the original string.

function unpair(n) {
  var w = Math.floor((Math.sqrt(8 * n + 1) - 1) / 2);
  var t = (w ** 2 + w) / 2;
  return [w - (n - t), n - t];
}

For further information about this algorithm, here are the pros, cons, and considerations:

Pros:

Fast processing.
Effective reduction of string size by half.

Cons:

Limited universality due to non-standard characters.

Considerations:

Avoid compressing an already compressed string to prevent incorrect Unicode.
Exercise caution with short strings, as they may lead to corrupted output.

If you are interested, check out the gist.