DEV Community: Nenba Jonathan

Caching function in Python Using the LRU Cache Strategy

Nenba Jonathan — Sun, 05 Nov 2023 03:50:00 +0000

This article was previously published on my personal blog Caching function in Python Using the LRU Cache Strategy

Introduction

In the realm of software development, efficiency is king. Reducing the time complexity of your code is often a primary objective, especially when dealing with functions that perform heavy computations. Python offers a built-in way to optimize such functions by memoizing their outputs. This technique is known as caching, and it's particularly useful when the same expensive function calls are made repeatedly with identical arguments. The functools module provides a decorator, lru_cache, which implements this strategy with an efficient approach known as "Least Recently Used" (LRU) caching.

What is Caching?

Caching is akin to taking notes in a lecture. Instead of recalculating the answer every time a function is called, Python can refer to a "note" of previously computed results. This simple concept can dramatically reduce execution time, as retrieving a value from a cache is typically orders of magnitude faster than computing it from scratch.

Understanding `lru_cache` and Its `maxsize` Parameter

The lru_cache decorator automates the process of storing function results in a cache. Its maxsize parameter determines how many of these results to store, with the LRU strategy ensuring that only the most recently accessed results are kept. This strategy elegantly balances the trade-off between time complexity and space complexity.

The maxsize parameter is pivotal for the following reasons:

Memory Management: A smaller maxsize means less memory usage, but also more frequent recalculations if the cache is too small for your needs.
Performance Tuning: A larger cache can prevent recalculations but adds overhead in memory and potential cache management.
Unbounded Caching: Setting maxsize to None can lead to unbounded cache growth, which, if unchecked, can consume all available memory and lead to performance degradation.

Selecting an optimal maxsize is not always straightforward. A power of two is usually recommended for the maxsize value because it aligns with how computers manage memory and can lead to slight performance optimizations.

Example: Caching Prime Number Calculations

Let's apply lru_cache to prime number calculation:

from functools import lru_cache

@lru_cache(maxsize=32)  # Small cache size for demonstration
def is_prime(num):
    if num < 2:
        return False
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            return False
    return True

@lru_cache(maxsize=32)  # Cache the most recent calls to speed up the calculation
def nth_prime(n):
    prime_count = 0
    num = 1
    while prime_count < n:
        num += 1
        if is_prime(num):
            prime_count += 1
    return num

# Let's see the caching in action
print(nth_prime(1000))  # Calculates and caches intermediate results
print(nth_prime(1001))  # Reuses the cache and only calculates the next prime
print(nth_prime(500))   # This result is cached, so it's retrieved instantly

In this code, the is_prime and nth_prime functions are decorated with lru_cache with a maxsize of 32. The cache stores the most recent 32 results. If you call nth_prime with a value less than or equal to 32 plus the last cached result, it will quickly return the result from the cache without recalculating.

Conclusion

Utilizing lru_cache with an appropriate maxsize is a smart way to enhance the performance of your Python functions that perform repetitive and intensive calculations. It allows you to save on computational costs and execute programs faster. However, it's essential to balance between the desired speed-up and the available memory resources. Experimenting with different maxsize values can help you find the sweet spot for your specific use case.

Join Us This Hacktoberfest: Contribute to the Ultimate Bitcoin & Blockchain Learning Resource!

Nenba Jonathan — Mon, 16 Oct 2023 22:41:00 +0000

Hello developers!

With Hacktoberfest in full swing, I wanted to share a opportunity for both seasoned developers and those just starting out. If you've ever been fascinated by Bitcoin and blockchain, and have been looking for a way to dip your toes into the vast ocean of its ecosystem, you've stumbled upon the right post!

Over the past few month, I've been curating and developing a project that strives to be the definitive guide for anyone looking to learn about Bitcoin and blockchain. We're talking about everything from foundational whitepapers, academic articles, beginner-friendly tutorials, to the most intricate technical deep dives.

nejos97 / resources-for-learning-about-bitcoin-and-blockchain

⚡ A complete plan to learn and know everything about bitcoin and the blockchain world in general.

The Open Guide To Learning About Bitcoin And Blockchain

Credits ∙ Contributing guidelines

Why an Open Guide?

A lot of information on Bitcoin is already written. Most people learn Bitcoin by reading a blog or a “Bitcoin White Paper” and referring to the Bitcoin Website. Nonetheless, trustworthy and practical information and recommendations aren’t easy to come by. Here we will list some sources of information to allow anyone and African in particular to be able to educate and learn about this technology that is revolutionizing the habits of the world.

