Limbajul de programare Rust

Categorii: Programare

16-Mar-2021 18:28 - 60 vizionari

Cu trei zile in urma am gasit un tutorial Rust de aproape doua ore si am realizat ce potential are acest limbaj:

Rust este simultan rapid, robust si productiv.

Rust este compilat si compilatorul garanteaza (prin analiza statica a codului) ca nu sunt probleme de alocare a memoriei sau de utilizare incorecta a memoriei alocate, adica programul are un comportament sigur chiar si in executia paralela.

In Rust nu ai probleme (frecvent intalnite in C, Java si Golang) in timpul executiei de tip “null pointer exception” pentru ca nu permite compilatorul. Compilatorul Rust refuza sa construiasca un program aparent scris corect (alte limbaje il accepta), dar cu utilizare incorecta a variabilelor declarate.

Dupa doua zile de teste pot spune ca am o solutie de conectare la un server MS SQL (4 ore m-am chinuit sa potrivesc versiunile bibliotecilor necesare si sa determin compilatorul sa imi accepte programul) dupa ce am invatat si aplicat corect notiunile de baza ale programarii in Rust:


use tiberius::{AuthMethod, Client, Config, EncryptionLevel};
use tokio::net::TcpStream;
use tokio_util::compat::TokioAsyncWriteCompatExt;

#[tokio::main]
async fn query(query: &str, descr: &str) -> anyhow::Result<()> {
    let mut config = Config::new();
    config.host("127.0.0.1");
    config.port(1433);
    config.trust_cert();
    config.encryption(EncryptionLevel::Off);
    config.database("mydatabase");
    config.authentication(AuthMethod::sql_server("user", "password"));
    let tcp = TcpStream::connect(config.get_addr()).await?;
    tcp.set_nodelay(true)?;

    // To be able to use Tokio's tcp, we're using the `compat_write` from
    // the `TokioAsyncWriteCompatExt` to get a stream compatible with the
    // traits from the `futures` crate.
    let mut client = Client::connect(config, tcp.compat_write()).await?;

    let results = client.simple_query(query).await?.into_results().await?;
    println!("{}", descr);

    for val in results.iter() {
        for inner in val.iter() {
            if let Some(id) = inner.get::("id") {
                print!("id = {} ", id);
            }
            if let Some(name) = inner.get::<&str, _>("nume") {
                println!("name = {}", name);
            }
        }
    }
    Ok(())
}


fn main() {
    println!("Main cu doua interogari SQL:");
    let _ret1 = match query("SELECT id,nume FROM Linii", "Set 1:") {
        Ok(v) => v,
        Err(e) => println!("Eroare1: {}", e),
    };
    match query("SELECT id,DenumirePalet as nume FROM Produse", "Set 2:") {
        Ok(v) => v,
        Err(e) => println!("Eroare2: {}", e),
    };
}



Fisierul Cargo.toml:


[package]
name = "teste-sql"
version = "0.1.0"
authors = ["Ioan Coman"]
edition = "2018"

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

[dependencies]
tiberius = "0.5.10"
tokio-util = { version="0.6.4", features = ["compat"] }
tokio = { version = "1.3", features = ["full"] }
anyhow = "1.0.31"


Astazi am testat un program Rust care porneste 600 de mii de proceduri, dar calculatorul (cu 8 giga de RAM) s-a blocat pentru 5-10 minute, in final am reusit sa opresc programul fara sa resetez calculatorul.

Interesant este ca initial am testat si era ok in Rust cu 100 de mii de proceduri si deja testasem Golang cu proceduri simultane, Golang ocupa 5 giga de RAM la 600 de mii de proceduri.

Dar Rust are o sintaxa un pic mai prietenoasa decat Golang si tratarea erorilor in Rust se face foarte elegant si aproape magic, in comparatie cu Golang unde aproximativ o treime din codul Golang scris trebuie sa verifice daca instructiunea anterioara s-a executat cu succes si daca nu, programatorul poate sa ignore eroarea (nu este recomandat),  sa o afiseze sau sa faca ceva util cu ea.

Robustetea limbajului Rust il face sa fie foarte potrivit pentru construirea sistemelor de operare, a programelor utilitare si chiar a driverelor.

Un program Rust simplu (fara sa importe biblioteci, ci doar sa afiseze ceva variabile pe ecran) ocupa 147-160 KB compilat, programul de conectare la MS SQL ocupa 3,8 MB in varianta de dezvoltare si 1,6 MB compilat cu optimizari (cargo build --release). Ca o comparatie, Golang genereaza programe executabile de cel putin 2 MB.

Exista mai multe incercari de construire a unui sistem de operare in Rust, un exemplu este https://os.phil-opp.com/

Cred ca urmatorul proiect il voi implementa in Rust.


Ultimele pagini: RSS

Alte adrese de Internet

Categorii

Istoric


Atentie: Continutul acestui server reprezinta ideile mele si acestea pot fi gresite.