DEV Community: Khair Alanam

Rust Tutorial 5: Let's Build a Simple Calculator! (Part 2)

Khair Alanam — Thu, 28 Dec 2023 10:15:56 +0000

Reading Time: 15 minutes

Welcome back to the Rust Tutorial Series!

We will be continuing the simple calculator project, and on the way learn new concepts like tuples, arrays, etc.

So, let's get started!

More functions!

Going back to the code, notice that for the operations we do, we are doing them in our main code and not refactored into separate functions.

Now for this project, our functions are all one-liners. But it's a good practice to keep operations as separate functions so that we can maintain the readability of our main program code.

So, let's write functions for each of the operations:


 rust
fn add(x: f64, y: f64) -> f64 {
    return x + y;
}

fn subtract(x: f64, y: f64) -> f64 {
    return x - y;
}

fn multiply(x: f64, y: f64) -> f64 {
    return x * y;
}

fn divide(x: f64, y: f64) -> f64 {
    return x / y;
}

Now, let's replace each of the operations in the match statement op with these functions:



use std::io;

fn main() {

    // rest of the code

    match op {
        1 => result = add(x, y),
        2 => result = subtract(x, y),
        3 => result = multiply(x, y),
        4 => result = divide(x, y),
        _ => {
            println!("Invalid selection");
            return;
        }
    }

    println!("The result is: {}", result);
}

Now that looks good. Let's get back to our four functions again.

Remember this block of code from a previous tutorial?


 rust
fn main() {
    let some_num: i32 = {
        let x: i32 = 45;
        let y: i32 = 34;
        x + y
    };

    println!("{}", some_num);
}

And remember that odd-looking x + y line of code that returns itself to the some_num variable? Well, we can do that in functions too!

In our four functions, we can remove the return keyword and the semi-colon to just do the same thing:


 rust
fn add(x: f64, y: f64) -> f64 {
    x + y
}

fn subtract(x: f64, y: f64) -> f64 {
    x - y
}

fn multiply(x: f64, y: f64) -> f64 {
    x * y
}

fn divide(x: f64, y: f64) -> f64 {
    x / y
}

These are still valid functions! These "naked returns" can be tricky to someone who isn't used to Rust. But just know that Rust can do this :D

Let's take a look at this part of the code we wrote:


 rust
match op {
        1 => result = add(x, y),
        2 => result = subtract(x, y),
        3 => result = multiply(x, y),
        4 => result = divide(x, y),
        _ => {
            println!("Invalid selection");
            return;
        }
    }

Notice that the numbers are not random and they are ordered?

Wouldn't it be nice to keep them in an ordered sequence in such a way that I can just access them via "indices", and get rid of the entire match statement completely?

That's where tuples and arrays come in!

Tuples

Tuples are compound data structures that can hold different types of data. These data are enclosed in parentheses (). They are fixed in length.


 rust
    let my_tup = (1, true, "Hello");

To add types for a tuple, you have to specify the type for each data inside the tuple in the exact order, enclosed in parentheses like this:


 rust
    let my_tup: (i32, bool, &str) = (1, true, "Hello");

We will get to know more about tuples in the later sections.

Arrays

Arrays are just like tuples in many ways, except unlike tuples, they can only hold values of the same data type. These data are enclosed in square brackets []. They are also fixed in length.


 rust
    let my_arr = [1, 2, 3, 4, 5];

To add types for an array, you have to specify two parameters enclosed in square brackets; the first is the data type for each value in the array, and the second is the length of the array. These parameters are separated by a semi-colon. Here's what it looks like:


 rust
    let my_arr: [i32; 5] = [1, 2, 3, 4, 5];

We will get to know more about arrays in the later sections.

Accessing values in tuples and arrays

If you ever come across accessing values in arrays or lists in other programming languages, then it is almost identical here in Rust. Rust follows zero-indexing, that is the first element is in the 0th index, the second element is in the 1st index, and so on.

However, The syntax to access values in arrays is very different from that of tuples. Let me show you:


 rust
fn main() {
    let my_arr: [i32; 5] = [1, 2, 3, 4, 5];
    let my_tup: (i32, f64, bool) = (23, 16.4, false);

    println!("{}", my_arr[0]);  // prints 1
    println!("{}", my_tup.1);   // prints 16.4
}

If you notice, we use square brackets to access any element in an array based on the given index. However, in tuples, we use dot notation.

Also, just a quick note, if you want to print the entire tuple or array in one print statement. We have to use the {:?} formatting instead of {} to do the same:


 rust
    let my_arr: [i32; 5] = [1, 2, 3, 4, 5];
    let my_tup: (i32, f64, bool) = (23, 16.4, false);

    println!("{:?}", my_arr);
    println!("{:?}", my_tup);

Now let's get back to our project.

Let's create an array of length four to enclose all the four operations:


 rust
let ops = [add, subtract, multiply, divide];

Remember when adding the function names in the array or tuple, you should not use parentheses along with the function name.

Now you might be thinking, what will be the data type of a function?

It's not necessary to mention types during declaration as Rust infers the type from the given value. However, here's what it looks like:


 rust
let ops: [fn(f64, f64) -> f64; 4] = [add, subtract, multiply, divide];

Let's break down the function type:

Firstly, we have the fn keyword to signify that the values given inside the ops array are functions.
Then we have two f64s enclosed inside the fn keyword. This is to signify the data types of parameters of these four functions. If you remember, all these four functions take two decimals as arguments which are of f64 type.
Lastly, we have the f64 after an arrow ->. This is the return type of the function. As you can notice, every function in the given array returns a decimal of type f64.

That's pretty much the breakdown. To summarise this bit, if you are including the functions in your array, make sure they have these checked:

All the values are of the fn type
The number of parameters AND the datatypes of each of the parameters IN the exact order are the same for every function.
Finally, the return type for each function has to be the same.

Now that we have our operations array, we can completely remove the match case statement and just use the desired operation based on the selection given:

So let's write this one line of code by replacing the match case statement:


 rust
result = ops[op - 1];

You will get an error saying that you cannot use an i32 as an index. So for indexing, you have to use the type casting to convert op - 1's type of i32 to something called usize which is the type defined for those variables that act as pointers to the array elements.

It will look like this:


 rust
result = ops[(op - 1) as usize];

Later, you will get a mismatched type error. This is because the result variable is of type f64 but you are assigning an array element of type fn, hence the mismatched type.

So to fix this, you have to "call" the operation along with arguments x and y using parentheses.

If the above sounds confusing, here's what it looks like:


 rust
result = ops[(op - 1) as usize](x, y);

Finally, we have to put an if check to see if the op lies in the range of 1 to 4 before assigning the result to the result variable, or else we will get the "out of range" error.


 rust
if op > 4 || op < 1 {
    println!("Invalid Selection!");
    return;
}

result = ops[(op - 1) as usize](x, y);

Now, the final code will look like this:


 rust
use std::io;

fn main() {
    let result: f64;
    let ops: [fn(f64, f64) -> f64; 4] = [add, subtract, multiply, divide];

    println!("Enter the first number: ");
    let x: f64 = input_parser();

    if f64::is_nan(x) {
        println!("Invalid input!");
        return;
    }

    println!("Enter the second number: ");
    let y: f64 = input_parser();


    if f64::is_nan(y) {
        println!("Invalid input!");
        return;
    }

    println!("List of operators:");
    println!("(1) Add");
    println!("(2) Subtract");
    println!("(3) Multiply");
    println!("(4) Divide");
    println!("Select the number associated with the desired operation: ");

    let op: f64 = input_parser();

    if f64::is_nan(op) {
        println!("Invalid input!");
        return;
    }

    let op: i32 = op as i32;

    if op > 4 || op < 1 {
        println!("Invalid Selection!");
        return;
    }

    result = ops[(op - 1) as usize](x, y);

    println!("The result is: {}", result);
}

fn input_parser() -> f64 {
    let mut x: String = String::new();
    io::stdin().read_line(&mut x).expect("Invalid Input");
    let x: f64 = match x.trim().parse() {
        Ok(num) => num,
        Err(_) => {
            return f64::NAN;
        }
    };

    return x;
}

fn add(x: f64, y: f64) -> f64 {
    x + y
}

fn subtract(x: f64, y: f64) -> f64 {
    x - y
}

fn multiply(x: f64, y: f64) -> f64 {
    x * y
}

fn divide(x: f64, y: f64) -> f64 {
    x / y
}

