Cosa è Nova project

Cosa è Nova project

Cosa è Nova Project

Nova è un motore JavaScript (ECMAScript) e WebAssembly scritto in Rust, basato su principi di data-oriented design, con l’obiettivo di esplorare un’architettura alternativa ai motori tradizionali basati su strutture ad albero. Nato come esperimento didattico, il progetto è rapidamente cresciuto grazie al contributo di sviluppatori appassionati, arrivando oggi a superare il 70% di conformità al test suite Test262.

Definizione tecnica di Nova project

Dal punto di vista tecnico, Nova è un “engine” per JavaScript e WebAssembly scritto interamente in Rust. La sua implementazione segue fedelmente le specifiche ufficiali ECMAScript (TC39) e WebAssembly, ma impiega un modello di gestione dei dati fortemente ottimizzato attraverso tecniche di Data-Oriented Design (DOD). In concreto:

• Heap Data Organization: Tutti gli oggetti allocati in heap (numeri, stringhe, oggetti, array, DataView, ecc.) vengono memorizzati in vettori separati, distinti per tipo o “kind”.
• Heap References: Invece di puntatori o smart pointer, ogni oggetto in heap è identificato da un indice (un u32) che indica la posizione nel vettore corrispondente. Il tipo dell’indice è discriminato (ad es. NumberIndex, StringIndex, ObjectIndex, ecc.), così da garantire sicurezza di tipo e facilità di garbage collection.
• RecordData vs RecordHeapData: La rappresentazione di record ECMAScript segue le convenzioni delle specifiche (“RecordData” e “RecordHeapData”), ma nei file Rust i dati di heap vengono raggruppati in strutture separate per ogni categoria (ad es. NumberData, StringData, ObjectData). Di conseguenza, un indice “PointInHeap” non è un puntatore ma un intero che rimanda alla corretta struttura nel vettore.

Questo approccio consente di migliorare l’efficienza di layout in memoria, riducendo il numero di cache miss quando si iterano strutture omogenee (ad esempio tutti i numeri o tutte le stringhe) e favorendo operazioni SIMD-like. Inoltre, la separazione dei dati per tipo facilita l’implementazione di un garbage collector “safepoint” e incrementale.

Storia: quando e come nasce, chi sono i fondatori di Nova project

Nova Project è avviato nei primi mesi del 2024 come un esperimento condiviso da un piccolo gruppo di ingegneri appassionati di Rust e motori JavaScript. Tra i membri fondatori spiccano:

• Aapo Alasuutari: Chief Design Engineer di giorno e sviluppatore di motori JavaScript di notte, noto per aver presentato Nova in diversi eventi (Finland Rust‑lang meetup 01/2024, Web Engines Hackfest 2024, FOSDEM 2025).
• Elias Sjögreen: Contributore significativo all’engine e autore del primo post di “benvenuto” sul sito di progetto.

Nel luglio 2024 viene lanciata la prima versione del sito ufficiale (trynova.dev), che include documentazione, blog e link al codice sorgente ospitato su GitHub. Da allora, il team si è ampliato con contributori europei e statunitensi, tutti uniti dall’idea di dimostrare che un motore JavaScript basato su design orientato ai dati possa competere – in termini di correttezza, performance e scalabilità – con i motori convenzionali basati su albero di oggetti.

Architettura di Nova project

L’architettura interna di Nova segue in linea di massima le sezioni delle specifiche ECMAScript: parsing, AST, interpreter o JIT, gestione dell’heap, garbage collection, implementazione delle API WebAssembly. Tuttavia, sotto la “carrozzeria” si applicano i principi di Data-Oriented Design per massimizzare l’efficienza in cache e semplificare la gestione della memoria.

1. Layout dei dati nel heap

