DEV Community: Carlos Rivas

How to connect and query to Postgresql Golang vs Rust?

Carlos Rivas — Mon, 14 Mar 2022 14:10:03 +0000

How to connect to Postgresql Golang vs Rust?

Programming Languages war

Hey, my friends, a new post about this war. I don't know which is better, but I'll try to figure it out. I hope y'all enjoy this series. Here we go!

It's regular in the job environment to have to connect to databases, in this case, we're going to connect with Postgresql.

You only need to have to install the Postgresql server (Docker is good too 😉), in my case I had to create a database called "test" and a table called pokemon, pokemon has 3 fields, id, name, type.

Golang/Go

First, you need to install a package called "github.com/lib/pq", how to install this package?

Init the package main with the name of the folder.

go mod init name_folder

Get the package from the internet.

go get -u github.com/lib/pq

This package is A pure Go/Golang Postgres driver for Go's database/sql package, later we will see how to use it.

All Go/Golang scripts are the package, so remember to tell it what package is, In this case, is the main.

package main

Now import all packages we need to write this code.

import (
    "database/sql" // Package sql provides a generic interface around SQL (or SQL-like) databases. 
    "fmt" // implements formatted I/O
    "log" // implements a simple logging package

    _ "github.com/lib/pq" // Why has underscore at first, that's because I never had to call this package directly.
)

In Go/Golang all you define you have to use it, this is the reason why I have to use underscore because it's the way to define but never I'm going to use it this declaration.

Define a variable of connection to the database.

const (
    host     = "localhost"
    port     = 5432
    user     = "user"
    password = "password"
    dbname   = "test"
)

Define struct of database table.

type Pokemon struct {
    ID   int
    Name string
    Type string
}

Remember it's the main function because is the entry point to run.

Now, I have to define the connection's string, I need all variables defined before.
Open the connection with the method Open() from the SQL package with the driver name that I need and the connection's string.
Validate if the connection has an error. If it doesn't error call with "defer" the method Close() from the SQL package.

  psqlInfo := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable", host, port, user, password, dbname)
    db, err := sql.Open("postgres", psqlInfo)
    if err != nil {
        log.Fatal(err)
    }

  defer db.Close()

If you wonder what does "defer" does? It's simple when all code run, the last command will be the one you say in "defer".

It's time to catch a new Pokemon, who is this Pokemon?

I use the "struct" to define the values that I need to create the register.
After, I create a value with the SQL script to insert, returning the id.
With the method QueryRow, It needs the query and the values necessary to insert after that I use the method Scan to add the id to a struct called Pokemon.
I check if it has an error and print the register.

  myNewPokemon := Pokemon{
        Name: "Metapod",
        Type: "Bug",
    }

    insertSql := "INSERT INTO pokemons (name, type) VALUES ($1, $2) RETURNING id"
    err = db.QueryRow(insertSql, myNewPokemon.Name, myNewPokemon.Type).Scan(&myNewPokemon.ID)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("%+v\n", myNewPokemon)

Now, It's time to fight, Metapod I choose you.

In this case, I need to get one register from the database, the steps are similar:

I declare a variable with the type Struct. (This is only to show that each register is in different variables)
I create the SQL script to find it in the database.
With the method QueryRow, it executes the query with the value necessary, and with the method Scan, it inserts the register in the struct.
I check if it has an error and print the register.

  var myPokemon Pokemon
    selectSql := `SELECT * FROM pokemons WHERE id = $1`
    err = db.QueryRow(selectSql, myNewPokemon.ID).Scan(&myPokemon.ID, &myPokemon.Name, &myPokemon.Type)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("%+v\n", myPokemon)

What is that, is Metapod evolving?

Now, it's time to update:

I declare a variable with the type Struct. (This is only to show that each register is in different variables)
I create the SQL script to update the database.
With the method QueryRow, it executes the query with the value necessary, and with the method Scan, it inserts the register in the struct.
I check if it has an error and print the register.

    var evolution Pokemon
    updateSql := "UPDATE pokemons SET name = $1, type = $2 WHERE id = $3 RETURNING id, name, type"
    err = db.QueryRow(updateSql, "Butterfree", "Bug Flying", myPokemon.ID).Scan(&evolution.ID, &evolution.Name, &evolution.Type)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("%+v\n", evolution)

Anyone wants this moment?, but I have to let free my Butterfree, He fell in love:

I have to delete, remember the delete methods are so dangerous, be careful.

I declare a variable with the type Struct. (This is only to show that each register is in different variables)
I create the SQL script to delete the database.
With the method QueryRow, it executes the query with the value necessary, and with the method Scan, it inserts the register in the struct.
I check if it has an error and print the register.

    var byePokemon Pokemon
    deleteSql := "DELETE FROM pokemons WHERE id = $1 RETURNING id, name, type"
    err = db.QueryRow(deleteSql, evolution.ID).Scan(&byePokemon.ID, &byePokemon.Name, &byePokemon.Type)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("%+v\n", byePokemon)

I have good pokemons yet.

In the end, how to show all registers in the database:

