DEV Community: Alessandro Foglia

How I implemented a DHT with the Chord protocol in C

Alessandro Foglia — Mon, 03 Mar 2025 20:16:29 +0000

Introduction
The Idea
The Actual Implementation
- DHTs
- Introduction to Chord Algorithm
- My Own Node/Data Implementation
- The find_successor Function
- Create/Join a Network
- The Stabilization Process
  - fix_fingers()
  - stabilize() and notify()
  - check_predecessor()
  - Complete Routine
Additional Resources and References
Who am I?
Arcade by Hack Club 🟧

Introduction

Before talking about my experience, I wanted to specify that this post can be read as both a report of my personal experience and a tutorial for implementing the Chord protocol in C. Enjoy your read!

I recently created a Peer-to-Peer file sharing system (you can find the full repo here, and I'd really appreciate if you gave it a ⭐ :D) in C and I wanted to share some details about why I started this project, how I managed to implement it and how it made me a better coder overall.

The idea

I'm a high-school student, a Web Developer and specifically a Cloud computing enthusiast. For quite some time now I've begun approaching to the C language, in order to really understand how computers work at the low level and how to work with them effectively. For this reason, I decided to start diving into some low level networking projects (I also created an HTTP protocol implementation and a simple chat app in C) and surely this one was the hardest of them all!

Initially, I began implementing a distributed network of unordered peers as I was able to do with the knowledge I got by coding the aforesaid projects. Soon, however, I realized that the approach I unknowingly chose was extremely inefficient and wouldn't work for large networks. Therefore, I started to search for a more optimized solution and I stumbled upon Distributed Hash Tables (DHTs) and the Chord algorithm. As a professional-high-schooler, the first thing I did was asking ChatGPT "What are the benefits of implementing a DHT into a p2p application?"... it answered me with big words like "decentralization", "fault tolerance", "efficiency" and "robustness"; however it also mentioned a downside: "complexity in implementation". And I can say, as a student with little to no ability in implementing even simple data structures, that it was in fact telling the truth 😅.

The actual implementation

DHTs

So, exactly... what is a distributed hash table?
As the name says, a distributed hash table (DHT) is a hash table which is distributed across various nodes in the network. By utilizing consistent hashing, any node can lookup the location (e.g. IP address and port) of the node that contains the value of a certain key (then contact it and get the value).

Introduction to Chord algorithm

Then, how does Chord effectively create a DHT?
Chord (an algorithm introduced in 2001 as one of the four original DHT protocols) creates a ring shaped network in which each node has a specific position based on an ID, generated through a hash function (I personally used the SHA-1 function). Each node has a successor and a predecessor: the successor is the next node in the ring going in clockwise direction, the predecessor is counter-clockwise. The maximum amount of nodes in the ring is 2^M where M is the amount of bits in the ID (if you're using the SHA-1 function, M is 160).

        Hash(Key) = 125
           ↓
    n1 ---------- n2 
  (100)          (200)
    |              |
    |              |
    |              |
    n4 ---------- n3
  (400)          (300)

The final aim of the system is to implement a find_successor(hash(key)) function to lookup the location of a key in the DHT. The function would return the location of the node (peer) responsible for that key.

    Hash(Key) FindSuccessor(Hash(Key))
        ↓         ↓
    n1 ---------- n2 
  (100)          (200)
    |              |
    |              |
    |              |
    n4 ---------- n3
  (400)          (300)

Credits for these cool illustrations go to @arush15june
For lookup, Chord algorithm suggests what's called a finger table, a table containing M nodes' data, to avoid a linear search in favor of a faster method.

My Own Node/Data implementation

From this point, I will display the pseudocode and, below, a simplified version of my C implementation

Specifically, here's how I structured my Node:

typedef struct Node {
    uint8_t id[20]; // SHA-1 hash
    char ip[16]; // e.g. 127.0.0.1
    int port; // e.g. 5000
    struct Node *successor; // node's successor
    struct Node *predecessor; // node's predecessor
    struct Node *finger[M]; // array of nodes (finger table)
    struct FileEntry *files; // files which the node is responsible for
    struct FileEntry *uploaded_files; // files uploaded by the node
    int sockfd; // file descriptor of node's socket
} Node;

and here's the FileEntry struct:

typedef struct FileEntry {
    uint8_t id[20]; // hash key of the file (used for lookup)
    char filename[256];
    char filepath[512];
    char owner_ip[16];
    int owner_port;
    struct FileEntry *next;
} FileEntry;

In my implementation, each node only stores file metadata, in order for a peer looking for a file to download it directly from the node who decided to share it originally. Here's how I structured my lookup flow:

- Node (A) requests file to responsible node (B)
- B responds with FileEntry object (sends it back to A)
- A contacts C (at file.owner_ip:file.owner_port) and downloads the file.

The `find_successor` Function

As I previously said, the most important function of the algorithm is the find_successor function. The function initially checks if the responsible node is the local one, by comparing its ID to its successor's ID and to the given ID. If it isn't, the node starts to search the local finger table for the highest predecessor of ID.

Here's the code for the find_successor function:

n.find_successor(id)
    // It is a half closed interval.
    if id ∈ (n, successor] then
        return successor
    else
        // forward the query around the circle
        n0 := closest_preceding_node(id)
        return n0.find_successor(id)

n.closest_preceding_node(id)
    for i = m downto 1 do
        if (finger[i] ∈ (n, id)) then
            return finger[i]
    return n

// checks if id is in the interval (a, b)
int is_in_interval(const uint8_t *id, const uint8_t *a, const uint8_t *b) {
    if (memcmp(a, b, HASH_SIZE) < 0) {
        return memcmp(id, a, HASH_SIZE) > 0 && memcmp(id, b, HASH_SIZE) < 0;
    }
    return memcmp(id, a, HASH_SIZE) > 0 || memcmp(id, b, HASH_SIZE) < 0;
}

Node *find_successor(Node *n, const uint8_t *id) {
    if (memcmp(id, n->id, HASH_SIZE) > 0 && memcmp(id, n->successor->id, HASH_SIZE) <= 0) {
        return n->successor;
    }

    const Node *n0 = closest_preceding_node(n, id);

    // Avoid sending message to itself
    if (n0 == n) {
        return n->successor;
    }

    // send a FIND_SUCCESSOR message to n0
    send_message(n, n0->ip, n0->port, "FIND_SUCCESSOR");

    // receive the successor's info
    const Node response = receive_message();

    Node *successor = n->successor;
    memcpy(successor->id, response->id, HASH_SIZE);
    strcpy(successor->ip, response->ip);
    successor->port = response->port;

    return successor;
}

Node *closest_preceding_node(Node *n, const uint8_t *id) {
    // search the finger table in reverse order to find the closest node
    for (int i = M - 1; i >= 0; i--) {
        if (is_in_interval(n->finger[i]->id, n->id, id)) {
            return n->finger[i];
        }
    }
    return n;
}

Create/Join a Network

A node can create a new ring by setting its predecessor to nil/NULL and its successor to itself, like this:

n.create()
    predecessor := nil
    successor := n

void create_ring(Node *n) {
    n->predecessor = NULL;
    n->successor = n;
}

If a node wants to join an existing ring it needs to know the location of at least another node in that network.

n.join(n0)
    predecessor := nil
    successor := n0.find_successor(n)

void join_ring(Node *n, const char *existing_ip, const int existing_port) {
    // send a JOIN message to the existing node
    send_message(n, existing_ip, existing_port, "JOIN");

    // the existing node will respond with the new node's successor
    Message response = receive_message();

    // create a new node for the successor
    Node *successor = create_node(response->ip, response->port);

    // set the new node's successor to the one returned by the existing node
    n->predecessor = NULL;
    n->successor = successor;
}

The Stabilization Process

At this point, the algorithm stumbles upon a problem. We need a way to ensure that the structure of the network remains the same, even after a node joins or leaves. The network has to be dynamically updated to let nodes join the network at will and stale nodes be removed from the network and stabilize the ring again. We can solve this through a stabilization routine. We need to regularly verify that:

the current successor is still its successor and no new node has joined in between them;
the predecessor is still alive;
the finger table is updated.

We can do this with the functions fix_fingers(), stabilize(), notify() and check_predecessor():

`fix_fingers()`

// called periodically. refreshes finger table entries.
// next stores the index of the finger to fix
n.fix_fingers()
    next := next + 1
    if next > m then
        next := 1
    finger[next] := find_successor(n+2next-1);

void fix_fingers(Node *n, int *next) {
    *next = (*next + 1) % M;
    Node *finger = find_successor(n, n->finger[*next]->id);
    n->finger[*next] = finger;
}

`stabilize()` and `notify()`

// called periodically. n asks the successor
// about its predecessor, verifies if n's immediate
// successor is consistent, and tells the successor about n
n.stabilize()
    x = successor.predecessor
    if x ∈ (n, successor) then
        successor := x
    successor.notify(n)

n.notify(n0)
    if predecessor is nil or n0∈(predecessor, n) then
        predecessor := n0

/*
 * Called periodically. Asks the successor for its predecessor,
 * verifies it to be itself. If not, its verified that the new
 * node lies between itself and successor. Therefore, the new
 * node is set as the new successor. The new node is also notified
 * of its new predecessor.
 */
void stabilize(Node *n) {
    // send a STABILIZE message to the successor
    send_message(n, n->successor->ip, n->successor->port, "STABILIZE");

    // receive the successor's predecessor to verify
    Message response = receive_message();

    // x is the successor's predecessor
    Node *x = create_node(response->ip, response->port);

    // if x is in the interval (n, successor), then update the successor
    if (is_in_interval(x->id, n->id, n->successor->id)) {
        n->successor = x;
    }

    // notify the new successor to update its predecessor
    notify(n->successor, n);
}

void notify(Node *n, Node *n_prime) {
    // send a NOTIFY message to n
    // notify that n_prime might be its new predecessor
    send_message(n_prime, n->ip, n->port, "NOTIFY");

    if (n->predecessor == NULL || is_in_interval(n->id, n->predecessor->id, n->id)) {
        n->predecessor = n_prime;
    }
}

`check_predecessor()`

// called periodically. checks whether predecessor has failed.
n.check_predecessor()
    if predecessor has failed then
        predecessor := nil

void check_predecessor(Node *n) {
    if (n->predecessor == NULL) {
        return;
    }
    // send a heartbeat message to the predecessor
    // if the predecessor does not respond, it has failed -> set it to NULL
    if (send_message(n, n->predecessor->ip, n->predecessor->port, "HEARTBEAT") < 0) {
        n->predecessor = NULL;
    }
}

Complete routine

I set up a multithreaded environment (with the pthread API) and created a thread that runs this routine every 15 seconds (as suggested in the official Chord paper):

void *node_thread(void *arg) {
    Node *n = (Node *) arg;
    while (1) {
        stabilize(n);
        fix_fingers(n, &(int){0});
        check_predecessor(n);
        sleep(15);
    }
}

Additional Resources and References

If you want to dive deeper into how DHTs and the Chord algorithm work, I can suggest you a specific set of resources I found particularly useful:

My Peer-to-Peer File Sharing System (I'd really appreciate if you gave it a ⭐ :D)
Chord (peer-to-peer) - Wikipedia
Chord official paper
Chord protocol implementation in Golang - Practical Papers

Who am I?

I am an Italian high-school student who is interested in Web Development 🧙‍♂️. If you'd like to support me, you can follow me here and on my GitHub, I would really appreciate it 💜

Arcade by Hack Club 🟧

I wanted to thank Hack Club and GitHub Education for the motivation they give us high-schoolers to code, to learn new things and to create amazing projects together. If you are a high-schooler and a programmer, I highly suggest you to join Hack Club in order to find more people with the same passions as you and to apply for the GitHub Education pack to get a series of tools to elevate your coding skills. I'm sure you won't regret it! 🚀

STOP using ANY in TypeScript RIGHT NOW. 🟦🧙‍♂️

Alessandro Foglia — Thu, 26 Oct 2023 04:00:00 +0000

Hello coders! 🧙‍♂️

How many times in your career have you used the any type in TypeScript? Well, most people use this special type everyday, however what if I told you you should completely stop using it?

That's right. As a TypeScript developer, you should stop using any. Let's dive deeper into this and I'm sure I'll convince you at the end and you'll become a real TypeScript lover. 💙

any type in TypeScript

The any type makes it into the category of "primitive types" in TypeScript. These are number, string, boolean, BigInt (from ES2020), symbol (not very common), undefined, null, void, never, unknown and lastly any.

However any is a special type, since it can be used when you don't want a particular value to cause typechecking errors.

TypeScript Documentation says:

When a value is of type any, you can access any properties of it (which will in turn be of type any), call it like a function, assign it to (or from) a value of any type, or pretty much anything else that’s syntactically legal.

And that's the reason why, unless you have some real issue, like libraries with no typing or old JavaScript code, you should never use any.

The unsafety of any

Since any type prevents any type-check, you can do literally whatever you want to do with it. E.g.:

let bar: any = { foo = 1 };
bar.foo; // Ok
bar.hello; // Ok ?
bar(); // Ok ??
bar.trim(); // ok???
new bar(); // ok...
bar[0][1][4]; // what the hell??

This will not throw any compiler error and, unless really specific cases, it's absolutely wrong, since it totally destroys TypeScript purpose, type checking.

The type-safe any: unknown

Fortunately, for 100% code type-safety, there's an alternative for any, the unknown type.

The unknown type works the same as any, but with compiler errors if you don't specify the exact type you expect. For clarity, here's an example:

let safeBar: unknown = "Hello world";
safeBar.hello; // Error thrown
safeBar(); // Error thrown
// etc...

This could be useful in case you literally don't know what type a variable is. Check this other example:

function parseApiResponse(response: string): unknown {
    try {
        return JSON.parse(response);
    } catch (error) {
        return null;
    }
}

const apiResponse = '{ "name": "John", "age": 30 }';
const parsedData = parseApiResponse(apiResponse);

if (typeof parsedData === 'object') {
    // Now, you can safely access properties without TypeScript errors
    const name = (parsedData as { name: string }).name;
    const age = (parsedData as { age: number }).age;

    console.log(`Name: ${name}, Age: ${age}`);
} else {
    console.log('Failed to parse API response');
}

In this example, the "parseApiResponse" function returns data of type "unknown" because the actual structure of the data is not known at compile time. You can use type assertions (e.g., (parsedData as { name: string }).name) to access properties safely when you've checked the type. This way, you maintain type safety even when dealing with data of an unknown structure.

How to prevent any in your code

You can start preventing any in your code by modifying your tsconfig.json file. Set the noImplicitAny property to true, to check if no type annotations are present for a variable. Normally, in that case, TypeScript will fall back to a type of any for a variable when it cannot infer the type.

{
  "compilerOptions": {
    /* ... */
    "noImplicitAny": true,
    /* ... */
  }
}

Check this example:
With noImplicitAny: false:

function fn(s) {
  // No error?
  console.log(s.subtr(3));
}
fn(42);

With noImplicitAny: true:

function fn(s) {
// Error: Parameter 's' implicitly has an 'any' type.
  console.log(s.subtr(3));
}

If you use EsLint as your main linter, you may also install @typescript-eslint plugin to get the noExplicitAny rule. Example:

function fn(s: any): any {
// Error: Unexpected any. Specify a different type. - eslint@typescript-eslint/no-explicit-any
  console.log(s);
  return s;
}

Who am I?

I am an Italian high-school student who is interested in web-dev 🧙‍♂️. If you'd like to support me, you can follow me here and on my GitHub, I would really appreciate it 💜

Unlocking the Power of JavaScript Generators 🦾⏭️

Alessandro Foglia — Tue, 03 Oct 2023 04:00:00 +0000

Hello coders! 🧙‍♂️

Have you ever heard of Generator Functions in JavaScript?
These were introduced in 2015, with the ES6 update and they allow you to create iterators in a more convenient and expressive way.

Generator functions have a pretty weird syntax. You can declare a generator function with the function keyword followed by an asterisk (*). 🤔

function* myGenerator() {
  // generator code here
}

Note that unlike normal functions, you can't declare a generator function with arrow syntax. ⚠️

Inside a generator function, you can use the yield statement to produce a value that can be iterated over.
The generator function's execution can be paused and resumed as needed. This makes it suitable for dealing with asynchronous operations, such as fetching data from a server.

We can call the next() method on the generator to run the execution until the nearest yield statement.

function* myGenerator() {
  yield 1;
  yield 2;
  return 3;
}

const generator = myGenerator();
console.log(generator.next()); // { value: 1, done: false }
console.log(generator.next()); // { value: 2, done: false }
console.log(generator.next()); // { value: 3, done: true }

As we can see, the next() method returns a object with two properties: value (the value yielded in the function) and done (true if the function returned a value with return instead of yield, since it's now finished). ⏭️

// In TypeScript 🟦
interface NextReturns {
  value: any; // or unknown, for TypeScript lovers ;D
  done: boolean;
}

Let's now see some real world examples for this strange feature! 😊
We could start by creating a function that generates and infinite sequence of numbers (useful when you need to assign IDs to objects or classes for example):

function* infiniteNumbers() {
  let num = 1;
  while (true) {
    yield num++;
  }
}

const numGenerator = infiniteNumbers();
console.log(numGenerator.next().value); // 1
console.log(numGenerator.next().value); // 2
console.log(numGenerator.next().value); // 3
// You can keep calling numGenerator.next() to get the next number. ♾️

Generator functions can produce sequences with conditions too. For example, you can create a generator that yields a sequence of numbers from a start to a certain limit.

function* generateSequence(start, end) {
  for (let i = start; i <= end; i++) yield i;
}

const sequenceGenerator = generateSequence(1, 5);

for (const value of sequenceGenerator) {
  console.log(value);
}
/* 1
   2
   3
   4
   5 
*/

We could use generators to create a function that automatically implements pagination with asynchronous data fetching:

async function* paginateData() {
  let page = 1;
  while (true) {
    const data = await fetchData(page);
    if (data.length === 0) break;
    yield data;
    page++;
  }
}

const dataPaginator = paginateData();

(async () => {
  for await (const chunk of dataPaginator) {
    // Process and display the data chunk
    console.log(chunk);
  }
})();

There are a lot of other cases in which generators can be useful, but from now I'll leave playing with it to you, hoping you loved this weird feature as much as I did when I learnt it for the first time 😍.

Some nice resource I found if you want to dive deeper:

Who am I?

I am an Italian high-school student who is interested in web-dev 🧙‍♂️. If you'd like to support me, you can follow me here and on my GitHub, I would really appreciate it 💜

I Stopped using Google and here's why.

Alessandro Foglia — Sun, 01 Oct 2023 21:10:36 +0000

Introduction
- Is there something I can do to be anonymous on the internet?
1 - Use a privacy-first browser
- Why I use Brave Browser
2 - Use a privacy-first search engine
3 - Use a VPN
4 - (Advanced) Don't use emails
Conclusion

Introduction

I recently got interested in privacy and anonymity on the internet and I found out something mind-blowing.
The sad truth of the internet is the fact that, by default, you get constantly tracked. That's because in most cases, mostly if you are not taking the correct precautions, even big companies like Google or Microsoft store and sell all of your information and movements around the internet to advertising companies, that use that data to sell products to you, and to governments, that always try to track you.

Most of the people justify themselves by saying "But I have nothing to hide!" and I answer them with a famous quotation of Edward Snowden:
"Arguing that you don't care about privacy because you have nothing to hide is no different than saying you don't care about free speech because you have nothing to say."

It's like someone that watches you using your PC 24 hours a day and records all of your activity, the things you like, your interests and more.
Isn't that just creepy?

Is there something I can do to be anonymous on the internet?

Obviously, there are some ways to enhance your privacy on the internet without compromising your comfort and here are some.

1 - Use a privacy-first browser

Even though most people use Google Chrome or Microsoft Edge as default browser, it is really recommended to use any privacy-first browser, like Mozilla Firefox, Brave Browser or DuckDuckGo Browser.
Between these three, I chose and started using Brave Browser for many reasons:

Why I use Brave Browser

Brave Browser (like Firefox and DuckDuckGo) doesn't track your activity at all.
It is Chromium Based, which means that it's based on the open-source Chromium project, the same of Chrome and Edge, so it's easier to get used to it.
It has an integrated ad-blocker and tracks-blocker: many think of this feature as unethical, but I personally like automatic ad-blocking, since I would use an ad-blocker anyway. Also it automatically blocks all kinds of tracks from websites.
It's the easiest to set up for an average user, as most of the privacy features it provides are already packed in and ready to use.
You can earn BATs using Brave: Brave gives you a cryptocurrency named BAT (Basic Attention Token) for using their browser and I think it's actually a nice way to convince people to switch.

2 - Use a privacy-first search engine

A search engine is a software system that finds web pages that match a web search. The most popular ones are Google Search and Bing Search (Now with Bing AI) for sure.
The sad thing is that these two are probably the most dangerous ones too: as proof, you can look at how much data Google sends and receives about you in one single search. To do that, you can try to open up DevTools in Google Chrome with F12, go to Network tab, enable the "Preserve log" option and try to search something.

Some nice privacy-first search engines are DuckDuckGo (my favorite one, since it's the most customizable and it promises to never create a personal history of your searches and to never collect information about your computer that might be used to identify you), Brave Search (also keeps no record of your search history), Searx and Startpage.

3 - Use a VPN

A VPN, or Virtual Private Network, is a technology that allows you to create a secure and encrypted connection over the internet. A VPN works by creating a secure and encrypted tunnel between your device (such as your computer or smartphone) and a remote server operated by the VPN provider. When you connect to the VPN, your internet traffic is routed through this encrypted tunnel, making it unreadable to anyone trying to intercept it, including hackers and your internet service provider. The VPN server can be located in a different region or country, allowing you to mask your IP address and appear as though you're browsing from that location, which can help you bypass geo-restrictions and enhance your online privacy and security.

There are a lot of trusted VPNs online, like NorthVPN, ExpressVPN or Surfshark VPN. The one I use is Proton VPN, made by the Proton company (specialized privacy-first services), since it's considered the best of the best out there, having however a nice free plan that lets you start playing with it.

However there are disadvantages in constantly using a VPN, like slower internet speed.
I personally use VPNs only in case I want to get real anonymity on the internet (for example, when I surf the deep web).

4 - (Advanced) Don't use emails

When emails were born, privacy and security wasn't such a problem in the internet, so no privacy-safe method was implemented in them, resulting them to be highly unsecure nowadays.

Emails work by sending electronic messages through various servers and networks. They lack inherent privacy because the content is often stored on servers, making it susceptible to surveillance or data breaches. To enhance email privacy, try to use end-to-end encrypted email services like ProtonMail or Tutanota, employ strong, unique passwords, enable two-factor authentication, avoid sharing sensitive information via email, and regularly update your email client and plugins to patch security vulnerabilities. Additionally, be cautious about clicking on links or downloading attachments from unknown senders to prevent phishing attacks and malware.

Conclusion

The world of the internet is a vast and interconnected space, but it comes with its own set of challenges, particularly concerning privacy and anonymity. It's crucial to recognize that online tracking and data collection are pervasive, often conducted by large companies and even governments. The notion that "having nothing to hide" justifies relinquishing your privacy is a notion that needs to be challenged.

Fortunately, there are proactive steps you can take to safeguard your online privacy without sacrificing your comfort. The recommendations provided, such as using privacy-first browsers like Brave, adopting search engines like DuckDuckGo, employing VPNs for encrypted connections, and considering secure email services like ProtonMail, offer effective ways to enhance your online anonymity.

Remember, being proactive about your online privacy is not just about protecting your secrets; it's about safeguarding your fundamental right to privacy in an increasingly digital world.

Let me know what you think about this!

Who am I?

I am an Italian high-school student who is interested in web-dev 🧙‍♂️. If you'd like to support me, you can follow me here and on my GitHub, I would really appreciate it 💜

Set up a Modern MERN Application in less than a minute.

Alessandro Foglia — Sat, 30 Sep 2023 21:50:54 +0000

TL;DR -> Installation

Hello coders! 🧙‍♂️

Since I am now building many different project that often need a similar initial setup, I created two modern templates to accelerate my work.

I started downloading pnpm, a fast, disk space efficient package manager.

Front-End

For the Front-End template, I created a Vite React app with Typescript 💙. Vite is a build tool used for faster and leaner development experience for modern web projects. Then I added support for most of the best modern technologies some might want to use in their project.

For example, I added Docker 🐋 support, with convinient npm scripts in the package.json to simplify build, run and development with it.

CSS ⁉️

I also added TailwindCSS, a utility-first CSS framework for rapidly building custom user interfaces and I paired it with the HeadlessUI library, made of completely unstyled, fully accessible UI components that work perfectly with Tailwind 😍. I personally find Tailwind absolutely amazing, since it simplifies a front-end dev work at the point that CSS doesn't feel bad anymore! 😄

Progressive Web App 😱

But the most important thing is probably the support for PWA (Progressive Web App). As a developer, it often feels boring to manually set up a PWA, but with this template, everything is packed-up and production ready! 🤩🤩

Back-end

For the Back-End template, I created a Node.js app and added basic features, like express.js and cors.

I also added support for mongoose.js, an elegant MongoDB object modeling library for Node.js.

Obviously, Docker 🐋 and the custom npm scripts are supported in the Back-End template too, so you will no longer be worrying about any initial Docker setup.

Linters? ✨

In both template EsLint and Prettier are already configured, so that you just need to specify how you want your code to be formatted and linted in the .prettierrc and .eslintrc.cjs files. ✨✨

I completed publishing to npm two npx packages to easily scaffold your next projects 🧙‍♂️.

Installation 🧙‍♂️

We finally got to the good part!
Here are the repositories for both the templates I created:
Front-end, Back-end

You can run these commands in your terminal to set up everything in a minute!

# Front-end (2nd argument to specify the location)
$ pnpx create-modern-react-pwa my-app-frontend

# Back-end (2nd argument to specify the location)
$ pnpx create-modern-node-app my-app-backend

If you don't like using pnpm, here are the same commands with npm:

# Front-end (2nd argument to specify the location)
$ npx create-modern-react-pwa my-app-frontend

# Back-end (2nd argument to specify the location)
$ npx create-modern-node-app my-app-backend

Who am I?

I am an Italian high-school student who is interested in web-dev 🧙‍♂️. If you'd like to support me, you can follow me here and on my GitHub, I would really appreciate it 💜

DEV Community: Alessandro Foglia

How I implemented a DHT with the Chord protocol in C

Table of Contents

Introduction

The idea

The actual implementation

DHTs

Introduction to Chord algorithm

My Own Node/Data implementation

The find_successor Function

Create/Join a Network

The Stabilization Process

fix_fingers()

stabilize() and notify()

check_predecessor()

Complete routine

Additional Resources and References

Who am I?

Arcade by Hack Club 🟧

STOP using ANY in TypeScript RIGHT NOW. 🟦🧙‍♂️

Hello coders! 🧙‍♂️

any type in TypeScript

The unsafety of any

The type-safe any: unknown

How to prevent any in your code

Who am I?

Unlocking the Power of JavaScript Generators 🦾⏭️

Hello coders! 🧙‍♂️

Who am I?

I Stopped using Google and here's why.

Table of contents

Introduction

Is there something I can do to be anonymous on the internet?

1 - Use a privacy-first browser

Why I use Brave Browser

2 - Use a privacy-first search engine

3 - Use a VPN

4 - (Advanced) Don't use emails

Conclusion

Who am I?

Set up a Modern MERN Application in less than a minute.

TL;DR -> Installation

Hello coders! 🧙‍♂️

Front-End

CSS ⁉️

Progressive Web App 😱

Back-end

Linters? ✨

Installation 🧙‍♂️

Who am I?

The `find_successor` Function

`fix_fingers()`

`stabilize()` and `notify()`

`check_predecessor()`