Moniajoisuus taustajärjestelmäohjelmissa : Go-, Java- ja JavaScript-ohjelmien vertailua

(1)

Heli Poikela

MONIAJOISUUS TAUSTAJÄRJESTELMÄOHJELMISSA

Go-, Java- ja JavaScript-ohjelmien vertailua

Informaatioteknologian ja viestinnän tiedekunta Kandidaattitutkielma Tammikuu 2021

(2)

TIIVISTELMÄ

Heli Poikela: Moniajoisuus taustajärjestelmäohjelmissa – Go-, Java- ja JavaScript-ohjelmien vertailua

Kandidaattitutkielma Tampereen yliopisto

Tietojenkäsittelytieteiden tutkinto-ohjelma Tammikuu 2021

Tämä tutkielma on kirjallisuuskatsaus taustajärjestelmän (backend tai server-side) ohjelmointikielten kyvystä toteuttaa moniajoisia ohjelmia. Moniajoisuus on erittäin tärkeä osatekijä siinä, että nykypäivän verkkosivut ja sovellukset pystyvät tarjoamaan hyvän käyttäjäkokemuksen kai- kille käyttäjilleen. Lyhyesti moniajoisuus tarkoittaa sitä, että tietokoneen monet prosessorit suo- rittavat useaa prosessia tai saman prosessin eri osia samanaikaisesti.

Käsittelen tutkielmassani seuraavia ohjelmointikieliä: Googlen Golang, Java sekä JavaScript.

Googlen Golang:in, josta käytetään lyhennettä Go, kehitysprosessissa moniajoisuus on ollut tär- keä osatekijä alusta lähtien, toisin kuin Javan tai JavaScriptin kohdalla. Tästä syystä on odotetta- vaa, että Go-ohjelmointikielellä on verrattain helppoa ja yksinkertaista tehdä moniajoinen ohjelma. Go on nuori ohjelmointikieli, joten siinä on vielä selkeitä heikkouksia. Merkittävimmät kehityskohteet Go-ohjelmointikielessä ovat koodin käännösvaiheen toteutus ja käännetyn koodin tallennus.

Tutkielmani tavoitteena on helpottaa ohjelmointikielen valitsemista, kun halutaan toteuttaa moniajoinen ohjelma. Go on lähes aina hyvä valinta. Go-ohjelmointikielen vahvuudet ovat helpossa syntaksissa, kevyissä säikeissä ja ison jaetun koodipohjan käsittelyssä. Java suoriutuu Go:ta paremmin silloin, kun ohjelman on toteutettava paljon laskentaa. JavaScript-ohjelma ei pärjännyt moniajosten ohjelmien vertailun millään osa-alueella Go- ja Java-ohjelmille.

Avainsanat: moniajoisuus, Google Golang, Java, JavaScript, samanaikaisuus, rinnakkaisuus Tämän julkaisun alkuperäisyys on tarkastettu Turnitin OriginalityCheck –ohjelmalla.

(3)

Sisällysluettelo

1 Johdanto ... 1

2 Moniajoisuuden määrittelyä ... 2

2.1 Moniajoisuuden käsitteistöä 2

2.2 Moniajoisuus ohjelmoinnissa 5

3 Google Go ... 6

3.1 Go:n historia ja kehittyminen 6

3.2 Go ja moniajoisuus 7

4 Muut ohjelmointikielet ... 8

4.1 JavaScript 8

4.2 Java 9

5 Moniajoisten ohjelmien vertailua ... 9 5.1 Aiemmissa tutkimuksissa käytettyjä tutkimusmenetelmiä 9 5.2 Moniajoisten ohjelmien vertailussa käytettäviä mittareita 10

5.3 Go vs. Java vs. JavaScript 10

6 Tutkimuksen arviointi ja yhteenveto ... 14 Lähdeluettelo ... 16

(4)

1 Johdanto

Tutkielmani on kirjallisuuskatsaus moniajoisuudesta, joka on tärkeä osatekijä, kun puhutaan verkkosivustojen tai erilaisten sovellusten tehokkaasta toimimisesta. Digitalisaation myötä yhteiskunta toimii yhä enemmän verkkoympäristössä. Esimerkiksi Kaupan Liiton (2021) tiedotteessa digiostamisen kasvusta kerrotaan, kuinka vuonna 2020 verkkoa käyt- tävistä suomalaisista 73 prosenttia oli tehnyt verkko-ostoksia viimeisen kolmen kuukau- den aikana, kun vastaava luku vuodelta 2019 oli 65 prosenttia. Verkkosivustot ja -kaupat ovat kovassa käytössä, samoin kuin erilaiset pelialustat. Moniajoisuus on tärkeää, kun pyritään tarjoamaan verkkosivujen ja sovellusten lukuisille käyttäjälle hyvä käyttäjäko- kemus.

Moniajoisuus (multiprocessing), jonka määrittelen tarkemmin kohdassa 3.1, tarkoittaa lyhyesti sitä, että prosessori suorittaa useaa prosessia tai saman prosessin eri osia samanaikaisesti. Moniajoisuuteen liittyvä käsitteistö on englanniksi laaja ja monimutkai- nen, minkä takia suomeksi käsitteen määritteleminen ei ole täysin yksiselitteistä.

Tutkielmassani keskityn taustajärjestelmien (backend tai server-side) ohjelmointi- kieliin. Tutkimuskysymykseni on: Kuinka hyviä moniajoisia ohjelmia eri ohjelmointikie- lillä voi tehdä? Ensimmäisenä käsittelen Googlen vuonna 2009 julkaisemaa Golang-oh- jelmointikieltä (Meyerson, 2014). Golang:sta käytetään lyhennettä Go ja se on suunniteltu juuri moniajoisuutta ajatellen. Go:n kehittäjien tavoitteena on kehittää kieli, jolla pystyy käsittelemään Googlen tapaista valtavaa jaettua koodipohjaa (Meyerson, 2014).

Go:n lisäksi tutustun myös Javan ja JavaScriptin moniajoisuuteen. Näihin ohjelmoin- tikieliin on rakennettu moniajoisuutta tukevia elementtejä vuosien varrella kielten varsi- naisen julkaisun jälkeen. Tästä näkökulmasta on mielenkiintoista verrata niitä Go-ohjelmointikieleen, joka on rakennettu alun alkujaan tukemaan samanaikaisuutta (concurrency). Tutkielman tavoitteena on helpottaa sopivan ohjelmointikielen valintaa moniajoisen ohjelman kirjoittamiseen.

Tutkielmani rakentuu kolmen aiemman tutkimuksen pohjalle: Uedan ja Oharan (2017) tekemä suorituskyvyn vertailu staattisesti ja dynaamisesti kääntyvien ohjelmointikielten välillä, Togashin ja Klyuevin (2014) tekemä tutkimus samanaikaisesta (concurrency) ohjelmoinnista Go:lla ja Javalla, ja Abhinavin ja muiden (2020) tekemä analyysi Go:n ja Javan samanaikaisuudesta (concurrency). Näihin kolmeen tutkimukseen nojautuu kohdassa 5.3 tekemäni vertailu Go:n, Javan ja JavaScriptin välillä.

Oma oletukseni tutkielmaa aloittaessani oli, että Google Go:lla pystytään tekemään muita kieliä paremmin moniajoisia ohjelmia, koska moniajoisuus on ollut hyvin tärkeä osatekijä Go:n koko kehitysprosessin ajan. Tämän takia Go on tutkielmani keskipisteessä.