I create the SQL script to read in the database.
With the method QueryRow, it executes the query with the value necessary.
I check if it has an error.
I have to close the connection with the method close, and I use "defer", you know why, if you don't know why, you can read a little higher.
I declare a variable with the type Struct, in this case, is an array because I want to show all pokemons.
I read each row and associate it with other variables in each column, with the method Scan.
I check if it has an error and add the register to the array.
Print the registers.

  rows, err := db.Query("SELECT * FROM pokemons")
    if err != nil {
        log.Fatal(err)
    }

    defer rows.Close()
    var myPokemons []Pokemon
    for rows.Next() {
        var pokemon Pokemon
        err = rows.Scan(&pokemon.ID, &pokemon.Name, &pokemon.Type)
        if err != nil {
            log.Fatal(err)
        }

        myPokemons = append(myPokemons, pokemon)
    }

    fmt.Printf("%+v\n", myPokemons)

Here is all my code in Go/Golang. And now it's our code. 🤓

package main

import (
    "database/sql"
    "fmt"
    "log"

    _ "github.com/lib/pq"
)

const (
    host     = "localhost"
    port     = 5432
    user     = "user"
    password = "password"
    dbname   = "test"
)

type Pokemon struct {
    ID   int
    Name string
    Type string
}

func main() {
    psqlInfo := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable", host, port, user, password, dbname)
    db, err := sql.Open("postgres", psqlInfo)
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // Create
    myNewPokemon := Pokemon{
        Name: "Metapod",
        Type: "Bug",
    }

    insertSql := "INSERT INTO pokemons (name, type) VALUES ($1, $2) RETURNING id"
    err = db.QueryRow(insertSql, myNewPokemon.Name, myNewPokemon.Type).Scan(&myNewPokemon.ID)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("%+v\n", myNewPokemon)

    // Read one register
    var myPokemon Pokemon
    selectSql := `SELECT * FROM pokemons WHERE id = $1`
    err = db.QueryRow(selectSql, myNewPokemon.ID).Scan(&myPokemon.ID, &myPokemon.Name, &myPokemon.Type)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("%+v\n", myPokemon)

    // Update
    var evolution Pokemon
    updateSql := "UPDATE pokemons SET name = $1, type = $2 WHERE id = $3 RETURNING id, name, type"
    err = db.QueryRow(updateSql, "Butterfree", "Bug Flying", myPokemon.ID).Scan(&evolution.ID, &evolution.Name, &evolution.Type)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("%+v\n", evolution)

    // Delete
    var byePokemon Pokemon
    deleteSql := "DELETE FROM pokemons WHERE id = $1 RETURNING id, name, type"
    err = db.QueryRow(deleteSql, evolution.ID).Scan(&byePokemon.ID, &byePokemon.Name, &byePokemon.Type)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("%+v\n", byePokemon)

    // Read all
    rows, err := db.Query("SELECT * FROM pokemons")
    if err != nil {
        log.Fatal(err)
    }
    defer rows.Close()

    var myPokemons []Pokemon
    for rows.Next() {
        var pokemon Pokemon
        err = rows.Scan(&pokemon.ID, &pokemon.Name, &pokemon.Type)
        if err != nil {
            log.Fatal(err)
        }

        myPokemons = append(myPokemons, pokemon)
    }
    fmt.Printf("%+v\n", myPokemons)

}

Rust

The first part is to add all dependencies necessary to execute this code. Remember these dependencies should add in the file Cargo.toml

[dependencies]
serde = { version = "1.0", features = ["derive"] } # framework for serializing and deserializing Rust data structures efficiently and generically.
postgres = "0.19.2" # A synchronous client for the PostgreSQL database.

Now I'm going to the file main.rs

First, call the modules necessary to run this code.

use serde::{Serialize};
use postgres::{Client, NoTls, Error};

Define struct of database table

[derive] This is able to implement a trait, which means that, how you can see, after this line, define a structure, I know that I need to get this information from a database, so, to achieve to serializing this information, I have to say how to structure with serializing or debug.

So, #[derive(Debug, Serialize)], Serialize, I used this to can change the name "type" to "ty" and Debug allows me to show variable with this operator {:?}

If you wonder why did I have to use rename? The reason is that type is a reserved keyword, then, exist two options.

using rename ( I like this more).
using r#type can escape reserved keywords.

#[derive(Debug, Serialize)]
struct Pokemon {
    id: i32,
    name: String,
    #[serde(rename = "type")]
    ty: String,
}

Remember it's the main function because is the entry point to run.

Now, I have to define the connection's string.
Open the connection with the method connect() from the SQL package with the string of connection.
To “unwrap” something in Rust is to say, “Give me the result of the computation, and if there was an error, panic and stop the program.”

    let mut client = Client::connect("postgresql://user:password@localhost:5432/test", NoTls).unwrap();

It's time to catch a new pokemon, who is this pokemon?

I use the "struct" to define the values that I need to create the register.
After, I create a value with the SQL script to insert, returning the id.
With the method query_one need the query and the values necessary to insert after that I use the method "get" to add the id to the struct called Pokemon.
Print the register.

    let mut my_new_pokemon = Pokemon {
        id: 0,
        name:  "Squirtle".to_string(),
        ty:  "Water".to_string(),
    };
    let insert_sql = "INSERT INTO pokemons (name, type) VALUES ($1, $2) RETURNING id";
    let row = client.query_one(insert_sql, &[&my_new_pokemon.name, &my_new_pokemon.ty])?;
    my_new_pokemon.id = row.get(0);
    println!("{:#?}", my_new_pokemon);

Now, It's time to fight, Squirtle I choose you.
In this case, I need to get one register from the database, the steps are similar:

I create the SQL script to find it in the database.
With the method query_one execute the query with the value necessary.
I declare a variable with the type Struct and with the method "get", I insert the register in the struct. (This is only to show that each register is in different variables)
Print the register.

    let select_sql = "SELECT * FROM pokemons WHERE id = $1";
    let row = client.query_one(select_sql, &[&my_new_pokemon.id])?;
    let my_pokemon = Pokemon {
        id: row.get(0),
        name:  row.get(1),
        ty:  row.get(2),
    };
    println!("{:#?}", my_pokemon);

What is that, is Squirtle evolving?
Now, it's time to update:

I create two variables with the name and type of this pokemon.
I create the SQL script to update the database.
With the method query_one execute the query with the value necessary.
I declare a variable with the type Struct and with the method "get", I insert the register in the struct. (This is only to show that each register is in different variables)
Print the register.

    let pokemon_name =  "Wartortle".to_string();
    let pokemon_type =  "Water".to_string();
    let update_sql = "UPDATE pokemons SET name = $1, type = $2 WHERE id = $3 RETURNING id, name, type";
    let row = client.query_one(update_sql, &[&pokemon_name, &pokemon_type, &my_pokemon.id])?;
    let evolution = Pokemon {
        id: row.get(0),
        name:  row.get(1),
        ty:  row.get(2),
    };
    println!("{:#?}", evolution);

Anyone wants this moment?, but I have to let free my Wartortle because is a great leader and the Squirtle squad need one, I know the story is not original.

I have to delete, remember the delete methods are so dangerous, be careful.

I create the SQL script to delete the database.
With the method query_one execute the query with the value necessary.
I declare a variable with the type Struct and with the method "get", I insert the register in the struct. (This is only to show that each register is in different variables)
Print the register.

    let delete_sql = "DELETE FROM pokemons WHERE id = $1 RETURNING id, name, type";
    let row = client.query_one(delete_sql, &[&evolution.id])?;
    let bye_pokemon = Pokemon {
        id: row.get(0),
        name:  row.get(1),
        ty:  row.get(2),
    };
    println!("{:#?}", bye_pokemon);

I have good pokemons yet.

In the end, how to show all registers in the database:

I declare a variable with the type Struct, in this case, is a vector because I want to show all pokemons.
I create the SQL script to read in the database, with the method query execute the query with the value necessary and I go through the rows that get the query.
I declare a variable with the type Struct and with the method "get", I insert the register in the struct. (This is only to show that each register is in different variables).
With the method push, I add to the vector each row.
Print the registers.

    let mut my_pokemons:Vec<Pokemon> = vec![];
    for row in client.query("SELECT * FROM pokemons", &[]).unwrap() {
        let pokemon = Pokemon {
            id: row.get(0),
            name: row.get(1),
            ty: row.get(2),
        };
        my_pokemons.push(pokemon);
    }
    println!("{:#?}", my_pokemons);

Here is all my code in Rust. And now it's our code. 🤓

use serde::{Serialize};
use postgres::{Client, NoTls, Error};

#[derive(Debug, Serialize)]
struct Pokemon {
    id: i32,
    name: String,
    #[serde(rename = "type")]
    ty: String,
}

fn main() -> Result<(), Error>{
    let mut client = Client::connect("postgresql://user:password@localhost:5432/test", NoTls).unwrap();

    // Create
    let mut my_new_pokemon = Pokemon {
        id: 0,
        name:  "Squirtle".to_string(),
        ty:  "Water".to_string(),
    };
    let insert_sql = "INSERT INTO pokemons (name, type) VALUES ($1, $2) RETURNING id";
    let row = client.query_one(insert_sql, &[&my_new_pokemon.name, &my_new_pokemon.ty])?;
    my_new_pokemon.id = row.get(0);
    println!("{:#?}", my_new_pokemon);

    // Read
    let select_sql = "SELECT * FROM pokemons WHERE id = $1";
    let row = client.query_one(select_sql, &[&my_new_pokemon.id])?;
    let my_pokemon = Pokemon {
        id: row.get(0),
        name:  row.get(1),
        ty:  row.get(2),
    };
    println!("{:#?}", my_pokemon);

    // Update
    let pokemon_name =  "Wartortle".to_string();
    let pokemon_type =  "Water".to_string();
    let update_sql = "UPDATE pokemons SET name = $1, type = $2 WHERE id = $3 RETURNING id, name, type";
    let row = client.query_one(update_sql, &[&pokemon_name, &pokemon_type, &my_pokemon.id])?;
    let evolution = Pokemon {
        id: row.get(0),
        name:  row.get(1),
        ty:  row.get(2),
    };
    println!("{:#?}", evolution);

    // Delete
    let delete_sql = "DELETE FROM pokemons WHERE id = $1 RETURNING id, name, type";
    let row = client.query_one(delete_sql, &[&evolution.id])?;
    let bye_pokemon = Pokemon {
        id: row.get(0),
        name:  row.get(1),
        ty:  row.get(2),
    };
    println!("{:#?}", bye_pokemon);

    // Read all
    let mut my_pokemons:Vec<Pokemon> = vec![];
    for row in client.query("SELECT * FROM pokemons", &[]).unwrap() {
        let pokemon = Pokemon {
            id: row.get(0),
            name: row.get(1),
            ty: row.get(2),
        };
        my_pokemons.push(pokemon);
    }
    println!("{:#?}", my_pokemons);
    Ok(())
}