Please help

This is an early in-progress draft! It’s our first attempt at assembling this information, so is far from comprehensive still, and likely to have omissions or errors.

Getting Started

Bitcoin : Bitcoin is an innovative payment network and a new kind of money.
Bitcoin Wiki: Welcome to the Bitcoin Wiki
Help:FAQ : Help:FAQ -…

View on GitHub

The best part? It's open source! 🎉 Which means that you can not only benefit from the resources but also contribute to this ever-growing library of knowledge. Why Contribute?

Expand Your Knowledge: By digging deep and curating resources, you'll be solidifying your own understanding of the blockchain realm.

Boost Your Portfolio: Especially for junior developers, contributing to open-source projects is an incredible way to showcase your skills to future employers.

Network: Interact with other contributors, and who knows, you might just find your next collaborator, mentor, or friend!

How Can You Help?

Add Resources: Know of a fantastic article or tool that's missing? Add it in!

Review: Check the added resources for accuracy and relevance.
Documentation: For those who are more into writing, help us craft clear and concise documentation or even tutorials.

And don’t worry if you’re just starting out. This is a beginner-friendly project, and we’re here to guide you through every step.

Getting Started

To the junior developers out there - I know how daunting it can be to dive into open source for the first time. I've been there. This is your chance to not only learn but also make meaningful contributions to a project that aims to educate many. Your fresh perspective is invaluable, and we welcome you with open arms!

Let’s come together this Hacktoberfest and make learning about Bitcoin and blockchain easier and more accessible for everyone. Every contribution, big or small, brings immense value. Can't wait to see what we'll achieve together!

Happy coding and happy Hacktoberfest! 🎃 🖥️ 🚀

Create 2 Million records in a database from a single SQL query

Nenba Jonathan — Sun, 15 Oct 2023 03:59:00 +0000

This article was previously published on my personal blog Create 2 Million records in a database from a single SQL query

More than once in programming, you've had to work with data, but somehow didn't have it, perhaps to test the performance of your queries, the general behavior of your application or to prepare a demo.

For some time now, this should no longer be a problem, as many databases support recursive SQL queries. This means you can generate large amounts of data (thanks to the WITH RECURSIVE clause).

For this post, I'll essentially be using SQLite for my queries, but keep in mind that it works for most of the current DBMS we have (MariaDB 10.2+, MySQL 8.0+, PostgreSQL 8.4+ and SQLite 3.8+. Oracle 11.2+ and SQL Server 2005+).

For our first example, we'll create a fake_data table, then insert 2 million rows into this table with random numerical data. For this example, there will be no field constraints.

CREATE TABLE fake_data AS
WITH RECURSIVE tmp(x) AS (
    SELECT abs(random() % 99) + 1
    UNION ALL
    SELECT abs(random() % 99) + 1 FROM tmp
    LIMIT 2000000
)
SELECT * FROM tmp;

come on, let's explain some of the code we've written:

CREATE TABLE fake_data AS: This part of the query creates a new table named fake_data where we will store the results of our query.
WITH RECURSIVE tmp(x) AS: This starts a common table expression (CTE) named tmp. A CTE is a temporary result set that you can reference within the main query.
(SELECT abs(random() % 99) + 1): In the CTE, we start with a SELECT statement that generates a random number between 1 and 99 (inclusive) using the random() function and takes the absolute value with abs. This generates the initial value for the column x in the tmp CTE.
UNION ALL: This is used to combine the result of the initial SELECT statement with the results of the subsequent SELECT statement. It's used in a recursive CTE to keep adding rows to the result set.
SELECT abs(random() % 99) + 1 FROM tmp: This is the recursive part of the CTE. It selects another random number between 1 and 99 and adds it to the result set. The FROM tmp part means that it's selecting from the tmp CTE itself, which creates a recursive loop.
LIMIT 2000000: This is a limit applied to the recursive part of the CTE to stop the recursion after 2,000,000 rows have been generated. This is done to prevent an infinite loop.
Finally, SELECT * FROM tmp; retrieves all the rows from the tmp CTE, which now contains 2,000,000 random numbers between 1 and 99 (inclusive).

In summary, this query generates a table named fake_data containing 2,000,000 random integers between 1 and 99 using a recursive common table expression (CTE). It starts with an initial random number and then keeps adding more random numbers until it reaches the limit of 2,000,000 rows.

