WebAssembly-säikeet: Rinnakkaisprosessoinnin ja jaetun muistin vapauttaminen parannetun suorituskyvyn saavuttamiseksi

WebAssembly (Wasm) on mullistanut web-kehityksen ja sitä käytetään yhä enemmän myös selaimen ulkopuolella. Sen siirrettävyys, suorituskyky ja turvallisuus ovat tehneet siitä houkuttelevan vaihtoehdon JavaScriptille suorituskykykriittisissä sovelluksissa. Yksi merkittävimmistä edistysaskelista WebAssemblyssa on säikeiden käyttöönotto, joka mahdollistaa rinnakkaisprosessoinnin ja jaetun muistin. Tämä avaa uuden suorituskyvyn tason laskennallisesti intensiivisille tehtäville, mikä mahdollistaa monimutkaisempien ja reagoivampien web-sovellusten sekä natiivisovellusten kehittämisen.

WebAssemblyn ja sen etujen ymmärtäminen

WebAssembly on binäärinen käskyformaatti, joka on suunniteltu siirrettäväksi käännöskohteeksi ohjelmointikielille. Se mahdollistaa C:n, C++:n, Rustin ja muiden kielten kaltaisilla kielillä kirjoitetun koodin suorittamisen lähes natiivinopeudella verkkoselaimissa ja muissa ympäristöissä. Sen tärkeimpiä etuja ovat:

• Suorituskyky: Wasm-koodi suoritetaan huomattavasti nopeammin kuin JavaScript, erityisesti laskennallisesti intensiivisissä tehtävissä.
• Siirrettävyys: Wasm on suunniteltu toimimaan eri alustoilla ja selaimilla.
• Turvallisuus: Wasmilla on turvallinen suoritusmalli, joka hiekkalaatikoi koodin estääkseen luvattoman pääsyn järjestelmäresursseihin.
• Kieliriippumattomuus: Voit kirjoittaa Wasm-moduuleita käyttämällä useita eri kieliä hyödyntäen kunkin vahvuuksia.

WebAssembly on löytänyt sovelluskohteita useilta aloilta, mukaan lukien:

• Pelaaminen: Suorituskykyisten pelien toimittaminen selaimessa.
• 3D-renderöinti: Interaktiivisten 3D-kokemusten luominen.
• Video- ja äänieditointi: Multimediasisällön nopean käsittelyn mahdollistaminen.
• Tieteellinen laskenta: Monimutkaisten simulaatioiden ja data-analyysin suorittaminen.
• Pilvilaskenta: Palvelinpuolen sovellusten ja mikropalveluiden ajaminen.

Säikeiden tarve WebAssemblyssa

Vaikka WebAssembly tarjoaa vaikuttavaa suorituskykyä, se toimi perinteisesti yksisäikeisessä ympäristössä. Tämä tarkoitti, että laskennallisesti intensiiviset tehtävät saattoivat tukkia pääsäikeen, mikä johti hitaaseen käyttäjäkokemukseen. Esimerkiksi monimutkainen kuvankäsittelyalgoritmi tai fysiikkasimulaatio saattoi jäädyttää selaimen sen ollessa käynnissä. Tässä kohtaa säikeet tulevat kuvaan.

Säikeet mahdollistavat ohjelman suorittaa useita tehtäviä samanaikaisesti. Tämä saavutetaan jakamalla ohjelma useisiin säikeisiin, joista jokainen voi toimia itsenäisesti. Monisäikeisessä sovelluksessa suuren prosessin eri osat voivat toimia samanaikaisesti, mahdollisesti erillisillä suoritinytimillä, mikä johtaa merkittävään nopeuden kasvuun. Tämä on erityisen hyödyllistä laskennallisesti raskaille tehtäville, koska työ voidaan jakaa useiden ytimien kesken sen sijaan, että kaikki suoritettaisiin yhdellä ytimellä. Tämä estää käyttöliittymän jäätymisen.

WebAssembly-säikeiden ja jaetun muistin esittely

WebAssembly-säikeet hyödyntävät SharedArrayBuffer (SAB) ja Atomics JavaScript-ominaisuuksia. SharedArrayBuffer mahdollistaa useiden säikeiden pääsyn samaan muistialueeseen ja sen muokkaamisen. Atomics tarjoaa matalan tason operaatioita säikeiden synkronointiin, kuten atomiset operaatiot ja lukot, estäen datakilpailutilanteet ja varmistaen, että jaetun muistin muutokset ovat yhdenmukaisia säikeiden välillä. Nämä ominaisuudet antavat kehittäjille mahdollisuuden rakentaa todella rinnakkaisia sovelluksia WebAssemblyssa.

