Amazon Prime usa Rust e WebAssembly

Amazon Prime usa Rust e WebAssembly

Alexandru Ene, principale software engineer di Amazon Prime Video racconta l’esperienza con cui hanno ricostruito la UI SDK del loro prodotto per i dispositivi “living room” utilizzando Rust e WebAssembly.

L’articolo “Amazon Prime usa Rust e WebAssembly” riporta sotto l’intervento di Alex durante la conferenza QCon San Francisco tenutasi il 21 Marzo 2025.

Parleremo delle sfide in questo ambito, ovvero circa i dispositivi da salotto sono come decoder, console di gioco, chiavette per lo streaming, TV. Di solito non si sviluppano interfacce utente per questi dispositivi, che presentano una serie di problemi specifici, quindi in questo articolo “Amazon Prime usa Rust e WebAssembly” verranno analizzate nello specifico. Mostreremo com’era l’ architettura per l’app Prime Video prima di riscrivere tutto in Rust. Esisteva un doppio stack tecnologico con il codice aziendale in React e JavaScript, con inoltre delle parti di basso livello del motore in Rust e WebAssembly, con anche un po’ di C++. Si mostrerà un po’ di codice con il nostro nuovo SDK per l’interfaccia utente in Rust e come appare, che è quello usato attualmente in produzione. Parleremo un po’ di come quel codice funziona con il motore di basso livello esistente e di come è organizzato il tutto. Alla fine, parleremo brevemente dei risultati, delle lezioni apprese.

Sfide in questo ambito – Amazon Prime usa Rust e WebAssembly

L’ambito riguarda i dispositivi da salotto, quindi, come detto sopra, si tratta di console di gioco, chiavette di streaming, decoder. Questi dispositivi presentano problematiche diverse, alcune delle quali sono evidenti. Le differenze di prestazioni sono enormi. Stiamo parlando di una PlayStation 5 Pro, una console di gioco fantastica, con un’ottima potenza, ma anche di una chiavetta di streaming USB. Con Prime Video, viene eseguita la stessa applicazione su tutti questi tipi di dispositivi. Ovviamente, le prestazioni sono molto importanti per Amazon Prive Video. Non i può avere un team per tipo di dispositivo, ovvero un team che si occupa di decoder, poi un altro team che si occupa di console di gioco ecc. , perché in quel caso tutto esplode. Quando si sviluppa una funzionalità, bisogna svilupparla per ogni dispositivo. In questo caso si sviluppava le cose una volta e poi si distribuiscono su tutte queste categorie di dispositivi. Amzon non distribuisce questa applicazione di cui parliamo su dispositivi mobili, come iPhone, iOS, i dispositivi mobili non hanno questa funzionalità. Si tratta solo di dispositivi da salotto (dispositivi “living room”). Ci sono una gamma enorme di prestazioni all’interno dell’applicativo che deve girare su dispositivi diversi.

Di solito, il codice ad alte prestazioni è quello compilato in modo nativo. Diciamo Rust compilato in modo nativo, C++ compilato in modo nativo, ma in questo caso non è sufficiente e vedremo perché. Un altro punto dolente sono le capacità hardware tra questi dispositivi. Come sviluppatori di SDK, si deve riflettere attentamente su quali siano i fallback ragionevoli ed a quali comportamenti dell’app gli sviluppatori non devono tenere conto quando scrivono quel codice. Oltre ad ogni piccola differenza hardware dei dispositivi. Si cerca quindi di avere delle impostazioni predefinite ragionevoli. Non è sempre possibile, quindi si utilizzano modelli come feature flag e simili per consentire loro di avere un po’ più di controllo. È un lavoro piuttosto impegnativo.

Un altra sfida di Amazon Prime è il tentativo di rendere questa applicazione il più veloce possibile e con il maggior numero di funzionalità possibile per ogni cliente, ma aggiornare il codice nativo su questi tipi di dispositivi è davvero difficile. In parte perché la maggior parte di questi dispositivi non hanno nemmeno un app store. Forse si verifica con un aggiornamento del firmware. È un problema (Amazon Prime usa Rust e WebAssembly).

Tutto ciò richiede un processo manuale che interagisce con una terza parte proprietaria della piattaforma. Anche dove c’è un app store, se si tenta di aggiornare un’app da un app store, è comunque una bella sfida. È molto probabile che si tratti di un processo manuale. Esiste questa tensione tra il codice che scarichiamo over-the-air, come JavaScript, WebAssembly e così via, e il codice che funziona su un dispositivo che è molto veloce, ma che poi è davvero difficile da aggiornare. Il team Amazon Prima lavoro per ottenere un ciclo di iterazione rapido. Aggiornare l’app in tempi brevi è fondamentale per il team.

Di seguito le parole di Alexandru Ene. – Amazon Prime usa Rust e WebAssembly

Ecco come si presenta oggi l’applicazione. Sono lì da otto anni e l’abbiamo modificata molte volte. Sono sicuro che cambierà ancora, come succede con le interfacce utente. Abbiamo aggiunto cose come canali, eventi live e ogni sorta di nuove funzionalità che non erano presenti nella versione iniziale. Parte del successo di questo progetto è dovuto all’attenzione all’aggiornabilità che avevamo fin dall’inizio. La maggior parte di queste applicazioni era in un linguaggio come JavaScript, con cui potevamo modificare praticamente tutto e aggiungere tutte queste funzionalità quasi senza bisogno di intervenire sul codice nativo di basso livello. Vi mostrerò l’architettura e il suo aspetto.

