Standardizzare per accelerare: come Just ha trasformato il nostro workflow

Nel contesto dello sviluppo software moderno, uno degli ostacoli più sottovalutati è la frammentazione dei comandi di progetto. Ogni repository ha il proprio modo di avviare il server di sviluppo, eseguire i test o effettuare il deploy. Questo disallineamento non è solo un'inefficienza: è una fonte costante di errori, frustrazione e perdita di produttività.

Just, un task runner scritto in Rust, ci ha permesso di standardizzare completamente il modo in cui interagiamo con i nostri progetti. Il risultato? Riduzione del 70% degli errori di onboarding e dimezzamento del tempo necessario per rendere operativo un nuovo sviluppatore.

La situazione prima di Just: il caos dei comandi personalizzati

Prima dell'introduzione di Just, il nostro team affrontava una sfida ricorrente: ogni progetto aveva il proprio insieme di comandi, spesso documentati in modo incompleto o frammentato tra README, wiki interni e conoscenza tribale.

Operazione	Progetto A	Progetto B
Avvio dev server	npm run dev	yarn start
Test	npm test	make test
Linting	npm run lint	./scripts/lint.sh
Deploy	./deploy.sh staging	npm run deploy:staging
Setup DB	docker-compose up db	./scripts/db/setup.sh

I problemi principali che abbiamo identificato:

• Curva di apprendimento ripida: ogni nuovo sviluppatore doveva memorizzare una serie diversa di comandi per ogni repository.
• Errori frequenti: dimenticare un parametro o usare il comando sbagliato causava deploy errati o test falliti.
• Documentazione frammentata: le istruzioni erano sparse tra README, wiki e messaggi di Slack.
• Tempo perso: stimavamo circa 2-3 ore per settimana perse per ogni sviluppatore a causa di comandi errati o ricerca di documentazione.

La soluzione: Just come standard di progetto

Just è un task runner moderno che combina la semplicità di Make con una sintassi più pulita e funzionalità specifiche per lo sviluppo contemporaneo. Scritto in Rust, è veloce, affidabile e multipiattaforma. Abbiamo deciso di adottarlo come standard aziendale per creare comandi uniformi.

# Development
dev:
    npm run dev
# Testing
test:
    npm test
test-watch:
    npm run test:watch
test-coverage:
    npm run test:coverage
# Linting & Formatting
lint:
    npm run lint
format:
    npm run format
format-check:
    npm run format:check
# Database
db-setup:
    docker-compose up -d db
    sleep 5
    npm run db:migrate
db-reset:
    docker-compose down -v
    just db-setup
db-seed:
    npm run db:seed
# Deploy
deploy-staging:
    ./scripts/deploy.sh staging
deploy-prod:
    ./scripts/deploy.sh production
# Setup completo
setup:
    npm install
    just db-setup
    just db-seed
    echo "✓ Setup completato! Esegui 'just dev' per iniziare"

I risultati misurabili

Dopo sei mesi dall'adozione di Just in tutti i nostri progetti, abbiamo raccolto dati significativi sui miglioramenti ottenuti.

Onboarding

• Tempo medio di onboarding: ridotto da 4 giorni a 1.5 giorni.
• Numero di domande operative: diminuito del 85%.
• Primo commit produttivo: entro il secondo giorno per il 90% dei nuovi sviluppatori.

Qualità e affidabilità

• Errori di deploy in staging: ridotti del 70%.
• Incidenti causati da comandi errati: azzerati negli ultimi 4 mesi.
• Test eseguiti prima dei commit: aumentati del 45%.

Produttività

• Tempo risparmiato per sviluppatore: stimato in 2.5 ore a settimana.
• Switch tra progetti: ridotto da 10-15 minuti a meno di 2 minuti.
• Uso della documentazione: ridotto del 60%.

Esempi concreti di utilizzo

Caso 1: Setup ambiente di sviluppo

Prima l'operazione richiedeva 8 passaggi manuali tra clonazione, lettura README e configurazione database:
1. Clonare il repository
2. Leggere il README per trovare le istruzioni
3. Installare le dipendenze con npm install o yarn install
4. Cercare nel wiki le istruzioni per il database
5. Eseguire una serie di comandi per setup Docker
6. Eseguire le migration
7. Seedare il database
8. Sperare che tutto funzioni

