\chapter{Kielet}

\section{Rust}
Rust \cite{rust:lang} on Mozillan 2010 julkaisema ohjelmointikieli. Se on hyvin suorituskykyinen järjestelmätason ohjelmointikieli, muistuttaen monilta osin C- ja C++ -kieliä. Rustin tarkoituksena on säilyttää näiden vanhojen kielien suorituskyky, mutta kuitenkin tarjota samalla muun muassa vahva tyypitys ja taattu turvallinen rinnakaisajo. Lisäksi tyypilliset C-kielien muistinhallintaongelmat on pyritty ratkaisemaan käytännöillä, jotka ovat samalla tehokkaita suorituskyvyn näkökulmasta, mutta myös helppoja käyttää ohjelmoijalle.

\subsection{Muistinhallinta}

Monissa korkean tason ohjelmointikielissä, esimerkiksi JavaScriptissä, on automaattinen roskienkeräys \cite{wiki:garbagecollection} (engl. garbage collector). Se on prosessi, joka siivoaa muistista käyttämättömiä tietoja ja näin ollen vapauttaa muistia. Automaattisen roskienkeräyksen ongelma on, että se itsessään käyttää järjestelmän resursseja, ja roskienkeruu on hidasta.

Automaattiselle roskienkeruulle on aikaisemmin ollut vaihtoehtona vain manuaalinen muistinhallinta, missä ohjelmoija varaa ja vapauttaa muistia tarpeen mukaan. Tämä on taas verratuna automaattiseen roskien keruuseen melko työlästä ja virheherkkää.

Rustin yhtenä pääominaisuutena on mainostettu sen uudenlaista näkökulmaa muistinhallintaan: omistajuutta \cite{rust:ownership}. Siinä jokaisella arvolla on omistaja, ja kun omistaja menee näkyvyysalueen ulkopuolelle, niin menevät myös sen omistamat arvotkin, eli ne vapautetaan muistista. Arvojen omistajuutta voi siirtää joko pysyvästi tai väliaikaisesti lainaamalla.

\begin{code}
	\inputminted{Rust}{code/ownership.rs}
	\captionof{listing}{Omistajuus}
	\label{code:rust:ownership}
\end{code}

Koodiesimerkin \ref{code:rust:ownership} rivillä 9 tapahtuva ''name'' -arvon tulostus ei toimi, koska arvon omistajuus on siirretty funktiolle ''say\char`_hello''. Funktion suorittamisen jälkeen se poistuu näkyvyysalueelta ja kaikki sen omistamat arvot vapautetaan muistista. Näin ollen arvoa ''name'' ei ole enää olemassa, kun sitä yritetään käyttää rivillä 9. Koodi saadaan toimimaan pienellä muutoksella:

\begin{code}
	\inputminted{Rust}{code/borrow.rs}
	\captionof{listing}{Lainaus}
	\label{code:rust:borrow}
\end{code}

Koodiesimerkissä \ref{code:rust:borrow} omistajuuden siirtäminen on korvattu lainauksella. Tämä muutos pitää tehdä sekä funktion parametrien määritykseen riville 1, että funktion kutsuun riville 7. Lainauksessa arvon omistajuus säilyy nykyisellään ja lainaaja antaa itse arvon sijasta viitteen(eng. reference). Viite on osoitin, joka osoittaa samaan muistipaikkaan kuin missä alkuperäinen arvo on. Lainaaminen tehdään käyttämällä merkkiä ''\char`&''.

\clearpage

\subsection{Vahva tyypitys}
Rust on vahvasti tyypitetty kieli, mikä tarkoittaa sitä, että kaikkien arvojen tyypit pitää olla tiedossa ohjelman kokoamisen aikana. Tähän sisältyy myös funktioiden parametrit ja paluuarvot. Usein Rustin kääntäjä osaa päätellä (eng. inference) arvojen tyypit itse, varsinkin yksinkertaisissa tapauksissa:

\begin{code}
	\inputminted{Rust}{code/type-inference.rs}
	\captionof{listing}{Tyypin päättely}
	\label{code:rust:inference}
\end{code}

Niissä tapauksissa joissa tyypille voi olla useita vaihtoehtoja, tai silloin jos arvon määrityksen yhteydessä tapahtuu konversio, ohjelmoijan tulee määrittää tyyppi. Tyypin voi määrittää näin:
\begin{code}
	\inputminted{Rust}{code/type-notation.rs}
	\captionof{listing}{Tyypin merkintä}
	\label{code:rust:type-notation}