Oletukseni osoittautui hyväksi, mutta Go on vielä nuori ohjelmointikieli, jossa on selkeitä

(5)

kehityskohteita. Java-ohjelma suoriutuu muita kieliä paremmin tehtävistä, joissa ohjelman on suoritettava paljon laskentaa. Go:n vahvuus on taas ison koodipohjan käsittelyssä, helpossa syntaksissa ja kevyissä säikeissä. JavaScript ei pärjää vertailussa Go:lle tai Ja- valle.

Tutkielmani on kirjallisuuskatsaus, joten se perustuu aiempaan tutkimukseen ja sen tutkimiseen (Salminen, 2011). Tekemäni kirjallisuuskatsaus on kuvailevan ja systemaattisen kirjallisuuskatsauksen välimuoto. Kuvailevassa kirjallisuuskatsauksessa ei ole tarkkoja sääntöjä, kun taas systemaattisessa kirjallisuuskatsauksessa noudatetaan ennalta määriteltyjä metodeja ja rajauksia (Salminen, 2011). Omassa tiedonhakuprosessissani en noudattanut tarkkoja sääntöjä, mutta valintaprosessissa seuloin lähteitä muun muassa vuosiluvun perusteella. Tutkielmani kaikki lähteet on julkaistu aikaisintaan vuonna 2010.

Tietokannat, joihin tein hakuja, olivat Andor, IEEE ja ACM-kirjasto.

Tästä eteenpäin tutkielmani etenee seuraavalla tavalla: Ensin luvussa 2 määrittelen moniajoisuuden käsitteen ja perehdyn moniajoiseen ohjelmointiin. Tämän jälkeen luvussa 3 käsittelen Go:n historiaa, kehittymistä ja sillä kirjoitettujen ohjelmien moniajoisuutta. Luku 4 käsittelee Javan ja JavaScriptin moniajoisuutta. Luvussa 5 vertailen Go- ohjelman moniajoisuutta Java- ja JavaScript-ohjelmien moniajoisuuteen. Esittelen tässä luvussa myös lyhyesti kolmessa päälähteessä käytettyjä tutkimusmenetelmiä ja -mittareita. Luku 6 kattaa tutkimukseni arvioinnin, tekemieni valintojen perustelut ja yhteenve- don. Siinä käyn tiiviisti läpi sen, mitä olen luvuissa 2–5 saanut selville sekä esitän vielä perustellun vastauksen tutkimuskysymykseen.

2 Moniajoisuuden määrittelyä

Tässä luvussa käsittelen moniajoisuuden käsitettä ohjelmoinnissa. Lisäksi avaan moniajoisuuteen liittyviä ja siihen rinnasteisia käsitteitä. Lopuksi totean, miksi ohjelman moniajoisuus on hyödyllistä. Englanninkielisten käsitteiden kääntämiseen olen käyttänyt MOT-kielikoneen ATK-sanakirjaa (MOT, 2021). Tästä huolimatta käännetyt käsitteet on hyvä pitää tämän tutkielman kontekstissa, sillä moniajoisuuden käsitteille ei ole suomeksi selkeää yleispätevää linjausta.

2.1 Moniajoisuuden käsitteistöä

Englanninkielisiä moniajoisuuteen viittaavia käsitteitä on valtavasti ja niiden ymmär- täminen ja erottaminen on olennaista asian ymmärtämisen kannalta. Kaikkien näiden kä- sitteiden kääntäminen suomeksi on myös monimutkaista. Esimerkiksi molempien käsit- teiden, multiprocessing ja multiprogramming, suomennos on moniajoisuus (MOT, 2021), vaikka englanniksi käsitteet tarkoittavat eri asioita. Kun myöhemmissä luvuissa käytän käsitettä moniajoisuus, viitataan sillä englanninkieliseen termiin multiprocessing, Muita olennaisia käsitteitä ovat monisäikeisyys (multithreading), samanaikaisuus (concurrency) ja rinnakkaisuus (parallelism).

(6)

Tutkielmani avainkäsite on moniajoisuus (multiprocessing). Ebbersin ja muiden (2011, 96). mukaan moniajoisuudessa olennaista on, että tietokoneessa on monta prosessoria ja ohjelma käyttää niitä samanaikaisesti. Moniajoinen ohjelma siis vaatii, että tietokoneessa on useita ohjelmansuoritusyksiköitä joko useita prosessoreja tai yksi mo- niydinprosessori. Tässä tutkielmassa käytän esimerkkinä tilannetta, jossa tietokoneessa on monta prosessoria.

Ebbers ja muut (2011, 96) viittaavat moniajoisuudella (multiprocessing) joko eri ohjelmien tai saman ohjelman eri osien samanaikaiseen suorittamiseen useassa prosessorissa. Näillä prosessoreilla on käytössä yhteisiä laitteistoresursseja, kuten sisäinen muisti ja ulkoisen kovalevyn muisti (Ebbers et al., 2011, 96). Britannica Academic (2008) puolestaan korostaa, että moniajoisuudessa (multiprocessing) on tyypillistä saman prosessin eri osien suorittaminen samanaikaisesti useassa eri mikroprosessorissa.

Kuvan 1 vasemmanpuoleisessa kaaviossa kuvataan moniajoisen (multiprocessing) ohjelman toimintaa. Kaaviosta nähdään, kuinka yksi prosessori suorittaa yhtä prosessia kerrallaan, mutta monta prosessoria toimii samanaikaisesti ja ne kaikki pystyvät hyödyn- tämään koneen sisäistä sekä mahdollista ulkoista muistia (GeeksforGeeks, 2021a).

Toisaalta Ebbers ja muut (2011, 96) määrittelevät moniajoisuuden (multiprogramming) siten, että käyttöjärjestelmä suorittaa useaa prosessia yhtä aikaa. Tämä ei ole yk- sittäisen ohjelman vaan käyttöjärjestelmän ominaisuus (Ebbers et al., 2011, 96; Geeksfor- Geeks, 2021a).

GeeksforGeeks-sivusto (2021a) määrittelee, että englanninkielinen termi multiprogramming tarkoittaa usean ohjelman suorittamista samassa prosessorissa lomittain keskenään. Tämä on esitetty kuvan 1 oikeanpuoleisessa kaaviossa. Käytännössä prosessori alkaa suorittamaan prosessia 1. Kun tämä siirtyy esimerkiksi I/O-tehtävään eli prosessi kommunikoi ulkomaailman kanssa, prosessori asettaa prosessin 1 odotustilaan ja alkaa suorittamaan prosessia 2. Kun prosessi 1 on valmis palaamaan prosessoriin, siirtyy

Kuva 1. Vasemmalla kaavio multiprocessing-ohjelmasta ja oikealla kaavio multiprogramming- ohjelmasta (muokattu lähteestä (GeeksforGeeks, 2021a)).

(7)

prosessi 2 odotustilaan, ja prosessin 1 suorittaminen jatkuu. Tämä prosessien lomittain suorittaminen jatkuu, kunnes kaikki prosessit on suoritettu. Aina kun yksi prosessi val- mistuu, uusi tulee sen tilalle. Näin vältetään pitkät ajanjaksot, jolloin prosessori ei suorita mitään prosessia. (GeeksforGeeks, 2021a)

