Learners First, edistynyttä tietotekniikan koulutusta

crates.io-tunnus vaarassa

2024-11-07T00:00:00+00:00

.io -tunnuksen katoaminen ja crates.io
crates.io</a> on yksi Rust-ohjelmointiympäristön tärkeimmistä osista. Kun käännöksessä tarvitaan puuttuvaa kirjastoa, se haetaan automaattisesti crates.io:sta.
Nyt koko .io-tunnus on vaarassa kadota.
Kun Brittiläisen kansainyhteisön siirtomaat itsenäistyivät 60-luvulla, yksi näistä itsenäistyvistä siirtomaista oli Mauritius. Mauritiuksen Chagossaaret (pääsaari on Diego Garcian atolli) jäi kuitenkin Britannian hallintaan. Erotettua osaa kutsuttiin nimellä BIOT, British Indian Ocean Territory.
Diego Garcian atollilla on suuri USA:n sotilastukikohta, jota varten Britannia on vuokrannut maan USA:lle. Diego Garcian alkuperäiset asukkaat karkotettiin joko Mauritiukselle tai Britanniaan.
Internet-aikaan tultaessa BIOT sai .io-tunnuksen (Indian Ocean). Tämä tunnus on ollut suosittu teknologiayritysten keskuudessa, koska se muistuttaa termiä Input/Ouput.
Ongelma vain on se, että Diego Garcian kuuluminen Britannialle oli kansainvälisten sopimusten vastainen. YK on kartoissaan jo vuosia liittänyt Diego Garcian Mauritiukseen. Ennen siirtomaiden itsenäistymistä tehtiin sopimus, etteivät entiset isäntämaat saa poimia rusinoita pullasta vaan siirtomaiden on itsenäistyttyvä yhtenäisenä. Koska Diego Garcia kuului ennen itsenäistymistä Mauritiukseen, se olisi pitänyt luovuttaa Mauritiukselle itsenäistymisessä.
Vuosikymmenten taistelun jälkeen on päästy sopimukseen saarten kohtalosta. Britannia on luvannut luovuttaa Diego Garcian Mauritiukselle. USA:n tukikohta vuokrataan edelleen pitkäksi aikaa, mutta nyt Mauritiukselta.
Tämä muuttaa Diego Garcian osaksi Mauritiusta, jolloin se ei enää täytä itsenäisen alueen tunnusmerkkejä. ISO tullee poistamaan maatunnuksen "io" kaksikirjaimisten maatunnusten listalta ISO 3166-1 melko pian.
Internetin tunnuksista päättävät ovat olleet hyvin tarkkoja siitä, että kaksikirjaimisen tunnuksen omistaja on itsenäinen valtio. Harvoja poikkeuksia lukuunottamatta kaksikirjaimiset tunnukset tulevat suoraan ISO:n standardista. Poikkeus on esimerkiksi .su, joka on jäänyt Venäjän hallintaan, vaikka Neuvostoliitto hajosi.
.io-tunnusta hallinnoi Internet Computer Bureau Ltd, jonka omistaa Identity Digital -niminen yritys, jonka puolestaan omistaa Ethos Capital -niminen amerikkalainen sijoitusrahasto. Vuonna 2020 Ethos yritti ostaa myös .org-tunnuksen, mistä se sai huonon maineen Internet-hallinnoijien keskuudessa. Joidenkin mielestä sijoitusrahaston valta .io-tunnukseen on ongelmallista, varsinkin kun yleensä voi olettaa, että kaksikirjaimisen tunnuksen hallinnoija on kyseisen maan virasto.
On kuitenkin mahdollista, että Mauritius tekee Chagossaarista oman alueensa. Suomessa Ahvenanmaalla on oma .ax-tunnuksensa, vaikka se on osa Suomea.
Tällä hetkellä ei ole mitään syytä olettaa, että .io-tunnus olisi kovin pitkäikäinen. Vielä ei ole paniikkiakaan, koska se ei varmaankaan katoa seuraavaan viiteen vuoteen, mutta sen jälkeen tilanne on epävarma. Ennen lopullista katoamista tulee olemaan vaihe, jossa ei voi luoda enää uusia io-tunnuksia.
On huono ajatus kovakoodata Rust-kääntäjään crates.io-osoitteita.

Mitä pitäisi tehdä?

The Highest-Paying IT Certifications for 2024</a>
CISSP-sertifikaatti tuo tilipussiin Amerikassa keskimäärin 156.699 dollaria vuodessa. Laskua edelliseen vuoteen on prosentti, mutta kyseessä on kuitenkin erittäin hyvä palkka.
Pilvipalveluiden tietoturvasertifikaatti AWS Certified Security - Specialty on sijalla 6. Palkka nousee CISSP:stä noin kymmenllä tuhannella dollarilla kuussa.
Sijalla 5 on CISM, Certified Information Security Manager. Palkka on sama kuin AWS-tietorvasertifikaatilla. Palkka on parempi kuin CISSP:llä, mutta toimenkuvakin muuttuu asiantuntijasta manageriksi.
Kärkisijat vievät tekniset pilvipalvelujen sertifikaatit. Google Cloud Architect on johdossa yli 200.000 dollarin vuosipalkalla.
CISSP:n taakse jäävät CRIS eli Certified in Risk and Information Systems Control, CIPM eli Certified Information Privacy manager ja CISA eli Certified Information Systems Auditor.

Rust ei ole oliokeskeinen ohjelmointikieli

2024-07-17T00:00:00+00:00