Conclusion

Structure: It's similar, Maybe the principal difference between them, it's that Go/Golang uses "if" in each iteration to validate if has an error, this is because Go/Golang doesn't have exceptions.
Lines: Golang: 91, Rust: 69
Easy to get information: For me It was easier to get information from Go/Golang than Rust.
Execution time: In this example, the difference is not decisive.

Would you like that I write more info about the database? What would be your first pokemon?

I hope you enjoy my post and remember that I am just a Dev like you!

How to create a rest API client Golang vs Rust?

Carlos Rivas — Mon, 24 Jan 2022 14:16:19 +0000

How to create a rest API client Golang vs Rust?

Programming Languages war

Hey, my friends, a new post about this war.

I don't know which is better, but I'll try to figure it out. I hope y'all enjoy this series. Here we go!

A RESTful API is an architectural style for an application program interface (API) that uses HTTP requests to access and use data.

Why the people use that? It's because every time we have to communicate between microservices o services, obviously exist other ways to communicate that, but it's the most popular.

In this case, I'm going to use an API about Chuck Norris Jokes, and how I can get information to manipulate between endpoints.

The endpoint is the URL where we can get information.

Golang/Go

The first part is to import all packages necessary to execute this code.

package main

import (
    "encoding/json" // package json implements encoding and decoding of JSON
    "fmt" // implements formatted I/O
    "io/ioutil" // implements some I/O utility functions
    "log" // implements a simple logging package
    "math/rand" // implements pseudo-random number generators unsuitable for security-sensitive work
    "net/http" // provides HTTP client and server implementations
    "time" // provides functionality for measuring and displaying time

    "github.com/davecgh/go-spew/spew" // implements a deep pretty printer for Go data structures to aid in debugging.
)

The next code define the structure of how to manipulate the response from API

type Joke struct {
    ID         string   `json:"id"`
    Value      string   `json:"value"`
    Categories []string `json:"categories"`
    URL        string   `json:"url"`
    CreatedAt  string   `json:"created_at"`
    IconURL    string   `json:"icon_url"`
    UpdatedAt  string   `json:"updated_at"`
}

The next code is the main function, remember it's the main function because is the entry point to run.

What does the main function do?

I initialize the time, why I do that, it's to know how long the execution lasts, next, I call the function getCategory (I'm going to explain this function after spoiler alert, get a category), after that with this information I call other function call getJoke( You know what happen here), in the end, I calculate the time and print the execution lasts.

func main() {
    start := time.Now()

    var category = getCategory()

    getJoke(category)
    elapsed := time.Since(start)
    fmt.Printf("Execution lasts: %s\n", elapsed)
}

I hope you're enjoying this post, I enjoy doing that. OK, I'm going to continue with this:

getCategory function:

I start my HTTP client, this client is who can get information from endpoint or services, so, It's who will tell us the joke, but first the category, after that, I use another method from HTTP, NewRequest, this method makes the request, what do I need for a request?

Verb + Endpoint or URL + data, in this case, we don't need data but what happens here, in Golang we have the use the keyword nil, to say I don't have data to send you.

this method returns two values, request or error.

I validate if I don't have errors and if I don't have anything to cry I can continue.

After, I use our client to call the method Do with the value request and to receive two values, response or error.

Again I cross my fingers and pray for good news.

I read the body responds with the method ReadAll from the package ioutil, and again I can receive two values (I know, I know), body or error.

It's important to know-how is the response, you can use the client to that (Hoppscotch or Postman) or print your body (fmt.Printf("%s", body)), Exist different ways to show you the response, but the most popular is JSON.

What means []string, this is a type of data, it says an array of strings, after that I use the method Unmarshal from JSON to say this information that is a JSON and I know is an array of string put in a variable that I defined as an array of strings, but, this method only returns one value, if it's an error, what happens is not an error? the variable bodyArray gets the data in this format.

You can ask why I have to convert my data in an array of strings, this is because is the ways easiest to use this information.

I receive an array with 16 positions, which means I have 16 strings which mean different categories, but I need one.

My option is to get this information randomly, for that, I use the method Seed from rand package to say that for each execution I want other numbers.