Now let's make this calculator work as much as we want to by wrapping the logic inside a loop statement.

Here's the final code:


 rust
use std::io;

fn main() {
    let mut result: f64;
    let mut y_or_n: String = String::new();
    let ops: [fn(f64, f64) -> f64; 4] = [add, subtract, multiply, divide];

    loop {
        println!("Enter the first number: ");
        let x: f64 = input_parser();
        if f64::is_nan(x) {
            println!("Invalid input!");
            return;
        }

        println!("Enter the second number: ");
        let y: f64 = input_parser();


        if f64::is_nan(y) {
            println!("Invalid input!");
            return;
        }

        println!("List of operators:");
        println!("(1) Add");
        println!("(2) Subtract");
        println!("(3) Multiply");
        println!("(4) Divide");
        println!("Select the number associated with the desired operation: ");

        let op: f64 = input_parser();

        if f64::is_nan(op) {
            println!("Invalid input!");
            return;
        }

        let op: i32 = op as i32;

        if op > 4 || op < 1 {
            println!("Invalid Selection!");
            return;
        }

        result = ops[(op - 1) as usize](x, y);

        println!("The result is: {}", result);

        println!("Continue? (y/n)");
        io::stdin().read_line(&mut y_or_n).expect("Invalid Input");

        if y_or_n.trim() == "n" {
            break;
        }
    }
}

Here's what I did:

I declared result as mutable using mut.
I declared a new variable y_or_n to check for loop condition whether to continue or not.
Then I wrapped the entire calculation logic inside a loop statement, except the first three declarations.
After the result printing, I take the user input for y_or_n. Since we want a string, we don't have to parse it for integer input.
Finally I check for the condition comparing the input with "n". I used the trim() function because when you press Enter key to finish the input, that key press is also recorded in the input (as \n). So to remove that \n, we use the trim() function.

That's pretty much it! Now you should probably be good with the Rust basics with just this simple calculator project!

In the next tutorial, we will explore one of the most important concepts of Rust and that is the concept of ownership and how memory management works in Rust.

Until then, have a great day ahead!

GitHub Repo: https://github.com/khairalanam/rust-calculator

If you like whatever I write here, follow me on Devto and check out my socials:

LinkedIn: https://www.linkedin.com/in/khair-alanam-b27b69221/
Twitter: https://www.twitter.com/khair_alanam
GitHub: https://github.com/khairalanam

I also have a new portfolio! I am a web developer as well as a web designer with 3+ years of experience designing creative web experiences for everyone.

Check it out: https://khairalanam.carrd.co/

Rust Tutorial 4: Let's build a Simple Calculator! (Part 1)

Khair Alanam — Sat, 28 Oct 2023 07:53:02 +0000

Reading time: 20 minutes

Welcome back to the Rust Tutorial Series!

In this tutorial, we will be building a simple calculator! On the way, we will learn some more concepts like functions, generics, tuples, arrays, and more!

This tutorial will be a 2-parter since we will be covering a heck load of concepts with just this simple project. The Rust Tutorial 5 will just be the second part of this tutorial.

So let's get started!

Setup

Run the cargo new rust_calculator command to create a new Rust project.
Open the rust_calculator project in your code editor.

Let's start!

Getting the user inputs

For our calculator, we want two numbers as the user input. So, let's set them up.

Go to the main.rs file and code this:


 rust
use std::io;

fn main() {
    let mut x: String = String::new();
    let mut y: String = String::new();

    println!("Enter the first number: ");
    io::stdin().read_line(&mut x).expect("Invalid Input");

    println!("Enter the second number: ");
    io::stdin().read_line(&mut y).expect("Invalid Input");

}

Funnily enough, I had to refer to the previous tutorial to see how to get the user input because I forgot lol. So yeah 😅.

We also need the input to get the type of operation to be done between the given two numbers.

There are many ways to do this. Do remember that for all the cases, we will handle the errors in case of invalid input (Please refer to the previous tutorial for handling errors).

We can ask the user for any of the four operations (+, -, *, /) directly.
We can ask the user to enter the commands like ADD, SUBTRACT, MULTIPLY, and DIVIDE. These commands can be used to trigger the corresponding operation in our code.

Or here's my way:

We show the set of operations the user can select in the terminal and then the user has to input the selection number. Then we can map that selection number to the operation we need.

So let's do that!

Here's the current code after asking for the operator input:


 rust
use std::io;

fn main() {
    let mut x: String = String::new();
    let mut y: String = String::new();
    let mut op: String = String::new();

    println!("Enter the first number: ");
    io::stdin().read_line(&mut x).expect("Invalid Input");

    println!("Enter the second number: ");
    io::stdin().read_line(&mut y).expect("Invalid Input");

    println!("List of operators:");
    println!("(1) Add");
    println!("(2) Subtract");
    println!("(3) Multiply");
    println!("(4) Divide");
    println!("Select the number associated with the desired operation: ");

    io::stdin().read_line(&mut op).expect("Invalid Input");
}

Let's not forget to parse the number inputs for x, y, and op. Along with parsing the input, I will also handle the errors here using the match statement (Please refer to the previous tutorial to learn more about the match statement and handling errors)


 rust
use std::io;

fn main() {
    let mut x: String = String::new();
    let mut y: String = String::new();
    let mut op: String = String::new();

    println!("Enter the first number: ");
    io::stdin().read_line(&mut x).expect("Invalid Input");
    let x: i32 = match x.trim().parse() {
        Ok(num) => num,
        Err(_) => {
            println!("Invalid input!");
            return;
        }
    };

    println!("Enter the second number: ");
    io::stdin().read_line(&mut y).expect("Invalid Input");
    let y: i32 = match y.trim().parse() {
        Ok(num) => num,
        Err(_) => {
            println!("Invalid input!");
            return;
        }
    };

    println!("List of operators:");
    println!("(1) Add");
    println!("(2) Subtract");
    println!("(3) Multiply");
    println!("(4) Divide");
    println!("Select the number associated with the desired operation: ");

    io::stdin().read_line(&mut op).expect("Invalid Input");
}

Notice that you will get warnings about unused variables. We'll ignore that for now.

Now that we have the operator input, let's use a match statement to see which number the operator corresponds to, do the operation, and store the result in some variable result (which we have to declare). If the number is not valid, we return some default case.


 rust
use std::io;

fn main() {
    let mut x: String = String::new();
    let mut y: String = String::new();
    let result: i32;
    let mut op: String = String::new();

    println!("Enter the first number: ");
    io::stdin().read_line(&mut x).expect("Invalid Input");
    let x: i32 = match x.trim().parse() {
        Ok(num) => num,
        Err(_) => {
            println!("Invalid input!");
            return;
        }
    };

    println!("Enter the second number: ");
    io::stdin().read_line(&mut y).expect("Invalid Input");
    let y: i32 = match y.trim().parse() {
        Ok(num) => num,
        Err(_) => {
            println!("Invalid input!");
            return;
        }
    };

    println!("List of operators:");
    println!("(1) Add");
    println!("(2) Subtract");
    println!("(3) Multiply");
    println!("(4) Divide");
    println!("Select the number associated with the desired operation: ");

    io::stdin().read_line(&mut op).expect("Invalid Input");
    let op: i32 = match op.trim().parse() {
        Ok(num) => num,
        Err(_) => {
            println!("Invalid input!");
            return;
        }
    };

    match op {
        1 => result = x + y,
        2 => result = x - y,
        3 => result = x * y,
        4 => result = x / y,
        _ => {
            println!("Invalid selection");
            return;
        }
    }

    println!("The result is: {}", result);
}

Now, let's run the code using the cargo run command.

Our calculator is working!

Making a better calculator

Just like our previous project, we can make this calculator even better with much better readability and other options.

Firstly, if you notice, we are only doing calculations on integers and not on decimal numbers. We can change this by changing the parsing type of our inputs to f64.



use std::io;

fn main() {
    // existing code

    let x: f64 = match x.trim().parse() {
        Ok(num) => num,
        Err(_) => {
            println!("Invalid input!");
            return;
        }
    };

    // existing code

    let y: f64 = match y.trim().parse() {
        Ok(num) => num,
        Err(_) => {
            println!("Invalid input!");
            return;
        }
    };

    // existing code
}

All we did was change the parsing type to f64 instead of i32 for the variables x and y.

Now you can run the program and input decimals like 23.4 and 12.3.