SharedArrayBuffer (SAB)

SharedArrayBuffer on JavaScript-objekti, joka antaa useiden web workereiden tai säikeiden jakaa saman taustalla olevan muistipuskurin. Ajattele sitä jaettuna muistitilana, jossa eri säikeet voivat lukea ja kirjoittaa dataa. Tämä jaettu muisti on perusta WebAssemblyn rinnakkaisprosessoinnille.

Atomics

Atomics on JavaScript-objekti, joka tarjoaa matalan tason atomisia operaatioita. Nämä operaatiot varmistavat, että luku- ja kirjoitusoperaatiot jaettuun muistiin tapahtuvat atomisesti, mikä tarkoittaa, että ne suoritetaan loppuun ilman keskeytyksiä. Tämä on kriittistä säikeiden turvallisuuden ja datakilpailutilanteiden välttämisen kannalta. Yleisiä Atomics-operaatioita ovat:

• Atomic.load(): Lukee arvon jaetusta muistista.
• Atomic.store(): Kirjoittaa arvon jaettuun muistiin.
• Atomic.add(): Lisää atomisesti arvon muistipaikkaan.
• Atomic.sub(): Vähentää atomisesti arvon muistipaikasta.
• Atomic.wait(): Odotaa, että jaetun muistin arvo muuttuu.
• Atomic.notify(): Ilmoittaa odottaville säikeille, että jaetun muistin arvo on muuttunut.

Kuinka WebAssembly-säikeet toimivat

Tässä on yksinkertaistettu yleiskatsaus WebAssembly-säikeiden toiminnasta:

1. Moduulin kääntäminen: Lähdekoodi (esim. C++, Rust) käännetään WebAssembly-moduuliksi yhdessä tarvittavien säikeiden tukikirjastojen kanssa.
2. Jaetun muistin varaaminen: Luodaan SharedArrayBuffer, joka tarjoaa jaetun muistitilan.
3. Säikeiden luominen: WebAssembly-moduuli luo useita säikeitä, joita voidaan sitten ohjata JavaScript-koodista (tai natiivin WebAssembly-ajonaikaisen ympäristön kautta, riippuen ympäristöstä).
4. Tehtävien jakaminen: Tehtävät jaetaan ja osoitetaan eri säikeille. Tämän voi tehdä kehittäjä manuaalisesti tai käyttämällä tehtävien ajoituskirjastoa.
5. Rinnakkainen suoritus: Jokainen säie suorittaa sille annetun tehtävän samanaikaisesti. Ne voivat käyttää ja muokata dataa SharedArrayBufferissa käyttäen atomisia operaatioita.
6. Synkronointi: Säikeet synkronoivat työnsä käyttämällä Atomics-operaatioita (esim. mutex-lukkoja, ehtomuuttujia) välttääkseen datakilpailutilanteet ja varmistaakseen datan yhdenmukaisuuden.
7. Tulosten yhdistäminen: Kun säikeet ovat saaneet tehtävänsä valmiiksi, tulokset yhdistetään. Tämä voi tarkoittaa, että pääsäie kerää tulokset työsäikeiltä.

WebAssembly-säikeiden käytön edut

WebAssembly-säikeet tarjoavat useita keskeisiä etuja:

• Parannettu suorituskyky: Rinnakkaisprosessointi antaa sinun hyödyntää useita suoritinytimiä, mikä nopeuttaa merkittävästi laskennallisesti intensiivisiä tehtäviä.
• Parempi reagoivuus: Siirtämällä tehtäviä työsäikeille pääsäie pysyy reagoivana, mikä johtaa parempaan käyttäjäkokemukseen.
• Monialustainen yhteensopivuus: WebAssembly-säikeet toimivat eri käyttöjärjestelmissä ja selaimissa, jotka tukevat SharedArrayBufferia ja Atomicsia.
• Olemassa olevan koodin hyödyntäminen: Voit usein kääntää olemassa olevia monisäikeisiä koodikantoja (esim. C++, Rust) WebAssemblyksi minimaalisin muutoksin.
• Lisääntynyt skaalautuvuus: Sovellukset voivat käsitellä suurempia tietomääriä ja monimutkaisempia laskutoimituksia ilman suorituskyvyn heikkenemistä.

