DEV Community: Aditya Verma

Common Programming Concepts - Part 2 (Data Types)

Aditya Verma — Sun, 16 Aug 2026 13:20:31 +0000

What are Data Types?

As we discussed in the last article that we can store any data in variables. The variables that we were declaring till now did not have any data types mentioned and were being assigned data type according to the data they contain by the Rust compiler. This is necessary because every data type requires a specific amount of space which is assigned after the data type is known.

There are 2 basic types of data types, Scalar and Compound. We will go deep into the types a little later. In Rust the data types are statically typed, meaning that they are needed at compilation. So either we can mention the type explicitly which is called type annotation or the Rust compiler can infer the type itself in simple cases. For example, if we declare a simple number it can be inferred easily like let num = 22 , but if we have a more complex operation like taking a string and converting it into number then we would have to annotate the variable with the type. It will look like : let num : u32 = "22".parse().expect("Not a number!") .

For now don’t worry about the .parse() or .expect() , we focus on : u32 this is where we are giving the variable a type of unsigned 32 bit integer. We will discuss more about these types later in this article. As we saw in the above example we annotate a variable with its type using a : . We add the : after the variable name followed by the type we want the variable to be.

Scalar Types

Scalar Types are the types that represent a single value, like a number or a character. In Rust there are 4 types of scalar data types : Integers, Floating-point numbers, Booleans and Characters. Let’s start with the easier ones and then go to the confusing types.

Character Type

The Character Type represents a single Unicode Value like an ‘a’ or a ‘=’ or an emoji like ‘🦀’. All these single values are characters. In Rust we use the char keyword to declare a character type. It is 4 bytes in size. For example, if we want to declare a variable ‘ch’ with the character data type we will do it like : let ch: char = 'a'; . This will declare a character variable called ch containing the character ‘a’.

Boolean Type

Boolean type is very useful data type used to denote just two values, either true or false . It is 1 byte in size. It is mostly used in conditional statements to determine if some statement is true or false. We declare a boolean like : let flag: bool = true; . This will create a variable flag with the data type boolean and the values as true.

Integer Type

Now coming to the little complex data types, first we have Integer. Integer type is used to represent numbers without any fraction component in Rust. At first it sounds simple, we have a number either positive or negative and we assign it the type integer. But here is where the complexity and optimization in Rust comes in. Since the numbers are infinite and can get bigger to any size we cannot have a single type that is able to contain the least possible and the most possible number as it will be a waste of space. So that is why in Integers we have different types for different sizes. Furthermore we have 2 variants for all the sizes, that are : signed and unsigned.

Signed integers will contain both positive and negative numbers while the unsigned integers will only contain positive numbers. So we use unsigned when we are sure that there is no possible negative value for that variable otherwise we use signed.

Now that we know about why it is complex and why there are so many types let’s look at the list of all types and sizes of integers:

Length	Signed	Unsigned
8-bit	i8	u8
16-bit	i16	u16
32-bit	i32	u32
64-bit	i64	u64
128-bit	i128	u128
Architecture-dependant	isize	usize

Here all the types are self explanatory but let me break it down. So we put an i followed by the size of integer for signed integer and an u followed by the size of the integer for unsigned integer. And as for the last one it depends on the architecture type of the machine that we are using, so if we are using a 32-bit machine then isize and usize will be 32 bit, and if we are using a 64-bit machine then isize and usize will be 64 bit in size.

Integer Overflow :

While we are at this topic we should also learn about a very common error that we will definitely encounter when using integers, it is called Integer Overflow. It is a condition when we try to assign a value to an integer variable that is out of range from its defined size. For example u8 can store values from 0-255, so if we try to assign 256 to a u8 variable it will throw an error.

Rust handles it in 2 ways. First is if we are in debug mode Rust will panic and throw an error that looks like :

❯ cargo run
   Compiling programming-basics v0.1.0 (<path>/programming-basics)
error: this arithmetic operation will overflow
 --> src/main.rs:3:17
  |
3 |     let m: u8 = n + 1;
  |                 ^^^^^ attempt to compute `u8::MAX + 1_u8`, which would overflow
  |
  = note: `#[deny(arithmetic_overflow)]` on by default

error: could not compile `programming-basics` (bin "programming-basics") due to 1 previous error