Creating a table with numbers only isn't interesting, so we're going to generate some more concrete user data.

Let's suppose we have a users table with ID, name and age fields. We'll create 2 million entries in our use table as follows:

ID will be numeric and incremental (1, 2, 3,...)
name will be randomly selected from another table with 5 names
age will be a random number chosen between 1 and 99

So we're going to create a table containing only the names

CREATE TABLE IF NOT EXISTS names(id integer primary key, name text);

INSERT INTO names(id, name) VALUES (1, 'Alex'), (2, 'Annita'), (3, 'Coco'), (4, 'Sundar'),(5, 'Zuck');

CREATE TABLE IF NOT EXISTS persons AS
WITH RECURSIVE tmp(id, idx, name, age) as (
    SELECT 1, 1, 'Ann', 20
    UNION ALL
    SELECT
        tmp.id + 1 as id,
        abs(random() % 5) + 1 as idx,
        (SELECT name FROM names WHERE id = idx) as name,
        abs(random() % 99 ) + 1 as age
    FROM tmp
    LIMIT 2000000 
) SELECT id, name, age FROM tmp;

In summary, this SQL statement creates a table called "persons" and populates it with up to 2,000,000 rows of randomly generated data, including names selected from another table. The recursive CTE is used to generate the data in a recursive manner until the specified limit is reached.

In conclusion, for developers focused on testing, employing a single SQL query to generate random data within a database is a powerful and time-saving strategy. This method facilitates comprehensive testing scenarios, ensuring robustness and reliability in software applications. By harnessing the simplicity of SQL queries, developers can efficiently create randomized datasets, ultimately enhancing the quality and effectiveness of their testing processes.

Building a simple API with Golang using Gin-gonic

Nenba Jonathan — Sun, 01 Oct 2023 09:17:00 +0000

Hello everyone, in this post, I'm going to show you how to create a small Golang API using the Gin-gonic library to expose some resources of your application's.

Introduction

An HTTP server is a program that runs in a loop on a machine that's usually connected to the Internet (it doesn't have to be, but if you want your server to be accessible anywhere in the world, it must be) and accepts requests, processes them and returns responses. We're not going to do a whole course on how the web works, but I have to make a small list of prerequisites so that you can continue following this post without getting lost.

Have a computer (haha I guess you already do)
Knowing and understanding how the web basically works
Golang coding skills (at least basic syntax)

Program preparation

Our little api will therefore be a go module. Here we'll initialize our go module and install the package we need.

mkdir http-server && cd http-server && go init mod nejos97/http-server

The above command will create the http-server folder and initialize it as a Golang module.

go get github.com/gin-gonic/gin@latest

Once in our module, we'll install our Gin package, which will enable us to create an http server more easily.

By the way, what is Gin ?????