Next, notice that the code for asking x and y inputs from the user is repetitive. Wouldn't it be nice to keep this code as some sort of a function so that we can reuse it?

Functions

Functions are basically reusable blocks of code. They help in maintaining readability.

In Rust, since we have the main function, we will have to write our functions outside the main function.

A Rust function looks like this:


 rust
fn add_two(x: i32, y: i32) -> i32 {
    return x + y;
}

Some points to note:

Functions are declared using the fn keyword.
When including parameters, each parameter has to be declared with its corresponding type like x and y here in the example function.
Notice that arrow -> after the parameters? That basically means the return type of the function. Here, the result is the addition of two i32 numbers x and y and we are returning an i32 result. Hence, we define the return type as i32 after the arrow ->.

Let's get back to the project!

Let's make a function input_parser that takes x of type String as argument, assigns the user input, and parses the input to f64.

Here's the code for our function:


 rust
fn input_parser() -> f64 {
    let mut x: String = String::new();
    io::stdin().read_line(&mut x).expect("Invalid Input");
    let x: f64 = match x.trim().parse() {
        Ok(num) => num,
        Err(_) => {
            println!("Invalid input!");
            return f64::NAN;
        }
    };

    return x;
}

What I basically did was copy the entire code for parsing the variable x and then return that x.

Also notice that for errors in parsing the input, we return something called a NAN (Not A Number). If you know JavaScript, then this should be familiar. We are using f64::NAN to return NAN as f64.

Now let's change the main code by using the input_parser function:


 rust
use std::io;

fn main() {
    let result: f64;
    let mut op: String = String::new();

    println!("Enter the first number: ");
    let x: f64 = input_parser();

    println!("Enter the second number: ");
    let y: f64 = input_parser();

    println!("List of operators:");
    println!("(1) Add");
    println!("(2) Subtract");
    println!("(3) Multiply");
    println!("(4) Divide");
    println!("Select the number associated with the desired operation: ");

    io::stdin().read_line(&mut op).expect("Invalid Input");
    let op: i32 = match op.trim().parse() {
        Ok(num) => num,
        Err(_) => {
            println!("Invalid input!");
            return;
        }
    };

    match op {
        1 => result = x + y,
        2 => result = x - y,
        3 => result = x * y,
        4 => result = x / y,
        _ => {
            println!("Invalid selection");
            return;
        }
    }

    println!("The result is: {}", result);
}

fn input_parser() -> f64 {
    let mut x: String = String::new();
    io::stdin().read_line(&mut x).expect("Invalid Input");
    let x: f64 = match x.trim().parse() {
        Ok(num) => num,
        Err(_) => {
            println!("Invalid input!");
            return f64::NAN;
        }
    };

    return x;
}

Notice how simple our main code is after we refactored the input and the parsing code into a function. Also, notice that we removed the declarations for x and y in the main code since input_parser() does that for us.

We forgot to handle the error in case we get one of our numbers as f64::NAN. So let's handle that in our main code:


 rust
use std::io;

fn main() {
    // existing code

    if f64::is_nan(x) {
        println!("Invalid input!");
        return;
    }

    // existing code


    if f64::is_nan(y) {
        println!("Invalid input!");
        return;
    }

    // existing code
}

We are using a built-in function called f64::is_nan() which accepts an f64 parameter to check whether the given parameter is NAN or not.

Also, notice that op is just accepting any number in the given selection (1 to 4) and can be considered as f64. So let's change the types from i32 to f64. The reason we are doing this is just so that we can use our input_parser() function for the op variable to not repeat ourselves.


 rust
    println!("List of operators:");
    println!("(1) Add");
    println!("(2) Subtract");
    println!("(3) Multiply");
    println!("(4) Divide");
    println!("Select the number associated with the desired operation: ");

    let op: f64 = input_parser();

    if f64::is_nan(op) {
        println!("Invalid input!");
        return;
    }

Just like the x and y variables, we use input_parser() for the op variable too. Also, you can remove the op variable declaration in the main code since input_parser() takes care of that.

After doing this, you will notice that there are errors related to mismatching types for f64 and integer in the match statement for op. We can fix this by converting the op variable's type from f64 to i32 like this:


 rust
    let op: f64 = input_parser();

    if f64::is_nan(op) {
        println!("Invalid input!");
        return;
    }

    let op: i32 = op as i32;

Here, by the concept of shadowing, we re-declare op as an i32 variable. Then we assign the value of the previous op variable. But since the new op and old op have different types, we explicitly convert the old op variable type to i32, which is what as i32 basically means. This is called type casting and is pretty essential when it comes to explicit conversions of data types.

Now that everything's done, let's see the final code:


 rust
use std::io;

fn main() {
    let result: f64;

    println!("Enter the first number: ");
    let x: f64 = input_parser();

    if f64::is_nan(x) {
        println!("Invalid input!");
        return;
    }

    println!("Enter the second number: ");
    let y: f64 = input_parser();


    if f64::is_nan(y) {
        println!("Invalid input!");
        return;
    }

    println!("List of operators:");
    println!("(1) Add");
    println!("(2) Subtract");
    println!("(3) Multiply");
    println!("(4) Divide");
    println!("Select the number associated with the desired operation: ");

    let op: f64 = input_parser();

    if f64::is_nan(op) {
        println!("Invalid input!");
        return;
    }

    let op: i32 = op as i32;

    match op {
        1 => result = x + y,
        2 => result = x - y,
        3 => result = x * y,
        4 => result = x / y,
        _ => {
            println!("Invalid selection");
            return;
        }
    }

    println!("The result is: {}", result);
}

fn input_parser() -> f64 {
    let mut x: String = String::new();
    io::stdin().read_line(&mut x).expect("Invalid Input");
    let x: f64 = match x.trim().parse() {
        Ok(num) => num,
        Err(_) => {
            return f64::NAN;
        }
    };

    return x;
}

Now you can run the code using the cargo run command and test for some inputs.

Great job! you have made a simple calculator that can do basic math operations!

In the next tutorial which is just the second part of this tutorial, we will be making a better calculator and on the way, learn some more new concepts!

Until then, have a great day!

GitHub Repo: https://github.com/khairalanam/rust-calculator

If you like whatever I write here, follow me on Devto and check out my socials:

LinkedIn: https://www.linkedin.com/in/khair-alanam-b27b69221/
Twitter: https://www.twitter.com/khair_alanam
GitHub: https://github.com/khairalanam

I also have a new portfolio!
Check it out: https://khairalanam.carrd.co/

Rust Tutorial 3: Handling Errors and Other Concepts

Khair Alanam — Fri, 29 Sep 2023 17:01:57 +0000

Reading time: 11 minutes

Welcome to the Rust Tutorial 3!

This will be a short tutorial and is a continuation of the previous tutorial.

In this tutorial, we will handle errors in our guessing game and also learn some more concepts on the way.

So let's get started!

`const` keyword

Just like the let keyword, const is used to declare variables in Rust that will never be changed through out the program.

One key thing you have to know about const variables is that, we cannot mutate these variables, even if you use the mut keyword. Using the mut keyword in a const variable will throw an error.

Also, it's a convention in Rust to use upper snake case names for const variables.

Let's just use an example:

fn main() {
    const SOME_NUMBER: i32 = 100_000_000;
}

Fun fact: you can use underscores in an integer if the given number is huge for better readability.

99% of the time, you will be using the let keyword. So just use that. If you are really sure that your variable doesn't change at all in the main program execution, then you may use const.

`match` case

The match case statement in Rust is very similar to the switch case statements you see in other programming languages. A match case is a clean way of writing multiple if statement that use the same variable to check for some value. An example looks like this:

fn main() {
    let age: i32 = 30;

    match age {
        1 => println!("One!"),
        2 | 3 | 5 | 7 | 11 => println!("This is a prime"),
        13..=19 => println!("A teen"),
        _ => println!("Just some number"),
    }
}

In the match statement, each value in the LHS of the => expression represents the cases of the match statement, separated by commas. For instance, If age is 1, then we print "One!".

We can chain multiple cases using the pipe | expression if many values give the same output. You can also use a range of numbers as a case.

In case none of the numbers match, we use underscore _ to define a default case.

`match` case with variable assignments

Let's take a look at this program:

fn main() {
    let age: i32 = 30;
    let res: &str;

    match age {
        1..=10 => res = "Child",
        11..=18 => res = "Teen",
        20..=30 => res = "Young Adult",
        _ => res = "Adult",
    }

    println!("{}", res);
}