WebAssembly-säikeiden käyttötapauksia

WebAssembly-säikeillä on laaja valikoima sovelluskohteita:

• Kuvan- ja videonkäsittely: Kuvasuodattimien, videon koodauksen/dekoodauksen ja muiden kuvankäsittelytehtävien rinnakkaistaminen. Kuvittele Tokiossa, Japanissa tehty sovellus, joka mahdollistaa useiden videosuodattimien reaaliaikaisen käytön ilman viivettä.
• 3D-grafiikka ja simulaatiot: Monimutkaisten 3D-näkymien renderöinti, fysiikkasimulaatioiden ajaminen ja pelien suorituskyvyn optimointi. Tämä on hyödyllistä sovelluksille, joita käytetään Saksassa tai missä tahansa muussa maassa, jossa on korkean suorituskyvyn pelikulttuuri.
• Tieteellinen laskenta: Monimutkaisten laskutoimitusten suorittaminen tieteellistä tutkimusta varten, kuten molekyylidynamiikan simulaatiot, sääennusteet ja data-analyysi, kaikkialla maailmassa.
• Data-analyysi ja koneoppiminen: Datan käsittelyn, mallien koulutuksen ja päättelytehtävien nopeuttaminen. Lontoossa, Yhdistyneessä kuningaskunnassa, sijaitsevat yritykset hyötyvät tästä, mikä johtaa suurempaan tehokkuuteen.
• Äänenkäsittely: Reaaliaikaisten ääniefektien, synteesin ja miksauksen toteuttaminen.
• Kryptovaluutan louhinta: Vaikka kiistanalaista, jotkut käyttävät WebAssemblyn nopeutta tähän tarkoitukseen.
• Rahoitusmallinnus: Monimutkaisten rahoitusmallien ja riskinarviointien laskeminen. Yritykset Sveitsissä ja Yhdysvalloissa hyötyvät tästä.
• Palvelinpuolen sovellukset: Suorituskykyisten taustajärjestelmien ja mikropalveluiden ajaminen.

WebAssembly-säikeiden toteuttaminen: Käytännön esimerkki (C++)

Kuvitellaan, kuinka voit luoda yksinkertaisen WebAssembly-moduulin säikeillä käyttäen C++:aa ja Emscripteniä, suosittua työkaluketjua C/C++:n kääntämiseen WebAssemblyksi. Tämä on yksinkertaistettu esimerkki peruskäsitteiden korostamiseksi. Todellisissa sovelluksissa käytetään tyypillisesti kehittyneempiä synkronointitekniikoita (esim. mutex-lukkoja, ehtomuuttujia).

1. Asenna Emscripten: Jos et ole vielä tehnyt sitä, asenna Emscripten, joka vaatii Pythonin ja muiden riippuvuuksien oikeanlaisen asennuksen.
2. Kirjoita C++-koodi: Luo tiedosto nimeltä `threads.cpp` seuraavalla sisällöllä:

               #include <emscripten.h>
   #include <pthread.h>
   #include <stdio.h>
   #include <atomic>
   
   // Shared memory
   std::atomic<int> shared_counter(0);
   
   void* thread_function(void* arg) {
       int thread_id = *(int*)arg;
       for (int i = 0; i < 1000000; ++i) {
           shared_counter++; // Atomic increment
       }
       printf("Thread %d finished\n", thread_id);
       return nullptr;
   }
   
   extern "C" {
       EMSCRIPTEN_KEEPALIVE
       int start_threads(int num_threads) {
           pthread_t threads[num_threads];
           int thread_ids[num_threads];
   
           printf("Starting %d threads...\n", num_threads);
   
           for (int i = 0; i < num_threads; ++i) {
               thread_ids[i] = i;
               pthread_create(&threads[i], nullptr, thread_function, &thread_ids[i]);
           }
   
           for (int i = 0; i < num_threads; ++i) {
               pthread_join(threads[i], nullptr);
           }
   
           printf("All threads finished. Final counter value: %d\n", shared_counter.load());
           return shared_counter.load();
       }
   }
   
               
   
                 
                   Copy
                 
               
             