In the end, I have to return a value from my array, with this method I get an integer value between 0 and the length of array rand.Intn(len(bodyArray).

This return something like that for instance "bodyArray[10]"

func getCategory() string {
    client := http.Client{}
    request, err := http.NewRequest("GET", "https://api.chucknorris.io/jokes/categories", nil)
    if err != nil {
        log.Fatal(err)
    }
    response, err := client.Do(request)
    if err != nil {
        log.Fatal(err)
    }
    defer response.Body.Close()

    body, err := ioutil.ReadAll(response.Body)
    if err != nil {
        log.Fatal(err)
    }

    var bodyArray []string
    newErr := json.Unmarshal(body, &bodyArray)
    if newErr != nil {
        log.Fatal(newErr)
    }
    rand.Seed(time.Now().UnixNano())

    return bodyArray[rand.Intn(len(bodyArray))]
}

getJoke function:

The first steps are the same as the before function, the unique difference is the endpoint and response format.

The Unmarshal method is from the JSON package, translating the body response to joke structure.

Now it's time to use the Dump and the structure. Well, I'm going to start at the beginning.

the Dump is only to show the pretty way a structure something like that

{
 ID: (string) (len=22) "0wdewlp2tz-mt_upesvrjw",
 Value: (string) (len=136) "Chuck Norris does not follow fashion trends, they follow him. But then he turns around and kicks their ass. Nobody follows Chuck Norris.",
 Categories: ([]string) (len=1 cap=4) {
  (string) (len=7) "fashion"
 },
 URL: (string) (len=55) "https://api.chucknorris.io/jokes/0wdewlp2tz-mt_upesvrjw",
 CreatedAt: (string) (len=26) "2020-01-05 13:42:18.823766",
 IconURL: (string) (len=59) "https://assets.chucknorris.host/img/avatar/chuck-norris.png",
 UpdatedAt: (string) (len=26) "2020-01-05 13:42:18.823766"
}

But if you want to use any value from this structure, you have to use variable name + . + structure value name.

Ex: joke.Value

func getJoke(category string) {
    client := http.Client{}
    request, err := http.NewRequest("GET", "https://api.chucknorris.io/jokes/random?category="+category, nil)
    if err != nil {
        log.Fatal(err)
    }

    response, err := client.Do(request)
    if err != nil {
        log.Fatal(err)
    }
    defer response.Body.Close()

    body, err := ioutil.ReadAll(response.Body)
    if err != nil {
        log.Fatal(err)
    }

    var joke Joke
    newErr := json.Unmarshal(body, &joke)
    if newErr != nil {
        log.Fatal(newErr)
    }

    spew.Dump(joke)
    fmt.Println(joke.Value)
}

Here is all my code in Golang.

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "log"
    "math/rand"
    "net/http"
    "time"

    "github.com/davecgh/go-spew/spew"
)

type Joke struct {
    ID         string   `json:"id"`
    Value      string   `json:"value"`
    Categories []string `json:"categories"`
    URL        string   `json:"url"`
    CreatedAt  string   `json:"created_at"`
    IconURL    string   `json:"icon_url"`
    UpdatedAt  string   `json:"updated_at"`
}

func main() {
    start := time.Now()

    var category = getCategory()

    getJoke(category)
    elapsed := time.Since(start)
    fmt.Printf("Execution lasts: %s\n", elapsed)
}

func getCategory() string {
    client := http.Client{}
    request, err := http.NewRequest("GET", "https://api.chucknorris.io/jokes/categories", nil)
    if err != nil {
        log.Fatal(err)
    }
    response, err := client.Do(request)
    if err != nil {
        log.Fatal(err)
    }
    defer response.Body.Close()

    body, err := ioutil.ReadAll(response.Body)
    if err != nil {
        log.Fatal(err)
    }

    var bodyArray []string
    newErr := json.Unmarshal(body, &bodyArray)
    if newErr != nil {
        log.Fatal(newErr)
    }
    rand.Seed(time.Now().UnixNano())

    return bodyArray[rand.Intn(len(bodyArray))]
}

func getJoke(category string) {
    client := http.Client{}
    request, err := http.NewRequest("GET", "https://api.chucknorris.io/jokes/random?category="+category, nil)
    if err != nil {
        log.Fatal(err)
    }

    response, err := client.Do(request)
    if err != nil {
        log.Fatal(err)
    }
    defer response.Body.Close()

    body, err := ioutil.ReadAll(response.Body)
    if err != nil {
        log.Fatal(err)
    }

    var joke Joke
    newErr := json.Unmarshal(body, &joke)
    if newErr != nil {
        log.Fatal(newErr)
    }

    spew.Dump(joke)
    fmt.Println(joke.Value)
}

Rust

The first part is to add all dependencies necessary to execute this code. Remember these dependencies should add in the file Cargo.toml

[dependencies]
reqwest = { version = "0.11", features = ["json"] } # provides a convenient, higher-level HTTP Client.
tokio = { version = "1", features = ["full"] } # an event-driven, non-blocking I/O platform for writing asynchronous applications
serde = { version = "1", features = ["derive"] }  # framework for serializing and deserializing Rust data structures efficiently and generically.
serde_json = "1.0" # A JSON serialization file format
futures = "0.3" # provides a number of core abstractions for writing asynchronous code
rand = "0.8.4" # provides utilities to generate random numbers

Now I'm going to the file main.rs

First, call the modules necessary to run this code.

use rand::Rng;
use serde::Deserialize;
use std::time::Instant;
use reqwest::Client;

#[derive] This is able to implement a trait, which means that, how you can see, after this line, define a structure, I know that I need to get this information from a JSON, so, to achieve to deserializing this information, I have to say how to structure with deserializing or debug.

So, #[derive(Deserialize, Debug)], Deserialize can translate a JSON in a struct and Debug allows me to show variable with this operator {:?}

#[derive(Deserialize, Debug)]
struct Joke {
    id: String,
    value: String,
    categories: Vec<String>,
    created_at: String,
    icon_url: String,
    updated_at: String,
    url: String,
}

The #[tokio::main] function is a macro. It transforms the async fn main() into a synchronous fn main() that initializes a runtime instance and executes the async main function. Here can you read a little more information about tokio

The next code is the main function, remember it's the main function because is the entry point to run.

What does the main function do?

I initialize the time, why do I do that? it's to know how long the execution lasts, next, I call the function get_category (I'm going to explain this function after, spoiler alert, get a category, looks like a Deja bu), after that with this information I call another function call get_joke( You know what happen here), in the end, I calculate the time and print the execution lasts.

