# Blog

102 articles.

### [Architettura delle Pipeline RAG: Strategie di Chunking, Ricerca Ibrida, Reranking e Framework di Valutazione](https://lucioduran.com/it/blog/rag-pipeline-architecture-chunking-reranking-evaluation)
2026-04-16 · AI/ML · 13 min

Una guida orientata alla produzione per costruire pipeline di Retrieval-Augmented Generation — dall'ingestione dei documenti e strategie di chunking alla ricerca ibrida, reranking con cross-encoder e valutazione sistematica con RAGAS e metriche personalizzate.

### [TLA+ per la Verifica Formale: Trovare Bug nei Sistemi Distribuiti Prima di Scrivere una Singola Riga di Codice](https://lucioduran.com/it/blog/formal-verification-tla-plus-distributed-systems)
2026-03-18 · Distributed Systems · 7 min

Modellare sistemi distribuiti con logica temporale, eseguire il model checker TLC, e un esempio reale di come TLA+ ha trovato un bug nel protocollo di ribilanciamento dei consumer group di Kafka che il testing non avrebbe mai trovato.

### [Pattern di Architettura per IA Agentica: Orchestrazione degli Strumenti e Coordinazione Multi-Agente](https://lucioduran.com/it/blog/agentic-ai-architecture-patterns)
2026-03-16 · IA Agentica · 6 min

Analisi dei pattern architetturali dei sistemi di IA agentica — dall'orchestrazione degli strumenti alla coordinazione multi-agente — con approcci testati in produzione e relativi compromessi.

### [WebCodecs API: Codifica e Decodifica Video Accelerata via Hardware nel Browser](https://lucioduran.com/it/blog/webcodecs-api-video-processing-browser)
2026-03-15 · Web APIs · 5 min