Edellä kuvattu havainnollistaa hyvin sitä, kuinka suomennoksella moniajoisuus ei ole yhtä yksiselitteistä määritelmää. Olennaista on myös ymmärtää, että käsitteiden määritel- mät ovat päällekkäisiä. Esimerkiksi seuraavaksi määrittelen käsitteen monisäikeisyys (multithreading), joka on yksi mahdollinen tapa, jolla ohjelma voi käyttää yksittäistä prosessoria. Moniajoinen ohjelma voi siis olla myös monisäikeinen.

Monisäikeisyys (multithreading) tarkoittaa sitä, että yksi ohjelma on jaettu segment- teihin ja nämä niin kutsutut säikeet (threads) pystytään ajamaan samanaikaisesti yhdessä prosessorissa. Kuvassa 2 kuvataan, kuinka monisäikeinen ohjelma toimii. Käytännössä, kun prosessori alkaa suorittamaan segmenttiä 1, luodaan säie s1. Tämän säikeen suori- tuksen aikana prosessin muut segmentit kykenevät edelleen vuorovaikuttamaan ulkomaailman kanssa. Jos segmenttiä 2 halutaan alkaa suorittaa, luodaan säie s2, joka alkaa toteuttaa segmenttiä 2 häiritsemättä muuta prosessia. (GeeksforGeeks, 2021a)

Samanaikaisuus (concurrency) sekä rinnakkaisuus (parallelism) ovat tärkeitä moniajoisuutta selittäviä käsitteitä. Myös niiden määritelmät ovat osittain päällekkäiset: Sa- manaikaisuus tarkoittaa sitä, että useaa prosessia suoritetaan samanaikaisesti. Rinnak- kaisuus puolestaan kuvaa sitä, kuinka yksi prosessi jaetaan pienempiin osiin ja nämä osat suoritetaan näennäisesti samaan aikaan (GeeksforGeeks, 2021b). Näin ollen voidaan sa- noa, että moniajoisuus, jossa hyödynnetään useaa prosessoria, on samanaikaista, kun taas esimerkiksi monisäikeisyys on rinnakkaista.

Kuva 2. Kaavio monisäikeisestä ohjelmasta (muokattu läh- teestä (GeeksforGeeks, 2021a)).

(8)

Kuvan 3 käsitekartassa esitän visuaalisesti edellä esitettyjen fyysisen tason ja ohjelman tason eri elementtien yhteyksiä toisiinsa. Kuvasta on muun muassa nähtävissä, että laitteisto sisältää useita prosessoreja mahdollistaen moniajoisuuden (multiprocessing), ja että ohjelmaa suoritetaan useassa säikeessä samanaikaisesti, mikä viittaa monisäikeisyy- teen.

2.2 Moniajoisuus ohjelmoinnissa

Moniajoisuus ohjelmoinnissa on nostanut profiiliaan viime vuosina. Yhteiskunnan vah- van digitalisaation myötä yritykset panostavat entistä enemmän nettisivuihin ja verkko- kauppoihin. Tämä vaatii selaimelta sekä mahdollisilta sovelluksilta paljon. Käyttäjiä on valtavasti, ja jotta heidän käyttökokemuksensa olisi positiivinen, verkkosivun tai sovelluksen on toimittava sujuvasti.

Moniajoinen ohjelma on usein ratkaisu edellä mainittuihin vaatimuksiin. Edellisessä kohdassa 2.1 esitellyt käsitteet samanaikaisuus ja rinnakkaisuus kuvaavat sitä, mitä kaik- kea moniajoisuus mahdollistaa. Dveckon (2021) mukaan samanaikaisuuden tai rinnakkaisuuden ohjelmointi kannattaa, vaikka sellainen ohjelmointiprosessi on työläs, sillä moniajoinen ohjelma tarjoaa lukuisia mahdollisuuksia ja etuja.

Moniajoisten ohjelmien merkittävimpiä etuja on se, että ohjelmat käyttävät tietokoneen resurssit mahdollisimman tehokkaasti. Moniajoinen ohjelma pystyy hyödyntämään tietokoneiden monia prosessoreja tai moniydinprosessorin eri ytimiä samanaikaisesti.

Kuva 3. Käsitekartta, jossa kuvaan fyysisen tason ja ohjelman tason yhteyksiä.

(9)

Näin ohjelma onnistuu käyttämään tietokoneen kapasiteettia tehokkaasti. Yksittäisen ohjelman tasolla moniajoisen ohjelman etuja ovat sen nopeus ja kyky käsitellä suuria data- määriä lyhyemmässä ajassa kuin ilman moniajoa toteutettu ohjelma (Britannica Acade- mic, 2008). Moniajon tuoma nopeus on ilmeistä: jos ohjelma suorittaa useampaa prosessia tai ohjelman osaa yhtä aikaa, on se nopeampi, kuin ohjelma, joka tekee prosessit yk- sitellen peräjälkeen. Vastaavasti, jos ohjelma pystyy hyödyntämään useaa prosessoria, sen on mahdollista käsitellä isompaa datamäärää, kuin tilanteessa, jossa ohjelmalla on käytettävissään vain yksi prosessori. Sama pätee myös säikeisiin: usea rinnakkainen säie mahdollistaa suuremman datamäärän käsittelyn.

3 Google Go

Tässä luvussa käsitellään Googlen kehittämää ohjelmointikieltä nimeltä Golang, josta käytetään lyhennettä Go. Ensin käsittelen hieman kielen historiaa ja kehittymistä ja sitten keskityn Go:lla tehdyn ohjelman moniajoisuuteen ja sen toteutukseen.

3.1 Go:n historia ja kehittyminen

Go:n kehittäminen alkoi 2000-luvun puolivälin jälkeen. Alkujaan se oli Googlen insinöö- rien sivuprojekti, mutta kehitystyö muuttui hiljattain tavoitteellisemmaksi ja vuoden 2009 marraskuussa julkaistiin Go:n avoin lähdekoodi. (Meyerson, 2014)

Maaliskuussa 2012 julkaistiin Go versio 1 eli Go 1. Tämä julkaisu sisälsi kielen mää- rittelyn sekä peruskirjastoja (core libraries), jotka muodostavat perustan luotettavaan ohjelmointiin Go:lla (Gerrand, 2010). Go 1:stä pidetään kielen merkittävimpänä yksittäi- senä julkaisuna (Meyerson, 2014). Tämän jälkeen on julkaistu lukuisia päivittyneitä ver- sioita Go 1:stä, viimeisimpänä Go 1.16 helmikuussa 2021 (The Go blog, 2021).

Syksyllä 2018 Googlen Go-tiimi esitteli ensimmäistä kertaa suunnitelman Go 2:sen kehittämisestä. Go 1 oli pienen tiimin toteuttama ja käyttäjien palautteella on ollut vain marginaalinen osuus kielen kehittämisessä. Uudessa versiossa, Go 2, tavoitteena on tehdä enemmän yhteistyötä Go-yhteisön (Go community) eli Go:n käyttäjien kanssa. (Grie- semer, 2018)

Go on edelleen kehitysvaiheessa oleva nuori kieli. Sitä päivitetään usein ja sillä on potentiaalia nousta yhdeksi johtavista ohjelmointikielistä (Togashi & Klyuev, 2014).

Togashin ja Klyuevin (2014) julkaisun jälkeen Go on vallannut alaa ja sitä hyödynnetään jo useissa tunnetuissa sovelluksissa, esimerkkeinä Netflix, Dropbox, Twitch ja tietysti Google itse (Wikipedia, 2021).

