DEV Community: MAYUR KUMBHAR

Rust Language Essentials: Variables, Constants, and Mutability Explained for Beginners

MAYUR KUMBHAR — Fri, 23 May 2025 15:26:55 +0000

Continuing to our last post on the rust language fundamentals, today we will discuss on language foundations. What are variables, constants and Mutability works in Rust.

Understanding how to store and manage data is fundamental. Rust has specific rules around the variables and mutability that are key to its safety guarantees.

1. Variables with `let` :

Variables are declared using the let keyword:

let variable_name = value;

Example:

let my_var = 5;

2. Immutability by Default:

By default, variables in Rust are immutable. Once a value is assigned with let , it can not be changed.
This default behaviour helps prevent the accidental data modification and makes code easier to reason about.

3. Mutability with `mut` :

To allow a variable'd value to change, you must explicitly use the mut keyword:

let mut variable_name = value;

Example:

let mut my_var = 123;
my_var = 345;

4. Constants wit `const` :

Declared using the const keyword:

const NAME: Type = value;

Always immutable, can not use mut with constants.
Must have their type annotated
Can only be set to a constant expression which is computable at compile time.
Often used for hardcoded values and conventionally named in UPPER_SNAKE_CASE.

5. Shadowing:

Declaring a new variable with the same name as previous one using let.
Example:

let x = 5;
let x = x + 1;

The second x is a new variable shadowing the first.

Key difference from mut: Shadowing creates a new variable, allowing you to change the type of the bound to the name. mut changes the value in place but not the type.
Useful for transforming a value while reusing the variable name.

Variables in Rust store data, which can be of various basic data types like integers, floats, booleans, and characters ( we will cover this in more details in coming articles).

Rust's emphasis on immutability by default, combined with option of mut and feature of shadowing, provides fine grained control over data manipulation.

👉 Follow @themayurkumbhar on Medium

Rust Essentials: How to Set Up Your Development Environment

MAYUR KUMBHAR — Sat, 10 May 2025 13:00:24 +0000

In the previous article, we uncovered the power of Rust and explored its fundamental concepts. But theory alone isn’t enough — it’s time to get our hands dirty! In this article, we’ll walk you through setting up your local Rust development environment and writing your very first program. Let’s dive in and bring Rust to life on your machine!

Rust offers an exceptional toolchain manager called rustup to simplify your development experience. Pair it with a reliable code editor or an integrated development environment (IDE) for a seamless and efficient coding journey.

1. Installing the Rust Toolchain with `rustup`

What is rustup? It’s the official command-line tool for installing and managing Rust versions along with its essential tools, such as rustc, cargo, and documentation. With rustup, keeping your Rust environment up-to-date becomes effortless, ensuring you always have access to the latest features and fixes.
How to Install Rust:

Linux/macOS: Open your terminal and run the following command to install Rust:

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

Windows: Visit the official Rust website and download rustup-init.exe. Run the installer to set up Rust on your system.

Post-Installation Steps: After installing Rust, it’s essential to ensure that cargo and rustc are properly added to your system's PATH. If they aren’t, you might need to restart your terminal or execute a source command, such as:

source $HOME/.cargo/env

(For Linux/macOS users).

Verification:
To confirm a successful installation, open a new terminal and run the following commands:

rustc --version

cargo --version

These will display the installed versions of Rust’s compiler and package manager, verifying that everything is set up correctly.

Key Tools Installed by rustup:

rustc: The Rust compiler that transforms your source code into executables or libraries, forming the backbone of Rust development.
cargo: Rust's indispensable build system and package manager. It simplifies project creation, builds your code, manages dependencies (crates from crates.io), runs tests, and much more.

2. Setting Up Your IDE

While a plain text editor can get the job done, using an IDE or advanced code editor can supercharge your productivity. With features like syntax highlighting, autocompletion, and real-time error detection, you’ll spend less time debugging and more time building.

Pair Visual Studio Code (VS Code) with the Rust Analyzer extension for the ultimate Rust development experience. This powerful combination provides intelligent code assistance, making your workflow smoother and more efficient.