In order to make life easier for many developers, packages have been put in place so that we can reuse them and deliver our functionality more quickly, Gin is a Golang framework that allows us to create a production-ready API in just a few lines of code, it already contains all the complexity and certain logic of api server operation. You can get more information on the Gin documentation here (https://gin-gonic.com/), which I really recommend you read.
To proceed, we'll create a main.go file in which we'll write our code.

Before getting down to the nitty-gritty of coding, let's define what we're going to do:

This will be a server with 2 or 3 endpoints which will enable us to manage the list of users in our system, return the list, get unique user or add new user.

So, first of all, we're going to define a user's data structure.

type User struct {
    ID          string `json:"id"`
    Firstname   string `json:"firstName"`
    Lastname    string `json:"lastName"`
    Email       string `json:"email"`
    IsActivated bool   `json:"isActivated"`
    Role        string `json:"role"`
}

This structure will allow us to create a user with the various fields, and the json... notation after each field will allow us to serialize each field in JSON, after which we'll be able to obtain data that looks like this.

{
    "id": "759983a5-3bcd-4af7-9055-88ed43062034",
    "firstName": "Coco",
    "lastName": "Gauff",
    "email": "coco.gauff@usopen.gov.com",
    "isActivated": true,
    "role": "staff"
}

Given that we won't be using a database in this little project, we're going to create a list of static users each time we start our application, so that we can initialize and query this data.

var users = []User{
    { ID: "49ed089f-4de1-420d-adcd-274166ea709b", Firstname: "Coco", Lastname: "Gauff", Email: "coco.gauff@usopen.gov.com", IsActivated: true, Role: "staff" },
    { ID: "8021aa9d-24fd-40c2-9092-d82ceda31783", Firstname: "Alex", Lastname: "Marvin", Email: "alex.marvin@usopen.gov.com", IsActivated: true, Role: "admin" },
    { ID: "39ffcd5b-88fa-415f-bdaa-8ccf3e6b6b87", Firstname: "Abdoul", Lastname: "Razak", Email: "abdoul.razak@usopen.gov.com", IsActivated: true, Role: "staff" },
    { ID: "7edaed66-fd82-4b09-96d1-22017cc6f258", Firstname: "Danwe", Lastname: "Aristide", Email: "danwe.aristide@usopen.gov.com", IsActivated: true, Role: "admin" },
}

In the rest of our program, we'll create our server with a first endpoint that will return a list of all the users on our system.

func getUsers(c *gin.Context) {
    c.IndentedJSON(http.StatusOK, users)
}

func main() {
    router := gin.Default()
    router.GET("/users", getUsers)
    router.Run(":8080")
}

This code is sufficient to launch a server and allow us to test our endpoint. For testing purposes, you're free to use either Postman or Insomnia, or any other software you know that will do the job. Please add this in the comments section so that other developers can try it out. Personally, I use Insomnia for my tests.

After testing the endpoint localhost:8080/users, it returns a json containing the list of all the users we statically created earlier.

So some explanation is in order.

c *gin.context this line passes the request context pointer to our function and allows us, via the line c.IndentedJSON(http.StatusOK, albums), to directly write the response to be returned by the endpoint.

The function defines the entry point for our program, and it's here that we have an instance of the Gin router, thanks to the gin.Default() function. This instance already contains some middleware, logging and other functions already embedded in Gin, isn't that great? hehe

router.GET("/users", getUsers) this line enabled us to map the endpoint to the method to be called, as simple as that.

Now that you've understood a little about how our code works, we'll continue by adding other endpoints, such as the one that will allow us to add a new user to our list.

func addUser(c *gin.Context) {
    var newUser User
    if err := c.Bind(&newUser); err != nil {
        return
    }
    users = append(users, newUser)
    c.IndentedJSON(http.StatusCreated, users)
}

func main() {
    router := gin.Default()
    router.GET("/users", getUsers)
    router.POST("/users", addUser)
    router.Run(":8080")
}

So you can see that when you run a test with sample data, it's added directly to the user list. In this tutorial, we're going to ignore the data validation mechanism. We'll come back to it in another tutorial to explain how to manage validation and errors in our system.

The next endpoint we're going to add will enable us to return a single user through his identifier.

func getUserByID(c *gin.Context) {
    id := c.Param("id")
    for _, user := range users {
        if user.ID == id {
            c.IndentedJSON(http.StatusOK, user)
            return
        }
    }
    c.IndentedJSON(http.StatusNotFound, gin.H{"message": "User Not Found"})
}

func main() {
    router := gin.Default()
    router.GET("/users", getUsers)
    router.POST("/users", addUser)
    router.GET("/users/:id", getUserByID)
    router.Run(":8080")
}

In this new code, we first retrieve the ID of the user whose information we wish to find, then we go through our list of users. If we find a user with this ID, we return this, otherwise we exit the loop and return a 404 Not Found response.

The gin.H method is in fact an alias, allowing us to create a dictionary and is used to generate JSON responses.

So, with this little application, we've designed an API with GET and POST methods.

This is just an introduction to creating an API with Gin. Other tutorials will follow, enabling us to refine our API even further, fixing certain bugs, parsing error messages and adding other functionalities.

Below is the complete code we've written throughout this tutorial.

package main

import (
    "net/http"

    "github.com/gin-gonic/gin"
)

type User struct {
    ID          string `json:"id"`
    Firstname   string `json:"firstName"`
    Lastname    string `json:"lastName"`
    Email       string `json:"email"`
    IsActivated bool   `json:"isActivated"`
    Role        string `json:"role"`
}

var users = []User{
    {ID: "49ed089f-4de1-420d-adcd-274166ea709b", Firstname: "Coco", Lastname: "Gauff", Email: "coco.gauff@usopen.gov.com", IsActivated: true, Role: "staff"},
    {ID: "8021aa9d-24fd-40c2-9092-d82ceda31783", Firstname: "Alex", Lastname: "Marvin", Email: "alex.marvin@usopen.gov.com", IsActivated: true, Role: "admin"},
    {ID: "39ffcd5b-88fa-415f-bdaa-8ccf3e6b6b87", Firstname: "Abdoul", Lastname: "Razak", Email: "abdoul.razak@usopen.gov.com", IsActivated: true, Role: "staff"},
    {ID: "7edaed66-fd82-4b09-96d1-22017cc6f258", Firstname: "Danwe", Lastname: "Aristide", Email: "danwe.aristide@usopen.gov.com", IsActivated: true, Role: "admin"},
}

func getUsers(c *gin.Context) {
    c.IndentedJSON(http.StatusOK, users)
}

func addUser(c *gin.Context) {
    var newUser User
    if err := c.Bind(&newUser); err != nil {
        return
    }

    users = append(users, newUser)
    c.IndentedJSON(http.StatusCreated, users)
}

func getUserByID(c *gin.Context) {
    id := c.Param("id")
    for _, user := range users {
        if user.ID == id {
            c.IndentedJSON(http.StatusOK, user)
            return
        }
    }
    c.IndentedJSON(http.StatusNotFound, gin.H{"message": "User Not Found"})
}

func main() {
    router := gin.Default()
    router.GET("/users", getUsers)
    router.POST("/users", addUser)
    router.GET("/users/:id", getUserByID)
    router.Run(":8080")
}

Conclusion

In this tutorial, our aim was to set up a simple API to perform basic retrieval and addition operations in our data list. I think the basic objective has been reached and you can create your own API and define your own functionalities, as said in the post, I'll create other posts as we go along to improve what we've done so far (adding other middleware, handling all possible errors, hosting our API on AWS, building a docker image... There are so many topics to develop around our little API) I encourage you to practice a lot and research more about Gin (I've shared the link above.).

Thanks for reading this post and don't forget to follow me on X(ex-Twitter)(https://x.com/nejos97) and LinkedIn(https://linkedin.com/in/jnenba)

What is ULID and why should you start using it?

Nenba Jonathan — Sat, 23 Sep 2023 04:38:00 +0000

This article was previously published on my personal blog What is ULID and why should you start using it?

Identifiers(IDs) in programming

When we're writing programs, we always have to store information either from our users or even from the data we're working with (photos, music, user information, orders...) so with all this data, we sometimes have to retrieve information in a unique way, which is where identifiers come in. It's a piece of data that uniquely identifies an entry in our set of collections.

Most of the time, this is a numeric and incremental field (i.e. each time a new entry is added to these fields, it retrieves the value of the previous entry and adds 1), which can result in a series of numbers. (1, 2, 4, 5...) But very quickly, this method was deprecated by most of developers, especially when we wanted to display this number on the client (browser, mobile app or other interface), as it can constitute a flaw in our system and is very predictable.

UUID(Universally Unique IDentifier)

It's a standard identifier, randomly generated and globally unique. The most widely used version at present is v4. What makes it so powerful is the number of possibilities: it's made up of 128 bits, or 32 hexadecimal characters.
You can therefore integrate this into your application and use a mechanism that will generate an identifier each time it is required (automatically or manually) or directly integrated into your database management system. (Postgres, for example, supports this.)

Although the probability of two UUIDs being generated exactly the same is very low, it is not impossible. The chance of generating a duplicate UUID is around one in 2^122. However, since UUIDs are used in distributed systems, it is unlikely that two UUIDs will collide.

The disadvantage of the UUID is that it's impossible to perform operations on these Ids, such as finding out whether uuid-one > uuid-two, which is where the ULID comes in.

Here is an example of how a UUID is represented: af44d4f0-92b6-475f-8902-a2c06a6f938a

ULIDs(Universally Unique Lexicographically Sortable Identifier)

ULID can be seen as an alternative to UUID, built to avoid the pitfalls and certain shortcomings of the UUID system.

1) collision possibilities across the history of all generated IDs

2) complete loss of locality