• Type‐Specific Vectors: Tutti i valori allocati in heap sono suddivisi in vettori distinti. Ad esempio:
  • numbers: Vec<NumberData>
  • strings: Vec<StringData>
  • objects: Vec<ObjectData>
  • arrays: Vec<ArrayData>
  • dataviews: Vec<DataViewData>
  • ecc.
  L’idea è che, anziché tenere ogni oggetto eterogeneo in un blocco unico (come fanno V8 o SpiderMonkey con inline caching e pointer indirections), Nova memorizza ogni categoria di record in un proprio vettore contiguo. Ciò riduce la frammentazione in memoria e ottimizza l’accesso iterativo ai dati omogenei.
• Heap References come Indici: Un “valore” JavaScript in Nova che risiede in heap è rappresentato internamente da un indice discriminato: ad esempio, per un numero useremo NumberIndex(u32), per una stringa StringIndex(u32), per un oggetto ObjectIndex(u32), e così via. In fase di esecuzione, le operazioni di lookup richiedono un semplice accesso al vettore corrispondente con quell’indice, senza alcuna dereferenziazione di puntatori.
• Oggetti “Agrostrutturati” (“Splitting Objects”): Anche i singoli oggetti JavaScript vengono divisi in parti logiche per minimizzare l’overhead. Ad esempio, le proprietà comuni (Shape/HiddenClasses) possono essere memorizzate separatamente dai dati “in linea” di oggetto. Gli array hanno il loro vettore dedicato, così come gli oggetti DataView. Oggetti “non ordinari” (ad esempio i Symbol, i Proxy, i RegExp, le TypedArray) possiedono un indice opzionale che punta a un “oggetto ordinario” con cui possono condividere parte della struttura interna. Questo meccanismo di splitting garantisce che le operazioni più comuni (lettura di una proprietà standard su un oggetto standard) non debbano mai toccare campi inutili.

2. Moduli e Parser

Attualmente Nova supporta la maggior parte della sintassi ECMAScript, incluse le arrow function, classi, generatori e async/await. Il parsing è eseguito con un analizzatore costruito internamente in Rust, ispirato a quelli di project “Kiesel” e “LibJS” di SerenityOS. I moduli ECMAScript (import/export) sono in via di implementazione completa, con alcuni PR già avviati ma non ancora fusi (per questioni di complessità).

3. Esecuzione: Interpreter e Pianificazione di Funzioni

Al momento Nova non incorpora un compilatore JIT: l’esecuzione avviene attraverso un interpreter bytecode-based. Il bytecode generator traduce l’AST in istruzioni interne che, a runtime, vengono eseguite in un ciclo “fetch‐decode‐execute” ben ottimizzato. Il team ha progettato già alcune strutture di supporto per introdurre un futuro JIT baseline e ottimizzazioni di tipo inline caching, senza compromettere l’approccio DOD.

4. Garbage Collector

Nova impiega un garbage collector “safepoint” con approccio intercalato (interleaved): quando la memoria raggiunge una soglia critica o periodicamente, il motore inserisce punti di pausa (safepoint) in cui si interrompe l’esecuzione del codice JavaScript per eseguire la raccolta dei rifiuti. Le caratteristiche principali sono:

• Tracciamento di Generazione Unica (“Single‐Generation”): Non ci sono nursery separate; tutti gli oggetti vivono nello stesso heap (ma suddiviso in vettori per tipo).
• Safepoint di Pausa Minima: Grazie a Rust e al sistema di borrowing, il GC può interrompere l’esecuzione in momenti ben definiti, rendendo sicura la mutazione della memoria.
• Compattazione Preventiva: Per ogni tipo di dato, quando un vettore viene compattato (per rimuovere gli oggetti non più raggiungibili), servono solo poche istruzioni per aggiornare tutti gli indici di quel tipo, evitando spostamenti massivi di blocchi eterogenei.

Questo schema è descritto approfonditamente nel blog “Guide to Nova’s garbage collector” (Pubblicato 14 marzo 2025), dove Aapo Alasuutari spiega come ha sfruttato funzionalità di “reborrowing” di Rust per integrare il GC con il borrow checker senza necessità di unsafe code.