Oggi, se uno sviluppatore aggiunge del codice, modifica una funzionalità, corregge un bug, apporta modifiche all’interfaccia utente, quel codice passa attraverso una pipeline di CI/CD completa, senza alcun test manuale. Eseguiamo test su dispositivi virtuali come Linux e su dispositivi fisici, dove disponiamo di una “device farm”. Una volta superati tutti questi test, la nuova esperienza è disponibile sulla TV del soggiorno. È molto più veloce di un aggiornamento di un’app nativa per quella piattaforma.

In questo momento, lo vedrete funzionare e vedrete un paio di funzionalità. Questi sono un gruppo di profili di test che stavo creando perché stavo testando delle cose. Abbiamo cose come l’animazione del layout, quindi l’intero layout viene ricalcolato. Questa è l’app Rust in produzione oggi. Le animazioni del layout erano una cosa che prima era impossibile con JavaScript e React, e ora funzionano. Quando vedete questa cosa ingrandirsi, tutti gli elementi vengono riordinati sulla pagina. Queste sono cose che sono possibili in questo momento grazie alle prestazioni di Rust. Anche le transizioni di pagina quasi istantanee sono cose che non erano possibili con TypeScript e React a causa di vincoli di prestazioni. Questo è live oggi ed ecco come appare, quindi avrete un’idea di cosa sta succedendo lì dentro. Torneremo un po’ sulle animazioni del layout e su queste cose più tardi. Per chi non è un UI engineer, o non lo sa bene, questa è la diapositiva che vi insegnerà tutto ciò che dovete sapere sulla programmazione dell’interfaccia utente.

In pratica, ogni interfaccia utente è un albero di nodi, e il compito di un SDK UI è manipolare questo albero il più velocemente possibile in risposta agli input dell’utente o a eventi che si verificano, come ad esempio determinati eventi. Si modificano le proprietà dei nodi, ad esempio animando un valore come una posizione, e il motore dell’interfaccia utente deve quindi occuparsi di aggiornare questo albero, creare nuovi nodi ed eliminarne di nuovi, a seconda di ciò che il codice della logica di business richiede. Questi nodi potrebbero essere nodi di visualizzazione, che magari sono semplicemente rettangoli. Poi, i nodi di testo sono piuttosto comuni, e i nodi di immagine, cose del genere. Niente di troppo complicato. È davvero fastidioso che sia un albero, ma andremo avanti perché abbiamo ancora un albero, anche nella nostra app Rust non abbiamo apportato innovazioni in quel senso, ma è importante avere questo modello mentale. Nel nostro motore dell’interfaccia utente lo chiamiamo albero di scena, i browser lo chiamano DOM, ma è fondamentalmente la stessa cosa ovunque.

Architettura di alto livello – Amazon Prime usa Rust e WebAssembly

Questa è l’architettura di alto livello prima di riscrivere tutto in Rust. Come potete vedere, abbiamo già aggiunto Rust, credo due o tre anni fa, lo avevamo già per il motore di interfaccia utente di basso livello. C’è un articolo di QCon su questo percorso. C’è un’altra parte che parla di JavaScript, ma in realtà gli sviluppatori scrivono TypeScript, che contiene il codice della logica di business per l’app Prime Video. Questo è il materiale che scarichiamo. Viene scaricato ogni volta che l’applicazione cambia. Questo è il risultato finale di quella pipeline CI/CD completa. È un bundle che contiene codice Rust compilato tramite WebAssembly e JavaScript proveniente da TypeScript e trascritto in JavaScript. Cambia forse una volta al giorno, a volte anche di più, a volte di meno, a seconda delle nostre pipeline e del superamento o meno dei test, ma viene aggiornato molto frequentemente su tutti i dispositivi di cui ho parlato, le categorie di dispositivi.

Poi abbiamo il materiale sul dispositivo nella nostra architettura. Cerchiamo di mantenerlo il più snello possibile perché è davvero difficile da aggiornare, quindi meno tocchiamo questo codice, meglio è. Ha un paio di macchine virtuali, un backend di rendering, che principalmente collega il materiale di livello superiore che scarichiamo a cose come OpenGL e altre API grafiche, e al networking. Questo è fondamentalmente cURL. Alcune API multimediali, storage e un sacco di altre cose, ma sono in C++. Le implementiamo su un dispositivo e rimangono lì praticamente intatte, a meno che non ci sia un bug critico da risolvere o qualche problema più complesso. È così che funzionano le cose oggi (Amazon Prime usa Rust e WebAssembly).

App Prime Video (prima) con React e WebAssembly – Amazon Prime usa Rust e WebAssembly

Potreste chiedervi, però, se si tratti di due macchine virtuali separate e come funzionino effettivamente insieme. Faremo un esempio di come funzionavano le cose in precedenza con questo stack tecnologico. L’app Prime Video qui prende decisioni di alto livello, come cosa mostrare all’utente, magari dei caroselli, magari disporre alcuni elementi sullo schermo. Supponiamo, in questo esempio, che voglia mostrare un’immagine sulla TV. L’app Prime Video è sviluppata con React. La chiamiamo React-Livingroom perché è una versione di React che abbiamo modificato e reso utilizzabile per i dispositivi da salotto abbinando alcune funzionalità, semplificandole e scrivendo anche alcuni riconciliatori, perché abbiamo questa applicazione che funziona su questo tipo di architettura, ma anche nei browser, perché alcuni dispositivi da salotto oggi hanno solo un browser HTML5 e non hanno nemmeno spazio flash abbastanza grande per installare il nostro motore C++ nativo. Avevamo bisogno di quell’astrazione del dispositivo qui. L’app Prime Video dice: “Voglio inserire un nodo immagine”. Utilizza React-Livingroom come SDK UI.

