• úvod
  • témata
  • události
  • tržiště
  • diskuze
  • nástěnka
    • přihlásit
    registrace
    ztracené heslo?
    SPIRALIRust - Programovací jazyk
    XCHAOS
    XCHAOS --- ---
    2 odpovědi-1
    ANT_39: tentokrát se to liší tím, že už opravdu kompipuju ukázky a tím, že do nich sáhnu, si ověřuju, že to chápu :-) ale z toho vyplývají nové otázky :-)

    ano, z C je toho málo, ale některé konstrukce, typu že .iter() dodává hodnoty zatímco .iter_mut() pointery na hodnoty a tudíž ten iterovaný kód se při změně z jednoho na druhý musí refaktorovat (chápu/píšu to správně?) nevím, jak by vysvětlovali někomu, kdo nepřichází z C, případně z C++. Nevím, kde jinde může začátečník pochytit koncept pointeru (leda by se ho učil přímo v Rustu... hmm, asi se začnou objevovat mladý lidi, co budou umět Rust, ale ne C... zajímavá představa).

    Je to právě četba ofiko dokumentace, která mi vede k pocitu, že vůbec nepíšou lidi, co C nebo C++ neznají a kdyby to byl VŠ kurz, berou to jako prerekvizitu. Protože tam ani nemají práci s pointery zmíněnou a v příkladech čtenáře rovnou házej do vody. A protože nejsem zběhlý v C++, ale v C, tak některé způsoby použití pointerů v Rustu mě matou (ale snad se orientuju, tak to holt bude copy+paste programování, zezačátku...)

    Protože jsem současně okouzlený Fediverse a ActivityPub, tak se hodlám zakousnout do
    GitHub - LemmyNet/activitypub-federation-rust: High-level Rust library for the Activitypub protocol
    https://github.com/LemmyNet/activitypub-federation-rust
    a začít si s tím hrát, ale na to potřebuju pochytit dostatek základních konceptů a prostě není to jen o "přečti si to"... používat copy+paste kód a nerozumět tomu co to dělá, je podle mě nejhorší způsob, jak programovat... (ale nic jiného mi asi nezbyde)
    ANT_39
    ANT_39 --- ---
    1 odpověď+4
    XCHAOS: Ty while let a if let jsou samozrejme syntax sugar, ale je to dost prakticky. Typicky mas std::option, a chces vedet, jestli je to Some nebo None. Tak napises
    if let Some(x) = neco_co_vrati_option() {
    ... je to Some, a tady muzu primo pouzit tu zapouzdrenou hodnotu x ...
} else {
    ... je to None, zadna zapouzdrena hodnota neni ...
}
    Me Rust prisel jako takovej hybrid Ocamlu a C, ale realne z toho C tam moc neni. Vyjadrovacima prostredkama je to spis podobny modernimu C++.
    Hele, ja s tebou tuhle hru nehraju poprve. Neco si k tomu precti. https://www.rust-lang.org/learn ma linky na Rust Book a Rust by Example. Dokumentace k Rustu, aspon k tem core vecem, je velice dobra.
    XCHAOS
    XCHAOS --- ---
    2 odpovědi-1
    Tak jsem si konečně Rust po letech odhodlávání se nainstaloval a začal si s ním hrát a některé věci jsou fakt easy a některé dokonce okamžitě chápu, proč to tak je (např. iterátory s modifikací nebo bez, polymorfismus místo dědičnosti apod.).

    Ale prosím vás... ty šílené flow control konstrukce jako let ... else, let .. .while, nebo if ... let... to se fakt používá? To mi přijde jako "přeslazená syntaxe"... nejdřív budu muset nějak pobrat skutečnost, že let vůbec může failnout, prostě když koukám na flow control v Rustu, tak je to úplný opak Pythonu, kde to hned od začátku bylo "kouknu a vidím", všechno je na první pohled jasné, zatímco tady prostě "kouknu a nevidím"... to flow control je zatím jedno z nejméně intuitivních ze všech jazyků, se kterými jsem se nově setkal... ale doufám, že se z toho ve skutečnosti většina toho moc nepoužívá (?)

    Do Rustu se pouštím jako bývalý céčkař, který nikdy pořádně nepronikl do C++, a reálně každodenní věci dělá v Pythonu, ale přijde mi škoda zahodit tu C zkušenost a přijde mi, že nejlíp jí uplatním právě v tom Rustu. Jenže problémy, na které narážím, jsou nečekaného typu... teda vlastně jsem ani ještě pořádně nezačal, že jo, ale :-)
    UNTOY
    UNTOY --- ---
    +3
    RustRover Is Released and Includes a Free Non-Commercial Option | The RustRover Blog
    https://blog.jetbrains.com/rust/2024/05/21/rustrover-is-released-and-includes-a-free-non-commercial-option/
    MARASAN
    MARASAN --- ---
    Nedelal jste nekdo WebServices klienta? Potreboval bych sice jednoduchyho WS klienta, ale potreboval bych jej se vsim tim korporatnim nanosem typu WS-Security, certifikaty, sifrovani, podpisy. Nenachazim crate, jestli nemate zkusenost?
    B42
    B42 --- ---
    +1
    meetup v praze 19.3.: https://www.meetup.com/rust-prague/events/299515169/
    GIOMIKY
    GIOMIKY --- ---
    GitHub - warpdotdev/Warp at news.itsfoss.com
    https://github.com/warpdotdev/Warp?ref=news.itsfoss.com
    BONEFLUTE
    BONEFLUTE --- ---
    RESURRECTION:

    Děkuji.

    Zatím jsem pochopil, že RefCell je od toho, že nemá vylejzat z objektu ven.

    Překopal jsem to všechno na &mut self, ale nakonec mě "něco" přinutilo, že jsem tam byl nucen dát self: &Rc. Ale také jsem celkově překopal architekturu.

    Možná ještě časem dozraju k dalšímu zjednodušení.
    VELDRANE
    VELDRANE --- ---
    RESURRECTION:
    BONEFLUTE:
    THEON:

    super thread! Diky kluci, docvaklo mi par veci :)
    SPIKE411
    SPIKE411 --- ---
    +2
    LUDWIG_: Aha, já před pár dny četl jen titulek tohoto a (aniž bych to otevíral) mi to vyznělo jako že budou přepisovat nějaké „jádro“ C# (části .NET?), a ono jde o M365.

    Microsoft seeks Rust developers to rewrite core C# code • The Register
    https://www.theregister.com/2024/01/31/microsoft_seeks_rust_developers/
    LUDWIG_
    LUDWIG_ --- ---
    1 odpověď+1
    Microsoft forms "new team" to adopt Rust into MS365's Substrate App Platform - MSPoweruser
    https://mspoweruser.com/microsoft-forms-new-team-to-help-rewrite-core-windows-components-into-rust-from-c-c/

    Search Jobs | Microsoft Careers
    https://jobs.careers.microsoft.com/global/en/job/1633482/Principal-Software-Architect

    Zajimava pozice v MS v Praze
    BONEFLUTE
    BONEFLUTE --- ---
    RESURRECTION: Díky, přežvejkám.
    RESURRECTION
    RESURRECTION --- ---
    1 odpověď+2
    THEON: Rc ti kompilator vetsinou zcela eliminuje, jen ne vzdy. Narozdil treba od Arcu, ktery z principu nemuze, protoze nema jak thready staticky analyzovat. Takze ano, neni to zero overhead, ale v praxi vetsinou ano. Daleko vetsi problem je ten RefCell, ktery bude mit runtime overhead vzdy, byt to taky nebude nejak dramaticke.
    THEON
    THEON --- ---
    2 odpovědi
    RESURRECTION: Rc je zero abstraction? Já myslel, že má taky za běhu nenulový (byť nepatrný) overhead, ty reference se odvíjí od chodu programu - a nebo to jsou ty jiné reference counting kontejnery jako Arc a Rc je magie? :)
    RESURRECTION
    RESURRECTION --- ---
    RESURRECTION: A jenom doplnim, ze multithreaded varianta nepouzije `Rc`, ale `Arc` (ten lock ma read() a write() misto borrow() a borrow_mut()), ale jinak to bude stejny.
    RESURRECTION
    RESURRECTION --- ---
    4 odpovědi+2
    BONEFLUTE: Hlavni problem je implementace `App`, nevidim moc duvod pro `self: &Rc`, proc ne `&self`? `Rc` je typicky to co pouziva klientsky/uzivatelsky kod, ne implementace. `Rc` je immutable single-threaded reference counted pointer. `RefCell` je pak runtime borrow checker. `Rc` je zero abstraciton, `RefCell` ma overhead (dela borrow checking v runtimeu). Pro to co chces mas vice moznosti:

    1. Uzivatel si bude resit borrowing v compile tam. Nepotrebujes ani `Rc`, proste signatury v impl budou:

    pub fn new(on_startup: ...) -> Self { /* */}
