chore: aggiunto esempio articolo node

src/pages/blog/en/node-did-not-implement-typescript.md

@@ -61,6 +61,24 @@ Node.js simply can't accept TypeScript as a dependency because it would break se
 
 This is where the confusion arises. Node.js did not implement TypeScript, but they did add type stripping under an experimental flag. This feature allows developers to write TypeScript code and have it compiled to JavaScript without the type information. This is a compromise that allows developers to use TypeScript in Node.js without introducing the issues mentioned above.
 
+Do you want an example? Here you go:
+
+```typescript
+function sum(a: number, b: number): number {
+  return a + b;
+}
+```
+
+This function, when compiled with the `--experimental-strip-types` flag, will become:
+
+```javascript
+function sum(a        , b        )         {
+  return a + b;
+}
+```
+
+Did you see that? The types are gone and have been replaced by spaces. _But, why?_, you might ask. Well, because doing so preserves sourcemaps references without the hassle of having a separate build process for those.
+
 Internally, this is done via a package called `amaro` which wraps `swc` — a well-known build tool which does the actual stripping.
 
 Of course, limitations exist, such as the inability to use TypeScript-specific features like the before-mentioned _enums_. But still, it's a big step forward to prevent people from writing 135 config files to make a `sum` function accept two numbers and return a third one.

src/pages/blog/node-non-ha-implementato-typescript.md

@@ -61,6 +61,24 @@ Node.js semplicemente non può accettare TypeScript come dipendenza perché romp
 
 È qui che nasce la confusione. Node.js non ha implementato TypeScript, ma ha aggiunto lo stripping dei tipi sotto un flag sperimentale. Questa funzionalità consente agli sviluppatori di scrivere codice TypeScript e di compilarlo in JavaScript rimuovendo la tipizzazione. Questo è un compromesso che consente agli sviluppatori di utilizzare TypeScript in Node.js senza introdurre i problemi menzionati sopra.
 
+Vediamo un esempio:
+
+```typescript
+function sum(a: number, b: number): number {
+  return a + b;
+}
+```
+
+Questa funzione, quando compilata con il flag `--experimental-strip-types`, diventerà:
+
+```javascript
+function sum(a        , b        )         {
+  return a + b;
+}
+```
+
+Visto quello che è successo? I tipi sono scomparsi e sono stati sostituiti da spazi. _Ma, perché?_, potresti chiedere. Beh, perché in questo modo si preservano i riferimenti alle sourcemap senza il fastidio di dover avere un processo di build separato per quelle.
+
 Internamente, questo viene fatto tramite un pacchetto chiamato `amaro` che racchiude `swc`, un noto _build tool_ che esegue lo stripping effettivo.
 
 Naturalmente, esistono delle limitazioni, come l'impossibilità di utilizzare funzionalità specifiche di TypeScript come gli _enum_ menzionati in precedenza. Ma è comunque un grande passo avanti impedire alle persone di scrivere 135 file di configurazione per far sì che una funzione `sum` accetti due numeri e ne restituisca un terzo.