3) Impossible to sort between identifiers

here's an example of ULID: 01AN4Z07BY79KA1307SR9X4MV3

01AN4Z07BY(Timestamp 10 chars 48bits base32) 79KA1307SR9X4MV3(Randomness 16 chars 80bits base32)

At first glance, you can see that ULID is compact and therefore easy to handle, compared with UUID, which is separated by dashes.

ULID guarantees that identifiers can be ordered monotonically and sorted even if they are generated in the space of a millisecond.

Here are a few of ULID's special features. For more information, click here(https://github.com/ulid/spec):

128-bit compatibility with UUID
1.21e+24 unique ULIDs per millisecond
Lexicographically sortable!
Canonically encoded as a 26 character string, as opposed to the 36 character UUID
Uses Crockford’s base32 for better efficiency and readability (5 bits per character)
Case insensitive
No special characters (URL safe)
Monotonic sort order (correctly detects and handles the same millisecond)

Note: ULIDs are encoded using Crockford’s Base32 alphabet (0123456789ABCDEFGHJKMNPQRSTVWXYZ). It excludes I, L, O, and U letters to avoid any unexpected confusion.

Example in Golang

To use it in a project, you first need to add the package to your project with the following command:

go get github.com/oklog/ulid/v2

package main

import (
    "fmt"

    "github.com/oklog/ulid/v2"
)