As we can see it clearly tells us that the number n+1 is out of the range of u8 data type as in the code I assigned the value 255 to n and tried to make the variable m = n+1.

Second is if we are compiling the program in release mode, then these checks are ignored. Rust will silently just ‘wrap around’ the value, so like if the values was 256 then it will turn to 0 and if it was 257 it will turn to 1.

Floating-point Type

To put is plainly, floating-point numbers are the numbers that contain a decimal. Meaning they contain an integer with a fraction. There are just 2 types of floating-point variables : f32 and f64 , which are 32-bit and 64-bit respectively.

This is how we represent it in code : let fl: f32 = 2.22; . This will create a variable named fl and assign the value 2.22 to it.

Code Implementation

Now that we know about all the scalar data types, let us implement all of them and observe the output.

fn main() {
    let mut num = 22;
    println!("{num}");
    num = 21;
    println!("{num}");

    let number: u32 = 1234;
    let number2: i32 = -1234;
    println!("I am an unsigned integer : {number}");
    println!("I am a signed integer : {number2}");

    let fl: f32 = 2.22;
    println!("I am a floating point number : {fl}");

    let ch: char = '🦀';
    println!("I am a character : {ch}");

    let t: bool = true;
    println!("I am a boolean : {t}");
}

The output will be:

❯ cargo run
   Compiling programming-basics v0.1.0 (<path>/programming-basics)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.26s
     Running `target/debug/programming-basics`
22
21
I am an unsigned integer : 1234
I am a signed integer : -1234
I am a floating point number : 2.22
I am a character : 🦀
I am a boolean : true

As we can see it ran perfectly and the output is as expected.

Compound Types

Compound Types are the data types that can group multiple values into once single type. There are 2 types of Compound Types in Rust : Tuples and Arrays.

Before diving deep into these types we need to address one thing, that is you might be expecting to see String here in the Compound Types but the thing is String in Rust is a dynamic heap allocated type that does not have a fixed size, hence it is not included in this article. It deserves its own article that we will have later in this series when we are covering collections.

Tuple Type

A Tuple in Rust is a way of grouping multiple values with different data types into one single compound type. Tuples have a fixed size and we cannot increase or decrease their size once declared. We create a tuple by writing the values separated by commas , inside parentheses() . Each value in a tuple can have its own type, they do not have to be all same or all different. By default Rust is able to detect the types in a tuple but it is still a good practise to annotate the types while declaring.

The syntax to create a tuple is as follows :

Without type annotation:
let tup = (22, false, 'a', 2.22);
With type annotation:
let tup: (i32, bool, char, f32) = (22, false, 'a', 2.22);

Now after creating a tuple, the question comes on how do we access these values. In Rust there are 2 ways to access these values :

Destructuring : This way we destructure a tuple into multiple variables. It can be done using the following syntax : let (a, b, c, d) = tup; . Considering the values in the above initiated tuple a will contain 22, b will contain false, c will contain ‘a’ and d will contain 2.22.
Indexing : If we don’t want to create multiple variables we can directly access the values using their index or position in the tuple. We access it by writing the tuple name followed by a . and then the index we want to access. The indexes always start from 0 and not 1. So if we want to print the first element we will write : let value = tup.0; println!("First element of tuple is : {value}") . This will print the element at 0th index meaning 1st position.

Array Type

An Array is also a way to group multiple values into a single compound type. The catch here is that unlike tuples all the values in an array should have the same data type. We create an array by writing the values separated by commas, inside square brackets[] . Arrays in Rust have a fixed length and cannot be expanded or shrunk after declaration.

The syntax to create an array is as follows :

Without type annotation:
let arr = [1,2,3,4,5];
With type annotation:
let arr: [i32; 5] = [1,2,3,4,5];

Here without the type annotation is straight forward but with the annotation after we write the name of the array we follow it by a : and then square brackets[] , inside which we first write the type of all the values in the array(i32in our case) then a semicolon ; , followed by the number of values inside the array.

We can also create an array with the same values by writing the values followed by a semicolon and then the number of elements.

let arr = ['a'; 5] , here the value of ‘arr’ will be : ['a', 'a', 'a', 'a', 'a'] .

To access the elements of an array we have one method, that is using the indexes.

We access an element at an index by writing the array name followed by the index inside square brackets[] .