Go on staattisesti kirjoitettava kieli samoin kuin C ja C++, joita pidetään Go:n edel- täjinä (Ueda & Ohara, 2017). Ennen Go:ta, Google hyödynsi muun muassa Javaa ja C++- kieltä, mikä selittää esimerkiksi sen, että Go:n syntaksi on hyvin samanlainen kuin C- ja C++-kielissä (Meyerson, 2014; Ueda & Ohara, 2017). Ueda ja Ohara (2017) kertovat Go- koodin olevan hyvin yhteensopiva C- ja C++-binäärikoodin kanssa, minkä ansiosta Go-

(10)

ohjelmassa on mahdollista hyödyntää muun muassa C- ja C++-kirjastoja tai -funktioita.

Go:n ja C:n tai C++:n erot johtuvat erilaisista käyttötarkoituksista. Esimerkiksi seuraa- vassa kohdassa 3.2 käsiteltävät sisäänrakennetut samanaikaisuuselementit ovat Go:ssa huomattavasti olennaisempia kuin C-kielissä (Ueda & Ohara, 2017).

3.2 Go ja moniajoisuus

Go kehitettiin, kun tarvittiin ohjelmointikieli, jolla pystytään käsittelemään valtavia mää- riä koodia. Googlen insinööri Andrew Gerrand kuvailee Googlea yhdeksi valtavaksi koo- dipohjaksi, jota muokkaavat ja käsittelevät useat eri henkilöt, ja Go:ta ratkaisuksi muiden kielten puutteisiin tällaisessa toimintaympäristössä (Meyerson, 2014). Toinen tärkeä te- kijä Go:n kehittämisessä oli moniajoisuus. Gerrandin mukaan moniajoisuus on aina mai- nittava, kun puhutaan Go:sta (Gerrand, 2013).

Moniajoisuutta toteutetaan Go-ohjelmissa kahden peruselementin avulla: gorutiini ja kanava. Gorutiini (goroutine) on kevyt säie (thread, ks. 3.1), jota hallitsee Go runtime - pakkaus. Gorutiinin etu verrattuna muista kielistä tuttuun säikeeseen on se, että se on kevyempi ja näin ollen ”halvempi” tehdä. Tämä mahdollistaa yksinkertaisemman koodin kirjoittamisen, sillä ohjelmoijan ei tarvitse miettiä kovin tarkasti, kuinka monta gorutiinia ohjelma luo ja tuhoaa. (Meyerson, 2014)

Gorutiinien hallinnoinnin mahdollistava Go runtime on pakkaus, joka sisältää Go:n ajon aikana tarvittavia funktioita mukaan lukien gorutiinien ajoa koskevat funktiot. Go runtime -pakkauksessa on muun muassa Gosched()-funktio, joka aikatauluttaa gorutiinit siten, että ne suoritetaan automaattisesti ja järjestelmällisesti. Toinen maininnan arvoinen funktio on Goexit(). Tämä funktio päättää gorutiinin häiritsemättä muuta ohjelmaa, mi- käli kyseinen säie on jumiutunut ja kutsuu Goexit()-funktiota. Näin muu ohjelma pysty- tään suorittamaan loppuun asti yksittäisestä virheestä huolimatta. (Go, 2021)

Go:n kanavaa (channel) voidaan kuvata putkena, jota pitkin voidaan lähettää ja vas- taanottaa arvoja (A Tour of Go, 2021). Kommunikointia kanavassa voi verrata CSP-tyyp- piseen (Communicating sequential processes) kommunikointiin (Tang, 2010). Roscoen

& Daviesin (2011) mukaan CSP on matemaattinen notaatio vuorovaikutusmallien kuvaa- mista varten. CSP-tapahtuma on siis abstrakti tiedonsiirto, joka koskee määriteltyjä pro- sesseja (Roscoe & Davies, 2011). Go:n kanavat ovat siis kommunikointikanavia gorutiinien välillä.

Yksi tärkeä Googlen Go-tiimin tavoite on ollut luoda helposti jäsenneltävä kieli, jolla ohjelmoiminen on hyvin suoraviivaista (Meyerson, 2014). Tang (2010) toteaa, että moniajoisten ohjelmien tekeminen on helppoa ja tehokasta Go:lla juuri ohjelmoinnin suora- viivaisuuden takia. Go:n yksinkertainen syntaksi mahdollistaa sen, että ohjelmoija voi keskittyä toimivan ohjelman kirjoittamiseen, eikä ohjelman rakenteeseen yhtä paljon kuin esimerkiksi Java-ohjelman kohdalla (Abhinav et al., 2020; Meyerson, 2014). Go:ssa on

(11)

Gofmt()-työkalu, joka formatoi kirjoitetun koodin tietyllä standardilla tavalla, mikä mahdollistaa sen, että eri ohjelmoijien tekemä lähdekoodi näyttää yhtenäiseltä (Meyerson, 2014).

4 Muut ohjelmointikielet

Tässä luvussa esittelen kaksi muuta taustajärjestelmien ohjelmoinnissa käytettävää ohjel- mointikieltä: JavaScript ja Java. Lyhyen historian lisäksi paneudun näillä kielillä kirjoitettujen ohjelmien moniajoisuuteen ja sen toteutukseen.

4.1 JavaScript

JavaScript kehitettiin alun perin komento- eli skriptikieleksi selainten asiakassovellusten (frontend tai client-side) kirjoittamiseen (Ueda & Ohara, 2017). Myöhemmin kieltä on alettu hyödyntämään laajemmin online-ympäristöissä, muun muassa juuri taustasovelluk- sissa (Fortuna et al., 2010). Tämän ohella JavaScript luokitellaan oliokieleksi ja sillä on dynaamisesti kääntyvän kielen ominaisuuksia ja funktionaalisen ohjelmoinnin piirteitä (MDN Web Docs, 2021).

Rinnakkaisuutta toteutettaessa JavaScript hyödyntää esimerkiksi Just-In-Time-kään- täjiä (JIT) tai Node.js-kääntäjää. JIT-kääntäjä nimensä mukaan kääntää koodin juuri silloin, kun sitä tarvitaan. Node.js-kääntäjä puolestaan mahdollistaa tapahtuma-ajoisen oh- jelmoinnin (event-driven programming) (Ueda & Ohara, 2017).

Edge Tech Academyn (2021) mukaan tapahtuma-ajoinen ohjelmointi (event-driven programming) tarkoittaa sitä, kun ohjelma on totutettu vastaamaan käyttäjän toimintaan.

Ohjelman suoriutuminen perustuu siis niin kutsuttuihin tapahtumiin (event). Tapahtumia voivat olla muun muassa hiiren klikkaus tai jonkin näppäimen painaminen. Kun tapahtuma havaitaan, ohjelman sisäinen tapahtumankäsittely-funktio (event listener) ohjaa ohjelman suorittamaan asianmukaista prosessia. (Edge Tech Academy, 2021)

Fortuna ja muut (2010) toteavat, että JavaScript ei suoraan tue samanaikaisuutta. Mo- nisäikeisen ohjelman tekeminen JavaScriptillä onnistuu kaikesta huolimatta ja JavaScrip- tissä nähdään potentiaalia toteuttaa rinnakkaisuutta etenkin web-ympäristössä. (Fortuna et al., 2010)

Node.js-kääntäjä pystyy käsittelemään vain yhtä säiettä (thread) kerrallaan (Ueda &

Ohara, 2017). Näin ollen monisäikeisen ohjelman kohdalla hyödynnetään useita kääntä- jän ilmentymiä, jotta palvelimen useita prosessoreja pystytään hyödyntämään tehokkaasti (Ueda & Ohara, 2017). Node.js-kääntäjää käytettäessä tapahtuma-ajoisuus tosin mahdollistaa usean verkon käsittelyä samanaikaisesti (Ueda & Ohara, 2017).