#[tokio::main]
async fn main() {
    let start = Instant::now();
    let category = get_category().await;
    get_joke(category).await;
    let end = start.elapsed();
    println!("Execution lasts: {:?}", end);
}

get_category function:

First, I define the function and say what type of data I have to return.

After I instantiate and I use the method get who needs the endpoint or URL how parameter, next, the method send() and await (Can you guess what does it do?) and unwrap.

To “unwrap” something in Rust is to say, “Give me the result of the computation, and if there was an error, panic and stop the program.” If you want to know a little more about Error Handling

Then, I translate the JSON response to Vector of String.

Count the length to the categories response.

Retrieve the lazily-initialized thread-local random number generator, seeded by the system. More info

return a string randomly from 0 and the length in categories.

async fn get_category() -> String {
    let res1 = Client::new()
        .get("https://api.chucknorris.io/jokes/categories")
        .send()
        .await
        .unwrap();

    let categories = res1.json::<Vec<String>>().await.unwrap();
    let count = categories.len();
    let mut rng = rand::thread_rng();

    categories[rng.gen_range(0..count)].to_string()
}

get_joke function:

The first steps are the same as the before function, the unique difference is the endpoint and response format.

format! is a macro that allows uniting two or more strings.

Then, I translate the JSON response to the Joke struct.