For example:
If we take an array ‘arr’.
let arr: [i32; 5] = [1,2,3,4,5];
Now we want to access and print the element at 3rd index, that is the 4th position, which contains the values 4.
let value = arr[3];
println!("The value at 4th position / 3rd index is : {value}");
This is going to print the value 4.

Code Implementation

Let’s implement and add these data types to our earlier code.

fn main() {
    let mut num = 22;
    println!("{num}");
    num = 21;
    println!("{num}");

    let number: u32 = 1234;
    let number2: i32 = -1234;
    println!("I am an unsigned integer : {number}");
    println!("I am a signed integer : {number2}");

    let fl: f32 = 2.22;
    println!("I am a floating point number : {fl}");

    let ch: char = '🦀';
    println!("I am a character : {ch}");

    let t: bool = true;
    println!("I am a boolean : {t}");

    let tup: (i32, f32, char, bool) = (22, 2.22, 'a', false);
    let (_a, b, _c, _d) = tup;
    let val1 = tup.2;
    println!("The value of b is : {b}");
    println!("The value at 3rd position / 2nd index of tuple is : {val1}");

    let arr: [char; 5] = ['a', 'b', 'c', 'd', 'e'];
    let val2 = arr[2];
    println!("The value at 3rd position / 2nd index is : {val2}");
}

The output will be:

❯ cargo run
   Compiling programming-basics v0.1.0 (<path>/programming-basics)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.06s
     Running `target/debug/programming-basics`
22
21
I am an unsigned integer : 1234
I am a signed integer : -1234
I am a floating point number : 2.22
I am a character : 🦀
I am a boolean : true
The value of b is : 2.22
The value at 3rd position / 2nd index of tuple is : a
The value at 3rd position / 2nd index is : c

Here we can see that we correctly get the value in the tuple as well as the array.

Conclusion

So this article has been a big one and we learnt a lot. We learnt about Scalar and Compound types. We then went deeper and learnt which data types come under them like integer, floating-point, boolean, character, tuple and array. With this much information please don’t forget to keep practicing these types and come back to the article if you ever forget some. That is it for this one will see you all in the next article where we will explore one of the most important topic that we will cover that is “Functions”.

-Aditya

Common Programming Concepts - Part 1 (Variables and Mutability)

Aditya Verma — Sat, 15 Aug 2026 11:55:18 +0000

What are we covering in this article?

As we established in the last article, “we are all nerds”. So this section might just be a revision for your basic programming concepts, and if you don’t know some then this is a great learning opportunity. This will also lay the foundation for all upcoming articles and all Rust specific concepts as well, so we need to make sure that these are very clear to us.

We will be covering the basics like Variables and Mutability, Data Types, Functions, Comments and Control Flow. These topics are large so we will split this topic into 4 parts that will be divided into 4 articles.

Variables and Mutability

Variables in simple language are just containers that stores a type of value. When we need a value at any step we get that value using the variable name in which we stored the value. For example, if we need to store the number 22, we will create a variable with a name and assign that value to it. So in this case let’s say I choose the name num, I will assign num = 22. This way whenever I need the value 22, I will use num.

Now that we are clear in what a variable is let’s talk about mutability. Mutability is a very important concept in Rust as it adds an important layer to the whole security and control aspect of Rust. Mutability in plain english means the ability to change. Meaning that if something can change then it is mutable and if it cannot then it is immutable. In Rust all variables are immutable by default meaning once we assign a value to them we cannot change that value.

Now that we are clear with both the concepts let’s see how we can create and use variables in Rust. To create a variable we use the keyword let to tell Rust that we will be creating a variable. It is then followed by the name of the variable which in our example is num, so it becomes
let num . Then we write = to assign it a value followed by the value, let num = 22 . We have just declared a variable called num and assigned it the value 22. Now we know that by default variables are immutable so if we ever want to change the value of num we cannot. To change this we are given a keyword called mut . This keyword when used while creating a variable makes it mutable. So if we added it to our declaration from before like let mut num = 22 , then we would be able to change the value of num whenever we want.

Seeing it in action

That’s a lot of talking, let’s see it in action in code. We will also see how the error looks for if we try to change the variable without using mut . I created a new cargo project for this section. So we start by doing cargo new programming-basics . Then we go to /programming-basics/src/main.rs and we code there.

Here first we simply try to declare a variable and print it.