5. WebAssembly

Nova integra anche un runtime WebAssembly (Wasm) basato sul progetto “wasmtime” e “wasmparser” in Rust, permettendo di eseguire moduli Wasm affianco a codice JavaScript. L’heap dei moduli Wasm risiede su un’area separata, ma l’interoperabilità con chiamate JS–Wasm è garantita attraverso wrapper che traducono i tipi ECMAScript in tipi Wasm e viceversa.

Funzioni principali di Nova project

1. Esecuzione di codice ECMAScript: Nova implementa il parsing completo del linguaggio, la generazione di bytecode e l’esecuzione tramite un interpreter Type‐Direct Threading.
2. Hosting di moduli WebAssembly: I moduli Wasm possono essere caricati, istanziati ed eseguiti allo stesso tempo del codice JavaScript.
3. Garbage Collection safepoint: Gestione automatica della memoria con politiche incrementali, sfruttando i safepoint inseriti in funzioni lunghe o loop.
4. API di Binding per Rust: Nova è esposto come libreria Rust, che espone un’API per creare un “runtime” personalizzato; l’utente (in Rust) definisce lo “host environment” (ad es. funzioni globali, oggetti nativi) e può eseguire script JavaScript in un contesto isolato.
5. Test Suite Test262 Integration: Nova punta alla conformità con lo standard ECMAScript, integrando Test262, il test suite ufficiale; al momento il motore supera circa il 70% dei test ed è in costante miglioramento.

Per quali tipi di progetti software è più adatto Nova project

Nova si rivolge soprattutto a:

• Progetti embedded o multipiattaforma basati su Rust, dove si ricerca un piccolo ingombro in memoria rispetto ai motori tradizionali (V8, SpiderMonkey), ma mantenendo buona compatibilità con ECMAScript.
• Ambienti con requisiti di sicurezza memory‐safe, dove l’uso di Rust riduce i rischi di buffer overflow e dangling pointers.
• Applicazioni di ricerca e sperimentazione: chi vuole studiare nuovi approcci di Data-Oriented Design nel contesto di motori di scripting.
• Sistemi con limitazioni di risorse (IoT, edge computing), dove un motore più leggero e modulare può essere preferibile.

Quando scegliere Nova:

• Se si utilizza già Rust come linguaggio principale e si desidera un’integrazione profonda tra runtime e librerie Rust.
• Se l’obiettivo è sperimentare o contribuire a un engine in fase embrionale, con un cuore di GC basato su safe Rust.
• Per progetti di ricerca accademica o proof-of-concept dove non sono richieste feature avanzate (ad es. JIT ottimizzato, snapshotting complessi, debugging avanzato).

Quando evitarlo:

• In applicazioni di produzione controverse sull’affidabilità: Nova non è ancora considerato “maturato” come V8 o SpiderMonkey.
• Se si ha bisogno di un performance JIT avanzato o di compatibilità al 100% con tutti i pacchetti npm.
• Se si deve integrare con infrastrutture di debugging e profiling già consolidate su V8/Chrome DevTools.

Punti di forza e punti deboli di Nova project

Punti di forza

1. Sicurezza e Affidabilità: Scritto in Rust, evita classi di bug legate a memoria (use-after-free, buffer overflow).
2. Progettazione Data-Oriented: Riduce la frammentazione, migliora il locality of reference e velocizza l’iterazione di strutture omogenee.
3. Heap Organizzato per Tipo: Garbage collector più semplice da implementare, perché lavora su vettori di tipo noto.
4. Estendibilità tramite Rust: L’API di binding è nativa per Rust, facilitando l’integrazione in applicazioni che già usano quest’ecosistema.
5. Interoperabilità con WebAssembly: Supporto integrato per moduli Wasm, con wrapper di conversione dei tipi.

Punti deboli