(12)

4.2 Java

Java on yksi johtavista ja käytetyimmistä ohjelmointikielistä web-sovelluksissa (Ueda &

Ohara, 2017). Sen on kehittänyt Sun Microsystems, joka julkaisi Javan vuonna 1995 (Togashi & Klyuev, 2014). Java on dynaamisesti käännettävä oliokieli. Samoin kuin Go:ssa, Javassa on sisäänrakennettuna paljon rinnakkaisuutta tukevia elementtejä:

Thread-luokka, Runnable-rajapinta sekä java.util.concurrent-pakkaus (Togashi &

Klyuev, 2014). Rinnakkaisuuselementtien kannalta olennainen päivitys on Java 1.5.0, joka sisälsi muun muassa edellä mainitut Thread-luokan ja java.util.concurrent-pakkauk- sen (Oracle, 2021a; Oracle, 2021b).

Java-ohjelmien moniajoisuus toteutetaan kohdassa 3.1 esiteltyä monisäikeisyyttä (multithreading) hyödyntämällä. Java-säie vastaa usein käyttöjärjestelmäsäiettä (OS thread), joka on raskaampi ratkaisu kuin Go:n gorutiinit (Ueda & Ohara, 2017). Siitä huolimatta, että Java-ohjelma voi olla monisäikeinen, Java-ohjelmissa on aina yksi pääsäie ja tarvittavat lisäsäikeet lisätään ohjelmaan Thread-luokan avulla (Abhinav et al., 2020).

Javassa käytetään Just-In-Time-kääntäjää (JIT). Tämä mahdollistaa Java-koodilla toteutetun sovelluksen nopeuden, sillä prosessissa usein tarvittu tavukoodi käännetään JIT-kääntäjällä koneen natiivikielelle kertaalleen ja se on siitä eteenpäin käytettävissä.

Lisäksi JIT-kääntäjä pystyy keräämänsä datan avulla optimoimaan koodin suorittamista, mihin staattisesti kääntyvä koodi, esimerkiksi Go, ei pysty. (Ueda & Ohara, 2017)

5 Moniajoisten ohjelmien vertailua

Tutkielmaa aloittaessani odotin, että Go suoriutuu moniajoisten ohjelmien vertailussa sel- keästi paremmin kuin Java tai JavaScript. Moniajoisten ohjelmien vertailuun vaikuttaa kuitenkin niin moni ominaisuus, että vastaus ei ole näin yksinkertainen. Ensin tässä luvussa esittelen lyhyesti lähteinä käyttämissäni tutkimuksissa hyödynnettyjä tutkimusme- netelmiä ja mittareita moniajoisuuden vertailuun. Tämän jälkeen vertailen Go-, Java- ja JavaScript-ohjelmien moniajoisuutta esiteltyjen tutkimusmenetelmien ja mittareiden avulla.

5.1 Aiemmissa tutkimuksissa käytettyjä tutkimusmenetelmiä

Löytämäni tähän aiheeseen liittyvät tutkimukset hyödynsivät moniajoisten ohjelmien vertailussa kolmea erilaista tapaa. Ueda ja Ohara (2017) tutkivat Go:n, Javan ja JavaScriptin suorituskykyä web-sovelluksissa hyödyntäen Acme Air -vertailututkimusta. Kahdessa tutkimuksessa hyödynnettiin matriisikertolaskua (Togashi & Klyuev, 2014; Abhinav et al., 2020) ja kolmas menetelmä on niin kutsuttu PageRank-algoritmi (Abhinav et al., 2020).

Acme Air -vertailuympäristö esittää kuvitteellisen lentoyhtiön lippujenvarausjärjes- telmää. Tiivistettynä Acme Air -ympäristö mallintaa verkkosivua, jossa lukuisat käyttäjät

(13)

vierailevat ostaessaan lentolippuja. Tutkimuksessa ohjelman taustajärjestelmä toteutettiin Go:lla, Javalla ja JavaScriptillä ja näitä eri toteutuksia vertailtiin keskenään eri mittareita käyttämällä. (Ueda & Ohara, 2017)

Matriisikertolasku on hyvin tyypillinen ja perinteinen vertailukeino, kun halutaan vertailla eri ohjelmien suorituskykyä (Abhinav et al., 2020; Togashi & Klyuev, 2014).

Lyhyesti matriisikertolaskussa luodaan kaksi samankokoista neliömatriisia ja suoritetaan niiden kertolasku (Abhinav et al., 2020; Togashi & Klyuev, 2014). Tähän on useita eri toteutusmahdollisuuksia, mutta perusajatus on aina sama.

Abhinavin ja muiden (2020) mukaan PageRank on yksi tunnetuimmista graafisista algoritmeista. Käytännössä se vertailee, lajittelee ja järjestää verkkosivuja. Esimerkiksi Googlen hakukoneen toteutuksessa hyödynnetään PageRank-algoritmia. Yksinkertaistet- tuna PageRank lajittelee verkkosivut yksittäisen sivun viittauslinkkien laadun perusteella.

(Abhinav et al., 2020)

5.2 Moniajoisten ohjelmien vertailussa käytettäviä mittareita

Tyypillinen eri ohjelmointikielten tai ohjelmien vertailussa käytettävä mittari on suori- tusaika (execution time tai run time) eli aika, joka kestää koodin ajamisessa. Esimerkiksi kaikissa kolmessa päälähteessä yhtenä mittarina oli käytetty suoritusaikaa (Togashi &

Klyuev, 2014; Ueda & Ohara, 2017; Abhinav et al., 2020). Toinen erittäin tyypillinen mittari on koodin käännösvaiheeseen kuluva aika (compile time), jota olivat käyttäneet sekä Abhnav ja muut (2020) että Togashi ja Klyuev (2014).

Kirjoitettavan koodin pituus sekä kirjoittamisen nopeus ja suoraviivaisuus ovat myös merkittäviä mittareita. Samanaikaisessa ohjelmoinnissa on tyypillistä, että ohjelmakoodin koko herkästi kasvaa, joten on hyödyllistä, jos käännetty koodi saadaan tallennettua suh- teellisen pieneen tilaan (Abhinav et al., 2020). Siksi binääritiedoston (binary file) eli käännetyn koodin koko on olennainen mitattava ominaisuus.

Lisäksi samanaikaisuuselementtien (concurrency features) määrä ja laatu on hyvä mittari (Togashi & Klyuev, 2014). Joissain kielissä samanaikaisuuselementit ovat sisään- rakennettuja, toisissa ne pitää hakea esimerkiksi erinäisistä kirjastoista.

Lukemissani tutkimuksissa edellä mainittujen mittarien erilaisten yhdistelmien avulla saadaan sellainen kokonaisuus, jonka avulla moniajoisuuden vertailu on mahdollista.

5.3 Go vs. Java vs. JavaScript

Kuten kohdassa 3.2. mainitsen, moniajoisuus ja samanaikaisen ohjelmoinnin ominaisuudet olivat keskeisiä Go:n kehitystyössä. Näin ollen Go:ssa on valtavasti sisäänrakennet- tuja samanaikaisuuselementtejä, joten moniajoisen ohjelman tekeminen on Go:lla verrattain helppoa (Abhinav et al, 2020; Tang, 2010). Tästä syystä odotin, että Go suoriutuu moniajoisuusvertailu paremmin kuin Java ja JavaScript. Koska Go on nuori ohjelmointikieli, siinä on vielä selkeitä kehityskohteita.