Attraverso il livello di astrazione del dispositivo, scopriamo di avere a disposizione una VM WebAssembly (Amazon Prime usa Rust e WebAssembly). A quel punto, invece di svolgere il lavoro vero e proprio, codifica semplicemente un messaggio e lo inserisce in un bus di messaggi. Si tratta letteralmente di un comando che dice: “Crea un nodo immagine con un ID, un URL da cui scaricare l’immagine, alcune proprietà come altezza e posizione e l’ID padre per inserirlo in quell’albero di scene”. La VM WebAssembly ha il motore, e questo motore ha componenti di basso livello che gestiscono effettivamente quell’albero di scene di cui abbiamo parlato.

Ad esempio, il gestore di scene e risorse capirà che c’è un nuovo messaggio. Devo creare un nodo e inserirlo nell’albero. È un nodo immagine, quindi controlla se l’immagine è disponibile o meno. Invia una richiesta di download. Forse anima alcune proprietà, se necessario. Una volta scaricata, l’immagine viene decodificata, caricata nella memoria della GPU e, successivamente, il rendering di alto livello, dall’albero della scena che potrebbe essere piuttosto grande, determina quale sottoinsieme di nodi è visibile sullo schermo e quindi invia i comandi, il livello C++, che usa il grigio, per disegnare i pixel sullo schermo. Alla fine, avrete l’immagine di The Marvelous Mrs. Maisel lì, come dovrebbe essere.

Funzionava così prima. Quando abbiamo aggiunto Rust, abbiamo ottenuto enormi miglioramenti nella fluidità delle animazioni e in altri aspetti simili. Tuttavia, aspetti come la latenza di input non sono migliorati del tutto, quindi la latenza di input è fondamentalmente il tempo che intercorre tra la pressione di un pulsante sul telecomando, nel nostro caso, e la risposta dell’applicazione all’input. Questo è ciò che chiamiamo latenza di input. Non è migliorato molto o per niente perché, in sostanza, tutte quelle decisioni e tutta quella logica di business, come ciò che accade in risposta a un evento di input nell’albero delle scene, è in JavaScript. È un linguaggio piuttosto lento, soprattutto perché alcuni di questi hardware possono essere, ad esempio, dispositivi dual-core con nemmeno 1 gigahertz di velocità di CPU e poca memoria.

In realtà, sono medie. Ne abbiamo alcune che sono ancora più lente, quindi eseguire JavaScript su queste richiede molto tempo. Volevamo migliorare questa latenza di input e alla fine ci siamo riusciti, ma ci siamo ritrovati con questa architettura. Il motore è più o meno lo stesso, tranne per il fatto che abbiamo aggiunto alcuni sistemi specifici per questa applicazione. Ad esempio, la gestione del focus e il motore di layout ora fanno parte del motore. Non l’ho inserito in questa diapositiva perché riguarda la gestione delle scene. Inoltre, abbiamo creato un nuovo SDK per l’interfaccia utente in Rust che poi utilizziamo per compilare l’applicazione. Ora tutto è in Rust. È un unico linguaggio. Non c’è nemmeno bisogno di preoccuparsi del bus dei messaggi. Non era nemmeno così lento, comunque. Era quasi istantaneo. Il problema era JavaScript, quindi non lo abbiamo più. In realtà non siamo ancora arrivati ​​a questo punto perché lo stiamo distribuendo in modo iterativo, pagina per pagina, perché volevamo renderlo disponibile più velocemente ai clienti, ma ci arriveremo all’inizio del prossimo anno.

Codice dell’interfaccia utente che utilizza il nuovo SDK dell’interfaccia utente Rust – Amazon Prime usa Rust e WebAssembly

Sarà un po’ impegnativo, ma ecco del codice UI con Rust, e questo è effettivamente codice UI funzionante supportato dal nostro SDK UI. Vi guiderò passo passo perché ci sono alcuni concetti che ritengo importanti. Quando si tratta di programmazione UI, Rust non è noto per avere molte librerie, e quindi l’ecosistema non è proprio completo. Abbiamo dovuto crearne uno nostro. Abbiamo usato alcune idee di Leptos, come i segnali di cui parlerò, ma ecco come si presentano le cose oggi. Se avete familiarità con React e SolidJS e simili, vedrete alcune cose familiari qui.

Innanzitutto, potresti notare che la macro Composer qui sopra si collega a questa funzione che restituisce un elemento componibile. Un elemento componibile è un elemento riutilizzabile di un albero, una gerarchia di nodi che possiamo collegare ad altri elementi riutilizzabili e comporre, in pratica, insieme. Questo è il nostro modo di riutilizzare l’interfaccia utente. Questa macro Composer in realtà non fa molto, se non generare codice boilerplate che ci fornisce funzionalità più interessanti nella macro Compose che vedi più avanti nella funzione. Ci permette di avere argomenti denominati, messaggi di errore più accattivanti e argomenti opzionali che potrebbero mancare per le funzioni.

Questa è una cosa che migliora la qualità della vita. In questo modo i nostri sviluppatori non hanno bisogno di specificare ogni argomento per queste funzioni, come questa funzione hello qui che accetta semplicemente un nome come stringa. In questo caso, il nome è obbligatorio, ma possiamo avere argomenti facoltativi con valori opzionali che non è necessario specificare. Inoltre, è possibile specificare gli argomenti in qualsiasi ordine, purché vengano nominati, e lo vedremo più avanti. È davvero una cosa fantastica che migliora la qualità della vita. Vorrei che Rust lo supportasse fin dall’inizio per le funzioni, ma non lo fa, quindi eccoci qui.