3. Käännä Emscriptenillä: Käännä C++-koodi WebAssemblyksi käyttämällä Emscripten-kääntäjää. Huomaa liput säikeiden ja jaetun muistin käyttöönottoa varten:

               emcc threads.cpp -o threads.js -s WASM=1 -s USE_PTHREADS=1 -s PTHREAD_POOL_SIZE=4 -s ENVIRONMENT=web,worker -s ALLOW_MEMORY_GROWTH=1
               
   
                 
                   Copy
                 
               
             

   Yllä oleva komento tekee seuraavaa:

   • `emcc`: Emscripten-kääntäjä.
   • `threads.cpp`: C++-lähdetiedosto.
   • `-o threads.js`: Tulos-JavaScript-tiedosto (joka sisältää myös WebAssembly-moduulin).
   • `-s WASM=1`: Ottaa käyttöön WebAssembly-käännöksen.
   • `-s USE_PTHREADS=1`: Ottaa käyttöön pthreads-tuen, joka on vaadittu säikeille.
   • `-s PTHREAD_POOL_SIZE=4`: Määrittää työsäikeiden määrän säiepoolissa (muokkaa tätä tarpeen mukaan).
   • `-s ENVIRONMENT=web,worker`: Määrittää, missä tämän tulisi toimia.
   • `-s ALLOW_MEMORY_GROWTH=1`: Sallii WebAssembly-muistin kasvaa dynaamisesti.
4. Luo HTML-tiedosto: Luo HTML-tiedosto (esim. `index.html`) ladataksesi ja suorittaaksesi luodun JavaScript- ja WebAssembly-moduulin:

               <!DOCTYPE html>
   <html>
   <head>
       <title>WebAssembly Threads Example</title>
   </head>
   <body>
       <script src="threads.js"></script>
       <script>
           Module.onRuntimeInitialized = () => {
               // Call the start_threads function from the WebAssembly module
               Module.start_threads(4);
           };
       </script>
   </body>
   </html>
   
               
   
                 
                   Copy
                 
               
             

5. Suorita koodi: Avaa `index.html` verkkoselaimessa. Avaa selaimen kehittäjäkonsoli nähdäksesi tulosteen. Koodi luo ja käynnistää useita säikeitä, jotka kasvattavat jaettua laskuria silmukassa ja tulostavat lopullisen laskurin arvon. Sinun pitäisi nähdä, että säikeet toimivat samanaikaisesti, mikä on nopeampaa kuin yksisäikeinen lähestymistapa.

   Tärkeä huomautus: Tämän esimerkin suorittaminen vaatii selaimen, joka tukee WebAssembly-säikeitä. Varmista, että selaimessasi on SharedArrayBuffer ja Atomics käytössä. Saatat joutua ottamaan käyttöön kokeellisia ominaisuuksia selaimesi asetuksista.

WebAssembly-säikeiden parhaat käytännöt

Kun työskentelet WebAssembly-säikeiden kanssa, harkitse näitä parhaita käytäntöjä:

• Säikeiden turvallisuus: Käytä aina atomisia operaatioita (esim. `Atomic.add`, `Atomic.store`, `Atomic.load`) tai synkronointiprimitiivejä (mutex-lukot, semaforit, ehtomuuttujat) suojataksesi jaettua dataa datakilpailutilanteilta.
• Minimoi jaettu muisti: Vähennä jaetun muistin määrää minimoidaksesi synkronoinnin aiheuttaman ylikuormituksen. Jos mahdollista, osioi data siten, että eri säikeet työskentelevät erillisillä osilla.
• Valitse oikea määrä säikeitä: Optimaalinen säikeiden määrä riippuu käytettävissä olevien suoritinydinten määrästä ja tehtävien luonteesta. Liian monien säikeiden käyttö voi johtaa suorituskyvyn heikkenemiseen kontekstin vaihdon aiheuttaman ylikuormituksen vuoksi. Harkitse säiepoolin käyttöä säikeiden tehokkaaseen hallintaan.
• Optimoi datan paikallisuus: Varmista, että säikeet käyttävät dataa, joka on lähellä toisiaan muistissa. Tämä voi parantaa välimuistin käyttöä ja vähentää muistin käyttöaikoja.
• Käytä sopivia synkronointiprimitiivejä: Valitse oikeat synkronointiprimitiivit sovelluksen tarpeiden mukaan. Mutex-lukot sopivat jaettujen resurssien suojaamiseen, kun taas ehtomuuttujia voidaan käyttää odottamiseen ja signalointiin säikeiden välillä.
• Profilointi ja vertailuanalyysi: Profiloi koodisi tunnistaaksesi suorituskyvyn pullonkaulat. Vertaa eri säiekokoonpanoja ja synkronointistrategioita löytääksesi tehokkaimman lähestymistavan.
• Virheenkäsittely: Toteuta asianmukainen virheenkäsittely hallitaksesi säikeiden epäonnistumisia ja muita mahdollisia ongelmia siististi.
• Muistinhallinta: Ole tietoinen muistin varaamisesta ja vapauttamisesta. Käytä sopivia muistinhallintatekniikoita, erityisesti työskennellessäsi jaetun muistin kanssa.
• Harkitse työntekijäpoolia: Kun käsitellään useita säikeitä, on hyödyllistä luoda työntekijäpooli tehokkuuden vuoksi. Tämä välttää työsäikeiden toistuvan luomisen ja tuhoamisen ja käyttää niitä kiertävästi.

