DEV Community: Anshuman Sathua

Programming fundamentals in Rust - Part 1 : Variables and Mutability

Anshuman Sathua — Fri, 09 Feb 2024 18:13:40 +0000

By default, Rust embraces immutability for variables as a deliberate choice. This serves as one of Rust's guiding principles, encouraging developers to write code that capitalizes on the safety and seamless concurrency that the language offers. Nevertheless, Rust provides the flexibility to make variables mutable, offering developers the choice to opt out of this default behavior. Let's delve into how and why Rust encourages immutability, and when you might consider opting for mutability.

In Rust, when a variable is immutable, once a value is bound to a name, you cannot alter that value. To illustrate this concept, let's create a new project named "variables" in our projects directory using cargo new variables.

Now, navigate to the newly created "variables" directory, open the src/main.rs file, and replace its existing code with the following snippet, which won't compile just yet:

fn main() {
    let x = 5;
    println!("The value of x is: {x}");
    x = 6; // This line will cause a compilation error
    println!("The value of x is: {x}");
}

Save your changes and execute the program using cargo run. Expect to encounter an error message indicating an immutability violation, as illustrated in the following output:

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
error[E0384]: cannot assign twice to immutable variable `x`
 --> src/main.rs:4:5
  |
2 |     let x = 5;
  |         -
  |         |
  |         first assignment to `x`
  |         help: consider making this binding mutable: `mut x`
3 |     println!("The value of x is: {x}");
4 |     x = 6;
  |     ^^^^^ cannot assign twice to immutable variable

For more information about this error, try `rustc --explain E0384`.
error: could not compile `variables` due to previous error

This example highlights the compiler's role in pinpointing errors within your programs. While compiler errors may seem vexing, they essentially signify that your program is not yet securely achieving its intended functionality.

The error message cannot assign twice to immutable variable x was triggered because an attempt was made to assign a second value to the immutable variable x.

This compile-time error is crucial as it prevents scenarios where unintentional value changes can lead to bugs. When one part of your code assumes that a value remains constant, and another part modifies that value, it introduces the potential for unexpected behavior. Identifying the source of such bugs after the fact can be challenging, particularly when the second piece of code alters the value selectively.

Rust's compiler provides assurance that if you declare a value as immutable, it genuinely remains unchanged. This eliminates the need for manual tracking, making your code more predictable and easier to comprehend.

However, embracing mutability can prove highly beneficial, enhancing the convenience of code composition. Despite the default immutability of variables, you have the flexibility to render them mutable by prefixing the variable name with mut. This not only alters the variable's behavior but also serves as a clear indication to future code readers that other segments of the codebase will modify the value associated with this variable.

For example, let’s change src/main.rs to the following:

fn main() {
    let mut x = 5;
    println!("The value of x is: {x}");
    x = 6;
    println!("The value of x is: {x}");
}