Encoding e decoding video a basso livello senza [FFmpeg.wasm](https://ffmpegwasm.netlify.app/) — VideoEncoder, VideoDecoder, encoding AV1, e costruzione di una pipeline di effetti video in tempo reale interamente nel browser.

### [Evoluzione del Service Mesh: Istio Ambient Mesh, Linkerd e le Architetture Senza Sidecar](https://lucioduran.com/it/blog/service-mesh-ambient-mesh-istio-linkerd)
2026-03-13 · Infrastructure · 5 min

Valutazione dei data plane senza sidecar: ztunnel, la separazione dell'elaborazione L4/L7, mTLS senza sidecar, e misurazioni dell'overhead di latenza confrontando Istio ambient vs sidecar vs Linkerd.

### [Drizzle ORM: SQL Type-Safe per PostgreSQL — Migrazioni, Prepared Statement e Confronto con Prisma](https://lucioduran.com/it/blog/drizzle-orm-type-safe-sql-postgresql)
2026-03-11 · Backend · 5 min

Sintassi SQL-like che è realmente type-safe, zero overhead a runtime, supporto edge runtime, e un confronto onesto con Prisma e Kysely.

### [TLS 1.3 + Post-Quantum: Scambio di Chiavi Ibrido ML-KEM (Kyber) nel Mondo Reale](https://lucioduran.com/it/blog/tls-1-3-post-quantum-kyber-hybrid)
2026-03-10 · Security · 7 min

Dentro l'handshake ibrido X25519Kyber768 — come Chrome e Firefox implementano TLS post-quantistico, implicazioni per certificate transparency, e cosa devi cambiare oggi.

### [Model Context Protocol (MCP): Il Livello di Standardizzazione Mancante per l'Integrazione AI-Strumenti](https://lucioduran.com/it/blog/model-context-protocol-mcp-ai-integration)
2026-03-08 · AI/ML · 9 min

Un'immersione profonda nell'architettura di MCP — livelli di trasporto, primitive resource/tool/prompt, e come costruire server MCP custom che funzionino in modo affidabile in produzione.

### [Programmazione GPU: CUDA vs ROCm vs Vulkan Compute — Warp Scheduling, Shared Memory e Moltiplicazione di Matrici](https://lucioduran.com/it/blog/gpu-programming-cuda-vs-rocm-vulkan-compute)
2026-03-06 · GPU Computing · 8 min

Oltre i tutorial — warp divergence, bank conflict della shared memory, tuning dell'occupancy, e un kernel di moltiplicazione di matrici che performa davvero. Con benchmark.

### [Speculation Rules API: Pre-rendering di Pagine Prima della Navigazione e Impatto Misurato sui Core Web Vitals](https://lucioduran.com/it/blog/speculation-rules-api-prerender-navigation)
2026-03-05 · Web Performance · 6 min

Un esame tecnico della Speculation Rules API per prerender e prefetch, strategie di speculazione basate sulla confidenza, dettagli dell'implementazione Chrome, e miglioramenti misurabili dei Core Web Vitals inclusa l'ottimizzazione INP.

### [RISC-V + Rust Firmware: Costruire un Nodo IoT di Sensori con Embassy-rs sull'ESP32-C6](https://lucioduran.com/it/blog/risc-v-embedded-systems-rust-firmware)
2026-03-03 · Embedded · 7 min

Una guida pratica per scrivere firmware Rust no_std per target RISC-V usando il runtime async embassy-rs, astrazioni HAL, e un progetto IoT reale con l'ESP32-C6 con WiFi 6 e BLE 5.

### [ClickHouse: OLAP Colonnare per Analytics Real-Time su 10 Miliardi di Righe](https://lucioduran.com/it/blog/clickhouse-olap-real-time-analytics-architecture)
2026-03-01 · Databases · 6 min

Guida architetturale di ClickHouse per analytics real-time: internals del motore MergeTree, viste materializzate per pre-aggregazione, ottimizzazione query su tabelle da 10B+ righe, e analisi comparativa con DuckDB e Druid.

### [Temporal.io: Sostituire le Code di Messaggi con Esecuzione Durabile per Orchestrazione Complessa](https://lucioduran.com/it/blog/temporal-workflow-engine-durable-execution)
2026-02-28 · Backend · 9 min

Analisi del modello di esecuzione durabile di Temporal, i vincoli di determinismo dei workflow, retry delle activity, pattern saga, e perché l'esecuzione durabile supera l'orchestrazione costruita sopra code di messaggi.

### [SPDK + NVMe: Costruire un Storage Engine in User-Space che Raggiunge 10M IOPS](https://lucioduran.com/it/blog/spdk-nvme-storage-performance-optimization)
2026-02-26 · Systems Programming · 9 min

Un percorso tecnico approfondito dei driver NVMe in user-space di SPDK, polled I/O, zero-copy DMA, e come ho costruito uno storage engine che sostiene 10 milioni di IOPS su hardware commodity.

### [Crittografia Omomorfa in Pratica: TFHE, Concrete-ML e Inferenza ML su Dati Crittografati](https://lucioduran.com/it/blog/homomorphic-encryption-tfhe-concrete-ml)
2026-02-24 · Cryptography · 6 min

Una guida pratica a TFHE, Concrete-ML di Zama, computazione su dati crittografati, vera inferenza ML su ciphertext, e la realtà onesta delle performance della crittografia omomorfa.

### [Event Sourcing + CQRS: Design dell'Event Store, Proiezioni, Snapshot e Quando NON Usarlo](https://lucioduran.com/it/blog/event-sourcing-cqrs-production-lessons)
2026-02-22 · Architecture · 6 min

Lezioni dalla produzione nella costruzione di sistemi event-sourced — design dell'event store, rebuild delle proiezioni, strategie di snapshot, orchestrazione saga, e una valutazione onesta di quando l'event sourcing peggiora le cose.

### [Content Layer API, Server Islands e View Transitions in Astro 5](https://lucioduran.com/it/blog/astro-5-view-transitions-content-collections)
2026-02-21 · Frontend · 9 min

Analisi della content layer API di Astro 5, dell'architettura server islands e delle view transitions, con benchmark di produzione che confrontano le prestazioni con Next.js per siti content-driven.

### [Supabase Realtime: Costruire Feature Multiplayer Senza Gestire un Singolo Server WebSocket](https://lucioduran.com/it/blog/supabase-realtime-presence-multiplayer)
2026-02-19 · Backend · 4 min

Tracking della presenza, canali broadcast, Postgres CDC e scalare connessioni WebSocket — una guida pratica per costruire feature multiplayer con Supabase Realtime.

### [eBPF e XDP: Elaborazione Pacchetti ad Alte Prestazioni e Mitigazione DDoS a Line Rate](https://lucioduran.com/it/blog/bpf-xdp-high-performance-packet-processing)
2026-02-17 · Networking · 6 min

Elaborazione pacchetti ad alte prestazioni con eBPF e XDP: programmi XDP in C, socket AF_XDP, mitigazione DDoS a line rate e analisi del dataplane di Cilium.

### [Cloudflare Durable Objects: Costruzione di un Game Server Stateful all'Edge](https://lucioduran.com/it/blog/edge-computing-durable-objects-cloudflare)
2026-02-16 · Edge Computing · 7 min

Computazione stateful all'edge con Cloudflare Durable Objects — coordinazione WebSocket, modello ad attori all'edge, e un'architettura di server di gioco multiplayer in 300+ località.

### [Privacy Differenziale e Federated Learning: Architettura di Pipeline ML Sanitari Conformi HIPAA](https://lucioduran.com/it/blog/differential-privacy-federated-learning-production)
2026-02-14 · AI/ML · 6 min

Budget di epsilon, meccanismi di rumore, aggregazione sicura e PySyft in pratica — un'architettura di pipeline di federated learning per imaging medico capace di superare audit HIPAA.

### [Concorrenza Strutturata in Java 21: Virtual Thread e Architettura Server](https://lucioduran.com/it/blog/structured-concurrency-java-21-virtual-threads)
2026-02-12 · JVM · 8 min

Un esame della concorrenza strutturata di Project Loom, virtual thread, scoped value e StructuredTaskScope — e come trasformano radicalmente l'architettura server sulla JVM.

### [Mojo come Superset Python: Prestazioni su Carichi di Lavoro ML di Produzione](https://lucioduran.com/it/blog/mojo-language-python-superset-performance)
2026-02-11 · Programming Languages · 6 min

Benchmarking di Mojo contro Python, Rust e C++ su pipeline di inferenza ML reali. Compilazione MLIR, modello di ownership, tipi SIMD, e perché l'affermazione '68.000x più veloce di Python' ha bisogno di serio contesto.

### [ARIA Live Region, Architettura degli Screen Reader e Metodologia Sistematica di Audit](https://lucioduran.com/it/blog/accessibility-aria-live-regions-screen-reader)
2026-02-09 · Accessibility · 4 min

Guida tecnica all'accessibilità web: ARIA live region, analisi del DOM da parte degli screen reader, pattern di gestione del focus e metodologia sistematica di audit con test automatizzati axe-core.

### [Scalare WebRTC a 10.000 Partecipanti: Confronto tra mediasoup, LiveKit e Janus](https://lucioduran.com/it/blog/webrtc-media-servers-mediasoup-livekit)
2026-02-07 · Real-time · 7 min

Un confronto collaudato in produzione dei media server WebRTC. Architettura SFU vs MCU, configurazione simulcast, negoziazione codec VP9/AV1, e i pattern di scaling che funzionano davvero quando servono 10.000 partecipanti contemporanei.

### [Gateway API di Kubernetes: Sostituire Ingress con Envoy Gateway e Cilium](https://lucioduran.com/it/blog/kubernetes-gateway-api-envoy-cilium)
2026-02-06 · Infrastructure · 5 min

Analisi della migrazione di 200+ servizi da nginx-ingress a Gateway API con Envoy Gateway e Cilium mesh. HTTPRoute, TLS passthrough, traffic splitting, e perché la risorsa Ingress è sempre stata un'astrazione limitata.

### [Il Comptime di Zig: Un Approccio Unificato alla Programmazione di Sistemi in Compile-Time](https://lucioduran.com/it/blog/zig-language-comptime-system-programming)
2026-02-04 · Systems Programming · 10 min

L'esecuzione di codice a compile-time in Zig sostituisce macro, generics e compilazione condizionale in un unico meccanismo. Ricostruire un parser di pacchetti in Zig rivela come comptime sfida le assunzioni radicate nella manutenzione tradizionale di progetti C.

### [Valkey vs Redis: Migrare 14TB di Dati in Produzione — Cosa la Documentazione Non Copre](https://lucioduran.com/it/blog/valkey-redis-fork-performance-analysis)
2026-02-02 · Databases · 10 min

Analisi dell'I/O multi-threaded di Valkey, del protocollo RESP3 e delle ottimizzazioni di memoria. Include una migrazione reale da Redis 7.2, metodologia di benchmark e le insidie riscontrate in produzione.

### [Signals e Reattività Fine-Grained: Angular, SolidJS, Preact e la Transizione dal Diffing del Virtual DOM](https://lucioduran.com/it/blog/signals-reactivity-angular-solid-preact)
2026-02-01 · Frontend · 10 min

La reattività fine-grained sta vincendo. Ho tracciato il pattern dei signals da SolidJS attraverso Angular 17+ e Preact Signals, analizzato la proposta TC39, e benchmarkato perché il diffing del virtual DOM sta diventando un lusso costoso.

### [Algoritmi di Bilanciamento del Carico: Maglev Hashing, Consistent Hashing con Carichi Limitati e P2C](https://lucioduran.com/it/blog/load-balancing-algorithms-maglev-consistent-hashing)
2026-01-30 · Infrastructure · 4 min

Analisi degli algoritmi moderni di bilanciamento del carico — Maglev hashing di Google, consistent hashing con carichi limitati, power of two choices e configurazioni di produzione HAProxy/Envoy.

### [WireGuard Mesh Networking: Gli Internals di Tailscale e Headscale Spiegati](https://lucioduran.com/it/blog/wireguard-mesh-networking-tailscale-internals)
2026-01-28 · Networking · 9 min

Come Tailscale costruisce una rete mesh sopra WireGuard. Server DERP relay, NAT traversal, MagicDNS, e una guida pratica per costruire la propria rete privata overlay con Headscale.

### [LLVM MLIR: Costruire Dialetti Compilatore Custom per Ottimizzazione di Dominio](https://lucioduran.com/it/blog/llvm-mlir-compiler-infrastructure-custom-dialects)
2026-01-27 · Compilers · 9 min

Analisi dell'architettura di rappresentazione intermedia multi-livello di MLIR, costruzione di dialetti personalizzati e la convergenza di compilatori ML, acceleratori hardware e DSL sul framework MLIR.

### [HSM e Cloud KMS: PKCS#11, Envelope Encryption e Architettura Reale di Gestione dei Segreti](https://lucioduran.com/it/blog/hardware-security-modules-hsm-cloud-kms)
2026-01-25 · Security · 6 min

Un walkthrough tecnico approfondito su moduli di sicurezza hardware, servizi cloud KMS, interfacce PKCS#11, pattern di envelope encryption, e come costruire un'architettura di gestione segreti che sopravviva a un audit.

### [CSS Anchor Positioning + Popover API: Finalmente, Tooltip Senza JavaScript](https://lucioduran.com/it/blog/css-anchor-positioning-popover-api-2026)
2026-01-23 · Frontend · 8 min

Costruzione di tooltip, dropdown e UI fluttuante interamente in CSS con la funzione anchor(), position-try-fallbacks e la Popover API. Cosa funziona davvero nei browser oggi e dove la spec ha ancora spigoli.

### [Kafka vs Redpanda: Benchmark di Event Streaming e Analisi della Migrazione](https://lucioduran.com/it/blog/kafka-vs-redpanda-event-streaming-benchmarks)
2026-01-22 · Infrastructure · 9 min

Un confronto testa a testa tra Apache Kafka e Redpanda. Raft vs ZooKeeper, C++ vs overhead JVM, tail latency al p99, schema registry, e un'analisi dettagliata di una migrazione di 2TB/giorno di event stream.

### [WASM GC: Tipi con Garbage Collection in WebAssembly](https://lucioduran.com/it/blog/wasm-gc-garbage-collection-browser-runtimes)
2026-01-20 · WebAssembly · 8 min

La proposta WASM GC porta struct e array con garbage collection automatica in WebAssembly. Questo articolo esamina l'impatto su Kotlin/WASM, Dart/WASM e l'architettura dei browser runtime.

### [Framework di Orchestrazione AI: Semantic Kernel vs LangChain vs LlamaIndex](https://lucioduran.com/it/blog/semantic-kernel-langchain-ai-orchestration)
2026-01-18 · AI/ML · 5 min

Un confronto reale tra framework di orchestrazione AI — architetture plugin, gestione della memoria e costruzione di pipeline RAG con ciascuno per vedere dove differiscono davvero sul campo.

### [Pattern di Function Calling negli LLM per Tool Use Affidabile negli Agenti AI](https://lucioduran.com/it/blog/llm-function-calling-tool-use-patterns)
2026-01-17 · AI/ML · 7 min

Guida tecnica al tool use degli LLM — structured output, tool call paralleli, strategie di retry, recupero errori, pattern di orchestrazione e lezioni dallo sviluppo di agenti AI in produzione.

### [Code Review Automatizzato: Regole Custom Semgrep, Pattern Matching AST e Costruzione di Scanner di Sicurezza Specifici per l'Organizzazione](https://lucioduran.com/it/blog/ai-code-review-ast-analysis-semgrep-custom-rules)
2026-01-15 · Developer Tools · 3 min

Una guida pratica al code review automatizzato con Semgrep — scrivere regole custom con pattern matching AST, taint analysis per tracciare dati non fidati, costruire scanner di sicurezza specifici per l'organizzazione, e integrare tutto nella CI per enforcement automatico.

### [PostgreSQL CDC con Debezium: Replica Logica, Decodifica WAL e Architettura Event-Driven Reale](https://lucioduran.com/it/blog/postgres-logical-replication-cdc-debezium)
2026-01-13 · Databases · 3 min

Una guida tecnica approfondita al Change Data Capture in PostgreSQL con Debezium — slot di replica logica, internals della decodifica WAL, il pattern transactional outbox, e costruzione di architettura event-driven in produzione con Kafka Connect.

### [Linux io_uring: Architettura I/O Asincrono e Integrazione con Node.js](https://lucioduran.com/it/blog/linux-io-uring-async-io-nodejs-integration)
2026-01-11 · Systems Programming · 6 min

Analisi a livello di sistema di io_uring — code di submission/completion, buffer registrati, file fissi, polling kernel-side e benchmark che confrontano io_uring con epoll e I/O sincrono per diversi carichi di lavoro.

### [Database Time Series: TimescaleDB Hypertable, QuestDB Columnar e InfluxDB IOx](https://lucioduran.com/it/blog/time-series-databases-timescaledb-questdb-influx)
2026-01-10 · Databases · 7 min

Costruire un pipeline IoT reale che gestisce 1M insert/sec — confrontando TimescaleDB hypertable, il motore columnar di QuestDB e InfluxDB IOx con benchmark reali e insidie di produzione.

### [Stack di Privacy DNS: DoH, DoT, DNSSEC, Encrypted Client Hello e Analisi Comparativa della Privacy](https://lucioduran.com/it/blog/dns-over-https-encrypted-client-hello-privacy)
2026-01-08 · Networking · 3 min

Una guida completa allo stack di privacy DNS — DNS-over-HTTPS, DNS-over-TLS, validazione DNSSEC, Encrypted Client Hello (ECH), Oblivious DoH, con analisi onesta di cosa protegge davvero ogni protocollo e una guida pratica all'implementazione.

### [gRPC + Protobuf + ConnectRPC: API Type-Safe con Streaming e Generazione del Codice](https://lucioduran.com/it/blog/grpc-protobuf-connectrpc-api-design)
2026-01-06 · API Design · 6 min

Un deep dive pratico in gRPC, Protocol Buffers e ConnectRPC per costruire API type-safe con streaming — confronti onesti con REST e tRPC, reflection, problemi di load balancing e codice production-ready.

### [Apache Arrow DataFusion: Costruire Query Engine Personalizzati in Rust](https://lucioduran.com/it/blog/arrow-datafusion-query-engine-rust)
2026-01-05 · Data Engineering · 3 min

Una guida pratica su Apache Arrow DataFusion — costruire query engine personalizzati in Rust con esecuzione colonnare, modelli push-based vs pull-based, custom table provider, funzioni definite dall'utente, e tuning reale delle performance per workload analitici.

### [Streaming HTML: Out-of-Order Streaming, Island Architecture e Idratazione Selettiva](https://lucioduran.com/it/blog/streaming-html-out-of-order-island-architecture)
2026-01-03 · Frontend · 7 min

Un esame delle strategie di streaming HTML con Marko, Qwik e Astro — out-of-order streaming, internals dell'island architecture, e perché l'idratazione progressiva cambia tutto nelle performance web.

### [React Server Components: Architettura Streaming, Costi Prestazionali e Pattern di Migrazione](https://lucioduran.com/it/blog/react-server-components-streaming-architecture)
2026-01-01 · Frontend · 7 min

Un deep dive nei React Server Components, streaming SSR, Suspense boundaries e server actions — con benchmark onesti sul costo reale dei client components e pattern di migrazione pratici.

### [Sicurezza della Supply Chain: Sigstore, SLSA, SBOM e Protezione della Pipeline di Build End-to-End](https://lucioduran.com/it/blog/supply-chain-security-sigstore-slsa-sbom)
2025-12-31 · Security · 6 min

Una guida tecnica alla sicurezza della supply chain software — dalla firma keyless con Sigstore cosign e compliance al framework SLSA alla generazione di SBOM con CycloneDX, npm provenance, e costruzione di una pipeline difendibile che catturi davvero gli attacchi che contano.

### [Passkeys e WebAuthn: Guida all'Implementazione in Produzione per l'Autenticazione FIDO2 Senza Password](https://lucioduran.com/it/blog/passkeys-webauthn-passwordless-implementation)
2025-12-29 · Security · 7 min

Una guida brutalmente onesta all'implementazione di passkeys FIDO2 con WebAuthn — credenziali residenti, autenticazione cross-device, cerimonie di attestation, e tutti gli edge case che vi rovineranno il weekend.

### [Platform Engineering: Costruire IDP con Backstage e Port](https://lucioduran.com/it/blog/platform-engineering-idp-backstage-port)
2025-12-27 · DevOps · 8 min

Guida pratica per costruire Internal Developer Platform che gli sviluppatori vogliono davvero usare — plugin Backstage, blueprint Port, golden path e le metriche di developer experience che contano.

### [Pipeline di Rendering GPU: Blend Mode, Compositing Porter-Duff e Rendering Tile-Based](https://lucioduran.com/it/blog/blend-mode-compositing-gpu-rendering-pipeline)
2025-12-26 · Graphics · 11 min

Analisi del pipeline di rendering GPU: blend mode e compositing Porter-Duff, tile-based rendering, il backend GPU di Skia, l'approccio compute-shader di Vello e tecniche pratiche di GPU profiling per contenuti web.

### [TypeScript 5.5: Type Predicate Inferiti, Isolated Declarations e Gotcha del Mondo Reale](https://lucioduran.com/it/blog/typescript-5-5-type-predicates-inference)
2025-12-24 · TypeScript · 9 min

Analisi delle funzionalità più importanti di TypeScript 5.5: type predicate inferiti che funzionano davvero, isolated declarations per build più veloci, miglioramenti config extends, regex type narrowing e pattern che ti morderanno.

### [Ottimizzazione dell'Inferenza LLM: KV-Cache, PagedAttention ed Efficienza della Memoria GPU](https://lucioduran.com/it/blog/llm-inference-optimization-kv-cache-paged-attention)
2025-12-22 · AI/ML · 10 min

Analisi della meccanica di ottimizzazione dell'inferenza LLM — dalla gestione del KV-cache e PagedAttention in vLLM al continuous batching, speculative decoding e FlashAttention-3, con misurazioni di throughput da deployment in produzione.

### [Infrastruttura Immutabile: Golden Image con Packer, Pipeline AMI, Deployment Blue-Green e la Vera Migrazione dai Server Mutabili](https://lucioduran.com/it/blog/immutable-infrastructure-packer-golden-images)
2025-12-21 · DevOps · 4 min

Una guida pratica all'infrastruttura immutabile — costruire golden image con Packer, automatizzare pipeline AMI, implementare deployment blue-green, eliminare il configuration drift, e la storia onesta di migrare un sistema di produzione dai server mutabili.

### [Internals dei Container Runtime: runc, youki, kata-containers e Modelli di Isolamento Sandbox](https://lucioduran.com/it/blog/container-runtime-internals-runc-youki-kata)
2025-12-19 · Containers · 8 min

Deep dive negli internals dei container runtime — runc vs youki (Rust), microVM kata-containers, sandboxing gVisor, controllo risorse cgroup v2 e isolamento namespace con trace di syscall reali.

### [Next.js 15 PPR: Partial Prerendering, Static Shell, e la Fine del Dibattito ISR vs SSR](https://lucioduran.com/it/blog/next-js-15-ppr-partial-prerendering)
2025-12-17 · Frontend · 5 min

Come il Partial Prerendering di Next.js 15 combina rendering statico e dinamico in una singola richiesta. Static shell + dynamic hole via Suspense, misurazioni reali di TTFB, e guida pratica alla migrazione da ISR.

### [CRDT per Software Local-First: App Collaborative Senza Server](https://lucioduran.com/it/blog/crdts-local-first-software-architecture)
2025-12-16 · Distributed Systems · 8 min

Deep dive nei CRDT con Yjs e Automerge 2.0. Operation-based vs state-based, strategie di risoluzione conflitti e pattern reali per costruire app collaborative che funzionano offline.

### [WebNN API: ML Accelerato Hardware nel Browser, Accesso NPU e Benchmark Reali di Inferenza On-Device](https://lucioduran.com/it/blog/webnn-api-hardware-accelerated-ml-browser)
2025-12-14 · AI/ML · 3 min

Un'esplorazione pratica della WebNN API — accedere a NPU e GPU dal browser per l'inferenza ML, esecuzione di modelli ONNX, confronti reali di benchmark con WASM e WebGPU, e pattern di AI che preservano la privacy mantenendo i dati sul dispositivo.

### [Formati di Storage Colonnare: Architettura e Ottimizzazione di Parquet, Lance, Delta Lake e Iceberg](https://lucioduran.com/it/blog/column-oriented-storage-parquet-lance-delta)
2025-12-12 · Data Engineering · 5 min

Comprendere i formati di storage colonnare dall'interno: row group, predicate pushdown, dictionary encoding, e ottimizzazione pratica delle query su Apache Parquet, Lance, Delta Lake e Apache Iceberg.

### [OpenTelemetry in Produzione: Implementazione di Distributed Tracing e Controllo dei Costi](https://lucioduran.com/it/blog/opentelemetry-distributed-tracing-microservices)
2025-12-11 · Observability · 8 min

Trappole dell'auto-strumentazione, custom span utili davvero, propagazione baggage, Jaeger vs Tempo a confronto, trace-based testing e come non andare in bancarotta con i costi di observability.

### [Unikernel vs MicroVM: Gli Internals di Firecracker, Unikraft, e il Vero Costo dell'Isolamento Serverless](https://lucioduran.com/it/blog/unikernels-firecracker-microvm-serverless)
2025-12-09 · Infrastructure · 5 min

Confronto esaustivo tra Firecracker MicroVM e unikernel Unikraft: benchmark dei tempi di boot, analisi dell'impronta di memoria, internals di KVM, e cosa fornisce realmente l'isolamento per le funzioni serverless in produzione.

### [TCP vs QUIC vs HTTP/3: Kernel Bypass, Zero-Copy e Ottimizzazione della Latenza](https://lucioduran.com/it/blog/tcp-quic-http3-kernel-bypass-performance)
2025-12-07 · Networking · 8 min

Benchmark reali a confronto tra TCP, QUIC e HTTP/3 con io_uring, DPDK e zero-copy networking. Algoritmi di controllo congestione analizzati con misurazioni reali di latenza in produzione.

### [Architettura Basata su Celle: Isolamento del Raggio d'Esplosione, Shuffle Sharding e Come AWS e Slack Riducono i Domini di Guasto](https://lucioduran.com/it/blog/cell-based-architecture-blast-radius-isolation)
2025-12-06 · Architecture · 4 min

Uno sguardo tecnico approfondito sull'architettura basata su celle — come isolare i guasti a una frazione di utenti attraverso celle indipendenti, shuffle sharding, routing delle celle e pattern di implementazione reali tratti da AWS, Slack e sistemi di produzione.

### [Scroll-Driven Animations con CSS scroll-timeline, ViewTimeline e la Web Animations API](https://lucioduran.com/it/blog/web-animations-api-scroll-driven-animations)
2025-12-04 · Frontend · 5 min

Costruire animazioni scroll-driven performanti con zero JavaScript usando CSS scroll-timeline, animation-range, e la Web Animations API. Esempi reali che sostituiscono [GSAP](https://gsap.com/) ScrollTrigger e hack con Intersection Observer.

### [Database Vettoriali a Confronto: Eseguire la Stessa Pipeline RAG su pgvector, Qdrant, Pinecone e Weaviate](https://lucioduran.com/it/blog/vector-databases-pgvector-qdrant-pinecone)
2025-12-02 · AI/ML · 9 min

Benchmark onesti che confrontano pgvector 0.8, Qdrant, Pinecone e Weaviate per una pipeline RAG reale. Indicizzazione HNSW vs IVF, tradeoff di quantizzazione, latenza a scala, e raccomandazioni pratiche per diversi casi d'uso.

### [MLOps Feature Store: Feast, Tecton, Feature Real-Time e Architettura di Pipeline ML in Produzione](https://lucioduran.com/it/blog/mlops-feature-stores-feast-tecton-production)
2025-11-30 · AI/ML · 4 min

Guida tecnica ai feature store nel ML di produzione — coprendo Feast e Tecton, point-in-time join, serving di feature real-time, rilevamento di feature drift e l'architettura che fa funzionare tutto senza collassare sotto la propria complessità.

### [Deterministic Simulation Testing: Metodologia di Iniezione Guasti in TigerBeetle e FoundationDB](https://lucioduran.com/it/blog/deterministic-simulation-testing-tigerbeetle)
2025-11-29 · Testing · 7 min

Iniezione di guasti basata su seed, scheduling deterministico, e la metodologia dietro la scoperta di bug impossibili nei sistemi distribuiti. Tecniche reali dai framework di testing di TigerBeetle e FoundationDB.

### [Effect-TS: Effetti Algebrici e Gestione Errori Tipizzata in TypeScript](https://lucioduran.com/it/blog/effect-ts-algebraic-effects-error-handling)
2025-11-27 · TypeScript · 9 min

Un'analisi di Effect-TS: effetti algebrici per TypeScript, concorrenza strutturata, errori tipizzati, scheduling basato su Fiber, e perché sostituire il caos del try-catch con un vero sistema di effetti rende il codice drammaticamente più affidabile.

### [Sicurezza Basata su Capability con WASI Preview 2: Sistemi di Plugin con Least-Privilege a Livello di Runtime](https://lucioduran.com/it/blog/capability-based-security-wasi-preview2)
2025-11-25 · Security · 7 min

Come il modello di capability di WASI Preview 2 applica il least-privilege a livello di runtime. Sandboxing del filesystem, capability di rete, wasi-http, e architetture di plugin sicure per la produzione.

### [Database a Grafo: Neo4j vs SurrealDB vs Apache AGE — Cypher, GQL e Ottimizzazione Reale di Query Social Network](https://lucioduran.com/it/blog/graph-databases-neo4j-surrealdb-age-comparison)
2025-11-24 · Databases · 6 min

Un confronto pratico di tre approcci ai database a grafo — Neo4j (grafo nativo), SurrealDB (multi-modello) e Apache AGE (estensione PostgreSQL). Copre Cypher vs lo standard GQL emergente, modelli property graph e ottimizzazione reale di query da un progetto di social network.

### [Benchmark di Migrazione a Graviton4 ARM64: Dati Reali di Performance in Produzione](https://lucioduran.com/it/blog/arm64-graviton4-server-migration-benchmarks)
2025-11-22 · Infrastructure · 9 min

Benchmark di produzione dalla migrazione di workload a istanze AWS Graviton4 ARM64. Differenze di performance tra Node.js, Go e Rust, insidie NEON SIMD, flag del compilatore che contano, e il risparmio reale dopo 4 mesi.

### [ScyllaDB: Architettura Shard-Per-Core, Benchmark di Latenza e Migrazione da Cassandra](https://lucioduran.com/it/blog/scylladb-cassandra-compatible-low-latency)
2025-11-20 · Databases · 8 min

Un'analisi approfondita dell'architettura shard-per-core di ScyllaDB, gli internals del framework Seastar, e benchmark reali di latenza p99 contro Apache Cassandra. Più una guida alla migrazione testata in produzione.

### [Nix Flakes come Sostituto di Docker per gli Ambienti di Sviluppo Locale](https://lucioduran.com/it/blog/nix-flakes-reproducible-dev-environments)
2025-11-19 · DevOps · 9 min

Una guida pratica a Nix Flakes per ambienti di sviluppo riproducibili: anatomia di flake.nix, devShells, sostituzione di Docker per lo sviluppo locale, cross-compilazione e una migrazione documentata con tutti i punti dolenti.

### [Crossplane: Composizione dell'Infrastruttura su Kubernetes, Sostituire Terraform con IaC GitOps-Native](https://lucioduran.com/it/blog/crossplane-infrastructure-composition-kubernetes)
2025-11-17 · DevOps · 5 min

Guida pratica a Crossplane — composizione dell'infrastruttura su Kubernetes usando XRD, composition e provider-aws. Come abbiamo sostituito Terraform con un approccio IaC GitOps-native e cosa abbiamo imparato nel processo.

### [Async Rust: Internals del Runtime Tokio, Work-Stealing e Costruire un Runtime Minimo da Zero](https://lucioduran.com/it/blog/async-rust-tokio-internals-runtime-design)
2025-11-15 · Rust · 9 min

Un'esplorazione tecnica profonda di come funziona realmente Tokio — lo scheduler work-stealing, l'I/O driver, la timer wheel, il meccanismo waker e la storia di Pin. Poi costruiamo un runtime async minimale da zero per consolidare il modello mentale.

### [HTMX 2.0: Applicazioni Hypermedia in Produzione](https://lucioduran.com/it/blog/htmx-2-hypermedia-driven-applications)
2025-11-14 · Frontend · 7 min

Un'analisi tecnica dell'approccio hypermedia di HTMX 2.0, hx-boost, estensioni WebSocket e server-sent events. Include benchmark comparativi con React e una valutazione di quando l'approccio è appropriato.

### [Tecniche di Compilazione JIT: Cranelift, Copy-and-Patch e CPython 3.13](https://lucioduran.com/it/blog/jit-compilation-cranelift-copy-patch-techniques)
2025-11-12 · Compilers · 5 min

Analisi delle tecniche moderne di compilazione JIT — l'approccio di Cranelift alla generazione rapida di codice, copy-and-patch, strategie di compilazione a livelli, allocazione dei registri e l'architettura interna del compilatore JIT sperimentale di CPython 3.13.

### [CSS :has() Selector: Quantity Query, Selezione del Genitore e Pattern Precedentemente Impossibili](https://lucioduran.com/it/blog/css-has-selector-quantity-queries-patterns)
2025-11-10 · Frontend · 7 min

Un'analisi del selettore CSS :has() — dalla selezione del genitore e i combinatori di fratelli alle quantity query e pattern responsive che genuinamente non potevano esistere prima. Con considerazioni sulle performance che contano su scala.

### [Deno 2: Compatibilità Completa con Node, Fresh 2.0 e Benchmark Comparativi Contro Node 22 e Bun](https://lucioduran.com/it/blog/deno-2-node-compat-fresh-framework)
2025-11-09 · JavaScript Runtimes · 7 min

Una valutazione tecnica onesta del layer di compatibilità Node.js di Deno 2, npm specifier, architettura island di Fresh 2.0, e benchmark di performance che raccontano una storia più sfumata di quanto suggerisca il marketing.

### [Smithy: Il Linguaggio di Modellazione API di AWS e Come Costruire il Tuo Generatore SDK](https://lucioduran.com/it/blog/smithy-api-modeling-aws-sdk-generation)
2025-11-07 · API Design · 4 min

Esame di Smithy — il linguaggio di modellazione API protocol-agnostic di AWS, la sua pipeline di generazione codice, validatori custom, sistema di trait, e come costruire il tuo generatore SDK da un modello Smithy.

### [Object Storage S3-Compatible: MinIO, Tigris, R2 e gli Internals del Multipart Upload](https://lucioduran.com/it/blog/object-storage-s3-compatible-minio-tigris)
2025-11-05 · Infrastructure · 9 min

Un percorso tecnico nelle viscere dell'object storage S3-compatible — dalla meccanica dei multipart upload e la sicurezza delle presigned URL alla costruzione del proprio layer CDN con edge caching su MinIO, Tigris e Cloudflare R2.

### [Zero-Knowledge Proof per l'Autenticazione: Verifica dell'Identità con Preservazione della Privacy](https://lucioduran.com/it/blog/zero-knowledge-proofs-web3-authentication)
2025-11-04 · Cryptography · 7 min

Come implementare autenticazione basata su ZK usando zk-SNARK, Groth16 e Plonk. Design di circuiti Circom, esempi pratici di prova d'identità senza rivelare credenziali, e perché ZK auth è utile ben oltre il Web3.

### [Micro-Frontend nel 2026: Module Federation 2.0, Native Federation e Import Maps](https://lucioduran.com/it/blog/micro-frontends-module-federation-native-federation)
2025-11-02 · Frontend · 7 min

Guida esaustiva all'architettura micro-frontend nel 2026 — Module Federation 2.0, Native Federation, import maps, gestione dello stato condiviso e una migrazione documentata da monolite SPA a frontend deployabili indipendentemente.

### [WASI Threads: Il Parallelismo con Memoria Condivisa Arriva in WebAssembly](https://lucioduran.com/it/blog/wasi-threads-shared-memory-parallel-wasm)
2025-10-31 · WebAssembly · 4 min

Shared memory in WebAssembly, atomics, computazione parallela, SharedArrayBuffer — esplorando i WASM threads attraverso un'implementazione di ray tracer per separare la realtà dall'esagerazione.

### [SQLite all'Edge: LiteFS, Turso, e Perché Postgres Non È Sempre la Risposta](https://lucioduran.com/it/blog/sqlite-litefs-distributed-edge-databases)
2025-10-30 · Databases · 9 min

Una guida pratica per eseguire SQLite come database distribuito all'edge. Meccaniche di replicazione LiteFS, estensioni libSQL, architettura Turso, e benchmark reali che mostrano quando SQLite distrugge Postgres per workload read-heavy all'edge.

### [Algoritmi di Consenso a Confronto: Raft, Multi-Paxos, Viewstamped Replication ed EPaxos](https://lucioduran.com/it/blog/consensus-algorithms-raft-paxos-viewstamped)
2025-10-28 · Distributed Systems · 10 min

Confronto orientato all'implementazione degli algoritmi di consenso distribuito — Raft, Multi-Paxos, Viewstamped Replication ed EPaxos — che copre leader election, log compaction, garanzie di liveness e le sfumature che emergono solo quando li costruisci.

### [OpenAPI 4.0 (Moonwalk): La Riscrittura della Spec Che Conta Davvero](https://lucioduran.com/it/blog/openapi-4-moonwalk-api-specification)
2025-10-26 · API Design · 3 min

Nuovo meccanismo di overlay, webhook di prima classe, workflow riutilizzabili, confronto con 3.1, e un percorso di migrazione reale da Swagger.

### [eBPF in Produzione: Osservabilità a Livello Kernel per Kubernetes Senza Overhead](https://lucioduran.com/it/blog/ebpf-observability-production-kubernetes)
2025-10-25 · Infrastructure · 8 min

Come usare eBPF per osservabilità di grado produttivo in cluster Kubernetes. Cilium, Tetragon, kprobe personalizzate, e perché il monitoraggio tradizionale sta lasciando performance sul tavolo.

### [API di Storage del Browser: OPFS, IndexedDB e SQLite-over-WASM per Applicazioni Offline-First](https://lucioduran.com/it/blog/browser-storage-apis-opfs-indexeddb-sqlite-wasm)
2025-10-23 · Web APIs · 10 min

Analisi delle API di storage moderne del browser: Origin Private File System, semantica delle transazioni IndexedDB, SQLite compilato in WASM, quote di storage e progettazione di architetture offline-first.

### [Algoritmi di Rate Limiting: Dai Token Bucket agli Script Lua Distribuiti](https://lucioduran.com/it/blog/rate-limiting-algorithms-token-bucket-sliding-window)
2025-10-21 · Backend · 4 min

Token bucket, sliding window log, GCRA, rate limiting distribuito con Redis — gli algoritmi dietro ogni API gateway, con implementazioni reali in Lua.

### [Maglev e Turboshaft in V8: Architettura del Compilatore Mid-Tier e Backend di V8](https://lucioduran.com/it/blog/v8-maglev-turboshaft-compiler-pipeline)
2025-10-19 · JavaScript Internals · 9 min

Un'analisi del compilatore JIT mid-tier Maglev di V8 e dell'IR Turboshaft che sta silenziosamente sostituendo il Sea of Nodes di Turbofan. Dati reali di performance, meccaniche di deottimizzazione, e perché il tuo codice 'ottimizzato' potrebbe fare l'opposto.

### [Alternative Memory-Safe al C++: Carbon, Cpp2, Val e Circle a Confronto](https://lucioduran.com/it/blog/memory-safe-c-alternatives-carbon-cpp2-val)
2025-10-18 · Programming Languages · 9 min

Confronto tecnico approfondito dei linguaggi successori del C++ — Carbon, Cpp2/cppfront, Val e Circle — con esempi reali di interop, analisi dei costi di migrazione e valutazioni obiettive su dove si trova ciascuno.

### [GraalVM Native Image: Da 8 Secondi di Startup Spring Boot a 50ms](https://lucioduran.com/it/blog/graalvm-native-image-spring-boot-startup)
2025-10-16 · JVM · 4 min

Compilazione AOT per Spring Boot, sfide di configurazione reflection, analisi del memory footprint e trade-off di produzione dopo sei mesi di esperienza operativa.

### [PostgreSQL 17: Backup Incrementale, Failover della Replica Logica e Miglioramenti Operativi](https://lucioduran.com/it/blog/postgresql-17-incremental-backup-logical-replication)
2025-10-14 · Databases · 10 min

Un deep dive pratico nelle funzionalità più impattanti di PostgreSQL 17: backup incrementale con pg_basebackup, failover della replica logica, nuove funzioni JSON, insight di pg_stat_io, e strategie di migrazione reali da PG 15/16.

### [Web Components nel 2026: Declarative Shadow DOM, CSS Parts e Interoperabilità con i Framework](https://lucioduran.com/it/blog/web-components-shadow-dom-custom-elements-2026)
2025-10-13 · Frontend · 6 min

Declarative Shadow DOM, CSS parts, Lit 4.0, custom elements ovunque — dopo anni di 'l'anno prossimo è l'anno,' i Web Components hanno finalmente mantenuto la promessa. Cosa è cambiato e cosa fa ancora male.

### [Quantizzazione LLM a Confronto: GPTQ, AWQ, GGUF e SqueezeLLM](https://lucioduran.com/it/blog/llm-quantization-gptq-awq-gguf-compared)
2025-10-11 · AI/ML · 10 min

Un confronto pratico dei metodi di quantizzazione LLM con benchmark reali di perplessità, impronte di memoria e velocità di inferenza. Quando utilizzare ciascun metodo e i casi in cui il 4-bit supera l'8-bit.

### [Chaos Engineering in Produzione: Ipotesi di Stato Stabile, LitmusChaos e Controllo del Blast Radius](https://lucioduran.com/it/blog/chaos-engineering-litmus-chaos-monkey-production)
2025-10-09 · SRE · 7 min

LitmusChaos, Chaos Monkey, controllo del blast radius, e l'ipotesi di stato stabile — una guida tecnica per introdurre perturbazioni controllate nei sistemi di produzione.

### [Rust + WASM Component Model in Produzione: Microservizi Poliglotti Che Funzionano Davvero](https://lucioduran.com/it/blog/rust-wasm-component-model-production)
2025-10-08 · WebAssembly · 8 min

Costruire microservizi poliglotti in produzione con Rust, il WASM Component Model e interfacce WIT. Composizione cross-language, workflow con wasm-tools, e lezioni dure dall'esecuzione su scala.

### [Computazione Incrementale con i Framework Salsa e Adapton](https://lucioduran.com/it/blog/incremental-computation-salsa-adapton-frameworks)
2025-10-06 · Compilers · 7 min

Analisi della computazione incrementale demand-driven implementata in rust-analyzer — memoizzazione con invalidazione automatica, tracciamento delle dipendenze e i pattern architetturali che consentono risposte sub-millisecondo negli IDE.

### [Internals di Bun v2: JavaScriptCore, Allocator Zig e Batching dei Syscall con io_uring](https://lucioduran.com/it/blog/bun-v2-runtime-internals-deep-dive)
2025-10-04 · JavaScript Runtimes · 10 min

Un'analisi dell'architettura di Bun v2: i compromessi tra JavaScriptCore e V8, il design dell'arena allocator di Zig, il batching dei syscall con io_uring, e le decisioni ingegneristiche dietro i miglioramenti di 3x nei cold start.

### [Cold Start Serverless: Guida Completa alle Strategie di Ottimizzazione](https://lucioduran.com/it/blog/serverless-cold-starts-optimization-strategies)
2025-10-03 · Serverless · 8 min

Provisioned concurrency, SnapStart, LLRT, V8 snapshots — un benchmark approfondito che rivela quali strategie di ottimizzazione dei cold start producono risultati misurabili.

### [Compute Shader WebGPU per l'Inferenza ML: Esecuzione di Modelli sul Client](https://lucioduran.com/it/blog/webgpu-compute-shaders-ml-inference)
2025-10-01 · WebGPU · 10 min

Esecuzione di modelli ML direttamente nel browser con compute shader WebGPU. Dettagli di implementazione WGSL, benchmark contro WebGL e inferenza server-side, e limitazioni pratiche dell'esecuzione di modelli sul client.