penso che molti sviluppatori considerino il lavoro di sviluppo come lo sviluppo di software.

sicuramente è di questo che si tratta!

tuttavia, è anche lo sviluppo dello sviluppatore.

diventare più forti.

ecco un semplice algoritmo che si può usare per diventare uno sviluppatore più forte:

• capire completamente il problema

• progettare un'astrazione

• implementare l'astrazione

• rilasciare l'astrazione

• richiedere feedback

• usare il feedback per costruire la comprensione

questo è piuttosto astratto per alcune persone da capire, quindi lasciami dare un esempio concreto che contrasta questo sviluppatore

con questo

nello sviluppo di un'applicazione che deve creare triangoli isosceli e rettangoli.

lo sviluppatore uno usa il seguente processo:

• prendi la carta 'isoscele' dalla bacheca. non preoccuparti di leggere quella 'triangolo rettangolo'.

• ottieni campioni di triangoli isosceli. scrivi codice che possa produrre affidabilmente solo quei tipi di triangoli isosceli che il codice si aspetta. poiché fare di più è YAGNI, controllalo, assicurati che CI sia verde. e vai a casa.

lo sviluppatore due invece fa:

• rivedi la bacheca. leggi i commit recenti. capisci la roadmap a 10.000 piedi lo sviluppatore unisce le carte 'isoscele' e 'triangolo rettangolo' in una nuova carta chiamata 'costruire un modello di dominio del triangolo' (capire il problema)

• lo sviluppatore lavora sulla carta, arrivando infine a (l'astrazione)

• lo sviluppatore implementa codice che modella triangoli generici utilizzando il teorema e le specializzazioni per ciascuno dei tipi specifici 'isoscele' e 'rettangolo' (implementare l'astrazione)

• lo sviluppatore isola il codice di dominio dal codice non di dominio e invia una libreria a github. (pubblicare l'astrazione e richiedere feedback)

• lo sviluppatore unisce la richiesta pull per il bug 'divisione per zero' alcuni giorni dopo (usare il feedback per ulteriori comprensioni)

alla fine lo sviluppatore uno spunta una casella e rafforza il processo del suo team. lo sviluppatore due rafforza il codice, il team e, soprattutto, se stesso.

ripetendo il processo più e più volte lo sviluppatore uno può trasformarsi nello sviluppatore due lavorando ripetutamente per rafforzare i muscoli tecnici e di dominio. al contrario, lo sviluppatore due può smettere di allenarsi e diventare morbido come lo sviluppatore uno.

la capacità dello sviluppatore è come un muscolo: devi usarlo o lo perdi.