(14)

Kahdessa lukemassani tutkimuksessa, todetaan tutkimusmenetelmästä riippumatta, että Go:n käännösaika on merkittävästi lyhyempi kuin Javan (Togashi & Klyuev, 2014;

Abhinav et a., 2020). Togashin ja Klyuevn (2014) tutkimuksen perusteella Go-ohjelman käännösaika on lähes kolme kertaa nopeampi kuin vastaavaa tehtävää suorittavan Java- ohjelman.

Go-ohjelman heikkous verrattaessa Java- ja JavaScript-ohjelmiin on koodin käännös- vaiheen toteutus ja erityisesti käännetyn koodin tallentaminen (Abhinav et al., 2020). Go on staattisesti kääntyvä kieli eli Go-koodi on käännettävä ennen kuin se voidaan ajaa (Ueda & Ohara, 2017). Java ja JavaScript taas ovat dynaamisesti kääntyviä kieliä eli Java- ja JavaScript-ohjelmien kääntäminen tapahtuu ohjelman suorittamisen yhteydessä (Ueda

& Ohara, 2017).

Abhinav et al. (2020) kuvaavat tutkimuksessaan, miten binääritiedoston eli käännetyn koodin kokoon vaikuttaa tapa, jolla koodi käännetään. Mutta koska Go-ohjelma kääntyy konekieliseksi, sen voi suorittaa ilman lisätiedostoja. Java puolestaan kääntyy tavukoo- diksi a.class-tiedostoon ja se on vielä formatoitava uudestaan ennen, kun sen voi ajaa.

Käännetyn Java-tavukoodin vaatimukset ovat pienemmät kuin konekieliseksi käännetyn Go-ohjelman, koska Java-tavukoodi tulkataan vielä ennen ajovaihetta. Näin ollen, kuten taulukossa 1 on esitetty, Javan binääritiedosto vie selvästi vähemmän tilaa kuin Go:n vastaava. (Abhinav et al., 2020)

Dynaamisesti kääntyvinä kielinä Javan ja JavaScriptin etu on se, että niillä tehtyä ohjelmaa on helppo kehittää ja ohjelma on sujuva ottaa käyttöön (Ueda & Ohara, 2017).

Toisaalta tutkimuksessaan Ueda ja Ohara (2017) toteavat, että kun staattisesti kääntyvä ohjelma, esimerkiksi Go-ohjelma, on saatu käyttöön, sen ylläpitäminen on helpompaa kuin dynaamisesti kääntyvän ohjelman.

Go:n vahvuus on myös, että siinä tarvitaan huomattavasti vähemmän funktiokutsuja kuin Javassa tai JavaScriptissa (Ueda & Ohara, 2017). Ohjelmoiminen Go:lla on suora- viivaisempaa kuin Javalla ja JavaScriptilla, sillä siinä on vähemmän abstraktioita (Ueda

& Ohara, 2017). Javan kohdalla samanaikaisuuselementit on haettava erillisistä kirjastoista, jolloin funktiokutsuja tarvitaan paljon (Togashi & Klyuev, 2014). JavaScriptin

Taulukko 1. Binääritiedoston koon vertailua Javan ja Go:n välillä (Abhinav et al., 2020).

(15)

Node.js-kääntäjä puolestaan ei tue rinnakkaista ohjelmointia, joten rinnakkaisuuden toteutuksessa tarvitaan useita Node.js:n ilmentymiä ja hyödynnetään JavaScriptin tapahtuma-ajoista ohjelmointimallia (Ueda & Ohara, 2017).

Go-koodin suoraviivaisuus ja konkreettisuus aiheuttaa myös, että Go:lla tehdyt ohjelmat ovat lyhyitä ja helposti ymmärrettäviä. Togashi ja Klyuev (2014) vertasivat Java- ja Go-ohjelmia koodirivien määrän mukaan. Ero ei ollut merkittävä, mutta se vaikuttaa ko- konaisuuteen. Go:ssa on myös Go Format -työkalu, jonka vuoksi ohjelmoija voi keskittyä kirjoittamaan toimivaa koodia, eikä hänen tarvitse erityisesti kiinnittää huomiota koodin rakenteeseen toisin kuin Javassa (Meyerson, 2014). Go Format eli Gofmt() muotoilee lähdekooditiedoston standardoidulla tavalla. Tämä helpottaa ohjelmoijien välistä yhteis- työtä, sillä eri ohjelmoijien lähdekoodit näyttävät yhtenäisiltä (Meyerson, 2014).

Togashi ja Klyuev (2014) huomasivat tutkimuksessaan, että Go:n samanaikaisuuselementit ovat tehokkaita. He toteuttivat Javalla ja Go:lla kummallakin kaksi matriisiker- tolaskuohjelmaa: toinen ohjelmista hyödynsi samanaikaisuuselementtejä ja toinen ei.

Näin he vertailivat matriisikertolaskun suoritusaikaa sekä kielten välillä että kummankin kielen sisällä. Tutkimus osoitti, että ilman samanaikaisuuselementtejä Go:n suoritusaika pitenee huomattavasti, mitä suurempaa matriisia käsitellään (kuvan 4 vasemmanpuolei- nen kaavio). Vastaavasti, kun samanaikaisuuselementit otettiin käyttöön, Go-ohjelma oli selkeästi nopeampi kuin Java-ohjelma. Tämä näkyy kuvan 4 oikeanpuoleisessa kaaviossa. (Togashi & Klyuev, 2014)

Kuusi vuotta myöhemmin Abhinavin ja muut (2020) tekivät tutkimusta Go:lla ja Ja- valla kirjoitettujen matriisikertolaskuohjelmien samanaikaisuudesta. He huomasivat, kuinka paljon matriisin koko vaikuttaa asiaan (Abhinav et al., 2020). Togashi ja Klyuev (2014) käsittelivät matriiseja, joiden koko oli suurimmillaan 80 ruutua. Abhinav et al.

(2020) löysivät käännöskohdan: Kuten kuvan 5 kaaviosta näkyy, kun matriisin koko on noin 1700 ruutua tai enemmän Go:n suoritusaika alkaa heikentyä merkittävästi.

Kuva 4. Käytetty aika suhteessa matriisin kokoon, kun ohjelmassa käytetään samanaikaisuus- elementtejä (oikea) tai ei (vasen) (Togashi & Klyuev, 2014).

(16)

Uedan ja Oharan (2017) mukaan Go:n suoritusteho on selkeästi parempi kuin Javan tai JavaScriptin. Kuten kuvasta 6 näkyy, Go-ohjelman suoritusteho oli 3.6 kertaa parempi kuin JavaScript-ohjelman ja 2.6 kertaa parempi kuin Java-ohjelman (Ueda & Ohara, 2017). Go-ohjelmointikieleen verratessa JavaScriptin heikkoudeksi osoittautuivat tapahtuma-ajoinen ohjelmointimalli ja Node.js-toteutukset, Java puolestaan ei onnistunut web- kehyksen tehokkaassa hyödyntämisessä, mihin tämän tutkielman puitteissa en paneudu mainintaa tarkemmin (Ueda & Ohara, 2017). Uedan ja Oharan (2017) tutkimus vertailee Go-, Java- ja JavaScript-ohjelmia web-ympäristöjen taustajärjestelmissä. Heidän johto- päätöksensä puoltavat väitettä, että Go on hyvä ohjelmointikieli juuri taustajärjestelmien ohjelmointiin web-ympäristössä (Ueda & Ohara, 2017).