When we run the program now, we get this:

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/variables`
The value of x is: 5
The value of x is: 6

The introduction of mut grants us the liberty to alter the value assigned to x from 5 to 6. The choice of whether to embrace mutability or not rests entirely on your discretion and hinges on what you deem most lucid in that specific scenario.

Constants

Similar to immutable variables, constants represent values tied to a name and are strictly off-limits when it comes to alterations. However, there are a few key differences between constants and variables.

Firstly, constants are inherently immutable — you can't use mut with them. Unlike variables declared with the let keyword, constants use const, and you must annotate the type of the value. Don't worry too much about the details of types and annotations for now, we'll dive into that in the next section, called "Data Types," where we'll get a more comprehensive understanding. Just keep in mind that type annotations are always required for constants.

Another thing to note is that constants can be declared in any scope, including the global scope. This makes them useful for values that many parts of the code need to know about.

The last difference is that constants may only be set to a constant expression, not the result of a value that could only be computed at runtime.

We'll explore these concepts further as we progress. For now, let's look at an example of a constant declaration:

const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;

The constant is named THREE_HOURS_IN_SECONDS, and its value is determined by multiplying 60 (the number of seconds in a minute) by 60 (the number of minutes in an hour) by 3 (representing the desired count of hours in this program). Rust follows a naming convention for constants, utilizing all uppercase letters with underscores between words. The compiler can evaluate a restricted set of operations during compile time, allowing us to express this value in a more comprehensible and verifiable manner, as opposed to directly setting it to the numeric result, such as 10,800.

Constants remain valid throughout the entire program runtime, confined to the scope in which they were declared. This enduring nature makes constants particularly advantageous for values within your application domain that multiple program sections might need to reference, like the maximum points a player can earn in a game or the speed of light.

Employing constants for hardcoded values across your program enhances code clarity for future maintainers and streamlines future updates. By centralizing such values as constants, you establish a single, easily locatable point for any necessary modifications in the future.

Shadowing

In Rust, we have the flexibility to declare a new variable with the same name as a previous one. Rust developers often refer to this as "shadowing," where the first variable is overshadowed by the second. This implies that, when we use the variable name, the compiler recognizes the second variable. Essentially, the second variable supersedes the first, capturing any references to the variable name until either it gets shadowed itself or the current scope concludes. To shadow a variable, we can simply reuse the same variable name and employ the let keyword again, as illustrated below:

fn main() {
    let x = 5;

    let x = x + 1;

    {
        let x = x * 2;
        println!("The value of x in the inner scope is: {x}");
    }

    println!("The value of x is: {x}");
}

This program initially binds the variable x to a value of 5. Subsequently, it introduces a new variable x by reusing the let x = construct, taking the original value and incrementing it by 1, resulting in x being assigned a new value of 6. Then, within an inner scope defined by curly brackets, the third let statement further shadows x, creating yet another variable. This time, the value is obtained by multiplying the previous value by 2, making x assume a value of 12. Upon the conclusion of this inner scope, the inner shadowing ceases, and x reverts to being 6. Upon executing this program, the output will be as follows:

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
    Finished dev [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/variables`
The value of x in the inner scope is: 12
The value of x is: 6

Shadowing differs from marking a variable as mutable (mut) because attempting to reassign a value without using the let keyword results in a compile-time error. The use of let allows us to apply various transformations to a value while maintaining immutability after those transformations are completed.

Another distinction between mut and shadowing lies in the fact that, with shadowing, a new variable is effectively created when the let keyword is employed again. This provides the flexibility to change the type of the value while reusing the same variable name. For instance, consider a scenario where our program prompts a user to specify the desired number of spaces between some text using space characters, and subsequently, we aim to store that input as a number:

    let spaces = "   ";
    let spaces = spaces.len();

The initial spaces variable is of type string, while the subsequent spaces variable is of type number. Shadowing offers the advantage of avoiding the need for distinct names, such as spaces_str and spaces_num, instead, we can reuse the more straightforward spaces name. However, if we attempt to use mut for this purpose, as illustrated here, a compile-time error will be triggered:

    let mut spaces = "   ";
    spaces = spaces.len();

The error says we’re not allowed to mutate a variable’s type:

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
error[E0308]: mismatched types
 --> src/main.rs:3:14
  |
2 |     let mut spaces = "   ";
  |                      ----- expected due to this value
3 |     spaces = spaces.len();
  |              ^^^^^^^^^^^^ expected `&str`, found `usize`

For more information about this error, try `rustc --explain E0308`.
error: could not compile `variables` due to previous error

Summary

Rust defaults to immutability for variables, encouraging safer code and easier concurrency handling.
Immutable variables cannot be altered once a value is assigned to them.
Attempting to modify an immutable variable results in a compile-time error.
Immutability ensures predictability in code behavior and prevents unintentional value changes.
Despite the default immutability, Rust allows variables to be declared mutable using the mut keyword.
Mutability offers flexibility in code composition but should be used judiciously.
Constants in Rust are similar to immutable variables but have a few key differences.
Constants are declared using the const keyword and must have a type annotation.
Constants are useful for values that remain constant throughout the program and can be declared in any scope.
Rust supports shadowing, allowing variables to be redeclared within the same scope.
Shadowing creates a new variable with the same name as an existing one, effectively hiding the original variable.
Shadowing differs from mutability in that it allows for the reuse of variable names and changing variable types.
Constants, immutability, mutability, and shadowing are fundamental concepts in Rust that contribute to code safety and readability.