Suorituskykyyn liittyvät näkökohdat ja optimointitekniikat

WebAssembly-säikeiden sovellusten suorituskyvyn optimointi sisältää useita keskeisiä tekniikoita:

• Minimoi tiedonsiirto: Vähennä säikeiden välillä siirrettävän datan määrää. Tiedonsiirto on suhteellisen hidas operaatio.
• Optimoi muistin käyttö: Varmista, että säikeet käyttävät muistia tehokkaasti. Vältä turhia muistikopioita ja välimuistihuteja.
• Vähennä synkronoinnin ylikuormitusta: Käytä synkronointiprimitiivejä säästeliäästi. Liiallinen synkronointi voi kumota rinnakkaisprosessoinnin suorituskykyedut.
• Hienosäädä säiepoolin kokoa: Kokeile eri säiepoolin kokoja löytääksesi optimaalisen kokoonpanon sovelluksellesi ja laitteistollesi.
• Profiloi koodisi: Käytä profilointityökaluja tunnistaaksesi suorituskyvyn pullonkaulat ja optimointikohteet.
• Hyödynnä SIMD (Single Instruction, Multiple Data): Kun mahdollista, hyödynnä SIMD-käskyjä suorittaaksesi operaatioita useille dataelementeille samanaikaisesti. Tämä voi parantaa dramaattisesti suorituskykyä tehtävissä, kuten vektorilaskennassa ja kuvankäsittelyssä.
• Muistin kohdistus: Varmista, että datasi on kohdistettu muistirajoihin. Tämä voi parantaa muistin käyttötehoa, erityisesti joillakin arkkitehtuureilla.
• Lukottomat tietorakenteet: Tutki lukottomia tietorakenteita tilanteisiin, joissa voit välttää lukkoja kokonaan. Nämä voivat vähentää synkronoinnin ylikuormitusta joissakin tilanteissa.

Työkalut ja kirjastot WebAssembly-säikeille

Useat työkalut ja kirjastot voivat virtaviivaistaa kehitysprosessia WebAssembly-säikeiden kanssa:

• Emscripten: Emscripten-työkaluketju yksinkertaistaa C/C++-koodin kääntämistä WebAssemblyksi ja tarjoaa vankan tuen pthreads-säikeille.
• Rust `wasm-bindgen`- ja `wasm-threads`-työkaluilla: Rustilla on erinomainen tuki WebAssemblylle. `wasm-bindgen` yksinkertaistaa vuorovaikutusta JavaScriptin kanssa, ja `wasm-threads`-krate mahdollistaa säikeiden helpon integroinnin.
• WebAssembly System Interface (WASI): WASI on järjestelmärajapinta WebAssemblylle, joka mahdollistaa pääsyn järjestelmäresursseihin, kuten tiedostoihin ja verkkoon, mikä helpottaa monimutkaisempien sovellusten rakentamista.
• Säiepoolikirjastot (esim. `rayon` Rustille): Säiepoolikirjastot tarjoavat tehokkaita tapoja hallita säikeitä, vähentäen säikeiden luomisen ja tuhoamisen ylikuormitusta. Ne myös hoitavat työn jakamisen tehokkaammin.
• Virheenkorjaustyökalut: WebAssemblyn virheenkorjaus voi olla monimutkaisempaa kuin natiivikoodin. Käytä virheenkorjaustyökaluja, jotka on erityisesti suunniteltu WebAssembly-sovelluksille. Selaimen kehittäjätyökalut sisältävät tuen WebAssembly-koodin virheenkorjaukselle ja lähdekoodin läpikäynnille.