Quindi, questo è il principio fondamentale del nostro UI SDK. Utilizza segnali ed effetti. Il segnale è un valore speciale, quindi questo nome qui ombreggerà la stringa sopra. In pratica, questo nome è un segnale, e questo significa che quando cambia, attiverà gli effetti che lo utilizzano. Ad esempio, quando questo nome cambia, eseguirà la funzione in questo memo, che è un segnale speciale, e creerà un nuovo messaggio di saluto con il nuovo valore a cui è stato impostato il nome. Esegue la funzione che vedi qui. La formatta. La concatena e restituirà qualcosa come “Ciao Billy”, o qualcosa del genere. Quindi il messaggio di saluto è un segnale speciale che attiverà anche degli effetti. Qui vedi in questa funzione, usiamo il messaggio di saluto.

Ogni volta che il messaggio di benvenuto viene aggiornato, verrà attivato questo effetto che qui chiamiamo “create effect”. Questo è molto simile al funzionamento di SolidJS o, se avete familiarità con React, di React. In realtà, questo è piuttosto importante perché è anche ciò che aiuta gli ingegneri dell’interfaccia utente a essere produttivi in ​​questo framework senza dover conoscere Rust in modo approfondito. Il cuore del nostro motore di interfaccia utente è costituito da segnali, effetti e memo, che sono segnali speciali che attivano gli effetti solo se i valori a cui sono stati aggiornati sono diversi dal valore precedente. Di default, attivano comunque l’effetto.

Poi, abbiamo quest’altra macro qui, che è la macro compose, che fa il grosso del lavoro. È qui che si definisce l’aspetto della gerarchia dell’interfaccia utente. Qui abbiamo una riga che poi ha dei figli, che sono nodi etichetta. Come potete vedere, l’etichetta ha un testo che può essere un valore hardcoded con tre punti esclamativi come stringa, oppure può accettare un segnale che racchiude una stringa. La prima etichetta qui verrà aggiornata ogni volta che il messaggio di benvenuto viene aggiornato. Senza che l’ingegnere dell’interfaccia utente intervenga, avviene automaticamente che il messaggio di benvenuto venga aggiornato, l’etichetta stessa visualizzerà il nuovo testo e tutto funziona. Se siete un ingegnere dell’interfaccia utente, questo è il codice che scrivete. È abbastanza facile da capire una volta capito il concetto. Ecco alcuni esempi, ad esempio, ChannelCard e MovieCard sono solo alcune altre funzioni che consentono di passare parametri come un nome, una main_texture, e magari un titolo, una main_texture e così via.

Di nuovo, potrebbero avere parametri opzionali che non vedi qui (Amazon Prime usa Rust e WebAssembly). Puoi anche inserire dei segnali al posto di quei valori hardcoded. Non importa molto, è solo che saranno fratelli di quelle due etichette. In fondo abbiamo un pulsante con un testo, che dice “Click”. Poi ha alcune callback su “select”, “on click” e cose del genere, che sono funzioni che vengono attivate ogni volta che si verificano quegli eventi nel motore dell’interfaccia utente. Ad esempio, ogni volta che selezioniamo questo pulsante, impostiamo un segnale. Quel nome viene impostato su un nuovo nome. Questo attiva una cascata di azioni, il messaggio di “hello” viene aggiornato a “hello new name”. Quindi, gli effetti vengono attivati ​​perché si tratta di un nuovo valore, quindi verrà visualizzato.

Infine, la prima etichetta che vedete qui verrà aggiornata con un nuovo valore. Infine, questa riga ha proprietà o modificatori, quindi possiamo modificare il colore di sfondo. In questo caso, è semplicemente impostato su un valore fisso di blu. Tuttavia, supportiamo anche il passaggio di segnali qui. Se avete un colore, questo è un segnale di un colore. Ogni volta che viene impostato, magari tramite un timer o altro, il colore del nodo viene aggiornato e lo passate qui esattamente come abbiamo impostato questo parametro. Questo è un altro modo potente per ottenere comportamenti o effetti come conseguenza della logica di business che si verifica nel codice dell’interfaccia utente. Questo è ciò di cui si occupano i vostri ingegneri, ed è di livello piuttosto alto, ed è molto simile ad altri motori di interfaccia utente, ma questa volta è in Rust.

Quando eseguiamo la macro di composizione, ecco come apparirà la gerarchia dell’interfaccia utente nell’albero della scena. C’è la riga, a cui è associata un’etichetta. Le etichette sono speciali perché sono widget. I componibili possono essere creati a partire da widget, che sono componibili speciali forniti dal nostro SDK di interfaccia utente agli ingegneri, o da altri componibili che alla fine vengono creati a partire da widget. I widget vengono quindi creati a partire da una serie di componenti. Questo è piuttosto importante perché utilizziamo sistemi di componenti entità. Per ora, i componenti possono essere considerati strutture senza comportamento, quindi solo dati senza alcun comportamento. Il comportamento deriva dai sistemi che operano su questi componenti.

In questo caso, l’etichetta ha un componente di layout che supporta il sistema di layout (Amazon Prime usa Rust e WebAssembly). Un componente di base, diciamo che ha una posizione, una rotazione, cose del genere. I componenti RenderInfo, questi sono tutti i dati necessari per posizionare i pixel sullo schermo per questo widget una volta che tutto è stato elaborato. Un componente di testo, che gestisce il layout del testo e cose del genere. Forse un componente di cache di testo che viene utilizzato per memorizzare nella cache il testo nella texture in modo da non doverlo disegnare lettera per lettera.