\end{code}

Valitsin arvolle ''age'' tyypin u8, koska se on pienin kokonaislukutyypeistä ja sen arvo voi olla välillä 0-255. Näin voi potentiaalisesti vähentää ohjelman muistin käyttöä. Lisäksi tyypeillä voi myös karkeasti rajata funktion parametrejen arvojen vaihteluväliä. Esimerkiksi jos on kirjoittamassa funktiota joka ottaa parametrina henkilön iän, u8 on hyvä valinta koska ihmisen ikä ei voi olla negatiivinen ja ihmiset myös harvoin elävät yli 255 vuotta.

Edellä mainittu tyyppi u8 on niin kutsuttu allekirjoittamaton kokonaisluku (eng. \textbf{u}nsigned). Allekirjoitetuissa kokonaisluvuissa (eng. signed) käytetään yksi bitti merkkaamaan sitä, onko luku positiivinen vai negatiivinen. Allekirjoittamattamattomissa  luvuissa tätä ei tehdä, joten luku voi olla hieman isompi kuin allekirjoitettu luku, mutta se ei voi olla negatiivinen.


\begin{table}[h!]
	\label{tab:table1}
	\begin{center}
		\begin{minipage}{2.5in}
			\begin{tabular}{|c|c|c|}
				\hline
				\multicolumn{3}{|c|}{\textbf{Allekirjoittamaton}} \\
				\hline
				Tyyppi & Minimi & Maksimi \\
				\hline
				u8   & 0 & $ 2^{8}-1   $\\
				u16  & 0 & $ 2^{16}-1  $\\
				u32  & 0 & $ 2^{32}-1  $\\
				u64  & 0 & $ 2^{64}-1  $\\
				u128 & 0 & $ 2^{128}-1 $\\
				\hline
			\end{tabular}
		\end{minipage}
		\begin{minipage}{2in}
			\begin{tabular}{|c|c|c|}
				\hline
				\multicolumn{3}{|c|}{\textbf{Allekirjoitettu}} \\
				\hline
				Tyyppi & Minimi & Maksimi \\
				\hline
				i8   & $ -2^{7}   $ & $ 2^{7}-1   $\\
				i16  & $ -2^{15}  $ & $ 2^{15}-1  $\\
				i32  & $ -2^{31}  $ & $ 2^{31}-1  $\\
				i64  & $ -2^{64}  $ & $ 2^{63}-1  $\\
				i128 & $ -2^{127} $ & $ 2^{127}-1 $\\
				\hline
			\end{tabular}
		\end{minipage}
	\end{center}
	\caption{Rustin kokonaislukutyypit ja niiden vaihteluvälit}
\end{table}

Toisin kuin C- ja C++ -kielissä, Rustissa on oletuksena allekirjoittamattomien kokonaislukujen ylivuoto pois päältä. Tämä tarkoittaa sitä, että jos 8-bittisen allekirjoittamattoman kokonaisluvun (u8) arvo on esimerkiksi 256, siitä tulee 0. Rustin kääntäjä siis ei anna tällaisen tapahtua vaan kääntämisen yhteydessä tulee virheviesti:

\begin{code}
	\inputminted{shell}{code/integer-overflow}
	\captionof{listing}{Allekirjoittamattoman kokonaisluvun ylivuoto}
	\label{code:rust:integer-overflow}
\end{code}

\subsection{Muuttumaton data}
Rustissa kaikki arvot ovat oletuksena muuttumattomia (engl.\ immutable). Jos muuttumattoman datan sijasta tarvitsee muuttujia (engl. mutable), voi käyttää avainsanaa ''mut'', esimerkiksi \mintinline{Rust}{let mut name = "Marko"}. Myös lainaukset suoritetaan oletuksena muuttumattomasti ja muutettavan lainauksen voi tehdä samalla avainsanalla, esimerkiksi \mintinline{Rust}{say_hello(&mut name)}

Yleinen konsensus  ohjelmoinnin maailmassa on se, että kaikki arvot, joita ei tarvitse muuttaa, pitäisi nimenomaan määrittää muuttumattomana. Tämä on tuttua kaikille, jotka ovat tutustuneet funktionaalisiin ohjelmointikieliin. Muuttumaton data on myös todella tärkeää rinnakkaisajossa, missä useampi prosessi suorittaa samoja funktioita ja käsittelee samoja arvoja samaan aikaan.