fn main() {
    let num = 22;
    println!("{num}");
}

Output will be:

❯ cargo run
   Compiling programming-basics v0.1.0 ({path}/programming-basics)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.09s
     Running `target/debug/programming-basics`
22

Checking the error

Now we try to mutate the variable.

fn main() {
    let num = 22;
    println!("{num}");
    num = 21;
    println!("{num}");

}

When we try to cargo run this we get the following output in the terminal:

❯ cargo run
   Compiling programming-basics v0.1.0 ({path}/programming-basics)
error[E0384]: cannot assign twice to immutable variable `num`
 --> src/main.rs:4:5
  |
2 |     let num = 22;
  |         --- first assignment to `num`
3 |     println!("{num}");
4 |     num = 21;
  |     ^^^^^^^^ cannot assign twice to immutable variable
  |
help: consider making this binding mutable
  |
2 |     let mut num = 22;
  |         +++

For more information about this error, try `rustc --explain E0384`.
error: could not compile `programming-basics` (bin "programming-basics") due to 1 previous error

This error clearly states that we ‘cannot assign twice to immutable variable num’.

Making it mutable

Now we try making the variable mutable and running the same program again.

fn main() {
    let mut num = 22;
    println!("{num}");
    num = 21;
    println!("{num}");
}

The output is :

❯ cargo run
   Compiling programming-basics v0.1.0 ({path}/programming-basics)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.13s
     Running `target/debug/programming-basics`
22
21

As we can clearly see the reassignment of value worked without any error. We first print a 22 but after changing the value when we print we get a 21. This is the mut keyword playing its part perfectly!

Conclusion

Let’s end it here for now. We learnt what a variable is and what is mutability. Then we learnt about the mutability of variables in Rust and how can we implement them in code. We also learnt how we can change the mutability of a variable. Next article we learn about data types, see you all then!

CARGO: Rust's Package Manager (Think npm or pip)

Aditya Verma — Sun, 09 Aug 2026 16:08:53 +0000

Building a CARGO Project

In the last article we learnt how we create a new CARGO project using the cargo new command in the command line. Now it’s time to build that project. We will have a main.rs in the /src folder that was created when we executed the cargo new command. It contains code for basic ‘Hello, World!’ program that we build in the last article. Let us use that as a base for now, we will code later on.

Before building the project let us first understand what the term ‘building’ means? So the code that we wrote is in a human readable format. Now to convert this code into a machine understandable code and then into an executable that can run directly we ‘build’ the project. So to lay it out plainly we build our program from a cluster of .rs files into a single .exe file (if we are on Windows, on Linux and on Mac they will be different) that will run our code and we do not need to compile it every time.

Now that we are a little clear on what building a project is let us move to actually building our cargo project. To build a cargo project we need to run the cargo build command in the new folder that was created when we ran the cargo new command. In my example I named the project as ‘cargo_intro’, so I will do cd cargo_intro and then cargo build . This will create an executable file in the ./target/debug folder with the same name as the project which in my case is ‘cargo_intro’.

$ cd cargo_intro
$ cargo build
   Compiling cargo_intro v0.1.0 (<folder_path>/cargo_intro)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 3.98s

Running cargo build for the first time also creates a new file at the top level called Cargo.lock. This file keeps track of the exact versions of dependencies in your project.

Running a CARGO Project

After the build we will have an executable file ready for us to run. We can directly run it by clicking in the file explorer or finder. But since we are all nerds here we will use the terminal to run the program. We can do so by just going to the executable in our terminal, so in our example we will do something like :

$ ./target/debug/cargo_intro
$ Hello, world!

Now learning this path and running it like this seems like a hassle if I had to do it more than 3 times. Cargo has made it easy for us to not do this and instead we just run cargo run and it will run the executable for us. Another use of this command is that it eliminates the build step for us. If there are any files changes it will first build and then run the executable for us. So instead of performing 2 steps, first cargo build and then ./target/debug/<executable_name> we simply do cargo run and cargo will build and run the executable for us.

For example, let’s say I change ‘Hello, World!’ to ‘Hello, my name is Aditya.’ then it should rebuild.

$ cargo run
   Compiling cargo_intro v0.1.0 (<project_path>/cargo_intro)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.36s
     Running `target/debug/cargo_intro`