L’aspetto importante è che i widget sono speciali perché vengono forniti come elementi componibili predefiniti dal nostro SDK UI. Inoltre, gli elementi componibili possono essere creati a partire da altri elementi componibili. Questa riga ha alcuni elementi figlio, ma alla fine deve avere dei widget come nodi foglia perché sono quelli che effettivamente hanno il comportamento di base. Qui, ad esempio, abbiamo un pulsante e un’altra immagine, e il pulsante ha, fino in fondo, un componente di focus. Questo ci permette di impostare il focus sul pulsante, che viene utilizzato automaticamente dal sistema. Il componente immagine, ancora una volta, memorizza solo un URL e forse lo stato, se è stato scaricato, caricato sulla GPU e così via. È abbastanza semplice. In pratica, questa architettura nel nostro motore di basso livello viene utilizzata per gestire la complessità del comportamento. Vedremo più avanti come funziona. Poi avevamo un’altra Movie Card in quell’esempio e, ancora una volta, alla fine deve essere creata a partire da widget.

I widget sono gli elementi che il nostro SDK UI fornisce agli sviluppatori di interfacce utente già pronti all’uso. Possono essere righe, colonne, immagini, etichette, stack, rich text, ovvero nodi di testo speciali che consentono di incorporare immagini e cose del genere. Stack, elenco di righe ed elenco di colonne sono scorrevoli sia orizzontalmente che verticalmente. Credo che abbiamo aggiunto la griglia di recente perché ci serviva per qualcosa, ma in pratica la sviluppiamo man mano che sviluppiamo l’app. È ciò che supportiamo ora. Credo che anche il pulsante sia supportato fin da subito, ma per qualche motivo non l’ho inserito. Ogni widget è un ID entità. Ha un ID e una raccolta di componenti. Quindi, il motore di livello inferiore utilizza i sistemi per modificare e aggiornare i componenti. ECS è questo sistema di componenti entità. È un modo per organizzare il codice e gestire la complessità senza spendere troppo in termini di prestazioni. È stato utilizzato dai motori di gioco, non molto, ma ad esempio, Overwatch lo usava.

Thief, credo, sia stato il primo gioco del 1998 a usarlo come quiz. È un’idea molto semplice: ci sono entità, che sono semplicemente ID che mappano i componenti. Ci sono componenti che sono dati senza comportamento. Poi ci sono i sistemi, che sono fondamentalmente funzioni che agiscono su tuple di componenti. Agiscono sempre su più cose contemporaneamente, non su una cosa alla volta. È un po’ diverso dagli altri paradigmi. Creare un comportamento è davvero utile, perché se si desidera un certo comportamento per un’entità, basta aggiungere il componente e poi i sistemi che lo richiedono funzioneranno automaticamente perché il componente è lì.

Ecco come potrebbe funzionare in un ciclo di gioco (Amazon Prime usa Rust e WebAssembly). Ad esempio, questi sistemi si trovano sul lato sinistro e i componenti sul lato destro. Quando parlo di componenti, potete immaginarli come array e gli ID delle entità come indici in quegli array. È un po’ più complicato di così, ma in pratica è così. Quindi gli elementi sul lato sinistro con l’elemento giallo, quelli sono sistemi, e sono fondamentalmente funzioni che operano su quegli array contemporaneamente. Supponiamo che il sistema di gestione delle risorse debba interagire con i componenti di base, i componenti dell’immagine e leggerli. Questa lettura avviene tramite la freccia bianca e scriverà nei componenti RenderInfo. Ad esempio, cercherà dove si trova l’immagine: se è vicina allo schermo, guarderà il componente di base. Guarderà il componente dell’immagine che contiene l’URL. Controllerà lo stato dell’immagine presente. È stata scaricata? È stata caricata sulla GPU? Se è stata decodificata e caricata sulla GPU, aggiorniamo i componenti RenderInfo in modo da poterla disegnare in seguito sullo schermo.

Per questo sistema, è necessario avere almeno tutti e tre i componenti su un’entità. È possibile averne di più, ma li ignoriamo. Non ci interessa. Questo sistema esamina solo quella porzione di oggetto, ovvero i componenti base, i componenti immagine e i componenti RenderInfo. È necessario averli tutti e tre. Se ne hai solo due senza il terzo, quell’entità non viene toccata da questo sistema e non fa nulla, il widget di sistema. Poi abbiamo il sistema di layout. Naturalmente, questo esamina un gruppo di componenti e ne aggiorna uno alla fine. È piuttosto complicato, ma il layout è complicato comunque. Almeno quella complicazione e quella complessità risiedono in un file o in una funzione. Dalla firma si capisce che questo legge da un milione di cose, scrive in una, ma è quello che è. Non si possono costruire sistemi di layout senza toccare tutti questi elementi. Forse abbiamo un componente di cache di testo che esamina i componenti di testo e scrive in un gruppo di altre cose.

Di nuovo, è necessario disporre di tutti e tre questi elementi per un’entità che venga aggiornata da questo sistema. Alla fine, abbiamo il sistema di rendering che esamina i componenti RenderInfo e li legge. Non scrive da nessuna parte perché non ha bisogno di aggiornare alcun componente. Si limita a chiamare le funzioni nel codice C++ nel backend del rendering per visualizzare gli elementi sullo schermo. Legge semplicemente i dati e aggiorna lo schermo con nuovi pixel. Sembra complicato, ma è un modo molto semplice per organizzare il comportamento. Questo ha dato i suoi frutti organizzando la nostra architettura di basso livello in questo modo per motivi che vedremo più avanti, come e perché. Non solo per la nuova applicazione, ma anche per la vecchia applicazione, perché entrambe utilizzano lo stesso motore di basso livello.

Tornando all’architettura, ecco cosa abbiamo: l’app Prime Video in cima. Abbiamo visto come gli sviluppatori scrivono l’interfaccia utente con elementi componibili utilizzando il nostro SDK UI. Poi abbiamo visto come l’SDK UI utilizza widget che vengono poi aggiornati dai sistemi e hanno componenti definiti nel motore di basso livello. Anche questo viene scaricato. Ogni volta che scriviamo nuovo codice, questo passa attraverso una pipeline, viene compilato in WebAssembly e poi lo eseguiamo sul vostro decoder, o su qualsiasi cosa abbiate in salotto. Poi abbiamo il codice di basso livello che interagisce con il dispositivo, che cerchiamo di mantenere il più piccolo possibile. Questo è ciò che abbiamo distribuito, credo, a fine agosto. È disponibile oggi.