This program prints out the group type based on age using match case. But notice that in every case, I am assigning a string to the variable res. You can see that it seems repetitive.

Well there's a way to make it DRY. Checkout this one:

fn main() {
    let age: i32 = 30;

    let res: &str = match age {
        1..=10 => "Child",
        11..=18 => "Teen",
        20..=30 => "Young Adult",
        _ => "Adult",
    };

    println!("{}", res);  // prints "Young Adult"
}

All I did was declare the res variable and assign it to the match case statement based on the age value.

Seems pretty intuitive. Right?

Block statements and Block scope

There are lot of syntactic sugar in Rust that you wouldn't see in other programming languages. Though all the programming languages has some kind of syntactic sugar, Rust has a unique way of handling them. Block statements are one of them.

Block statements are pretty useful when you want to assign a value to some variable "once" (thus not needing a separate function) but requires some complex calculations to get that value.

A major advantage of block statements is that any variable declared inside the block statement are scoped to that block only. This helps in keeping the program consistent and prevent the program from any kind of scope errors.

Let's take an example:

fn main() {
    let age: i32 = 30;

    {
        let age: i32 = 24;
        println!("Block Age: {}", age);
    }

    println!("Global Age: {}", age);
}

Running the code will give this output:

Block Age: 24
Global Age: 30

You would expect that the age would change to 24 outside the block due to shadowing, but that's not what happened.

Due to block scope, the age variable declared inside the block will not affect anything outside the block.

Except, if you are mutating the age variable. Like this:

fn main() {
    let mut age: i32 = 30;

    {
        age += 24;
        println!("Block Age: {}", age);
    }

    println!("Global Age: {}", age);
}

This will print:

Block Age: 54
Global Age: 54

So, yea. If the variable is being declared as mutable, then block statements can change the variables outside the block scope.

Now let's get to an interesting part.

Assigning block statements to the variables.

Let's write this code:

fn main() {
    let some_num: i32 = {
        let x: i32 = 45;
        let y: i32 = 34;
        x + y
    };

    println!("{}", some_num);
}

In this code:

I declared a variable called some_num.
Then I declared a block statement in which I declared two local variables x and y and assigned some values.
Then I add them x + y and assign the sum to some_num.

This will print out "79" in the console.

Now, you might be confused with the x + y term that seems out of place compared to the rest of code. Basically what's happening is that after I add x and y, since there's no other code remaining, The block will return this value, i.e. x + y, and assign it to some_num.

Also, notice that I didn't put a semi-colon after x + y. This is because if you used a semi-colon after x + y then the value cannot get assigned to the variable and will return some empty block.

Some more loops!

Let's get back to the loops! In the previous tutorial, I talked about the loop expression, the simplest of the loops. Now let's learn the for and while loop.

A while loop in Rust looks like this:

fn main() {
    let mut i: i32 = 0;

    while i < 5 {
        println!("{}", i);
        i += 1;
    }
}

A for loop in Rust looks like this:

fn main() {
    for i in 1..=5 {
        println!("{}", i);
    }
}

Notice we have used a range in a for loop.

Making a Better Guessing Game

In the previous tutorial, we have made our guessing game. But you might have noticed that we can guess as many times as you want and the game wouldn't end.

So let's implement a guess limiter to our game.

To do that, we can simply replace the loop expression with a while loop expression. For our game, we can let the player have at maximum 5 guesses.

Here's how the code will look like:

use std::io;
use rand::Rng;

fn main() {
    let secret_number: i32 = rand::thread_rng().gen_range(1..101);
    let mut i: i32 = 0;

    while i < 5 {
        println!("Guess {}", i + 1);
        println!("Guess the number between 1 and 100: ");
        let mut user_input: String = String::new();

        io::stdin().read_line(&mut user_input).expect("Some Input Error.");

        let user_input: i32 = user_input.trim().parse().expect("Not an integer");

        if user_input < secret_number {
            println!("Too small!");
        } else if user_input > secret_number {
            println!("Too big!");
        } else {
            break;
        }

        i += 1;
    }

    if i == 5 {
        println!("You have lost! The number was {}!", secret_number);
    } else {
        println!("You guessed it! It's {}!", secret_number);
    }
}

The changes that I made here are:

I declared a mutable variable i with initial value as 0.
I replaced the loop with a while loop when i < 5 (5 guesses).
I added a print statement to keep track of the guesses.
Once the while loop is over, whether normally or using break statement, it will go through an if block (outside the while loop) to see if i is equal to 5 or not and then set the print statements for each condition.

You can now play the game and you will notice you will only have five guesses to guess the number.

Now let's play the game, but this time let's input some string instead of an integer as our guess.

Let's run the cargo run command and see the output:

We get an error since we input a string and not an integer. We have to handle these errors in our code.

Let's take a look at our code:

If you observe, the line of code pointed by the arrow is where we are getting the error. We need to modify this line to handle our errors.

What we can do is, if the user inputs a valid input, then it's all okay. But if the user inputs an invalid input, we can notify the user that it's an invalid input and then restart the loop.

We can do this using match case statement for the user_input variable.

But what will be the variable which we will match the values to?

That will be the user_input.trim().parse().

We know that this function will either return a valid result or an error.

We can verify the return value of the function by using these two enums:

Ok() to see if it's a valid result, and
Err() to see if it's an error.

These two enums will be our cases for matching user_input.trim().parse() and then assign that to the user_input.

Let's modify that one line of code to this:

let user_input: i32 = match user_input.trim().parse() {
            Ok(num) => num,
            Err(_) => {
                println!("Invalid Input! Try again!");
                continue;
            },
        };

In this code, The first case is when the result is valid. We first check whether the user_input.trim().parse() returns an integer, say num. The Ok(num) will verify if it's a valid result.

The second case is when user_input.trim().parse() returns an Error object. Since, we will check for any kind of errors, we use an underscore _ inside Err() to verify for any errors.

Also, notice that I removed expect() function since we are already handling the errors in a better way.

Now let's run the code and see the output:

As you can notice, I have input some invalid inputs to test the game and it works!

Great job! You have made a better guessing game!

I hope you have learnt a lot in this short tutorial. As I have said, I would have included this in the previous tutorial but that one was getting too long and hence, I decided to write a new one just for this.

In the next tutorial, we will make a simple calculator using Rust.

Until next time, have an awesome day ahead!

GitHub Repo: https://github.com/khairalanam/better-rust-guessing-game

If you like whatever I write here, follow me on Devto and check out my socials:

LinkedIn: https://www.linkedin.com/in/khair-alanam-b27b69221/
Twitter: https://www.twitter.com/khair_alanam
GitHub: https://github.com/khairalanam

Rust Tutorial 2: Let's make a Guessing Game!

Khair Alanam — Thu, 21 Sep 2023 07:07:36 +0000

Reading time: 20 minutes

Welcome back to the Rust Tutorial series!

In this tutorial, I will be programming a simple guessing game! On the way, we will learn basic concepts like variables, loops, control statements, etc.

As promised in the previous tutorial, we will use Rust's built-in tool called Cargo to make our game.

Also, I will be referring to some chapters from the official Rust documentation to get the basics done. However, I will be building projects in each tutorial based on the concepts learned.

So let's get started!

Building with Cargo

To the web developers out there, Cargo is basically npm in Rust. It's a package manager as well as a build tool.

To create our guessing game project, we have to run the below command:

cargo new <Name of the project>

Let's name our project "guessing_game" and run:

cargo new guessing_game

Now open the guessing_game folder in VS Code.
On opening the folder, you will notice that the folder structure is dead simple. It's just a src folder with a main.rs file and a Cargo.toml file.

src
-> main.rs

Cargo.toml

The main.rs file just contains a simple "Hello World" program. Cargo.toml is basically package.json in web development projects. It just lists out any dependencies and packages used in the project.

Variables in Rust

`let` and `const`

Like JavaScript, we use the let keyword to declare a Rust variable. There is also a const keyword, like JavaScript, but you will be using let keyword for 99.9% of the time.

Example:

fn main() {
    let a = 2;
}

Let's declare some more variables and print them in our terminal. But how do you print them?

Rust uses formatting using {} to print the variables. For example:

fn main() {
    let a = 2;
    let b = 3;
    let c = 4;

    println!("a is {}", a);
    println!("b is {}", b);
    println!("c is {}", c);
    println!("a, b, c are {}, {} and {} respectively", a, b, c);
}