Rust-yhteisössä on yleistä, että aloittelevat Rust-kehittäjät etsivät tapoja soveltaa tuttuja olio-ohjelmoinnin (OOP) konsepteja Rustin maailmaan. Vaikka Rust ei ole puhdas oliokieli, se tarjoaa tehokkaita työkaluja vastaavien ratkaisujen toteuttamiseen.
Tässä käydään läpi niitä olio-ohjelmoinnin ominaisuuksia, joita on turha etsiä Rustista.
Huomaa, että tässä keskitytään ominaisuuksiin, joita Rustissa ei ole. Rustissa on paljon ominaisuuksia, jotka tarjoavat samankaltaisia toiminnallisuuksia kuin oliokielissä, mutta niitä ei tarkemmin käsitellä tässä.
Rust on muistikeskeinen, ei toimintakeskeinen kieli
#</a> </h2> Rustissa ei käytetä gettereitä ja settereitä. Näitä käytetään oliokielissä muuttamaan kentän arvo toiminnoiksi, joita voidaan perinnässä muokata. Jos haluat muuttaa olion tilaa Rustissa, tee se suoraan. fn main() { let mut henkilo = Henkilo { nimi: "Matti".to_string(), ika: 42, }; henkilo.ika = 43; henkilo.tervehdi(); }</code></pre> Seuraava oliokielissä tuikitavallien koodi siis osoittaa, ettet ole ymmärtänyt Rustin oliomallin perusteita. struct Henkilo { nimi: String, ika: u8, } impl Henkilo { fn set_ika(&mut self, ika: u8) { self.ika = ika; } fn tervehdi(&self) { println!("Hei, nimeni on {} ja olen {} vuotta vanha.", self.nimi, self.ika); } } fn main() { let mut henkilo = Henkilo { nimi: "Matti".to_string(), ika: 42, }; henkilo.set_ika(43); henkilo.tervehdi(); }</code></pre> Ilman perintää gettereissä ja settereissä ei ole järkeä. Private-kentät#</a> </h2> Joissain olio-ohjelmointikielissä kenttien näkyvyyden määrittely on keskeinen osa suunnittelua. Kentät voivat olla yksityisiä, julkisia, aliluokkien käytettävissä tai oletusarvoisia, ja esimerkiksi Javassa on peräti 40 eri vaihtoehtoa käyttöpaikkojen ja suojausmääritelmien yhdistelmille. Rustissa ei ole yksityisiä kenttiä. Kaikki kentät ovat moduulin sisällä julkisia. Tarkemmasta suojauksesta vastaa Rustin tyyppijärjestelmä. Moduulien välillä Rustin funktiot ja kentät ovat oletuksena yksityisiä, mutta ne voidaan julkaista pub</code>-avainsanalla. Yleisesti ottaen Rustin kanssa voit unohtaa monimutkaiset näkyvyyssäännöt. Rustissa ei ole new()-funktiota, joka loisi dynaamisia objekteja#</a> </h2> Oliokielissä on usein konstruktoreita ja destruktoreita. Konstruktori luo olion ja destruktori poistaa sen. Rustista niitä on turha etsiä. Rustissa ei ole erityistä new-konstruktoria, joka loisi olion. Ja erityisesti Rustissa ei ole new-konstruktoria, joka loisi dynaamisen olion. Rust-olioita voi luoda aivan hyvin pinomuuttujina. Useimmat Rust-oliot eivät ole dynaamisia olioita, joille tila on varattava ajon aikana keosta. fn main() { let henkilo = Henkilo { nimi: "Matti".to_string(), ika: 42, }; henkilo.tervehdi(); }</code></pre> Tämä olio käyttäytyy aivan kuin normaali muuttuja. Se on pinossa ja se poistetaan automaattisesti, kun sen käyttöalue päättyy. Sen koko tiedetään käännösaikana, joten se vain varataan pinosta ilman mitään muuta työtä. Huomaa, että nimi on tyyppiä String, joka aina automaattisesti varataan keosta. Pinossa on siis vain viite kekoon tuon kentän osalta. Jos olio luodaan dynaamisesti, se tehdään Boxin avulla. fn main() { let henkilo = Box::new(Henkilo { nimi: "Matti".to_string(), ika: 42, }); henkilo.tervehdi(); }</code></pre> Dynaamiset muuttujat ovat aina sidoksissa pinomuuttujaan. Kun pinomuuttuja poistuu pinosta, siihen liittyvä dynaaminen muuttuja poistetaan automaattisesti. Box käyttää standardikirjaston allokaattoria std::alloc::System, joka on oletuksena Linuxissa glibc:n malloc(). Sen voi kuitenkin korvata omalla allokaattorilla. </blockquote> Rustissa on usein tapana tehdä new-funktio, joka luo olion. Mutta tämäkään ei ole dynaaminen olio. struct Henkilo { nimi: String, ika: u8, } impl Henkilo { fn new(nimi: String, ika: u8) -> Henkilo { Henkilo { nimi, ika } } fn tervehdi(&self) { println!("Hei, nimeni on {} ja olen {} vuotta vanha.", self.nimi, self.ika); } } fn main() { let henkilo = Henkilo::new("Matti".to_string(), 42); henkilo.tervehdi(); }</code></pre> Tämä esimerkki luo Henkilo-tyyppisen olion new()-funktiossa ja palauttaa sen main()-funktiolle. Paluuarvo kopioidaan main()-funktion henkilo-muuttujaan. Sille siis tehdään tilaa main()-funktion pinosta jo main()-funktion käynnistyessä. Rustissa new()-funktio ei ole merkki dynaamisesta muistinvarauksesta. Sen käyttö on täysin vapaaehtoista. Kyse on tavallisesta käytännöstä, ei kielessä olevasta rakenteesta. Rustissa ei puhuta patterneista#</a> </h2> Patternit ovat oliokielten tapa selvitä ongelmista, joita oliomalli aiheuttaa. Periaatteessa Rustissakin voisi olla patterneja, mutta kieli taipuu paljon paremmin selvittämään nuo ongelmat toisilla tavoilla. Siksi: "First rule of Rust: Don't talk about patterns."
Rust tulossa Windowsiin 2023-05-09T00:00:00+00:00 Rust tulossa Windowsiin#</a> </h2> Rust on loistava uusi kieli rautaa lähellä olevaan ohjelmointiin. Rustilla tehdyt ohjelmat ovat tehokkaita, virheettömiä ja ohjelmoinnissa voi käyttää korkeita abstraktioita. Eipä siis ole ihme, että myös Microsoft on alkanut käyttää sitä Windowsin ytimen kehityksessä. Käyttöjärjestelmän tietoturvallisuuden johtaja David Weston vahvisti konferenssissa huhtikuussa 2023, että Windows 11:ssa tulee olemaan Rustilla kirjoitettua koodia viikkojen tai korkeintaan kuukausien päästä. Windows 11 preview -versiossa joitakin käyttöjärjestelmän osia on kirjoitettu uudelleen Rustilla. Rust-koodin nopeus on ollut erinomainen, mitään huononnusta C++ -versioon Microsoft ei ole havainnut. Microsoft kiittää Rustissa muistiturvallisuuden lisäksi mm. Result- ja Vec-tyyppejä, jotka tekevät APIeista helpompia ymmärtää. Rustin odotetaan tekevän Windowssista turvallisemman ja helpomman ylläpitää. Jo syyskuussa 2022 Microsoft Azuren johtaja Mark Russinovich kertoi, että Microsoft on alkanut käyttää Rustia Azure-palvelimien kehityksessä. Kaikkien uusien projektien odotetaan käyttävän Rustia C/C++:n sijaan. Ensimmäinen Microsoftin isompi Rust-projekti on ollut DWriteCore, joka on DirectWrite-kirjaston uusi versio. DirectWrite on Windowsin kirjasto, joka piirtää tekstin näytölle. Tällä hetkellä kirjastossa on 152 000 riviä koodia, josta 56 000 on Rustia. Tämänhetkinen kirjasto on 5 - 15% nopeampi kuin C++-versio. Kirjasto on jo nyt kehittäjien käytössä. Toinen työn alla oleva kirjasto on Win32 GDI, joka on Windowsin graafinen kirjasto. Tästä 36 000 riviä koodia on kirjoitettu uudelleen Rustilla, mutta se ei ole vielä kehittäjien käytettävissä. https://www.windowslatest.com/2023/05/02/windows-11-updates-booting-with-rust-refs-instead-of-ntfs-file-system</a> https://www.theregister.com/2023/04/27/microsoft_windows_rust</a> Heterogeeninen lista Rustissa 2022-07-02T00:00:00+00:00 Heterogeeninen lista#</a> </h2> Rust-ohjelmointikielessä ei ole olio-ohjelmoinnin perintää. Kuitenkin hyödyllisimmät perinnän edut saadaan aikaan traiteilla. Tärkein käyttötarkoitus on heterogeeninen lista. Heterogeenisessa listassa on useita erityyppisiä olioita, joilla kaikilla on sama trait eli joukko samalla tavalla kutsuttavia funktioita. Drawable ja executable -esimerkki#</a> </h2> Peleissä käytetään paljon heterogeenisia listoja. Esimerkiksi virtuaalimaailman objektit käydään nopeasti läpi kutsumalla piirrettävissä olevien objektien draw()-funktiota ja esim. kerran mikrosekunnissa muutosta vaativien objektien tick()-funktiota. Itse objektit voivat muuten olla täysin erilaisia. Tämä on perinteinen esimerkki heterogeenisista listoista, joita nyt tässäkin käytämme. Olio-ohjelmoinnin ratkaisu#</a> </h2> Olio-ohjelmoinnissa piirrettävissä olevat oliot ovat erikoistapauksia ("perivät") samasta drawable-luokasta. Silloin näitä olioita voi laittaa samaan taulukkoon, joka nopeasti käydään läpi kutsuen kaikille yhteistä draw()-funtiota. Puuttumatta yksityiskohtiin, oliokielten perinnässä on aina jonkin verran ajonaikaista tehottomuutta. Myös jos sama objekti on sekä "drawable" että "executable", niiden on perittävä kummastakin luokasta. Tästä tulee omat sotkunsa, jotka eri oliokielet ratkaisevat eri tavalla. Rust-trait#</a> </h2> Rust ratkaisee ongelman traiteilla. Jos olioon on liitetty trait "Drawable", sen on toteutettava funktio Draw() identtisellä tavalla. Tämä ei kuitenkaan anna vielä lupaa kutsua tätä funktiota tietämättä olion tyyppiä käännösaikana. Rust on staattinen kieli, jossa ei lisätä dynaamisia tietorakenteita turhan takia. Esimerkiksi tyyppi "Line" voi olla struct Line { x1: i32, x2: i32, y1: i32, y2: i32, } trait Drawable { fn draw(&self); } impl Drawable for Line { fn draw(&self) { println!("line"); } }</code></pre> Tämä tarkoittaa, että jos tästä tyypistä luodaan muutuja, se on täsmälleen 4*32 bittiä eli 16 tavua. muuttujassa ei ole tietoa tyypistä tai ohjeita Draw()-funktion kutsumiseen. Voit luoda Line-tyyppisen muuttujan ja kutsua sen Draw()-funktiota, esim. let line = Line { x1: 1, x2: 2, y1: 3, y2: 4 }; line.Draw();</code></pre> mutta tämä perustuu siihen, että kääntäjä tietää käännösaikana muuttujan line tyypin ja osaa siten kutsua oikeaa Draw()-funktiota. Dynaaminen trait-objekti#</a> </h2> Että voimme käsitellä samassa listassa eri tyyppisiä instansseja, joudumme luomaan trait-objekti -tyyppisen viittauksen varsinaiseen objektiin. let line = Line { x1: 1, x2: 2, y1: 3, y2: 4 }; let l: &dyn Drawable = &line; l.Draw();</code></pre> Oikeaan muistissa olevaan objektiin line voi luoda viittauksen trait-objektina. Tähän viittaukseen lisätään tyyppi-informaatio niin, että viittausta voi käyttää myös sellaisissa tilanteissa, että tyyppi ei ole selvillä käännösaikana. Esimerkissä muuttujan l tyyppi ei ole Line vaan "mikä tahansa, mikä toteuttaa traitin Drawable". Toteutus tässä on se, että muuttuja l on todellisuudessa kaksi osoitinta. Yksi, joka osoittaa muuttuujaan line ja siellä oleviin kuuteentoista tavuun dataan. Ja toinen, joka osoittaa staattisella alueella sijaitsevaan "vtableen" (virtual table). Vtable luodaan jokaiselle tyypille jokaiselle traitille, ja se siältää osoittimet tuon tyypin funktioille. Esimerkissämme stattisella muistialueella on siis osoitin fuktioon Draw() tyypille Line. Kaikissa traitin Drawable vtableissa on samassa paikassa osoitin funktioon Draw(), eri tyypeillä on vain eri vtable. Kun siis kutsutaan seuraavaa Draw()-funtiota x.Draw(); // x tyyppiä &dyn Drawable</code></pre> Ensin otetaan muuttujasta x se osa, joka osoittaa vtableen. vtablen vakiokohdasta, esim. tavu 16 löytyy osoite funktioon Draw Line-tyypin traitista Drawable. Tälle annetaan parametreiksi muuttujan x toisen osan pointterin päästä löytyvä muuttuja. Kaikki tapahtuu erittäin tehokkaasti kun kaikki raskas päättely tehdään jo käännösaikana. Kuinka tehdä heterogeeninen lista#</a> </h2> Nyt maillä on ainekset koossa heterogeeniseen listaan. Yksinkertaisesti teemme listan, jossa on viittauksia objekteihin, joiden tyyppi toteuttaa Drawable-traitin. let v : Vec<&dyn Drawable> = vec![&line, &square, &line, &line]; for x in v.iter() { x.draw() }</code></pre> Objektilla on siis oltava todellinen muistia varaava implementaatio valmiina muualla. Esimerkkikoodi#</a> </h2> Ja tässä vielä kokonaisuudessaan esimerkkikoodi heterogeenisten listojen käytöstä. #![allow(dead_code)] struct Line { x1: i32, x2: i32, y1: i32, y2: i32, } struct Square { x: i32, y: i32, width: i32, height: i32, } trait Drawable { fn draw(&self); } impl Drawable for Line { fn draw(&self) { println!("line"); } } impl Drawable for Square { fn draw(&self) { println!("square"); } } trait Executable { fn tick(&self); } impl Executable for Square { fn tick(&self) { println!("square tick"); } }</code></pre>fn main() { let line = Line{ x1: 1, x2: 2, y1: 3, y2: 4, }; let l: &dyn Drawable = &line; l.draw(); let square = Square{ x: 1, y: 2, width: 3, height: 4, }; let v : Vec<&dyn Drawable> = vec![&line, &square, &line, &line]; let e : Vec<&dyn Executable> = vec![&square, &square, &square]; for x in v.iter () { x.draw(); }; for x in e.iter () { x.tick(); }; }</code></pre> Rust itseopiskelumateriaaleja 2022-01-06T00:00:00+00:00 Rust-ohjelmointikielen kokeiluympäristöjä#</a> </h2> Rust-ohjelmointia voi harjoitella itsekseen monella tavalla. Tässä listataan joitakin vaihtoehtoja, jotka eivät ole pelkkää lukemista, vaan niiden avulla voi oppia kirjoittamalla koodia. Tour of Rust#</a> </h3> Tour of rust käy läpi Rustin perusteet yhdeksässä kappaleessa. Jokaiseen asiaan liittyy esimerkki, joka on kuvauksen vieressä. Esimerkkiä voi muuttaa ja ajaa suoraan ikkunassa. Kurssin ensimmäinen kappale on käännetty suomeksikin allekirjoittaneen toimesta, mutta se kannattaa käydä läpi alkuperäisenä englanninkielisenä versiona. https://tourofrust.com/</a></li> </ul> Rust Playground#</a> </h3> Tour of Rustin esimerkit itse asiassa suoritetaan upotetussa Rust Playground -ikkunassa. Tätä voi käyttää suoraan selaimesta osoitteessa https://play.rust-lang.org/</a></li> </ul> Pro-vihje: voit tutkia ohjelman tuottamaan Assembly-koodia vaihtamalla Play -> Asm ja Debug -> Release. Ohjelmassa on vieläkin aika paljon ylimääräistä, mutta pääohjelmasi tuottama Assembly-koodi löytyy kohdasta playground::main. </blockquote> VS Code Rust Playground#</a> </h3> Joskus nopeisiin kokeiluihin ei riitä Rust Playgroundin sallimat cratet tai CPU-aika, joten voit haluta vastaavan toiminnallisuuden omaan koneeseesi. VS Codeen on saatavilla plugin, jolla Rust-koodia voidaan kokeilla nopeasti luomatta kokonaista projektia: https://marketplace.visualstudio.com/items?itemName=ConradLudgate.rust-playground</a></li> </ul> IntelliJ IDEA Rust Playground#</a> </h3> Vastaava Rust Playground IntelliJ IDEA -kehitysympäristöön löytyy https://github.com/MolotovCherry/IntelliJ-Rust-Playground</a></li> </ul> Rust-tehtäviä editorilla ja tarkistimella#</a> </h2> CodeWars Rust#</a> </h3> CodeWars sisältää tehtäviä, jotka voi tehdä sisäänrakennetulla editorilla, testata vastauksensa ja sitten toimittaa vastauksen julkiseen arvosteluun. https://www.codewars.com/</a></li> </ul> Rust-tehtäviä on tällä hetkellä noin 550 ja ne on jaettu kahdeksaan vaikeusasteeseen. Tehtävät ovat käyttäjien tekemiä. Yksi hankaluus näissä tehtävissä on, että samat tehtävät on tarkoitettu usealle eri ohjelmointikielelle. Esimerkiksi keskimmäisen kirjaimen löytäminen merkkijonosta on Rustilla paljon vaikeampaa kuin C:llä, koska C olettaa tasamittaisen ASCII-koodin mutta Rust UTF-8 vaihtuvakoodisen merkistön. Monien tehtävien hyväksytyt ratkaisut ovatkin rumaa Rust-kieltä. Monet tehtävät ovat myöskin enemmän matematiikkaa kuin ohjelmointia. LeetCode#</a> </h3> Toinen samanlainen sivusto on LeetCode. https://leetcode.com/</a></li> </ul> Näistä monen tehtävän ongelmana on, että ne vaativat suoraan linkitetyn listan käyttöä, mikä on Rustissa vaikeaa tai mahdotontakin (ilman unsafe-lohkoja). Codingame#</a> </h3> Rustia voi oppia myös pelaamalla. Tällä sivustolla voit haastaa vastustajia 15 minuutin otteluun tehtävien ratkaisuista. https://www.codingame.com/</a></li> </ul> Nopeimmat ratkaisevat tehtävät yleensä Pythonilla, joten joudut olemaan nopeampi kuin he. Muut#</a> </h3> Tässä vielä muutama samantyyppinen tehtäväsivusto, joka tukee Rustia. Näitä en ole kokeillut. https://exercism.org/</a></li> https://www.codechef.com/</a></li> https://www.spoj.com/</a></li> </ul> Excercism tarjoaa perusharjoituksia 55 ohjelmointikielelle, joista Go on neljänneksi suosituin ja Rust viidenneksi. Excercismin harjoitukset on ryhmitetty kielten rakenteiden mukaan, ja ne ovat CodeWarsiin ja LeetCodeen verrattuna yksinkertaisia. Päivitys 2024: IntellijIDEA-linkki vaihdettu toimivaksi. </blockquote> Minimaalinen Docker/Rust image 2021-11-23T00:00:00+00:00 Kuinka tehdä minimaalinen Docker-kontti, jossa on vain Rust-ohjelma#</a> </h2> Minimaalisessa Docker-kontissa ei ole muuta kuin yksi staattisesti linkitetty ohjelma. Staattisessa ohjelmassa on kaikki mahdolliset kirjastot otettu mukaan samaan suoritettavaan tiedostoon. Scratch-image#</a> </h2> Kun käytämme pohjana Docker-konttia Scratch</code>, imagen koko muu tiedostojärjestelmä on tyhjä. Itse asiassa Docker toteuttaa tämän imagen sisäisesti. Vanhemmissa Dockereissa FROM Scratch</code> loi oikeasti tyhjän tiedostolayerin, mutta uusimmissa ei luoda erillistä tiedostolayeriä. [5] Rust-ohjelmamme tulee olemaan tiedostojärjestelmän ainoa tiedosto. Esimerkkiohjelma#</a> </h2> Esimerkkiohjelma käy pyytämässä httpbin.org -palvelusta kysyjän eli meidän ulkoisen IP-osoitteemme merkkijonona, esim. "122.123.124.125". [1] Haussa käytetään webbikutsun tekevää reqwest</code>-pakettia ja JSON</code>-vastauksen aukaisevaa Serde</code>-pakettia. use serde::Deserialize; use std::error::Error; #[derive(Deserialize, Debug)] struct ApiRes { origin: String, } fn main() -> Result<(), Box<dyn Error>> { let res = reqwest::blocking::get("http://httpbin.org/ip")?.json::<ApiRes>()?; println!("{}", res.origin); Ok(()) }</code></pre>Cargo.toml#</a> </h2> Projektin kuvauksessa joudutaan asettamaan muutama valinnainen ominaisuus. Serden ominaisuus "derive" on valinnainen. Sen ja reqwest-craten "json"-ominasuuden avulla web-kutsun paluu-JSON luetaan suoraan kentän "origin" arvoksi. Web-kutsun tekevän reqwest-paketin oletus on asynkroninen toiminta. Yksinkertaisesti vastausta odottamaan jäävää blocking-ominaisuutta täytyy erikseen pyytää. [package] name = "minimal-docker" version = "0.1.0" edition = "2018" [dependencies] serde = { version = "1.0.130", features = ["derive"] } reqwest = { version = "0.11.6", default-features = false, features = ["json", "blocking"] }</code></pre>Käännös#</a> </h2> Staattisessa käännöksessä kaikki kirjastot halutaan ohjelman sisään. Yleensä Linuxissa käännettävät Rust-ohjelmat olettavat koneesta löytyvän dynaamisesti ladattava glibc</code>-kirjasto. glibc</code> soveltuu kuitenkin huonosti staattiseen käännökseen. Vaikka glibc</code> olisi käännetty staattisesti, se haluaa silti ladata muutaman alikirjaston dynaamisesti. [3] Helpointa on käyttää pienempää MUSL</code>-kirjastoa ja kääntää se staattisesti ohjelmaan. Kun valitsemme käännöksen target-arkkitehtuuriksi x86_64-unknown-linux-musl</code></pre> saamme käyttöön MUSL</code>-kirjaston ja staattisen käännöksen. Tämä käännöstargetin kääntäjät ja kirjastot saadaan käyttöön rustup</code>-komennolla rustup target add x86_64-unknown-linux-musl</code></pre> Lisäksi saatetaan tarvita paketit (Debian/Ubuntu) musl-tools</code> ja musl-dev</code>, mutta esimerkissämme näitä ei tarvita. Imagen luonti#</a> </h2> Dockerfile</code> on seuraavan näköinen (Yksinkertaistettu lähteen [1] esimerkistä.) # # Käännösimage # FROM rust:latest AS builder RUN rustup target add x86_64-unknown-linux-musl ENV USER=minimal-docker ENV UID=10001 RUN adduser \ --disabled-password \ --gecos "" \ --home "/nonexistent" \ --shell "/sbin/nologin" \ --no-create-home \ --uid "${UID}" \ "${USER}" WORKDIR /minimal-docker COPY ./ . RUN cargo build --target x86_64-unknown-linux-musl --release # # Lopullinen image # FROM scratch COPY --from=builder /etc/passwd /etc/passwd COPY --from=builder /etc/group /etc/group WORKDIR /minimal-docker COPY --from=builder minimal-docker/target/x86_64-unknown-linux-musl/release/minimal-docker ./ USER minimal-docker:minimal-docker CMD ["/minimal-docker/minimal-docker"]</code></pre> Tämä ajetaan hakemistossa, jossa on Cargo.toml</code> ja src/main.rs</code> docker build .</code></pre> (Vihje: jos olet jo kääntänyt ohjelman paikallisesti, poista hakemisto /target ennen docker buildia. Mahdollisesti unohtunut /target kopioidaan tarpeettomasti käännösimageen. Sen koko on puolisen gigatavua ja kopio voi kestää minuutin verran.) </blockquote> Yhteenveto#</a> </h2> Tuloksena oleva Docker-image on kooltaan 8,14 MB. Tämä siis sisältää perustavaran, mutta ainoa tiedostojärjestelmän tiedosto on staattisesti linkitetty ohjelma minimal-docker</code>. (Ja /etc/passwd ja /etc/group, joiden avulla voimme ajaa ohjelman ei-root-käyttäjänä.) </blockquote> Windowsissa kontin ajo kestää noin viisi sekuntia. Jos keksit tavan tehdä vielä pienempiä kontteja, kerro ideasi esa@learners.fi</a>. Ratkaisun lähdekoodi (kolme tiedostoa) on ladattavissa https://blog.learners.fi/minimal-docker.zip</a> Lähteitä#</a> </h2> [1] Sylvain Kerkour, How to create small Docker images for Rust, https://kerkour.com/rust-small-docker-image/</a> [2] Pyry Kontio, Container for building Rust crates for MUSL target https://gitlab.com/rust_musl_docker/image</a> [3] Miksi glibc ei toimi staattisesti linkitettynä https://stackoverflow.com/questions/57476533/why-is-statically-linking-glibc-discouraged</a> [4] James Walker, How to Create Your Own Docker Base Images From “Scratch” https://www.howtogeek.com/devops/how-to-create-your-own-docker-base-images-from-scratch/</a> [5] Scracth-imagen muuttuminen sisäisesti toteutetuksi https://github.com/moby/moby/pull/8827</a> Päivitys 2024: Vaihdettu James Walkerin linkki toimivaksi. </blockquote> FaaS eli WebAssembly as a service 2021-10-25T00:00:00+00:00 Kaupalliset Edge FaaS -palvelut#</a> </h2> Sekä Fastlyllä että Cloudflarella on palveluita, joissa voi ajaa WebAssemblyä hyvin kevyesti Function-as-a-Service eli FaaS-palveluna. Kummassakin palvelussa asiakas antaa suoritettavan WebAssembly-tiedoston heille, ja he asentavat sen kymmeniin reunapalvelimiin ympäri maailmaa. Aina kun asiakkaan pyyntö triggeröi tämän palvelun tarpeen, se käynnistetään millisekunneissa lähimmässä reunapalvelimessa. Fastly#</a> </h2> Fastlyn ratkaisussa luodaan WebAssembly-moduuli Rustilla tai C:llä. https://www.fastly.com/documentation/reference/compute/</a> Moduuli käynnistetään yhden HTTP-pyynnön webbiserveriksi. Se voi lukea pyydetyn URL:n argumentteineen. Tulos palautetaan HTTP-pyynnön esittäjälle HTML-sivuna. Tämän lisäksi Palvelin voi tehdä HTTP-kyselyjä (mutta ei muuta verkkotoimintaa)</li> Saa vahvan satunnaisuluvun pyytäessään</li> Saa kellonajan</li> </ul> Tämä on kaikki, mitä WebAssembly-ohjelma voi kommunikoida isäntätietokoneen kanssa. Fastlyn toteutus on tehty Rustilla. Cloudflare workers#</a> </h2> Clouflaren ratkaisussa WebAssembly-moduuli on web-palvelin, joka saa HTTP-pyyntöjä eventteinä, jotka se käsittelee. CloudFlare käyttää runtimenä V8-JavaScriptiä. Aikaisemmin pyynnöt oli välitettävä JavaScript ohjelmatynkien kautta, mutta noin kuukausi sitten tehtiin päivitys, joka sallii WebAssemblyn saada pyynnöt suoraan ilman JavaScript-koodia. https://developers.cloudflare.com/workers/learning/how-workers-works</a> Palvelupyynnön sisällä voidaan käyttää WebSocketteja kutsujan ja palvelimen tietojenvaihtoon. Tämä on toistaiseksi kokeellinen ominaisuus. https://developers.cloudflare.com/workers/</a> Cloudflaren WebAssembly-moduuleilla on käytettävissään Key-Value -tietokanta tietojen pysyvään säilyttämiseen. Miksi WebAssembly#</a> </h2> WebAssemblyn vuoksi tarvitaan vain hyvin kevyt runtime-ympäristö. Koodi ei pääse missään vaiheessa tekemään suoraan systeemikutsuja tai edes kirjastokutsuja isäntäkoneessa. Tämä takaa täyden turvallisuuden hyökkäyksiin isäntäkoneeseen. Myöskään isäntäkoneen konekielisiä käskyjä ei suoriteta suoraan, joten käskykannan HW-bugejakaan ei päästä hyväksikäyttämään. Esim. Spectre-haavoittuvuus.</a> Kevyt runtime tarkoittaa myös, että suoritus alkaa hyvin nopeasti, jopa tuhat kertaa nopeammin kuin kontainer-tyyppisen kuorman käynnistäminen. Yhtäaikaisia suorituksia voi myös olla paljon enemmän. Päivitys 2024: Fastlyn linkki vaihdettu toimivaksi. </blockquote> Miksi WebAssembly-palvelimia 2021-10-25T00:00:00+00:00 Miksi WebAssemblyä kannattaa käyttää palvelimissa?#</a> </h2> WebAssemblyn avuksi tarvitaan vain hyvin kevyt runtime-ympäristö. Tästä on monia etuja esim. verrattuna Docker-ympäristöön. Turvallisuus#</a> </h2> Palvelin suorittaa jonkun muun omistamaa koodia. Siksi on tärkeää, että vieras koodi ei pääse missään vaiheessa tekemään suoraan systeemikutsuja tai edes kirjastokutsuja isäntäkoneessa. WebAssemblyn kaikki kommunikaatio isäntäkoneen kanssa tarkastetaan, joten WebAssembly takaa suojan hyökkäyksiin isäntäkonetta vastaan. Myöskään isäntäkoneen konekielisiä käskyjä ei suoriteta suoraan, joten käskykannan HW-bugejakaan ei päästä hyväksikäyttämään. Esim. Spectre-haavoittuvuus.</a> Nopeus#</a> </h2> Kevyt runtime tarkoittaa myös, että suoritus alkaa hyvin nopeasti, jopa tuhat kertaa nopeammin kuin kontainer-tyyppisen kuorman käynnistäminen. Yhtäaikaisia suorituksia voi myös olla paljon enemmän. Joustavuus arkkitehtuurin suhteen#</a> </h2> WebAssembly-ohjelmia voidaan ajaa täysin identtisesti esimerkiksi Intel- ja ARM-palvelimissa. Tämä mahdollistaa aina sopivan palvelimen käytön. Kubernetes ja WebAssembly#</a> </h2> WebAssembly-ohjelmia voidaan käyttää osana Kubernetes-klusteria. Rustilla kirjoitettu Krustlet Kubelet ajaa WebAssebly-podeja kontainer-podien seassa. Miksi JVM ei onnistunut virtuaalisena konekielenä?#</a> </h2> WebAssembly tavoitteet ovat hyvin samanlaiset, kuin Javan virtuaalikonekielen, JVM:n alkuperäiset tavoitteet. Write once, run everywhere. Tämä ei kuitenkaan koskaan täysin onnistunut. Java on hyvin raskas järjestelmä, ei ollenkaan yksinkertainen konekieli kuten WebAssembly. Aikaisemmin ei ole ollut korkean tason tehokasta staattista muistinvarausta tekevää kieltä kuten Rust, joten yksinkertaisempaa virtuaalikonekieltä ei ole osattu kaivata. WebAssembly onkin suorituksessa nopeampi. Paljon nopeampi. Teoriassa tietenkin esimerkiksi C-ohjelmia voi kääntää JVM:lle. Käytännössä tämä on tehty esimerkiksi niin, että C-ohjelma käännetään hieman akateemiselle MIPS-konekoodille, ja tehty JVM:llä tulkki tälle konekoodille. Tai kääntämällä C-lähdekoodi automaattisesti Javaksi ja kääntämällä tämä. Tämä kuvastaa hyvin, miten sopimaton JVM on konekoodille ja systeemiohjelmointikielille (C, C++ ja Rust). JVM:n turvallisuus ei ole aukoton. Sitä ei ole suunniteltu ajamaan ei-luotettuja vihamielisiä ohjelmia. JVM kaatui melko paljon siihen, että Oracle osti sen itselleen. Sen jälkeen, kun Google hävisi oikeudessa paljon rahaa tehtyään yhteensopivan JVM-virtuaalikoneen, tuskin kukaan uskaltaa tai viitsii tehdä enää JVM-virtuaalikoneita. (Tosin Goole huijasi kopioimalla suoraan tiedostoja, mutta se ei muuta tätä lopputulosta.) Chromessa kriittisiä haavoittuvuuksia, jotka olisi välttänyt käyttämällä Rustia 2021-09-03T00:00:00+00:00 Chromessa kriittisiä haavoittuvuuksia#</a> </h2> Google on varoittanut Chromen käyttäjiä viidestä kriittisestä turvallisuusbugista Chromessa. High — CVE-2021-30606: Use after free in Blink. Reported by Nan Wang</li> High — CVE-2021-30607: Use after free in Permissions. Reported by Weipeng Jiang</li> High — CVE-2021-30608: Use after free in Web Share. Reported by Viettel Cyber Security</li> High — CVE-2021-30609: Use after free in Sign-In. Reported by raven</li> High — CVE-2021-30610: Use after free in Extensions API. Reported by Vivaldi</li> </ul> Jokainen näistä virheistä on muistiobjektin käyttö sen vapauttamisen jälkeen. Rust havaitsee use-after-free -bugit käännösaikana#</a> </h2> Kuten muistamme, Rustissa kääntäjä takaa, ettei se päästä läpi ohjemaa, joka yrittää käyttää muistiobjekteja vapautuksen jälkeen. Esimerkiksi seuraava koodi aiheuttaa kääntäjän virheilmoituksen: fn as_str(data: &u32) -> &str { let s = format!("{}", data); &s }</code></pre> Heappiin luodun merkkijonon omistaa muuttuja s</code>, joka automaattisesti poistetaan funktion lopussa. Muuttujan poistamisen mukana poistetaan myös automaattisesti muistiobjektit, jotka se omistaa. Funktio yrittää kuitenkin palauttaa viittauksen tuohon olemattomaan merkkijonoon, mikä huomataan käännösaikana. Tarkempi selitys: format!</code> luo String</code>-tyyppisen merkkijonon heappiin, ja sen omistaa s</code>-niminen pinossa oleva muuttuja. &s</code> luo viittauksen (eli noin C:n pointteri) tuohon merkkijonoon ja yrittää palauttaa sen funktion paluuarvona. Muuttuja s</code> kuitenkin katoaa pinosta funktion lopussa, joten myös String</code>-objekti poistetaan heapista. Funktion lopussa huomataan, että objektiin on vielä viittaus, joten se on virhe. </blockquote> error[E0515]: cannot return reference to local variable 's' --> src/lib.rs:9:5 | 9 | &s | ^^ returns a reference to data owned by the current function error: aborting due to previous error For more information about this error, try 'rustc --explain E0515'. error: could not compile 'playground' To learn more, run the command again with --verbose.</code></pre> Rustin virheilmoitus on tavanomaisen perusteellinen. Rustissa dynaamisilla muistiobjekteilla on aina omistaja staattisissa pino-objekteissa. Omistaja ja vain omistaja voi vapauttaa muistiobjektin. Omistajuus loppuu muistiobjektin vapautukseen, joten kukaan ei voi yrittää käyttää tai vapauttaa uudelleen muistiobjektia, joka on jo vapautettu. Kaikki nämä turvallisuuskriittiset bugit olisi voitu välttää käyttämällä Rust-ohjelmointikieltä. Lisätietoja#</a> </h2> Forbes: Google Issues Warning For 2 Billion Chrome Users</a> The Rustnomicon: Ownership and Lifetimes</a> Sulautettu Rust 2021-08-29T00:00:00+00:00 Rust on loistava kieli sulautettuun kehityksen#</a> </h2> Yksinkertaisesti Rustia voisi kuvailla ohjelmointikieleksi, jolla voi tehdä ohjelmia sulautettuun ympäristöön samalla tarkkuudella kuin C. Mutta toisaalta kielessä on paljon korkeamman tason abstraktioita kuten iteraattorit. Ohjelmointi muistuttaa siksi tuottavuudeltaan esimerkiksi Python-ohjelmointia. Tämän lisäksi Rustilla ohjelmointi tekee ohjelmista paljon luotettavampia. Rust poistaa C:tä kiusaavat muistinvarausvirheet. Rustin merkittävin huono puoli on se, että se vaatii kieltämättä paljon osaamista. Se, että Rustilla voi ohjelmoida kaikki hienoudet tuntien on kuin pitäisi osata kaikki C:n hienoudet, Pythonin hienoudet ja sitten vielä kolmannes lisää. Mutta kyllä Rustilla voi ohjelmoida sulautettuja järjestelmiä ilman hienoimpien piirteiden käyttöä. C-ohjelmoija voi tuntea olonsa Rustin kanssa kotoisaksi ilman kovin suurta uuden opettelua. Mutta silloin kyllä vain raapaistaan pintaa. Rustissa kehittyneemmissä ominaisuuksissa ei ole kuitenkaan mitään liikaa, turhaa tai tarpeetonta. Rust on vaikeudesta huolimatta rakastetuin ohjelmointkieli. Ne, jotka sitä käytävät eivät halua enää vaihtaa toiseen ohjelmointikieleen. StackOverflowin kehittäjien kyselyssä 2021 Rust oli rakastetuin ohjelmointikieli kuudetta vuotta peräkkäin. 87% Rustin käyttäjistä ei halua siirtyä mihinkään muuhun kieleen. Rustin olennaisimmat ominaisuudet sulautetussa käytössä ovat: selkeästi tavupohjaiseen tietokoneeseen määritellyt tietotyypit (esim. i8, i16, i32, ...)</li> staattinen tyypitys</li> tyyppien päättely funktioiden sisällä niin, ettei hankalaa tyyppimäärittelyä tarvitse useinkaan merkitä, jos se on muutenkin pääteltävissä</li> rustin abstraktiot ovat yleensä "zero-cost" ne helpottavat ohjelmointia, mutta prosessorille ei niistä tule lisää tekemistä</li> kyky toimia tarvittaessa kokonaan ilman dynaamista muistinvarausta, tietyillä edellytyksillä ohjelman muistinkulutus on ennalta tunnettu</li> osajoukko standardikirjastosta (Core) antaa perustoiminnallisuuden, mutta se ei tarvitse dynaamista muistinhallintaa; se on myös helppo portata uusiin sulautettuihin prosessoreihin</li> ei tarvita "runtimeä", jossa olisi esimerkiksi roskankeruu; sulautettu Rust-ohjelma on vain joitakin kilotavuja (noin 20 kB ilman erikoistemppuiluja), kun minimi Go-ohjelma on yli puoli megatavua</li> valmis tuki kaikille tärkeimmille sulautetuille prosessoreille</li> Monisäikeisen ohjelman kykyä koskea jaettuihin muistialueisiin on automaattisesti rajoitettu turvallisiin operaatioihin jo kielen tasolla</li> helppo linkittyminen C-funktioihin (FFI)</li> olio-ohjelmoinnin sijaan täytettävissä on traitit, jotka toteuttavat osan olio-ohjelmoinnin hyvistä puolista olio-ohjelmointia tehokkaammin</li> geneeriset tyypit monistavat saman toiminnallisuuden eri tyypeille niin, että jokaisen implementointi optimoidaan erikseen (esim. tavutaulukko ja merkkijonotaulukko toteutetaan samalla lähdekoodilla, mutta kummallekin käännetään oma erikseen optimoitu implementaatio)</li> erittäin kehittynyt makrojärjestelmä mahdollistaa sovellusriippuvat tehokkaasti toteutetut abstraktiot</li> mahdollisuus käyttää asynkronisia IO-funktioita; näitä voi käyttää kuin säikeitä, mutta odotus toteutetaan tehokkaalla tilakoneella</li> mahdollisuus tehdä "unsafe"-operaatioita merkitsemällä ne; esim. täysin C:n pointtereita vastaavat operaatiot ovat käytettävissä unsafe-lohkon sisällä</li> integroitu "make" ja kirjastovarastojen hallinta nimeltä cargo</code> seuraa parhaita moderneja paketointikäytäntöjä</li> valtava määrä valmiita kirjastoja</li> </ul> Linkkejä#</a> </h2> Rust for Embedded Development</a></li> Why the developers who use Rust love it so much</a></li> </ul> Esimerkkejä Rust-makroista 2021-08-23T00:00:00+00:00 Tässä artikkelissa on joitakin esimerkkejä Rustin makroilla tehdyistä toiminnoista. Nämä kaikki makrot ovat proseduraalisia eli ne on toteutettu Rust-ohjelmalla, joka manipuloi Rust-ohjelmaa. safe_regex#</a> </h2> safe_regex::regex!()</code> kääntää säännöllisen lauseen käännösaikana tilakoneeksi (struct), jolloin käännös ei voi epäonnistua enää suorituksen aikana. Tavallisin paketti regex</code> ei tarkista säännöllisiä lauseita käännösaikana. recap#</a> </h2> recap</code> on proseduraalinen derive-makro, jolla monimutkaiselle structille voidaan luoda literaali kuvaamalla sen sisältö säännöllisellä lauseella. #[derive(Debug, Deserialize, Recap)] #[recap(regex = r#"(?x) (?P<foo>\d+) \s+ (?P<bar>true|false) \s+ (?P<baz>\S+) "#)] struct LogEntry { foo: usize, bar: bool, baz: String, } fn main() { let logs = r#"1 true hello 2 false world"#; }</code></pre> Literaalin purku tehdään käännösaikana, joten operaatio ei voi enää suoritusaikana epäonnistua. derive_more#</a> </h2> derive_more</code> sisältää perusimplementaatiosta puuttuvia yleiskäyttöisiä derivejä. Esimerkiksi structeille usein määritellään new-niminen konstruktori, vaikkei Rust sitä edellytäkään monen muun kielen tapaan. Tämä voidaan tehdä tästä cratesta löytyvällä derivellä Constructor. #[derive(Constructor)] struct MyInts(i32, i32);</code></pre> Mikä siis lisää structille tavanomaisen idiomin fn new()</code>: impl MyInts { pub fn new(__0: i32, __1: i32) -> MyInts { MyInts(__0, __1) } }</code></pre> Muita derive_more</code>:sta löytyviä derivejä ovat konversioita, joilla tupleen, structiin tai enumiin voi sijoittaa lukuja suoraan sisään (vrt. shrinkwraprs</code>)</li> yleinen formatointi tyypeille, joilta se puuttuu</li> peruslaskutoimitukset tupleille, structeille ja enumeille, jos niissä on yhteensopivat kentät ja niille voidaan tehdä ko. peruslaskutoimitus keskenään</li> IsVariant: jos enumin e</code> vaihtoehdot ovat Kissa</code> ja Koira</code>, luodaan automaattisesti funktiot e.is_kissa()</code> ja e.is_koira()</code></li> yms.</li> </ul> metered#</a> </h2> metered</code> -attribuuttimakro lisää funktiolle suoritusnopeusstatistiikan keräämisen. strum#</a> </h2> strum</code> tarjoaa makrot (esim. #[derive(EnumString)</code>) siihen, että enum-tietotyypin vaihtoehdot (esim. Red, Green, Blue) ovat käytettävissä ajon aikana myös merkkijonoina (esim. "red", "green", "blue") tarvitsematta aina luetella, että Red on sama kuin "red". Jos enumille on määritelty #[derive(EnumIter)]</code>, enumeraation kaikki variantit voidaan käydä läpi for-silmukalla for v in e.iter() {}</code>. Tämä onnistuu vain, jos yhdelläkään variantilla ei ole vaihtuvia parametreja. shrinkwraprs#</a> </h2> shrinkwraprs</code> tarjoaa makron #[derive(Shrinkwrap)</code>, jolla luodaan helposti uusi "johdettu tyyppi" (vrt. esim. "derived type" Adassa). Johdettu tyyppi toimii täsmälleen samoin kuin alkuperäinen tyyppi, mutta se ei ole yhteensopiva alkuperäisen kanssa. Esimerkiksi tällä tavalla voidaan luoda merkkijonotyyppi sähköpostiosoite. Tällöin sitä voi käyttää kuten mitä tahansa muutakin merkkijonoa, mutta siihen ei voi edes vahingossa sijoittaa tavallista merkkijonotyyppiä olevaa arvoa ilman funktiota, joka tarkistaa, että merkkijono edustaa käypää sähköpostiosoitetta. Shrinkwrap toimii siten, että uusi tyyppi "piilotetaan" structin sisään tehden siitä epäyhteensopiva muiden samojen tyyppien kanssa, mutta Shrinkwrap "nostaa" kaikki tämän tyypin operaatiot käytettäväksi struktille, joka ohjaa ne edelleen "piilotetulle" tyypille. Siksi nimi on käärimiseen viittaava shrinkwrap. Rocket www-framework#</a> </h2> Yksi Rustin WWW-sovelluspalvelin on Rocket. Rocket-sovelluksessa kerrotaan attribuuttimakroilla mitä webbiosoitetta mikäkin funktio palvelee. Nämä kerätään näkymättömissä yhteen, eikä pyyntöjen reitittäminen funktioille ole sen monimutkaisempaa. #[get("/hello/<name>/<age>")] fn hello(name: &str, age: u8) -> String { format!("Hello, {} year old named {}!", age, name) } #[launch] fn rocket() -> _ { rocket::build().mount("/", routes![hello]) }</code></pre>sqlx#</a> </h2> sqlx on liittymä tietokantoihin, jolla voi antaa suoraan SQL-kyselyjä. Normaalisti käytetään funtiota query()</code> tietojen saamiseksi. Toinen mahdollisuus antaa kyselyjä on makro query!</code>. Tämä tarkistaa SQL-kyselyn oikeellisuuden jo käännösaikana suoraan tietokannan skeemasta. let countries = sqlx::query!(" SELECT country, COUNT(*) as count FROM users GROUP BY country WHERE organization = ? ", organization ) .fetch_all(&pool) .await?;</code></pre>getset#</a> </h2> getset</code> tarjoaa derive-makron, joka luo structin kentille getterit ja setterit. Tämä tarjoittaa sitä, että jos structissa T on kenttä x, derivellä #[derive(Getters, Setters)]</code> voidaan luoda automaattisesti funktiot T.get_x()</code> ja T.set_x()</code>. Gettereitä ja settereitä tarvitaan perinnällisessä olio-ohjelmoinnissa jossa halutaan kaikkien olion operaatioiden olevan funktioita, jotka voidaan määritellä perinnässä uudelleen. Rustissa ei ole samanlaista perintää, vaan olioiden polymorfisuus hoidetaan traiteilla. On siis kyseenalaista, pitäisikö gettereitä ja settereitä käyttää Rustissa ollenkaan. core ja std -kirjastot eivät käytä proseduraalisia makroja#</a> </h2> Standardifunktiot voisivat toteuttaa erimerkiksi print!()</code> -makron proseduraalisena makrona. Lähdekoodia lukiessa kuitenkin selviää, etteivät core</code> tai std</code> -kirjastot käytä proseduraalisia makroja. print!()</code> -makro kyllä lavennetaan makrona aluksi, mutta kun on päästy core</code>-kirjaston makroon format_args!()</code>, selviää, että makron ainoa sisältö on kommentti "compiler built-in". Tämä oli pieni pettymys, koska tätä ei mainita dokumentaatiossa. Rust ilman dynaamista muistinvarausta 2021-08-10T00:00:00+00:00 Milloin dynaaminen muistinhallinta ei ole hyvä idea?#</a> </h2> Yleensä tietokoneohjelmissa on totuttu ajatukseen, että muistia on riittävästi. Jos ohjelmalta loppuu muisti, se pyytää sitä lisää käyttöjärjestelmältä. Jos käyttöjärjestelmältä loppuu muisti, se päättää ohjelman suorituksen tai kriittisessä tapauksessa jonkun muun ohjelman suorituksen. Joskus tilanne on se, että muistia ei ole paljon eikä ohjelma saa missään tapauksessa kaatua muistin loppumiseen. Voimme ajatella esimerkiksi sydämen tahdistajaa. Myös erittäin kriittisessä palvelinymäristössä on edullista, ettei muistia käytetä tarpeettomasti dynaamisesti. Jos dynaamisesti varattu muisti loppuu, pyyntö saada sitä käyttöjärjelmältä lisää voi aiheuttaa muutaman millisekunnin pysähdyksen väärässä paikassa. Puhumattakaan roskienkeruun kymmenistä tai jopa sadoista millisekunneista. Rustin normaali muistinhallinta#</a> </h2> Rust normaalisti säilyttää muistissa olevia tietoja kolmessa paikassa: heap dynaamisesti varatuille objekteille</li> pino (stack) funktioiden paikallisesti varaamalle muistille</li> staattinen data, joka varataan ja alustaan ohjelman kanssa pysymään aina samassa paikassae</li> </ul> Jos tiedämme kuinka syvälle funkiot voivat kutsua toisiaan, tiedämme pinon maksimikoon. Pinon muisti voi loppua vain, jos funkiot kutsuvat itseään (suoraan tai epäsuorasti) eli ne tekevät rekursiivisia kutsuja. Pinon ylivuoto huomataan. Rustissa ei ole roskienkeruuta. Kieli takaa, ettei dynaamisesti varattuja käyttämättömiä muistialueita voi unohtua muistiin. Rust-ohjelmointi ilman dynaamista muistia#</a> </h2> Suurimmassa osassa ohjelmointia voidaan selvitä lähes yhtä hyvin ilman dynaamisesti varattuja muistiohjekteja. Kaiken tarvittavan muistin koko on tiedettävä silloin käännösaikana. Rustin standardikirjasto on jaettu kahteen osaan core - perustoiminnallisuus ilman heappia</li> std - heappia tarvitsevat toiminnot</li> </ul> Normaalisti Rust käyttää vain std-kirjastoa, joka osanaan jakaa tarpeelliset coren toiminnot. Jos halutaan selvitä ilman heappia, ohjelmatiedostoon lisätään attribuutti #![no_std]</code></pre> Ilman standardikirjastoa dynaaminen muisti ei ole käytettävissä</li> dynaamiset standardityypit eivät ole käytettävissä (String, Vec, HashMap, ...) (mutta huomaa, että stattiset merkkijonot ja tulostuksen formatointiin vaadittavat perusfunktiot ovat coressa mukana, samoin esim. iteraattorit)</li> libc-kirjastoa ei vaadita</li> coren voi hyvin helposti portata uusille arkkitehtuureille, libstd voi sisältää koneriippuvia optimointeja</li> pinon ylivuotoa ei tarkisteta, ohjelman oletetaan hoitavan tarkastuksen itse</li> </ul> Rekursion muuttaminen iteraattoriksi#</a> </h2> Funktio, joka laskee Fibonaccin lukuja Rustilla rekursiivisesti on esimerkiksi tällainen: fn fibonacci(n: u32) -> u32 { match n { 0 => 1, 1 => 1, _ => fibonacci(n - 1) + fibonacci(n - 2), } }</code></pre> Fibonaccin luku on siis luku, joka on kahden edeltävän Fibonaccin luvun summa. 1, 1, 2, 3, 5, 8, 13, ... </blockquote> Jos tämä käännetään suoraviivaisesti konekoodiksi, jokainen kutsu aiheuttaa kaksi uutta rekursiivista kutsua lisäten pinon kokoa. Rekursiiviset funktiot voivat hyvinkin kasvattaa pinon koon hallitsemattomasti niin isoksi, että kohdekoneen muisti loppuu. Kääntäjä yleensä poistaa häntärekursion eli jos jokaisen haaran lopussa kutsutaan rekursiivisesti funktiota itseään, funktiokutsu korvataan silmukalla. Edellisestä ohjelmasta kääntäjä optimoi toisen rekusiivisen kutsun silmukaksi, mutta ohjelma on kirjoitettavissa siten, että kummatkin kutsut optimoidaan pois. Ohjelman on kuitenkin tarkoitus olla esimerkki rekursiosta, joka voi siis olla paljon monimutkaisempaa kuin tässä esimerkissä, joten tämä ei nyt ole olennaista. </blockquote> Saman funktion tekeminen iteraattorina on monimutkaisempaa, mutta sen tarvitsema tila on täysin staattinen ja käännösaikana tiedossa. Lisäksi iteraattoria voi käyttää hyvin monipuolisesti Rustin funktioilla. Rustin itertools crate voidaan ottaa käyttöön ilman featurea use_std</code> (päällä oletuksena), jolloin käytettävissä on vain toiminnot, jotka eivät tarvitse heappia. Suurin osa työkaluista on kuitenkin käytettävissä. Vain unique- ja group-tyyppiset operaatiot jäävät pois. </blockquote> struct Fib { previous: usize, current: usize, } impl Fib { fn new() -> Fib { Fib { previous: 0, // Initialize fibonacci(0) = 0 current: 1, // Initialize fibonacci(1) = 1 } } } impl Iterator for Fib { type Item = usize; fn next(&mut self) -> Option<Self::Item> { let (p, c) = (self.previous, self.current); self.previous = c; self.current = p + c; Some(c) } } fn main() { for n in Fib::new().take(10) { println!("{}", n); } println!("{}", Fib::new() .filter(|x| (x % 2) == 0) .nth(9) .unwrap()); }</code></pre> Tämä ohjelma luo iteraattorin, joka palauttaa Fibonaccin luvut järjestyksessä. Iteraattorilla on helppo tehdä paljon monimutkaisempia juttuja kuin pelkällä funktiolla tai silmukalla. Iteraattori litistää ohjelmassa usein olevan monimutkaisen hiearkian yksinkertaiseksi peräkkäiseksi käsittelyksi. Esimerkkiohjelma tulostaa ensin kymmenen ensimmäistä (take(9)</code>, ensimmäinen on nolla) fibonaccin lukua. Sitten uudella iteraattorilla valitsemme kymmenennen parillisen Fibonaccin luvun Ensin .filter() valitsee parilliset luvut eli ne, jotka ovat kahdella jaollisia, kahden jakojäännös on nolla. Sitten nth valitsee kymmenennen arvon lopputuloksesta (laskenta alkaa nollasta kuten taulukoillakin, joten kymmenes elementti on nth(9)). Lopputulos on tyyppiä Option<usize></code>, koska iteraattori voi viestittää loppumisesta option arvolla None. Tässtä tapauksessa iteraattori ei voi loppua. Luku n täytyy kuitenkin lopuksi ottaa ulos optiorakenteesta Some(n) funktiolla unwrap(). </blockquote> Iteraattorin kuluttama muistimäärä on vakio ja pieni koko läpikäynnin ajan. Yleensä se on yhtä tehokas kuin silmukkarakenne, mutta sillä on paljon helpompi tehdä operaatioiden monimutkaisia ketjutuksia. Heapless-tietotyypit#</a> </h2> Rustin kirjastoissa on mukana heapless</code>-crate joka sisältää tavallisimmat dynaamiset tietotyypit kuten Vec, String ja IndexMap sellaisina versioina, että niiden maksimikoko annetaan koodissa eikä tätä kokoa voi muuttaa. Tällöin niitä voi käyttää ilman dynaamista muistinhallintaa. Seuraava koodi on kuin tavallinen Vec-vektori, mutta vektori on pinossa, ja sen maksimikoko on kahdeksan alkiota. use heapless::Vec; let mut v: Vec<u8, 8> = Vec::new(); v.push(3).unwrap();</code></pre> Tätä kirjastoa voidaan huoletta käyttää sulautetussa järjestelemässä, jos tiedetään, ettei vektorin koko koskaan nouse yli kahdeksaan. Pääohjelma, joka ei tarvitse dynaamista muistia#</a> </h2> Useissa ohjeissa väitetään, että #[no_std]</code> ratkaisee helposti sen, ettei dynaamista muistinhallintaa käytetä. Tämä valitettavasti pätee vain kirjastoihin. Pääohjelman, joka ei tarvitse dynaamista muistinhallintaa, tekeminen vaatii paljon lisää vaivaa. Linux ei nykytilanteessa kykene helposti tuottamaan omaan käyttöön ohjelmia, jotka selviäisivät ilman dynaamista muistinhallintaa. Sen sijaan se osaa kyllä ristikääntää moneen sulautettuun ympäristöön ilman muistinhallintaa olevia ohjelmia aivan sulavasti. Tällä hetkellä #[no_std]</code> käynnistää kaikki toiminnot, jotka olettavat, että ohjelma on menossa ympäristöön, jossa ei ole ollenkaan käyttöjärjestelmää. Ohjelman on itse tarjottava poikkeustilanteiden käsittely ja käyttöjärjestelmätön ohjelman käynnistys. Nämä toiminnot ovat melko epästabiileja ja dokumentaatio ei ole täysin ajan tasalla. Panic#</a> </h3> Jos pääohjelmassa on no_std</code>, sen on itse tarjottava funktio, jota kutsutaan, jos ohjelma päätyy panic-virheeseen. use core::panic::PanicInfo; #[panic_handler] fn panic(_panic: &PanicInfo) -> ! { loop {} }</code></pre> Huutomerkki paluuarvona kertoo, ettei tämä funktio koskaan voi palata. Tämä toteutus jää yksinkertaisesti ikisilmukkaan paniikin tapahtuessa. eh_personality#</a> </h3> Toinen funktio, joka tarvitaan on nimeltään eh_personality</code>, mutta tapa, jolla sen toteutuksen yksinkertaisesti kiertää on erilainen. eh_personality</code> vapauttaa panic-tapauksessa varatun muistin mahdollisuuksien mukaan. Jos panic-funtio on ikisilmukka, tästä ei tarvitse kovin paljon välittää. Tarve kutsua eh_personality</code>-funktiota poistuu, jos projektin asetustiedostoon Cargo.toml lisätään tähän määräävät asetukset. [profile.dev] panic = "abort" [profile.release] panic = "abort"</code></pre>main()#</a> </h3> Teoriassa Rustissa pitäisi voida käyttää no_std</code> -asetusta esimerkiksi Linuxissa ajettavassa ohjelmassa. Se on kuitenkin käytännössä hyvin vaikeaa. no_std</code> -asetuksen kanssa käyttäjän on itse hoidettava myös ensimmäisen funktion kutsuminen. Teoriassa tämän pitäisi olla vaadittu vasta, jos määritellään myös no_main</code>, mutta kokeilujeni perusteella jo no_std</code> vaatii main</code>-funktion muuttamisen. Tämä pitää hoitaa käyttöjärjestelmästä riippuen suunnilleen seuraavasti: #![no_std] #![no_main] #[no_mangle] pub extern "C" fn _start() -> ! { ... }</code></pre> missä no_mangle</code> ja pub extern "C"</code> takaa, että _start</code> on linkkerille ulospäin näkyvä C-kutsukonventiolla kutsuttava funktio. Käyttöjärjestelmä tms. pitää sitten saada kutsumaan tuota funktiota. Linkkaus#</a> </h3> Ja jäljellä on vielä suurin ongelma. Rust-kääntäjässä ei ole valmiina kohdearkkitehtuuria "ei käyttöjärjestelmätukea" esim. Linux-ympäristöön. Standardi käännös-target x86_64-unknown-linux-gnu</code> yrittää yhdistää ohelmaan C-kirjastoa, mikä epäonnistuu, koska std-kirjastoa ei ole mukana. Linkkaus onnistuu, jos käännöskohde on esimerkiksi sulautettu ARM-prosessori ilman käyttöjärjestelmää. Esim. thumbv7em-none-eabihf</code> Linuxille voidaan määritellä custom käännös-target. Nykyisen käännös-targetin asetukset saa näkyviin komennolla rustc +nightly -Z unstable-options --target=x86_64-unknown-linux --print target-spec-json</code></pre> Asetukset saa yksinkertaisesti --print</code> -valitsimella. Mutta tämä on käytettävissä vain, jos on valittu -Z unstable-options</code>. Mikä taas on saatavissa tällä hetkellä vain nightly</code> releasen kääntäjässä. Lisätietoja#</a> </h2> Embedded Rust Book: A no_std Rust Environment</a></li> Minimizing Rust Binary Size</a></li> Custom Targets</a></li> lang_items (#[start])</a></li> A Freestanding Rust Binary</a></li> </ul> Rustin proseduraaliset makrot 2021-07-25T00:00:00+00:00 Rust-dokumentaation lopussa kerrotaan proseduraalisista makroista. Siinä vaiheessa useimmat meistä pitävät tauon lukemisessa. Dokumentaatio taitaakin luottaa siihen, sillä dokumentaatio on proseduraalisten makrojen kohdalta luvattoman huonoa. Dokumentaatio ei ole myöskään ajan tasalla, sillä proseduraaliset makrot ovat muuttuneet vuoden 2018 Rust-päivityksessä. Proseduraaliset makrot jäävät helposti epäselviksi pitkäksi aikaa. Mutta itse asiassa kyse on hyvin yksinkertaisesta asiasta: Käännöksessä Rust-koodi voidaan esikäsitellä Rust-funktiolla. </blockquote> Näin koodia voidaan muokata miten vain, ja makron argumenteille voidaan tehdä myös perusteellinen virhetarkistus. Tavallisemmat makrot ovat deklaratiivisia. C:ssä makroilla kerrotaan miten tietyt merkkjonot korvataan toisilla. Rustin deklaratiiviset makrot ovat kehittyneempiä, ja niillä voi käsitellä hierarkkisia tokenpuita. Mutta ne eivät ole varsinaisia ohjelmia. Token on ohjelmointikielen perusyksikkö. esimerkiksi luku 123</code> on yksi token. Sana let</code> on token. Rustin makrot saavat argumentteinaan valmiiksi tokenisoidun Rust-ohjelman, jonka rakenne on myös Rustin sääntöjen mukaan purettu valmiiksi tokenpuuksi. </blockquote> Rustin proseduraaliset makrot menevät vielä pidemmälle, ne ovat oikeita ohjelmia. Esimerkiksi cratessa hex-literal</code> on proseduraalinen makro hex!()</code>, joka muuttaa minkä tahansa heksadesimaaliliteraalin tavutaulukoksi: let bytes: [u8; 16] = hex!( "00010203 04050607" // first half "08090a0b 0c0d0e0f" // second half );</code></pre> Perus-Rustilla tämä jouduttaisiin määrittelemään let bytes: [u8; 16] = [ 0x00, 0x01, 0x02, ... ]</code></pre> eli säästetty työmäärä on huomattava ja merkintä on selkeämpi. Makro hex!()</code> yhdistää merkkijonot ja poistaa kommentit. Ohjelma näkee makron ajamisen jälkeen makron argumenttien sijaan kokonaislukutaulukon initialisoinnin heksadesimaaliarvot muutettuna kokonaislukuliteraaleiksi (proseduraalinen makro palauttaa suoraan tokeneja, ei tekstuaalista esitysmuotoa) [0, 1, 2, ...] </blockquote> Jos makron argumenteissa on virhe, proseduraalinen makro voi tehdä panic!</code> -keskeytyksen, ja se nähdään kääntäjän virheilmoituksena. Esimerkiksi jos ensimmäinen nolla jätetään pois, heksadesimaalilukuja on pariton määrä: --> src/main.rs:4:27 | 4 | let bytes: [u8; 16] = hex!( | ___________________________^ 5 | | "0010203 04050607" // first half 6 | | "08090a0b 0c0d0e0f" // second half 7 | | ); | |_____^ | = help: message: expected even number of hex characters error: aborting due to previous error</code></pre> Makro siis voi tehdä hyvinkin kehittynyttä käsittelyä argumenteilleen. Se voi tehdä mitä tahansa, koska käsittelijä on Rust-ohjelma. Proseduraalisen makron käyttö#</a> </h2> Proseduraalisen makron sisältämä crate lisätään normaalisti cargo.toml</code>-tiedostoon ja makro lisätään use</code>-lauseeseen ilman huutomerkkiä. Esimerkiksi Cargo.toml</code>: hex-literal = "0.3.3"</code></pre> Lähdekoodissa: use hex_literal::hex;</code></pre> Aikaisemmin Rust vaati proseduraalisten makrojen tuomiseksi käyttämään lisäksi erityistä macro_use</code> -merkintää jokaisessa makroja käyttävässä lähdetiedostossa: #[macro_use] extern crate hex_literal;</code></pre> Tätä ei enää tarvita Rustin versiossa 2018. Tavallinen use riittää. Ansoja#</a> </h2> Huomaa, että proseduraalisen makron on oltava ajokelpoinen ohjelma siinä vaiheessa, kun sitä käytetään. Siksi se pitää määritellä eri cratessa kuin missä sitä käytetään. Proseduraalinen makro ajaa Rust-ohjelman ilman, että ohjelman kääntäjä sitä tulee ajatelleeksi. Tämä suoritus ei ole missään suojatussa hiekkalaatikossa vaan suoraan kehityskoneessa. On mahdollista, että makro on pahantahtoinen ja tekee ei-haluttuja muutoksia kehityskoneeseen. Proseduraalisten makrojen tyypit#</a> </h2> hex!() -makro on yleisintä makrotyyppiä eli funktion näköinen makro. Rustissa nämä voivat olla deklaratiivisia (määritely erityisellä makrokielellä) tai proseduraalisia (määritelty Rustilla itsellään). Attribuuttimakrot#</a> </h3> Toinen makrotyyppi on proseduraaliset attribuuttimakrot. Nämä näyttävät koodissa tältä #[attribuuttimakron_nimi(argumentteja)] fn tee_jotain(){ // koodia }</code></pre> Tällainen attribuuttimakro saa argumentikseen koko seuraavan funktion koodin. Se on vapaa muuttamaan tätä koodia miten haluaa. Huomaa, etteivät kaikki attribuutit ole makroja. Osa niistä on sisäänrakennettuja. Esimerkiksi proseduraalisen makron esittelevä attribuutti proc_macro</code> ei ole makro. Sitä ei tarvitse ottaa käyttöön use-lauseella kuten makro pitäisi. Derive-makrot#</a> </h3> Kolmas proseduraalisen makron tyyppi on derive</code>-makro. #[derive(attribuutti)]</code></pre> Tällä voidaan luoda esimerkiksi structeille puoliautomaattisesti funktioiden/traittien toteutuksia. Proseduraalisten makrojen teko#</a> </h2> Cratessa, joka määrittelee proseduraalisia makroja tulee olla attribuutti proc-macro</code> määriteltynä: [lib] proc-macro = true</code></pre> Proseduraaliset makrot käsittelevät token-jonoja ja -puita. Koska tämä on työlästä, useimmissa tapauksissa halutaan käyttää tähän erikoistuneita kirjastoja. Crate proc-macro</code> on kääntäjän peruspaketti proseduraalisten makrojen tekemiseen ja TokenStream</code>-tyypin käsittelyyn. Proseduraalisten makrojen on kuitenkin usein käsiteltävä myös Rust-koodia tasolla, joka on työlästä pelkällä TokenStream- tyypillä. Tätä varten on kaksi cratea, syn</code> ja quote</code>. Syn</code> on Rust-kielen parseri proseduraalisten makrojen käyttöön. Quote</code> tokenisoi merkkijonossa olevaa Rust-kieltä. Koska proseduraalisen makron on palautettava tokeneita, koodi, jonka haluamme palauttaa sellaisenaan on muutettava quotella tokeneiksi. Lisäksi cratella rustc-span</code> voidaan selvittää lähdekoodin tarkka rivi parempia virheilmoituksia varten. Funktion kaltaisen proseduraalisen makron määrittely#</a> </h3> Funtion kaltaista makroa voi käyttää kaikkialla missä funktiotakin. Makron määrittelee #[proc_macro]</code> ja funktio, jonka sisään- ja ulosparametrit ovat tyyppiä TokenStream</code>. Funktion nimi on makron nimi. use quote::quote; use proc_macro::TokenStream; #[proc_macro] pub fn ping(_input: TokenStream) -> TokenStream { TokenStream::from(quote!( info!("Here we are"); )) }</code></pre> Tämä makro tekee yksinkertaisimman mahdollisen asian eli muuttaa makron ping!(); </blockquote> Makrokutsuksi info!("Here we are"); </blockquote> Makro ei lue sisään tulevaa TokenStreamia. Makro info!()</code> tulee paketista log</code>, ja se tallettaa viestin lokiin vakavuustasolla info. Proseduraalinen attribuuttimakro#</a> </h3> Attribuuttimakro määritellään melko samalla tavalla. Määrittelevä attribuutti on proc_macro_attribute</code> ja sisääntulevia TokenStreameja on kaksi, toinen metadatalle. Seuraava makro #![foo]</code> luo structin Foo{}</code>. Huomaa, että attribuutit #[]</code> koskevat seuraavaa elementtiä, esim. funktiota, jonka ne saavat sisääntulevana TokenStreaminä. Huutomerkillä lisättynä #![]</code> koskee koko yksikköä, missä se on. Muuttujia ja tyyppejä voi siis esitellä #![]</code>-notaatiolla. use proc_macro::TokenStream; use quote::quote; #[proc_macro_attribute] pub fn foo(_metadata: TokenStream, _input: TokenStream) -> TokenStream { TokenStream::from(quote!{struct Foo{}}) }</code></pre> Monimutkaisempia esimerkkejä löytyy lähteistä. Lisätietoja#</a> </h2> The Rust Reference: Procedural Macros</a> Macros in Rust: A tutorial with examples</a> The Rust Programming Language: Procedural Macros for Generating Code from Attributes</a> 6 useful Rust macros that you might not have seen before</a> Crate proc_macro</a> crates.io: syn</a> crates.io: quote</a> Crate hex-literal, lähdekoodi</a> Procedural Macros in Rust 2018</a> Python Rustilla ja Webassemblyllä 2021-07-22T00:00:00+00:00 Rustilla on tehty Python-tulkki, jonka nimi on mielikuvituksettomasti RustPython. RustPythonin pääsivu on githubissa: http://github.com/RustPython/RustPython</code></pre> Ohjelman voi kääntää itselle suoraan cargo-komennolla. > cargo install --git https://github.com/RustPython/RustPython</code></pre> Tämä asentaa ohjelman hakemistoon ¨/.local/.cargo/bin</code></pre> joten tämä hakemisto kannattaa olla bashin polussa. > rustpython Welcome to the magnificent Rust Python 0.1.2 interpreter 😱 🖖 No previous history. >>>>> 1 + 1 2 >>>>></code></pre>Webassembly -Python#</a> </h2> Ehkä mielenkiintoisempaa kuin Rustilla tehty Python on se, että Rust osaa kääntää sujuvasti Webassembly-välikielelle, jota esim. selaimet tukevat. RustPython on siis saatavissa Webassembly-versiona. Jos haluat kokeilla Webassemblyksi käännettyä RustPythonia, voit asentaa sen koneeseesi Webassembly-pakettimanagerilla wapm. Wapm on osa Wasmer-pakettia, joka on kokonainen ympäristö palvelimessa ajettavalle Webassemblylle. Wasmer on kirjoitettu Rustilla. Wasmerin asennus Linuxille onnistuu seuraavasti: > curl https://get.wasmer.io -sSfL | sh</code></pre> Kun Wasmer on asennettu, valmis RustPython-Webassembly-paketti voidaan asentaa seuraavasti: > wapm install rustpython > wapm run rustpython</code></pre> Tällä tavalla voidaan ajaa Python-ohjelmia containerin sijaan "kevysandboxissa". Webassembly takaa, ettei suoritettava ohjelma voi päästä tunkeutumaan serverin muihin toimintoihin. Tästä voi lukea lisää täältä: Can WASM become the new Docker?</a> Krustlet Brings WebAssembly to Kubernetes with a Rust-Based Kubelet</a> Zola 2021-07-16T00:00:00+00:00 Jälleen yksi osoitus Rustin sopivuudesta nopeaan komentoriviohjelmointiin on Zola. Zola on staattisten webbisivujen tekemiseen erikoistunut ohjelma. getzola.org</a> Vastaavia ohjelmia ovat Pythonilla tehty Pelican ja Golla tehty Hugo. Tämä sivusto on tehty Zolalla. Se on tehty tarkoituksella hieman nopeasti tehdyn näköiseksi, jotta se ei pakota tekemään liian hiottuja tekstejä. Zolalla saa toki tehtyä parempiakin. Sivut kirjoitetaan Markdown-tekstinä tietyn näköiseen hakemistorakenteeseen, Tiedostojen yläosaan laitetaan muutama metatieto ja sivusto generoidaan yhdellä komennolla zola build</code></pre> Ja sivusto on sekunnissa valmis. Tämä blogin luonti noin kymmenellä sivulla indeksointeineen kestää 0,4 sekuntia hitaalla tietokoneella. Jos käynnistetään kehitysserveri, sivuston editointeja voi seurata reaaliajassa osoitteessa http://localhost:1111</a> zola serve</code></pre> Julkaisua varten valmis sivusto siirretään tuotetusta hakemistosta Amazon S3 buckettiin, joka on konfiguroitu webbipalvelimeksi. aws s3 sync public s3://blog.learners.fi</code></pre> Ainoa hankaluus S3:ssa on, ettei siihen helposti saa yhdistettyä https-sertifikaatteja. Vahtoehtona voi käyttää esim. Cloudflarea.