\subsection{Luotettavuus}
Rustia kehitettäessä on aina ollut tavoitteena luotettavuus. Tämä tarkoittaa sitä, että ohjelman virheet huomataan jo koontivaiheessa, eikä vasta suorituksen aikana ohjelman tietyssä tilassa. Tämän mahdollistavat edellä mainitut omistajuusmalli ja vahva tyypitys. Omistajuusmalli varmistaa sen, että ohjelmoija joutuu koodia kirjoittaessaan miettimään arvojen eliniän, joka tekee muistivuodoista harvinaisia. Vahva tyypitys varmistaa taas sen, että data on kaikkialla ohjelmassa yhteensopivaa.

Myös Rustin kääntäjään on panostettu paljon, ja virheiden sattuessa se on todella hyvä työkalu ohjelmoijalle. Se alleviivaa ongelmakohdat ja selittää lyhyesti, mistä ongelma johtuu. Jossain tapauksissa kääntäjä jopa antaa pieniä koodin pätkiä mistä voi olla apua ongelman ratkaisemisessa.

\subsection{Paketinhallinta}
Rustin paketinhallinta on toteutettu Cargo-nimisellä ohjelmalla. Sitä voi käyttää koko ohjelmiston elinkaaren ajan aina projektin luomisesta sen julkaisemiseen. Cargon käsittelemiä paketteja kutsutaan laatikoiksi (eng. crate), jotka julkaistaan crates.io \cite{rust:cratesio} pakettirekisterissä. Laatikot voivat myös olla riippuvaisia toisista laatikoista.

Laatikon tiedot ja riippuvuudet määritetään Cargo.toml tiedostossa.

\begin{code}
	\inputminted{TOML}{code/Cargo.toml}
	\captionof{listing}{Projektin palvelinpuolen Cargo.toml}
	\label{code:rust:cargo-toml}
\end{code}

Cargoon on saatavilla myös useita liitännäisiä, esimerkiksi cargo-watch, joka suorittaa halutun toiminnon aina kun projektin sisällä tapahtuu muutoksia ja tässäkin projektissa käytetty cargo-web, joka helpottaa WebAssembly-ohjelmien kehittämistä.

\subsection{Dokumentaatio ja yhteisö}
Rust on tunnettu todella laajasta dokumentaatiostaan ja vahvasta yhteisöstään. Molemmista on paljon apua varsinkin aloittejioille.

Aloitin itsekin opiskelemaan Rustia vain hieman ennen tämän opinnäytetyön alkua ja vahvasta yhteisöstä oli monesti apua.

\section{WebAssembly}
WebAssembly \cite{webassembly:home} on kehitteillä oleva asiakaspuolen ohjelmointikieli. Sitä on suunniteltu JavaScriptin seuraajaksi ja sen suurimpana etuna JavaScriptiin verrattuna on huomattavasti matalamman tason esitysmuoto, minkä ansiosta se on suorituskykyisempi.

Kehittäjän ei ole tarkoitus kirjoittaa WebAssemblya itse, vaan käyttää työkaluja, joilla olemassa olevia ohjelmointikieliä voi kääntää WebAssemblyksi. Rust on tästä hyvä esimerkki, sillä WebAssembly on yksi sen kääntäjän natiiveista ''targeteista'', samalla tavalla kuin vaikka x86-prosessorit.

WebAssembly on siis ensisijaisesti binääriformaatti, mutta sen voi muuntaa myös tekstiformaatiksi, jonka nimi on WebAssembly text \cite{webassembly:text}. WebAssembly text käyttää S-lauseita, joten se muistuttaa syntaxiltaan hyvin paljon Lisp-ohjelmointikieltä.

\begin{code}
	\inputminted{Lisp}{code/plus.wat}
	\captionof{listing}{Lukujen yhteenlasku WebAssembly text -formaatissa}
	\label{code:webassembly:plus}
\end{code}
\clearpage

\begin{code}
	\inputminted{Rust}{code/plus.rs}
	\captionof{listing}{Lukujen yhteenlasku Rustilla}
	\label{code:rust:plus}
\end{code}