Gli aspetti positivi – Amazon Prime usa Rust e WebAssembly

La produttività degli sviluppatori, in realtà, è stata fantastica per noi. In precedenza, quando abbiamo riscritto il motore, avevamo un gruppo di sviluppatori che conoscevano C++ e che erano passati a Rust, e abbiamo ottenuto buoni risultati. In questo caso, abbiamo trasferito a Rust persone che conoscevano solo JavaScript e TypeScript, e che conoscevano solo programmi come React e quei framework. Li abbiamo trasferiti con il nostro SDK UI di Rust senza alcuna perdita di produttività. Questo è sia autodichiarato che confrontato. Ogni volta che sviluppiamo una funzionalità, abbiamo altri client che non la usano, quindi, ad esempio, come il client mobile o il client web e così via. Il client Rust, in realtà, quando discutevamo di alcune nuove funzionalità da sviluppare ora su tutti i client, era, credo, il secondo in termini di velocità, dopo il web. Quindi anche gli sviluppatori mobile avevano stime più alte delle nostre. Inoltre, abbiamo completato l’intera riscrittura in un tempo davvero breve. Dovevamo essere produttivi. Abbiamo sviluppato l’SDK UI e gran parte dell’app abbastanza velocemente.

Il motivo per cui penso che questo sia vero è perché abbiamo lavorato molto in ambito di sviluppo con quelle macro che forse possono sembrare un po’ scioccanti se non si conosce la programmazione dell’interfaccia utente, ma in realtà sono risultate molto familiari agli ingegneri dell’interfaccia utente. Potevano lavorarci subito, non dovevano gestire troppa complessità nel controllo dei prestiti. Di solito, nel codice dell’interfaccia utente, si possono clonare elementi se necessario, o persino usare un codice RC e cose del genere. Sapete tutti che non è proprio la soluzione ottimale. Sì, proveniamo da JavaScript, quindi va bene, ve lo prometto. I pezzi più complessi sono nel motore, e lì ci preoccupiamo molto della gestione dei dati, della memoria e così via. Nel codice dell’interfaccia utente, possiamo permettercelo facilmente. Anche sull’hardware di livello più basso, ho alcune slide che vi mostreranno l’impatto di questo.

Un’altra cosa nell’SDK, come team SDK e motore, è che abbiamo scelto alcuni vincoli che ci hanno aiutato a creare un SDK UI più semplice e a rilasciarlo più velocemente. Ad esempio, un vincolo del nostro motore UI, che potrei mostrarvi, è che quando definite un’etichetta o un widget o qualcosa del genere, non potete leggerne le proprietà a meno che non siate stati voi a impostarle. È impossibile leggere in quale punto dello schermo finisce un elemento dopo il layout dal codice UI. Non si sa mai. Li inserite e basta. Calcoliamo le cose nel motore, ma non potete leggerle a meno che non siate stati voi a dire: “Questo è il tuo colore, il blu”. Allora dite: “Sì, è nella mia variabile”. Posso leggerlo, ovviamente. Cose del genere, voi non potete leggerle. Questo ha semplificato enormemente la nostra architettura UI e non dobbiamo occuparci di un sacco di cose, con la conseguente lentezza. Sembra una cosa scioccante. Forse avete bisogno di sapere in quale punto dello schermo. No, non lo dovete sapere, perché l’abbiamo rilasciato.

Non c’era bisogno di sapere dove ci si trovava sullo schermo, né di leggere una proprietà non impostata. In alcuni casi, avvisiamo gli sviluppatori dell’interfaccia utente tramite callback, che consentono loro di associare una funzione e ricevere una notifica se accade qualcosa. È molto raro. Di solito accade in caso di gestione del focus e cose del genere. Si riceve una chiamata di funzione che indica che si è focalizzati, che non lo si è più, e funziona perfettamente. Di nuovo, è un compromesso. Per noi ha funzionato perfettamente. È un aspetto che credo abbia anche migliorato la produttività. Abbiamo avuto solo un caso in cui gli sviluppatori hanno chiesto di leggere un valore di layout perché volevano che qualcosa crescesse, e forse al 70% del processo, volevano che accadesse qualcos’altro. Bastava usare un timer e il problema si risolveva.

Un altro aspetto positivo è che abbiamo distribuito questo prodotto in modo iterativo. Questo perché, a mio avviso, abbiamo utilizzato sistemi di componenti entità come base del nostro motore di livello inferiore. Quel motore di livello inferiore, con i sistemi e i componenti che ha, attualmente supporta pagine JavaScript. Per pagine, intendo che tutto ciò che appare sullo schermo è in Rust o che tutto ciò che appare sullo schermo è in JavaScript. Ad esempio, abbiamo distribuito la pagina dei profili, che è la pagina in cui si seleziona il profilo. La pagina delle raccolte, che è la pagina subito dopo aver selezionato il profilo e dove si vedono tutte le categorie, tutti i film e tutto il resto. La pagina dei dettagli, che, una volta scelto qualcosa da guardare, si può andare lì e vedere magari gli episodi o semplicemente maggiori dettagli sul film, e premere play. Dobbiamo ancora spostare la pagina di ricerca, le impostazioni e un sacco di altre pagine più piccole. Sono ancora in JavaScript. È un lavoro in corso, quindi le stiamo solo spostando. È solo una questione di tempo. Abbiamo solo 20 persone sia per l’SDK dell’interfaccia utente che per l’applicazione. Ci vuole un po’ per spostare tutto. È solo questione di tempo.