Kuva 5. Kaavio kuvaa ohjelman käyttämää aikaa suhteessa matriisin kokoon (Abhinav et al., 2020).

Kuva 6. Kaavio, jossa verrataan Go-, Java- ja JavaScript- ohjelmien suoritustehoa (Ueda & Ohara, 2017).

(17)

6 Tutkimuksen arviointi ja yhteenveto

Tässä tutkielmassa vertailin moniajoisuutta Go:lla, Javalla ja JavaScriptilla kirjoitetuissa taustajärjestelmäohjelmissa. Digitalisaatio on siirtänyt ihmisten toimintaa yhä enemmän verkkoympäristöön. Tämä johtaa siihen, että lukuisat ihmiset vierailevat samoilla verk- kosivuilla tai sovelluksissa samanaikaisesti. Moniajoiset verkkosivut ja sovellukset ovat ratkaisu, jolla tähän käyttäjämäärään pystytään vastaamaan.

Tutkielmani on kuvailevan ja systemaattisen kirjallisuuskatsauksen yhdistelmä. Tut- kielmaa kirjoittaessani opin paljon uutta taustajärjestelmäohjelmien moniajoisuudesta, mutta aloittaessani avainkäsitteistö oli minulle tuntematon. Tämä johti siihen, etten voi- nut kirjallisuushakuprosessin alussa määrittää selkeitä hakumetodeja tai rajauksia, jotka ovat keskeisiä systemaattisessa kirjallisuuskatsauksessa (Salminen, 2011).

Systemaattinen kirjallisuuskatsaus on hyvä tapa kiinnittää tutkimus muihin saman alan tutkimuksiin, sillä sen tekoprosessissa keskitytään kirjallisuushaun lisäksi myös löy- dettyjen tutkimusten välillä oleviin yhteyksiin (Salminen, 2011). Koska tutkielmani ei ole täydellisen systemaattinen kirjallisuuskatsaus, se ei ole yhtä tiiviisti linkittynyt aiempaan tutkimukseen. Systemaattisen kirjallisuuskatsauksen tärkeä ominaisuus on toistettavuus, joten kirjallisuushakuprosessini ei täysin täytä systemaattisen kirjallisuuskatsauksen kri- teerejä (Salminen, 2011).

Tutkielmani lähtökohtana oli kaksi käsitettä: ohjelmistojen taustajärjestelmä (backend tai server-side) sekä moniajoisuus. Ensimmäiset kirjallisuushakuni olivat hyvin laajoja, sillä käyttämiäni hakusanoja olivat server-side, backend, language ja concur- rency. Näillä hauilla tuloksia tuli erittäin paljon, mutta onnistuin silti löytämään muuta- man lupaavalta vaikuttavan lähteen mukaan lukien yhden tutkielmani päälähteistä (Ueda

& Ohara, 2017).

Tämän jälkeen avainkäsitteet alkoivat hahmottua paremmin, ja kirjallisuushakupro- sessistani tuli systemaattisempi. Hyödynsin löytämieni lähteiden lähdeluetteloita. Niiden avainkäsitteet auttoivat uusien hakulauseiden muodostamisessa. Uusia hakusanoja olivat multi-threading, parallel programming, Google Go, Java ja JavaScript.

Aloitin hakuni Tampereen Yliopiston kirjaston Andor-palvelusta. Koska Andor on monialainen, hakuja on rajattava todella paljon, jotta sopivia lähteitä löytyy. Näin ollen käsitteistöni tarkentuessa siirryin hyödyntämään IEEE-tietokantaa ja ACM-kirjastoa, jotka sisältävät yksinomaan tietojenkäsittelytieteiden kirjallisuutta. Tästä syystä tein suu- rimman osan kirjallisuushauistani ja löysin osuvimmat lähteeni näistä tietokannoista.

Tutkielmani keskiössä oleva Go vaikutti lähteiden julkaisuvuoden rajaukseen. Go julkaistiin loppuvuodesta 2009 (Meyeron, 2014) ja siihen liittyviä ensimmäisiä tutkimuk- sia julkaistiin jo 2010, joista esimerkkinä Tang (2010). Tangin (2010) julkaisuun viitataan myös useassa muussa käyttämässäni lähteessä, esimerkkeinä Togashi ja Klyuev (2014)

(18)

sekä Abhinav ja muut (2020). Tästä syystä rajasin, että tutkielmassa käyttämäni lähteet on julkaistu aikaisintaan vuonna 2010.

Tässä tutkielmassa vertailen Googlen kehittämää Golang- eli Go-ohjelmointikieltä Javaan ja JavaScriptiin, jotka molemmat ovat erittäin käytettyjä ohjelmointikieliä. Alku- peräinen oletukseni oli, että Go suoriutuisi selkeästi paremmin moniajoisen taustajärjes- telmäohjelman toteuttamisessa kuin Java ja JavaScript. Oletukseni perustui siihen, että moniajoisuus on ollut tärkeä osatekijä Go:n kehitystyössä, ja kielellä on selkeät samanaikaisuuselementit. Go on kuitenkin vielä verrattain nuori ohjelmointikieli, kun taas Javalla ja JavaScriptillä on ollut valtavasti aikaa päivittyä nyky-yhteiskunnan käyttötarkoituksia varten.

Kaikkien käyttämieni tutkimusten tuloksissa Go suoriutui todella hyvin. Esimerkiksi Togashin ja Klyuevin (2014) tutkimuksen mukaan Go suoriutui kaikissa toteutetuissa tes- teissä paremmin kuin Java. Kuusi vuotta myöhemmin tehdyssä tutkimuksessa Go:n suo- riutumisesta löydettiin vielä selkeitä heikkouksia. Merkittävin näistä on Go:n heikko suoritusaika, kun suoritettavassa ohjelmassa on toteutettava paljon laskentaa (Abhinav et al., 2020).

Go:n selkeä vahvuus on yksinkertainen syntaksi: Go-ohjelmaa on helppo kirjoittaa, sillä siinä ei tarvitse erityisen tarkasti keskittyä koodin rakenteeseen, ja ohjelman varsi- nainen kirjoittaminen on hyvin suoraviivaista (Abhinav et al., 2020; Meyerson, 2014).

Go:ssa on sisäänrakennettuna kaikki tarvittavat samanaikaisuuselementit, joten Go-ohjelma esimerkiksi vaatii selkeästi vähemmän funktiokutsuja tehtävän suorittamiseen kuin vastaava Java- ja JavaScript-ohjelma (Ueda & Ohara, 2017).

Dynaamisesti kääntyvinä kielinä Javan ja JavaScriptin etu on se, että niillä tehtyä ohjelmaa on helppo kehittää ja ohjelma on sujuva ottaa käyttöön (Ueda & Ohara, 2017).

Toisaalta tutkimuksessaan Ueda ja Ohara (2017) toteavat, että kun staattisesti kääntyvä ohjelma, esimerkiksi Go-ohjelma, on saatu käyttöön, sen ylläpitäminen on helpompaa kuin dynaamisesti kääntyvän ohjelman.

