Domande per il Colloquio di Senior Full Stack Developer: Guida Completa

Introduzione

Lo sviluppo full stack si è evoluto in una disciplina completa che richiede competenze in frontend, backend, database e infrastruttura. Ci si aspetta che gli sviluppatori full stack senior progettino sistemi scalabili, prendano decisioni tecnologiche informate e colmino il divario tra i diversi livelli delle applicazioni moderne.

Questa guida tratta le domande essenziali per i colloqui per sviluppatori Full Stack Senior, che spaziano dai framework frontend, all'architettura backend, alla progettazione del sistema, ai database e alle pratiche DevOps. Ogni domanda include risposte dettagliate, valutazione della rarità e valutazioni della difficoltà per aiutarti a prepararti in modo efficace.

Sviluppo Frontend (6 Domande)

1. Spiega il Virtual DOM di React e l'algoritmo di Reconciliation.

Risposta: Il Virtual DOM è una rappresentazione JavaScript leggera del DOM effettivo. React lo utilizza per ottimizzare gli aggiornamenti.

• Processo: Quando lo stato cambia, React crea un nuovo albero Virtual DOM e lo confronta con quello precedente (diffing).
• Reconciliation: L'algoritmo di React identifica l'insieme minimo di modifiche necessarie e aggiorna solo quelle parti del DOM reale.
• Ottimizzazione chiave: L'utilizzo di key props aiuta React a identificare quali elementi sono stati modificati, aggiunti o rimossi negli elenchi, rendendo la reconciliation più efficiente.
• Architettura Fiber: React moderno utilizza Fiber, che consente di suddividere il lavoro di rendering in blocchi e di dare la priorità agli aggiornamenti.

Rarità: Molto Comune Difficoltà: Media

2. Cosa sono gli Hook di React e perché sono stati introdotti?

Risposta: Gli Hook sono funzioni che consentono di utilizzare lo stato e altre funzionalità di React nei componenti funzionali.

• Motivazione: Prima degli Hook, la logica stateful richiedeva componenti di classe. Gli Hook consentono di riutilizzare la logica stateful senza modificare la gerarchia dei componenti.
• Hook comuni:
  • useState: Gestisce lo stato locale
  • useEffect: Gestisce gli effetti collaterali (data fetching, sottoscrizioni)
  • useContext: Accede ai valori di contesto
  • useMemo/useCallback: Ottimizzazione delle prestazioni
• Hook personalizzati: È possibile creare hook personalizzati per estrarre e riutilizzare la logica dei componenti.

Rarità: Molto Comune Difficoltà: Facile

3. Come si ottimizzano le prestazioni di un'applicazione React?

Risposta: Diverse strategie possono migliorare le prestazioni di React:

1. Code Splitting: Utilizzare React.lazy() e Suspense per caricare i componenti su richiesta.
2. Memoization: Utilizzare React.memo() per i componenti, useMemo() per i calcoli costosi, useCallback() per i riferimenti alle funzioni.
3. Virtual Lists: Per elenchi lunghi, utilizzare librerie come react-window o react-virtualized.
4. Evitare le funzioni inline: Nei metodi di rendering, in quanto creano nuovi riferimenti a ogni rendering.
5. Profiler: Utilizzare React DevTools Profiler per identificare i colli di bottiglia.
6. State Management: Mantenere lo stato il più locale possibile, utilizzare il contesto con saggezza.

Rarità: Comune Difficoltà: Media

4. Spiega la differenza tra Server-Side Rendering (SSR) e Client-Side Rendering (CSR).

Risposta:

• CSR: JavaScript viene eseguito nel browser per eseguire il rendering della pagina. L'HTML iniziale è minimo. Navigazione successiva veloce ma caricamento iniziale più lento e SEO scadente.
• SSR: Il server genera HTML completo per ogni richiesta. SEO migliore e paint iniziale più veloce, ma navigazione successiva più lenta e carico del server più elevato.
• Approcci ibridi:
  • Static Site Generation (SSG): Pre-renderizza le pagine in fase di build (Next.js, Gatsby).
  • Incremental Static Regeneration (ISR): Aggiorna le pagine statiche dopo la distribuzione senza una ricostruzione completa.

