, tag— scrivi semplicemente Markdown." +- icon: 👁 + title: Migliore negli editor + desc: "Il Markdown viene renderizzato splendidamente nei moderni IDE e editor di testo." +support: + description: "Disponibile dal JDK 23 (settembre 2024)" diff --git a/translations/content/it/language/module-import-declarations.yaml b/translations/content/it/language/module-import-declarations.yaml new file mode 100644 index 0000000..ac1248b --- /dev/null +++ b/translations/content/it/language/module-import-declarations.yaml @@ -0,0 +1,18 @@ +--- +title: Dichiarazioni di importazione modulo +oldApproach: Molte importazioni +modernApproach: import module +summary: "Importa tutti i package esportati da un modulo con una singola dichiarazione." +explanation: "Le dichiarazioni di importazione modulo permettono di importare tutto ciò che un modulo esporta con una riga. Particolarmente utile per java.base che copre collezioni, I/O, stream e altro." +whyModernWins: +- icon: 🧹 + title: Una riga + desc: "Sostituisci un muro di importazioni con una singola importazione modulo." +- icon: 📦 + title: Consapevole dei moduli + desc: "Sfrutta il sistema di moduli per importare insiemi coerenti di package." +- icon: 🚀 + title: Avvio rapido + desc: "Perfetto per script e prototipi dove le liste di importazioni sono noiose." +support: + description: "Finalizzato nel JDK 25 LTS (JEP 511, settembre 2025)." diff --git a/translations/content/it/language/pattern-matching-instanceof.yaml b/translations/content/it/language/pattern-matching-instanceof.yaml new file mode 100644 index 0000000..56316e7 --- /dev/null +++ b/translations/content/it/language/pattern-matching-instanceof.yaml @@ -0,0 +1,18 @@ +--- +title: Pattern matching per instanceof +oldApproach: instanceof + Cast +modernApproach: Variabile pattern +summary: "Combina il controllo del tipo e il cast in un unico passo con il pattern matching." +explanation: "Il pattern matching per instanceof elimina il cast ridondante dopo un controllo del tipo. La variabile è automaticamente scoped dove il pattern corrisponde, rendendo il codice più sicuro e conciso." +whyModernWins: +- icon: 🔄 + title: Nessun cast ridondante + desc: "Il controllo del tipo e il binding della variabile avvengono in un'unica espressione." +- icon: 📏 + title: Meno righe + desc: "Una riga invece di due — la riga del cast sparisce completamente." +- icon: 🛡️ + title: Scope sicuro + desc: "La variabile pattern è nello scope solo dove il tipo è garantito." +support: + description: Ampiamente disponibile dal JDK 16 (marzo 2021) diff --git a/translations/content/it/language/pattern-matching-switch.yaml b/translations/content/it/language/pattern-matching-switch.yaml new file mode 100644 index 0000000..be48672 --- /dev/null +++ b/translations/content/it/language/pattern-matching-switch.yaml @@ -0,0 +1,18 @@ +--- +title: Pattern matching in switch +oldApproach: Catena if-else +modernApproach: Pattern di tipo +summary: "Sostituisci le catene if-else instanceof con pattern di tipo switch puliti." +explanation: "Il pattern matching in switch permette di corrispondere direttamente sui tipi, combinando il test del tipo, il cast e il binding in un'unica etichetta case concisa. Il compilatore verifica la completezza." +whyModernWins: +- icon: 📐 + title: Dispatch strutturato + desc: "Lo switch rende la struttura di branching esplicita e scansionabile." +- icon: 🎯 + title: Forma espressione + desc: "Restituisce un valore direttamente — nessuna variabile mutabile necessaria." +- icon: ✅ + title: Esaustività + desc: "Il compilatore verifica che tutti i tipi siano gestiti." +support: + description: Ampiamente disponibile dal JDK 21 LTS (settembre 2023) diff --git a/translations/content/it/language/primitive-types-in-patterns.yaml b/translations/content/it/language/primitive-types-in-patterns.yaml new file mode 100644 index 0000000..7b9ff35 --- /dev/null +++ b/translations/content/it/language/primitive-types-in-patterns.yaml @@ -0,0 +1,18 @@ +--- +title: Tipi primitivi nei pattern +oldApproach: Controlli manuali degli intervalli +modernApproach: Pattern primitivi +summary: "Il pattern matching ora funziona anche con i tipi primitivi, non solo gli oggetti." +explanation: "Java 25 estende il pattern matching ai tipi primitivi. Puoi usare int, long, double ecc. nei pattern switch con guardie when, eliminando la necessità di boxing o controlli manuali degli intervalli." +whyModernWins: +- icon: 📦 + title: Nessun boxing + desc: "Corrisponde ai primitivi direttamente — nessun wrapper Integer necessario." +- icon: 🎯 + title: Coerenza dei pattern + desc: "Stessa sintassi dei pattern per oggetti e primitivi." +- icon: ⚡ + title: Prestazioni migliori + desc: "Evita l'overhead dell'autoboxing nel pattern matching." +support: + description: "Anteprima nel JDK 25 (terza anteprima, JEP 507). Richiede --enable-preview." diff --git a/translations/content/it/language/private-interface-methods.yaml b/translations/content/it/language/private-interface-methods.yaml new file mode 100644 index 0000000..278c871 --- /dev/null +++ b/translations/content/it/language/private-interface-methods.yaml @@ -0,0 +1,18 @@ +--- +title: Metodi privati nelle interfacce +oldApproach: Logica duplicata +modernApproach: Metodi privati +summary: "Estrai la logica condivisa nelle interfacce usando metodi privati." +explanation: "Java 9 consente i metodi privati nelle interfacce, permettendo di condividere codice tra i metodi default senza esporre i dettagli di implementazione alle classi implementanti." +whyModernWins: +- icon: 🧩 + title: Riutilizzo del codice + desc: "Condividi la logica tra i metodi default senza duplicazione." +- icon: 🔐 + title: Incapsulamento + desc: "I dettagli di implementazione rimangono nascosti alle classi implementanti." +- icon: 🧹 + title: Interfacce DRY + desc: "Niente più copia-incolla tra i metodi default." +support: + description: Ampiamente disponibile dal JDK 9 (settembre 2017) diff --git a/translations/content/it/language/record-patterns.yaml b/translations/content/it/language/record-patterns.yaml new file mode 100644 index 0000000..1a9ed83 --- /dev/null +++ b/translations/content/it/language/record-patterns.yaml @@ -0,0 +1,18 @@ +--- +title: Pattern record (destrutturazione) +oldApproach: Accesso manuale +modernApproach: Destrutturazione +summary: "Destruttua i record direttamente nei pattern — estrai i campi in un unico passo." +explanation: "I pattern record permettono di decomporre i componenti di un record direttamente in instanceof e switch. Sono supportati anche i pattern annidati, abilitando il matching profondo senza variabili intermedie." +whyModernWins: +- icon: 🎯 + title: Estrazione diretta + desc: "Accedi ai componenti del record senza chiamare manualmente gli accessori." +- icon: 🪆 + title: Annidabile + desc: "I pattern possono annidarsi — corrisponde ai record interni in un'unica espressione." +- icon: 📏 + title: Codice compatto + desc: "Cinque righe diventano due — meno cerimonia, stessa chiarezza." +support: + description: Ampiamente disponibile dal JDK 21 LTS (settembre 2023) diff --git a/translations/content/it/language/records-for-data-classes.yaml b/translations/content/it/language/records-for-data-classes.yaml new file mode 100644 index 0000000..81b2261 --- /dev/null +++ b/translations/content/it/language/records-for-data-classes.yaml @@ -0,0 +1,18 @@ +--- +title: Record per classi di dati +oldApproach: POJO verboso +modernApproach: record +summary: "Una riga sostituisce oltre 30 righe di codice boilerplate per i data carrier immutabili." +explanation: "I record generano automaticamente il costruttore, gli accessori (x(), y()), equals(), hashCode() e toString(). Sono immutabili per design e ideali per DTO, value object e pattern matching." +whyModernWins: +- icon: ⚡ + title: Definizione in una riga + desc: "Una singola riga sostituisce costruttore, getter, equals, hashCode, toString." +- icon: 🔒 + title: Immutabile per default + desc: "Tutti i campi sono final — nessun setter pericoloso." +- icon: 🧩 + title: Pattern-friendly + desc: "I record funzionano con i pattern di destrutturazione in switch e instanceof." +support: + description: Ampiamente disponibile dal JDK 16 (marzo 2021) diff --git a/translations/content/it/language/sealed-classes.yaml b/translations/content/it/language/sealed-classes.yaml new file mode 100644 index 0000000..cc5f5ac --- /dev/null +++ b/translations/content/it/language/sealed-classes.yaml @@ -0,0 +1,18 @@ +--- +title: Classi sealed per gerarchie di tipi +oldApproach: Gerarchia aperta +modernApproach: sealed permits +summary: "Limita le classi che possono estendere un tipo — abilitando switch esaustivi." +explanation: "Le classi sealed definiscono un insieme chiuso di sottotipi. Il compilatore conosce tutti i casi possibili, abilitando il pattern matching esaustivo senza un ramo default. Combinate con i record, modellano i tipi di dati algebrici." +whyModernWins: +- icon: 🔐 + title: Gerarchia controllata + desc: "Solo i sottotipi consentiti possono estendere — nessuna sottoclasse a sorpresa." +- icon: ✅ + title: Matching esaustivo + desc: "Il compilatore verifica che lo switch copra tutti i casi, senza default necessario." +- icon: 📐 + title: Tipi di dati algebrici + desc: "Modella i tipi somma in modo naturale — sealed + record = ADT in Java." +support: + description: Ampiamente disponibile dal JDK 17 LTS (settembre 2021) diff --git a/translations/content/it/language/static-members-in-inner-classes.yaml b/translations/content/it/language/static-members-in-inner-classes.yaml new file mode 100644 index 0000000..bf66106 --- /dev/null +++ b/translations/content/it/language/static-members-in-inner-classes.yaml @@ -0,0 +1,18 @@ +--- +title: Membri statici nelle classi interne +oldApproach: Necessaria la classe nested statica +modernApproach: Membri statici nelle classi interne +summary: "Definisci membri statici nelle classi interne senza richiedere classi nested statiche." +explanation: "Prima di Java 16, solo le classi nested statiche potevano contenere membri statici. Le classi interne (non statiche) non potevano avere statici perché richiedevano un'istanza di enclosing. Java 16 allenta questa restrizione, permettendo campi statici, metodi e anche tipi nested nelle classi interne." +whyModernWins: +- icon: 🔓 + title: Più flessibilità + desc: "Le classi interne ora possono avere membri statici quando necessario." +- icon: 🧩 + title: Stato condiviso + desc: "Traccia lo stato condiviso tra le istanze di una classe interna." +- icon: 📐 + title: Libertà di design + desc: "Non è necessario promuovere a classe nested statica solo per un campo statico." +support: + description: Ampiamente disponibile dal JDK 16 (marzo 2021) diff --git a/translations/content/it/language/static-methods-in-interfaces.yaml b/translations/content/it/language/static-methods-in-interfaces.yaml new file mode 100644 index 0000000..7f73487 --- /dev/null +++ b/translations/content/it/language/static-methods-in-interfaces.yaml @@ -0,0 +1,18 @@ +--- +title: Metodi statici nelle interfacce +oldApproach: Classi di utilità +modernApproach: Metodi statici nelle interfacce +summary: "Aggiungi metodi di utilità statici direttamente nelle interfacce invece di classi di utilità separate." +explanation: "Prima di Java 8, i metodi di utilità correlati a un'interfaccia dovevano trovarsi in una classe separata (es. Collections per Collection). I metodi statici nelle interfacce permettono di tenere le utilità correlate insieme. Comune nelle API moderne come Comparator.comparing(), Stream.of() e List.of()." +whyModernWins: +- icon: 📦 + title: Migliore organizzazione + desc: "Tieni le utilità correlate con l'interfaccia, non in una classe separata." +- icon: 🔍 + title: Rilevabilità + desc: "I metodi factory e helper si trovano dove te li aspetti." +- icon: 🧩 + title: Coesione dell'API + desc: "Nessun bisogno di classi *Utils o *Helper separate." +support: + description: "Disponibile dal JDK 8 (marzo 2014)" diff --git a/translations/content/it/language/switch-expressions.yaml b/translations/content/it/language/switch-expressions.yaml new file mode 100644 index 0000000..4ae3ec4 --- /dev/null +++ b/translations/content/it/language/switch-expressions.yaml @@ -0,0 +1,18 @@ +--- +title: Espressioni switch +oldApproach: Istruzione switch +modernApproach: Espressione switch +summary: "Switch come espressione che restituisce un valore — niente break, niente fall-through." +explanation: "Le espressioni switch restituiscono un valore direttamente, usano la sintassi a freccia per prevenire i bug da fall-through, e il compilatore verifica l'esaustività. Questo sostituisce la forma a istruzione soggetta a errori." +whyModernWins: +- icon: 🎯 + title: Restituisce un valore + desc: "Assegna direttamente il risultato dello switch — nessuna variabile temporanea necessaria." +- icon: 🛡️ + title: Nessun fall-through + desc: "La sintassi a freccia elimina i bug da fall-through accidentale per break mancanti." +- icon: ✅ + title: Verifica di esaustività + desc: "Il compilatore verifica che tutti i casi siano coperti." +support: + description: Ampiamente disponibile dal JDK 14 (marzo 2020) diff --git a/translations/content/it/language/text-blocks-for-multiline-strings.yaml b/translations/content/it/language/text-blocks-for-multiline-strings.yaml new file mode 100644 index 0000000..3c6825a --- /dev/null +++ b/translations/content/it/language/text-blocks-for-multiline-strings.yaml @@ -0,0 +1,18 @@ +--- +title: Text block per stringhe multiriga +oldApproach: Concatenazione di stringhe +modernApproach: Text Block +summary: "Scrivi stringhe multiriga in modo naturale con i text block delimitati da triple virgolette." +explanation: "I text block permettono di scrivere stringhe multiriga esattamente come appaiono. Non serve più eseguire l'escape delle virgolette o aggiungere \n. Il compilatore rimuove automaticamente l'indentazione superflua." +whyModernWins: +- icon: 📖 + title: Leggibile com'è + desc: "JSON, SQL e HTML appaiono come vero JSON, SQL e HTML nel codice sorgente." +- icon: 🚫 + title: Nessun escape infernale + desc: "Le virgolette incorporate non richiedono il backslash di escape." +- icon: 📐 + title: Indentazione intelligente + desc: "Gli spazi iniziali vengono rimossi automaticamente in base alla posizione del delimitatore di chiusura." +support: + description: Ampiamente disponibile dal JDK 15 (settembre 2020) diff --git a/translations/content/it/language/type-inference-with-var.yaml b/translations/content/it/language/type-inference-with-var.yaml new file mode 100644 index 0000000..9ec63a7 --- /dev/null +++ b/translations/content/it/language/type-inference-with-var.yaml @@ -0,0 +1,18 @@ +--- +title: Inferenza di tipo con var +oldApproach: Tipi espliciti +modernApproach: Parola chiave var +summary: "Usa var per l'inferenza di tipo nelle variabili locali — meno rumore, stessa sicurezza." +explanation: "Da Java 10, il compilatore inferisce i tipi delle variabili locali dal lato destro dell'assegnazione. Questo riduce il rumore visivo senza sacrificare la sicurezza dei tipi. Usa var quando il tipo è ovvio dal contesto." +whyModernWins: +- icon: ⚡ + title: Meno codice ripetitivo + desc: "Non è necessario ripetere tipi generici complessi su entrambi i lati dell'assegnazione." +- icon: 👁 + title: Migliore leggibilità + desc: "Concentrati sui nomi delle variabili e i valori, non sulle dichiarazioni di tipo." +- icon: 🔒 + title: Ancora type-safe + desc: Il compilatore inferisce e applica il tipo esatto in fase di compilazione. +support: + description: Ampiamente disponibile dal JDK 10 (marzo 2018) diff --git a/translations/content/it/language/unnamed-variables.yaml b/translations/content/it/language/unnamed-variables.yaml new file mode 100644 index 0000000..ceabfc6 --- /dev/null +++ b/translations/content/it/language/unnamed-variables.yaml @@ -0,0 +1,18 @@ +--- +title: Variabili senza nome con _ +oldApproach: Variabile non utilizzata +modernApproach: Segnaposto _ +summary: "Usa _ per segnalare l'intento quando una variabile è intenzionalmente non utilizzata." +explanation: "Le variabili senza nome comunicano a lettori e strumenti che un valore viene deliberatamente ignorato. Niente più convenzioni di naming come 'ignored' o 'unused', niente più avvisi IDE." +whyModernWins: +- icon: 📢 + title: Intento chiaro + desc: "_ dice esplicitamente 'questo valore non è necessario qui'." +- icon: 🔇 + title: Nessun avviso + desc: "IDE e linter non segnaleranno variabili intenzionalmente non utilizzate." +- icon: 🧹 + title: Lambda più pulite + desc: "Le lambda multi-parametro sono più pulite quando si usano solo alcuni parametri." +support: + description: "Finalizzato nel JDK 22 (JEP 456, marzo 2024)." diff --git a/translations/content/it/security/key-derivation-functions.yaml b/translations/content/it/security/key-derivation-functions.yaml new file mode 100644 index 0000000..b455b4d --- /dev/null +++ b/translations/content/it/security/key-derivation-functions.yaml @@ -0,0 +1,18 @@ +--- +title: Funzioni di derivazione delle chiavi +oldApproach: PBKDF2 manuale +modernApproach: API KDF +summary: "Deriva chiavi crittografiche usando l'API KDF standard." +explanation: "L'API KDF fornisce un'interfaccia standard per le funzioni di derivazione delle chiavi incluso HKDF. Sostituisce il goffo pattern SecretKeyFactory + PBEKeySpec con una pulita API builder." +whyModernWins: +- icon: 📐 + title: API pulita + desc: "Pattern builder invece degli goffi costruttori KeySpec." +- icon: 🔧 + title: Supporto HKDF + desc: "Algoritmo HKDF moderno insieme a PBKDF2." +- icon: 🛡️ + title: Standard + desc: "API unificata per tutti gli algoritmi di derivazione delle chiavi." +support: + description: "Finalizzato nel JDK 25 LTS (JEP 510, settembre 2025)." diff --git a/translations/content/it/security/pem-encoding.yaml b/translations/content/it/security/pem-encoding.yaml new file mode 100644 index 0000000..ebe0480 --- /dev/null +++ b/translations/content/it/security/pem-encoding.yaml @@ -0,0 +1,18 @@ +--- +title: Codifica/decodifica PEM +oldApproach: Base64 manuale + Header +modernApproach: API PEM +summary: "Codifica e decodifica oggetti crittografici in formato PEM in modo nativo." +explanation: "L'API PEM fornisce codifica/decodifica standard per certificati, chiavi e altri oggetti crittografici in formato PEM. Niente più wrapping Base64 manuale con header BEGIN/END." +whyModernWins: +- icon: 🧹 + title: Nessun Base64 manuale + desc: "Header PEM, wrapping di riga e Base64 gestiti automaticamente." +- icon: 🔄 + title: Bidirezionale + desc: "Codifica in PEM e decodifica da PEM con un'unica API." +- icon: 🛡️ + title: Formato standard + desc: "Produce output PEM conforme a RFC 7468." +support: + description: "Anteprima nel JDK 25 (JEP 470). Richiede --enable-preview." diff --git a/translations/content/it/security/random-generator.yaml b/translations/content/it/security/random-generator.yaml new file mode 100644 index 0000000..a4c5013 --- /dev/null +++ b/translations/content/it/security/random-generator.yaml @@ -0,0 +1,18 @@ +--- +title: Interfaccia RandomGenerator +oldApproach: new Random() / ThreadLocalRandom +modernApproach: Factory RandomGenerator +summary: "Usa l'interfaccia RandomGenerator per scegliere gli algoritmi di numeri casuali per nome senza accoppiamento a una classe specifica." +explanation: "JDK 17 ha introdotto RandomGenerator come interfaccia comune per tutte le implementazioni RNG. Invece di codificare direttamente new Random() o ThreadLocalRandom, puoi selezionare gli algoritmi per nome tramite una factory, rendendo facile passare tra algoritmi ottimizzati per diversi casi d'uso (velocità, qualità statistica, divisibilità)." +whyModernWins: +- icon: 🔧 + title: Algoritmo-agnostico + desc: "Scegli il miglior algoritmo RNG per nome senza cambiare la struttura del codice." +- icon: ⚡ + title: Algoritmi migliori + desc: "Accesso ai moderni generatori LXM con proprietà statistiche superiori." +- icon: 🔗 + title: API unificata + desc: "Un'interfaccia copre Random, ThreadLocalRandom, SplittableRandom e altro." +support: + description: "Disponibile dal JDK 17 (settembre 2021, JEP 356)." diff --git a/translations/content/it/security/strong-random.yaml b/translations/content/it/security/strong-random.yaml new file mode 100644 index 0000000..c1aa0a2 --- /dev/null +++ b/translations/content/it/security/strong-random.yaml @@ -0,0 +1,18 @@ +--- +title: Generazione di numeri casuali sicuri +oldApproach: new SecureRandom() +modernApproach: getInstanceStrong() +summary: "Ottieni l'implementazione SecureRandom più forte della piattaforma." +explanation: "getInstanceStrong() restituisce l'implementazione SecureRandom configurata come la più forte sulla piattaforma. Questo è controllato dalla proprietà di sicurezza securerandom.strongAlgorithms." +whyModernWins: +- icon: 🛡️ + title: La più forte disponibile + desc: "Seleziona automaticamente il miglior algoritmo per la piattaforma." +- icon: 📖 + title: Intento esplicito + desc: "Comunica chiaramente che è richiesta la casualità forte." +- icon: 🔧 + title: Configurabile + desc: "Gli amministratori possono cambiare l'algoritmo forte tramite le proprietà di sicurezza." +support: + description: Ampiamente disponibile dal JDK 9 (settembre 2017) diff --git a/translations/content/it/security/tls-default.yaml b/translations/content/it/security/tls-default.yaml new file mode 100644 index 0000000..c70cc9c --- /dev/null +++ b/translations/content/it/security/tls-default.yaml @@ -0,0 +1,18 @@ +--- +title: TLS 1.3 per default +oldApproach: Configurazione TLS manuale +modernApproach: TLS 1.3 predefinito +summary: "TLS 1.3 è abilitato per default — nessuna configurazione esplicita del protocollo necessaria." +explanation: "Java 11 ha aggiunto il supporto TLS 1.3 e lo ha reso il protocollo preferito. HttpClient lo usa automaticamente. Niente più specifiche manuali delle versioni del protocollo per le connessioni sicure." +whyModernWins: +- icon: 🛡️ + title: Più sicuro + desc: "TLS 1.3 rimuove le suite di cifratura obsolete e i pattern di handshake." +- icon: ⚡ + title: Handshake più veloce + desc: "TLS 1.3 completa in un round trip invece di due." +- icon: 🆓 + title: Zero configurazione + desc: "Sicuro per default — nessuna selezione esplicita del protocollo necessaria." +support: + description: Ampiamente disponibile dal JDK 11 (settembre 2018) diff --git a/translations/content/it/streams/collectors-flatmapping.yaml b/translations/content/it/streams/collectors-flatmapping.yaml new file mode 100644 index 0000000..6428dcf --- /dev/null +++ b/translations/content/it/streams/collectors-flatmapping.yaml @@ -0,0 +1,18 @@ +--- +title: Collectors.flatMapping() +oldApproach: flatMap annidato +modernApproach: flatMapping() +summary: "Usa flatMapping() per appiattire all'interno di un collector di raggruppamento." +explanation: "Collectors.flatMapping() applica una mappatura uno-a-molti come collector downstream. È l'equivalente collector di Stream.flatMap() — utile all'interno di groupingBy o partitioningBy." +whyModernWins: +- icon: 🧩 + title: Componibile + desc: "Funziona come collector downstream all'interno di groupingBy." +- icon: 📐 + title: Un passaggio + desc: "Appiattisci e raggruppa in un'unica traversata dello stream." +- icon: 🔗 + title: Annidabile + desc: "Combina con altri collector downstream." +support: + description: Ampiamente disponibile dal JDK 9 (settembre 2017) diff --git a/translations/content/it/streams/optional-ifpresentorelse.yaml b/translations/content/it/streams/optional-ifpresentorelse.yaml new file mode 100644 index 0000000..5f04bc4 --- /dev/null +++ b/translations/content/it/streams/optional-ifpresentorelse.yaml @@ -0,0 +1,18 @@ +--- +title: Optional.ifPresentOrElse() +oldApproach: if/else su Optional +modernApproach: ifPresentOrElse() +summary: "Gestisci entrambi i casi di Optional presente e vuoto in una chiamata." +explanation: "ifPresentOrElse() accetta un Consumer per il caso presente e un Runnable per il caso vuoto. Evita l'anti-pattern isPresent/get." +whyModernWins: +- icon: 📏 + title: Espressione singola + desc: "Entrambi i casi gestiti in una singola chiamata a metodo." +- icon: 🚫 + title: Nessun get() + desc: "Elimina il pericoloso pattern isPresent() + get()." +- icon: 🔗 + title: Fluente + desc: "Si concatena naturalmente dopo findUser() o qualsiasi metodo che restituisce Optional." +support: + description: Ampiamente disponibile dal JDK 9 (settembre 2017) diff --git a/translations/content/it/streams/optional-or.yaml b/translations/content/it/streams/optional-or.yaml new file mode 100644 index 0000000..2688d06 --- /dev/null +++ b/translations/content/it/streams/optional-or.yaml @@ -0,0 +1,18 @@ +--- +title: Fallback Optional.or() +oldApproach: Fallback annidato +modernApproach: Catena .or() +summary: "Concatena i fallback Optional senza controlli annidati." +explanation: "Optional.or() restituisce l'Optional originale se ha un valore, altrimenti valuta il supplier per ottenere un Optional alternativo. I supplier sono lazy — chiamati solo quando necessario." +whyModernWins: +- icon: 🔗 + title: Concatenabile + desc: "Impila i fallback in una pipeline leggibile." +- icon: ⚡ + title: Valutazione lazy + desc: "I supplier di fallback vengono eseguiti solo se necessario." +- icon: 📖 + title: Dichiarativo + desc: "Si legge come 'prova il primario, o il secondario, o i default'." +support: + description: Ampiamente disponibile dal JDK 9 (settembre 2017) diff --git a/translations/content/it/streams/predicate-not.yaml b/translations/content/it/streams/predicate-not.yaml new file mode 100644 index 0000000..9c614c4 --- /dev/null +++ b/translations/content/it/streams/predicate-not.yaml @@ -0,0 +1,18 @@ +--- +title: Predicate.not() per la negazione +oldApproach: Negazione lambda +modernApproach: Predicate.not() +summary: "Usa Predicate.not() per negare i riferimenti a metodo in modo pulito invece di scrivere wrapper lambda." +explanation: "Prima di Java 11, negare un riferimento a metodo richiedeva di avvolgerlo in una lambda. Predicate.not() permette di negare qualsiasi predicato direttamente, mantenendo il codice leggibile e coerente con lo stile dei riferimenti a metodo in tutta la pipeline stream." +whyModernWins: +- icon: 👁 + title: Negazione più pulita + desc: "Non è necessario avvolgere i riferimenti a metodo in lambda solo per negarli." +- icon: 🔗 + title: Componibile + desc: "Funziona con qualsiasi Predicate, abilitando catene di predicati pulite." +- icon: 📖 + title: Lettura naturale + desc: "Predicate.not(String::isBlank) si legge come in inglese." +support: + description: "Disponibile dal JDK 11 (settembre 2018)." diff --git a/translations/content/it/streams/stream-gatherers.yaml b/translations/content/it/streams/stream-gatherers.yaml new file mode 100644 index 0000000..d932bc1 --- /dev/null +++ b/translations/content/it/streams/stream-gatherers.yaml @@ -0,0 +1,18 @@ +--- +title: Stream gatherer +oldApproach: Collector personalizzato +modernApproach: gather() +summary: "Usa i gatherer per operazioni stream intermedie personalizzate." +explanation: "I gatherer sono una nuova operazione stream intermedia che può esprimere trasformazioni complesse come finestre scorrevoli, gruppi di dimensioni fisse e operazioni di scansione che erano impossibili con le operazioni stream standard." +whyModernWins: +- icon: 🧩 + title: Componibile + desc: "I gatherer si compongono con altre operazioni stream." +- icon: 📦 + title: Operazioni integrate + desc: "windowFixed, windowSliding, fold, scan pronti all'uso." +- icon: 🔧 + title: Estensibile + desc: "Scrivi gatherer personalizzati per qualsiasi trasformazione intermedia." +support: + description: "Finalizzato nel JDK 24 (JEP 485, marzo 2025)." diff --git a/translations/content/it/streams/stream-iterate-predicate.yaml b/translations/content/it/streams/stream-iterate-predicate.yaml new file mode 100644 index 0000000..f3cd9ea --- /dev/null +++ b/translations/content/it/streams/stream-iterate-predicate.yaml @@ -0,0 +1,18 @@ +--- +title: Stream.iterate() con predicato +oldApproach: iterate + limit +modernApproach: iterate(seed, pred, op) +summary: "Usa un predicato per fermare l'iterazione — come un ciclo for in forma stream." +explanation: "Il tre-argomenti Stream.iterate(seed, hasNext, next) funziona come un ciclo for: seed è l'inizio, hasNext determina quando fermarsi e next produce il valore successivo." +whyModernWins: +- icon: 🎯 + title: Terminazione naturale + desc: "Fermati in base a una condizione, non a un limite arbitrario." +- icon: 📐 + title: Equivalente al ciclo for + desc: "Stessa semantica di for(seed; hasNext; next)." +- icon: 🛡️ + title: Nessun rischio di stream infinito + desc: "Il predicato garantisce la terminazione." +support: + description: Ampiamente disponibile dal JDK 9 (settembre 2017) diff --git a/translations/content/it/streams/stream-mapmulti.yaml b/translations/content/it/streams/stream-mapmulti.yaml new file mode 100644 index 0000000..861870f --- /dev/null +++ b/translations/content/it/streams/stream-mapmulti.yaml @@ -0,0 +1,18 @@ +--- +title: Stream.mapMulti() +oldApproach: flatMap + List +modernApproach: mapMulti() +summary: "Emetti zero o più elementi per input senza creare stream intermedi." +explanation: "mapMulti() è un'alternativa imperativa a flatMap che evita la creazione di oggetti Stream intermedi per ogni elemento. È più efficiente quando la mappatura produce un numero ridotto di elementi." +whyModernWins: +- icon: ⚡ + title: Meno allocazione + desc: "Nessuno Stream intermedio creato per elemento." +- icon: 🎯 + title: Stile imperativo + desc: "Usa loop e condizionali direttamente." +- icon: 📐 + title: Flessibile + desc: "Emetti zero, uno o molti elementi con pieno controllo." +support: + description: Ampiamente disponibile dal JDK 16 (marzo 2021) diff --git a/translations/content/it/streams/stream-of-nullable.yaml b/translations/content/it/streams/stream-of-nullable.yaml new file mode 100644 index 0000000..37333b1 --- /dev/null +++ b/translations/content/it/streams/stream-of-nullable.yaml @@ -0,0 +1,18 @@ +--- +title: Stream.ofNullable() +oldApproach: Controllo null +modernApproach: ofNullable() +summary: "Crea uno stream da zero o un elemento da un valore nullable." +explanation: "Stream.ofNullable() restituisce uno stream a elemento singolo se il valore è non-null, o uno stream vuoto se null. Elimina il pattern di controllo null ternario." +whyModernWins: +- icon: 📏 + title: Conciso + desc: "Una chiamata sostituisce il condizionale ternario." +- icon: 🔗 + title: Adatto a flatMap + desc: "Perfetto all'interno di flatMap per saltare i valori null." +- icon: 🛡️ + title: Null-safe + desc: "Nessun rischio NPE — null diventa stream vuoto." +support: + description: Ampiamente disponibile dal JDK 9 (settembre 2017) diff --git a/translations/content/it/streams/stream-takewhile-dropwhile.yaml b/translations/content/it/streams/stream-takewhile-dropwhile.yaml new file mode 100644 index 0000000..22625fa --- /dev/null +++ b/translations/content/it/streams/stream-takewhile-dropwhile.yaml @@ -0,0 +1,18 @@ +--- +title: Stream takeWhile / dropWhile +oldApproach: Loop manuale +modernApproach: takeWhile/dropWhile +summary: "Prendi o scarta elementi da uno stream in base a un predicato." +explanation: "takeWhile() restituisce elementi finché il predicato è vero e si ferma al primo falso. dropWhile() salta gli elementi finché è vero e restituisce il resto. Entrambi funzionano meglio su stream ordinati." +whyModernWins: +- icon: 🎯 + title: Cortocircuito + desc: "Smette di elaborare non appena il predicato fallisce." +- icon: 🔗 + title: Adatto alla pipeline + desc: "Si concatena naturalmente con altre operazioni stream." +- icon: 📖 + title: Dichiarativo + desc: "takeWhile si legge come in inglese: 'prendi mentre meno di 100'." +support: + description: Ampiamente disponibile dal JDK 9 (settembre 2017) diff --git a/translations/content/it/streams/stream-tolist.yaml b/translations/content/it/streams/stream-tolist.yaml new file mode 100644 index 0000000..d552618 --- /dev/null +++ b/translations/content/it/streams/stream-tolist.yaml @@ -0,0 +1,18 @@ +--- +title: Stream.toList() +oldApproach: Collectors.toList() +modernApproach: .toList() +summary: "Il terminale toList() sostituisce il verboso collect(Collectors.toList())." +explanation: "Stream.toList() restituisce una lista non modificabile. È equivalente a .collect(Collectors.toUnmodifiableList()) ma molto più breve. Nota: il risultato è immutabile, a differenza di Collectors.toList()." +whyModernWins: +- icon: 📏 + title: 7 caratteri vs 24 + desc: ".toList() sostituisce .collect(Collectors.toList())." +- icon: 🔒 + title: Immutabile + desc: "La lista risultante non può essere modificata." +- icon: 📖 + title: Fluente + desc: "Si legge naturalmente alla fine di una pipeline." +support: + description: Ampiamente disponibile dal JDK 16 (marzo 2021) diff --git a/translations/content/it/streams/virtual-thread-executor.yaml b/translations/content/it/streams/virtual-thread-executor.yaml new file mode 100644 index 0000000..89b0173 --- /dev/null +++ b/translations/content/it/streams/virtual-thread-executor.yaml @@ -0,0 +1,18 @@ +--- +title: Executor con thread virtuali +oldApproach: Pool di thread fisso +modernApproach: Executor con thread virtuali +summary: "Usa gli executor con thread virtuali per concorrenza leggera illimitata." +explanation: "L'executor con thread virtuali crea un nuovo thread virtuale per ogni task. Nessun dimensionamento del pool necessario — i thread virtuali sono abbastanza economici da crearne milioni." +whyModernWins: +- icon: ♾️ + title: Nessun dimensionamento + desc: "Nessuna dimensione del pool da ottimizzare — crea tutti i thread necessari." +- icon: ⚡ + title: Leggero + desc: "I thread virtuali usano KB di memoria, non MB." +- icon: 🧹 + title: Auto-chiudibile + desc: "Il try-with-resources gestisce automaticamente lo shutdown." +support: + description: Ampiamente disponibile dal JDK 21 LTS (settembre 2023) diff --git a/translations/content/it/strings/string-chars-stream.yaml b/translations/content/it/strings/string-chars-stream.yaml new file mode 100644 index 0000000..cfbda26 --- /dev/null +++ b/translations/content/it/strings/string-chars-stream.yaml @@ -0,0 +1,18 @@ +--- +title: Caratteri della stringa come stream +oldApproach: Loop manuale +modernApproach: Stream chars() +summary: "Elabora i caratteri della stringa come pipeline stream." +explanation: "String.chars() restituisce un IntStream di valori carattere, abilitando l'elaborazione funzionale. Per il supporto Unicode, codePoints() gestisce correttamente i caratteri supplementari." +whyModernWins: +- icon: 🔗 + title: Concatenabile + desc: "Usa filter, map, collect sugli stream di caratteri." +- icon: 📐 + title: Dichiarativo + desc: "Descrivi cosa fare, non come fare il loop." +- icon: 🌐 + title: Pronto per Unicode + desc: "codePoints() gestisce correttamente emoji e caratteri supplementari." +support: + description: "Disponibile dal JDK 8+ (migliorato in 9+)" diff --git a/translations/content/it/strings/string-formatted.yaml b/translations/content/it/strings/string-formatted.yaml new file mode 100644 index 0000000..592a52f --- /dev/null +++ b/translations/content/it/strings/string-formatted.yaml @@ -0,0 +1,18 @@ +--- +title: String.formatted() +oldApproach: String.format() +modernApproach: formatted() +summary: "Chiama formatted() sulla stringa template stessa." +explanation: "String.formatted() è un metodo di istanza equivalente a String.format() ma chiamato sulla stringa di formato. Si legge più naturalmente in un flusso da sinistra a destra." +whyModernWins: +- icon: 📖 + title: Si legge naturalmente + desc: "template.formatted(args) scorre meglio di String.format(template, args)." +- icon: 🔗 + title: Concatenabile + desc: "Può essere concatenato con altri metodi string." +- icon: 📏 + title: Meno verboso + desc: "Elimina la ridondante chiamata statica String.format()." +support: + description: Ampiamente disponibile dal JDK 15 (settembre 2020) diff --git a/translations/content/it/strings/string-indent-transform.yaml b/translations/content/it/strings/string-indent-transform.yaml new file mode 100644 index 0000000..f26a075 --- /dev/null +++ b/translations/content/it/strings/string-indent-transform.yaml @@ -0,0 +1,18 @@ +--- +title: String.indent() e transform() +oldApproach: Indentazione manuale +modernApproach: indent() / transform() +summary: "Indenta il testo e concatena le trasformazioni di stringa in modo fluente." +explanation: "indent(n) aggiunge n spazi a ogni riga. transform(fn) applica qualsiasi funzione e restituisce il risultato, abilitando la concatenazione fluente delle operazioni sulle stringhe." +whyModernWins: +- icon: 📏 + title: Integrato + desc: "L'indentazione è un'operazione comune — ora è una chiamata." +- icon: 🔗 + title: Concatenabile + desc: "transform() abilita pipeline fluenti sulle stringhe." +- icon: 🧹 + title: Codice pulito + desc: "Nessuna divisione manuale di righe e loop StringBuilder." +support: + description: Ampiamente disponibile dal JDK 12 (marzo 2019) diff --git a/translations/content/it/strings/string-isblank.yaml b/translations/content/it/strings/string-isblank.yaml new file mode 100644 index 0000000..9feca2c --- /dev/null +++ b/translations/content/it/strings/string-isblank.yaml @@ -0,0 +1,18 @@ +--- +title: String.isBlank() +oldApproach: trim().isEmpty() +modernApproach: isBlank() +summary: "Controlla le stringhe vuote con una singola chiamata a metodo." +explanation: "isBlank() restituisce true se la stringa è vuota o contiene solo spazi bianchi, inclusi i caratteri di spazio bianco Unicode che trim() non riconosce." +whyModernWins: +- icon: 📖 + title: Auto-documentante + desc: "isBlank() dice esattamente cosa controlla." +- icon: 🌐 + title: Consapevole di Unicode + desc: "Gestisce tutti gli spazi bianchi Unicode, non solo ASCII." +- icon: ⚡ + title: Nessuna allocazione + desc: "Non viene creata alcuna stringa trimmed intermedia." +support: + description: Ampiamente disponibile dal JDK 11 (settembre 2018) diff --git a/translations/content/it/strings/string-lines.yaml b/translations/content/it/strings/string-lines.yaml new file mode 100644 index 0000000..305bf91 --- /dev/null +++ b/translations/content/it/strings/string-lines.yaml @@ -0,0 +1,18 @@ +--- +title: String.lines() per la divisione in righe +oldApproach: split("\\n") +modernApproach: lines() +summary: "Usa String.lines() per dividere il testo in uno stream di righe senza overhead regex." +explanation: "String.lines() restituisce uno Stream
di righe divise per \n, \r o \r\n. È più lazy ed efficiente di split(), evita la compilazione regex e si integra naturalmente con l'API Stream per ulteriori elaborazioni." +whyModernWins: +- icon: ⚡ + title: Streaming lazy + desc: "Le righe vengono prodotte su richiesta, non tutte in una volta come split()." +- icon: 🔧 + title: Terminatori di riga universali + desc: "Gestisce automaticamente \n, \r e \r\n senza regex." +- icon: 🔗 + title: Integrazione Stream + desc: "Restituisce uno Stream per uso diretto con filter, map, collect." +support: + description: "Disponibile dal JDK 11 (settembre 2018)." diff --git a/translations/content/it/strings/string-repeat.yaml b/translations/content/it/strings/string-repeat.yaml new file mode 100644 index 0000000..c1cd453 --- /dev/null +++ b/translations/content/it/strings/string-repeat.yaml @@ -0,0 +1,18 @@ +--- +title: String.repeat() +oldApproach: Loop StringBuilder +modernApproach: repeat() +summary: "Ripeti una stringa n volte senza un loop." +explanation: "String.repeat(int) restituisce la stringa concatenata con se stessa n volte. Gestisce i casi limite: repeat(0) restituisce una stringa vuota, repeat(1) restituisce la stessa stringa." +whyModernWins: +- icon: 📏 + title: Una riga + desc: "Sostituisci 5 righe di codice StringBuilder con una chiamata." +- icon: ⚡ + title: Ottimizzato + desc: "L'implementazione interna è ottimizzata per le ripetizioni grandi." +- icon: 📖 + title: Intento chiaro + desc: "repeat(3) trasmette immediatamente lo scopo." +support: + description: Ampiamente disponibile dal JDK 11 (settembre 2018) diff --git a/translations/content/it/strings/string-strip.yaml b/translations/content/it/strings/string-strip.yaml new file mode 100644 index 0000000..9721647 --- /dev/null +++ b/translations/content/it/strings/string-strip.yaml @@ -0,0 +1,18 @@ +--- +title: String.strip() vs trim() +oldApproach: trim() +modernApproach: strip() +summary: "Usa stripping consapevole di Unicode con strip(), stripLeading(), stripTrailing()." +explanation: "trim() rimuove solo i caratteri ≤ U+0020 (caratteri di controllo ASCII e spazio). strip() usa Character.isWhitespace() che gestisce gli spazi Unicode come lo spazio unificatore, lo spazio ideografico, ecc." +whyModernWins: +- icon: 🌐 + title: Corretto per Unicode + desc: "Gestisce tutti i caratteri di spazio bianco da ogni script." +- icon: 🎯 + title: Direzionale + desc: "stripLeading() e stripTrailing() per il trimming su un solo lato." +- icon: 🛡️ + title: Meno bug + desc: "Nessun spazio bianco a sorpresa rimasto nel testo internazionale." +support: + description: Ampiamente disponibile dal JDK 11 (settembre 2018) diff --git a/translations/content/it/tooling/aot-class-preloading.yaml b/translations/content/it/tooling/aot-class-preloading.yaml new file mode 100644 index 0000000..555935e --- /dev/null +++ b/translations/content/it/tooling/aot-class-preloading.yaml @@ -0,0 +1,18 @@ +--- +title: Precaricamento AOT delle classi +oldApproach: Avvio a freddo ogni volta +modernApproach: Cache AOT +summary: "Metti in cache il caricamento delle classi e la compilazione per un avvio istantaneo." +explanation: "Il precaricamento AOT delle classi mette in cache le classi caricate e collegate da un'esecuzione di addestramento. Agli avvii successivi, le classi vengono caricate dalla cache, saltando la verifica e il collegamento. Combinato con la compilazione AOT, questo riduce drasticamente il tempo di avvio." +whyModernWins: +- icon: ⚡ + title: Avvio più veloce + desc: "Salta il caricamento, la verifica e il collegamento delle classi." +- icon: 📦 + title: Stato in cache + desc: "L'esecuzione di addestramento cattura lo stato ideale delle classi." +- icon: 🔧 + title: Nessuna modifica al codice + desc: "Funziona con le applicazioni esistenti — basta aggiungere flag JVM." +support: + description: "Disponibile come funzionalità standard nel JDK 25 LTS (JEP 514/515, settembre 2025)." diff --git a/translations/content/it/tooling/built-in-http-server.yaml b/translations/content/it/tooling/built-in-http-server.yaml new file mode 100644 index 0000000..00d10c1 --- /dev/null +++ b/translations/content/it/tooling/built-in-http-server.yaml @@ -0,0 +1,18 @@ +--- +title: Server HTTP integrato +oldApproach: Server esterno / Framework +modernApproach: CLI jwebserver +summary: "Java 18 include un server HTTP minimale integrato per la prototipazione e la servizione di file." +explanation: "JDK 18 ha aggiunto un semplice server HTTP di file senza dipendenze accessibile tramite lo strumento da riga di comando jwebserver o l'API SimpleFileServer. Serve file statici da una directory specifica senza configurazione. Lo strumento CLI è ideale per prototipazione rapida, test e condivisione di file ad hoc — nessuna dipendenza esterna o framework richiesto." +whyModernWins: +- icon: 🚀 + title: Zero setup + desc: "Esegui jwebserver in qualsiasi directory — nessuna installazione, configurazione o dipendenza necessaria." +- icon: 📦 + title: Integrato nel JDK + desc: "Disponibile in ogni installazione JDK 18+, sempre disponibile su qualsiasi macchina con Java." +- icon: 🧪 + title: Ottimo per la prototipazione + desc: "Servi file statici istantaneamente per testare HTML, API o sviluppo front-end." +support: + description: "Disponibile dal JDK 18 (marzo 2022)" diff --git a/translations/content/it/tooling/compact-object-headers.yaml b/translations/content/it/tooling/compact-object-headers.yaml new file mode 100644 index 0000000..8ca040c --- /dev/null +++ b/translations/content/it/tooling/compact-object-headers.yaml @@ -0,0 +1,18 @@ +--- +title: Header oggetto compatti +oldApproach: Header a 128 bit +modernApproach: Header a 64 bit +summary: "Riduci della metà la dimensione dell'header degli oggetti per una migliore densità di memoria e utilizzo della cache." +explanation: "Gli header oggetto compatti riducono l'overhead per oggetto da 128 bit a 64 bit sulle piattaforme a 64 bit. Questo risparmia memoria e migliora l'utilizzo della cache, specialmente per le applicazioni con molti oggetti piccoli." +whyModernWins: +- icon: 📦 + title: Header più piccoli del 50% + desc: "8 byte invece di 16 per oggetto." +- icon: ⚡ + title: Migliore utilizzo della cache + desc: "Più oggetti entrano nelle linee di cache della CPU." +- icon: 📊 + title: Maggiore densità + desc: "Più oggetti nello stesso heap." +support: + description: "Finalizzato nel JDK 25 LTS (JEP 519, settembre 2025)." diff --git a/translations/content/it/tooling/jfr-profiling.yaml b/translations/content/it/tooling/jfr-profiling.yaml new file mode 100644 index 0000000..94a42c3 --- /dev/null +++ b/translations/content/it/tooling/jfr-profiling.yaml @@ -0,0 +1,18 @@ +--- +title: JFR per il profiling +oldApproach: Profiler esterno +modernApproach: Java Flight Recorder +summary: "Profila qualsiasi app Java con il Flight Recorder integrato — nessuno strumento esterno." +explanation: "Java Flight Recorder (JFR) è uno strumento di profiling a basso overhead integrato nella JVM. Cattura eventi per CPU, memoria, GC, I/O, thread e eventi personalizzati con impatto minimo sulle prestazioni (~1%)." +whyModernWins: +- icon: 🆓 + title: Integrato + desc: "Nessun profiler esterno da installare o licenziare." +- icon: ⚡ + title: Basso overhead + desc: "~1% di impatto sulle prestazioni — sicuro per la produzione." +- icon: 📊 + title: Eventi ricchi + desc: "CPU, memoria, GC, thread, I/O, lock ed eventi personalizzati." +support: + description: "Ampiamente disponibile dal JDK 9/11 (open-source in 11)" diff --git a/translations/content/it/tooling/jshell-prototyping.yaml b/translations/content/it/tooling/jshell-prototyping.yaml new file mode 100644 index 0000000..f972877 --- /dev/null +++ b/translations/content/it/tooling/jshell-prototyping.yaml @@ -0,0 +1,18 @@ +--- +title: JShell per la prototipazione +oldApproach: Crea file + Compila + Esegui +modernApproach: REPL jshell +summary: "Prova le espressioni Java in modo interattivo senza creare file." +explanation: "JShell è un Read-Eval-Print Loop per Java. Testa espressioni, sperimenta con le API e prototipa codice senza creare file, compilare o scrivere un metodo main. Include completamento con tab e documentazione inline." +whyModernWins: +- icon: ⚡ + title: Feedback immediato + desc: "Digita un'espressione, vedi il risultato immediatamente." +- icon: 📝 + title: Nessun file necessario + desc: "Nessun file .java, nessun passo di compilazione." +- icon: 🔍 + title: Esplorazione delle API + desc: "Il completamento con tab aiuta a scoprire metodi e parametri." +support: + description: Ampiamente disponibile dal JDK 9 (settembre 2017) diff --git a/translations/content/it/tooling/junit6-with-jspecify.yaml b/translations/content/it/tooling/junit6-with-jspecify.yaml new file mode 100644 index 0000000..a85047f --- /dev/null +++ b/translations/content/it/tooling/junit6-with-jspecify.yaml @@ -0,0 +1,18 @@ +--- +title: JUnit 6 con sicurezza null JSpecify +oldApproach: API non annotata +modernApproach: API @NullMarked +summary: "JUnit 6 adotta JSpecify @NullMarked, rendendo espliciti i contratti null nell'intera API di asserzione." +explanation: "JUnit 5 è stato rilasciato senza annotazioni di nullabilità standardizzate, lasciando agli sviluppatori il compito di indovinare se i parametri di asserzione o i valori di ritorno potessero essere null. JUnit 6 adotta JSpecify nell'intero modulo: l'annotazione @NullMarked rende tutti i tipi non annotati non-null per default, e @Nullable contrassegna le eccezioni. La classe Assertions annota esplicitamente i parametri come assertNull(@Nullable Object actual) e fail(@Nullable String message), così IDE e analizzatori statici possono rilevare l'uso errato del null in fase di compilazione invece che a runtime." +whyModernWins: +- icon: 📜 + title: Contratti espliciti + desc: "@NullMarked sul modulo JUnit 6 documenta la semantica null direttamente nell'API — nessuna lettura del sorgente necessaria." +- icon: 🛡️ + title: Sicurezza in fase di compilazione + desc: "IDE e analizzatori avvisano quando viene passato null dove è atteso non-null, rilevando i bug prima dell'esecuzione dei test." +- icon: 🌐 + title: Standard dell'ecosistema + desc: "JSpecify è adottato da Spring, Guava e altri — semantica null coerente nell'intero stack." +support: + description: "Disponibile da JUnit 6.0 (ottobre 2025, richiede Java 17+)" diff --git a/translations/content/it/tooling/multi-file-source.yaml b/translations/content/it/tooling/multi-file-source.yaml new file mode 100644 index 0000000..632bfdd --- /dev/null +++ b/translations/content/it/tooling/multi-file-source.yaml @@ -0,0 +1,18 @@ +--- +title: Launcher multi-file sorgente +oldApproach: Compila tutto prima +modernApproach: Source Launcher +summary: "Avvia programmi multi-file senza un passo di compilazione esplicito." +explanation: "Java 22+ può compilare automaticamente i file sorgente referenziati quando si avvia da un file .java. Questo rende i piccoli programmi multi-file facili da eseguire come script, senza necessità di Maven o Gradle." +whyModernWins: +- icon: 🚀 + title: Zero setup + desc: "Nessuno strumento di build necessario per piccoli programmi multi-file." +- icon: 🔗 + title: Auto-risoluzione + desc: "Le classi referenziate vengono trovate e compilate automaticamente." +- icon: 📝 + title: Simile a script + desc: "Esegui programmi multi-file come script." +support: + description: "Disponibile dal JDK 22 (marzo 2024)" diff --git a/translations/content/it/tooling/single-file-execution.yaml b/translations/content/it/tooling/single-file-execution.yaml new file mode 100644 index 0000000..a784d4a --- /dev/null +++ b/translations/content/it/tooling/single-file-execution.yaml @@ -0,0 +1,18 @@ +--- +title: Esecuzione di file singoli +oldApproach: Compilazione in due passi +modernApproach: Avvio diretto +summary: "Esegui programmi Java a file singolo direttamente senza javac." +explanation: "Il launcher Java può compilare ed eseguire un singolo file sorgente in un comando. Combinato con il supporto shebang su Unix, i file Java possono funzionare come script. Nessun passo di compilazione separato necessario." +whyModernWins: +- icon: ⚡ + title: Un comando + desc: "java File.java compila ed esegue in un unico passo." +- icon: 📝 + title: Simile a script + desc: "Aggiungi una riga shebang per rendere i file .java script eseguibili." +- icon: 🎓 + title: Adatto all'apprendimento + desc: "I principianti eseguono il codice immediatamente senza imparare gli strumenti di build." +support: + description: Ampiamente disponibile dal JDK 11 (settembre 2018) diff --git a/translations/strings/it.yaml b/translations/strings/it.yaml new file mode 100644 index 0000000..0f9e414 --- /dev/null +++ b/translations/strings/it.yaml @@ -0,0 +1,90 @@ +site: + title: java.evolved + tagline: Java si è evoluto. Anche il tuo codice può. + tagline_line1: Java si è evoluto. + tagline_line2: Anche il tuo codice può. + description: Una raccolta di snippet Java moderni. Ogni vecchio pattern Java accanto + al suo sostituto moderno e pulito — fianco a fianco. + heroSnippetCount: ✦ {{snippetCount}} pattern moderni · Java 8 → Java 25 + heroOld: Vecchio + heroModern: Moderno + allComparisons: Tutti i confronti + snippetsBadge: '{{snippetCount}} snippet' +nav: + allPatterns: ← Tutti i pattern + toggleTheme: Cambia tema + viewOnGitHub: Vedi su GitHub + selectLanguage: Seleziona lingua +breadcrumb: + home: Home +sections: + codeComparison: Confronto Codice + whyModernWins: Perché vince l'approccio moderno + oldApproach: Approccio Vecchio + modernApproach: Approccio Moderno + sinceJdk: Dal JDK + difficulty: Difficoltà + jdkSupport: Supporto JDK + howItWorks: Come funziona + relatedDocs: Documentazione Correlata + relatedPatterns: Pattern correlati +filters: + show: 'Mostra:' + all: Tutti +difficulty: + beginner: Principiante + intermediate: Intermedio + advanced: Avanzato +search: + placeholder: Cerca snippet… + noResults: Nessun risultato trovato. + esc: ESC + searchTrigger: Cerca… + navigate: naviga + open: apri + close: chiudi +cards: + old: Vecchio + modern: Moderno + hoverHint: passa il mouse per vedere il moderno → + hoverHintRelated: Passa il mouse per vedere il moderno ➜ + touchHint: 👆 tocca o scorri → +copy: + copy: Copia + copied: Copiato! +share: + label: Condividi +view: + expandAll: Espandi Tutto + collapseAll: Comprimi Tutto +stats: + modernPatterns: Pattern Moderni + jdkVersions: Versioni JDK Coperte + categories: Categorie + linesOfPython: Righe di Python Richieste +footer: + tagline: Java si è evoluto. Anche il tuo codice può. + madeWith: Fatto con ❤️ da + and: e + inspiredBy: Ispirato da + viewOnGitHub: Vedi su GitHub +copilot: + headline: Modernizza il tuo codice Java con GitHub Copilot. + description: Lascia che Copilot ti aiuti a migrare i pattern legacy a Java moderno + — automaticamente. + appModernization: Modernizzazione App → + javaGuide: Guida Java → +support: + available: Disponibile + preview: Anteprima + experimental: Sperimentale +contribute: + button: Contribuisci + codeIssue: Segnala un problema nel codice + translationIssue: Segnala un problema di traduzione + suggestPattern: Suggerisci un nuovo pattern + seeIssue: "Vedi un problema con questo codice?" + reportIt: "Faccelo sapere." +untranslated: + notice: Questa pagina non è ancora stata tradotta in {{localeName}}. + viewInEnglish: Visualizza in Inglese