DEV Community: Luis Filipe Pedroso

Formatting Relative Time in Swift: Quick Guide

Luis Filipe Pedroso — Thu, 23 Oct 2025 13:36:07 +0000

In Swift, there are several ways to work with date formatting, such as DateComponentsFormatter and RelativeDateTimeFormatter.

DateComponentsFormatter

Formats a time interval (duration) between two points in time.
It doesn’t know whether it’s past or future, only the length of time.
Example outputs: 2d, 1 hour, 5 minutes, 3h 15m
Use it for: durations, timers, countdowns, video lengths, etc.

RelativeDateTimeFormatter

Formats a date relative to another date, automatically handling past or future.
Adds natural language like “ago” or “in”.
Example outputs: 2 days ago, in 3 hours, yesterday, tomorrow
Use it for: human-readable time expressions like “5m ago” or “in 2d”.

Quick Comparison

Purpose	Formatter	Example
Duration (no direction)	`DateComponentsFormatter`	`2d`, `3h 15m`
Relative time (with context)	`RelativeDateTimeFormatter`	`2 days ago`, `in 3 hours`

Example of usage

DateComponentsFormatter:

private var abbreviatedFormatter: DateComponentsFormatter {
    let formatter = DateComponentsFormatter()
    formatter.allowedUnits = [.minute, .hour, .day]
    formatter.unitsStyle = .abbreviated
    formatter.maximumUnitCount = 1
    return formatter
}

func asAbbreviatedString() -> String {
    let from = Date().timeIntervalSince(self)
    return abbreviatedFormatter.string(from: from) ?? ""
}

RelativeDateTimeFormatter:

private var shortFormatter: RelativeDateTimeFormatter {
    let formatter = RelativeDateTimeFormatter()
    formatter.unitsStyle = .full
    return formatter
}

func asShortString() -> String {
    return shortFormatter.localizedString(for: self, relativeTo: Date())
}

Pro tip

Create an extension and add these shorthand functions to it.

extension Date {

    private var abbreviatedFormatter: DateComponentsFormatter {
        let formatter = DateComponentsFormatter()
        formatter.allowedUnits = [.minute, .hour, .day]
        formatter.unitsStyle = .abbreviated
        formatter.maximumUnitCount = 1
        return formatter
    }

    private var shortFormatter: RelativeDateTimeFormatter {
        let formatter = RelativeDateTimeFormatter()
        formatter.unitsStyle = .full
        return formatter
    }

    func asAbbreviatedString() -> String {
        let from = Date().timeIntervalSince(self)
        return abbreviatedFormatter.string(from: from) ?? ""
    }

    func asShortString() -> String {
        return shortFormatter.localizedString(for: self, relativeTo: Date())
    }
}

Mastering Dependency Injection: A Practical Guide

Luis Filipe Pedroso — Wed, 26 Jun 2024 10:42:26 +0000

As the sun set behind the rolling hills of Silicon Valley, John found himself at a crucial crossroads. Months ago, a library was introduced into the project, only to now reveal numerous bugs, leaving John with the daunting task of updating 30 files to achieve the team's goal. Faced with this challenge, John realized that simply updating imports and refactoring the code wasn't the best path forward. Instead, he saw an opportunity to apply a design pattern that would not only resolve the current issue but also streamline future modifications.
John decided to use Dependency Injection (DI), a powerful design pattern that decouples the code, shifting responsibilities outside of a single file. This approach ensures that individual files don't directly consume third-party packages but rely on functions or classes within the project. By doing so, John could transform a potentially extensive refactor into a single, manageable transformation down the road.
In this post, we’ll explore how to implement Dependency Injection by creating an API client that consumes data from the GitHub API, demonstrating the pattern's practical application and benefits.

The first class:

Let's start by creating our first class, which we'll call Api.

class Api {
  constructor() {}

  async get(url: string) {

  }
}

export default Api;