pub fn run(&self) { /* */}
pub fn add_something(&mut self, x: ...) { /* */ }

    2. Uzivatel si bude resit ten borrowing v runtimeu:

    // stejne signatury jako v 1.
let app = Rc::new(RefCell::new(App::new()));
app.borrow().run();
app.borrow_mut().add_something(x);

    3. Hidnes implementaci a ten runtime borrowing budes delat sam stejne jako ve 2 (hledej "interior mutability"), kde budou trochu jine ty signatiry:

    #[derive(Clone)]
struct App {
    callback: Rc<RefCell<Callback>>
}

pub fn new(on_startup: ...) -> Self { Self { callback: Rc::new(RefCell::new(on_startup)) } }
pub fn run(&self) { self.callback.borrow()... } // predpoklad je, ze callback je `Fn` nebo obdoba
pub fn add_something(&self, x: ...) { self.callback.borrow_mut()... } // <-- povsimni si, ze toto taky bere &self a ne `&mut self`

    Samozrejme nejlepsi je 1. Ty ostatni maji runtime overhead (borrow checking pri runtime). Zejmena jelikoz to mas single-threaded, tak neni moc duvod resit reference counting, pokud `App` nekde neskladujes jako member promennou. V kazdem pripade nejlepsi performance (za cenu nejake ergonomie) m a i v takovem pripade nasledujici pattern:

    struct App { pub callback: ... }