func main() {
    result := ulid.Make()
    fmt.Println(result)
}

A little further ahead with entropy

package main

import (
    "fmt"
    "math/rand"
    "time"

    "github.com/oklog/ulid/v2"
)

func main() {
    entropy := rand.New(rand.NewSource(time.Now().UnixNano()))
    ms := ulid.Timestamp(time.Now())
    result, err := ulid.New(ms, entropy)
    if err != nil {
        fmt.Println("Error while generating ULID: ", err)
    }
    fmt.Println(fmt.Sprintf("Result: %s", result))
}

You can also make comparisons between the identifiers you've generated, and find out which identifier is more recent than the other, for example, or all the identifiers generated from a given date.

This becomes interesting when, for example, a fintech application wants to filter all the transactions of a user from a certain date, so we can do this operation just with the identifiers without having to retrieve the creation date of the transactions.

Here's a code snippet that illustrates how the comparison is made.

package main

import (
    "fmt"
    "math/rand"
    "time"

    "github.com/oklog/ulid/v2"
)

func main() {
    entropy := rand.New(rand.NewSource(time.Now().UnixNano()))
    ms1 := ulid.Timestamp(time.Now())
    time.Sleep(2 * time.Second)
    ms2 := ulid.Timestamp(time.Now())
    resultOne, err := ulid.New(ms1, entropy)
    if err != nil {
        fmt.Println("Error while generating ULID: ", err)
    }

    resultTwo, err := ulid.New(ms2, entropy)

    if err != nil {
        fmt.Println("Error while generating ULID: ", err)
    }
    fmt.Println(fmt.Sprintf("ResultOne: %s  ResultTwo: %s", resultOne, resultTwo))

    fmt.Println(resultTwo.Compare(resultOne))

    if resultTwo.Compare(resultOne) >= 1 {
        fmt.Println("resultTwo > resultOne")
    }
}

You can also use the CLI to generate your ids.

go install github.com/oklog/ulid/v2/cmd/ulid@latest

ulid

ULIDs are not completely random, as they use a timestamp as part of the identifier. However, they are still unique and secure, making them ideal for many applications.

