DEV Community: Claudio Guedes

Do you know what a distributed database is?

Claudio Guedes — Wed, 09 Jul 2025 19:44:26 +0000

I thought I did… But when I started this course in my Master’s in Computer Science, I realized I was completely wrong. I used to think it was something simple and straightforward: just take my centralized database and replicate it across multiple nodes. Okay, that’s one possible approach, but it goes far beyond that.

Let’s say we adopt replication. How can we guarantee data consistency? When an INSERT or UPDATE is received, do I need to propagate it to all nodes? Does it make sense to keep exactly the same data on every node? I think you can already see the kind of challenge we’re facing. The truth is: a distributed database is much more than simple replication, it involves fragmentation, synchronization, fault tolerance, and optimization.

The most common techniques are:

- Horizontal fragmentation (by rows/tuples)
- Vertical fragmentation (by columns)
- Hybrid fragmentation, which combines both

In horizontal fragmentation, for example, imagine a sales table.
Suppose you have 3 customers, and every month you need to generate reports for each one. Your query might look like:

SELECT * FROM customer_sales WHERE customer_id = x;

In this case, it makes sense to split the customer_sales table into three parts, one for each customer, and distribute them across different nodes.

If there are related tables that use JOINs with customer_sales, we apply derived horizontal fragmentation to maintain integrity and query performance.

In vertical fragmentation, the focus is on the columns.
Suppose your application only needs some specific columns from the table. You can divide the table into two fragments: the first containing customer_id, date, and total_value, and the second containing the remaining columns. This improves performance by reducing the amount of data transferred and processed during queries.

The criteria for fragment distribution can vary, for example:
latency, cloud cost, geographic location of users, among others.

With this structure, we can distribute queries, reduce bottlenecks, and execute operations in parallel, making better use of available resources.

Of course, not all database management systems support this type of architecture. When they do, the DBMS is responsible for managing fragmentation, routing queries, and reassembling the data.

At the end of the course, we did a case study using Hive, which allowed us to see in practice how fragmentation and distributed querying actually work.

Despite the high complexity and maintenance effort, some scenarios require a distributed database or similar solutions.

How to use Elasticsearch and Grafana in a local environment

Claudio Guedes — Fri, 21 Mar 2025 10:29:50 +0000

⚙️ Prerequisites:

Docker installed and configured (I'm using wsl and ubuntu)
Api using Elasticsearch for logging (I'm using Node.js)

Create a shared newtwork using Docker

docker network create monitoring

Start the Elasticsearch container

docker run -d --name=elasticsearch --network=monitoring -p 9200:9200 \
  -e "discovery.type=single-node" \
  -e "xpack.security.enabled=false" \
  docker.elastic.co/elasticsearch/elasticsearch:8.12.0

Check if Elasticsearch is running

curl -X GET "http://localhost:9200"

Start the Grafana container

docker run -d --name=grafana --network=monitoring -p 3003:3000 grafana/grafana

Access Grafana using http:localhost:3003. The default user is "admin" and password is "admin" as well.

Check if Grafana can connect to Elasticsearch by following these steps:

docker exec -it grafana sh

curl -X GET "http://elasticsearch:9200"

If the DNS was not resolved, check the shared network again or try using Elasticsearch's IP instead of the DNS.

Now, you can configure Elasticsearch in Grafana using the interface (http:localhost:3003).

Go to: Configuration -> Data Sources -> Add data source -> Elasticsearch

Fill in the information:

URL Connection: http://elasticsearch:9200 or http://ip-addess:9200
Elasticsearch details according to your API configuration. ⚠️Remember that you should run your API first to generate logs and to register an index.

✅ Ok! to view your logs, go to 'Explore' in Grafana.

❌ If problems happen, you can investigate:

You can check the available indexes in Elasticsearch using:

curl -X GET "http://localhost:9200/_cat/indices?v"

To see your specific index configuration (replace with your API's index name):

curl -X GET "http://localhost:9200/<api-index-name>/_mapping?pretty"

To see if logs are beeing registered in Elasticsearch:

http://localhost:9200/_all/_search?pretty

Binary Search in Practice

Claudio Guedes — Wed, 18 Dec 2024 11:24:17 +0000

When working with a large input dataset, it may be necessary to adopt different algorithms. Imagine that you need to search in a large list of numbers, for example, 1 million numbers. If you adopt a solution to iterate through the entire list of numbers one index at a time with a conventional loop until you find the target element, in the worst case, this would require 1 million searches (linear time complexity O(n)).

Now, by adopting binary search, you won't need to search more than 19 times in the worst case (logarithmic time complexity O(log(n))), and this number doesn't grow much even if your input data increases significantly.

However, this is only possible with ordered lists.

If you want to know more about this topic, I found a good material on W3Schools: https://www.w3schools.com/dsa/dsa_algo_binarysearch.php.

I also included a simple example of a binary search implementation.

function binarySearch(value, list){
    let left = 0; //start of the list
    let right = list.length - 1; //end of the list

    while ( left <= right ) {
        const middle = Math.floor(( left + right ) / 2); //middle of the list
        const potentialValue = list[middle]; //potential value starts in the middle

        if (value === potentialValue){ //is the potential value what you are looking for?
            return middle; //if so, return the index of the list
        } else if (value < potentialValue){ //is this value smaller than the potential value (middle of the list)?
            right = middle - 1; //if so, it's to the left, and you can ignore everything to the right of the middle
        } else {
            left = middle + 1; //if not, it's to the right, and you can ignore everything to the left of the middle
        }
    }
    //the whole process happens again... until the value you are looking for is found
    return false;
}

Difference between return and return await in JavaScript

Claudio Guedes — Fri, 13 Dec 2024 17:10:13 +0000

You might be thinking that these two approaches are the same. But there is a crucial difference between return and return await.

When we deal with promises, such as database queries, we commonly use await. For example:

async function getUserById(userId) {
  const user = await userRepository.findById(userId);
  return user;
}

However, in this case, it is not strictly necessary to use await. We can write it like this:

function getUserById(userId) {
  return userRepository.findById(userId);
}

Both options will work normally.

When we have a try/catch block, the behavior is different, and if you're unaware of this, it can cause unexpected errors.

function getUserById(userId) {
  try {
    return userRepository.findById(userId);
  } catch (error) {
    console.error(error.message);
  }
}

If an error occurs in findById, it won't be caught, and this will likely become a problem. This is where we need to use return await.

async function getUserById(userId) {
  try {
    return await userRepository.findById(userId);
  } catch (error) {
    console.error(error.message);
  }
}

Now, we are safe, and any error will fall into the catch block.

In summary, if we need to handle and process errors in a catch block, we must use return await to ensure the application operates correctly.

What is a Turing Machine, exactly?

Claudio Guedes — Tue, 10 Dec 2024 23:32:12 +0000

When we think about the concept of an algorithm, we are essentially talking about something that can be interpreted as a Turing Machine, and vice versa.

A Turing Machine is a formal and abstract model that represents a computer in its most primitive form. It consists of three main elements:

A set of states, which defines the different steps in the processing.
A tape (or memory), which can be understood as an infinite list where data is read, written, and processed.
Transition functions, which determine how the machine changes states and interacts with the tape (by reading or writing data and moving left or right).

With these elements, we can create algorithms using a Turing Machine to interpret and process data based on an initial input.

The most fascinating thing is that, although modern computers are incredibly advanced, they can all be conceptually reduced to a simple Turing Machine. Of course, the processing would be extremely slow, but the principle remains valid.

This model was created by Alan Turing in 1936 and remains, to this day, the theoretical foundation of computing. Turing's work demonstrated that a Turing Machine can solve any computational problem that is computable, as long as there is unlimited time and memory.

Recently, I had to study this topic during my master’s program, and it has completely transformed my understanding of algorithms. Not only did it enhance my logical reasoning, but it also helped me gain a deeper understanding of how code is actually processed.

I asked to Chat GPT to create a Turing Machine image, and he gave me this back 🤔

Simple clean code #1

Claudio Guedes — Tue, 26 Nov 2024 20:20:56 +0000

Change this:

if (user.active === true && user.age >= 18 && user.email !== null && user.email !== undefined && externalParams === true) return true;

To this:

const { active: userIsActive, age: userAge, email: userEmail } = user;

const minimalAge = 18;
const userAgeIsValid = userAge >= minimalAge;
const userHasConditionsToRegister = userIsActive && userAgeIsValid && userEmail && externalParams;

if (userHasConditionsToRegister) return true;

You might be thinking, "But you've increased the code by a lot, before, I only had one line!" And yes, you're absolutely right! However, fewer lines of code aren't always better than more lines.

When working with other developers and frequently maintaining the codebase, small details like the ones I've shown can make a big difference. In just a few seconds, anyone can understand the logic and rules behind the code. Additionally, if you need to add another condition, it becomes easy and clear to do so.

Shallow vs Deep Copy of Objects in JavaScript

Claudio Guedes — Fri, 04 Oct 2024 14:13:21 +0000

When we need to copy an object to another object, we generally use something like this:

const mainObject = { id: 1 };
const secondaryObject = { ...mainObject };

But this only works for copying the shallow properties of the object. If we have a case like the following code, the scenario changes:

const mainObject = { id: 1, user: { name: 'John Doe', age: 30 } };
const secondaryObject = { ...mainObject };

The property user won't be copied; it will still be related to mainObject. So, if we alter the user property, it will also affect mainObject. To solve this, we can do the following:

const mainObject = { id: 1, user: { name: 'John Doe', age: 30 } };
const deepCopy = JSON.parse(JSON.stringify(mainObject));

Now, we have a deep copy of mainObject, with two distinct memory addresses.

How to anonymize properties in an object using recursion

Claudio Guedes — Tue, 01 Oct 2024 17:13:32 +0000

Recently, I needed to handle logging of input and output data in my API. However, I encountered a problem: some properties contained sensitive data that couldn't be displayed in the logs. It's straightforward to handle this when dealing with a simple object, but when dealing with a nested object with multiple levels, things get more complex. This is where recursion comes in. Using recursion, it's possible to handle this efficiently in linear time O(n). Here's the code:

const sensitiveFields = ['password', 'email', 'userCode'];

function handleSensitivesFields(data) {
  if (typeof data !== 'object' || data === null) {
    return data;
  }

  for (const key in data) {
    if (sensitiveFields.includes(key)) {
      const value = data[key];

      if (typeof value === 'string') data[key] = createMask(value.length);
    }

    if (typeof data[key] === 'object') handleSensitivesFields(data[key]);
  }
}

Understanding data structures is essential for improving your code's performance

Claudio Guedes — Fri, 13 Sep 2024 17:07:48 +0000

Often, most developers focus on learning new languages, frameworks, and libraries. However, the most important thing is to understand the fundamentals (which are many) before jumping into new hype technologies. Understanding the time and space complexity of your code, the data structures you're using, and so on is crucial.

In languages like JavaScript, we often find it easy to use HOFs like filter, map, and reduce, and we don't always analyze how these might increase the complexity of our code. Of course, we don't always need to worry about this — in certain situations, we're dealing with small arrays, and using a for loop inside another for doesn't affect the final result. However, when working with large datasets, your approach will make a significant difference and will definitely impact response times and resource consumption.