1. Maturità Limitata: Molti standard ECMAScript sono ancora in fase di sviluppo o parziale supporto (moduli, API DOM, Web APIs).
2. Performance Brutta e Grezza (no JIT): L’interpreter bytecode è più lento dei motori JIT più avanzati; mancano ottimizzazioni di inline caching.
3. Tooling Ancora Scarno: Debugger, profiler e strumenti di introspezione non sono buoni quanto quelli di motori consolidati.
4. Compatibilità Ridotta: Alcune API di basso livello (ad es. sockets, file system) non sono presenti o vanno implementate manualmente in Rust.
5. Community in Crescita ma Ancora Piccola: Meno contributori e meno documentazione rispetto a motori più popolari.

Nova project JavaScript Engine: dettagli tecnici

1. Nova JavaScript Engine (NJE)

Il “Nova JavaScript Engine” è la parte di Nova dedicata esclusivamente all’interpretazione di codice ECMAScript. Le principali componenti includono:

• Lexer & Parser: Basati su Rust, generano un AST conforme alle specifiche TC39. La grammatica supporta ES2024 (inclusi async/await, generics, optional chaining, ecc.).
• Bytecode Generator: L’AST viene tradotto in un formato interno di bytecode, ottimizzato per l’esecuzione veloce su macchina virtuale Rust.
• Interpreter DOD‐Based: Ogni istruzione bytecode va a leggere e scrivere direttamente in vettori di dati, aggiornando gli indici corrispondenti. Non esistono oggetti inline: ogni valore o proprietà risiede in heap mediante un indice.
• RecordData e RecordHeapData: Le record strutturali (ad es. ObjectRecord, FunctionRecord, ArrayRecord) vengono implementate in Rust come struct separate da HeapData per l’allocazione. Un indice come ObjectIndex(u32) informa l’interprete di recuperare il ObjectData dal vettore objects.

2. Data-Oriented View

“Data‐Oriented View” è un termine che Nova prende in prestito dall’omonimo articolo di Aapo Alasuutari e Elias Sjögreen (Pubblicato 1 novembre 2024). In breve:

• Obiettivo: Migliorare le prestazioni delle operazioni su oggetti di tipo DataView (principalmente per ArrayBuffer e tipi TypedArray) sfruttando layout contigui in memoria anziché strutture “a piscina” con header e puntatori.
• Implementazione: I DataViewData vengono mantenuti in un vettore dedicato, con campi che puntano direttamente all’offset corretto di un ArrayBufferData. L’indice di DataView funge da “handle”: in fase di lettura/scrittura, l’interprete calcola l’indirizzo base come base_ptr + offset e accede direttamente al buffer contiguo.
• Benefici: Riduce l’overhead di indirezione; ogni accesso a un elemento di typed array è una semplice operazione di offset su un vettore contiguo gestito in Rust.

3. Garbage Collector e Gestione della Memoria

Nova utilizza un garbage collector “interleaved safepoint” che procede come segue:

1. Allocazioni: Quando il codice JavaScript richiede memoria per un nuovo oggetto (ad es. new Object(), new Array(), stringhe, numeri), Nova alloca un nuovo elemento nel vettore di tipo corrispondente e restituisce un indice.
2. Safepoint Insertion: In punti predefiniti del bytecode (ad esempio all’inizio di ogni function, nella gestione di loop lunghi, in chiamate a funzioni native), l’interprete verifica se la memoria heap ha superato una certa soglia. Se sì, sospende l’esecuzione e avvia il GC.
3. Mark & Sweep “Generazionale”: Essenzialmente, Nova segue un algoritmo “Mark & Sweep” ma senza divisione in generazioni:
   • Mark: Parti dai root (registri di vm, stack di chiamate, chiusure) e effettua una marcatura ricorsiva degli indici raggiungibili.
   • Sweep per Tipo: Per ogni vettore di tipo specifico, si scansiona l’intera lista di dati; gli elementi non marcati vengono deallocati (possono essere semplicemente rimossi o spostati altrimenti).
   • Compattazione: Per mantenere l’ordine contiguo in memoria, Nova compatta il vettore, aggiornando tutti gli indici rimasti. Siccome le references sono solo indici (non puntatori), l’aggiornamento richiede una scansione di tutti gli oggetti rimasti per aggiustare gli indici vecchi con quelli nuovi.