Rarità: Comune Difficoltà: Media

5. Qual è la differenza tra localStorage, sessionStorage e Cookies?

Risposta:

• localStorage: Memorizza i dati senza scadenza. Limite di ~5-10 MB. Non viene inviato automaticamente al server.
• sessionStorage: Come localStorage ma viene cancellato quando si chiude la scheda/il browser.
• Cookies: Piccoli dati (~4KB) inviati con ogni richiesta HTTP. È possibile impostare la scadenza. Utilizzato per i token di autenticazione.
• Sicurezza: I cookie possono essere HttpOnly (non accessibili tramite JS) e Secure (solo HTTPS). Utilizzare per i dati sensibili.

Rarità: Comune Difficoltà: Facile

6. Come funziona CSS-in-JS e quali sono i suoi compromessi?

Risposta: Le librerie CSS-in-JS (styled-components, Emotion) consentono di scrivere CSS direttamente in JavaScript.

• Vantaggi:
  • Stili con ambito (nessun inquinamento dello spazio dei nomi globale)
  • Stili dinamici basati su props
  • Prefissaggio automatico del vendor
  • Eliminazione del codice morto
• Compromessi:
  • Overhead di runtime (stili generati in fase di runtime)
  • Dimensioni del bundle maggiori
  • Curva di apprendimento
• Alternative: CSS Modules, Tailwind CSS, CSS tradizionale con metodologia BEM.

Rarità: Media Difficoltà: Media

Sviluppo Backend (6 Domande)

7. Spiega l'Event Loop in Node.js.

Risposta: Node.js è single-threaded ma gestisce la concorrenza attraverso l'event loop.

• Fasi:
  1. Timers: Esegue i callback setTimeout e setInterval
  2. Pending callbacks: Callback I/O differiti all'iterazione successiva
  3. Poll: Recupera nuovi eventi I/O, esegue i callback I/O
  4. Check: Callback setImmediate
  5. Close callbacks: Eventi di chiusura del socket
• I/O non bloccante: Quando vengono avviate operazioni I/O, Node.js le delega al kernel del sistema e continua a eseguire altro codice.

console.log('1');
setTimeout(() => console.log('2'), 0);
Promise.resolve().then(() => console.log('3'));
console.log('4');
// Output: 1, 4, 3, 2

Rarità: Molto Comune Difficoltà: Difficile

8. Cos'è Middleware in Express.js?

Risposta: Le funzioni middleware hanno accesso alla richiesta, alla risposta e alla funzione middleware successiva nel ciclo richiesta-risposta dell'applicazione.

• Tipi:
  • Application-level: app.use()
  • Router-level: router.use()
  • Error-handling: Ha 4 parametri (err, req, res, next)
  • Built-in: express.json(), express.static()
  • Third-party: cors, helmet, morgan
• L'ordine è importante: Il middleware viene eseguito nell'ordine in cui è definito.

app.use((req, res, next) => {
  console.log('Time:', Date.now());
  next();
});

Rarità: Molto Comune Difficoltà: Facile

9. Come gestisci l'autenticazione in un'API REST?

Risposta: Esistono diversi approcci:

• JWT (Stateless):
  • Il server genera un token firmato contenente le informazioni sull'utente
  • Il client memorizza il token (localStorage/cookie) e lo invia con ogni richiesta
  • Il server verifica la firma
  • Pro: Scalabile, nessuna memorizzazione della sessione lato server
  • Contro: Difficile da revocare, payload più grande
• Session-based (Stateful):
  • Il server crea una sessione, la memorizza in DB/Redis
  • Il client riceve l'ID di sessione nel cookie
  • Pro: Facile da revocare
  • Contro: Richiede archiviazione lato server
• OAuth 2.0: Per l'autenticazione di terze parti
• Best Practice: Utilizzare token di aggiornamento per l'accesso a lungo termine, token di accesso a breve termine.