Sopivan ohjelmointikielen valitseminen on aina tapauskohtaista. Tutkielmani tavoitteena oli vertailla Go-, Java- ja JavaScript-kielisiä moniajoisia ohjelmia ja sitä kautta helpottaa sopivan ohjelmointikielen valitsemista moniajoisen ohjelman kirjoittamiseen.

Java on laajasti käytetty ja hyvin pidetty ohjelmointikieli. Päivitysten myötä kieleen tuodut rinnakkaisuuselementit ovat mahdollistaneet moniajoisuuden toteuttamisen moni- säikeisyyttä hyödyntäen. Javassa käytetyt säikeet ovat selkeästi raskaampia kuin Go:n gorutiinit (Ueda & Ohara, 2017). Abhinav ja muut (2020) toteavat Javan suoriutuvan par- haiten sellaisessa tehtävässä, missä säikeitä ei tarvitse luoda tai tuhota valtavia määriä.

Selkeä vahvuus Java-ohjelmassa on tehokkuus, kun ohjelman on toteutettava paljon laskentaa (Abhinav et at., 2020).

(19)

JavaScript on laajasti käytetty taustajärjestelmän ohjelmointikieli, erityisesti web- ympäristöissä. Node.js-kääntäjän tai JIT-kääntäjän sekä tapahtuma-ajoisen ohjelmointi- mallin ansiosta JavaScriptillä pystyy toteuttamaan monisäikeisen ohjelman (Ueda &

Ohara, 2017). Lukemieni tutkimusten perusteella JavaScript-ohjelma häviää vertailussa vastaavalle moniajoiselle Go- tai Java-taustajärjestelmäohjelmalle.

Go:lla on potentiaalia vakiinnuttaa asemansa nykyhetken ja tulevaisuuden laajasti käytettynä ohjelmointikielenä (Togashi & Klyuev, 2014). Siinä on moniajoisuuden vaa- timat ominaisuudet ja sitä voi hyödyntää myös suurien koodipohjien samanaikaiseen kä- sittelyyn (Meyerson, 2014). Go on monelta osin ratkaisu Googlen kohtaamiin ongelmiin (Meyerson, 2014).

Lähdeluettelo

Abhinav, P. Y., Bhat, A., Joseph, C. T. & Chandrasekaran, K. (2020). Concurrency Anal- ysis of Go and Java. Proceedings of the 2020 5^th International Conference on Com- puting, Communication and Security. 1-6. https://doi-org.libproxy.tuni.fi/10.1109/ICCCS49678.2020.9277498

A Tour of Go. (2021). A Tour of Go. https://tour.golang.org/concurrency/2 (Haettu 23.2.2021)

Britannica Academy. (2021). Multiprocessing, Britannica Academy. https://academic- eb-com.libproxy.tuni.fi/levels/collegiate/article/multiprocessing/1734 (Haettu 22.2.2021)

Ebbers, M., Kettner, J., O’Brien, W. & Ogder, B. (2011). Introduction to the New Main- frame: z/OS Basics, (3.2.2). IBM Redbook

Edge Tech Academy. (2021). Event-Driven Programming. https://www.edgetechacad- emy.edu/node-js/event-driven-programming/ (Haettu 11.4.2021)

Fortuna, E., Anderson, O., Ceze, L. & Eggers, S. (2010). A limit study of JavaScript parallelism. Proceedings of the IEEE International Symposium on Workload Char- acterization. 1-10. https://doi-org.libproxy.tuni.fi/10.1109/IISWC.2010.5649419

Dvecko, M. (2021). Introduction to concurrent programming: a beginner’s guide. Devel- opers. https://www.toptal.com/software/introduction-to-concurrent-programming (Haettu 22.2.2021)

(20)

GeeksforGeeks. (2021a). Difference between multiprogramming, multitasking, multithreading and multiprocessing. GeeksforGeeks. https://www.geeksforgeeks.org/difference-between-multitasking-multithreading-and-multiprocessing/ (Haettu 22.2.2021)

GeeksforGeeks. (2021b). Difference between Concurrency and Parallelism. Geeksfor- Geeks. https://www.geeksforgeeks.org/difference-between-concurrency-and-parallelism/ (Haettu 22.2.2021)

Gerrand, A. (2010). Go version 1 is released. The Go blog. https://blog.golang.org/go1 Gerrand, A. (2013). Concurrency is not parallelism. The Go blog. https://blog.go-

lang.org/waza-talk

Griesemer, R. (2018). Go 2, here we come! The Go blog. https://blog.golang.org/go2- here-we-come

Go. (2021). Package runtime. https://golang.org/pkg/runtime/ (Haettu 29.3.2021)

Kaupan Liitto. (2021). Digiostaminen kasvoi Suomessa yli viidenneksellä – kotimainen verkkokauppa valtasi markkinoita. https://kauppa.fi/uutishuone/2021/03/18/digiostaminen-kasvoi-suomessa-yli-viidenneksella-kotimainen-verkkokauppa-valtasi-markkinoita/ (Haettu 16.4.2021)

Oracle. (2021a). Class Thread. https://docs.oracle.com/ja- vase/8/docs/api/java/lang/Thread.html (Haettu 31.3.2021)

Oracle (2021b). java.util.concurrent. https://docs.oracle.com/ja- vase/8/docs/api/java/util/concurrent/package-summary.html (Haettu 31.3.2021) Meyerson, J. (2014). The Go Programming Language. IEEE Software, 31(5), 104-104.

https://doi.org/10.1109/MS.2014.127

MOT. (2021). MOT Tietotekniikan liiton ATK-sanakirja, Mot-kielikone. https://mot-kielikone-fi.libproxy.tuni.fi/mot/uta/netmot.exe

MDN Web Docs. (2021). About JavaScript. MDN Web Docs Mozilla. https://devel- oper.mozilla.org/en-US/docs/Web/JavaScript/About_JavaScript (Haettu 25.2.2021) Roscoe, A. W. & Davies, J. (2011). CSP (Communicating Sequential Processing). Ency- clopedia of Parallel Computing. https://doi-org.libproxy.tuni.fi/10.1007/978-0- 387-09766-4

(21)

Salminen, A. (2011). Mikä kirjallisuuskatsaus? Vaasan yliopiston julkaisuja, opetus- julkaisuja 62, julkisjohtaminen 4. https://osuva.uwasa.fi/bitstream/han- dle/10024/7961/isbn_978-952-476-349-3.pdf?sequence=1

Tang, P. (2010). Multi-Core Parallel Programming in Go. Proceeding of the First Inter- national Conference on Advanced Computing and Communication. 64-69.

http://citeseerx.ist.psu.edu.libproxy.tuni.fi/viewdoc/down- load?doi=10.1.1.467.9137&rep=rep1&type=pdf

The Go blog. (2021). The Go blog. https://blog.golang.org/index (Haettu 23.2.2021) Togashi, N. & Klyuev, V. (2014). Concurrency in Go and Java: Performance analysis.

Proceedings of the 2014 4^th IEEE International Conference on Information Science

and Technology. 213-216. https://doi-

org.libproxy.tuni.fi/10.1109/ICIST.2014.6920368

Ueda, Y. & Ohara, M. (2017). Performance competitiveness of a statically compiled language for server-side Web applications. Proceedings of the 2017 IEEE International Symposium on Performance Analysis of Systems and Software. 13-22. https://doi- org.libproxy.tuni.fi/10.1109/ISPASS.2017.7975266

Wikipedia. (2021a). Go (programming language). https://en.wikipedia.org/wiki/Go_(programming_language)#Applications (Haettu 29.3.2021)