https://www.windowslatest.com/2023/05/02/windows-11-updates-booting-with-rust-refs-instead-of-ntfs-file-system</a></p>
https://www.theregister.com/2023/04/27/microsoft_windows_rust</a></p>

Heterogeeninen lista

Miksi WebAssemblyä kannattaa käyttää palvelimissa?
Spectre-haavoittuvuus.</a></p>
Nopeus

Spectre-haavoittuvuus.</a></p>

Nopeus

Forbes: Google Issues Warning For 2 Billion Chrome Users</a></p>
The Rustnomicon: Ownership and Lifetimes</a></p>

Forbes: Google Issues Warning For 2 Billion Chrome Users</a></p>
The Rustnomicon: Ownership and Lifetimes</a></p>

Forbes: Google Issues Warning For 2 Billion Chrome Users</a></p>
The Rustnomicon: Ownership and Lifetimes</a></p>

Rust on loistava kieli sulautettuun kehityksen
`Linkkejä#</a> </h2> Rust for Embedded Development</a></li> Why the developers who use Rust love it so much</a></li> </ul>`

Rust for Embedded Development</a></li>
Why the developers who use Rust love it so much</a></li> </ul>

`#</a> </h2> Embedded Rust Book: A no_std Rust Environment</a></li> Minimizing Rust Binary Size</a></li> Custom Targets</a></li> lang_items (#[start])</a></li> A Freestanding Rust Binary</a></li> </ul>`

