What is Rust programming language 01

🦀 What is Rust?

Rust is a modern systems programming language focused on three main goals: safety, speed, and concurrency.

Think of it as the spiritual successor to C and C++. It allows developers to write low-level code (like operating systems, game engines, and browsers) that runs incredibly fast, but without the common bugs and crashes associated with manual memory management.

📜 A Brief History

The Inception (2006): Rust began as a personal project by Mozilla employee Graydon Hoare. He was reportedly frustrated with a crashing elevator (software failure) and wanted to write a language that wouldn't crash.
Mozilla adoption (2009): Mozilla began sponsoring the project, realizing it could be perfect for their next-generation browser engine (Servo).
Version 1.0 (2015): The first stable version was released. This marked the point where the language was considered "production-ready."
The Rust Foundation (2021): To ensure the language's future was independent of any single company, the Rust Foundation was formed, backed by giants like AWS, Google, Microsoft, and Meta.

⚡ Key Benefits

Rust has been voted the "Most Loved Programming Language" on Stack Overflow for many years running. Here is why:

Memory Safety without Garbage Collection: This is Rust's "killer feature." It uses a system called Ownership and Borrowing to enforce memory safety at compile time. This means it eliminates entire classes of bugs (like null pointer dereferences or buffer overflows) before your code ever runs.
Blazing Speed: Because it doesn't have a heavy garbage collector (like Java or Python) running in the background, Rust apps run at speeds comparable to C++.
Fearless Concurrency: Writing multi-threaded programs is notoriously difficult. Rust’s compiler prevents data races, allowing you to write parallel code without fear of random crashes.
Incredible Tooling: Rust comes with Cargo, a package manager and build system that is widely considered the gold standard in the industry. It handles dependencies, testing, and documentation generation effortlessly.
Helpful Error Messages: The Rust compiler is famous for acting like a strict but helpful teacher. Instead of just saying "Error," it often points to the exact line, explains why it's wrong, and suggests how to fix it.

😂 Fun & Funny Facts

The Rust community has a very distinct and humorous culture:

The Mascot: Rust’s unofficial mascot is a crab named Ferris. You will often see plushie crabs on the desks of Rust developers.
The Name "Rustaceans": People who use Rust call themselves "Rustaceans" (a play on crustaceans, hence the crab mascot).
The Name Origin: Graydon Hoare named the language after the rust fungus because it is incredibly robust and hard to kill, not because of "rusty metal."
"Rewrite it in Rust": There is a running meme in the programming world where Rust enthusiasts aggressively suggest rewriting every piece of software in existence (from Linux to obscure utilities) in Rust.
Turbofish: Rust has a specific syntax ::<> that looks like a fish. The community officially calls it the "Turbofish."

-------------

Here is the comparison between Python and Rust rewritten in English.

To illustrate the difference, let's look at a simple program that sums up numbers in a list.

🐍 1. Python Code

Python is famous for being very easy to write and read. It looks almost like English.

Python
def main():
    # Creating a list
    numbers = [10, 20, 30, 40, 50]
    
    total = 0
    
    # Loop through the list to add numbers
    for num in numbers:
        total += num
        
    print(f"The total is: {total}")

main()

Note: In Python, you don't need to specify what "type" of data a variable is. Python figures it out automatically. It is easy to write, but can sometimes lead to runtime errors.

🦀 2. Rust Code

Rust is a bit more detailed (verbose), but it is designed to be much safer.

Rust
fn main() {
    // Creating a Vector (similar to a list in Python)
    let numbers = vec![10, 20, 30, 40, 50];
    
    // 'mut' stands for 'mutable'.
    // In Rust, variables are immutable (cannot be changed) by default.
    // We must explicitly add 'mut' to allow 'total' to be updated.
    let mut total = 0;
    
    // Loop through the vector
    for num in numbers {
        total += num;
    }
    
    // Printing the result
    // The '!' tells us this is a macro, not a regular function
    println!("The total is: {}", total);
}

🔍 Key Differences:

Strictness (Mutability):
- Python: You can simply write total = 0. You can change it later without asking for permission.
- Rust: You must write let mut total = 0;. If you forget the mut, the compiler will give you an error. This prevents variables from changing unexpectedly, which eliminates many bugs.
Syntax:
- Python uses whitespace and indentation to organize code.
- Rust uses curly braces { } and semicolons ; (similar to C++ or Java).
Speed:

Python is an interpreted language, so it is generally slower.
Rust is a compiled language. Once compiled, this code runs directly on the hardware at incredible speeds.

------------------

🦀 రస్ట్ (Rust) అంటే ఏమిటి?

రస్ట్ అనేది ఒక ఆధునిక సిస్టమ్స్ ప్రోగ్రామింగ్ లాంగ్వేజ్. ఇది ప్రధానంగా మూడు లక్ష్యాలపై దృష్టి పెడుతుంది: భద్రత (Safety), వేగం (Speed), మరియు కంకరెన్సీ (Concurrency - ఒకేసారి అనేక పనులు చేయడం).

దీనిని C మరియు C++ లాంగ్వేజ్‌లకు వారసుడిగా భావించవచ్చు. ఇది డెవలపర్‌లను ఆపరేటింగ్ సిస్టమ్‌లు, గేమ్ ఇంజిన్‌లు మరియు బ్రౌజర్‌ల వంటి లో-లెవల్ (low-level) కోడ్‌ను రాయడానికి అనుమతిస్తుంది. ఇది చాలా వేగంగా పనిచేస్తుంది, కానీ మాన్యువల్ మెమరీ మేనేజ్‌మెంట్‌తో వచ్చే సాధారణ బగ్స్ (bugs) మరియు క్రాష్‌లు (crashes) ఇందులో ఉండవు.

📜 సంక్షిప్త చరిత్ర

ప్రారంభం (2006): రస్ట్ మోజిల్లా ఉద్యోగి గ్రేడన్ హోరే (Graydon Hoare) యొక్క వ్యక్తిగత ప్రాజెక్ట్‌గా మొదలైంది. ఒకసారి ఆయన ప్రయాణిస్తున్న లిఫ్ట్ (ఎలివేటర్) సాఫ్ట్‌వేర్ లోపం వల్ల క్రాష్ అవ్వడంతో విసిగిపోయిన ఆయన, క్రాష్ అవ్వని లాంగ్వేజ్‌ని తయారు చేయాలని నిర్ణయించుకున్నారు.
మోజిల్లా స్వీకరణ (2009): తమ తదుపరి తరం బ్రౌజర్ ఇంజిన్ (Servo) కోసం ఇది సరైనదని భావించి, మోజిల్లా ఈ ప్రాజెక్ట్‌ను స్పాన్సర్ చేయడం ప్రారంభించింది.
వెర్షన్ 1.0 (2015): రస్ట్ యొక్క మొదటి స్థిరమైన (Stable) వెర్షన్ విడుదల చేయబడింది. ఈ దశ నుండే ఈ లాంగ్వేజ్ "ప్రొడక్షన్-రెడీ" (ఉపయోగించడానికి సిద్ధం) అని నిర్ధారించబడింది.
రస్ట్ ఫౌండేషన్ (2021): ఈ లాంగ్వేజ్ భవిష్యత్తు ఏ ఒక్క కంపెనీపైనా ఆధారపడకూడదనే ఉద్దేశంతో 'రస్ట్ ఫౌండేషన్' ఏర్పడింది. దీనికి AWS, Google, Microsoft మరియు Meta వంటి దిగ్గజ సంస్థలు మద్దతు ఇస్తున్నాయి.

⚡ ముఖ్యమైన ప్రయోజనాలు (Benefits)

స్టాక్ ఓవర్‌ఫ్లో (Stack Overflow) సర్వేలో వరుసగా చాలా సంవత్సరాల పాటు "అందరూ ఇష్టపడే ప్రోగ్రామింగ్ లాంగ్వేజ్"గా రస్ట్ నిలిచింది. దానికి గల కారణాలు ఇవే:

గార్బేజ్ కలెక్షన్ లేకుండా మెమరీ సేఫ్టీ: ఇది రస్ట్ యొక్క "అద్భుతమైన ఫీచర్". ఇది కంపైల్ టైమ్‌లోనే మెమరీ భద్రతను అమలు చేయడానికి ఓనర్‌షిప్ (Ownership) మరియు బారోయింగ్ (Borrowing) అనే పద్ధతిని ఉపయోగిస్తుంది. అంటే ప్రోగ్రామ్ రన్ అవ్వకముందే బగ్స్ (Null pointer వంటివి) రాకుండా ఇది అడ్డుకుంటుంది.
అద్భుతమైన వేగం: జావా (Java) లేదా పైథాన్ (Python) లాగా బ్యాక్‌గ్రౌండ్‌లో భారీ "గార్బేజ్ కలెక్టర్" ఇందులో ఉండదు. కాబట్టి, రస్ట్ యాప్స్ C++ తో సమానమైన వేగంతో పనిచేస్తాయి.
భయం లేని కంకరెన్సీ (Fearless Concurrency): మల్టీ-థ్రెడెడ్ ప్రోగ్రామ్స్ రాయడం చాలా కష్టం. కానీ రస్ట్ కంపైలర్ డేటా సమస్యలను (data races) నివారిస్తుంది. దీనివల్ల మీరు క్రాష్ అవుతుందనే భయం లేకుండా ప్యారలల్ కోడ్ (parallel code) రాయవచ్చు.
అద్భుతమైన టూల్స్: రస్ట్ 'కార్గో' (Cargo) అనే ప్యాకేజీ మేనేజర్ మరియు బిల్డ్ సిస్టమ్‌తో వస్తుంది. ఇది సాఫ్ట్‌వేర్ ఇండస్ట్రీలోనే అత్యుత్తమమైనదిగా పరిగణించబడుతుంది.
సహాయకరమైన ఎర్రర్ మెసేజ్లు: రస్ట్ కంపైలర్ ఒక కఠినమైన కానీ సహాయపడే గురువు లాంటిది. కేవలం "Error" అని చెప్పకుండా, తప్పు ఎక్కడ ఉందో, ఎందుకు వచ్చిందో మరియు దాన్ని ఎలా సరిదిద్దాలో కూడా ఇది స్పష్టంగా సూచిస్తుంది.

😂 సరదా విషయాలు (Fun Facts)

రస్ట్ కమ్యూనిటీకి ఒక ప్రత్యేకమైన హాస్య చతురత ఉంది:

మాస్కాట్ (Mascot): రస్ట్ యొక్క అనధికారిక చిహ్నం 'ఫెర్రిస్' (Ferris) అనే పీత (crab). రస్ట్ డెవలపర్ల డెస్క్‌లపై పీత బొమ్మలు తరచుగా కనిపిస్తాయి.
"రస్టేషియన్స్" (Rustaceans): రస్ట్ వాడేవాళ్ళు తమను తాము "రస్టేషియన్స్" అని పిలుచుకుంటారు (Crustaceans - పీత జాతి అనే పదం నుండి ఇది వచ్చింది).
పేరు వెనుక కథ: గ్రేడన్ హోరే ఈ లాంగ్వేజ్‌కి రస్ట్ ఫంగస్ (బూజు) పేరు పెట్టారు. ఎందుకంటే ఆ ఫంగస్ జీవశాస్త్రపరంగా చాలా బలంగా ఉంటుంది మరియు దాన్ని చంపడం కష్టం. అంతే కానీ "తుప్పు పట్టిన ఇనుము" అని దీని ఉద్దేశ్యం కాదు.
"రీరైట్ ఇట్ ఇన్ రస్ట్" (Rewrite it in Rust): ప్రోగ్రామింగ్ ప్రపంచంలో ఇదొక జోక్ (Meme). రస్ట్ అభిమానులు ప్రతి సాఫ్ట్‌వేర్‌ను (Linux నుండి చిన్న టూల్స్ వరకు) రస్ట్‌లో మళ్ళీ రాయమని జోక్ చేస్తూ ఉంటారు.
టర్బోఫిష్ (Turbofish): రస్ట్‌లో ::<> అనే సింటాక్స్ వాడతారు. ఇది చూడటానికి చేపలా ఉంటుంది కాబట్టి కమ్యూనిటీ దీనిని అధికారికంగా "టర్బోఫిష్" అని పిలుస్తుంది.