I invite you to read the spec page on Github for more information: Github(https://github.com/ulid/spec)

Some modules in different programming languages

ULIB is in fact standard, so you can find the libraries for your various programming languages to use it.
It's supported by around 50 programming languages, and I've listed the Github links to some of the repositories below.

Javascript (https://github.com/ulid/javascript)
Golang (https://github.com/oklog/ulid)
Python (https://github.com/mdipierro/ulid)
Java (https://github.com/huxi/sulky/tree/master/sulky-ulid)
Scala (https://github.com/petitviolet/ulid4s)

According to the various comments from developers, there's really no major drawback to using it, except perhaps that it's case-sensitive, and even that will really depend on the use case you're applying it to. There's been quite a bit of implementation and consideration for this standard for a while now, and hopefully more versions will come out in the future with many more improvements and new features.

Thanks for reading this post, don't forget to leave a comment or let us know what you think about it.

Node(20.6.0) now supports built-in .env files

Nenba Jonathan — Sun, 17 Sep 2023 03:38:00 +0000

Hello javascript lovers too, for some time now the new version of node, more precisely version 20.6.0, has been supporting your environment variable file without the need for an external package to do this. Well, in this little article we're going to talk a bit about what this means and how to take full advantage of this improvement, as well as some of the drawbacks or weak points of this functionality.

To begin with, environment variables are essential for our code, and their usefulness is well established. This allows us to avoid exposing sensitive data in our source code, and also to easily change certain configurations in our application without having to hardcode them.

In the development world, we're used to using a file to store our data. Often we call it .env .env.local env.uat .env.prod, depending on your environment.

In javascript, the essential package for managing configuration files was dotenv, which was used, and still is today, to load env files and perform other configuration. Since node version 20.6.0, you can do it without this package.

What's the advantage of using this

Firstly, this means we don't have to depend on an external library, and therefore limit security failures in our code.

more simplicity, so we won't need to install and configure the dotenv package in our project as we used to do.

So without further ado, let's get to work!

So I'm not going to tell you again to install node version 20.6.0 - I assume you've already done that - but for a little tip I recommend using nvm (node version manager), which lets you have several versions of node installed on your computer, so you can easily switch versions independently of the projects you're working on.

create a folder and initialize a project node with the command

npm init --yes

once this is done create two files index.js and .env at the root of your folder, place this content in the .env file

PORT=3000
APP_NAME=fake-app-name
LOG_LEVEL=debug

and this in the index.js file

console.log(process.env.PORT)
console.log(process.env.APP_NAME)
console.log(process.env.LOG_LEVEL)

Now to launch your little application, type the following command in your terminal and you'll see the contents of your different environment variables displayed.

node --env-file=.env index.js

as you can see, we didn't have to install anything or configure anything to have our variables available in the code, now it's up to you to improve it and define the file by environment.

{
  "name": "test_env",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "start:dev": "node --env-file=.env index.js",
    "start:uat": "node --env-file=.env.uat index.js",
    "start:prod": "node --env-file=.env.prod index.js"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}

From the release of this announcement there have been some questions about this feature, for example:

It doesn't traverse parent directories, doesn't have good overwrite/merge logic - things that dotenv supported.

It doesn't support multiline variables, which are very important for keys, certificates and JSON configuration.

Above all, it should be noted that this functionality has been made public and that it's up to the community to decide how to improve it and make it more suited to our needs.

Scheduling tasks in Golang with atomicgo

Nenba Jonathan — Sat, 16 Sep 2023 02:02:00 +0000

This article was previously published on my personal blog Scheduling tasks in Golang with atomicgo

Hi coder, in one way or another in programming, you have once been confronted with the fact of wanting to schedule the execution of certain tasks in your program, whether it's to delete certain unnecessary files, build your application, send birthday mails or even periodically check access and delete when it's out of date; in any case, there are an awful lot of them.

In this new post, we'll take a look at how to do this in golang using atomicgo.

What is atomicgo

Atomicgo is a golang package that offers a lot of ready-to-use functionality to make life easier for go developers.

Before going straight to the code, let's create a context or environment in which we'll practice our example.

Let's say we have a list of user in our database and that each user has the expiry date of their access to our system (this could also be access to our secret room, for example.) Our task will therefore be to write our task executor so that it can periodically check our list and automatically remove all users whose access has expired.

Before going into the code, I assume you've already installed the official Golang website in your environment (Windows, Linux, MacOS).

To get started, create a folder and initialize the go module with this command

mkdir schedule_tasks
cd schedule_tasks
go mod init nejos97/schedule-tasks

Once your module has been initialized, make sure you install the package we need for our little project.

go get atomicgo.dev/schedule

Now that everything's ready, let's create our main package and the user structure we'll be using.

package main

import (
    "fmt"
    "time"
)

type User struct {
    FirstName      string
    LastName       string
    RegisteredDate time.Time
    ExpiredDate    time.Time
}

So we're going to add two functions to our code to create a single user and another to return a list of users. To improve the code, you can pass dates to the getFakeUniqueUser function so that you can use it with several different dates.

func getFakeUniqueUser() User {
    registerdDate, err := time.Parse(time.DateOnly, "2022-06-08")
    if err != nil {
        fmt.Println(err)
    }

    expiredDate, err := time.Parse(time.DateOnly, "2023-08-08")
    if err != nil {
        fmt.Println(err)
    }

    return User{
        FirstName:      "Fake Firstname",
        LastName:       "Fake Lastname",
        RegisteredDate: registerdDate,
        ExpiredDate:    expiredDate,
    }
}

func getUsers() []User {
    var data []User
    // TODO: Lets get some users in our database here
    data = append(data, getFakeUniqueUser())
    data = append(data, getFakeUniqueUser())
    data = append(data, getFakeUniqueUser())
    return data
}

Now we're going to write the function that removes expired users from our list and blocks their access to our system.

func processUsers(users *[]User) {
    var result []User
    for _, user := range *users {
        if user.ExpiredDate.After(time.Now()) {
            result = append(result, user)
            continue
        }
        fmt.Println(fmt.Sprintf("User %s %s expired.", user.FirstName, user.LastName))
    }
    *users = result
}

This function takes a pointer to a list of users as a parameter, performs the deletion operation and updates the list with the new values.

To test our code, here's what our hand will look like

func main() {
    var users []User = getUsers()
    processUsers(&users)
    fmt.Println(users)
}

When you run this go run . code, you'll get something like this on screen

➜ go run .
[{Fake Firstname Fake Lastname 2022-06-08 00:00:00 +0000 UTC 2023-10-08 00:00:00 +0000 UTC} {Fake Firstname Fake Lastname 2022-06-08 00:00:00 +0000 UTC 2023-10-08 00:00:00 +0000 UTC} {Fake Firstname Fake Lastname 2022-06-08 00:00:00 +0000 UTC 2023-10-08 00:00:00 +0000 UTC}]

For the moment, I've created all my users with a valid expiry date.

So, to get to the heart of the matter and see how to use atomicgo in our project, we're going to use the first method offered by the documentation to schedule our execution.

func main() {
    var users []User = getUsers()
    task := schedule.After(5*time.Second, func() {
        processUsers(&users)
    })
    task.Wait()
}

In the code above, we've used schedule's After function, which takes the second time as a parameter and the function to be executed after the second time has elapsed.

Importantly, it's a non-blocking function, so you can perform other tasks below it without having to wait the 5 seconds.

func main() {
    var users []User = getUsers()
    task := schedule.Every(time.Second, func() bool {
        processUsers(&users)
        return true
    })
    time.Sleep(30 * time.Second)
    task.Wait()
}

The Every function in the schedule package allows the function to be executed several times after a time specified here as in seconds, which means that our code block will be executed here after every second.

func main() {
    var users []User = getUsers()

    task := schedule.At(time.Now().Add(5*time.Second), func() {
        processUsers(&users)
    })

    task.Wait()
}

The function above allows you to execute your task on a specific date, so here I've retrieved the current date and added 5 seconds to obtain a future date and wait for the date to arrive to see my function execute.

As you can see, we store our task in a variable. In fact, there's some information that will let us know certain states of our task.
task.IsActive() returns true if the task is still active
task.ExecutesIn() returns the duration of our task's next execution
task.NextExecutionTime() returns the date of our task's next execution
task.StartedAt() returns the time at which our task began execution

I'll leave you to browse through the atomicgo documentation to learn more about all the advantages this library has to offer.

The aim of this tutorial was to give you a brief overview of the atomicgo library and how you can use it to program the execution of certain tasks in your projects.

Thanks for liking it, if you have any recommendations, questions or any other packages you'd like to share please add it in the comments section, I'd love to read it.

Which ORM to use for build an API with NodeJS ?

Nenba Jonathan — Wed, 09 Jan 2019 13:53:06 +0000

Hello @everyone

I want to create an API with nodejs and express to delivery some information.

I have check some solution but i'm always lost.

I will use a relational database and the API will be consumed by a React application.

whatever you say to me will be useful.

Thank you

DEV Community: Nenba Jonathan

Caching function in Python Using the LRU Cache Strategy

Introduction

What is Caching?

Understanding lru_cache and Its maxsize Parameter

Example: Caching Prime Number Calculations

Conclusion

Join Us This Hacktoberfest: Contribute to the Ultimate Bitcoin & Blockchain Learning Resource!

nejos97 / resources-for-learning-about-bitcoin-and-blockchain

⚡ A complete plan to learn and know everything about bitcoin and the blockchain world in general.

The Open Guide To Learning About Bitcoin And Blockchain

Why an Open Guide?

Please help

Getting Started

Create 2 Million records in a database from a single SQL query

Building a simple API with Golang using Gin-gonic

Introduction

Program preparation

Conclusion

What is ULID and why should you start using it?

Identifiers(IDs) in programming

UUID(Universally Unique IDentifier)

ULIDs(Universally Unique Lexicographically Sortable Identifier)

Example in Golang

Some modules in different programming languages

Node(20.6.0) now supports built-in .env files

Scheduling tasks in Golang with atomicgo

Which ORM to use for build an API with NodeJS ?

Understanding `lru_cache` and Its `maxsize` Parameter