Rarità: Molto Comune Difficoltà: Media

10. Spiega le transazioni del database e le proprietà ACID.

Risposta: Una transazione è una sequenza di operazioni eseguite come una singola unità logica di lavoro.

• ACID:
  • Atomicity: Tutte le operazioni hanno successo o tutte falliscono (tutto o niente)
  • Consistency: Il database passa da uno stato valido a un altro
  • Isolation: Le transazioni simultanee non interferiscono tra loro
  • Durability: Le transazioni confermate persistono anche dopo un guasto del sistema
• Isolation Levels: Read Uncommitted, Read Committed, Repeatable Read, Serializable (compromesso tra coerenza e prestazioni).

Rarità: Comune Difficoltà: Media

11. Qual è la differenza tra i database SQL e NoSQL?

Risposta:

• SQL (Relazionale):
  • Schema strutturato, tabelle con righe/colonne
  • Conforme a ACID
  • Scalabilità verticale (server più grande)
  • Esempi: PostgreSQL, MySQL
  • Caso d'uso: Query complesse, transazioni, dati strutturati
• NoSQL:
  • Schema flessibile, documento/chiave-valore/grafo/famiglia di colonne
  • BASE (Eventually consistent)
  • Scalabilità orizzontale (più server)
  • Esempi: MongoDB, Redis, Cassandra
  • Caso d'uso: Sviluppo rapido, scala massiccia, dati non strutturati

Rarità: Comune Difficoltà: Facile

12. Come si prevengono gli attacchi SQL Injection?

Risposta: SQL Injection si verifica quando l'input dell'utente viene concatenato direttamente nelle query SQL.

• Prevenzione:
  1. Parameterized Queries/Prepared Statements: Utilizzare segnaposto per l'input dell'utente
  2. ORM: Librerie come Sequelize, TypeORM gestiscono automaticamente l'escaping
  3. Input Validation: Inserire nella whitelist i caratteri consentiti
  4. Least Privilege: L'utente del database deve avere le autorizzazioni minime
  5. Stored Procedures: Può fornire un ulteriore livello

// Bad
const query = `SELECT * FROM users WHERE id = ${userId}`;

// Good
const query = 'SELECT * FROM users WHERE id = ?';
db.execute(query, [userId]);

Rarità: Molto Comune Difficoltà: Facile

Progettazione del sistema e architettura (6 domande)

13. Come progetteresti un sistema di notifica scalabile?

Risposta: Un sistema di notifica deve gestire più canali (e-mail, SMS, push) su larga scala.

• Componenti:
  • API Service: Riceve le richieste di notifica
  • Message Queue: RabbitMQ/Kafka per l'elaborazione asincrona
  • Workers: Servizi separati per ogni canale
  • Database: Memorizza la cronologia delle notifiche, le preferenze dell'utente
  • Rate Limiting: Prevenire lo spam
• Considerazioni:
  • Logica di ripetizione per i guasti
  • Code di priorità per le notifiche urgenti
  • Gestione dei modelli
  • Preferenze dell'utente (opt-out)

Rarità: Comune Difficoltà: Difficile

14. Spiega l'architettura dei microservizi e le sue sfide.

Risposta: I microservizi scompongono un'applicazione in servizi piccoli e indipendenti.

• Vantaggi:
  • Distribuzione e scalabilità indipendenti
  • Diversità tecnologica
  • Isolamento dei guasti
  • Autonomia del team
• Sfide:
  • Transazioni distribuite: Difficile mantenere la coerenza tra i servizi
  • Network Latency: Overhead di comunicazione tra servizi
  • Monitoring: Necessità di tracciamento distribuito (Jaeger, Zipkin)
  • Data Management: Ogni servizio possiede il proprio database
  • Testing: L'integration testing è complesso
• Patterns: API Gateway, Service Mesh, Circuit Breaker, Saga pattern per le transazioni.

Rarità: Molto Comune Difficoltà: Difficile

15. Cos'è la Caching e quali sono le strategie di caching comuni?