To execute the above program, run the command:

cargo run

You will get the output:

You will also notice that after running the cargo run command, we got extra files in our directory:

Cargo.lock: It's more or less similar to package-lock.json in web development projects.
Then, we have the target folder where the executable file is stored. If you open the debug folder in the target folder, you will see a lot of files related to the project build files plus the executable file.

In the end, you don't have to worry about anything inside the target folder. All you need to focus on is everything inside the src folder.

Using different data and datatypes

Rust is a strongly typed static programming language. It means that once the variable has data of some datatype like numbers, strings, etc., that variable can only store data of that datatype.

In Rust, it's essential to declare the variable along with its datatype. However, Rust can infer the datatype from the data you've given for the variable.

Let's get to know the different datatypes:

fn main() {
    // integers

    let a: u8 = 2;                                // numbers from 0 - 255
    let b: i8 = -34;                              // numbers from -128 - 127
    let c: u16 = 1000;                            // numbers from 0 - 65535
    let d: i16 = -20000;                          // numbers from -32768 - 32767
    let e: u32 = 1000000;                         // numbers from 0 - 4294967295
    let f: i32 = -5000000;                        // numbers from -2147483648 - 2147483647
    let g: u64 = 10000000000;                     // numbers from 0 - 18446744073709551615
    let h: i64 = -80000000000;                    // numbers from -9223372036854775808 - 9223372036854775807
    let i: u128 = 1000000000000000000000000;      // numbers from 0 - 340282366920938463463374607431768211455
    let j: i128 = -9000000000000000000000000;     // numbers from -170141183460469231731687303715884105728 - 170141183460469231731687303715884105727

    // floating-points
    let x: f32 = 3.14;                            // 32-bit floating-point
    let y: f64 = 2.71828182845;                   // 64-bit floating-point

    // boolean types
    let is_true: bool = true;                     // Boolean type (true)
    let is_false: bool = false;                   // Boolean type (false)

    // single character type
    let ch: char = 'A';                           // Character type

    // strings
    let str1: &str = "Hello, world!";             // String slice
    let str2: String = String::from("Hello");     // String object

    println!("u8: {}", a);
    println!("i8: {}", b);
    println!("u16: {}", c);
    println!("i16: {}", d);
    println!("u32: {}", e);
    println!("i32: {}", f);
    println!("u64: {}", g);
    println!("i64: {}", h);
    println!("u128: {}", i);
    println!("i128: {}", j);

    println!("f32: {}", x);
    println!("f64: {}", y);

    println!("bool (true): {}", is_true);
    println!("bool (false): {}", is_false);

    println!("char: {}", ch);

    println!("&str: {}", str1);
    println!("String: {}", str2);
}

Integers

There are mainly two types of integer data types.

Unsigned Integers (Can represent only positive integers including 0)
Signed Integers (Can represent both negative and positive integers)

Unsigned integer datatypes include: u8, u16, u32, u64, and u128.
Signed integer datatypes include: i8, i16, i32, i64, and i128.

I am not going to explain each data type from integers. But I will explain u8 and i8, while the rest can be inferred from these two.

Variables with the u8 type imply that such variables can store 2^8 = 256 unique positive integers from 0 to 255. Whereas for i8, you can represent 256 unique integers like u8, but we have negative integers too. Variables of the i8 type can store values from -128 to 127.

Similarly, u16 and i16 can represent 2^16 = 65536 unique integers, 2^32 = 4294967296 unique integers for u32 and i32, and so on.

So, you may be wondering, which datatype should I choose for integers?

The answer is i32. Most of the time, when dealing with integers, they would be in the range of i32. Even Rust considers the default integer type as i32 when inferring from integer data.

Floating-points

There are only two datatypes; f32 and f64. You can represent any decimal number using floating points.

As for which datatype to use, use f64. It's also the default floating-point datatype.

Booleans

Booleans represent the values true and false and are represented by the bool keyword.

Character types

The char datatype represents any single character enclosed in single or double quotation marks. For example, 'a', 'w', "1", "?", etc. Variables with a char type can store exactly one character and not more or less than that. Storing more or less than one character for the char type will throw an error.

Strings

This can get a bit tricky because both &str and String are related to each other and very similar. I will differentiate them here:

&str	String
Cannot change size	Can change size
Used for read-only operations	Used for both read and write operations
Variables of this type are string slices of some existing string.	Variables of this type are actually string objects and can be manipulated by any string operations.

Anyways, which one to use? Just use String. But remember, unlike other datatypes, it's important to declare a string using String::new() like the code snippet below along with the String datatype:

let hello: String = String::new("Hello World!");

Here, String in String::new() is a library, and the new() is the function to declare a string object. As for the double colons ::, it's similar to double-colon notation in C++.

Control flow statements

The if-else condition statements in Rust are just as identical as those of other programming languages.

fn main() {
    let a: i32 = 15;

    if a == 10 {
        println!("It's 10");
    } else if a == 20 {
        println!("It's 20");
    } else if a == 15 {
        println!("It's 15");
    } else {
        println!("Some number");
    }
}

Notice that when mentioning conditions, you don't need to enclose the condition in brackets () similar to Python.

Loops

Surprisingly, there are five types of loops in Rust!

loop expression
while expression
while let expression
for expression
Labeled block expression

We will know these loops in the coming tutorials while building some projects. But for this guessing game, let's learn the loop expression.

As the name suggests, a loop expression is a block that loops the execution of the statements inside the loop indefinitely.

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

That's the syntax. Look how simple it is! This program will print "Hello world" for eternity :)

You can break out of the loop by using a break statement.

Now for practice, let's write the code given below:

fn main() {
    let a: i32 = 0;
    loop {
        if a == 5 {
            break;
        }
        println!("Hello world");
        a += 1;
    }
}

Now, try to compile without executing the code by running the below command:

cargo build

When you run the command, you will get the below error:

This is because Rust variables are immutable by default, despite using the let keyword. To make it mutable, use the mut keyword before the variable declaration like this:

let mut a: i32 = 0;

Now you can run the code using cargo run, and you'll see "Hello world" printed five times.

A quick tip: You can change the value of the variable without the mut keyword just by re-declaring the same variable with the let keyword and then assigning the new value. This concept is called "Shadowing" in Rust.

You can also use the same variable to assign a new value with a different datatype by shadowing. We will see this concept when we are making our guessing game.

fn main() {
    let a: i32 = 4; // 'a' is of integer type
    println!("{}", a); // prints 4

    let a: f64 = 4.5; // 'a' becomes floating point here
    println!("{}", a); // prints 4.5
}

Let's make the Guessing Game!

So, let's get started!

First off, we need a secret number for our guess. Let's declare one!

fn main() {
    let secret_number: i32 = 34;
}

Now, we need user input to guess. But how?

For that, we need to use a library called std::io. We can import any library in Rust using the use keyword.

use std::io;

fn main() {
    let secret_number: i32 = 34;
}

To get the user input, we need a variable to store it first. So let's declare a variable called user_input.

use std::io;

fn main() {
    let secret_number: i32 = 34;

    let user_input: String = String::new();
}

Wait, why is the user input a string and not a number?

Well, it's because, by default, all the inputs coming from the user are stored as strings, including numbers. Hence, we declare a string variable. But there's a way to convert a string input to an input of type integer or float as long as the string is a number.

Now, here's the confusing part to get the input from the user:

After you have declared a string variable user_input, go to the next line.

Then, type io to use the std::io library.
Then, attach the stdin() function using double colon notation so that Rust can access the input device.
Then, attach the read_line() function using simple dot notation to read the input from the user.
The read_line() accepts the "reference" of the variable in which you are going to store the user input, i.e., user_input. The reference of the variable can be taken using the & notation. As for why we are using &, it's part of the memory management in Rust which I will cover in a later tutorial. For now, just follow the tutorial.
And finally, it could be possible that some error could come due to some erroneous input. Therefore, we have to finally attach one more function called the expect() function to handle such errors.
expect() function accepts a string parameter to print some error message.

After all this confusing stuff, your final code should look like this:

fn main() {
    let secret_number: i32 = 34;

    let user_input: String = String::new();

    io::stdin().read_line(&user_input).expect("Some Input Error.");
}

It's confusing but will become easier once it's used frequently.

Also, if you are using VS Code, you may get an error in the third line stating that it has to use the mut keyword. That's because when it comes to inputs, they have to be mutable. So you must use the mut keyword in both the declaration and the read_line function.