This class has a single method called get, responsible for executing GET requests. Now, think for a minute about how you would implement the code for this method. Would you add a library such as Axios and call it in the get method? Something like:

async get(url: string) {
  const response = await axios.get(url)
  return response.data
}

If you thought about doing something like this, let me tell you that here's our core for dependency injection. Instead of attaching this class with a third-party library, we will move the dependency one level up. Therefore, all the logic regarding the headers of the request, or how to perform a request, will be placed in a new class responsible for only this.
To achieve that, let's create a new field for our class called client, and set its value in the constructor of the class.

class Api {
  private client: Fetcher<any>;

  constructor(client: Fetcher<any>) {
    this.client = client
  }
}

or, to simplify:

class Api {
  constructor(private client: Fetcher<any>) {}
}

And update our get method:

async get(url: string) {
  return this.client.get(url);
}

The contract

Now, we need to create something called Fetcher. What is Fetcher? It’s an interface that defines methods for those that implement it. By doing this, we can ensure that the Api class will call a valid method in the get method.
Let's create it:

interface Fetcher<T> {
  initialize(baseUrl: string): void;
  get(url: string): Promise<T>;
}

export default Fetcher;

In this interface, we define two functions, initialize, and get. You will understand the purpose of the initialize in a bit.

The first fetcher

It's time to create the first class responsible for making requests.

Let's call it FetchFetcher.

import Fetcher from "./Fetcher";

class FetchFetcher<T> implements Fetcher<T> {
  private baseUrl: string = "";

  initialize(baseURL: string): void {
    this.baseUrl = baseURL;
  }

  async get(url: string): Promise<T> {
    const response = await fetch(`${this.baseUrl}${url}`);
    const parsedResponse = await response.json();

    return parsedResponse;
  }
}

export default FetchFetcher;

Beautiful, huh? Now we have a class that uses the Javascript Fetch API and does a single stuff.

Connecting the pieces

To connect everything, let's create an initialization file:

import Api from "./Api";
import FetchFetcher from "./FetchFetcher";

async function main() {
  const fetchFetcher = new FetchFetcher();

  fetchFetcher.initialize("https://api.github.com");

  const api = new Api(fetchFetcher);

  const response = await api.get("/users/luisfilipepedroso");
  console.log(response);
}

main();

You might be asking yourself, why create a class called Api to perform requests, or wouldn't it be better to call get from the FetchFetcher directly? Well, you are half right, since, at this moment, we can create any fetchers we want. Take a look:

import axios, { AxiosInstance } from "axios";
import Fetcher from "./Fetcher";

class AxiosFetcher<T> implements Fetcher<T> {
  private axiosInstance: AxiosInstance | null = null;

  initialize(baseURL: string): void {
    this.axiosInstance = axios.create({
      baseURL,
    });
  }

  async get(url: string): Promise<T> {
    const response = await this.axiosInstance!.get<T>(url);
    return response.data;
  }
}

export default AxiosFetcher;

Now we have a class that uses the Axios library, and we can initiate it in the main file:

import Api from "./Api";
import AxiosFetcher from "./AxiosFetcher";
import FetchFetcher from "./FetchFetcher";

async function main() {
  const axiosFetcher = new AxiosFetcher();
  // const fetchFetcher = new FetchFetcher();

  axiosFetcher.initialize("https://api.github.com");
  // fetchFetcher.initialize("https://api.github.com");

  const api = new Api(axiosFetcher);

  const response = await api.get("/users/luisfilipepedroso");
  console.log(response);
}

main();

And the code will continue working, without touching the Api class.

Conclusion

Using Dependency Injection allows us to decouple our code, making it more flexible and easier to maintain. By abstracting the HTTP client, we can swap implementations without modifying the core logic.

To recap, here are the key benefits and steps we covered:

Decoupling Code: Dependency Injection helps to separate concerns by shifting dependencies outside of a single class.
Flexibility: We can easily switch between different HTTP clients (like Fetch and Axios) without altering the core Api class.
Maintainability: This approach makes the codebase more maintainable by isolating third-party dependencies.