type Callabck = ...;

impl App {
    pub fn run(callback: &Callback)
    pub fn add_something: &mut Callback, x: ...);
}

fn main() {
    let app = App { callback: ... };
    App::run(&app.callback);
    App::add_something(&mut app.callback, x);
}

    Tahle varianta presouva ten borrow checking zpet do compile time a je vhodna tam, kde ten ownership neni uplne jasny a kde to chces volat z ruznych mist. Takhle se vlatne pise cecko (minus prave ten borrow checking).
    BONEFLUTE
    BONEFLUTE --- ---
    2 odpovědi
    Ahoj.

    Prosím poraďte, nebo mi vysvětlete, že to nejde.

    V kostce:
    Jde převést 
    Rc<App>
    na 
    Rc<RefCell<App>>
    ?

    Kontext:
    Mám strukturu App, nějak takto:
struct App {
    callback: ...
}
impl App {
	pub fn new(on_startup: ...) -> Rc<Self> {}
	pub fn run(self: &Rc<Self>) {
		... volání callbacku
	}
	pub fn add_something(mut self: &Rc<Self>, x: ...) {
		let _1: &Rc<ApplicationView> = self;
		let appview: Rc<RefCell<ApplicationView>> = ???;
	}
}
    Následně vytvořím instanci této struktury:

    let app = App::new(move |this| {
	let _: Rc<RefCell<App>> = this;
	this.add_something(obj);
});
    Ta lambda se uloží do vlastnosti struktury a zavolá se následně při zavolání metody run():
    app.run();

    Jak je doufám z kódu vidět, potřebuji převést 
    Rc<App>
    na 
    Rc<RefCell<App>>
    .

    (GPT mi radí různé způsoby, které žádné nefungují. Jak známo, když problematice nerozumíš, je GPT dost naprd.)

    Je samozřejmě možné, že toto nejde, a budu to muset udělat jinak. Ale rád bych si nechal vynadat a vysvětlit, že to mám dělat jinak a ideálně proč :-)

    Děkuji za nasměrování.
    SPIKE411
    SPIKE411 --- ---
    Where Does the Time Go? Rust's Problem with Slow Compiles - The New Stack
    https://thenewstack.io/where-does-the-time-go-rusts-problem-with-slow-compiles/
    SPIKE411
    SPIKE411 --- ---
    The Python Rust-aissance - Bain Capital Ventures
    https://baincapitalventures.com/insight/why-more-python-developers-are-using-rust-for-building-libraries/
    SPIKE411
    SPIKE411 --- ---
    +1
    Making Rust binaries smaller by default | Kobzol’s blog
    https://kobzol.github.io/rust/cargo/2024/01/23/making-rust-binaries-smaller-by-default.html
    Kliknutím sem můžete změnit nastavení reklam