fn main() {
    let secret_number: i32 = 34;

    let mut user_input: String = String::new();

    io::stdin().read_line(&mut user_input).expect("Some Input Error.");
}

Let's use randomness!

Notice that our secret number is set to 34. But, we want a random number every time we start playing a new game. To generate random numbers, we have to import a new library called rand.

However, this library is not built into Rust and has to be installed in our project.

To install rand:

Open Cargo.toml.
Under the [dependencies] tab, type this:

rand = "0.8.5"

Basically, we are adding a new dependency called rand which as of writing now, is currently in version 0.8.5.

Then finally, run the cargo build command.

After this, you will have rand installed.

Next, let's import rand using the use keyword. Plus, we will be specifically importing the Rng trait to generate random numbers.

What are traits? They are basically abstract classes in Rust. I will discuss these in a later tutorial.

use std::io;
use rand::Rng;

fn main() {
    let secret_number: i32 = 34;

    println!("Guess the number between 1 and 100: ")
    let mut user_input: String = String::new();

    io::stdin().read_line(&mut user_input).expect("Some Input Error.");
}

Now, let's remove the secret_number value and replace it with a random number. To do that, we will have to type a long line just like we did to get the user input:

Type rand in the secret_number expression.
Then using double colon notation, attach the thread_rng() function.
Then using dot notation, attach the gen_range() function.
gen_range accepts a range of values in which a random number can be selected.

Before I finish adding the code for random number generation, it's important to know that Rust has a weird but unique way of declaring ranges of numbers.

In Python, you may have used the range() function to generate a range of numbers. Something like range(1, 101) to generate all the numbers between 1 and 101 (101 is not included).

But in Rust, you use this unique "double dot" notation to generate a range of numbers.
For example, to generate numbers between 1 to 10. You have to write like this: 1..11.
The number at the right end is exclusive, hence you will have numbers from 1 upto and including 10.

For 1 to 100, it would be 1..101.

But let's say you want to include the right end as well. For example, you want a range of numbers between 1 to 6 with 6 included. Then you can write the range as 1..=6.

For 1 to 100, you can write it as 1..=100.

Now, let's pick up where we have left off.

So remember that our gen_range() function needs a range of numbers as a parameter. And we need the user to guess a number between 1 to 100. So, we will have 1..101 or 1..=100 as our range.

So the final code for our random number generation looks like this:

use std::io;
use rand::Rng;

fn main() {
    let secret_number: i32 = rand::thread_rng().gen_range(1..101);

    println!("Guess the number between 1 and 100: ");
    let mut user_input: String = String::new();

    io::stdin().read_line(&mut user_input).expect("Some Input Error.");
}

Comparing the input guess and the secret number

Now it's time to see if the user input and the secret number are the same. To do that, we can set some "if" conditions to see if the given input is greater than, less than, or equal to the secret number.

Here's the code for the conditional block:

if user_input < secret_number {
    println!("Too small!");
} else if user_input > secret_number {
    println!("Too big!");
} else {
    println!("You guessed it!");
}

Now our current code will look like this:

use std::io;
use rand::Rng;

fn main() {
    let secret_number: i32 = rand::thread_rng().gen_range(1..101);

    println!("Guess the number between 1 and 100: ");
    let mut user_input: String = String::new();

    io::stdin().read_line(&mut user_input).expect("Some Input Error.");

    if user_input < secret_number {
        println!("Too small!");
    } else if user_input > secret_number {
        println!("Too big!");
    } else {
        println!("You guessed it!");
    }
}

Now, you will probably get the error regarding the mismatched types in the conditional block. That's because the user_input is a string while the secret_number is an integer.

To fix that, we will have to parse our user_input into an integer. Here's how:

let user_input: i32 = user_input.trim().parse().expect("Not an integer");

Let me explain:

Here, we re-declare the user_input variable to be of integer type by the concept of shadowing. Then to get rid of any trailing spaces, we use the trim() function. Then we use the parse() function to parse the input (which is of string type) to any datatype we want to convert to, which is i32 in this case. Then in case of any error, we use the expect() function with a custom error message.

Our code will now look like this:

use std::io;
use rand::Rng;

fn main() {
    let secret_number: i32 = rand::thread_rng().gen_range(1..101);

    println!("Guess the number between 1 and 100: ");
    let mut user_input: String = String::new();

    io::stdin().read_line(&mut user_input).expect("Some Input Error.");

    let user_input: i32 = user_input.trim().parse().expect("Not an integer");

    if user_input < secret_number {
        println!("Too small!");
    } else if user_input > secret_number {
        println!("Too big!");
    } else {
        println!("You guessed it!");
    }
}

You can now run this program and play the guessing game!

However, you will notice that the game only plays once and then stops.

So, we need to run this program until we guess the secret number.

Loop the program

All we need to do here is to add a loop expression with a condition to break out of the loop. The loop has to break once we guess the number right.

Just wrap the guessing logic under a loop expression and then modify the else clause to include a break statement.

Here's the final code:

use std::io;
use rand::Rng;

fn main() {
    let secret_number: i32 = rand::thread_rng().gen_range(1..101);

    loop {
        println!("Guess the number between 1 and 100: ");
        let mut user_input: String = String::new();

        io::stdin().read_line(&mut user_input).expect("Some Input Error.");

        let user_input: i32 = user_input.trim().parse().expect("Not an integer");

        if user_input < secret_number {
            println!("Too small!");
        } else if user_input > secret_number {
            println!("Too big!");
        } else {
            println!("You guessed it! It's {}!", secret_number);
            break;
        }
    }
}

Now run the code using cargo run and you are good to go!

Congratulations! You have made a really solid program that covers the major Rust basics including variables, datatypes, user input, loops, etc.

For the next tutorial, we will be improving this guessing game to handle errors as well as learn some new concepts on the way. I could cover this here but since this tutorial is getting long, I think it's better to keep it as a separate short tutorial.

Anyways, I hope you have learned a lot in this tutorial!

Have an awesome day ahead!

GitHub Repo: https://github.com/khairalanam/rust-guessing-game

If you like whatever I write here, follow me on Devto and check out my socials:

LinkedIn: https://www.linkedin.com/in/khair-alanam-b27b69221/
Twitter: https://www.twitter.com/khair_alanam
GitHub: https://github.com/khairalanam

Rust Tutorial 1: Writing Hello World

Khair Alanam — Thu, 14 Sep 2023 15:05:34 +0000

Reading time: 3 minutes

Hey everyone! Recently I started learning the Rust programming language for a personal side project of mine. But there aren't many resources available apart from the official documentation. So I decided I might as well share the stuff I have learned in Rust.

So without further ado, let's learn Rust!

How is Rust different?

Rust is a low-level programming language like C. It's a compiled language like C. But unlike C, Rust is memory-safe (No segfaults nightmares). And unlike many languages, Rust doesn't use a garbage collector. This "best of both worlds"-feature makes Rust insanely fast and efficient.

The main factor that makes it different is its memory management. I will cover this in a later tutorial. But to give you a brief idea, Rust language works on ownership and borrowing concepts of memory. In other words, when data are being passed on to different variables, the data don't get copied to all these variables. Instead, the one that currently has the data will have ownership of it while the other variables "lose" ownership of it.

Now let's get to the interesting part.

Writing your first program in Rust

Before writing your first program in Rust, let's install Rust!

Installing Rust

The installation differs for each platform. But I will be installing Rust for Windows.

Go to this link to install Rust for Windows.
Click on the button that downloads the rustup installer. Mine is Windows 10 64-bit. So I will download a 64-bit installer.
Go to the folder where you downloaded the installer and open it.

You will get the below screen:

Type "1" and then press Enter. Wait until everything is installed. Also, Rust requires Visual Studio C++ Build Tools, which will be prompted by the installer for you to install these tools.

Once everything is done, you will get the below image which implies Rust is finally installed. Press Enter.

Setup Rust in VS Code

After the installation, create a new folder and open it in VS Code.

Go to Extensions. Search for "rust-analyzer" and install it.

Also, search for "CodeLLDB" and install it.

Writing Rust code

Every program in Rust ends with the file extension .rs.

Create a file and name it main.rs.
Like C, C++, and Java, Rust runs your main program inside a main function.
Now, write your program.



fn main() {
    println!("Hello World!");
}

Now, run the below command on your terminal to compile the Rust code.