4. Rebinding Indici: Grazie alla tipizzazione degli indici (ad es. ObjectIndex diverso da ArrayIndex), è semplice individuare quale vettore va compattato; ogni compatto genera una mappa da indice vecchio a indice nuovo, che viene applicata a tutti i campi di indice nei record di heap.
5. Sicurezza con Rust: L’uso di “reborrowing” di Rust (concept del borrow checker per riferimenti mutabili e condivisi) consente di coordinare l’accesso dei thread di GC con l’interprete, evitando data race senza ricorrere ad unsafe.

Il blog “Taking out the trash” (13 ottobre 2024) illustra i problemi filosofici e le scelte di design adottate, mentre “Guide to Nova’s garbage collector” (14 marzo 2025) fornisce una panoramica passo per passo dell’implementazione interna.

Quando scegliere Nova project e quando evitarlo

• Scegliere Nova se:
  1. Stai sviluppando in Rust e vuoi integrare un motore JS in un’applicazione di sistema (es. CLI, serverless, IoT) con footprint contenuto.
  2. Il tuo obiettivo è sperimentare tecniche di Data-Oriented Design su un motore di scripting completo.
  3. Vuoi un motore sicuro alla memory safety, senza dipendere da librerie C++ complesse.
  4. Hai risorse limitate e non hai bisogno di ottimizzazioni JIT avanzate, ma ti serve comunque compatibilità con un buon sottoinsieme di ECMAScript.
• Evitare Nova se:
  1. Hai necessità di prestazioni di punta (ad es. V8 con JIT, Turbofan, Snap).
  2. Ti serve supporto pieno a Node.js/npm, pacchetti N-API o addon nativi C++.
  3. Vuoi un motore con tooling già maturo (Chrome DevTools, profiler avanzati, ottimizzazioni di benchmark).
  4. Richiedi “headless” testing integrato o runtime specifici per browser.

Punti di forza e punti deboli (Riepilogo)

Punti di forza	Punti deboli
Sicuro (Rust memory safe)	Maturità del progetto limitata
Data-Oriented Design garantisce efficienza in cache	Nessun JIT avanzato (solo interpreter)
Heap suddiviso per tipo semplifica il GC	Compatibilità ECMAScript non al 100%
Integrazione nativa con Rust	Tooling (debugger, profiler) ancora scarni
Supporto integrato a WebAssembly	Community relativamente piccola

---

Nova JavaScript Engine: focus su componenti specifiche

1. Nova JavaScript Engine (NJE)

Nova JS Engine è l’insieme di moduli Rust che si occupano di:

1. Parsing:
   • Implementazione di un lexer che tokenizza secondo la grammatica ES2024.
   • Parser ricorsivo‑discendente che ottiene un AST “typed” con nodi ben definiti (FunctionDecl, VariableDecl, ExpressionStmt, ecc.).
2. Bytecode Generation:
   • Ogni nodo AST viene tradotto in un insieme di istruzioni “Nova bytecode”.
   • Le istruzioni sono progettate per massimizzare la località di dati (accesso diretto tramite indici alle strutture DOD).
3. Interpreter:
   • Usa un “threaded interpreter” (o “displaced interpreter”) in Rust, con un ciclo “fetch‐decode‐execute”.
   • Il valore dei registri di VM e lo stack di esecuzione contengono indici tipizzati (ad es. Value::Heap(ObjectIndex(u32)) o Value::Immediate(Number)).
   • Quando serve recuperare proprietà di oggetti o chiamare funzioni, si risale ai vettori di heap corrispondenti (ad es. heap.objects[object_index.0]).