Un altro motivo è che è solo un lavoro in corso. Pensiamo che sia stato un buon risultato. Quel sistema di componenti entità è riuscito perfettamente a far funzionare questi due elementi fianco a fianco. Non credo che abbiamo avuto un solo bug a causa di questo. Abbiamo dovuto solo fare un po’ di lavoro extra per sincronizzare un po’ di stato tra queste cose, come lo stack che si usava per tornare indietro, lo stack di back e cose del genere, ma alla fine ne è valsa la pena. Siamo riusciti a completarlo molto velocemente. In realtà abbiamo prima rilasciato la pagina dei profili, poi abbiamo aggiunto la pagina delle raccolte, poi la pagina dei dettagli, poi live e lineare e così via. Ottimo.

Un altro aspetto positivo è che, a mio parere, abbiamo creato degli strumenti durante la creazione di questo SDK UI. Dato che avevamo creato un SDK, dovevamo creare degli strumenti. Credo che una mossa vincente in questo caso sia stata la facilità con cui nel nostro codice base è possibile aggiungere un nuovo strumento, soprattutto perché usiamo egui, ovvero la libreria Rust per l’interfaccia utente in modalità immediata. Come potete vedere, il gestore delle risorse appare semplicemente sopra l’interfaccia utente. È qualcosa che uno sviluppatore ha creato perché stava eseguendo il debug di un problema relativo al mancato caricamento di una texture e stava cercando di capire quanta memoria abbiamo a disposizione. È un problema di memoria? Il gestore delle risorse forse non ha fatto qualcosa di corretto. Ha semplicemente semplificato la creazione degli strumenti. Abbiamo creato gli strumenti parallelamente alla creazione dell’applicazione e dell’SDK UI.

In realtà, queste sono ben al di sotto di quanto ci si aspetterebbe da browser e simili, ma con letteralmente il 20% degli strumenti, si ottiene l’80%. È assolutamente vero. Servono principalmente le basi. Certo, abbiamo un debugger e cose del genere che funzionano, ma questi sono strumenti specifici per l’interfaccia utente. Abbiamo ispettori di layout e un sacco di altre cose, così si può capire se si imposta la proprietà sbagliata. Un’altra cosa interessante, a mio parere, è che abbiamo creato questo, che è essenzialmente una riscrittura dell’intera app Prime Video. Ovviamente, siamo contrari a queste cose senza molti dati. Una cosa che ci ha davvero aiutato a dimostrare che ne valeva la pena è stata la creazione di un prototipo che non barasse, che abbiamo mostrato ai dirigenti, questa è la sensazione sul dispositivo prima di quello che abbiamo fatto, e questa è con questa nuova funzionalità.

Letteralmente, funzionalità che prima erano impossibili, come le animazioni del layout, ora sono semplicemente super facili da realizzare. Vedete, le cose crescono, il layout funziona, riorganizza tutto. Le cose appaiono e scompaiono. Di nuovo, questa è un’animazione del layout. Certo, si tratta di arte da programmatore, ma non ha nulla a che fare con i designer. Stiamo solo mostrando le capacità di un dispositivo. Come potete vedere, le cose sono sopra e sotto le icone, è solo un prototipo, ma sembrava molto più bello e reattivo rispetto a quello che si poteva ottenere su un dispositivo che ha convinto immediatamente le persone che valeva la pena rischiare di costruire un’interfaccia utente in Rust e WebAssembly. Perché anche se abbiamo aggiunto Rust e faceva parte del nostro stack tecnologico, lo stavamo usando per parti di basso livello, ma questo ci ha dimostrato che possiamo correre il rischio e provare a costruire un’interfaccia utente al suo interno.

Ecco alcuni risultati. Si tratta di un dispositivo di fascia bassa, dove la latenza di input per la pagina principale, per la pagina di raccolta, era di soli 247 millisecondi, 250 millisecondi, una latenza di input orribile, con il colore arancione, questo è in JavaScript. Con Rust in blu, 33 millisecondi, facile. Allo stesso modo, la pagina dei dettagli, 440 millisecondi. Questo include anche il tempo di layout, perché se si preme un pulsante mentre la pagina si carica e si esegue il layout, si potrebbe attendere così tanto. Questo è il massimo. Il dispositivo è molto lento. Di nuovo, 30 millisecondi, perché le animazioni del layout implicano che dobbiamo eseguire il layout alla stessa velocità di un fotogramma di animazione, che di solito è di 16 millisecondi o 30 millisecondi a 30 FPS. È molto più veloce e molto più reattivo. Di nuovo, quella linea è praticamente piatta. Era fantastico. Altri dispositivi si sono avvicinati a queste due linee, ma ho scelto questo esempio perché dimostra davvero che anche sul dispositivo di fascia bassa si possono ottenere ottimi risultati. I dispositivi medi erano circa 70 millisecondi, poi sono scesi a 16 o 33, ma questo è il peggiore di tutti. Ce l’abbiamo.

Gli aspetti negativi – Amazon Prime usa Rust e WebAssembly

L’interfaccia di sistema di WebAssembly è piuttosto nuova. WebAssembly in generale è piuttosto nuovo. Facciamo parte della comunità W3C. Stiamo lavorando con loro su funzionalità, cose del genere. Ci sono alcune cose che mancano. Ad esempio, abbiamo aggiunto thread, ma ci sono anche cose che accadono nell’ecosistema che a volte interrompono il nostro codice perché usiamo qualcosa che non è completamente standardizzato in produzione da un po’ di tempo. Un esempio di questo tipo è stato di recente Rust 1.82, che ha abilitato alcune funzionalità di default per le build WASI di WebAssembly, che sostanzialmente non funzionavano sulle vecchie macchine virtuali WebAssembly che avevamo in produzione. Ora abbiamo sostanzialmente un modo per disabilitarle, anche se si ha una nuova impostazione predefinita e cose del genere. Per noi ne vale la pena. È qualcosa su cui riflettere.