rustc main.rs

After running this command, you will see some files including an executable file.
Now finally, run the below command to see the output.


 shell
./main

This will run the main.exe file and print "Hello World" in your terminal.

Great job! You have written in your first program in Rust!

Plus, you have also learned how to print texts in the terminal using println!() as well as initializing a function using the fn keyword.

In the next tutorial, we will be using Rust's in-built package manager called Cargo to make simple Rust programs and build Rust projects.

Have a great day!

GitHub Repo: https://github.com/khairalanam/rust-tutorial

If you like whatever I write here, follow me on Devto and check out my socials:

LinkedIn: https://www.linkedin.com/in/khair-alanam-b27b69221/
Twitter: https://www.twitter.com/khair_alanam
GitHub: https://github.com/khairalanam

What are some things that one has to be ready with before starting a side project?

Khair Alanam — Sat, 19 Aug 2023 15:56:29 +0000

I am currently building a simple readme generator website as one of my personal projects. By almost at the end of the project, I realized I could have done some testing before every component is coded. And also realized I could have automated some workflows.

Sometimes I feel they are unnecessary and are just a waste of time if the project is small. But at the same time, these are some of the most underrated skills of a professional developer.

Anyways, what are your thoughts on this? And what are some things that a developer has to keep note of before or during the building of the side project?

Would you rather choose Rust or Golang?

Khair Alanam — Wed, 09 Aug 2023 09:41:11 +0000

When it comes to programming languages, I am proficient in Python and JavaScript. However, I wanted to learn a language that deals with low-level stuff and thought of learning Rust. So far, I have enjoyed a lot about Rust including the concept of ownership, borrowing, structs and impls etc. I am learning Rust since I wanted to use it for a side project.

What are your opinions? Rust or Golang? I heard Golang is pretty good option when it comes to usage and the number of jobs that ask for Golang.

@Developers What's your before and after tech stack?

Khair Alanam — Wed, 26 Jul 2023 03:20:05 +0000

A couple months ago, I learnt MERN stack, and built 1-2 projects with it. But later I thought of trying out Django as I heard Django is such a strong backend framework. I am still learning it but I really love how Django is powerful when it comes to having all batteries included despite being complex.

What is the easiest way to do auth?

Khair Alanam — Sat, 15 Jul 2023 13:35:37 +0000

I am learning fullstack development but I always get stuck with authentication. Do you know of any frameworks/ways that makes auth super easy to implement?

Top 10 Obscure HTML tags You may not Know

Khair Alanam — Fri, 10 Mar 2023 16:33:15 +0000

Reading time: 6 minutes

Whether you are a professional web developer, a seasoned one, a learner, or even someone who doesn't know web development, everyone knows that at the heart of every website is a simple HTML page or a set of HTML pages.

In fact, one starts diving into the world of web development by starting with HTML and its semantic tags. In fact, HTML5 is the final version of the HTML and is considered a W3C recommendation.

When it comes to HTML tags, there are so many to learn, that many of us skip and move on to other web technologies. While this is considered totally A-Okay, it's interesting to know that some HTML tags are so obscure that they are rarely used and not even heard of.

So, without further ado, let me share with you the ten HTML tags you may not know and are not heard of. However, many tags are less used apart from these and if you are interested, you can learn about them in MDN Web Docs.

1. ``

<body>
    <p>Lorem ipsum <wbr>dolor</wbr> sit amet 
consectetur adipisicing elit. Molestiae, eveniet.</p>
    <p>Lorem ipsum dolor sit amet consectetur 
adipisicing elit. Minus, corporis.</p>
</body>

As per MDN Web Docs:

The  HTML element represents a word break opportunity—a position within text where the browser may optionally break a line, though its line-breaking rules would not otherwise create a break at that location.

To explain this in simple words, the text wrapped in a  tag will not get broken by those annoying hyphens when reducing the width of the screen.

The  tag is supported in all the major browsers except IE (But who cares about IE?).

2. `<var>`

<p>
    The volume of a box is <var>l</var> × <var>w</var> ×
    <var>h</var>, where <var>l</var> represents the length
    <var>w</var> the width and <var>h</var> the height of the box.
</p>

The <var> tag helps in emphasizing variables in a mathematical expression by italicizing the variables (As you usually see in Math Textbooks). They are mainly used for semantic purposes.

Fortunately, this tag is supported in all browsers including IE (Again, who cares about IE?).

3. ``

<body>
<p>You could use this element to highlight
<u>speling</u> mistakes, so the writer can 
<u>corect</u> them.</p>
</body>

The  tag is used to annotate text in HTML using some underlined decoration. This tag can be useful to mark incorrect text and other types of annotations.

Many of us including me know this  tag to give underline to the text. However, this has been deprecated in HTML4 and is replaced with the current  tag used for annotations.

4. `<dfn>`

<body>
<p>A <dfn id="def-validator">validator</dfn>
is a program that checks for syntax 
errors in code or documents.</p>
</body>

A <dfn> tag is used to indicate a word to be defined within a paragraph or text. This tag looks for the parent tag like a  or a <section> and considers all the text inside it to be the word's definition, again for semantic purposes.

5. `<cite>`

<body>
<figure>
    <blockquote>
        <p>It was a bright cold day in April, and the clocks were striking thirteen.</p>
    </blockquote>
    <figcaption>First sentence in <cite><a href="http://www.george-orwell.org/1984/0.html">Nineteen Eighty-Four</a></cite> by George Orwell (Part 1, Chapter 1).</figcaption>
</figure>
</body>

The <cite> tag is used to indicate a cited work or article in a block of text. This is almost the same as <a> tag except for semantic purposes.

6. `<ins>` and `<del>`

<p>“You're late!”</p>
<del>
    <p>“I apologize for the delay.”</p>
</del>
<ins cite="../howtobeawizard.html" datetime="2018-05">
    <p>“A wizard is never late …”</p>
</ins>

So... technically it's 11 tags instead of 10 :) But whatever. I wanted to put the two tags together because they both do the same thing but with different purposes.

The <ins> and <del> tags are the tags that are used to indicate the insertion of text and deletion of text respectively in a given block of text.

Think of these as the same kind used in the GitHub commits where you can see the insertion and deletion of lines of code in a file.

7. `<noscript>` tag

Now, if you have any experience using React, then you must have come across the <noscript> tag when going through the index.html page created by the CRA tool. However, many of us including me don't know the exact reason for this. You may even think about why a <noscript> tag is used when you have a <script> tag.

To give you a clear idea, the <noscript> tag is used to define a section of the HTML page that contains the alternative text for those browsers that don't support scripting. That is, when scripting is enabled, the content inside <noscript> tag is hidden and vice versa.

8. `<pre>` tag

<pre>
  L          TE
    A       A
      C    V
       R A
       DOU
       LOU
      REUSE
      QUE TU
      PORTES
    ET QUI T'
    ORNE O CI
     VILISÉ
    OTE-  TU VEUX
     LA    BIEN
    SI      RESPI
            RER       - Apollinaire
</pre>

Did you know? HTML5 by default ignores some extra spacing, blank lines, and new lines when you are typing out a text block inside any HTML tag.

However, with the <pre> tag, the text including all the spacing and blank lines is exactly formatted when rendered on the web. In other words, all the space and blank lines are considered as typed out when a <pre> tag is used.

9. `<q>` tag

<p>When Dave asks HAL to open the pod bay door, HAL answers: <q cite="https://www.imdb.com/title/tt0062622/quotes/qt0396921">I'm sorry, Dave. I'm afraid I can't do that.</q></p>

The <q> tag is similar to the  tag in the sense that they emphasize the inline text. The <q> tag is used to emphasize a small quote in a given paragraph or a block of text.

10. `<ruby>` tag

<ruby>
明日 <rp>(</rp><rt>Ashita</rt><rp>)</rp>
</ruby>

<ruby> tag? Now that's a very weird name for an HTML tag.

Initially, I thought it may have something to do with the Ruby language but I was way out of my assumptions.

In fact, the <ruby> tag is used to annotate small text rendered above or below some text, and this tag is mainly used for text written in East Asian languages like Japanese, Chinese, etc to denote the meaning and/or pronunciation of the characters.

Fun fact: the term "ruby" refers to a unit of measurement used in typesetters for newspapers to print very small but legible text.

Conclusion

So, there you have it! These are, in my opinion, some of the obscure HTML5 tags that are rarely heard of. Apart from these, there are many more that you can check out in MDN Web Docs.