పైథాన్ (Python) మరియు రస్ట్ (Rust) మధ్య తేడాను అర్థం చేసుకోవడానికి ఒక చిన్న ఉదాహరణను చూద్దాం.

మనం ఒక లిస్ట్‌లోని సంఖ్యలను కూడే (Sum of numbers) చిన్న ప్రోగ్రామ్‌ను తీసుకుందాం.

🐍 1. పైథాన్ (Python) కోడ్

పైథాన్ రాయడానికి చాలా సులభంగా, ఇంగ్లీష్ చదివినట్లు ఉంటుంది.

Python
def main():
    # లిస్ట్ తయారు చేయడం
    numbers = [10, 20, 30, 40, 50]
    
    total = 0
    
    # లూప్ ద్వారా కూడటం
    for num in numbers:
        total += num
        
    print(f"మొత్తం విలువ: {total}")

main()

గమనిక: ఇక్కడ మనం వేరియబుల్స్ ఏ రకానికి (Type) చెందినవి అని చెప్పలేదు. పైథాన్ దానంతట అదే అర్థం చేసుకుంటుంది. ఇది రాయడం సులభం, కానీ కొన్నిసార్లు రన్ చేసేటప్పుడు ఎర్రర్స్ రావచ్చు.

🦀 2. రస్ట్ (Rust) కోడ్

రస్ట్ కొంచెం ఎక్కువ వివరంగా ఉంటుంది, కానీ చాలా సురక్షితం.

Rust
fn main() {
    // లిస్ట్ (Vector) తయారు చేయడం
    let numbers = vec![10, 20, 30, 40, 50];
    
    // 'mut' అంటే 'mutable'. అంటే ఈ విలువను మనం మార్చవచ్చు అని అర్థం.
    // రస్ట్‌లో సాధారణంగా వేరియబుల్స్ మార్చలేము, అందుకే 'mut' వాడాలి.
    let mut total = 0;
    
    // లూప్ ద్వారా కూడటం
    for num in numbers {
        total += num;
    }
    
    // ప్రింట్ చేయడం (చివర ! ఉంటే అది మ్యాక్రో అని అర్థం)
    println!("మొత్తం విలువ: {}", total);
}

🔍 ప్రధాన తేడాలు (Key Differences):

కచ్చితత్వం (Strictness):
- పైథాన్: total = 0 అని రాస్తే చాలు.
- రస్ట్: let mut total = 0; అని రాయాలి. రస్ట్‌లో ఒక వేరియబుల్ విలువను మార్చాలంటే కచ్చితంగా mut (mutable) అని చెప్పాలి. లేకపోతే రస్ట్ కంపైలర్ ఒప్పుకోదు. ఇది అనుకోకుండా డేటా మారిపోకుండా కాపాడుతుంది.
సింటాక్స్ (Syntax):
- పైథాన్‌లో స్పేస్ (Indentation) ముఖ్యం.
- రస్ట్‌లో { } (కర్లీ బ్రేసెస్) మరియు ; (సెమికోలన్) వాడతాం (C++ లాగా).
వేగం (Speed):
- పైథాన్ కోడ్ రన్ అయ్యేటప్పుడు మెల్లగా ఉంటుంది.
- రస్ట్ కోడ్ కంపైల్ అయ్యాక, మెషీన్ కోడ్‌గా మారి చాలా వేగంగా రన్ అవుతుంది.