With rustup installed (giving you rustc and cargo) and your IDE set up with Rust Analyzer, your development environment is ready!

3. Hello Rust! your first program

Projects in Rust are managed with cargo, a versatile tool that acts as a package manager, build system, test runner, and documentation generator. We'll use cargo to create and manage our project.

Step 1: Create project with cargo

cargo new hello_rust

cargo: Runs the Cargo tool, Rust's package manager and build system.
new: A subcommand that creates a new Rust project.
hello_rust: The name of the project. Cargo will create a new directory with this name containing the project files.

When you run this, cargo will output something like:

Created binary (application) `hello_rust` package

Step 2: Explore project structure

Navigate into the newly created directory:

cd hello_rust

Now, look at the files and directories inside. You should see:

.
├── Cargo.toml
└── src
    └── main.rs

Cargo.toml: The manifest file of your project, written in TOML (Tom's Obvious, Minimal Language). It includes metadata like the project's name, version, author, and dependencies. We'll explore this file in detail in the next lesson.
src/: Directory containing your project's source code.
src/main.rs: The crate root file for a binary application. By default, Cargo creates a binary crate (an executable program), and main.rs serves as the entry point for the executable.
Step 3: Examine the Default Code (src/main.rs)

Open the src/main.rs file in your chosen IDE (VS Code or IntelliJ IDEA). You'll find the following code already written for you by cargo new:

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

fn: Declares a new function.
main: The special entry point function for Rust executable programs.
(): Indicates the main function takes no arguments.
{}: Encloses the body of the function, where instructions are written.
println!: A macro (not a function, identified by !) used to print text to the console, followed by a newline.
"Hello, world!": A string literal, representing the text to be printed.
;: Marks the end of a statement in Rust.
Step 4: Build and Run Your Program

Building the Project:
Make sure you are inside the hello_rust directory in your terminal. Then, run the following command to build your project:

cargo build

The output will look something like this (details may vary):

    Compiling hello_rust v0.1.0 (/path/to/your/project/hello_rust)
    Finished dev [unoptimized + debuginfo] target(s) in X.XXs

Step 5: Running the project (the easy way):

The most common way to run your Rust program is using cargo run:

cargo run

This command is a shortcut. Cargo will first check if your code needs to be rebuilt. If it does, it will compile it. Then, it will execute the compiled program.

You should see the following output:

Finished dev [unoptimized + debuginfo] target(s) in Y.YYs
     Running `target/debug/hello_rust`
Hello, world!

Success! You have written, compiled, and run your first Rust program.

There’s another useful cargo command: cargo check. This command quickly checks your code for errors without producing an executable

You’ve successfully learned the basics of creating, building, and running a Rust program using cargo, while exploring the default project structure. You're now ready to dive deeper into Rust's powerful features. Happy coding!

👉 Follow @themayurkumbhar on Medium

Rust 101: the fundamentals

MAYUR KUMBHAR — Tue, 06 May 2025 04:48:46 +0000

Hello learner’s, in this article, we will discuss about the Rust language fundamentals. We’ll explore why we need Rust, What it is? And Core philosophy behind the language.

Rust programming language was started in 2006 as personal project, in 2009 Mozilla sponsored project, in 2015 Rust 1.0 was released.

What is rust?

Rust is general-purpose, multi-paradigm system programming Language. It’s designed for performance critical tasks, often handled by languages such as C and C++, used in operating systems, embedded systems, game engines etc. It also offers flexibility for command-line tools, web development and more.

Essentially, rust achieves this low-level control and performance without requiring a garbage collector.

Core philosophy of Rust

Rust is built on key pillars:

Safety: Rust guarantees memory safety at compile time, eliminating common bugs like dangling pointers, null pointer dereferencing, and data races in concurrent code, which are major causes of crashes and security vulnerabilities in other languages.
Performance: Rust compiles code into highly efficient native code, comparable in performance to C and C++, while eliminating runtime overhead. Its “Zero-cost abstraction” ensures speed without compromising high-level features.
Concurrency: Rust’s ownership system and borrow checker prevent data races at compile time, making concurrent code much more manageable.
Productivity: Rust offers good tooling (cargo), a helpful compiler with detailed error messages, and a growing tooling ecosystem of libraries (crates) to boost productivity, despite its focus on low-level control.

Why learn rust?

Selecting rust offers significant advantages:

Reliability: Rust’s robust safety guarantees that successfully compiled code is remarkably free of common, challenging-to-debug runtime errors related to memory or concurrency.
Speed: For performance–sensitive applications, Rust is top choice.
Safer concurrency: Build multithreaded applications confidently, knowing compiler helps prevent dangerous bugs.
Growing demand: rust’s adoption is increasing across various domains, creating new opportunities
Deeper understanding: Learning Rust provides valuable insights into how computer programs manage resources like memory.

Common use-cases:

Rust’s journey and its role in the world include:

Operating systems
Web servers and web assembly
Command line tools
Databases and distributed systems
Embedded systems
Blockchain

In summary, Rust empowers developers to construct dependable, efficient, and secure software, effectively addressing intricate challenges such as concurrency directly through compile-time guarantees.

👉 Follow @themayurkumbhar on Medium

Circular ⭕ dependency exceptions in Spring❗

MAYUR KUMBHAR — Wed, 21 Jun 2023 16:48:42 +0000

Issue?

When two beans are waiting for each other to be created in the spring context so that autowiring can happen, this state is called as Circular Dependency and we get the BeanCurrentlyInCreationException exception.

Scenario, lets say BeanA is defined as below

@Component 
class BeanA{

@Autowired // here BeanA is depends on BeanB
public BeanB bean;

}

Now lets say we have BeanB as below

@Component 
class BeanB{

@Autowired // here BeanB is depending on BeanA
public BeanA bean;

}

So there is dependency between two components resulting in circular dependency as each bean is waiting for its dependent bean to created for autowiring.

Solution

Developer should be careful while creating the Beans, making sure there are no circular dependency. But is worst case if there exists case or by mistake some developer put the circular dependency then we can follow below to resolve this.

Use setter injection instead of constructor injection

We can use the setter injection in one of class for dependent bean, so that injection is happed after one object is created avoiding the race condition.

Use Lazy initialization on beans

We can use @Lazy annotation on one of the bean in circular dependency so that one of bean creation is delayed until bean is actually required.

Refactor code to remove circular dependency

We should avoid creating such circular dependency in first place, and refactor code respectively to remove the circular dependency.

How @Autowired works in Spring - A detailed guide

MAYUR KUMBHAR — Mon, 19 Jun 2023 14:53:09 +0000

In last post we have seen how @Autowired can be used at multiple places to inject the dependent beans. Spring framework handles the dependency between the components and based on field, setter or constructor injection injects appropriate objects.

Issue?

What happens when spring context has multiple beans of same type? which object spring framework injects for @Autowired annotation?

If we have single bean of required type in the spring context, there is no ambiguity to framework and it will inject the dependent bean wherever required.

How Spring framework handle such scenarios?

When spring framework gets into situation of multiple beans of same type which need to be injected in one of the @Autowired dependency, it will follow the three steps to resolve the ambiguity.

By Default IoC container will always look for class type of bean to inject.

Step 1: look for bean name with same parameter/field name.

Spring IoC container will look for bean name with equal to parameter name mentioned with @Autowired annotation in filed, setter parameter, constructor parameter.


// field injection
@Autowired 
private SomeBean bean; // here spring looks for bean with name "bean" in context

// setter injection
@Autowired 
public void setSomeBean(SomeBean bean1){ // here spring looks for bean with name "bean1" in context to inject.
  this.bean = bean1;
}

// constructor injection
@Autowired 
public Example(SomeBean bean2){ // here spring looks for bean with name "bean2" in context to inject.
   this.bean=bean2;
}

if no matching name bean found, follow step 2

Step 2: Spring IoC container looks for bean marked as `@Primary` bean

So if no matching name bean found, then spring IoC Container check for if there is any bean among multiple beans which is marked as @Primary bean, if yes inject that bean.


@Primary // this is primary bean
@Bean 
public SomeBean myBean(){
  return new SomeBean("Hello");
}

@Bean // this is normal bean
public SomeBean myOtherBean(){
  return new SomeBean("Welcome");
}

// when @Autowired is invoked, as we have multiple beans of same class type, @Primary bean will be injected for below wiring.

@Autowired 
public SomeBean bean; // as no name bean matching with myBean, myOtherBean so Primary bean will be injected here.

If no @Primary bean found in context, follow step 3

Step 3: Spring IoC container will look for @Qualifier annotation and find the bean with name matching.

Now, IoC container checks if @Qualifier is used or not and if found look for the name of the bean mentioned in @Qualifier and injects that.

@Bean 
public SomeBean myBean(){
  return new SomeBean("Hello");
}

@Bean
public SomeBean myOtherBean(){
  return new SomeBean("Welcome");
}

// when @Autowired is invoked, as we have multiple beans of same class type, @Primary bean not found checks name with @Qualifier and injects below

@Autowired // here qualifier used is "myBean" so IoC will inject the bean with name myBean
public Example(@Qualifier("myBean")SomeBean bean){ 
   this.bean = bean;
}

Use of @Qualifier is beneficial as the parameter name can change based on developers choice to improve readability of code, but it will not impact the autowiring due to qualifier name used.

If all the above step followed and no matching bean is found then it will throw an exception NoUniqueBeanDefinitionException as multiple beans are present but are ambiguious.

Difference between @Autowiring ➿& @Inject 🔌

MAYUR KUMBHAR — Sun, 18 Jun 2023 16:00:03 +0000

In article we looked at how wiring works in the spring framework, how to use the @Autowired annotation and different ways to use it.
Here we will briefly compare the @Autowired annotation with @Inject annotation.

Qualifier support

@Autowired built-in support the qualifier to qualify which exact bean to use foe dependency injection.
@Inject dose not have built-in support for qualifying the specific bean.

Standardization of annotation

@Autowired is annotation specific to spring framework and dose not work outside spring context
@Inject is part of java dependency injection (JSR-330).

Optional Dependency Support

@Autowired supports the optional dependency with Optional<T>
@Inject however dose not have built-in mechanism to make dependency as optional

Framework Integration

@Autowired is specifically developed to use with the spring framework.
@Inject is more general annotation can be used with any framework supporting the JSR-330

Note that both @Inject and @Autowired serve the purpose of dependency injection and can be used effectively in their respective contexts

Wiring in Spring

MAYUR KUMBHAR — Wed, 14 Jun 2023 14:48:30 +0000

Context

Bean is most fundamental unit in spring framework which we have seen in previous posts. Bean creation may include creating the normal object which dose not have any dependency on other objects they solely can be created from the primitive data types.

But most of the objects we create they depends on other objects either developer created or library objects.

Now with bean we give control to spring framework how to create and manage the java objects in application. When there is dependency between the Objects, spring framework should understand and construct the dependent objects (beans) as well.

Wiring

So to enable the framework to create dependent beans objects and inject them on runtime whenever required this concept is called as "wiring".
Here spring framework process the connection between the objects & make sure required objects are created and injected.

Ways to wire a bean

Spring provides multiple ways to wire a bean, by dependency injection, annotation based wiring, xml-based wiring, java-based configuration wiring, component scanning.

Springboot provides the @Autowired annotation to automatically wire the dependent objects.

Similarly java has @Inject annotation which more general dose can be used without spring, to wire the dependent objects.

The @Inject annotation is part of the Java Dependency Injection (JSR-330) standard, which is supported by frameworks like Spring

Ways to use @Autowired annotation

Annotation @Autowired used with multiple ways via field injection, constructor injection, setter injection, optional dependency & with @Qualifier annotation.

Field injection

To inject the dependent object in bean, we can put @Autowired annotation on the class fields, which then framework detects and injects the appropriate dependency.


@Autowired 
private ExampleBean someBean;

Constructor injection

While creating the bean, we can provide the constructor param as @Autowired to inject the required object. Spring will automatically pass the require Object as param in constructor.


@Autowired
public ExampleBean(DependentBean dependentBean){
   this.dependentBean = dependentBean;
}

Setter injection

Another way to inject the dependency is to use the setter method annotated with @Autowired, So spring can use it to inject the required dependency.


@Autowired 
public void setDependentBean(DependeentBean bean){
   this.dependentBean = bean;
}

Optional Dependency injection

Sometimes the dependency on object is optional, as with some objects can be created without depending on all the objects. This can be achieved using the Optional and required=false in the @Autowired.

By default the @Autowired is not optional & always injects the dependency.


@Autowired(required = false)
private Optional<DependentBean> bean;

Use of Qualifiers with Autowiring

Sometime we have multiple beans in our context, now if we only specify the @Autowired on the field, constructor, setter Spring frameworks get confused on which exact dependency to inject as there are multiple objects of same type are available in context.

To remove ambiguity and provide exact dependent object to inject we use @Qualifier with value to specify the which exact bean to use for this dependency injection.


@Autowired 
@Qualifier(value = "someSpecificBean")
private DependentBean bean;

@Inject can also be used similar to @Autowired annotation, with slight difference.

@PreDestroy annotation in spring 💥

MAYUR KUMBHAR — Tue, 13 Jun 2023 17:21:14 +0000

Need of the @PreDestroy annotation

Sometime in our application we have perform some business operations before the destroy the bean of a class. Such business logic can be performed with @PreDestroy annotation.

How to use?

Below code snippet help in understanding how to configure the @PreDestroy annotation on bean.


@Component
class BeanExample {

    private String name;

    public BeanExample() {
    }

    @PreDestroy 
    public void destroy() {
        System.out.println("Doing destructive operations!");
    }

}

Whenever the bean of BeanExample class about to get destroyed the code in method destroy() will be invoked. Here in case of our example it will output Doing destructive operations! when you close the context annotationConfigApplicationContext.close() by deliberately destroying all the beans.

When to use?

When you want to perform some business operations on the bean during the closing/removing/end of lifecycle you can use the @PreDestroy annotation. Some common use case can be to close the IO resources, release the dependent objects, close acquired connections such as DB connections etc.

Most of the time the spring framework is handling all the resource closing, destruction related activities, but in case you have some scenarios where you want to perform tasks before the bean is destroyed you can use the annotation.

@PostContruct Annotation in Spring

MAYUR KUMBHAR — Tue, 13 Jun 2023 17:20:58 +0000

Issue?

Spring beans are most basic building block of spring framework. We have seen ways we can create the beans in spring in this post and its benefits. We also understood that there is drawback of using @Component annotation for bean creation.

With @Component you can not specify or configure how the bean is created, spring framework is responsible for creating & configuring the bean. With Normal @Bean annotation developer have more control on bean creation.

Solves?

To solve the issue of having some control on created bean using @Component annotation, spring provides another annotation which is called @PostConstruct annotation inspired from the Java EE edition.

With help of @PostContruct annotation, after the bean is created developer can execute the desired code. This annotation is applied on the method of the bean class which marked as @Component.


@Component
class BeanExample {

    private String name;

    public BeanExample() {
    }

    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @PostConstruct
    public void initialize() {
        this.name = "DEFAULT_STRING";
    }

    public void printName() {
        System.out.println(this.name);
    }

}

If we get the object after spring has created the bean of BeanExample class, we can call the printName() on the bean and verify that the DEFAULT_STRING is set as part of PostContruct code execution.

Use?

Whenever the application requires the some business logic to be applied after the specific object is created we can use this annotation to perform the action e.g. initialize with default values.

Bean vs Component in Spring

MAYUR KUMBHAR — Fri, 09 Jun 2023 16:45:06 +0000

@Bean in Spring

more than one instance of class can be added to spring context
we can create bean of any class, from libraries classes as well as user defined classes
need to write specific code methods to create the instances
developer is in control of how to create & configure the objects
spring will create the beans based on the instructions, configuration specified by the developer

@Component in Spring

only one instance of class can be added to spring context
only user defined class can be marked as component to instantiate as bean, library class objects can not instantiated
only the @Component annotation is required to add on class, no more code is required
developer will not have control on how to create & configure bean
spring framework is in charge of creating the bean & post that developer will have access to bean

Sometimes you want to create bean based on the certain conditions are met. Developer can create the objects manually and register them to spring context with help of context.registerBean("<name_of_bean>", <class_of_bean>.class, <Supplier>) basic method. There are multiple ways you can register a bean.

Spring IoC container 📦

MAYUR KUMBHAR — Sun, 28 May 2023 13:13:49 +0000

Spring IoC container is the component in spring core framework. Lifecycle of bean is maintained by this container. This container converts the java objects into the beans by provided configurations.

Spring IoC container responsibilities:

instantiate the application class
configure object
assemble the dependencies between objects

Types of IoC

Bean Factory - Basic IoC container, no advance feature, only bean creation, maintenance, auto wiring & injecting dependencies.
Application Context - advanced IoC provides all features of Bean Factory & on top of it provides extra features like event handling based on bean events.

Spring Beans 🫘& Context

MAYUR KUMBHAR — Sun, 28 May 2023 12:40:05 +0000

Bean

A java class which is maintained by the spring framework, it is called as Bean in spring. Its fundamental building block of spring framework.

How spring knows which class maintain as Bean?

We can configures the beans using the annotations or XML configurations in spring. Based on configurations available spring container instantiates and assembles them to become bean in spring. IoC container help to maintain the lifecycle of the beans.

Spring Context

Context is memory location of web application in which all the objects instantiated by the framework are present and managed by the context framework.
By default spring dose not know all the objects in the application, based on the configuration spring will instantiate & maintain the object during the initialization so all the information related to those object is available inside spring context.

If object dose not available in spring context then spring dose not know about the object.

SpEL - spring expression language

It is the expression language provided by the spring framework to perform the operations such as manipulating object graph like setting, getting property values, property assignments & method invocations etc.

DEV Community: MAYUR KUMBHAR

Rust Language Essentials: Variables, Constants, and Mutability Explained for Beginners

1. Variables with let :

2. Immutability by Default:

3. Mutability with mut :

4. Constants wit const :

5. Shadowing:

Rust Essentials: How to Set Up Your Development Environment

1. Installing the Rust Toolchain with rustup

2. Setting Up Your IDE

3. Hello Rust! your first program

Rust 101: the fundamentals

What is rust?

Core philosophy of Rust

Why learn rust?

Common use-cases:

Circular ⭕ dependency exceptions in Spring❗

Issue?

Solution

Use setter injection instead of constructor injection

Use Lazy initialization on beans

Refactor code to remove circular dependency

How @Autowired works in Spring - A detailed guide

Issue?

How Spring framework handle such scenarios?

Step 1: look for bean name with same parameter/field name.

Step 2: Spring IoC container looks for bean marked as @Primary bean

Step 3: Spring IoC container will look for @Qualifier annotation and find the bean with name matching.

Difference between @Autowiring ➿& @Inject 🔌

Qualifier support

Standardization of annotation

Optional Dependency Support

Framework Integration

Wiring in Spring

Context

Wiring

Ways to wire a bean

Ways to use @Autowired annotation

Field injection

Constructor injection

Setter injection

Optional Dependency injection

Use of Qualifiers with Autowiring

@PreDestroy annotation in spring 💥

Need of the @PreDestroy annotation

How to use?

When to use?

@PostContruct Annotation in Spring

Issue?

Solves?

Use?

Bean vs Component in Spring

@Bean in Spring

@Component in Spring

Spring IoC container 📦

Spring IoC container responsibilities:

Types of IoC

Spring Beans 🫘& Context

Bean

How spring knows which class maintain as Bean?

Spring Context

SpEL - spring expression language

1. Variables with `let` :

3. Mutability with `mut` :

4. Constants wit `const` :

1. Installing the Rust Toolchain with `rustup`

Step 2: Spring IoC container looks for bean marked as `@Primary` bean