4. Opcode Principali:
   • OpGetProperty <ObjectIndex>, <PropertyName> → recupera il valore letto dal vettore objects e lo ritorna come Value.
   • OpSetProperty <ObjectIndex>, <PropertyName>, <Value> → aggiorna il vettore objects con nuovo valore.
   • OpCallFunction <FunctionIndex>, <ArgCount> → recupera l’oggetto funzione dal vettore functions, crea un nuovo stack frame, e invoca l’interprete ricorsivamente.
5. Esecuzione Modulabile:
   • Il motore è esposto come libreria con l’API NovaRuntime::new() (o similare), su cui si possono registrare “host functions” in Rust, e infine lanciare runtime.execute(script).

2. Data-Oriented View per DataView e TypedArray

Implementare DataView in un motore JS richiede gestire un puntatore a un buffer e offset variabili. Nova ottimizza questo:

• Vettore ArrayBufferData: Contiene un campo con un Vec<u8> al cui interno risiede il blocco contiguo di memoria.
• Vettore TypedArrayData: Ogni TypedArray (ad es. Uint8Array, Float32Array) è memorizzato in un vettore separato, ma il dato effettivo risiede ancora in ArrayBufferData. Per un indice TypedArrayIndex(i), si recupera il riferimento all’ArrayBufferData, si applica offset e scale (dipendente dal tipo di TypedArray) e si ritorna il valore desiderato.
• Data-Oriented Layout: Poiché i buffer sono in vettori contigui, operazioni come iterare su un Float64Array o su un Uint8ClampedArray beneficiano della località di memoria e del prefetching hardware. Il blog “Data-oriented View” (01 novembre 2024) illustra come viene ridotto l’overhead delle strutture header/pointer ridondanti rispetto ad altre implementazioni.

3. Garbage Collector: dettagli di funzionamento

• Safepointing: In fase di compilazione del bytecode, il compilatore inserisce istruzioni “safepoint check” in posizioni strategiche (inizio di funzione, ogni tot iterazioni di loop, chiamate a funzioni native). Quando l’esecuzione raggiunge un safepoint e l’heap ha superato una soglia (heap.allocated_bytes > threshold), si attiva il GC.
• Phases:
  1. Mark: Si parte dagli oggetti root nel “VM Stack” (registri, chiusure su stack, valori temporanei) e si esegue un DFS sui riferimenti: ogni indice ObjectIndex, ArrayIndex, StringIndex che appare viene marcato come “live”.
  2. Sweep per Tipo: Per ogni vettore, si scorre linearmente dal primo all’ultimo elemento; se un elemento non è marcato, viene scaricato. Per rimuoverlo, si toglie il suo indice e si riduce la lunghezza del vettore.
  3. Compattazione e Aggiornamento Indici: Quando si rimuovono elementi in posizione intermedia di un vettore, si spostano gli elementi successivi verso sinistra e si deve aggiornare ogni indice che faceva riferimento agli elementi spostati. A tal fine, Nova costruisce una mappa old_index → new_index durante la sweep e la applica a tutti i campi “indice” di ogni tipo di heap data.
• Reborrowing in Rust: Per garantire che, durante la fase di mark, il GC non introduca alias non sicuri, Nova sfrutta la funzionalità di “reborrowing” di Rust: i riferimenti a memoria condivisa vengono immutabili durante la mark phase; all’inizio del sweep, tutti i riferimenti mutabili vengono momentaneamente presi in prestito in esclusiva per procedere alla compattazione, poi rilasciati. Questo meccanismo è trattato in dettaglio nella guida “Guide to Nova’s garbage collector” (14 marzo 2025).

Caso d’uso e piccoli esempi di codice

Di seguito un esempio minimale di come integrare Nova all’interno di un progetto Rust per eseguire uno script JavaScript che utilizza un TypedArray e una funzione JS.