Also, I would like to tell you that you don't have to know any of these at all. Just stick with the most commonly used tags and you are good to go and become an awesome web developer!

If you like my content, you can check out my socials:

LinkedIn
Twitter

5 YouTube Channels I follow for Web Development (in no particular order)

Khair Alanam — Fri, 04 Nov 2022 17:08:20 +0000

Reading time: 5 minutes

As someone still learning web development (and will never stop learning), I have come across a bajillion of web development content across YouTube. Some are good, some are fine, and some are meh.

So, with all the web development content I have seen (and with practice), I have seen some channels that have helped me in my web development journey. I still follow these channels for my ongoing learning. I have found them to be helpful in many unique ways.

So without further ado, Here are 5 YouTube channels that I follow for web development in no particular order. All these channels are best in their own right, and I have found them immensely helpful in my web development journey.

1. FreeCodeCamp

This one needs no introduction. I can't stress how much this gold mine of educational content has helped me in my learning and still does it to this day. FreeCodeCamp has revolutionalized tech education.

FreeCodeCamp is a non-profit organization started by Quincy Larson to make learning web development (and software development in general) accessible to everyone, and it's all for free!

You can find a lot of tutorials covering various development fields like Web development, Machine learning, Game development, DevOps, Mobile app development, etc., in FreeCodeCamp.

FreeCodeCamp also provides tutorials covering all the major programming languages like C++, Java, Python, JavaScript, Kotlin, etc. Plus, they update their tutorials to keep up with the trends.

2. Traversy Media

Traversy Media is a great channel for web developers and those learning web development. It is a youtube channel started by Brad Traversy that provides web development tutorials and other videos that are useful for a developer that wants to make their careers fruitful.

What I like about his channel is that in his tutorials (including other awesome developers' tutorials), the technologies and concepts are taught concisely without being overwhelmed by the complexity of that particular subject.

Plus, I love his videos on web development guides as I would get to know which technologies are relevant then and prepare myself to learn and apply them.

I recommend this channel to every web developer and those learning web development.

3. Web Dev Simplified

Web Dev Simplified is another great channel mainly focused on web development, specifically the front end. If there's one thing Web Dev Simplified stands out from others, it's that this channel teaches every concept within minutes, with clarity and conciseness.

Personally speaking, I found Kyle's (the one behind Web Dev Simplified) CSS Flexbox and Grid videos to be one of the best tutorials on YouTube that talks about Flexbox and Grid. Some of his JavaScript tutorials were also really helpful, especially as a revision of whatever I have learned in modern JavaScript.

4. Kevin Powell

Kevin Powell's channel is the one that made me fall in love with CSS. Many things in CSS are underused, some are ahead of their time, and some are just unique. Anyways, to get to the point, I realized the power of CSS because of this great channel.

Very well known as the "King of CSS," Kevin Powell's YouTube channel is a channel that's heavily focused on CSS and its efficient use in making well-optimized websites. Despite its only focus on CSS, I found the channel to be great for web development learners.

While learning CSS, I found this channel to be particularly useful in one of the most important aspects of web development; responsiveness. And because of him, I enjoyed making my website projects responsive and well-optimized.

Outside his YouTube channel, he has a course called "Conquering Responsive Layouts" on his official website which is, in my opinion, the best course on responsive layouts. I would highly recommend every web developer check it out. From this course, I learned the use of em, rem, ch, vw, vh, and other units from Kevin Powell and much useful information on responsiveness.

I highly recommend every web developer and learner check out his channel.

5. The Net Ninja

The four channels that I have mentioned earlier are well-known in the web development community. But for some reason, this channel is not very well-known. Let me tell you, this channel is just too good.

To begin with, The Net Ninja is a YouTube channel that is heavily focused on tutorials in the field of full-stack development. Going through many of his playlists on JavaScript and React, I have one question only: "How are these tutorials free of cost?!?!"

The tutorials in The Net Ninja are well structured and well thought-out in playlists for all kinds of learners to understand every concept and technology explained in these tutorials. Shaun (The one behind The Net Ninja) is such an awesome instructor and knows very well how to make his students understand everything in his tutorials.

I learned Modern JavaScript, Asynchronous Programming with JavaScript, and Modern React from The Net Ninja. For all these playlists, I give them 11/10 because they are just so good and well-structured.

I recommend everyone The Net Ninja channel if you are learning web development.

And that's pretty much it! Those are the 5 YouTube channels I follow for web development.

All these channels are the best in their right. Besides, these are not the only best channels out there. So if you got any good channels for learning web development, comment below!

You can follow me on:
Twitter: https://twitter.com/khair_alanam
LinkedIn: https://www.linkedin.com/in/khair-alanam-b27b69221/

How to host your website on GitHub Pages in 5 minutes?

Khair Alanam — Fri, 07 Oct 2022 09:35:25 +0000

Reading time: 2 minutes

Now, you have finally made your website using HTML, CSS and JavaScript, but now you need to host it on some platform for free. So, where will you want to host the website of yours?

There are many options to try out web hosting; Netlify, Vercel, Amazon S3 etc.

But here, in this article, we will be hosting our website on something called GitHub Pages in just 5 minutes.

What is GitHub Pages?

GitHub Pages is a static site hosting service by GitHub which takes the necessary files from your git repository (HTML, CSS and JavaScript files), builds them, and publishes the website for you.

You can use a custom domain along with the GitHub Pages to host your website without that "github.io" sub-domain.

How to GitHub Pages?

So, let's start!

I have made a sample website that just shows "Hello World" and a button which when clicked will generate some sentences.

This is how it looks like:

All the files will be present in a GitHub repository which I have linked to, at the end of this article.

Now, onto the steps:

Push all your files to a GitHub repository.

Go to Settings.

Scroll down until you see Pages tab on the left and click on it.

Under the Branch sub-heading, click on the tab that shows None and then select main.

Click Save.

The GitHub Pages source is saved and now, you can wait for sometime until your website is published.

Try reloading the current page 2-3 times until you get the below page.

Your website is ready! Now you can click Visit Site to see your website!

Congratulations! You have hosted your website on GitHub Pages in 5 minutes!

I hope you have learnt something new and as always, Happy Learning!

If you would like to follow me, you can follow me on LinkedIn.

Here's the GitHub repository: https://github.com/khairalanam/Hello-World

DEV Community: Khair Alanam

Rust Tutorial 5: Let's Build a Simple Calculator! (Part 2)

More functions!

Tuples

Arrays

Accessing values in tuples and arrays

Rust Tutorial 4: Let's build a Simple Calculator! (Part 1)

Setup

Getting the user inputs

Making a better calculator

Functions

Rust Tutorial 3: Handling Errors and Other Concepts

const keyword

match case

match case with variable assignments

Block statements and Block scope

Assigning block statements to the variables.

Some more loops!

Making a Better Guessing Game

Rust Tutorial 2: Let's make a Guessing Game!

Building with Cargo

Variables in Rust

let and const

Using different data and datatypes

Integers

Floating-points

Booleans

Character types

Strings

Control flow statements

Loops

Let's make the Guessing Game!

Let's use randomness!

Comparing the input guess and the secret number

Loop the program

Rust Tutorial 1: Writing Hello World

How is Rust different?

Writing your first program in Rust

Installing Rust

Setup Rust in VS Code

Writing Rust code

What are some things that one has to be ready with before starting a side project?

Would you rather choose Rust or Golang?

@Developers What's your before and after tech stack?

What is the easiest way to do auth?

Top 10 Obscure HTML tags You may not Know

1. <wbr>

2. <var>

3. <u>

4. <dfn>

5. <cite>

6. <ins> and <del>

7. <noscript> tag

8. <pre> tag

9. <q> tag

10. <ruby> tag

Conclusion

5 YouTube Channels I follow for Web Development (in no particular order)

1. FreeCodeCamp

2. Traversy Media

3. Web Dev Simplified

4. Kevin Powell

5. The Net Ninja

How to host your website on GitHub Pages in 5 minutes?

What is GitHub Pages?

How to GitHub Pages?

`const` keyword

`match` case

`match` case with variable assignments

`let` and `const`

1. `<wbr>`

2. `<var>`

3. `<u>`

4. `<dfn>`

5. `<cite>`

6. `<ins>` and `<del>`

7. `<noscript>` tag

8. `<pre>` tag

9. `<q>` tag

10. `<ruby>` tag