What do you think about this post? Let me know your thoughts!

Understanding Hash Tables: The Backbone of Efficient Data Storage

Luis Filipe Pedroso — Wed, 29 May 2024 12:31:34 +0000

In the realm of computer science and programming, hash tables are indispensable tools that provide efficient data storage and retrieval capabilities. Whether you're a seasoned developer or a beginner, understanding hash tables can significantly enhance your problem-solving toolkit. In this post, we will explore what exactly hash tables are, how they work, the mechanics of hashing, and their application. Let's get started

What is a Hash Table?

Well, that's a good question, and as the long story short, a hash table is a data structure that maps keys to values for highly efficient lookup. Think of it as a digital version of a dictionary, where each word (key) maps to a definition (value).

The image below describes what a hash table looks like:

A general view of a HashTable

From the image above, there are three important things to mention:

The "hash" function: The "hash" function transforms keys, such as "ab" into 1234 and "cd" into 5678. This transformation maps the keys to specific indices in an array, enabling quick data retrieval.
Mapping to indexes: The hash values are mapped to indices in the array using a modulo operation to ensure they fit within the array's bounds. For example, 1234 maps the key "ab" to index 4 because 1234 % 5 (the length of the hash table) equals 4.
Dealing with collisions: To handle cases like the keys "ef" and "gh", or "cd", "ij", and "kl" being stored at the same index, linked lists are used to manage these situations, also called collisions. By storing multiple keys at the same index in a chain, the hash table allows efficient data retrieval even in the presence of collisions.

Let's take a look at these items separately.

Hash Function

A hash function is a crucial component of a hash table. It takes an input (the "key") and returns an integer, which is used as the index where the value associated with the key is stored. For instance, the key "ab" might be transformed into the index 1234, and "cd' into 5678.
An example of a simple hash function for strings is shown below:

function hash(key, tableSize) {
  let hash = 23;

  for (let i = 0; i < key.length; i++) {
    hash = (hash * key.charCodeAt(i)) % tableSize;
  }

  return hash;
}

This function iterates over each character in the input string, multiplying its Unicode value with the hash variable, and uses the modulo operation to ensure the resulting hash value fits within the bounds of the hash table's length. The use of a prime number (23) as the initial value helps create a more uniform distribution of hash values, reducing the likelihood of collisions in the hash table.

Collision Handling

A collision occurs when two keys hash to the same index, as in the case of the keys "ef" and "gh" in the image above. In situations like this, two techniques could be used to solve this problem: separate chaining, or open addressing.

Separate Chaining: One of the most common methods for handling collisions. When a collision occurs, the key-value pairs that hash to the same index are stored in a linked list at that index.
Open Addressing: This method involves finding another slot within the hash table for the colliding key. Techniques like linear probing, quadratic probing, and double hashing fall under this category.

Advantages of Hash Tables

Fast Data Access: Hash tables provide average-case constant time complexity, O(1), for both insertions and lookups, making them highly efficient.
Flexibility: They can store a wide variety of data types and can dynamically resize to accommodate more entries.

Applications of Hash Tables

There are a myriad of ways you could use Hash Table, the most common applications are:

Databases: Hash tables are used in database indexing to quickly retrieve records.
Caches: Acting as a fundamental piece of the implementation of caches for fast data retrieval.
Sets and Maps in Programming Languages: Many programming languages use hash tables to implement sets and maps, such as Python's dict and set, and Java's HashMap.

Conclusion

Hash tables are an example of efficient data storage and retrieval, due to their average-case constant time complexity for basic operations. By understanding the mechanisms of hashing and collision resolution, you can harness the power of hash tables to optimize your programs and solve complex problems with ease. Whether you are preparing for a coding interview or applying it to a project, hash tables are a fundamental tool that can make your data management tasks more efficient and effective.