If you ask the difference between {#?} and {?} It's only to show pretty the structure and looks like that:

Joke {
    id: "6sdvoj-msgi6miv07ekctq",
    value: "Chuck Norris is currently suing myspace for taking the name of what he calls everything around you.",
    categories: [
        "dev",
    ],
    created_at: "2020-01-05 13:42:19.104863",
    icon_url: "https://assets.chucknorris.host/img/avatar/chuck-norris.png",
    updated_at: "2020-01-05 13:42:19.104863",
    url: "https://api.chucknorris.io/jokes/6sdvoj-msgi6miv07ekctq",
}

But if you want to use any value from this structure, you have to use variable name + . + structure value name.

Ex: joke.value

async fn get_joke(category: String) {
    let res1 = Client::new()
        .get(format!(
            "https://api.chucknorris.io/jokes/random?category={}",
            category
        ))
        .send()
        .await
        .unwrap();

    let joke = res1.json::<Joke>().await.unwrap();
    println!("{:#?}", joke);
    println!("{:?}", joke.value);
}

Here is all my code in Rust.

use rand::Rng;
use serde::Deserialize;
use std::time::Instant;
use reqwest::Client;


#[derive(Deserialize, Debug)]
struct Joke {
    id: String,
    value: String,
    categories: Vec<String>,
    created_at: String,
    icon_url: String,
    updated_at: String,
    url: String,
}

#[tokio::main]
async fn main() {
    let start = Instant::now();
    let category = get_categories().await;
    get_joke(category).await;
    let end = start.elapsed();
    println!("Execution lasts: {:?}", end);
}

async fn get_category() -> String {
    let res1 = Client::new()
        .get("https://api.chucknorris.io/jokes/categories")
        .send()
        .await
        .unwrap();

    let categories = res1.json::<Vec<String>>().await.unwrap();
    let count = categories.len();
    let mut rng = rand::thread_rng();

    categories[rng.gen_range(0..count)].to_string()
}

async fn get_joke(category: String) {
    let res1 = Client::new()
        .get(format!(
            "https://api.chucknorris.io/jokes/random?category={}",
            category
        ))
        .send()
        .await
        .unwrap();

    let joke = res1.json::<Joke>().await.unwrap();
    println!("{:#?}", joke);
    println!("{:?}", joke.value);
}

Conclusion

Structure:
Golang needs more steps to get and to read the information from the endpoint.
Golang uses camelCase structure to define variables and functions, but, Rust uses snake_case.
Golang used 88 lines of code and Rust used 54 plus 16 lines from Cargo.toml files

Lasts
I run 5 times each code and get this average:
Golang: 3.33s
Rust: 4.44s

But I think it is not enough to know who is better.

What do you think? Do you want to know a little more about API Client and other methods?

If you want to know a little more about Golang or Rust

I hope you enjoy my post and remember that I am just a Dev like you!

Programming Languages war Golang vs Rust Define Variables

Carlos Rivas — Fri, 26 Nov 2021 13:55:29 +0000

Define Variables

Hey, my friends, a new post about this war.

I don't know which is better, but I'll try to figure it out. I hope y'all enjoy this series. Here we go!

In this opportunity I'm going to check up the deep basic information that these languages could hide, I think I'm being dramatic. 😅

We're going to figure out how to define variables.

I'm going to do a little script with all examples and a little more. =D

Variables

It's a space of memory where you could save information what you need to manipulate. These two languages need to define the type of variable in front of the name or not. It's important to say that exist boolean, numbers, strings, and others.

Golang/Go

Before defining variables, I'm going to write about the structure

Do you remember our hello.go

hello.go

package main import "fmt"
func main() {
  fmt.Println("Hello, World!")
}

The first line: Tells the Go compiler that the package should compile as an executable.
Second line: Import fmt, fmt is a core library package that contains functionalities related to formatting and printing output.
And the end func main() is the entry point of an executable program.

Now you know theory things now I'm going to make magic. Ok no. I'm going to make code.

It's indispensable that you know that exist var and const like special words to define variables and constants.

Example

const NAME string = "Luffy"
func main() {
  var country string = "Brazil"
  fmt.Printf("Hello, %s from %s\n", NAME, country)
}

But Go is so smart, then doesn't need that you tell him the type, he can discover it.

Example

func main() {
  var color = "Blue"
  var number = 20
  fmt.Printf("Type: %T Value: %v\n", number, number)
  fmt.Printf("Type: %T Value: %v\n", color, color)
}

These are all basic types of variables that exist in Golang

Boolean: bool

String: string

Integers:
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr

Byte:
byte // alias for uint8

Rune:
rune // alias for int32
// represents a Unicode code point

Float:
float32 float64

Complex:
complex64 complex128

The last trick that I'm going to use is to disappear the word "var"

func main() {
  crew := "Straw Hat Pirates"
  fmt.Printf("Type: %T Value: %v\n", crew, crew)
}

I almost forget something important, the zero value, what means that?

func main() {
  var i int
  var f float64
  var b bool
  var s string
  fmt.Printf("%v %v %v %q\n", i, f, b, s)
}

Each type of variable has a value by default, Then if you declare a variable, but you don't initialize it, the variable is going to take the default value.

You can use any method to declare a variable, but I recommend that you should specify the datatype to new variables.

The last challenge if you want to try it. What if?

func main() {
  number := 1 number = "one"
  fmt.Printf("%v \n", number)
}

Rust

Before defining variables, I'm going to write about the structure. What is that, a déjà vu?

Do you remember our main.rs

main.rs

fn main() {
  println!("Hello, world!");
}

fn main() is always the first code that runs in every executable Rust program.

Rust has Variables, Variables Mutability, and Constants

It's indispensable that you know that exist let, let mut, and const like special words to define variables and constants.

Example

const NAME: &str = "Nami";
fn main() {
  let country: &str = "Swedish";
  println!("Hello, {} from {}!", NAME, country);
}

The difference between let and let mut, let: you can't change the value of the variable, and let mut you can.

But if "let" you can't change and constant either, what is the difference?

In addition to the declaration are "let" or "const", in the constant the type of the value must be annotated and can be declared in any scope.

Rust is so smart too because it doesn't need that you tell him the type, he can discover it.

Example

use typename::TypeName;
fn main() {
  let color = "Blue";
  let number = 18;
  println!("Type: {}, value: {}", color.type_name_of(), color);
  println!("Type: {}, value: {}", number.type_name_of(), number);
}

Add this like dependence, in the file Cargo.toml

[dependencies]typename = "0.1.1"

I know that I haven't explained that, but believe me, it's way easier to show the type of data with this method, in another post, I'm going to explain that.

These are all basic types of variables that exist in Rust

Boolean: bool

String: &str

Character: char

Integers:
i8 i16 i32 i64 i128 isize
u8 u16 u32 u64 u128 usize

Float:
f32 f64

Rust does not have NULL, then you can't do something like that:

fn main() {
  let color: &str;
  let number: i8;
  println!("Value: {}", number);
  println!("Value: {}", color);
}

And again the same challenge, what if?

fn main() {
  let mut number = 1;
  number = "one";
  println!("Value: {}", number);
}

The last thing that you should know, I am sure you noticed semicolon use, is not mandatory in the last line of code, but if you have to write more than one line, you have to use a semicolon.

My recommendation about semicolons is to use them all the time. But if you forget, the language will tell you. 😉

Conclusion

Structure: They are very similar but Golang is easier than Rust because you don't have to use a semicolon or external dependence to print type of value, and Rust for now is not possible to use null or zero value.

Then this time Golang takes a little advantage over Rust.

But I think it is not enough to know who is better.

What do you think? Is the same for you?

I hope you enjoy my post and remember that I am just a Dev like you!

Programming Languages war Golang vs Rust

Carlos Rivas — Sat, 20 Nov 2021 02:21:29 +0000

Install new fighters

I'm back, first if anyone miss my post I offer my apologizes, but I was without inspiration, but I'm here again with new fighters.

Ladies and gentlemen, in this corner first appeared in 2009 with memory safety, garbage collection, structural typing and is loved according to Stack Overflow 2021 by 62.74% Goooooolang

Now the next fighter had the first appeared in 2010 with memory safety without garbage collection, reference counting is optional and is loved according to Stack Overflow 2021 by 86.98% Ruuuuuuuust.

Note: Please read that like WWE or Boxing presentations.

Now we're going with the tech stuff, but remember, I don't know which is better, but I'll try to figure it out. I hope y'all enjoy this series. Obviously We have to start the installation and amazing "Hello, World!". The whole series I'm going to use SO Ubuntu, then if you need support for other SO I'm going to be here to help you.

Pre requirements

Install curl

apt install curl

Golang/Go

This is our recipe to install Golang/Go

Step 1:

Download golang from the website https://golang.org/doc/install#download I recommend to use curl to download the file

curl https://dl.google.com/go/go1.17.3.linux-amd64.tar.gz --output go1.17.3.linux-amd64.tar.gz

Step 2

Now you have to decompress the file in folder /usr/local

rm -rf /usr/local/go && tar -C /usr/local -xzf go1.17.3.linux-amd64.tar.gz

Step 3

Add to the file .bashrc the next line

export PATH=$PATH:/usr/local/go/bin

After that, close the shell or run

. .bashrc

If you run that and has an output, all was good

go version

Step 4

Create a folder and join in it

mkdir hello
cd hello/

Step 5

You have to enable dependency tracking for your code

go mod init example/hello

Step 6

You have to create a file, can you guess the name?
Image tic tac

hello.go

  package main

  import "fmt"

  func main() {
      fmt.Println("Hello, World!")
  }

Step 7

It's time to run our program

go run .

Rust

This is our recipe to install Rust

Pre requirements
Install build-essential

apt install build-essential

Step 1

Download the tools that you need to run the rust language from the website https://www.rust-lang.org/tools/install

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

You only require to choose the first option

And run that

source $HOME/.cargo/env

Step 2

This tool is called "cargo", this tool creates all structure for you and do other things, but this time only you create the structure

cargo new hello_world

By default, "cargo" creates this structure with the file to make our "Hello world!"

  fn main() {
      println!("Hello, world!");
  }

Step 3

It's time to run our program, you can guess how to?

cargo run

Resume

Entertainment fight, Golang starts with its better punch, show a simple structure, but Rust responds with fewer steps to run, Golang requires import the package "fmt" to print with "Println" something and Rust needs to use the macro Println, by the way both have the same method ending with "ln" you know why? To add a break line.

This is our first view about two amazing languages, how you could see we can use any language in so many environments for the same things, but which is better, today we can see a few conclusions:

Golang/Go requires more step to run.
Golang requires import packages to print, and Rust uses macros to the same.
Rust in addition to the language, install the tool "cargo" can run and create the structure base to Rust.

I hope you enjoy my post and remember that I am just a Dev like you!

My first conference

Carlos Rivas — Tue, 30 Jun 2020 15:18:18 +0000

Today I want to say how I felt about this first conference called Unconf 2020, When I arrived the email, It was very strange, they tell me, somebody recommends me, for I will be a part of a conference, The first I thought to be this message is real?, I used twitter for looking for about this conference, I didn’t anything about this, then I thought it’s not real, Then I told my wife that I had been invited to a conference about tech o remote work, but I think is false, My wife told me, but you are looking for in google, then I googled this conference and I found it, It was a feel a little strange, but It was real.

Then I join my personal data, I selected which subject I want to talk, then arrived a second email. It said the conference will be in English. It’s not possible, they told me that it was like a conference TED 5 minute, a little introduce me, then my wife told me you have to do, Then I started to write in Spanish my speech, I have to think about what I want to write, then I tell myself I want to talk about remote work, I had a lot time before pandemic worked whit this method then I think I can talk about this.

I wrote my speech while the days pass, I have thought yet may be false, Who invited me, I choose no write in my twitter about this, I don’t want feeling dispoinment.
June 20th, 2020, I wake up early, I practice my speech in English over and over, My speech will be at 11:00 am Venezuela, then I joined in the zoom, I was the last people who talk this day, I was very nervous, the other people speak English very well, I don’t speak English yet, but I don’t give up I’m going to try all times, obviously I had a lot fear but, when was my turn I said what I had to read and this was my speech:

“ Hi, my name is Carlos Rivas I’m a developer from Venezuela, I was thinking about what I can talk about, code maybe, javascript, php, but the first thing I really thought about was because I, I did that someone recommended me, who recommended me or if this was true, It’s obviously true, but what I mean is that impostor syndrome called me again.

And not only that, the mail that arrives to me says that the presentation is in English, I do not speak English, but I promised not to give up and here I am from Venezuela, against all adversity and prognosis, with bad internet, with bad electrical system, with daily problems, but happy. I can do what I like: program. Thanks to the COVID new job opportunities appeared and I am not afraid to try every day, to strive every day to be better professional, better person. Thanks to technology we can communicate better, we can be better professionals and we can compete with us to be better every day and surpass ourselves.

So what am I gonna talk about?
I decided it was work from home. It’s the most wonderful invention from the light, having a couch to lay on, a shoulder to cry on or a warm hug to motivate you, which we don’t usually have working from an office for fear of the one they’ll say, maybe, because someone’s gonna look weak, or take advantage of you, because let’s be realistic it’s very common! but in the house, you can be as strong as the arms that embrace you or as confident as the good morning or as motivated as the children wanting to be Messi or Ter Stegen, you can be your, with your fears, failures and self-destruction, but with your joy, your dreams and illusions, it’s obviously hard to have a meeting with kids running around, or screaming because one hit the ball to the other, but that’s also you, the father, the friend, the husband, the student, the one who knows nothing when I miss a semicolon or the one who knows everything when the code compiles at first. All those you, you get stronger every day, maybe someday I’ll go back to work in an office, but I don’t really want it.

Let’s always remember that our office doesn’t have to be a particular place, I just know that we should stay comfortable with our space, if you have a great space better, but if you have a small desk that meets all your needs that will guarantee you better concentration and performance in your activities.

In the end what I want to convey is that we must value that which many thought was the best thing to separate the work from the house, so as not to carry unnecessary burdens from one side to the other, But maybe that mix is the one that will give you more peace of mind, more opportunities and more courage in facing the new problems, says a Venezuelan who asked for all the problems for us.

So remote work for me was what I looked for so long, I looked for happiness and found remote work.

And as Muhamad Ali said, “Don’t count the days, make the days count.”

Thank you.”

Now I am very proud, I do not give up, this day I chose I have to help many people who are afraid to try. If I can, you can.

Because I am a dev like you!