Turvallisuusnäkökohdat

Vaikka WebAssemblylla itsellään on vahva turvallisuusmalli, on tärkeää käsitellä turvallisuushuolia WebAssembly-säikeitä käytettäessä:

• Syötteen validointi: Validoi kaikki syötedata huolellisesti estääksesi haavoittuvuuksia, kuten puskurin ylivuotoja tai muita hyökkäyksiä.
• Muistiturvallisuus: Varmista muistiturvallisuus käyttämällä kieliä, joissa on muistiturvallisuusominaisuuksia (esim. Rust) tai tiukkoja muistinhallintatekniikoita.
• Hiekkalaatikointi: WebAssembly toimii luonnostaan hiekkalaatikoidussa ympäristössä, mikä rajoittaa pääsyä järjestelmäresursseihin. Varmista, että tämä hiekkalaatikointi säilyy säikeitä käytettäessä.
• Vähimmän oikeuden periaate: Myönnä WebAssembly-moduulille vain vähimmäisvälttämättömät oikeudet järjestelmäresurssien käyttöön.
• Koodikatselmointi: Suorita perusteellisia koodikatselmuksia tunnistaaksesi mahdolliset haavoittuvuudet.
• Säännölliset päivitykset: Pidä WebAssembly-työkaluketjusi ja kirjastosi ajan tasalla korjataksesi tunnetut tietoturvaongelmat.

WebAssembly-säikeiden tulevaisuus

WebAssembly-säikeiden tulevaisuus on valoisa. Kun WebAssembly-ekosysteemi kypsyy, voimme odottaa lisää edistysaskelia:

• Parannetut työkalut: Kehittyneemmät työkalut, virheenkorjaus- ja profilointityökalut yksinkertaistavat kehitysprosessia.
• WASI-integraatio: WASI tarjoaa standardoidumman pääsyn järjestelmäresursseihin, laajentaen WebAssembly-sovellusten ominaisuuksia.
• Laitteistokiihdytys: Syvempi integrointi laitteistokiihdytyksen, kuten GPU:iden, kanssa lisätäkseen laskentatehokkaiden operaatioiden suorituskykyä.
• Laajempi kielituki: Jatkuva tuki useammille kielille, mikä antaa useammille kehittäjille mahdollisuuden hyödyntää WebAssembly-säikeitä.
• Laajennetut käyttötapaukset: WebAssemblya tullaan käyttämään laajemmin sovelluksissa, jotka vaativat korkeaa suorituskykyä ja monialustaista yhteensopivuutta.

WebAssembly-säikeiden jatkuva kehitys tulee edelleen ajamaan innovaatiota ja suorituskykyä, avaten uusia ovia kehittäjille ja mahdollistaen monimutkaisempien sovellusten tehokkaan toiminnan sekä selaimessa että sen ulkopuolella.

Yhteenveto

WebAssembly-säikeet tarjoavat tehokkaan mekanismin rinnakkaisprosessointiin ja jaettuun muistiin, antaen kehittäjille mahdollisuuden rakentaa korkean suorituskyvyn sovelluksia eri alustoille. Ymmärtämällä WebAssembly-säikeisiin liittyvät periaatteet, parhaat käytännöt ja työkalut, kehittäjät voivat merkittävästi parantaa sovellusten suorituskykyä, reagoivuutta ja skaalautuvuutta. Kun WebAssembly jatkaa kehittymistään, sen on määrä ottaa yhä tärkeämpi rooli web-kehityksessä ja muilla aloilla, muuttaen tapaa, jolla rakennamme ja otamme käyttöön ohjelmistoja maailmanlaajuisesti.

Tämä teknologia mahdollistaa edistyneitä ominaisuuksia käyttäjille ympäri maailmaa – interaktiivisista kokemuksista Saksassa vankkoihin simulaatioihin Yhdysvalloissa, WebAssembly ja säikeet ovat täällä mullistamassa ohjelmistokehityksen.