Inoltre, l’interfaccia di sistema di WebAssembly continua a evolversi e ad aggiungere nuove funzionalità, e stiamo cercando di essere parte attiva anche in questo sforzo. Richiede un impegno ingegneristico. Non possiamo semplicemente prendere una dipendenza, o specificamente su WebAssembly, e dire, vediamo dove va a parare. È necessario essere coinvolti e contribuire con feedback, lavorando sulle funzionalità e così via. Un altro problema che abbiamo scoperto è che scrivere codice senza errori è davvero difficile. Certo, le eccezioni dovrebbero essere per cose eccezionali, ma non è così che si scrive JavaScript. Quando il codice va in errore nella nostra nuova app Rust, l’intera app viene praticamente demolita, si blocca. Bisogna riavviarla dal menu della TV. È davvero fastidioso. Gli errori non dovrebbero verificarsi. È molto facile causare un errore in Rust: basta accedere a un array con l’indice sbagliato, si va in errore, game over. Poi, è fatta. Se sei un ingegnere che ha lavorato solo in JavaScript, forse hai familiarità con le eccezioni, puoi provare a usare try-catch da qualche parte.

Anche se non è l’ideale, è possibile intercettare l’eccezione e magari reimpostare il cliente in una posizione ottimale, più vicina a dove si trovava prima o letteralmente dove si trovava prima. Con la nostra nuova app è impossibile, il che è davvero fastidioso. Ovviamente usiamo Clippy per vietare gli unwrap e le aspettative e cose del genere. Vietiamo il codice non sicuro, tranne che in un contenitore del motore che deve interagire con i bit di livello inferiore. Anche in questo caso, ci è voluta un po’ di formazione per i nostri ingegneri dell’interfaccia utente per affidarsi a questo schema di utilizzo del tipo risultato da Rust e abituarsi all’idea che non ci sia alcun unwinding dello stack, soprattutto in WebAssembly, che è legato al primo punto. Non è possibile intercettarlo nemmeno in un gestore di panico. Semplicemente interrompe il programma. Di nuovo, questo è un grosso problema per noi (Amazon Prime usa Rust e WebAssembly).

Alla fine, ovviamente, abbiamo finito, quindi siamo contenti. Non abbiamo quasi mai avuto crash, ma questo richiede un sacco di lavoro. Questo ci ha anche generato un sacco di lavoro perché dipendevamo da alcune librerie di terze parti che andavano in panico ogni volta che si chiamavano alcune funzioni in un modo forse non proprio corretto. Di nuovo, preferivamo avere risultati concreti piuttosto che panic in quei casi. Questo ha comportato un po’ di lavoro inaspettato. È un aspetto da considerare, soprattutto nella programmazione dell’interfaccia utente, o soprattutto se si passa, come abbiamo fatto noi, da JavaScript a Rust e WebAssembly.

La collaborazione con Bytecode – Amazon Prime usa Rust e WebAssembly

La Bytecode Alliance è un’organizzazione no-profit di cui facciamo parte, a cui aderiscono diverse aziende, e si basa su standard open source come WebAssembly e WebAssembly System Interface. WebAssembly Micro Runtime, la macchina virtuale che utilizziamo, è sviluppata lì, così come Wasmtime, un altro popolare runtime di Rust, implementato questa volta in Rust. WebAssembly Micro Runtime è in C. È un buon punto di riferimento se siete interessati a usare Rust in produzione, e in particolare a usare WebAssembly in produzione. Nel nostro caso, viene fornito con Rust e tutto il resto.

Domanda finale e risposta – Amazon Prime usa Rust e WebAssembly

Partecipante: Hai detto che non lo usi per i tuoi client web. Pensi che qualcosa del genere possa funzionare usando WebGL come target di rendering?

Ene: Abbiamo fatto dei confronti sui dispositivi. Ci sono un sacco di punti critici. Il primo punto critico riguarda quelli per cui dobbiamo usare un browser, perché non c’è spazio sulla flash, su alcuni decoder. Il problema è che si tratta di una versione di WebKit che non supporta WebAssembly. Questo è il grosso ostacolo per noi. Potrebbe essere possibile. Abbiamo fatto degli esperimenti e ha funzionato, ma si perdono alcune funzionalità dei browser che noi non abbiamo. Oggi non ne vale la pena perché hanno pochissimi clienti. Funzionano abbastanza bene in termini di confronto, persino con l’interfaccia utente di sistema. Anche se non raggiungono questi numeri, sarebbe un notevole sforzo far funzionare questo SDK su un browser.

Al momento, è piuttosto semplice perché ha un solo target, quello che ha la VM nativa. Richiede una serie di funzioni dalla VM nativa che esponiamo e che non sono standard. Per ottenerle probabilmente sarebbe necessario indirizzarle a JavaScript. A quel punto ti chiedi: cosa sta succedendo? Potresti perdere un po’ di prestazioni e cose del genere. È un po’ complicato, ma lo stiamo tenendo d’occhio.

(fonte)

Innovaformazione, scuola informatica specialistica promuove la cultura IT consapevole e segue costantemente i trend di mercato. Con un’offerta formativa sempre aggiornata, accompagniamo le aziende nella formazione continua del team di sviluppatori. trovate l’elenco corsi QUI.

INFO: info@innovaformazione.net – tel. 3471012275 (Dario Carrassi)

Ti potrebbe interessare

Articoli correlati