$ Hello, my name is Aditya.

Cargo also provides us with cargo check command to check if the code will compile successfully but it will not produce a new executable with the changed code.

$ cargo check
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.03s

So that is the basics for now. This much will help us setup and run rust programs. We are good to move to actual programming concepts and creating projects to understand the deeper rust concepts. Thanks a lot if you have been part of this journey till now, from the next article we will start creating some interesting programs and learn concepts. Hope to see you there!

-Aditya

Learn Rust with me 🦀

Aditya Verma — Sat, 08 Aug 2026 11:23:14 +0000

Why Rust?

Before starting this series and my articles related to Rust I should address why am I even trying to learn and program in Rust. Honestly the first and most important reason is I feel like doing it, that doesn’t mean I do not have a better reason. It’s just a rush of learning something new making mistakes and growing my knowledge and my skillset. Also I feel like the path that I am taking as a software developer has a pretty good spot for Rust. Actually that’s it, I cannot wait to see if Rust can make me fall in love with it or just be another language in my skillset!

Note : For now I am following the official - The Rust Programming Language book.

Introduction

Rust is a multi-purpose system programming language. It is designed for performance, thread safety and memory safety. It provides low level control like C or C++ and provide modern features like many modern programming languages.

Rust Compiler : `rustc`

Rust uses the rustc compiler that is written in Rust itself. It directly compiles the code to machine code. So for example if we create a file called hello.rs we can directly use the Rust compiler to compile this file and it will provide us with an executable.

rustc hello.rs
./hello

Fun Fact : While researching on this topic I got to know that Rust was very much inspired by OCaml and the very first Rust compiler was written in OCaml which then enabled to make a Rust based compiler.

First Program

We create a Rust file giving it a file extension of .rs. In Rust we go by the basic rule of creating a main function that becomes the entry point for our application. We start by creating a main function that will be ran when we run the executable that is created after compiling the file.
For this example we will go the traditional route and create a “Hello, World!” program.

// hello.rs file.

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

The above is a simple Rust code to print “Hello, World!” in the terminal. Here we have a simple main function which we can define using the keyword fn . Then inside the main function we have a println! . It is a macro according to the official guide book that is still to be explored by me. Basically if we have a ! after the name it is a macro and if it’s not there it’s a function.

Now we will see how we can manually compile and run the script like in the above section.

$ rustc hello.rs
$ ./hello
$ Hello, World!

CARGO : The level up!

Now since we have seen how can we manually compile a Rust program let’s do one thing, let’s not just use it anytime and start using Cargo! Okay so you see like in every other language we have some sort of a package manager/build system, that’s basically Cargo for Rust. It is a package manager and a build system that is used to download the libraries/dependencies that are needed in our project, build those dependencies, build the project and run it.

To get started with a project using cargo we will use the cargo new <project_name> command. It will create a basic project structure and some configuration files. Let’s first explore the file structure then look at how to actually use cargo properly. When we run the cargo new command we are presented with this type of file structure :

- <project_name>/
    - Cargo.toml
    - .gitignore
    - src/
        - main.rs

Okay so here .gitignore contains only one thing that is the /target directory since that is the build directory that we will explore later. .gitignore is created since Cargo automatically initialises git for us. Next we have the Cargo.toml file that we can relate to package.json in JavaScript. It contains the configurations for the project including the package versions and the dependency list. And at the last we have a src/ folder that contains the main.rs file that will start with when Cargo is used to build the project.

That is it for this article! We will explore CARGO deeply in the next article. Hope you all have a wonderful day ahead of you.

-Aditya

DEV Community: Aditya Verma

Common Programming Concepts - Part 2 (Data Types)

What are Data Types?

Scalar Types

Character Type

Boolean Type

Integer Type

Floating-point Type

Code Implementation

Compound Types

Tuple Type

Array Type

Code Implementation

Conclusion

Common Programming Concepts - Part 1 (Variables and Mutability)

What are we covering in this article?

Variables and Mutability

Seeing it in action

Checking the error

Making it mutable

Conclusion

CARGO: Rust's Package Manager (Think npm or pip)

Building a CARGO Project

Running a CARGO Project

Learn Rust with me 🦀

Why Rust?

Introduction

Rust Compiler : rustc

First Program

CARGO : The level up!

Rust Compiler : `rustc`