DEV Community: Devrata puri

Day 2: Rust Ownership vs Garbage Collector: A Detailed Comparison with Code

Devrata puri — Wed, 01 Jan 2025 12:50:25 +0000

Memory management is one of the most critical aspects of modern programming languages. Rust's ownership model and traditional garbage collector (GC)-based languages like Go provide two distinct approaches to managing memory. This blog dives into their differences with examples to help you understand how each system works and when to use them.

1. Overview of Rust Ownership

Rust's ownership model ensures memory safety without the need for a garbage collector. It enforces strict rules at compile time, such as:

Every value has a single owner.
When the owner goes out of scope, the value is automatically deallocated.
Borrowing allows shared or mutable access with strict conditions.

This approach eliminates runtime overhead and prevents memory-related bugs like dangling pointers and data races.

Rust Example: Ownership in Action

fn main() {
    let s1 = String::from("hello"); // `s1` owns the string.
    let s2 = s1; // Ownership is moved to `s2`.
    // println!("{}", s1); // Error: `s1` is no longer valid.

    let s3 = s2.clone(); // Explicitly clone the string.
    println!("{}", s3); // `s3` owns a copy.

    borrow_example(&s3); // Borrow the string (does not take ownership).
    println!("{}", s3); // `s3` is still valid here.
}

fn borrow_example(s: &String) {
    println!("Borrowed string: {}", s);
}

Output:

Borrowed string: hello
hello

Key Features:

Move Semantics: s1's ownership is transferred to s2. Afterward, s1 is no longer accessible.
Borrowing: &s3 allows the function to read the value without taking ownership.
Clone: Creates a deep copy of the value to retain ownership.

2. Overview of Garbage Collectors (GC)

GC-based languages, like Go, automatically manage memory at runtime by identifying unused objects and reclaiming their memory. This approach is simpler for developers but introduces runtime overhead due to periodic garbage collection.

Go Example: Garbage Collection in Action

package main

import "fmt"

func main() {
    s1 := "hello" // GC manages memory for this string.
    s2 := s1       // References are shared.

    fmt.Println(s1) // Both s1 and s2 can access the same object.

    manipulateString(s1)
    fmt.Println(s1) // s1 is unaffected since strings are immutable in Go.
}

func manipulateString(s string) {
    fmt.Println("Manipulating string:", s)
}

Output:

hello
Manipulating string: hello
hello

Key Features:

Shared Ownership: Multiple references to the same memory are allowed.
Automatic Cleanup: GC ensures memory is reclaimed when objects are no longer accessible.
Runtime Cost: Periodic GC sweeps may introduce pauses.

3. Key Differences Between Rust Ownership and Garbage Collection

Feature	Rust Ownership	Garbage Collector (GC)
Memory Management	Compile-time ownership rules.	Managed at runtime by the GC.
Performance	No runtime overhead, predictable.	Introduces runtime pauses for GC.
Safety	Enforced by strict ownership and borrowing rules.	Ensures safety with runtime checks.
Multithreading	Prevents data races via ownership model.	Data races possible, requires synchronization.
Flexibility	Fine-grained control over memory.	Easier to share and manage references.

4. Comparing Code Behavior

Dynamic Memory Allocation

Rust Example:

fn main() {
    let mut numbers = vec![1, 2, 3]; // Heap-allocated vector
    numbers.push(4); // Add element dynamically
    println!("{:?}", numbers);
}

Output:

[1, 2, 3, 4]

Rust uses Vec for dynamic arrays, with memory managed by ownership rules. The vector is deallocated automatically when it goes out of scope.

Go Example:

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3} // Slice (dynamic array)
    numbers = append(numbers, 4) // Dynamically add element
    fmt.Println(numbers)
}

Output:

[1 2 3 4]

Go uses slices for dynamic arrays, with memory managed by the GC.

Borrowing and Shared Ownership

Rust:

fn main() {
    let s = String::from("hello");
    borrow_example(&s); // Borrowing allows shared access
    println!("Original string: {}", s); // `s` is still valid
}

fn borrow_example(s: &String) {
    println!("Borrowed: {}", s);
}

Go:

package main

import "fmt"

func main() {
    s := "hello"
    manipulateString(s) // Pass by value (copy is made)
    fmt.Println("Original string:", s) // Original remains intact
}

func manipulateString(s string) {
    fmt.Println("Manipulated string:", s)
}

5. Advantages and Trade-offs

Rust Ownership

Advantages:

Zero runtime overhead.
Predictable memory deallocation.
Prevents memory leaks, dangling pointers, and data races.

Trade-offs:

Steeper learning curve due to strict rules.
Requires explicit handling of borrowing and ownership.

Garbage Collection

Advantages:

Simplifies development by handling memory automatically.
Easier to work with shared and complex data structures.

Trade-offs:

Runtime performance hit due to GC sweeps.
Potential for unpredictable pauses (GC "stop-the-world").

6. When to Choose Which?

Choose Rust for:
- Performance-critical systems (e.g., game engines, real-time systems).
- Applications requiring fine-grained memory control (e.g., embedded systems).
Choose GC-Based Languages (e.g., Go) for:
- Developer productivity and ease of use.
- Applications where runtime GC pauses are acceptable (e.g., web servers).

Conclusion

Rust's ownership model and garbage collectors offer two fundamentally different approaches to memory management. While Rust prioritizes performance and safety at the cost of a steeper learning curve, GC-based languages prioritize simplicity and ease of development with a runtime performance trade-off. Choosing the right approach depends on the specific requirements of your project.

Which memory management style do you prefer? Let us know in the comments!

Rust Series: Day 1

Devrata puri — Sun, 29 Dec 2024 08:54:51 +0000

Understanding Rust Basics

This guide introduces foundational concepts in Rust, providing insights into key language features and practical examples to solidify your understanding.

Associated Functions and Their Usage

Associated functions are functions tied to a type rather than an instance. They are defined in an impl block and accessed using ::. For example, String::new() creates a new, empty String.

Example:

fn main() {
    let s = String::new();
    println!("String: {}", s); // Output: String: 
}

Rust also allows defining custom associated functions for your types:

struct MyStruct;

impl MyStruct {
    fn new() -> Self {
        MyStruct
    }

    fn describe() {
        println!("This is MyStruct.");
    }
}

fn main() {
    let instance = MyStruct::new(); // Creates a new instance of MyStruct
    MyStruct::describe(); // Prints: This is MyStruct.
}

Type-Level vs Instance-Level Functions

In Rust, there is a distinction between type-level and instance-level functions. Type-level functions operate on the type itself, while instance-level functions operate on specific instances.

Comparison:

Feature	Type-Level	Instance-Level
Definition	Associated with the type itself	Associated with an instance of the type
Call Syntax	`TypeName::function_name()`	`instance_name.method_name()`
Access to `self`	No (`self` is not present)	Yes (`self`, `&self`, or `&mut self`)
Example	`String::new()`	`string_instance.len()`

Common Examples of Associated Functions

Rust provides several associated functions for its standard types:

Vectors

fn main() {
    let mut numbers: Vec<i32> = Vec::new(); // Creates an empty vector
    numbers.push(42);
    println!("Numbers: {:?}", numbers); // Output: Numbers: [42]
}

Hash Maps

use std::collections::HashMap;

fn main() {
    let mut scores: HashMap<String, i32> = HashMap::new();
    scores.insert("Alice".to_string(), 10);
    println!("Scores: {:?}", scores); // Output: Scores: {"Alice": 10}
}

Enums: `Option` and `Result`

Rust uses enums like Option and Result to handle optional values and errors explicitly and safely.

Option

Option represents a value that may or may not exist. It has two variants:

Option::Some(value) for a present value.
Option::None for no value.

Example:

fn find_value(values: &[i32], target: i32) -> Option<usize> {
    values.iter().position(|&x| x == target)
}

fn main() {
    match find_value(&[1, 2, 3], 2) {
        Some(index) => println!("Found at index: {}", index),
        None => println!("Not found"),
    }
}

Result

Result represents the outcome of an operation that may succeed or fail. It has two variants:

Result::Ok(value) for success.
Result::Err(error) for failure.

Example:

fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err("Cannot divide by zero".to_string())
    } else {
        Ok(a / b)
    }
}

fn main() {
    match divide(10, 2) {
        Ok(result) => println!("Result: {}", result),
        Err(err) => println!("Error: {}", err),
    }
}

Declaring Integers and Default Values

Integers in Rust are primitive types and do not have associated functions like String::new(). However, you can initialize them directly or use the Default trait.

Examples:

let x: i32 = 0; // Default value for i32
let y = u64::default(); // Using `Default` trait for unsigned 64-bit integer

You can mimic String::new() with:

fn main() {
    let x: i32 = i32::default(); // Default value is 0
    println!("x = {}", x); // Output: x = 0
}

Reading Integers with `io::stdin()`

Rust's io::stdin() is used for reading user input. Since input is read as a string, you must parse it into the desired type, like i32.

Basic Example:

use std::io;

fn main() {
    let mut input = String::new();
    println!("Enter a number:");

    io::stdin()
        .read_line(&mut input)
        .expect("Failed to read line");

    let number: i32 = input.trim().parse().expect("Invalid number");
    println!("You entered: {}", number);
}

With Error Handling:

use std::io;

fn main() {
    let mut input = String::new();
    println!("Enter a number:");

    io::stdin()
        .read_line(&mut input)
        .expect("Failed to read line");

    let number: i32 = match input.trim().parse() {
        Ok(num) => num,
        Err(_) => {
            println!("Invalid input, defaulting to 0");
            0
        }
    };

    println!("You entered: {}", number);
}

What I Learned While Creating a Guessing Game

Creating a simple guessing game in Rust was an excellent way to explore core language features such as input handling, random number generation, and control flow. Here are the key takeaways:

Key Steps in the Guessing Game

Importing Required Modules:
- Used rand crate for generating random numbers.
- Used std::io for handling user input.
Generating a Random Number:

   use rand::Rng;

   let secret_number = rand::thread_rng().gen_range(1..=100);

Taking User Input: Read input from the user and parse it into an integer:

   use std::io;

   let mut guess = String::new();
   io::stdin().read_line(&mut guess).expect("Failed to read line");
   let guess: u32 = guess.trim().parse().expect("Please enter a number!");

Using match for Comparison: Compare the guessed number with the secret number using pattern matching:

   match guess.cmp(&secret_number) {
       std::cmp::Ordering::Less => println!("Too small!"),
       std::cmp::Ordering::Greater => println!("Too big!"),
       std::cmp::Ordering::Equal => {
           println!("You win!");
           break;
       }
   }

Error Handling: Added proper error handling for invalid input to ensure the program doesn't crash.

Lessons Learned

How to use external crates like rand.
Parsing user input and handling errors effectively.
Leveraging pattern matching with match for clean control flow.
Building a complete program by combining Rust's core concepts.

Conclusion

On Day 1, I explored Rust basics and created a guessing game. This included:

Understanding associated functions like String::new.
Exploring enums like Option and Result.
Using io::stdin() for input handling.
Learning practical programming concepts while creating the guessing game.

These exercises laid a strong foundation for further learning in Rust. The journey has just begun!

What is Hyperledger and its different types

Devrata puri — Sun, 30 May 2021 07:26:52 +0000

Hyperledger is an umberlla project of open source Blockchain. It was started by Linux foundation in December of 2015. It was created to help cross-industry blockchain technologies.

Types of Hyperledger

Hyperledger distributed ledger frameworks

There are six blockchain frameworks

Hyperledger Besu:

Hyperledger Besu is a Java Based Ethereum client formerly
known as Pantheon.It can run on the Ethereum public network
or on private permissioned networks,as well as test networks
such as Rinkeby, Ropsten, and Görli. It supports several
consensus algorithms , including Proof of work (Pow) ,
Proof of authority(POA), Istanbul Byzantine fault tolerence
(IBFT),along with permissioning scheme design for users in
consortium environment . It implements enterprise etherum
alliance (EAA) specification. The EEA specification was
established to create standard interfaces for team building
applications.

Hyperledger Burrow:

Hyperledger Burrow, which was contributed by Monax and Intel
initially, is a modular blockchain that was client-built to
the specification of the EVM. It supports both EVM and WASM
based smart contracts and uses Byzantine Fault Tolerance
consensus via the Tendermint algorithm.It supports advanced
event, database, and permissioning features.

Hyperledger Fabric:

Hyperledger fabric was contributed by IBM, It is designed to
be a foundation for developing applications or solutions
with a modular architecture.It has modular and versatile
design which satisfies a broad range of industry use
cases.It offers scalable and secure platform that supports
private transactions and confidential contracts. It allows
for plug-and-play components, such as consensus and
membership services, and leverages containers to host
smart contracts, also called chaincodes, that comprise the
application logic of the system

Hyperledger Indy :

Contributed by the Sovrin Foundation, Indy is a Hyperledger
project made to support decentralized and self-sovereign
identity on distributed ledgers.It provides tools,libraries,
and reusable components for providing digital identities
rooted on blockchains or other distributed ledgers. Indy
is interoperable with other blockchains or can be use
standalone powering the decentralization of identity.

Hyperledger Iroha :

Iroha is a straightforward distributed ledger technology
(DLT), inspired by the Japanese Kaizen principle —
eliminate excessiveness (muri). It is designed for mobile
and IoT development projects, is based on Hyperledger Fabric
and was contributed by Soramitsu, Hitachi, NTT Data, and Colu.
Iroha is Crash Fault Tolerant and has its own consensus
algorithm — YAC

Hyperledger Sawooth :

Sawtooth was contributed by Intel . It offers a flexible and
modular architecture separates the core system from the
application domain, so smart contracts can specify the
business rules for applications without needing to know the
underlying design of the core system. It has support for
both permissioned and permissionless deployments and
recognition of diverse requirements. Sawtooth is designed
for versatility.

DEV Community: Devrata puri

Day 2: Rust Ownership vs Garbage Collector: A Detailed Comparison with Code

1. Overview of Rust Ownership

Rust Example: Ownership in Action

Key Features:

2. Overview of Garbage Collectors (GC)

Go Example: Garbage Collection in Action

Key Features:

3. Key Differences Between Rust Ownership and Garbage Collection

4. Comparing Code Behavior

Dynamic Memory Allocation

Borrowing and Shared Ownership

5. Advantages and Trade-offs

Rust Ownership

Advantages:

Trade-offs:

Garbage Collection

Advantages:

Trade-offs:

6. When to Choose Which?

Conclusion

Rust Series: Day 1

Understanding Rust Basics

Associated Functions and Their Usage

Example:

Type-Level vs Instance-Level Functions

Comparison:

Common Examples of Associated Functions

Vectors

Hash Maps

Enums: Option and Result

Option

Example:

Result

Example:

Declaring Integers and Default Values

Examples:

Reading Integers with io::stdin()

Basic Example:

With Error Handling:

What I Learned While Creating a Guessing Game

Key Steps in the Guessing Game

Lessons Learned

Conclusion

What is Hyperledger and its different types

Types of Hyperledger

Hyperledger distributed ledger frameworks

Hyperledger Besu:

Hyperledger Burrow:

Hyperledger Fabric:

Hyperledger Indy :

Hyperledger Iroha :

Hyperledger Sawooth :

Enums: `Option` and `Result`

Reading Integers with `io::stdin()`