Risposta: La caching memorizza i dati a cui si accede frequentemente in un'archiviazione veloce per ridurre la latenza.

• Livelli:
  • Cache del browser
  • CDN (CloudFlare, Akamai)
  • Cache dell'applicazione (Redis, Memcached)
  • Cache delle query del database
• Strategie:
  • Cache-Aside: L'app controlla prima la cache, carica dal DB in caso di mancata corrispondenza
  • Write-Through: Scrivi contemporaneamente nella cache e nel DB
  • Write-Behind: Scrivi nella cache, scrivi in modo asincrono nel DB
  • Read-Through: La cache carica automaticamente i dati dal DB
• Eviction Policies: LRU (Least Recently Used), LFU (Least Frequently Used), TTL (Time To Live).

Rarità: Molto Comune Difficoltà: Media

16. Come garantisci il versioning dell'API?

Risposta: Il versioning dell'API consente la compatibilità con le versioni precedenti quando si apportano modifiche.

• Strategie:
  • URI Versioning: /api/v1/users, /api/v2/users
  • Header Versioning: Accept: application/vnd.api.v1+json
  • Query Parameter: /api/users?version=1
• Best Practices:
  • Avvisi di deprecazione
  • Mantenere almeno 2 versioni
  • Guide di migrazione chiare
  • Versioning semantico
• Alternativa GraphQL: Evoluzione dello schema senza versioning (campi deprecati).

Rarità: Comune Difficoltà: Media

17. Spiega il teorema CAP.

Risposta: Nei sistemi distribuiti, puoi garantire solo 2 su 3:

• Consistency: Tutti i nodi vedono gli stessi dati contemporaneamente
• Availability: Ogni richiesta riceve una risposta (successo/fallimento)
• Partition Tolerance: Il sistema continua a funzionare nonostante i guasti di rete
• Realtà: Le partizioni di rete si verificheranno, quindi devi scegliere tra CP (Consistency) o AP (Availability).
• Esempi:
  • CP: MongoDB, HBase (sacrificare la disponibilità durante la partizione)
  • AP: Cassandra, DynamoDB (eventuale coerenza)

Rarità: Comune Difficoltà: Difficile

18. Cos'è il Load Balancing e quali algoritmi vengono utilizzati?

Risposta: Il bilanciamento del carico distribuisce il traffico su più server.

• Algoritmi:
  • Round Robin: Distribuzione sequenziale
  • Least Connections: Invia al server con il minor numero di connessioni attive
  • IP Hash: Hach client IP per determinare il server (persistenza della sessione)
  • Weighted Round Robin: I server con maggiore capacità ricevono più richieste
• Tipi:
  • Layer 4 (Transport): Basato su IP/Port, più veloce
  • Layer 7 (Application): Basato sul contenuto (URL, intestazioni), più intelligente
• Strumenti: Nginx, HAProxy, AWS ELB, Google Cloud Load Balancer.

Rarità: Comune Difficoltà: Media

DevOps e Cloud (4 domande)

19. Spiega Docker e i vantaggi della containerizzazione.

Risposta: Docker confeziona le applicazioni con le loro dipendenze in container.

• Vantaggi:
  • Consistency: Stesso ambiente in dev/staging/prod
  • Isolation: Ogni container è isolato
  • Lightweight: Condividi il kernel del sistema operativo host (vs VM)
  • Fast startup: Secondi anziché minuti per le VM
  • Portability: Esegui ovunque sia installato Docker
• Componenti:
  • Image: Template di sola lettura
  • Container: Istanza in esecuzione di un'immagine
  • Dockerfile: Istruzioni per costruire un'immagine
  • Registry: Docker Hub, registri privati

Rarità: Molto Comune Difficoltà: Facile

20. Cos'è CI/CD e perché è importante?

Risposta:

• Continuous Integration: Gli sviluppatori uniscono il codice frequentemente, i test automatizzati vengono eseguiti su ogni commit
• Continuous Deployment: Distribuisci automaticamente in produzione dopo aver superato i test
• Vantaggi:
  • Feedback più rapido
  • Problemi di integrazione ridotti
  • Codice di qualità superiore
  • Time to market più veloce