To recap, remember that:

A hash table is a data structure that maps keys to values.
The average case of a hash table is constant time complexity, O(1), for both insertions and lookups.
A hash function is a crucial component of a hash table.
The use of a prime number helps create a more uniform distribution of hash values, reducing the likelihood of collisions in the hash table.
The most common technique to deal with collisions is Separate Chaining.
Hash tables are great for database indexing and cache.

Resources

Tutorials

How to Implement a Hash Table in JavaScript: A YouTube video tutorial where Ben Awad explains in detail how to implement a Hash Table in Javascript.

Books

Cracking the Coding Interview: 150 Programming Interview Questions and Solutions.

Master the Art of Software Testing with FIRST Principles

Luis Filipe Pedroso — Tue, 30 Apr 2024 14:00:33 +0000

Software testing is crucial to software development, ensuring that the product meets the desired requirements and functions as intended. Testing principles guide software testers and developers to create efficient, practical, high-quality tests. One such set of principles is F.I.R.S.T (Fast, Independent, Repeatable, Self-validating, Thorough), introduced by Robert “Uncle Bob” Martin.

In this blog post, we will dive into the meaning of these principles. Whether you are a seasoned software tester or a beginner, this post will provide valuable insights and best practices for improving your testing process and ensuring the quality of your software.

Fast

Says that tests should be quick to run, allowing developers to receive feedback on the code changes on time. The reasons for this are:

Improved Developer Productivity: fast tests allow developers to quickly and efficiently verify their code changes, freeing up time for more productive tasks.
Faster Feedback Loop: tests that take too long to run slowly down the development process and discourage frequent testing, crucial for catching and fixing bugs early.
Increased Test Coverage: fast tests enable developers to write and run more tests, which can uncover potential issues and improve the overall quality of the software.
Better Test Design: fast tests force developers to think critically about the design and implementation of their tests, leading to better test suites that are easier to maintain and less prone to errors.

Independent

Emphasizes that tests should be isolated from each other and not rely on the state or output of other tests. The factors behind this principle are:

Reliable Results: independent tests produce predictable and consistent results, making diagnosing and fixing bugs easier.
Improved Test Design: Independent tests encourage developers to design tests focusing on specific functionality, leading to a well-structured and comprehensive test suite.
Easier Debugging: when tests are independent, it is easier to identify the source of a failure, as the problem can be isolated to a specific test.
Faster Test Execution: independent tests can be executed in any order, allowing developers to run a subset of tests relevant to the changes they made, speeding up the testing process.
Better Test Maintenance: independent tests are less prone to breakage, as changes to one test do not affect the behavior of other tests.

Repeatable

It remains that tests should be able to be run multiple times in the same environment and produce the same results. The motivations behind this principle are:

Consistent Results: produce the same results each time they are run, making detecting and diagnosing failures easier.
Improved Confidence: increase confidence in the software, as developers know that the results of the tests are reliable and accurate.
Easier Debugging: this makes it easier to identify and fix bugs, as the source of the failure can be easily reproduced.
Better Test Maintenance: less prone to breakage, as changes to the environment or test data, do not affect the results.
Improved Collaboration: make it easier for multiple developers to work on the same codebase, as they can be confident that the tests will produce consistent results.

Self-validating

Refers to the ability of a test to verify its results without the need for manual intervention. The reasons behind this concept are:

Improved efficiency: self-validating saves time and effort as they can automatically check the results without manual validation.
Reduced errors: manual validation can introduce errors, which self-validating tests can reduce.
Increased reliability: self-validating tests can provide more reliable results as they reduce the potential for human error.
Improved maintainability: self-validating tests are easier to maintain, as they do not require manual intervention to check results.
Increased confidence: self-validating tests can increase confidence in the results, as they are automatically verified, reducing the risk of human error.

Thorough

Remains the idea that software testing should be comprehensive and cover all relevant areas of the system being tested. The reasons to adhere to the particular concept are:

Increased confidence: it can increase confidence in the results, as it covers all relevant system areas and reduces the risk of missed bugs or issues.
Improved quality: it can help to ensure the overall quality of the software, as it covers all relevant areas and reduces the risk of defects.
Reduced costs: it can reduce the cost of software development, as it reduces the need for rework or fixing bugs discovered later in the development cycle.
Improved user experience: it can improve the user experience, ensuring the software is free from defects and works as expected.
Better compliance: it can help ensure compliance with industry standards and regulations, as it covers all relevant system areas.

The benefits of adhering to the F.I.R.S.T Principles

Fast: adhering to the “Fast” principle leads to developing efficient and practical tests, resulting in enhanced software quality and augmented developer productivity.
Independent: following the “Independent” principle enables software teams to develop tests that are dependable, manageable, and furnish precise feedback on the software’s quality.
Repeatable: sticking to the “Repeatable” principle results in the development of tests that are reliable, consistent, and easy to maintain, leading to improved software quality and increased developer productivity.
Self-validating: adhering to the “Self-validating” principle helps ensure test results’ accuracy, efficiency, and reliability.
Thorough: cleaving to the “Thorough” principle helps to ensure the quality, reliability, and overall effectiveness of the software being tested.

Build Your Own Proximity Search: Haversine Distance Formula in Go

Luis Filipe Pedroso — Tue, 16 Apr 2024 15:00:14 +0000

Imagine that you are working on a task where your goal is to create a function that receives a latitude, longitude, and max distance and returns places nearby. Without directions on where to get started, you decide to research how to achieve this goal. After a time you realize that you only discovered websites saying to you to use Google Maps API.

But if I tell you that there exists a mathematical formula that can help you with this task? That’s what you will learn in this tutorial.

The Haversine Formula

The Haversine Formula is a mathematical formula used to calculate the distance between two points on a sphere, such as the Earth. It takes into account the radius of the sphere as well as the latitude and longitude of the two points and calculates the great-circle distance, which is the shortest distance between the two points along the surface of the sphere.

The Haversine formula is particularly useful for calculating distances between two points on the Earth’s surface, as it takes into account the fact that the Earth is not a perfect sphere, but rather an oblate spheroid. It is commonly used in applications such as GPS navigation, geodesy, and astronomy.

The formula is expressed as follows:

d = 2r * arcsin(sqrt(sin^2((lat2-lat1)/2) + cos(lat1) * cos(lat2) * sin^2((lon2-lon1)/2)))

where:

d = distance between the two points in units of the sphere’s radius (typically kilometers or miles)

r = radius of the sphere, in this case, Earth (in the same units as d)

lat1, lat2 = latitude of point 1 and point 2 (in radians)

lon1, lon2 = longitude of point 1 and point 2 (in radians)

Let's code

As our goal is to create a function that calculates places nearby, I decided not to show how to initialize the project and keep the focus only on the function.

Furthermore, it could be said that I’ll be using the Go programming language for this particular tutorial.

Let’s start by creating the Place struct, the variables and constants, and the main function:

type Place struct {
    Name      string `json:"name"`
    Latitude  float64 `json:"latitude"`
    Longitude float64 `json:"longitude"`
}

const EARTH_RADIUS = 6371.0
const MAX_DISTANCE = 50.0

func main() {
    myLatitude := -27.600852
    myLongitude := -48.505479

    places := []Place{
        {Name: "Ramiro Ruediger Park", Latitude: -26.9134, Longitude: -49.0855},
        {Name: "Corrego Grande Municipal Park", Latitude: -27.5998, Longitude: -48.5114},
        {Name: "Corrego Grande Linear Park", Latitude: -27.6028, Longitude: -48.5037},
        {Name: "Coqueiros Park", Latitude: -27.6016, Longitude: -48.5745},
    }
}

Great, now let’s create the function that will use the Haversine Formula:

func getNearbyPlaces(latitude float64, longitude float64, maxDistance float64, places []Place) []Place {
    var nearbyPlaces []Place

    for _, place := range places {
        lat2 := radians(place.Latitude)
        long2 := radians(place.Longitude)

        dlat := lat2 - radians(latitude)
        dlong := long2 - radians(longitude)

        a := math.Pow(math.Sin(dlat/2), 2) + math.Cos(radians(latitude))*math.Cos(lat2)*math.Pow(math.Sin(dlong/2), 2)

        c := 2 * math.Atan2(math.Sqrt(a), math.Sqrt(1-a))

        distance := EARTH_RADIUS * c

        if distance <= maxDistance {
            nearbyPlaces = append(nearbyPlaces, place)
        }
    }

    return nearbyPlaces
}

The only missing thing that we have to create is the radians function. This function will be responsible for converting the latitude and longitude, which are in degrees units, to radians units.

func radians(degrees float64) float64 {
    return degrees * (math.Pi / 180)
}

And that’s it, we made it 🔥.

Let's test

I will start by using the latitude -27.600852 and the longitude -48.505479, which is a point near Córrego Grande Municipal Park and Córrego Grande Linear Park. Furthermore, I will set the max distance of 1.5 kilometers, so I expect that the getNearbyPlaces function will return to me only Córrego Grande Municipal Park and Córrego Grande Linear Park as they are the closest places of the current latitude and longitude.

type Place struct {
    Name      string `json:"name"`
    Latitude  float64 `json:"latitude"`
    Longitude float64 `json:"longitude"`
}

const EARTH_RADIUS = 6371.0
const MAX_DISTANCE = 1.5

func main() {
    myLatitude := -27.600852
    myLongitude := -48.505479

    places := []Place{
        {Name: "Ramiro Ruediger Park", Latitude: -26.9134, Longitude: -49.0855},
        {Name: "Corrego Grande Municipal Park", Latitude: -27.5998, Longitude: -48.5114},
        {Name: "Corrego Grande Linear Park", Latitude: -27.6028, Longitude: -48.5037},
        {Name: "Coqueiros Park", Latitude: -27.6016, Longitude: -48.5745},
    }

    nearbyPlaces := getNearbyPlaces(myLatitude, myLongitude, MAX_DISTANCE, places)

    fmt.Println(nearbyPlaces)
    // [{Corrego Grande Municipal Park -27.5998 -48.5114} {Corrego Grande Linear Park -27.6028 -48.5037}]
}

Great, it’s working. Let’s increase the max distance to ensure that we receive also Coqueiros Park.

type Place struct {
    Name      string `json:"name"`
    Latitude  float64 `json:"latitude"`
    Longitude float64 `json:"longitude"`
}

const EARTH_RADIUS = 6371.0
const MAX_DISTANCE = 15.0

func main() {
    myLatitude := -27.600852
    myLongitude := -48.505479

    places := []Place{
        {Name: "Ramiro Ruediger Park", Latitude: -26.9134, Longitude: -49.0855},
        {Name: "Corrego Grande Municipal Park", Latitude: -27.5998, Longitude: -48.5114},
        {Name: "Corrego Grande Linear Park", Latitude: -27.6028, Longitude: -48.5037},
        {Name: "Coqueiros Park", Latitude: -27.6016, Longitude: -48.5745},
    }

    nearbyPlaces := getNearbyPlaces(myLatitude, myLongitude, MAX_DISTANCE, places)

    fmt.Println(nearbyPlaces)
    // [{Corrego Grande Municipal Park -27.5998 -48.5114} {Corrego Grande Linear Park -27.6028 -48.5037} {Coqueiros Park -27.6016 -48.5745}]
}

As expected, the function returned three places, Córrego Grande Municipal Park, Córrego Grande Linear Park, and Coqueiros Park. Now is your turn, copy the code, add your places, and make some tests.