As we wrap up this chapter, we've laid a solid foundation by comprehending the intricacies of variables and their behavior, including concepts like immutability, mutability, and shadowing. Our journey into Rust programming is far from over, though. In the upcoming chapters, we will dive into the realm of data types, unlocking a new layer of knowledge that will pave the way for crafting even more sophisticated and efficient Rust programs. Stay tuned for the next chapter, where we explore the diverse world of Rust data types and further elevate our programming skills.

Mastering Cargo: A Comprehensive Guide to Harnessing the Power of Rust's Package Manager

Anshuman Sathua — Thu, 01 Feb 2024 19:53:03 +0000

Now that we've embarked on our Rust programming journey and mastered the art of writing a Hello World program from the command line, it's time to delve into Cargo – Rust's package manager and build system. In this blog post, we'll not only explore the reasons why Cargo is a game-changer but also provide a hands-on guide on how to leverage its features effectively.

Why Choose Cargo?

Before we dive into the how, let's quickly recap why Cargo is an essential tool for Rust developers:

Dependency Management: Cargo simplifies the process of adding and managing dependencies, ensuring a smooth integration of external libraries into your projects.
Consistent Project Structure: Cargo generates a standardized project structure, fostering consistency and making collaboration more accessible.
Efficient Build Process: With a single command, cargo build, you can compile your code, handle dependencies, and build your project effortlessly.
Automated Testing: Cargo integrates seamlessly with Rust's testing framework, allowing you to run tests with a simple cargo test command.
Easy Distribution: Cargo provides a streamlined way to package and distribute your Rust projects, making it convenient for both developers and users.

Now, let's get hands-on with Cargo.

Getting Started with Cargo:

Cargo comes installed with Rust if you used the official installers discussed in the previous blog, if not then you can click here for a smooth setup. Check whether Cargo is installed by entering the following in your terminal:

$ cargo --version

If you see a version number, you have it! if not please go ahead and install it.

1. Creating a New Rust Project:

To initialize a new Rust project, use the following command:

cargo new my_project
cd my_project

This will create a new directory named my_project with the standard project structure.

2. Adding Dependencies:

Open the Cargo.toml file in your project directory. This file serves as the configuration file for your project. To add a dependency, modify the [dependencies] section. For example:

[package]
name = "my_project"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
rand = "0.8.5" 

# Rand provides utilities to generate random numbers, to convert them to useful types and distributions, and some randomness-related algorithms.

Run cargo build to fetch and compile the specified dependencies. For now we don't need to add any dependencies but for future projects this is the place to add dependencies.

3. Building and Running a Cargo Project:

Let's take a look at src/main.rs file:

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

Cargo has generated a “Hello, world!” program, just like the one we've written in the previous blog. Key differences are:

Cargo placed the code in the src directory.
We've a Cargo.toml configuration file in the top directory.

In the Cargo convention, our source files are anticipated to reside within the src directory. The primary project directory is designated for README files, license information, configuration files, and any other content unrelated to our actual code.

As we've seen previously that in rust compiling and running are two differenet steps. For that in cargo we've the command cargo build:

$ cargo build
   Compiling hello_cargo v0.1.0 (file:///projects/my_project)
    Finished dev [unoptimized + debuginfo] target(s) in 2.85 secs

When you run this command, an executable file is created in target/debug/my_project (or target\debug\my_project.exe on Windows), not in your current directory. Since it's a default debug build, Cargo puts the binary in a debug directory. To run the executable, use this command:

$ ./target/debug/my_project # or .\target\debug\my_project.exe on Windows
Hello, world!

After constructing our project using cargo build and executing it with ./target/debug/my_project, there's an alternative approach. You can streamline the process by using cargo run, which compiles the code and immediately executes the resulting executable in a single command:

$ cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
     Running `target/debug/my_project`
Hello, world!

Opting for cargo run is more convenient compared to the two-step process of remembering to run cargo build and then specifying the full path to the binary. Hence, the majority of developers prefer the simplicity of cargo run.

It's noteworthy that this time, no output indicated that Cargo was compiling my_project. Cargo intelligently recognized that the files hadn't undergone any changes, opting to run the existing binary rather than initiating a rebuild. If modifications were made to the source code, Cargo would have executed a rebuild before running.

Cargo also furnishes a command named cargo check. This command swiftly verifies your code for compilation correctness without generating an executable:

$ cargo check
   Checking hello_cargo v0.1.0 (file:///projects/my_project)
    Finished dev [unoptimized + debuginfo] target(s) in 0.32 secs

Why might you opt not to generate an executable? Frequently, cargo check proves significantly faster than cargo build since it bypasses the step of creating an executable. If you find yourself consistently checking your work during the coding process, employing cargo checkexpedites the feedback loop, promptly notifying you if your project is still compiling. Many Rust developers intermittently run cargo check as they code to ensure compilation correctness, reserving cargo build for when they're prepared to generate the executable.

4. Building for Release

When your project is prepared for its final release, employ cargo build --release to compile it with optimizations. This command produces an executable in target/release rather than target/debug. While these optimizations enhance the runtime performance of your Rust code, it's essential to note that enabling them prolongs the compilation time of your program.

To accommodate different needs, Cargo provides two distinct profiles: one tailored for development, facilitating quick and frequent rebuilds, and another optimized for constructing the final program intended for users. This final version is designed for optimal runtime speed and is not subjected to repeated rebuilds.

For accurate benchmarking of your code's execution time, ensure to execute cargo build --release and conduct benchmarks using the resulting executable in the target/release directory.

Summary

Cargo is more than just a package manager – it's a versatile tool that significantly improves the Rust development experience. As we continue our Rust journey, we'll explore more advanced Cargo features, and leverage its power to streamline our workflow. Let's summarize the key points we've covered about Cargo:

Initiating a new project is accomplished with cargo new.
Building a project is executed via cargo build.
The combined process of building and running a project can be streamlined with cargo run.
Conducting a swift code check for errors, without producing an executable, is achieved using cargo check.
Cargo stores build results in the target/debug directory, diverging from the project's source code directory.
For optimal performance in a release-ready project, utilize cargo build --release.
A noteworthy advantage of Cargo is its cross-platform consistency, where commands remain the same regardless of the operating system.

Thanks for reading, i hope it was worth your time. Happy coding!

Write your first Hello World! program in Rust

Anshuman Sathua — Fri, 26 Jan 2024 12:20:23 +0000

Why Rust:

Imagine crafting a rocket with Lego, where the pieces not only magically stay together but also soar through the skies at astonishing speeds without a hint of a crash. That's Rust in a nutshell: a programming language that's powerful, safe, and remarkably enjoyable to work with.

A Word of Caution:

Young Ecosystem: With fewer tools compared to a seasoned language, consider yourself a pioneer forging new paths!
Learning Curve: It's more of a mountain than a hill, but the view from the top is breathtaking! ⛰️
Not for Everyone: If your goal is a quick website, stick to simpler tools for now.

Alright, enough talk—let's dive in.

Installation:

To embark on our Rust journey, we'll use rustup, a command-line tool for managing Rust versions and associated tools.

For Linux and macOS users, follow these steps.
Windows users can click here. The installation process is straightforward, but if you encounter any issues, drop a comment below, and I'll do my best to assist.

Writing and Running a Rust Program

Now that Rust is at our fingertips, let's write our inaugural Rust program. Open a terminal and enter the following commands to create a projects directory and a subdirectory for the “Hello, world!” project:

For Windows CMD:

> mkdir "%USERPROFILE%\projects"
> cd /d "%USERPROFILE%\projects"
> mkdir hello_world
> cd hello_world

For Linux, macOS and PowerShell on Windows:

$ mkdir ~/projects
$ cd ~/projects
$ mkdir hello_world
$ cd hello_world

Next, create a new source file named main.rs. Rust files always end with the .rs extension. Add the following code to main.rs:

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

Save the file and return to your terminal in the same directory. Compile and run the file using the following commands:

For Windows:

> rustc main.rs
> .\main.exe
Hello, world!

On Linux and macOS, use ./main instead of .\main.exe. The terminal should display the string "Hello, world!"

Understanding the Basics: Anatomy of a Rust Program

Let's dissect the program. Initially, we have:

fn main() {

}

The first line declares a function named main with no parameters and no return value. The function body is enclosed in curly braces {}. The main function is special—it's always the first code that runs in every executable Rust program.

Inside the body of the main function, you'll find:

    println!("Hello, world!");

This line prints the string to the terminal.

A couple of things to note: end a line with a semicolon (;) to indicate the completion of the expression. Additionally, println! calls a Rust macro. At this point, let's consider macros a mystery to unravel in our future, more advanced explorations. Remember, if you're writing println!, you're calling a Rust macro, not a regular function. For regular functions, use println without the !.

Compiling and Running

To run a Rust program, first, compile it using the Rust compiler with the rustc command:

$ rustc main.rs

If you're familiar with languages like C or C++, this is similar to using the gcc compiler. For those accustomed to dynamic languages like Ruby, Python, or JavaScript, the concept of compiling and running as separate steps might be new. Rust is an ahead-of-time compiled language, generating a binary executable file. It doesn't matter where your code lives, as long as you have the executable file, you can run the program even without having Rust installed—something not possible with dynamic languages like Ruby, Python, or JavaScript.

After compilation, on Linux and macOS, you can see the executable file:

$ ls
main  main.rs

On Windows, it might look like this:

> dir /file names
main.exe
main.pdb
main.rs

This displays the source code file with the .rs extension, the executable file (main.exe on Windows, main on other platforms), and, when using Windows, a file containing debugging information with the .pdb extension. To run the program, use:

$ ./main  or .\main.exe on Windows

This should print Hello, world! to your terminal. Congrats!🎉 You've written your first Rust program. Keep an eye out for future updates, we'll explore more about Rust in the future. Thanks for reading, I hope it was worth your time. Have a fantastic day!

Understanding the Document Object Model (DOM) in Frontend Development

Anshuman Sathua — Thu, 30 Nov 2023 07:16:16 +0000

While exploring the world of frontend development, the term "DOM" frequently surfaces. Let's understand it. The DOM, or Document Object Model, is pivotal in creating dynamic and interactive web pages.

The Static Nature of HTML

HTML, a markup language, allows us to define the structure of a webpage using various tags. However, this structure is inherently static. Without a mechanism to alter the content within these tags, our webpage remains unchanged. Enter JavaScript and the DOM API.

JavaScript's DOM API

JavaScript provides an essential tool: the DOM API. This API empowers developers to dynamically manipulate the structure of a webpage. Essentially, it serves as a bridge between the static HTML structure and the dynamic content we aspire to create.

Visualizing the DOM: A Tree-Like Structure

Imagine transforming your HTML code into a tree-like representation. Each tag becomes a node in this hierarchical structure. This tree, known as the DOM tree, becomes the foundation for JavaScript's DOM API to navigate, manipulate, and render changes.

HTML Code :-

<html>
  <head>
    <title>My Webpage</title>
  </head>
  <body>
    <h1>I'm a Heading</h1>
    <p>This is a paragraph.</p>
  </body>
</html>

DOM Representation :-

HTML
|
|-- HEAD
|   |
|   |-- TITLE
|   |   |
|   |   | My Webpage
|
|-- BODY
|   |
|   |-- H1
|   |   |
|   |   | I'm a Heading
|   |
|   |-- P
|   |   |
|   |   | This is a paragraph.

DOM Manipulation in Three Steps

DOM manipulation involves three fundamental steps:

Querying the DOM: The process of locating a specific element within the DOM tree is aptly named querying. JavaScript searches and identifies the desired element to interact with.
DOM Update: Once located, the identified element undergoes changes as needed. This could involve altering text, updating attributes, or manipulating the structure itself.
Rendering the DOM: The final step involves rendering or re-rendering the DOM. It's at this point that the browser displays the updated content. Notably, re-rendering can be a resource-intensive operation.

The Balancing Act: Performance Considerations

While querying and updating the DOM are relatively lightweight operations, frequent re-rendering can impact performance. This is where modern libraries and frameworks, such as React, come to the rescue.

Looking Ahead

In subsequent discussions, we'll explore how frameworks like React address performance concerns and offer efficient solutions for building dynamic and responsive web applications.

Thanks for exploring the fundamentals of the DOM with me. Stay tuned for more insights into the world of frontend development!

Thanks for reading! Have a great day... :)