• Strumenti: Jenkins, GitLab CI, GitHub Actions, CircleCI
• Pipeline Stages: Build → Test → Deploy
• Best Practices: Test automatizzati, feature flags, meccanismi di rollback.

Rarità: Molto Comune Difficoltà: Facile

21. Come monitori e debugghi le applicazioni di produzione?

Risposta: Un monitoraggio completo è fondamentale per i sistemi di produzione.

• Logging:
  • Structured logging (formato JSON)
  • Centralized logging (ELK Stack, Splunk)
  • Log levels (ERROR, WARN, INFO, DEBUG)
• Metrics:
  • Application metrics (tempo di risposta, throughput)
  • Infrastructure metrics (CPU, memoria, disco)
  • Strumenti: Prometheus, Grafana, DataDog
• Tracing:
  • Distributed tracing per microservizi
  • Strumenti: Jaeger, Zipkin, AWS X-Ray
• Alerting: PagerDuty, Opsgenie per problemi critici
• Error Tracking: Sentry, Rollbar per il monitoraggio delle eccezioni.

Rarità: Comune Difficoltà: Media

22. Cos'è Infrastructure as Code (IaC)?

Risposta: IaC gestisce l'infrastruttura tramite codice anziché processi manuali.

• Vantaggi:
  • Controllo della versione per l'infrastruttura
  • Ambienti riproducibili
  • Provisioning più veloce
  • Errore umano ridotto
• Strumenti:
  • Terraform: Cloud-agnostic, dichiarativo
  • CloudFormation: Specifico per AWS
  • Ansible: Gestione della configurazione
  • Pulumi: Utilizza linguaggi di programmazione
• Best Practices:
  • Memorizza nel controllo della versione
  • Componenti modulari e riutilizzabili
  • Ambienti separati (dev/staging/prod)
  • Test automatizzati dell'infrastruttura.

Rarità: Media Difficoltà: Media

Testing e Best Practices (3 domande)

23. Spiega la piramide dei test.

Risposta: La piramide dei test rappresenta la distribuzione ideale dei diversi tipi di test.

• Unit Tests: Testa singole funzioni/componenti in isolamento. Veloci, molti di loro.
• Integration Tests: Testa come i componenti lavorano insieme. Velocità media, numero moderato.
• E2E Tests: Testa interi flussi utente. Lenti, costosi, pochi di loro.
• Rationale: Più unit test perché sono veloci e individuano i bug in anticipo. Meno test E2E perché sono lenti e fragili.

Rarità: Comune Difficoltà: Facile

24. Quali sono i principi SOLID?

Risposta: SOLID è un acronimo per cinque principi di progettazione:

• S - Single Responsibility: Una classe dovrebbe avere un solo motivo per cambiare
• O - Open/Closed: Aperto all'estensione, chiuso alla modifica
• L - Liskov Substitution: I sottotipi devono essere sostituibili ai loro tipi base
• I - Interface Segregation: Molte interfacce specifiche sono meglio di una generale
• D - Dependency Inversion: Dipende dalle astrazioni, non dalle concretizzazioni
• Vantaggi: Codice più manutenibile, testabile e flessibile.

Rarità: Comune Difficoltà: Media

25. Come gestisci gli errori in JavaScript asincrono?

Risposta: Esistono diversi pattern per la gestione degli errori asincroni:

• Promises:

fetch('/api/data')
  .then(response => response.json())
  .catch(error => console.error('Error:', error));

• Async/Await:

try {
  const response = await fetch('/api/data');
  const data = await response.json();
} catch (error) {
  console.error('Error:', error);
}

• Global Error Handlers:
  • window.addEventListener('unhandledrejection', ...) per i promise rejection non gestiti
  • Express error middleware per il backend
• Best Practice: Gestisci sempre gli errori, utilizza una gestione centralizzata degli errori, registra correttamente gli errori.

Rarità: Molto Comune Difficoltà: Facile