Webassembly -Python
Can WASM become the new Docker?</a></p>
Krustlet Brings WebAssembly to Kubernetes with a Rust-Based Kubelet</a></p>

Learners First, edistynyttä tietotekniikan koulutusta

crates.io-tunnus vaarassa

Mitä pitäisi tehdä?

CISSP on kymmenenneksi rahakkain IT-sertifikaatti USA:ssa

Rust ei ole oliokeskeinen ohjelmointikieli

Rust tulossa Windowsiin

Heterogeeninen lista Rustissa

Rust itseopiskelumateriaaleja

Minimaalinen Docker/Rust image

FaaS eli WebAssembly as a service

Miksi WebAssembly-palvelimia

Chromessa kriittisiä haavoittuvuuksia, jotka olisi välttänyt käyttämällä Rustia

Sulautettu Rust

Esimerkkejä Rust-makroista

Rust ilman dynaamista muistinvarausta

Rustin proseduraaliset makrot

Python Rustilla ja Webassemblyllä

Zola

Learners First, edistynyttä tietotekniikan koulutusta

crates.io-tunnus vaarassa

CISSP on kymmenenneksi rahakkain IT-sertifikaatti USA:ssa

Rust ei ole oliokeskeinen ohjelmointikieli

Rust tulossa Windowsiin

Heterogeeninen lista Rustissa

Rust itseopiskelumateriaaleja

Minimaalinen Docker/Rust image

FaaS eli WebAssembly as a service

Miksi WebAssembly-palvelimia

Chromessa kriittisiä haavoittuvuuksia, jotka olisi välttänyt käyttämällä Rustia

Sulautettu Rust

Esimerkkejä Rust-makroista

Rust ilman dynaamista muistinvarausta

Rustin normaali muistinhallinta#</a> </h2> Rust normaalisti säilyttää muistissa olevia tietoja kolmessa paikassa:</p> heap dynaamisesti varatuille objekteille</li> pino (stack) funktioiden paikallisesti varaamalle muistille</li>

Rustin proseduraaliset makrot

Python Rustilla ja Webassemblyllä

Zola