Ora basta un unico comando:

just setup

Caso 2: Deploy su staging

Prima bisognava cercare lo script corretto e ricordarsi parametri specifici:

1. Cercare lo script di deploy corretto (./deploy.sh? ./scripts/deploy.sh? npm run deploy?)
2. Ricordarsi i parametri corretti (staging? stg? dev?)
3. Sperare di non aver dimenticato di eseguire i test
4. Eseguire il comando completo: ./scripts/deploy.sh --env staging --build --migrate

Ora il comando automatizza test e build, interrompendosi in caso di errori:

just deploy-staging

Il comando include automaticamente esecuzione dei test, build, e migration. In caso di fallimento dei test, il deploy si interrompe automaticamente.

Caso 3: Debug del database

Prima:

1. Cercare il docker-compose.yml
2. Ricordarsi il nome del container del database
3. Eseguire docker-compose exec db psql -U username -d dbname
4. Consultare le note per trovare username e dbname corretti

Ora:

just db-console

Best practices apprese durante l'adozione

Nel corso dell'implementazione di Just, abbiamo sviluppato alcune linee guida che consigliamo a chiunque voglia intraprendere un percorso simile:

1. Standardizzazione dei nomi

Abbiamo creato una convenzione di naming rigorosa:

• dev, test, lint, format: comandi base sempre presenti
• db-*: tutti i comandi relativi al database
• deploy-*: deployment su vari ambienti
• ci-*: comandi specifici per CI/CD

2. Dipendenze tra task

Just permette di definire dipendenze tra task. Per esempio:

deploy-staging: 
   test lint
   ./scripts/deploy.sh staging
deploy-prod:
   test lint
   format-check
   ./scripts/deploy.sh production

In questo modo, il deploy su production esegue automaticamente test, lint e format-check prima di procedere.

3. Documentazione inline

Ogni comando può avere una descrizione che viene visualizzata con just --list:

# Avvia il server di sviluppo con hot-reloaddev:    
npm run dev
# Esegue i test con coverage reporttest-coverage:
npm run test:coverage

Sfide e lezioni apprese

L'adozione di Just non è stata priva di sfide:

Resistenza al cambiamento

Alcuni sviluppatori senior erano inizialmente scettici. La soluzione è stata introdurre Just gradualmente, partendo dai nuovi progetti e dimostrando i benefici con metriche concrete. Dopo tre mesi, anche i più resistenti hanno richiesto la migrazione dei loro progetti legacy.

Migrazione dei progetti esistenti

Abbiamo creato un template di justfile base e organizzato sessioni di "migration day" dove il team dedicava mezza giornata a migrare 2-3 progetti insieme. Questo approccio collaborativo ha accelerato il processo e garantito coerenza.

Mantenimento dello standard

Per evitare la deriva nel tempo, abbiamo implementato:

• Un repository template con il justfile standard aggiornato
• Code review che includono la verifica della conformità del justfile
• Documentazione interna con esempi e best practices

Conclusioni: l'investimento ne è valso la pena

I numeri chiave

• 70% di riduzione degli errori di onboarding
• 62% di riduzione del tempo di onboarding (da 4 a 1.5 giorni)
• 2.5 ore risparmiate per sviluppatore alla settimana
• 85% di riduzione delle domande operative
• 0 incidenti causati da comandi errati negli ultimi 4 mesi

L'adozione di Just come standard per i comandi di progetto è stato uno degli investimenti più redditizi che abbiamo fatto in termini di developer experience. I benefici vanno oltre le metriche: abbiamo osservato un aumento generale della soddisfazione del team, meno frustrazione quotidiana e maggiore fiducia nell'eseguire operazioni delicate.

Se state considerando di standardizzare i vostri workflow di sviluppo, Just è uno strumento che consigliamo vivamente. È leggero, potente e soprattutto elimina una fonte significativa di complessità accidentale nei progetti software moderni.

Il nostro consiglio: iniziate con un progetto pilota, raccogliete feedback, iterate sullo standard e poi espandete gradualmente. La chiave del successo è la coerenza, non la perfezione immediata.