// Cargo.toml
// [dependencies]
// nova = { git = "https://github.com/trynova/nova", tag = "v0.1.0" }
// anyhow = "1.0"

// src/main.rs
use nova::{RuntimeBuilder, Value};
use anyhow::Result;

fn main() -> Result<()> {
    // 1. Costruisco un runtime Nova
    let mut runtime = RuntimeBuilder::new()
        .enable_wasm(true)    // abilito anche il supporto WebAssembly
        .build()?;

    // 2. Registra una funzione host in Rust che verrà chiamata da JS
    runtime.register_function("log", |args| {
        if let Some(Value::String(s)) = args.get(0) {
            println!("[JS LOG] {}", s);
        }
        Ok(Value::Undefined)
    });

    // 3. Scrivo uno script JS che utilizza TypedArray e DataView
    let script = r#"
        // Creo un ArrayBuffer di 16 byte
        let buffer = new ArrayBuffer(16);
        // Creo una DataView che lo gestisce
        let view = new DataView(buffer);
        // Scrivo un valore a 0, usando 32-bit little-endian
        view.setUint32(0, 0xdeadbeef, true);

        // Leggo il valore dagli stessi byte
        let val = view.getUint32(0, true);
        log("Valore letto da DataView: 0x" + val.toString(16));

        // Funzione JS semplice
        function somma(a, b) {
            return a + b;
        }
        let res = somma(10, 32);
        log("Somma: " + res);
    "#;

    // 4. Eseguo lo script
    runtime.execute(script)?;

    Ok(())
}

Spiegazione:

• RuntimeBuilder::new() crea un’istanza di runtime Nova configurabile.
• enable_wasm(true) abilita l’interprete Wasm.
• register_function("log", ...) espone una native function chiamata log che, in questo caso, stampa su stdout.
• Nel codice JS, si crea un ArrayBuffer di 16 byte, si ottiene una DataView, si scrive un valore Uint32 con setUint32 (che internamente fa TypedArrayData lookup), e poi si legge con getUint32. Grazie al design DOD, l’accesso al campo è un semplice lookup in un vettore contiguo.
• Infine, viene eseguita una funzione JS somma(a, b) e il risultato è passato alla funzione host log.

Risultato atteso in console:

[JS LOG] Valore letto da DataView: 0xdeadbeef
[JS LOG] Somma: 42

Conclusioni – Cosa è Nova Project

Nova Project rappresenta un tentativo ambizioso di ridefinire l’architettura di un motore JavaScript basandosi sul paradigma Data-Oriented Design. Scritto in Rust e dotato di un garbage collector safepoint incrementale, Nova punta a dimostrare che è possibile costruire un engine sicuro, modulare e potenzialmente più efficiente sul piano della cache rispetto ai motori tradizionali basati su C++. Sul versante tecnico, Nova si distingue per:

• Organizzazione dei dati in vettori separati per tipo, eliminando puntatori ridondanti.
• Gestione delle referenze in heap tramite indici tipizzati che facilitano il GC e riducono l’overhead.
• Integrazione con WebAssembly per scenari misti JS + Wasm.
• Un’implementazione del garbage collector che sfrutta le caratteristiche uniche di Rust, come il borrow checker e la nozione di “reborrowing”.

Tuttavia, Nova non è ancora pronto per sostituire motori consolidati in ambiente di produzione: mancano alcune feature ECMAScript avanzate, JIT ottimizzato e strumenti di debugging integrati. Rimane invece una piattaforma ideale per sperimentare, contribuire e imparare i dettagli dell’implementazione di un motore JavaScript sicuro e orientato ai dati.

(fonte)

Innovaformazione, scuola informatica specialistica segue costantemente il mercato ed affianca le aziende IT nella formazione continua dei team di sviluppatori. Potete visionare i corsi a catalogo sul nostro sito QUI.

Per leggere altri articoli tecnici consigliamo di navigare sul nostro blog QUI.

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