questo è un argomento che ho fatto abbastanza a
un po ‘ di ricerca e sviluppo su e
Sto continuando a fare ricerche e
sviluppo su questo e in effetti ho
fatto ho scritto di questo
soggetto sul sito developerworks che ho
scritto 20 rate intorno a questo
soggetto puoi arrivarci attraverso questo
URL ma è orribile e terribile così ho
usato la tecnologia moderna per accorciarlo
e renderlo più accessibile e così tu
puoi leggere molto di più su questo argomento
lì se ti interessa il mio
l’agenda di questa mattina è parlare prima
su cosa è il software design cosa facciamo
significa che parliamo di design e software
poi un po ‘ sulla distinzione
tra architettura e design e it
risulta che è particolarmente utile
modo di distinguere tra questi due
cose che ti permettono di pensare
loro separatamente, che è molto spesso a
esercizio utile per esibirsi poi parlo
su cose che ti fanno emergere
progettare duro ho parlato di alcune cose
questo lo rende più facile e poi ho parlato a
un po ‘su una volta che hai trovato questi design
elementi cosa puoi fare con loro come
li raccogli e come li prendi?
vantaggio di loro, ma ho intenzione di iniziare
con la poesia di Donald Rumsfeld che
molto famoso ha detto che ci sono noti
incognite, cioè, ci sono cose
che ora sappiamo che non lo sappiamo, ma lì
sono anche sconosciuti sconosciuti ci sono
cose che non sappiamo non sappiamo
e lui non se ne rendeva conto, ma lo era
davvero parlando di software qui
perché questo risulta essere il micidiale
cosa nel software non è il noto
incognite perché puoi farlo
piani di emergenza per quello che conosci noi
non capisco davvero come funziona
quindi pianifichiamo un po ‘di tempo per la ricerca e
sviluppalo e pensaci è il
sconosciuti sconosciuti che finiscono per ucciderti
e infatti questa è la cosa che
alla fine uccide qualsiasi tipo di grande gigante
sforzo di progettazione in anticipo nel software
sei sempre beccato dall’ignoto
incognite e così nello spazio agile cosa
ci siamo resi conto che il futuro è
davvero molto difficile da prevedere e nel
mondo dell’architettura tradizionale cosa
che hanno cercato di fare da anni è
grazie alla loro sfera di cristallo
applicare di più e
o il rigore ad esso e abbiamo fatto
qualcosa di diverso che abbiamo detto che tu sai
il futuro è davvero difficile da prevedere
cosa succede se invece di migliorare e
meglio a prevedere il futuro che otteniamo
sempre meglio nell’adattabilità come noi
vai e poi non paghi proprio così
prezzo difficile per avere l’ignoto
pop-up sconosciuto perché sei molto di più
adattabile è esattamente ciò che questo discorso
Riguarda è come possiamo costruire tecniche
per l’adattabilità nel software in modo che
noi non paghiamo questi enormi prezzi per il
inevitabili incognite sconosciute che sono
sempre in agguato dietro l’angolo
ma prima di arrivare troppo in là noi
davvero bisogno di rispondere a una fondamentale
domanda come cosa intendiamo noi parliamo?
sulla progettazione del software e fortunatamente
qualcuno ha risposto a questa domanda
ci riporta in autunno del 1992 in C ++
il diario Jack Reeves ha scritto molto
saggio influente che puoi ancora
arrivare in quella posizione vale comunque la pena
leggendo perché ci crederesti
è stato scritto la scorsa settimana e tu lo fai
alcune osservazioni molto in questo documento
perché quello che sta cercando di fare qui è
fare un profondo confronto metaforico
tra ingegneria tradizionale e
l’ingegneria del software fa molta luce
confronti metaforici su di te
il nostro lavoro è come costruire ponti o il nostro
il lavoro è come il giardinaggio o la montagna
arrampicata o tutti questi tipi di sciolto
confronti metaforici ma tu vuoi
vai un po ‘ più a fondo e vedi come
le cose sono davvero simili e come le cose
sono davvero diversi e lui viola
alcune conclusioni interessanti la prima
un essere che è l’obiettivo finale di qualsiasi
attività di ingegneria è un qualche tipo di
documentazione se sei un ingegnere civile
e hai il compito di creare un nuovo
ponte qual è il tuo risultato per il tuo
lavoro è un progetto per un ponte in a
luogo particolare che opera sotto
particolari vincoli che ha
particolari caratteristiche di scalabilità
ma in realtà non costruisci quel ponte
lo consegni a un gruppo di persone
chi sono esperti costruttori di ponti e tu
consegnalo a un team di produzione e
quindi l’ output per lo sforzo ingegneristico
è questo disegno che gestisci e un
squadra di ingegneri in realtà finisce
produrlo ma ecco uno dei
luoghi in cui il mondo tradizionale in
il mondo del software differisce molto perché
per le cose fisiche significa uscire
atomi e si scopre che una volta che hai
atomi stampati in una forma particolare
è davvero difficile da capire loro di
cercando un ricampionamento in un altro
forma a cui devi fare cose pazze
come scioglierli o cambiare la loro sostanza chimica
composizione ecc. ma non viviamo in un
atomi mondo basato viviamo in un boccone
mondo base e byte sono super soft e
malleabile e puoi cambiarle tutte
il momento in cui la goccia di un cappello è molto
cosa diversa dal nostro mondo in
mondo dell’ingegneria tradizionale ma poi
devi chiedertelo quindi qual è il
analogico nel mondo del software a quello
processo di produzione che tradizionale
l’ingegneria passa attraverso di essa
è la compilazione e l’implementazione
processo che attraversiamo è il
cosa che prende il nostro design e
lo manifesta in qualcosa che si muove
cose in giro nel mondo reale in questo
caso elettroni attraverso fili ecc
suggerisce che il nostro progetto sia il nostro progetto
il nostro risultato per lo sforzo ingegneristico
è il codice sorgente la fonte completa
codice questo è il nostro programma per il software
e ogni modifica che modifica il codice sorgente
cambia il nostro design ogni volta che fai un
cambia il codice sorgente che stai modificando
il design del tuo pezzo di software così
il debugging fa parte della qualità del design
L’assicurazione fa parte del design perché loro
apportare modifiche che producono cambiamenti nel
codice sorgente il tuo software che è il tuo
design ma qui è dove ci differenziamo davvero
dal tradizionale nella produzione
mondo perché il processo più costoso
nel mondo dell’ingegneria giudiziaria è il
abbattere gli atomi parte infatti molto
le tecniche di prevedibilità che
sono stati creati nel tradizionale
il mondo dell’ingegneria non è stato creato per
rendere le cose più sicure sono state create
inizialmente per renderli di più
conveniente perché è anche troppo
costoso per testare i ponti costruendo
nuovi ponti e rotolamento di cose pesanti
loro per vedere se crollano o no
è un modo terribile per costruire ponti
ma possiamo costruire un software del genere
giorno lungo perché praticamente non c’è
costo per rigenerarlo, basta risolvere il problema
piccolo buco e riabilitare il tutto
cosa e abbiamo un tipo realistico di
di nuovo il mondo la nostra produzione è sporca
economico infatti ogni volta che smetti di digitare
adesso
un esercito di gnomi nel tuo computer
prende vita e produttori sei
progettato per te e Jack Reese
conclude come saggio dicendo che dato
che i progetti software sono relativamente
facile da realizzare ed essenzialmente gratuito
costruire una rivelazione non sorprendente è quella
i progetti software tendono ad essere incredibilmente
ampio e complesso penso che siano suscettibili
alcune delle cose più complesse che
gli umani creano perché non ne abbiamo
degli stessi vincoli che altri tipi
di ingegneria ha per esempio non lo facciamo
avere lo stesso tipo di località da criticare
che i sistemi tradizionali hanno così se a
l’ala cade da un aereo per la polizia legale
l’ingegnere può andare dove era
collegato l’aereo e dedurre quello
Probabilmente è un problema lì intorno
ma nel software qualche piccola colpa può
causare un’instabilità che non lo fa
manifestare per centomila righe di
codice via quindi è molto difficile da rintracciare
giù esattamente qual è quel problema è
anche straordinariamente fragili che abbiamo
punti di rottura molto molto fragili in
software diverso da quello tradizionale
mondo ingegneristico quindi il software
i disegni tendono ad essere questi grandi giganti
cose complesse perché non abbiamo il
stesso tipo di modalità di guasto e lo stesso
tipo di vincoli che li terrebbero
semplice che esiste nel mondo reale e
la sua conclusione definitiva perché il
il software può essere economico da compilare ma è così
incredibilmente costoso da progettare perché
tutto quello che stai facendo è fondamentalmente
parte di questo processo di progettazione nel software
quindi quando stavamo parlando di design lui
Stavo davvero parlando di ciò che abbiamo parlato
circa ora comprende tutti
architettura e design e tutto il
cose che costituiscono ciò che stai facendo come
tu crei un nuovo software ma io voglio
fare una differenza qui tra
architettura e quello che sto chiamando design
sfortunatamente il design è uno di quelli
mega parole sovraccariche perché Jack
Reeves usa il design come fondamentalmente ciò che noi
chiama architettura e progetta tutto il
cose che vanno nel software quando noi
pensiamo di progettazione ora pensiamo a utente
esperienza di design e il tipo di
interazione con l’ esperienza dell’utente che non lo è
il tipo di design che sto parlando del
la differenziazione che voglio fare qui è
quello che fa Martin Fowler nel suo
Libro bianco chiamato a chi ha bisogno di un
architetto ed è in realtà la base
per il titolo del lavoro dello sviluppatore
serie
che ti ho fatto vedere di sfuggita in precedenza
è questa idea che nel suo un whitepaper
chi ha bisogno di un architetto che sia veramente un
white paper sul ruolo degli architetti
su progetti agili che tipo di
incidentalmente dà alcune definizioni di
architettura e uno di quelli è il mio
definizione preferita di architettura e
ti porta a questo tipo molto utile di
capacità di fendere questa definizione in
parte è che gli elementi architettonici
e un pezzo di software sono le cose
che sono percepiti come difficili da cambiare
più tardi e che in effetti porta al
titolo di quella serie di lavoro dello sviluppatore I
non so se l’hai notato o no
architettura evolutiva ed emergente
design e c’è un importante
distinzione tra queste due cose
perché se gli elementi architettonici
sono le cose che sono difficili da cambiare
in seguito quelli sono rappresentati qui in natura
di queste scatole grigie tutto si posa
parte superiore dell’architettura che non si può avere
architettura emergente perché tutto
poggia su di esso ma non puoi avere
design emergente quindi le scatole grigie qui
in questa immagine molto astratta rappresentano
elementi architettonici che non puoi iniziare
mescolando quelli senza fare
tutto è instabile, quindi le cose sono così
sono seduti in cima puoi avere molto
maggiore flessibilità nel muovere quelle cose
intorno e così si può tipo di chiedere
te stesso quando guardi il tuo software
stack wotz architecture contro design se
è difficile cambiare più tardi della sua darka
testuale quindi la tua lingua è certamente
architettonico il framework web che hai
scelto come architettonico perché tu
non posso cambiare banalmente questo per
qualcosa dopo ma il modo in cui stai usando
quegli elementi architettonici così il tuo web
quadro nel modo in cui stai usando il
flusso di lavoro e la convalida e tutti
quei pezzi che vengono con quelli sono
veramente aspetti del design e tu no
devono ottenere quelli quasi corretti
perché la pena per cambiarli
non è quasi così alto perché gli altri
le cose non poggiano su di loro e dipendono da
loro quindi il vero trucco in questo mondo è
possiamo costruire componenti architettonici
questo è semplicemente sufficiente che possiamo
evolvere nel tempo perché la seconda metà
di questa definizione è idealmente che desideri
avere poche di queste cose che sono
difficile da cambiare il più possibile perché
elementi architettonici ti danno utili
impalcature sono cose che non hai
per costruire te stesso ma anche loro
rappresentare i vincoli e quindi cosa faremmo
piace avere il massimo beneficio con
il minor numero di vincoli e questo è
il modo in cui cerchiamo di progettare le cose e noi
rendere questa divisione tra evolutiva
architettura che è molto nel
tipo di micro-servizi resto e
mondi basati su componenti il precedente
parlava di chi parlava e quello
le altre persone in questa traccia stanno andando
parleremo più tardi di oggi
concentrati principalmente in questo discorso su questo design
aspetto e in particolare il design emergente
e quindi parliamo di alcune definizioni
se guardi la parola emergenza che è
fondamentalmente la parola radice di emergente o
viceversa e la definizione da
Webster dice emergente o emergente
lo sfrigolio ma qualcosa sui liquidi così
Ho intenzione di modificare in modo selettivo il
Definizione di Webster per ottenere esattamente il
uno che voglio emergere o emergere
fuori di tutto ciò che copre o nasconde
o viene alla luce e ce n’è un altro
Definizione di Webster che è improvvisamente
apparire inaspettatamente o
chiede un’azione tempestiva entrambi questi
gli aspetti rivelano la nostra parte di questo mondo
di design emergente e ho intenzione di parlare
su due aspetti diversi che farò
fare un tuffo molto più in profondità durante la
corso di questo discorso ed ecco il primo
diciamo che concettualmente è
il tuo lavoro ha un problema che sembra
un po ‘ come questo e mentre sei a
lavoro che stai pensando a questo mentre
stai guidando verso casa a cui stai pensando
su questo mentre stai falciando il tuo giardino
stai pensando a questo quando il tuo
il coniuge sta parlando con te che sei supposto
per prestare attenzione a loro sono
ancora parte del tuo cervello e ancora
a lavorare su questo perché si sa che
c’è una sorta di schema e tutto
questo casino che puoi davvero risolvere
ci pensi davvero a lungo e duramente
e infine una sorta di schema utile
o la gerarchia viene fuori da quello
questo è davvero questo esercizio di presa
codice esistente e ricerca di astrazioni
e modelli che sono viventi e in agguato
e nascondendo in quel codice e mostrerò
voi usando alcune tecniche concrete
metriche e altre cose per andare effettivamente
e fallo in una base di codice esistente così
fa parte del design emergente
codice esistente e in grado di
trova elementi di design che sono lì dentro
che non hai mai visto prima perché
non hai avuto una luce particolarmente
che potresti splendere su quell’angolo di
la tua base di codice per illuminare quel poco
problema di progettazione così è
metà delle tecniche parlerò
circa l’ altra metà è questo concetto
dai software magri ragazzi dell’ultimo
momento responsabile per prendere decisioni
riguardo alle cose l’ idea qui è proprio così
spesso su progetti si è presentato con
la decisione che dovresti chiederti è
c’è un modo in cui posso rinviare responsabilmente questo
decisione fino a più tardi l’idea è quella
più a lungo è possibile ritardare tale decisione
più conoscenza e contesto reali
sulla vera natura del problema no
ciò che si pensa è il problema, ma la
problema reale più a lungo puoi ritardare
che più informazioni reali puoi
lavora e hai un potenziale per a
decisione migliore ovviamente non puoi aspettare
troppo lungo e questa è la cosa più difficile
l’ultimo momento responsabile ma il
più a lungo puoi ritardare di avere più reale
dati per una decisione e quindi il trucco
qui diventa come lo trovi
punto di inflessione dell’ultimo responsabile
momento parlerò di alcune tecniche
su quello che è dove la fine del
parlare e quindi parlerò
questi due aspetti del design emergente e
si scopre che questi due molto bene
cadere in due categorie
trovare astrazioni e schemi funziona
veramente bene su brownfield esistente
proietta dieci giri di tempo responsabile
funziona davvero molto bene su greenfield
o nuovo tipo di progetti e in
Infatti alcune delle ricerche attuali sono
fare è e non ci arriverò in questo discorso
Non ti stuzzico solo per il prossimo discorso
che ho intenzione di fare a un certo punto in
il futuro è esattamente quando fa il
variazione del punto di inflessione da greenfield
un brownfield e la tua ingegneria
le pratiche dovrebbero cambiare come inflessione
il punto passa dal greenfield a
Brownfield perché quando quella inflessione
il punto capita che ora tu abbia diverso
preoccupazioni di ingegneria che avete fatto da
quando era un progetto greenfield oh e
ecco il libro bianco che ero
parlare di
Aelita – prima da un certo Martin Fowler
quello è l’uomo che ha bisogno di un architetto bianco
carta di cui ho parlato così sono
andando a parlare di alcune cose
fallo in modo da poter trovare elementi di design
ma ho intenzione di passare un paio di
minuti e parla di ciò che è
purtroppo molto più comune nel nostro
mondo che sono cose che fanno trovare
elementi di design e codice duro parlerò
circa tre cose al primo di questi è
la natura della complessità
software abbiamo due tipi di complessità
e software essenziale o intrinseco
complessità ogni problema ha un certo
quantità di complessità essenziale che
c’è una parte di questo problema ma anche noi
hanno un sacco di complessità accidentale
quali sono tutti i modi veramente innovativi
abbiamo capito come creare problemi
modo più duro di quello che dovrebbe essere, che è
sembra l’area più fruttuosa di
l’innovazione nel software è come possiamo
rendere le cose ridicolmente complesse perché
siamo veramente veramente bravo a che questo è
Non una nuova distinzione Fred Brooks fatti
questa distinzione nel 1975 e noi
ancora lottare con questo, ma un sacco di
capire il design è capire l’am
Guardo un centrale contro accidentale
complessità perché ovviamente accidentale
la complessità è design che non dovrebbe essere
lì e così passare al setaccio è uno
delle cose iniziali che potevi
devo fare per capire bene è questo
qualcosa che deve essere preservato o
dovrebbe essere liberato di un secondo
cosa che rende davvero il design emergente
difficile è il debito tecnico dilagante
ovunque questa è una metafora di Ward
Cunningham che sono sicuro che tu sia tutto molto
familiarità perché è una metafora
funziona davvero bene nel reale
mondo l’idea è che se tu
guardare se si può immaginare il software
su cui stai lavorando adesso ma tu
potrebbe prodigare tutto il tuo amore e
attenzione su di esso non c’è alcun refactoring
troppo grande o troppo piccolo
si può fare tutto ciò che si desidera
rendendoli un software perfetto sulla terra
pensaci e poi il
versione di ciò che hai lasciato per venire qui
il Delta tra queste due cose è
in gran parte sarà il debito tecnico che
sono generalmente forze imposte dall’esterno
questo ti costringe a compromettere il design
gli elementi programmano le pressioni del classico
tipo di autista di debito tecnico ma lì
sono altri sui progetti c’è un famoso
uno ha chiamato l’anti-pattern dell’ancoraggio della barca
che dice che abbiamo pagato un sacco di soldi
per questo quadro di questo
infrastruttura e tu la userai
ogni progetto in cui abbia senso
utilizzare su questo progetto o no perché noi
pagato un sacco di soldi per ciò che guida a
molto debito tecnico su molto e molto
di progetti o lo standard
database aziendale spesso si asciuga tecnico
debito su molti progetti perché tutti noi
utilizzare lo stesso database per tutto e
quindi una congratulazione sta cercando di ottenere
il tuo grafico di rete attraverso Oracle vedi se
puoi mai farlo accadere
questa è davvero una realtà nel nostro mondo
questa idea di debito tecnico e di fatto
Non penso sia necessariamente un male
cosa
proprio come il debito della carta di credito, per esempio
non è necessariamente una brutta cosa ma
per fortuna c’è un mondo reale
governatore sul debito della carta di credito chiamato a
limite di credito e questa è la cosa che
la maggior parte dei progetti software è carente
limite e quindi il vero trucco tecnico
il debito non lo sta evitando, penso che lo sia
in realtà inevitabile a causa del
la natura di come il business interagisce con
il modo in cui costruisci il software il vero
il trucco per noi sta negoziando il rimborso
ma prima puoi negoziare il rimborso
devi convincere qualcuno
il debito tecnico esiste in un modo che loro
può capire che è una cosa di andare a
il tuo capo e dì che sai che sto iniziando
sentirsi male dentro sto avendo problemi
dormire la notte penso che il nostro software
potrebbe iniziare a succhiare e loro lo sono
ti chiederò subito come puoi
lo dici bene ti mostrerò come
per dire e uno dei miei mantra nel
lo spazio ingegneristico agile è a
la discussione di Trump dimostrativa che puoi
parla di queste cose finché non sei blu
in faccia e non ne farai mai
ma se puoi iniziare a mostrare
risultati oggettivi questo è il risultato di
ingegneria sulla ripetibilità se tu
puoi trovare qualcosa che mostri il tuo caso
oggettivamente puoi fare molta strada
per convincerli a fare un po ‘di esercizio
come abbiamo bisogno di passare un po ‘di tempo
il refactoring è un esercizio utile per
subire e voglio mostrarti davvero
bel manufatto tecnico che illustra
debito tecnico, ma prima lo faccio io
bisogno di divagare solo per un secondo e fare
un po ‘di background su un particolare
chiamata metrica complessità ciclomatica che
molti di voi sono senza dubbio familiari
questa è una metrica molto vecchia che è stata
anche dagli anni ’70 si sente
questo si chiama ciclomatico di mccabe
complessità perché thomas mccabe ha creato
ma l’idea qui è che puoi
posizionare un valore numerico su quanto complicato
una funzione o un metodo è ed ecco il
bordi della formula meno i nodi più 2 dove
i nodi sono linee di codice e bordi o
possibili percorsi attraverso il codice quindi se tu
guarda un piccolo metodo semplice come questo
e lo estrai in questi bordi e
tipo di vista nodi è possibile contare le cose
su questo è 4 meno 4 più 2
quindi questo ha una complessità ciclomatica di
due, ma è un po ‘noioso quando i due
si cancellano a vicenda quindi ecco a
metodo o funzione leggermente più complesso
e puoi etichettarlo con i bordi a
vista dei nodi e scoprire che ciclamato
la complessità questo ragazzo è tre così questo è
uno più complicato della funzione
che abbiamo visto prima, quindi ora abbiamo uno strumento
questo ci permette di eseguirlo contro il nostro codice
basare e valutare quale sia il più complesso
le funzioni sono a portata di mano
bene approfittare di questo un po ‘
più tardi per andare a trovare alcune cose complesse così
possiamo ucciderli ma possiamo anche
generare alcuni altri fatti interessanti
da questo parametro, ad esempio perché
questo è un livello di funzione o metodo
metrica e il tuo sistema è composto da
classi che consistono in molti metodi e
funzioni a cui potresti farcela
tutta la tua base di codice e ottieni un
numero di complessità per l’intero codice
base segregando tutti quelli insieme
e se si divide per il numero di
linee di codice si ottiene ciclomatic
complessità per linea di codice che è a
metrica molto interessante perché è possibile
vedi trend così ecco un grafico che era
creato da uno dei miei colleghi su a
progetto c’era un media di fronte pubblico
sito nel Regno Unito questa è un’istantanea di
questo progetto nel tempo dal 1 aprile 2006
al 18 agosto 2007
la linea rossa che vedi c’è
complessità ciclomatica per riga di codice
e le caselle grigie ti vedono i tuoi comunicati
di questo codice e la cosa interessante
ecco cosa è successo intorno al rilascio
numero tre perché si stavano affrettando
per ottenere questo hanno avuto un sacco di
pressione del programma si manifesta qui in
agita in complessità perché sono
aggiungendo complessità e stanno uccidendolo
spento e lo aggiungono perché
sono in un sacco di fretta e c’è un
molto churn sul progetto e la tecnologia
portare a questo progetto ha realizzato questa tendenza
stava succedendo e così produce questo grafico
e lo ha fatto a mano scrivendo a
Piccolo script rubino abbiamo eseguito una complessità
strumento sulla prima versione e quindi controllare
la seconda versione esegue il
strumento di complessità aggrega i risultati
e quindi avere grafico Excel per te
fallo più facilmente con qualcosa di simile
sonar che ti mostrerò tra un secondo
ma ha preso questo come prova per il
gestione del progetto che sembrava okay
e dove sono stati rilasciati tre
c’è una tendenza inquietante qui perché
molto spesso nel mondo del software il raw
i valori delle metriche non sono quello
significativo perché tu
un metodo che ha una carnagione di ciclamino
di 12 era quello buono o cattivo bene io no
sapere che dipende da che è essenziale o
complessità accidentale che lo sta facendo
così in alto, ma le tendenze sono spesso molto
interessante perché se ora è 12 e
poi due mesi dopo sono le 20 e poi
tre mesi dopo è 35 chiaramente
qualcosa sta andando nella direzione sbagliata
e questo è esattamente ciò che ha valutato qui
il tipo di tendenza sembrava disturbante
ma devi chiederti così cosa è
l’impatto e se non ci importava
a tale proposito che cosa facciamo lasciamo questa corsa
dilagante e lasciare che questa linea di tendenza mantenere
salendo sulla luna ciò che alla fine è
sarà il lato negativo di questo
beh, il rovescio della medaglia è che tu sei
aggiungendo più cose lì dentro
non dovrebbe essere lì in termini di tecnici
debito che significa che tutti
la velocità rallenterà solo a
un po ‘perché ora il debito tecnico
significa letteralmente cose nel tuo codice
non dovrebbe essere lì che sono compromessi
per quello che dovrebbe essere lì così quando
arriva il momento di aggiungere altre nuove funzionalità
dopo devi tornare indietro e rifare
fuori perché questa cosa strana è lì e
quindi costruisci questo compromesso
spesso costruendo un altro
compromesso intorno a questo e quindi è come
hai un giardino dove hai le erbacce
crescere e diventa molto difficile
trova le verdure per tutte le erbacce
nel tempo quindi l’impatto a lungo termine di
il debito tecnico non affrontato è quello
la velocità di tutti diventa un po ‘
più lentamente col tempo, alcuni di voi potrebbero
ho visto questo manifest nella tua azienda
dove cambia che due o tre anni
ci vorrebbero due o tre giorni ora
ci vogliono diverse settimane perché tu abbia così
molto debito tecnico costruito e di fatto
questo diventa la base per un buon risultato
argomento per dire che sai cosa non è un
cattiva idea in particolare nel codice base che
sono stati in giro per un po ‘
inevitabilmente maturano debiti tecnici n
importa quanto sei stato attento
progettandoli perché sconosciuti sconosciuti
manifestare sempre avendo un dedicato
risorsa una coppia di sviluppatori rotanti
per esempio che non fanno altro che andare e
uccidere il debito tecnico è una cosa utile
perché se hanno successo loro
aumentare la velocità di tutti solo a
un po ‘così il loro impatto è maggiore
rispetto all’impatto di sole due persone
toccare il codice perché si sta schiarendo
via sottobosco in modo che altre persone possano
essere efficace nello scrivere il codice e quello
è stato abbastanza convincente da dire okay
dobbiamo fare alcuni esercizi di refactoring
e che fondamentalmente era 300 e 3.1 con
gli sforzi per uccidere un po ‘ di quello
debito tecnico questo è un buon esempio di
questa idea che la dimostrazione di Trump
discussione che mostra fatti concreti molto spesso
fa una discussione che puoi almeno
ottenere un margine di manovra per provare alcune risorse
assegnazione o per ottenere un po ‘di tempo o
qualcosa del genere ora la persona che
prodotto questo è stato molto laborioso
tipo di processo creato a mano e puoi
spesso ottenere tipi simili di ricchi
visualizzazioni da strumenti come nel
Il sonar del mondo Java è questo freeware
strumento di misurazione che ti dà un sacco e
molte visualizzazioni incluso
complessità ciclomatica praticamente ogni
il linguaggio strutturato nel mondo ha a
strumenti di complessità ciclomatica che puoi
ottenere e scoprire, quindi è una bella
metrica utile e parlerò
un altro in un po ‘chiamato uno dei
un paio di parametri quindi quelli sono entrambi
cose che rendono difficile il design emergente
parliamo di alcune cose che rendono
è più facile alcuni acceleratori per emergenti
design e uno dei miei preferiti
acceleratori per il design emergente è il
utilizzo di test unitari e test-driven
lo sviluppo come un modo di guidare meglio
design creando meno complessità con
eliminando ipotesi errate che
strisciare molto presto e sono molto
difficile da individuare dopo il fatto, ma è
molto facile per me dire questo, ma io
volevo illustrare questa idea, quindi cosa io
Volevo fare è creare un molto
semplice piccolo problema e risolverlo in
in due modi diversi, voglio risolverlo
prima facendo test dopo aver appena scritto
il codice e quindi scrivere test per questo e
allora ho intenzione di guidare la soluzione
utilizzando lo sviluppo basato su test e vedere
qual è la differenza nel design di
quei due pezzi di codice sono e ho scelto
per questo il mio piccolo problema preferito
c’è un piccolo problema molto semplice
che ha un po ‘di carne per questo
c’è questa cosa antica che il
gli antichi Greci scoperti per primi è questo
la cosa chiamata numero perfetto è a
numero in cui la somma dei fattori
è uguale al numero se non includi
il numero stesso così sei per esempio è
un
numero perché i suoi fattori sono 1 2 e 3
e se aggiungi 1 + 2 + 3 è uguale a 6
28 è anche un numero perfetto se vuoi
per sommare un fattore e aggiungere i numeri
in alto puoi verificare che sia in effetti a
numero perfetto quindi è quello che voglio
fare è scrivere un codice che determina
numeri perfetti e così farò questo in
Java ed ecco il mio primo passaggio un test
dopo la versione di questo codice e così via
Farò è entrare e dire ok bene
So che un 1 e il numero sono
sempre parte dei fattori un numero e
ora passerò da 2 fino al numero e
se I numero mod I è uguale a 0, questo è il
operatore mod in Java, quindi se dovessi entrare
numero con un resto ancora, quindi è
uno dei fattori che aggiungi l’elenco di
fattori li riassumi e poi tu
decidere se è perfetto o no e io
ha scritto test per questo e funziona ma
è veramente lento come un matto lento e così
Pensavo che ci fosse un po ‘
così c’è un po ‘di eleganza qui così
c’è un modo ho potuto ottimizzare questo
risulta che puoi facilmente ottimizzare questo
pezzo giusto qui, rendendo il
osservazione che i fattori arrivano sempre
coppie quindi il tuo numero di destinazione è 28 quando
tu prendi 2 puoi anche prendere 14 perché
2 volte 14 è 28 e quindi puoi prendere
vantaggio di questo fatto dicendo bene
Raccogliamoli a coppie e quello
significa che non devo andare fino in fondo
al numero se sto raccogliendo in coppia
Potrei essere molto più intelligente e andare
per esempio alla metà del numero ma io
non potrebbe essere ancora più intelligente di così
e basta andare fino alla radice quadrata del
numero perché per definizione è il
numero di volte stesso che è uguale al mio
numero di destinazione se afferro tutti quelli
sotto e tutti quelli sopra li ho
tutto e questo è esattamente quello che faccio io
cambiato il mio codice per andare solo fino al
radice quadrata del numero che raccolgo
a coppie ma rompe una delle mie unità
test ho un caso limite per intero
numero di radici quadrate quindi pensaci
16 per esempio quando afferro quattro sono
ne prenderò 4 e poi lo afferro ‘
due volte quindi ho finito per aggiungere 4 due volte per a
numero intero radice quadrata ma è facile
abbastanza da sistemare
Conosco quel caso limite quindi mi limiterò a mettere un
condizione di piccola guardia qui che dice se
questa non è una radice quadrata simmetrica
quindi aggiungilo alla mia lista e questo ora
funziona ed è considerato abbastanza veloce da
considera ok è fatto così che è il test
dopo la versione hai visto l’algoritmo
per
non passerò attraverso i test
versione la versione test-driven in realtà
ha un sacco di metodi molto piccoli che è
molto caratteristico delle basi di codice TDD
perché l’atto di fare TDD stesso
ti incoraggia verso metodi molto piccoli
che sono testabili il tuo obiettivo è il
il metodo più piccolo che posso testare e realizzare
lavoro infatti dato il parametro che io
ti ho mostrato prima che diventerò una specie di a
pronuncia audace qui e se lo farai
mostrami una metrica sulla tua base di codice
Ti dirò se è un codice TDD corretto
base o no perché nella mia esperienza
le basi di codice TDD buone hanno tipicamente a
complessità ciclomatica per metodo tra
1.5 e 2 e non basi di codice TDD è
generalmente tra 8 e 15 così è
spesso un ordine di grandezza più alto per
funzione in termini di complessità in non
Il codice TDD si basa perché non c’è
forza esterna che cerca di costringerti a
mantienili semplici e tendono ad espandersi
da soli di propria volontà e
questo significa anche che le basi del codice TDD tendono
avere una forma particolare in quei lotti
di metodi molto piccoli che si nutrono di
metodi di aggregazione più ampi ma lungo il
modo di farlo ho scoperto qualcosa
interessante perché nella mia prova dopo
versione che ho mantenuto i fattori come
una lista di numeri ma fa l’ordine
conta davvero quando sto collezionando
i fattori risultano non è l’ordine
irrilevante nei fattori è un insieme di
numeri non una lista di numeri e io
l’ ho scoperto da uno dei miei piccoli
prova le rotture che dicevano che ero
aspettandomi uno due tre e sei, ma io
ho ottenuto uno sei due e tre e mi ha fatto
rendersi conto che l’ordine non conta qui
Dovrei usare set e non list ma
poi torni alle due versioni mie
codice nel test dopo la versione il mio codice
che questo ha davvero qualcosa da fare
con radici quadrate di numeri interi
risulta che non ha dovuto fare il
fatto che ho scelto i dati sbagliati
struttura inizialmente ho scelto un ordinato
struttura dei dati come a loro un non ordinato
uno e quando ho avuto quel test di rottura in
un mondo perfetto sarei tornato indietro
e rivalutato tutte le mie decisioni tutto il
ritorno all’inizio del tempo per vedere
dove giace l’errore ma non lo fai mai
soprattutto quando puoi vedere un facile
cerotto e questo è esattamente quello che ho fatto
è stato applicato questo semplice cerotto e così via
quello che ho fatto è stato scegliere l’errato
struttura dei dati inizialmente ho aggiunto
complessità accidentale e il modo in cui io
risolto era aggiungere ancora più accidentale
complessità perché molto spesso questo è il
modo in cui finisci per aggiustare un pezzo di
la complessità accidentale sta creando un
compensazione di un pezzo di accidentale
complessità piuttosto che rimuovere il
fonte originale del problema molto
spesso TDD ti porta all’originale
fonte perché ti costringe a controllare il tuo
ipotesi al livello del metodo non al
l’intero livello dell’algoritmo e ottiene
pericoloso se stai provando a controllare le cose
a livello molto grossolana perché
non saresti mai costretto a tornare indietro e
che le tue decisioni sono davvero molto
livello granulare e molte volte poco
la complessità accidentale può insinuarsi
per questo è un buon esempio di
il tipo di tecnica di progettazione emergente su
un progetto greenfield in cui stai andando
TDD e puoi usarlo come aiuto per
fare design ma parliamo di
rovescio della medaglia che è un tipo di
progetto brownfield e refactoring
verso il design questo è un piccolo frammento
di codice che viene da questo piccolo giocattolo
sito di e-commerce da cui prende le cose
carrelli della spesa e metterli in ordine
e mi piacerebbe vedere se c’è
qualcosa di interessante qui ma non posso
Dillo perché è solo una brutta pila gigante
di codice e non posso se non riesco a leggerlo
quindi non posso tirare fuori niente di utile
così prima che potessi davvero fare qualsiasi cosa
utile con questo ho bisogno di fare un po ‘
refactoring su di esso per farlo organizzare
che posso vedere cosa sta realmente succedendo
qui quindi farò una corsa di refactoring
su questo e notare che un gruppo di questi
dichiarazioni come queste tre o quattro
le affermazioni qui sono davvero tutte intorno
sorta di installazione di impianti idraulici per il
roba transazionale quindi sto solo andando
tipo di prenderli nel mio IDE e dire
Metodo estratto lo farò per diversi
di questi ragazzi che stanno tipo di correlate a
l’un l’ altro e arriva a questo intermedio
lo stato qui è solo leggermente migliore ma
Posso fare molto meglio ma notare uno strano
cosa è successo qui perché io ho
queste variabili locali hanno definito qui il mio
lo strumento di refactoring è molto specifico
contratto con me che garantisce che
una volta finito il mio codice sarà ancora
funziona esattamente allo stesso modo
fatto prima e se ho variabili locali
come questo e sto estraendo il metodo
l’unica cosa che può fare è passarli come
parametri e così tante volte ci provi
estrarre il metodo in uno di questi
funzioni complesse come questa o metodi
così finisci con questi giganti
i parametri numerici vengono passati in giro
perché questa è l’unica opzione in realtà
ha
per fortuna tu come umano capisci
le implicazioni di spostare le cose in a
portata di livello di classe rispetto a un ambito locale
e threading e visibilità e tutto
quella roba e io sono un umano quello
capisce che così farò
un’altra corsa di refactoring consolida a
un sacco di queste cose e luoghi condivisi
e finisco qui è esattamente lo stesso
codice e la motivazione per questo stile
di refactoring proviene da una specie di
luogo interessante dal libro piccolo
parli degli schemi delle migliori pratiche di Kent Beck
perché chiama questo tipo di codice
metodo composto l’idea in composto
il metodo è che ogni metodo pubblico legge
come un contorno di tutte le cose che
lo fa e quegli elementi di contorno sono
i metodi privati che ottengono quel lavoro
fatto e notare che è un particolare
potente tipo di modello per il moderno
idee perché tutti i moderni IDE
i nomi delle funzioni o dei metodi diventano
collegamenti ipertestuali quando si tiene premuto il tasto
tasto di controllo in modo da poter letteralmente navigare
il tuo codice se inizi con un pubblico
Metodo di alto livello e forare il
metodi individuali per vedere i loro dettagli
se vuoi ma non sei obbligato a farlo
trattare con i loro dettagli tutto il tempo e
ora che l’ho capito, è stato ridotto a
questo stato molto semplice è banale
guarda cosa succede e in effetti se io
abbattere queste due linee molto specifiche
di codice qui quindi ho il tipo di
modello per fare un dati transazionali
piccola struttura cosa che farò
estrai in un secondo mentre parlo di cosa
fare con queste cose come hai fatto tu
li ho scoperti ma prima che lo faccia io
voglio fare un altro esercizio di refactoring
e per questo ho bisogno di un’altra metrica
ha parlato di una complessità ciclomatica
prima di ora voglio parlare di afferente
accoppiando questo è al disaccoppiamento
accoppiamento famigliare afferente del numero
di connessioni in entrata a un particolare
artefatto o fibbia o pacchetto e così via
in questo particolare scenario questo ragazzo ha
un accoppiamento afferente di 6 il rovescio della medaglia
metrico a questo è l’accoppiamento efferente
che è il numero di uscite
connessioni e il modo di ricordare questo
è che efferente inizia con una e che
è anche la prima lettera della parola
uscita e quelle sono le chiamate in uscita
mentre afferenti sono le chiamate in arrivo
e così in molti modi se guardi a
la classe per esempio è diversa
l’accoppiamento è una misura importante
a causa di molte altre classi lo usano
è probabilmente abbastanza importante quindi ora io
ho due armi che ho una metrica
posso dirmi cose complicate e io
avere una metrica e dimmi importante
le cose andiamo a cercare complicate
cose importanti perché suona
come una buona cosa trovare così ciò che io
volevo fare è prendere un codice esistente
base e vedere se potrei usare alcuni di
queste metriche vanno bene non raccolte
schemi idiomatici che sono in agguato
in giro per molto tempo, ma ho voluto
essere una base di codice disponibile pubblicamente così
che le persone potessero riprodurre ciò di cui ho bisogno
essere in giro per un po ‘e usare per a
molte cose quindi ho scelto molto bene le montature
è stato ben noto framework web
in giro per più di un decennio è dentro
la sua seconda major release letteralmente
migliaia di applicazioni web incluso
siti Web di forza industriale sono stati
costruito sopra questo ed è il mio
contesa che ogni pezzo di software
ha un design poco idiomatico non realizzato
modelli in esso quindi andiamo a vedere se possiamo
trovare qualcosa di interessante i montanti
codebase quindi scaricherò il tratto
strumento di metriche casuali di base del codice su di esso
mi dà i miei due parametri ciclomatici
complessità e accoppiamento afferent il
strumento che ho usato se qualcuno è interessato a questo
piccolo strumento gratuito chiamato C kjm
esegue il chittim ER e l’oggetto kimra né
metrica suite su codice java che è il ck
e C kjm e il modo in cui viene segnalato
complessità ciclomatica perché è a
strumento metrico di livello di classe che riporta
complessità ciclomatica per la classe come
la somma della complessità ciclomatica di
tutti i metodi e lo chiama ponderato
la complessità del metodo e qui ci sono i
risultati per i punti di forza e così si trasforma
la componente più complessa del campione
in tutti i montanti è presente questa guida del fascio WI
con un 66 se aggiungi tutto il ciclomatico
complessità di tutti i suoi metodi fino a 66 anni
quindi se stavo solo facendo la complessità
la caccia vorrei andare dopo quel ragazzo e
prova a ucciderlo o a fargli un sacco
più semplice ma quando guardi attraverso
è usato solo da altre tre classi
e così gli sforzi di Herculean qui potrebbero
pulisci molto ma non lo farà
avere un sacco di effetti a catena in altre parti
del mio codice base
ordiniamo invece per importanza
e non sorprendentemente componente è il
il più importante in puntoni essendo un
framework web basato su componenti , ma questo è
nemmeno quello che sto cercando
o quello che sto cercando qui sono
alte combinazioni di membri ricordano
Sto cercando complicato importante
cose e voglio scoprire perché loro
esiste e quello che cattura il mio sguardo
ecco questo ragazzo del raggio UI con una cinquantina
tre e ventidue importanti e
complicato quindi andiamo a vedere perché io così
apro il raggio della UI SS e lo trovo
ragazzo adorabile che valuta i miei param
la parte preferita di questo metodo è di gran lunga
l’ ultima riga del metodo che
è valutare parametri extra è come il
lo sviluppatore si è stancato di digitare a
qualche punto oh dio okay valuta extra
Carrozzine Credo di aver finito così che questo codice
fa struts come una struttura web componente
e a volte fa la magia automatica
cose i parametri URI ea volte
li passa semplicemente attraverso invisibilmente
ea volte le mappature avvengono
quei ragazzi così sono i parametri di valutazione
e valutare i parametri extra ora come ho fatto io
ho iniziato a sbirciare tra le gambe
Ho notato che molti e molti di questi
valutare i parametri per valutare i passeggini extra
metodi che stiamo mostrando e così ho ottenuto
davvero curioso, certo che puoi farlo
in IDE ma l’ho fatto sulla linea di comando con
un po ‘di judo da linea di comando come
sta iniziando il percorso dei montanti dare
me tutti i metodi o mi dai tutto
i file di origine Java e trovare tutto il
quelli che hanno una dichiarazione per
valutare qualcosa di param e qui loro
ho trovato un modello idiomatico
e puntoni e questo è un esempio perfetto
di uno schema idiomatico perché quindici
anni fa, quando ho iniziato a lavorare
non c’è modo in cui hanno detto che lo sai
quello che in 15 anni è il più complicato
parte dei montanti sarà il modo in cui gestiremo
Parametri URI perché è così
problema semplice è così semplice in effetti
hanno reimplementate più e più e
ancora e ancora e ancora nel
codebase senza rendersene conto
manifestando dappertutto così
c’è un epilogo interessante a questo
storia Ho scritto questa analisi e quella
serie di lavoro degli sviluppatori stavo parlando
circa e uno degli sviluppatori di stress
mi ha contattato e ha detto che aveva fine
scoperto la stessa identica cosa
manifest nei codebase di puntoni e lui
era in procinto di risolverlo
estraendo tutto quel parametro uri
maneggiare roba come componente interno
di puntelli quindi se guardi puntoni ora
tu o I parametri sono gestiti da questo
componente interno e facendo ciò lui
buttato giù diverse migliaia di righe di
codice e diverse centinaia di complessità
indica puntoni senza cambiare
la funzionalità dei montanti lui solo
notevolmente semplificato perché nessuno aveva
mai usato quel particolare obiettivo per
illumina quella parte del codice base
è come se questo codice duplicato fosse
correre in giro dappertutto
ma letteralmente non potevi vederlo
perché è in agguato e si nasconde dietro
tutte le altre cose che ci sono così una volta
hai trovato queste cose, cosa fai?
con loro come li catturi e
ci sono un paio di semplici modi per fare
questo semplice modo per farlo è giusto
catturalo come un’API questo è il
il modo più semplice è l’unità di come tu
catturare le cose nel mondo Java così
esempio che ti ho mostrato per questo
unità di lavoro idiomatica questo è il codice
che voglio catturarlo da così dentro
Java Posso entrare molto facilmente qui e
diciamo usiamo un design corretto per la gang a4
schema qui e lo estraeremo
usando lo schema di comando così ora il mio
comanda lassù e questo è ora il mio
metodo che probabilmente vale la pena notare
l’intera diapositiva piena di codice che io
ti ho mostrato prima di questo perché non l’hai fatto
quell’essere è questo un metodo proprio qui
dopo tutto ciò che aveva la roba utile riutilizzabile
stato risucchiato fuori di esso, una volta abbiamo determinato
in cosa consistevano le utili cose riutilizzabili
Infatti se guardi questo questo piccolo
la cosa della transazione rapida sembra molto simile
Le molle fanno nel wrapper transazionale che
fondamentalmente molte delle stesse cose
Java forza una discreta quantità di sintassi
rumore su di te perché davvero tutto ciò che vuoi
fare è questo avvolgere questa roba in a
transazione e lingue di livello superiore
ordinare funzioni come groovy e di
Ovviamente Java 8 lo faremo a
molto più pulito e semplice perché si ottiene
sbarazzarsi della classe middleman che è solo
lì come detentore per quell’esecuzione
metodo e così ad esempio in groovy if
hai scritto esattamente la stessa cosa che sarebbe stata
molto più pulito perché questo qualcosa
parentesi graffe in groovy è un blocco di codice
e questo viene passato qui e quello è
zucchero sintattico
la stessa identica cosa che puoi fare in a
lingua delle funzioni di ordine superiore e
in modo che in realtà pulisce molto
e questo risulta essere un bel
cosa importante
la pulizia sintattica è davvero
importante perché il tuo codice è tuo
documento di design e quindi design e
la leggibilità è strettamente intrecciata
l’uno con l’altro sulla base di quello che Jack
Reeves stava dicendo che la leggibilità fa un
grande differenza nell’altro modo in cui puoi
raccogliere questi ragazzi in lingue come
Java usa annotazioni che non penso
la gente usa questo abbastanza questo è
in realtà un meccanismo molto potente in
Java perché aggiunge un livello extra di
espressività alla lingua che tu
normalmente non ce l’ ho è stato davvero bello
cosa da avere ma non ne spenderò più
tempo in cui molte strutture usano
questo ma non molti usano gli sviluppatori
questo meccanismo e non è adatto per
tutto ovviamente, ma la cosa bella
è che le annotazioni vivono molto vicino a
la cosa che stai cercando di modificare
e quindi c’è un bel tipo di località
alle modifiche che stai facendo lasciare
io parlo solo di un secondo sull’astrazione
stili perché ho citato il
f-word la parola di programmazione funzionale
qui come ho detto Landers siamo tutti
interessati sono tutti in anteprima con
linguaggi di programmazione imperativi
strutturato e modulare e
orientati agli oggetti sono tutti in stili
e periodo di stili di astrazione, ma tu
ascolta molto sulla programmazione funzionale
in questi giorni capisco che anche se lo è
davvero solo una diversa gamma di strumenti
è letteralmente una cassetta degli attrezzi diversa e
nessuno dei due è particolarmente adatto a
risolvere ogni problema meglio del
altro ma un sacco di volte l’uso di uno è
più adatto a un particolare tipo di
problema perché corrisponde all’essenziale
la complessità è migliore di un’altra e
finiamo per essere presi molto in
tipo di paradigma di fondo nel
il linguaggio supporta perché è il
modo predefinito in cui le cose funzionano ma tu
non c’è bisogno di farsi prendere in questo e
un grande esempio di questo è questo concetto
di un oggetto anti che proviene da a
carta che è stata consegnata a Uppsala in
2006, credo chiamato collaborativo
diffusione e hanno creato questo
concetto di un oggetto anti nella loro carta
Dicono che la metafora di Rob è che puoi andare
troppo lontano costringendoci a creare oggetti
molto ispirato al mondo reale
un oggetto anti è tipo di oggetto quello
fa il contrario di ciò che pensi
dovrebbe fare come un modo di modellare
qualcosa che è più semplice un po ‘come
questa illusione ottica è questa di a
fonte in due fasi e il classico
arriva un esempio di approccio anti oggetto
a noi in forma di pac-uomo ora ho
per avvisarti che sto per spiegare come
pac-man funziona se vuoi mantenere
giocando a pac-man e goditelo, dovresti
vattene ora e capirò
a volte la conoscenza ha un costo e
il costo per questo è che non lo farai
godi pac-man abbastanza perché lo sono
Spiegherò l’algoritmo a te quando
pensi al gioco della console pac-man
che è uscito nei primi anni ’80 loro
aveva meno memoria e potenza di elaborazione
di quello che la maggior parte degli orologi ha ora e loro avevano
un problema davvero difficile risolvere è come facciamo a
calcolare la distanza tra due
gli oggetti in movimento in un labirinto non l’hanno fatto
avere ovunque un’elaborazione quasi sufficiente
potere di farlo
quindi hanno adottato un approccio anti oggetto
questo piuttosto che costruire l’intelligenza in
va al singolo pac-man
ecc. hanno costruito tutte le informazioni
il labirinto il labirinto è fondamentalmente uno stato
macchina che per ogni cella viene eseguita
regole per ogni volta durante il gioco
ciclo e hanno inventato questo concetto di
odore di pac-uomo e quando è pac-man
seduto su una cella ha il pac-man massimo
odore e la cella che ha appena lasciato
ha il massimo odore di pac-uomo meno 1 e it
decade molto rapidamente e tutti i fantasmi
fare è vagare in giro in modo casuale fino a quando
incontrano l’odore di pac-uomo a cui vanno
il prossimo argento adiacente più forte e
si muovono leggermente più velocemente di pac-man
e questo è l’intero gioco pseudo-casuale
i numeri e l’odore di pac-uomo e hanno fatto a
cosa davvero subdolo per te perché il
i fantasmi hanno dato loro occhi ma loro
dovrebbe solo dargli un naso
perché non possono vedere voi a venire
può correre su di loro e loro non possono
ci vediamo ma possono sentire l’odore di dove sei
stato
quindi i fantasmi hanno davvero bisogno di nasi giganti
ma senza occhi ma ti hanno ingannato
mettendo gli occhi su di loro ma ora il prossimo
volta che si gioca a Pac-Man si può correre a destra
su un fantasma ea meno che non lo faccia
si gira casualmente verso di te, non lo fa
sai che sei lì perché possono solo
segui questo è un grande esempio di
prendendo un progetto che era troppo complicato
costruire e gli strumenti che avevano al
tempo e venire con un modo di
sfogliando l’abstract
all’indietro e essere in grado di costruire
qualcosa e quando miss pac-man è uscito
hanno mantenuto lo stesso algoritmo proprio loro
ha reso il generatore di numeri casuali migliore
quindi un sacco di questo è in questo posto di
ricerca e raccolta idiomatica
schemi ma voglio tornare per a
secondo all’ultimo momento responsabile e
parla di come lo determini
punto di flesso quindi se si guarda
complessità nel tempo sul progetto che guardi
a particolari componenti come parte del tuo
lo stack architettonico che noterai
che nel tempo assumono variazioni
gradi di responsabilità e se quelli
punti di flesso dove stanno prendendo
su più responsabilità o sul serio
cambia a loro quella è la volta che leggi
e dire che hai davvero raggiunto il tuo
ultimo momento responsabile e quindi questo
in realtà va verso uno dei
caratteristiche di Architects su agile
i progetti hanno bisogno di molto di più
consapevolezza del tipo di eventi attuali di
cosa sta succedendo nel codice perché loro
bisogno di essere in grado di fare questo tipo di
le determinazioni abbiamo raggiunto l’ultimo
momento responsabile ha questa componente
ha iniziato ad assumerne troppi
responsabilità di cui siamo anche grandi fan
facendo picchi che sono sperimentali
esercizi di codifica per determinare di liberarsi
di incertezza per cose come le stime
ce n’è un altro davvero famoso
anti-modello chiamato il dammi
stima ora anti-pattern e il modo
questo modello si manifesta è che qualcuno
ti ha chiesto di stimare qualcosa e tu
non ne so nulla come dire
me quanto ci vorrà
geocoding questa applicazione e il
la cosa veramente pericolosa qui è indovinare
perché mi danno delle stime ora
anti-modello dice che non appena
i numeri escono dalla tua bocca che hai
inavvertitamente entrò in una corazza
contratto che si rischia la vita per
rendere tale data avverata, non importa come
molte parole cialda ti mettono di fronte ad essa
i picchi ti permettono di allontanarti da quello
perché ora puoi guardare e
determinare e sbarazzarsi di alcuni dei
incertezza che sta portando al
speculazione su quanto durerà
prendi questo per riassumere
ovviamente architettura evolutiva e
la progettazione emergente richiede una buona ingegneria
pratica se hai un buon codice TDD
base su cui puoi fare il refactoring
è molto più facile fare questi esercizi
non ti preclude dal farli
certamente lo rende molto più facile se
hai già una buona ingegneria
pratica il
la più avanzata pratica ingegneristica
quale l’ architettura e il design spaziano
diventa più facile cercare di prevedere il
il futuro porta all’ingegneria che
è una brutta cosa e questo sta per essere un
sottile distinzione ma penso davvero
importante perché nel mondo agile
stiamo cercando di preferire essere professionisti e
reattivo al predittivo non stiamo provando
per predire il futuro quello che stiamo provando
fare è essere proattivi di cose che
so che succederà in futuro
e quindi essere immediatamente reattivo come
le cose accadono nel nostro codice base che noi
bisogno di essere in grado di rispondere al
combinazione di Pro e reattivo penso
funziona molto meglio di cercare di ottenere
sempre meglio a predittivo perché
come dirà ogni angolo della strada psichico
stai cercando di migliorare
predire il futuro è davvero davvero
difficile da fare, sono fuori dal tempo e non lo faccio
vogliono tagliare a pranzo perché so
questo è un argomento molto importante per l’ agenda
molti di voi sarò qui per il resto
settimana se avete domande o
qualcosa di simile, grazie molto per
in arrivo spero che ti sia piaciuto
un po ‘ di ricerca e sviluppo su e
Sto continuando a fare ricerche e
sviluppo su questo e in effetti ho
fatto ho scritto di questo
soggetto sul sito developerworks che ho
scritto 20 rate intorno a questo
soggetto puoi arrivarci attraverso questo
URL ma è orribile e terribile così ho
usato la tecnologia moderna per accorciarlo
e renderlo più accessibile e così tu
puoi leggere molto di più su questo argomento
lì se ti interessa il mio
l’agenda di questa mattina è parlare prima
su cosa è il software design cosa facciamo
significa che parliamo di design e software
poi un po ‘ sulla distinzione
tra architettura e design e it
risulta che è particolarmente utile
modo di distinguere tra questi due
cose che ti permettono di pensare
loro separatamente, che è molto spesso a
esercizio utile per esibirsi poi parlo
su cose che ti fanno emergere
progettare duro ho parlato di alcune cose
questo lo rende più facile e poi ho parlato a
un po ‘su una volta che hai trovato questi design
elementi cosa puoi fare con loro come
li raccogli e come li prendi?
vantaggio di loro, ma ho intenzione di iniziare
con la poesia di Donald Rumsfeld che
molto famoso ha detto che ci sono noti
incognite, cioè, ci sono cose
che ora sappiamo che non lo sappiamo, ma lì
sono anche sconosciuti sconosciuti ci sono
cose che non sappiamo non sappiamo
e lui non se ne rendeva conto, ma lo era
davvero parlando di software qui
perché questo risulta essere il micidiale
cosa nel software non è il noto
incognite perché puoi farlo
piani di emergenza per quello che conosci noi
non capisco davvero come funziona
quindi pianifichiamo un po ‘di tempo per la ricerca e
sviluppalo e pensaci è il
sconosciuti sconosciuti che finiscono per ucciderti
e infatti questa è la cosa che
alla fine uccide qualsiasi tipo di grande gigante
sforzo di progettazione in anticipo nel software
sei sempre beccato dall’ignoto
incognite e così nello spazio agile cosa
ci siamo resi conto che il futuro è
davvero molto difficile da prevedere e nel
mondo dell’architettura tradizionale cosa
che hanno cercato di fare da anni è
grazie alla loro sfera di cristallo
applicare di più e
o il rigore ad esso e abbiamo fatto
qualcosa di diverso che abbiamo detto che tu sai
il futuro è davvero difficile da prevedere
cosa succede se invece di migliorare e
meglio a prevedere il futuro che otteniamo
sempre meglio nell’adattabilità come noi
vai e poi non paghi proprio così
prezzo difficile per avere l’ignoto
pop-up sconosciuto perché sei molto di più
adattabile è esattamente ciò che questo discorso
Riguarda è come possiamo costruire tecniche
per l’adattabilità nel software in modo che
noi non paghiamo questi enormi prezzi per il
inevitabili incognite sconosciute che sono
sempre in agguato dietro l’angolo
ma prima di arrivare troppo in là noi
davvero bisogno di rispondere a una fondamentale
domanda come cosa intendiamo noi parliamo?
sulla progettazione del software e fortunatamente
qualcuno ha risposto a questa domanda
ci riporta in autunno del 1992 in C ++
il diario Jack Reeves ha scritto molto
saggio influente che puoi ancora
arrivare in quella posizione vale comunque la pena
leggendo perché ci crederesti
è stato scritto la scorsa settimana e tu lo fai
alcune osservazioni molto in questo documento
perché quello che sta cercando di fare qui è
fare un profondo confronto metaforico
tra ingegneria tradizionale e
l’ingegneria del software fa molta luce
confronti metaforici su di te
il nostro lavoro è come costruire ponti o il nostro
il lavoro è come il giardinaggio o la montagna
arrampicata o tutti questi tipi di sciolto
confronti metaforici ma tu vuoi
vai un po ‘ più a fondo e vedi come
le cose sono davvero simili e come le cose
sono davvero diversi e lui viola
alcune conclusioni interessanti la prima
un essere che è l’obiettivo finale di qualsiasi
attività di ingegneria è un qualche tipo di
documentazione se sei un ingegnere civile
e hai il compito di creare un nuovo
ponte qual è il tuo risultato per il tuo
lavoro è un progetto per un ponte in a
luogo particolare che opera sotto
particolari vincoli che ha
particolari caratteristiche di scalabilità
ma in realtà non costruisci quel ponte
lo consegni a un gruppo di persone
chi sono esperti costruttori di ponti e tu
consegnalo a un team di produzione e
quindi l’ output per lo sforzo ingegneristico
è questo disegno che gestisci e un
squadra di ingegneri in realtà finisce
produrlo ma ecco uno dei
luoghi in cui il mondo tradizionale in
il mondo del software differisce molto perché
per le cose fisiche significa uscire
atomi e si scopre che una volta che hai
atomi stampati in una forma particolare
è davvero difficile da capire loro di
cercando un ricampionamento in un altro
forma a cui devi fare cose pazze
come scioglierli o cambiare la loro sostanza chimica
composizione ecc. ma non viviamo in un
atomi mondo basato viviamo in un boccone
mondo base e byte sono super soft e
malleabile e puoi cambiarle tutte
il momento in cui la goccia di un cappello è molto
cosa diversa dal nostro mondo in
mondo dell’ingegneria tradizionale ma poi
devi chiedertelo quindi qual è il
analogico nel mondo del software a quello
processo di produzione che tradizionale
l’ingegneria passa attraverso di essa
è la compilazione e l’implementazione
processo che attraversiamo è il
cosa che prende il nostro design e
lo manifesta in qualcosa che si muove
cose in giro nel mondo reale in questo
caso elettroni attraverso fili ecc
suggerisce che il nostro progetto sia il nostro progetto
il nostro risultato per lo sforzo ingegneristico
è il codice sorgente la fonte completa
codice questo è il nostro programma per il software
e ogni modifica che modifica il codice sorgente
cambia il nostro design ogni volta che fai un
cambia il codice sorgente che stai modificando
il design del tuo pezzo di software così
il debugging fa parte della qualità del design
L’assicurazione fa parte del design perché loro
apportare modifiche che producono cambiamenti nel
codice sorgente il tuo software che è il tuo
design ma qui è dove ci differenziamo davvero
dal tradizionale nella produzione
mondo perché il processo più costoso
nel mondo dell’ingegneria giudiziaria è il
abbattere gli atomi parte infatti molto
le tecniche di prevedibilità che
sono stati creati nel tradizionale
il mondo dell’ingegneria non è stato creato per
rendere le cose più sicure sono state create
inizialmente per renderli di più
conveniente perché è anche troppo
costoso per testare i ponti costruendo
nuovi ponti e rotolamento di cose pesanti
loro per vedere se crollano o no
è un modo terribile per costruire ponti
ma possiamo costruire un software del genere
giorno lungo perché praticamente non c’è
costo per rigenerarlo, basta risolvere il problema
piccolo buco e riabilitare il tutto
cosa e abbiamo un tipo realistico di
di nuovo il mondo la nostra produzione è sporca
economico infatti ogni volta che smetti di digitare
adesso
un esercito di gnomi nel tuo computer
prende vita e produttori sei
progettato per te e Jack Reese
conclude come saggio dicendo che dato
che i progetti software sono relativamente
facile da realizzare ed essenzialmente gratuito
costruire una rivelazione non sorprendente è quella
i progetti software tendono ad essere incredibilmente
ampio e complesso penso che siano suscettibili
alcune delle cose più complesse che
gli umani creano perché non ne abbiamo
degli stessi vincoli che altri tipi
di ingegneria ha per esempio non lo facciamo
avere lo stesso tipo di località da criticare
che i sistemi tradizionali hanno così se a
l’ala cade da un aereo per la polizia legale
l’ingegnere può andare dove era
collegato l’aereo e dedurre quello
Probabilmente è un problema lì intorno
ma nel software qualche piccola colpa può
causare un’instabilità che non lo fa
manifestare per centomila righe di
codice via quindi è molto difficile da rintracciare
giù esattamente qual è quel problema è
anche straordinariamente fragili che abbiamo
punti di rottura molto molto fragili in
software diverso da quello tradizionale
mondo ingegneristico quindi il software
i disegni tendono ad essere questi grandi giganti
cose complesse perché non abbiamo il
stesso tipo di modalità di guasto e lo stesso
tipo di vincoli che li terrebbero
semplice che esiste nel mondo reale e
la sua conclusione definitiva perché il
il software può essere economico da compilare ma è così
incredibilmente costoso da progettare perché
tutto quello che stai facendo è fondamentalmente
parte di questo processo di progettazione nel software
quindi quando stavamo parlando di design lui
Stavo davvero parlando di ciò che abbiamo parlato
circa ora comprende tutti
architettura e design e tutto il
cose che costituiscono ciò che stai facendo come
tu crei un nuovo software ma io voglio
fare una differenza qui tra
architettura e quello che sto chiamando design
sfortunatamente il design è uno di quelli
mega parole sovraccariche perché Jack
Reeves usa il design come fondamentalmente ciò che noi
chiama architettura e progetta tutto il
cose che vanno nel software quando noi
pensiamo di progettazione ora pensiamo a utente
esperienza di design e il tipo di
interazione con l’ esperienza dell’utente che non lo è
il tipo di design che sto parlando del
la differenziazione che voglio fare qui è
quello che fa Martin Fowler nel suo
Libro bianco chiamato a chi ha bisogno di un
architetto ed è in realtà la base
per il titolo del lavoro dello sviluppatore
serie
che ti ho fatto vedere di sfuggita in precedenza
è questa idea che nel suo un whitepaper
chi ha bisogno di un architetto che sia veramente un
white paper sul ruolo degli architetti
su progetti agili che tipo di
incidentalmente dà alcune definizioni di
architettura e uno di quelli è il mio
definizione preferita di architettura e
ti porta a questo tipo molto utile di
capacità di fendere questa definizione in
parte è che gli elementi architettonici
e un pezzo di software sono le cose
che sono percepiti come difficili da cambiare
più tardi e che in effetti porta al
titolo di quella serie di lavoro dello sviluppatore I
non so se l’hai notato o no
architettura evolutiva ed emergente
design e c’è un importante
distinzione tra queste due cose
perché se gli elementi architettonici
sono le cose che sono difficili da cambiare
in seguito quelli sono rappresentati qui in natura
di queste scatole grigie tutto si posa
parte superiore dell’architettura che non si può avere
architettura emergente perché tutto
poggia su di esso ma non puoi avere
design emergente quindi le scatole grigie qui
in questa immagine molto astratta rappresentano
elementi architettonici che non puoi iniziare
mescolando quelli senza fare
tutto è instabile, quindi le cose sono così
sono seduti in cima puoi avere molto
maggiore flessibilità nel muovere quelle cose
intorno e così si può tipo di chiedere
te stesso quando guardi il tuo software
stack wotz architecture contro design se
è difficile cambiare più tardi della sua darka
testuale quindi la tua lingua è certamente
architettonico il framework web che hai
scelto come architettonico perché tu
non posso cambiare banalmente questo per
qualcosa dopo ma il modo in cui stai usando
quegli elementi architettonici così il tuo web
quadro nel modo in cui stai usando il
flusso di lavoro e la convalida e tutti
quei pezzi che vengono con quelli sono
veramente aspetti del design e tu no
devono ottenere quelli quasi corretti
perché la pena per cambiarli
non è quasi così alto perché gli altri
le cose non poggiano su di loro e dipendono da
loro quindi il vero trucco in questo mondo è
possiamo costruire componenti architettonici
questo è semplicemente sufficiente che possiamo
evolvere nel tempo perché la seconda metà
di questa definizione è idealmente che desideri
avere poche di queste cose che sono
difficile da cambiare il più possibile perché
elementi architettonici ti danno utili
impalcature sono cose che non hai
per costruire te stesso ma anche loro
rappresentare i vincoli e quindi cosa faremmo
piace avere il massimo beneficio con
il minor numero di vincoli e questo è
il modo in cui cerchiamo di progettare le cose e noi
rendere questa divisione tra evolutiva
architettura che è molto nel
tipo di micro-servizi resto e
mondi basati su componenti il precedente
parlava di chi parlava e quello
le altre persone in questa traccia stanno andando
parleremo più tardi di oggi
concentrati principalmente in questo discorso su questo design
aspetto e in particolare il design emergente
e quindi parliamo di alcune definizioni
se guardi la parola emergenza che è
fondamentalmente la parola radice di emergente o
viceversa e la definizione da
Webster dice emergente o emergente
lo sfrigolio ma qualcosa sui liquidi così
Ho intenzione di modificare in modo selettivo il
Definizione di Webster per ottenere esattamente il
uno che voglio emergere o emergere
fuori di tutto ciò che copre o nasconde
o viene alla luce e ce n’è un altro
Definizione di Webster che è improvvisamente
apparire inaspettatamente o
chiede un’azione tempestiva entrambi questi
gli aspetti rivelano la nostra parte di questo mondo
di design emergente e ho intenzione di parlare
su due aspetti diversi che farò
fare un tuffo molto più in profondità durante la
corso di questo discorso ed ecco il primo
diciamo che concettualmente è
il tuo lavoro ha un problema che sembra
un po ‘ come questo e mentre sei a
lavoro che stai pensando a questo mentre
stai guidando verso casa a cui stai pensando
su questo mentre stai falciando il tuo giardino
stai pensando a questo quando il tuo
il coniuge sta parlando con te che sei supposto
per prestare attenzione a loro sono
ancora parte del tuo cervello e ancora
a lavorare su questo perché si sa che
c’è una sorta di schema e tutto
questo casino che puoi davvero risolvere
ci pensi davvero a lungo e duramente
e infine una sorta di schema utile
o la gerarchia viene fuori da quello
questo è davvero questo esercizio di presa
codice esistente e ricerca di astrazioni
e modelli che sono viventi e in agguato
e nascondendo in quel codice e mostrerò
voi usando alcune tecniche concrete
metriche e altre cose per andare effettivamente
e fallo in una base di codice esistente così
fa parte del design emergente
codice esistente e in grado di
trova elementi di design che sono lì dentro
che non hai mai visto prima perché
non hai avuto una luce particolarmente
che potresti splendere su quell’angolo di
la tua base di codice per illuminare quel poco
problema di progettazione così è
metà delle tecniche parlerò
circa l’ altra metà è questo concetto
dai software magri ragazzi dell’ultimo
momento responsabile per prendere decisioni
riguardo alle cose l’ idea qui è proprio così
spesso su progetti si è presentato con
la decisione che dovresti chiederti è
c’è un modo in cui posso rinviare responsabilmente questo
decisione fino a più tardi l’idea è quella
più a lungo è possibile ritardare tale decisione
più conoscenza e contesto reali
sulla vera natura del problema no
ciò che si pensa è il problema, ma la
problema reale più a lungo puoi ritardare
che più informazioni reali puoi
lavora e hai un potenziale per a
decisione migliore ovviamente non puoi aspettare
troppo lungo e questa è la cosa più difficile
l’ultimo momento responsabile ma il
più a lungo puoi ritardare di avere più reale
dati per una decisione e quindi il trucco
qui diventa come lo trovi
punto di inflessione dell’ultimo responsabile
momento parlerò di alcune tecniche
su quello che è dove la fine del
parlare e quindi parlerò
questi due aspetti del design emergente e
si scopre che questi due molto bene
cadere in due categorie
trovare astrazioni e schemi funziona
veramente bene su brownfield esistente
proietta dieci giri di tempo responsabile
funziona davvero molto bene su greenfield
o nuovo tipo di progetti e in
Infatti alcune delle ricerche attuali sono
fare è e non ci arriverò in questo discorso
Non ti stuzzico solo per il prossimo discorso
che ho intenzione di fare a un certo punto in
il futuro è esattamente quando fa il
variazione del punto di inflessione da greenfield
un brownfield e la tua ingegneria
le pratiche dovrebbero cambiare come inflessione
il punto passa dal greenfield a
Brownfield perché quando quella inflessione
il punto capita che ora tu abbia diverso
preoccupazioni di ingegneria che avete fatto da
quando era un progetto greenfield oh e
ecco il libro bianco che ero
parlare di
Aelita – prima da un certo Martin Fowler
quello è l’uomo che ha bisogno di un architetto bianco
carta di cui ho parlato così sono
andando a parlare di alcune cose
fallo in modo da poter trovare elementi di design
ma ho intenzione di passare un paio di
minuti e parla di ciò che è
purtroppo molto più comune nel nostro
mondo che sono cose che fanno trovare
elementi di design e codice duro parlerò
circa tre cose al primo di questi è
la natura della complessità
software abbiamo due tipi di complessità
e software essenziale o intrinseco
complessità ogni problema ha un certo
quantità di complessità essenziale che
c’è una parte di questo problema ma anche noi
hanno un sacco di complessità accidentale
quali sono tutti i modi veramente innovativi
abbiamo capito come creare problemi
modo più duro di quello che dovrebbe essere, che è
sembra l’area più fruttuosa di
l’innovazione nel software è come possiamo
rendere le cose ridicolmente complesse perché
siamo veramente veramente bravo a che questo è
Non una nuova distinzione Fred Brooks fatti
questa distinzione nel 1975 e noi
ancora lottare con questo, ma un sacco di
capire il design è capire l’am
Guardo un centrale contro accidentale
complessità perché ovviamente accidentale
la complessità è design che non dovrebbe essere
lì e così passare al setaccio è uno
delle cose iniziali che potevi
devo fare per capire bene è questo
qualcosa che deve essere preservato o
dovrebbe essere liberato di un secondo
cosa che rende davvero il design emergente
difficile è il debito tecnico dilagante
ovunque questa è una metafora di Ward
Cunningham che sono sicuro che tu sia tutto molto
familiarità perché è una metafora
funziona davvero bene nel reale
mondo l’idea è che se tu
guardare se si può immaginare il software
su cui stai lavorando adesso ma tu
potrebbe prodigare tutto il tuo amore e
attenzione su di esso non c’è alcun refactoring
troppo grande o troppo piccolo
si può fare tutto ciò che si desidera
rendendoli un software perfetto sulla terra
pensaci e poi il
versione di ciò che hai lasciato per venire qui
il Delta tra queste due cose è
in gran parte sarà il debito tecnico che
sono generalmente forze imposte dall’esterno
questo ti costringe a compromettere il design
gli elementi programmano le pressioni del classico
tipo di autista di debito tecnico ma lì
sono altri sui progetti c’è un famoso
uno ha chiamato l’anti-pattern dell’ancoraggio della barca
che dice che abbiamo pagato un sacco di soldi
per questo quadro di questo
infrastruttura e tu la userai
ogni progetto in cui abbia senso
utilizzare su questo progetto o no perché noi
pagato un sacco di soldi per ciò che guida a
molto debito tecnico su molto e molto
di progetti o lo standard
database aziendale spesso si asciuga tecnico
debito su molti progetti perché tutti noi
utilizzare lo stesso database per tutto e
quindi una congratulazione sta cercando di ottenere
il tuo grafico di rete attraverso Oracle vedi se
puoi mai farlo accadere
questa è davvero una realtà nel nostro mondo
questa idea di debito tecnico e di fatto
Non penso sia necessariamente un male
cosa
proprio come il debito della carta di credito, per esempio
non è necessariamente una brutta cosa ma
per fortuna c’è un mondo reale
governatore sul debito della carta di credito chiamato a
limite di credito e questa è la cosa che
la maggior parte dei progetti software è carente
limite e quindi il vero trucco tecnico
il debito non lo sta evitando, penso che lo sia
in realtà inevitabile a causa del
la natura di come il business interagisce con
il modo in cui costruisci il software il vero
il trucco per noi sta negoziando il rimborso
ma prima puoi negoziare il rimborso
devi convincere qualcuno
il debito tecnico esiste in un modo che loro
può capire che è una cosa di andare a
il tuo capo e dì che sai che sto iniziando
sentirsi male dentro sto avendo problemi
dormire la notte penso che il nostro software
potrebbe iniziare a succhiare e loro lo sono
ti chiederò subito come puoi
lo dici bene ti mostrerò come
per dire e uno dei miei mantra nel
lo spazio ingegneristico agile è a
la discussione di Trump dimostrativa che puoi
parla di queste cose finché non sei blu
in faccia e non ne farai mai
ma se puoi iniziare a mostrare
risultati oggettivi questo è il risultato di
ingegneria sulla ripetibilità se tu
puoi trovare qualcosa che mostri il tuo caso
oggettivamente puoi fare molta strada
per convincerli a fare un po ‘di esercizio
come abbiamo bisogno di passare un po ‘di tempo
il refactoring è un esercizio utile per
subire e voglio mostrarti davvero
bel manufatto tecnico che illustra
debito tecnico, ma prima lo faccio io
bisogno di divagare solo per un secondo e fare
un po ‘di background su un particolare
chiamata metrica complessità ciclomatica che
molti di voi sono senza dubbio familiari
questa è una metrica molto vecchia che è stata
anche dagli anni ’70 si sente
questo si chiama ciclomatico di mccabe
complessità perché thomas mccabe ha creato
ma l’idea qui è che puoi
posizionare un valore numerico su quanto complicato
una funzione o un metodo è ed ecco il
bordi della formula meno i nodi più 2 dove
i nodi sono linee di codice e bordi o
possibili percorsi attraverso il codice quindi se tu
guarda un piccolo metodo semplice come questo
e lo estrai in questi bordi e
tipo di vista nodi è possibile contare le cose
su questo è 4 meno 4 più 2
quindi questo ha una complessità ciclomatica di
due, ma è un po ‘noioso quando i due
si cancellano a vicenda quindi ecco a
metodo o funzione leggermente più complesso
e puoi etichettarlo con i bordi a
vista dei nodi e scoprire che ciclamato
la complessità questo ragazzo è tre così questo è
uno più complicato della funzione
che abbiamo visto prima, quindi ora abbiamo uno strumento
questo ci permette di eseguirlo contro il nostro codice
basare e valutare quale sia il più complesso
le funzioni sono a portata di mano
bene approfittare di questo un po ‘
più tardi per andare a trovare alcune cose complesse così
possiamo ucciderli ma possiamo anche
generare alcuni altri fatti interessanti
da questo parametro, ad esempio perché
questo è un livello di funzione o metodo
metrica e il tuo sistema è composto da
classi che consistono in molti metodi e
funzioni a cui potresti farcela
tutta la tua base di codice e ottieni un
numero di complessità per l’intero codice
base segregando tutti quelli insieme
e se si divide per il numero di
linee di codice si ottiene ciclomatic
complessità per linea di codice che è a
metrica molto interessante perché è possibile
vedi trend così ecco un grafico che era
creato da uno dei miei colleghi su a
progetto c’era un media di fronte pubblico
sito nel Regno Unito questa è un’istantanea di
questo progetto nel tempo dal 1 aprile 2006
al 18 agosto 2007
la linea rossa che vedi c’è
complessità ciclomatica per riga di codice
e le caselle grigie ti vedono i tuoi comunicati
di questo codice e la cosa interessante
ecco cosa è successo intorno al rilascio
numero tre perché si stavano affrettando
per ottenere questo hanno avuto un sacco di
pressione del programma si manifesta qui in
agita in complessità perché sono
aggiungendo complessità e stanno uccidendolo
spento e lo aggiungono perché
sono in un sacco di fretta e c’è un
molto churn sul progetto e la tecnologia
portare a questo progetto ha realizzato questa tendenza
stava succedendo e così produce questo grafico
e lo ha fatto a mano scrivendo a
Piccolo script rubino abbiamo eseguito una complessità
strumento sulla prima versione e quindi controllare
la seconda versione esegue il
strumento di complessità aggrega i risultati
e quindi avere grafico Excel per te
fallo più facilmente con qualcosa di simile
sonar che ti mostrerò tra un secondo
ma ha preso questo come prova per il
gestione del progetto che sembrava okay
e dove sono stati rilasciati tre
c’è una tendenza inquietante qui perché
molto spesso nel mondo del software il raw
i valori delle metriche non sono quello
significativo perché tu
un metodo che ha una carnagione di ciclamino
di 12 era quello buono o cattivo bene io no
sapere che dipende da che è essenziale o
complessità accidentale che lo sta facendo
così in alto, ma le tendenze sono spesso molto
interessante perché se ora è 12 e
poi due mesi dopo sono le 20 e poi
tre mesi dopo è 35 chiaramente
qualcosa sta andando nella direzione sbagliata
e questo è esattamente ciò che ha valutato qui
il tipo di tendenza sembrava disturbante
ma devi chiederti così cosa è
l’impatto e se non ci importava
a tale proposito che cosa facciamo lasciamo questa corsa
dilagante e lasciare che questa linea di tendenza mantenere
salendo sulla luna ciò che alla fine è
sarà il lato negativo di questo
beh, il rovescio della medaglia è che tu sei
aggiungendo più cose lì dentro
non dovrebbe essere lì in termini di tecnici
debito che significa che tutti
la velocità rallenterà solo a
un po ‘perché ora il debito tecnico
significa letteralmente cose nel tuo codice
non dovrebbe essere lì che sono compromessi
per quello che dovrebbe essere lì così quando
arriva il momento di aggiungere altre nuove funzionalità
dopo devi tornare indietro e rifare
fuori perché questa cosa strana è lì e
quindi costruisci questo compromesso
spesso costruendo un altro
compromesso intorno a questo e quindi è come
hai un giardino dove hai le erbacce
crescere e diventa molto difficile
trova le verdure per tutte le erbacce
nel tempo quindi l’impatto a lungo termine di
il debito tecnico non affrontato è quello
la velocità di tutti diventa un po ‘
più lentamente col tempo, alcuni di voi potrebbero
ho visto questo manifest nella tua azienda
dove cambia che due o tre anni
ci vorrebbero due o tre giorni ora
ci vogliono diverse settimane perché tu abbia così
molto debito tecnico costruito e di fatto
questo diventa la base per un buon risultato
argomento per dire che sai cosa non è un
cattiva idea in particolare nel codice base che
sono stati in giro per un po ‘
inevitabilmente maturano debiti tecnici n
importa quanto sei stato attento
progettandoli perché sconosciuti sconosciuti
manifestare sempre avendo un dedicato
risorsa una coppia di sviluppatori rotanti
per esempio che non fanno altro che andare e
uccidere il debito tecnico è una cosa utile
perché se hanno successo loro
aumentare la velocità di tutti solo a
un po ‘così il loro impatto è maggiore
rispetto all’impatto di sole due persone
toccare il codice perché si sta schiarendo
via sottobosco in modo che altre persone possano
essere efficace nello scrivere il codice e quello
è stato abbastanza convincente da dire okay
dobbiamo fare alcuni esercizi di refactoring
e che fondamentalmente era 300 e 3.1 con
gli sforzi per uccidere un po ‘ di quello
debito tecnico questo è un buon esempio di
questa idea che la dimostrazione di Trump
discussione che mostra fatti concreti molto spesso
fa una discussione che puoi almeno
ottenere un margine di manovra per provare alcune risorse
assegnazione o per ottenere un po ‘di tempo o
qualcosa del genere ora la persona che
prodotto questo è stato molto laborioso
tipo di processo creato a mano e puoi
spesso ottenere tipi simili di ricchi
visualizzazioni da strumenti come nel
Il sonar del mondo Java è questo freeware
strumento di misurazione che ti dà un sacco e
molte visualizzazioni incluso
complessità ciclomatica praticamente ogni
il linguaggio strutturato nel mondo ha a
strumenti di complessità ciclomatica che puoi
ottenere e scoprire, quindi è una bella
metrica utile e parlerò
un altro in un po ‘chiamato uno dei
un paio di parametri quindi quelli sono entrambi
cose che rendono difficile il design emergente
parliamo di alcune cose che rendono
è più facile alcuni acceleratori per emergenti
design e uno dei miei preferiti
acceleratori per il design emergente è il
utilizzo di test unitari e test-driven
lo sviluppo come un modo di guidare meglio
design creando meno complessità con
eliminando ipotesi errate che
strisciare molto presto e sono molto
difficile da individuare dopo il fatto, ma è
molto facile per me dire questo, ma io
volevo illustrare questa idea, quindi cosa io
Volevo fare è creare un molto
semplice piccolo problema e risolverlo in
in due modi diversi, voglio risolverlo
prima facendo test dopo aver appena scritto
il codice e quindi scrivere test per questo e
allora ho intenzione di guidare la soluzione
utilizzando lo sviluppo basato su test e vedere
qual è la differenza nel design di
quei due pezzi di codice sono e ho scelto
per questo il mio piccolo problema preferito
c’è un piccolo problema molto semplice
che ha un po ‘di carne per questo
c’è questa cosa antica che il
gli antichi Greci scoperti per primi è questo
la cosa chiamata numero perfetto è a
numero in cui la somma dei fattori
è uguale al numero se non includi
il numero stesso così sei per esempio è
un
numero perché i suoi fattori sono 1 2 e 3
e se aggiungi 1 + 2 + 3 è uguale a 6
28 è anche un numero perfetto se vuoi
per sommare un fattore e aggiungere i numeri
in alto puoi verificare che sia in effetti a
numero perfetto quindi è quello che voglio
fare è scrivere un codice che determina
numeri perfetti e così farò questo in
Java ed ecco il mio primo passaggio un test
dopo la versione di questo codice e così via
Farò è entrare e dire ok bene
So che un 1 e il numero sono
sempre parte dei fattori un numero e
ora passerò da 2 fino al numero e
se I numero mod I è uguale a 0, questo è il
operatore mod in Java, quindi se dovessi entrare
numero con un resto ancora, quindi è
uno dei fattori che aggiungi l’elenco di
fattori li riassumi e poi tu
decidere se è perfetto o no e io
ha scritto test per questo e funziona ma
è veramente lento come un matto lento e così
Pensavo che ci fosse un po ‘
così c’è un po ‘di eleganza qui così
c’è un modo ho potuto ottimizzare questo
risulta che puoi facilmente ottimizzare questo
pezzo giusto qui, rendendo il
osservazione che i fattori arrivano sempre
coppie quindi il tuo numero di destinazione è 28 quando
tu prendi 2 puoi anche prendere 14 perché
2 volte 14 è 28 e quindi puoi prendere
vantaggio di questo fatto dicendo bene
Raccogliamoli a coppie e quello
significa che non devo andare fino in fondo
al numero se sto raccogliendo in coppia
Potrei essere molto più intelligente e andare
per esempio alla metà del numero ma io
non potrebbe essere ancora più intelligente di così
e basta andare fino alla radice quadrata del
numero perché per definizione è il
numero di volte stesso che è uguale al mio
numero di destinazione se afferro tutti quelli
sotto e tutti quelli sopra li ho
tutto e questo è esattamente quello che faccio io
cambiato il mio codice per andare solo fino al
radice quadrata del numero che raccolgo
a coppie ma rompe una delle mie unità
test ho un caso limite per intero
numero di radici quadrate quindi pensaci
16 per esempio quando afferro quattro sono
ne prenderò 4 e poi lo afferro ‘
due volte quindi ho finito per aggiungere 4 due volte per a
numero intero radice quadrata ma è facile
abbastanza da sistemare
Conosco quel caso limite quindi mi limiterò a mettere un
condizione di piccola guardia qui che dice se
questa non è una radice quadrata simmetrica
quindi aggiungilo alla mia lista e questo ora
funziona ed è considerato abbastanza veloce da
considera ok è fatto così che è il test
dopo la versione hai visto l’algoritmo
per
non passerò attraverso i test
versione la versione test-driven in realtà
ha un sacco di metodi molto piccoli che è
molto caratteristico delle basi di codice TDD
perché l’atto di fare TDD stesso
ti incoraggia verso metodi molto piccoli
che sono testabili il tuo obiettivo è il
il metodo più piccolo che posso testare e realizzare
lavoro infatti dato il parametro che io
ti ho mostrato prima che diventerò una specie di a
pronuncia audace qui e se lo farai
mostrami una metrica sulla tua base di codice
Ti dirò se è un codice TDD corretto
base o no perché nella mia esperienza
le basi di codice TDD buone hanno tipicamente a
complessità ciclomatica per metodo tra
1.5 e 2 e non basi di codice TDD è
generalmente tra 8 e 15 così è
spesso un ordine di grandezza più alto per
funzione in termini di complessità in non
Il codice TDD si basa perché non c’è
forza esterna che cerca di costringerti a
mantienili semplici e tendono ad espandersi
da soli di propria volontà e
questo significa anche che le basi del codice TDD tendono
avere una forma particolare in quei lotti
di metodi molto piccoli che si nutrono di
metodi di aggregazione più ampi ma lungo il
modo di farlo ho scoperto qualcosa
interessante perché nella mia prova dopo
versione che ho mantenuto i fattori come
una lista di numeri ma fa l’ordine
conta davvero quando sto collezionando
i fattori risultano non è l’ordine
irrilevante nei fattori è un insieme di
numeri non una lista di numeri e io
l’ ho scoperto da uno dei miei piccoli
prova le rotture che dicevano che ero
aspettandomi uno due tre e sei, ma io
ho ottenuto uno sei due e tre e mi ha fatto
rendersi conto che l’ordine non conta qui
Dovrei usare set e non list ma
poi torni alle due versioni mie
codice nel test dopo la versione il mio codice
che questo ha davvero qualcosa da fare
con radici quadrate di numeri interi
risulta che non ha dovuto fare il
fatto che ho scelto i dati sbagliati
struttura inizialmente ho scelto un ordinato
struttura dei dati come a loro un non ordinato
uno e quando ho avuto quel test di rottura in
un mondo perfetto sarei tornato indietro
e rivalutato tutte le mie decisioni tutto il
ritorno all’inizio del tempo per vedere
dove giace l’errore ma non lo fai mai
soprattutto quando puoi vedere un facile
cerotto e questo è esattamente quello che ho fatto
è stato applicato questo semplice cerotto e così via
quello che ho fatto è stato scegliere l’errato
struttura dei dati inizialmente ho aggiunto
complessità accidentale e il modo in cui io
risolto era aggiungere ancora più accidentale
complessità perché molto spesso questo è il
modo in cui finisci per aggiustare un pezzo di
la complessità accidentale sta creando un
compensazione di un pezzo di accidentale
complessità piuttosto che rimuovere il
fonte originale del problema molto
spesso TDD ti porta all’originale
fonte perché ti costringe a controllare il tuo
ipotesi al livello del metodo non al
l’intero livello dell’algoritmo e ottiene
pericoloso se stai provando a controllare le cose
a livello molto grossolana perché
non saresti mai costretto a tornare indietro e
che le tue decisioni sono davvero molto
livello granulare e molte volte poco
la complessità accidentale può insinuarsi
per questo è un buon esempio di
il tipo di tecnica di progettazione emergente su
un progetto greenfield in cui stai andando
TDD e puoi usarlo come aiuto per
fare design ma parliamo di
rovescio della medaglia che è un tipo di
progetto brownfield e refactoring
verso il design questo è un piccolo frammento
di codice che viene da questo piccolo giocattolo
sito di e-commerce da cui prende le cose
carrelli della spesa e metterli in ordine
e mi piacerebbe vedere se c’è
qualcosa di interessante qui ma non posso
Dillo perché è solo una brutta pila gigante
di codice e non posso se non riesco a leggerlo
quindi non posso tirare fuori niente di utile
così prima che potessi davvero fare qualsiasi cosa
utile con questo ho bisogno di fare un po ‘
refactoring su di esso per farlo organizzare
che posso vedere cosa sta realmente succedendo
qui quindi farò una corsa di refactoring
su questo e notare che un gruppo di questi
dichiarazioni come queste tre o quattro
le affermazioni qui sono davvero tutte intorno
sorta di installazione di impianti idraulici per il
roba transazionale quindi sto solo andando
tipo di prenderli nel mio IDE e dire
Metodo estratto lo farò per diversi
di questi ragazzi che stanno tipo di correlate a
l’un l’ altro e arriva a questo intermedio
lo stato qui è solo leggermente migliore ma
Posso fare molto meglio ma notare uno strano
cosa è successo qui perché io ho
queste variabili locali hanno definito qui il mio
lo strumento di refactoring è molto specifico
contratto con me che garantisce che
una volta finito il mio codice sarà ancora
funziona esattamente allo stesso modo
fatto prima e se ho variabili locali
come questo e sto estraendo il metodo
l’unica cosa che può fare è passarli come
parametri e così tante volte ci provi
estrarre il metodo in uno di questi
funzioni complesse come questa o metodi
così finisci con questi giganti
i parametri numerici vengono passati in giro
perché questa è l’unica opzione in realtà
ha
per fortuna tu come umano capisci
le implicazioni di spostare le cose in a
portata di livello di classe rispetto a un ambito locale
e threading e visibilità e tutto
quella roba e io sono un umano quello
capisce che così farò
un’altra corsa di refactoring consolida a
un sacco di queste cose e luoghi condivisi
e finisco qui è esattamente lo stesso
codice e la motivazione per questo stile
di refactoring proviene da una specie di
luogo interessante dal libro piccolo
parli degli schemi delle migliori pratiche di Kent Beck
perché chiama questo tipo di codice
metodo composto l’idea in composto
il metodo è che ogni metodo pubblico legge
come un contorno di tutte le cose che
lo fa e quegli elementi di contorno sono
i metodi privati che ottengono quel lavoro
fatto e notare che è un particolare
potente tipo di modello per il moderno
idee perché tutti i moderni IDE
i nomi delle funzioni o dei metodi diventano
collegamenti ipertestuali quando si tiene premuto il tasto
tasto di controllo in modo da poter letteralmente navigare
il tuo codice se inizi con un pubblico
Metodo di alto livello e forare il
metodi individuali per vedere i loro dettagli
se vuoi ma non sei obbligato a farlo
trattare con i loro dettagli tutto il tempo e
ora che l’ho capito, è stato ridotto a
questo stato molto semplice è banale
guarda cosa succede e in effetti se io
abbattere queste due linee molto specifiche
di codice qui quindi ho il tipo di
modello per fare un dati transazionali
piccola struttura cosa che farò
estrai in un secondo mentre parlo di cosa
fare con queste cose come hai fatto tu
li ho scoperti ma prima che lo faccia io
voglio fare un altro esercizio di refactoring
e per questo ho bisogno di un’altra metrica
ha parlato di una complessità ciclomatica
prima di ora voglio parlare di afferente
accoppiando questo è al disaccoppiamento
accoppiamento famigliare afferente del numero
di connessioni in entrata a un particolare
artefatto o fibbia o pacchetto e così via
in questo particolare scenario questo ragazzo ha
un accoppiamento afferente di 6 il rovescio della medaglia
metrico a questo è l’accoppiamento efferente
che è il numero di uscite
connessioni e il modo di ricordare questo
è che efferente inizia con una e che
è anche la prima lettera della parola
uscita e quelle sono le chiamate in uscita
mentre afferenti sono le chiamate in arrivo
e così in molti modi se guardi a
la classe per esempio è diversa
l’accoppiamento è una misura importante
a causa di molte altre classi lo usano
è probabilmente abbastanza importante quindi ora io
ho due armi che ho una metrica
posso dirmi cose complicate e io
avere una metrica e dimmi importante
le cose andiamo a cercare complicate
cose importanti perché suona
come una buona cosa trovare così ciò che io
volevo fare è prendere un codice esistente
base e vedere se potrei usare alcuni di
queste metriche vanno bene non raccolte
schemi idiomatici che sono in agguato
in giro per molto tempo, ma ho voluto
essere una base di codice disponibile pubblicamente così
che le persone potessero riprodurre ciò di cui ho bisogno
essere in giro per un po ‘e usare per a
molte cose quindi ho scelto molto bene le montature
è stato ben noto framework web
in giro per più di un decennio è dentro
la sua seconda major release letteralmente
migliaia di applicazioni web incluso
siti Web di forza industriale sono stati
costruito sopra questo ed è il mio
contesa che ogni pezzo di software
ha un design poco idiomatico non realizzato
modelli in esso quindi andiamo a vedere se possiamo
trovare qualcosa di interessante i montanti
codebase quindi scaricherò il tratto
strumento di metriche casuali di base del codice su di esso
mi dà i miei due parametri ciclomatici
complessità e accoppiamento afferent il
strumento che ho usato se qualcuno è interessato a questo
piccolo strumento gratuito chiamato C kjm
esegue il chittim ER e l’oggetto kimra né
metrica suite su codice java che è il ck
e C kjm e il modo in cui viene segnalato
complessità ciclomatica perché è a
strumento metrico di livello di classe che riporta
complessità ciclomatica per la classe come
la somma della complessità ciclomatica di
tutti i metodi e lo chiama ponderato
la complessità del metodo e qui ci sono i
risultati per i punti di forza e così si trasforma
la componente più complessa del campione
in tutti i montanti è presente questa guida del fascio WI
con un 66 se aggiungi tutto il ciclomatico
complessità di tutti i suoi metodi fino a 66 anni
quindi se stavo solo facendo la complessità
la caccia vorrei andare dopo quel ragazzo e
prova a ucciderlo o a fargli un sacco
più semplice ma quando guardi attraverso
è usato solo da altre tre classi
e così gli sforzi di Herculean qui potrebbero
pulisci molto ma non lo farà
avere un sacco di effetti a catena in altre parti
del mio codice base
ordiniamo invece per importanza
e non sorprendentemente componente è il
il più importante in puntoni essendo un
framework web basato su componenti , ma questo è
nemmeno quello che sto cercando
o quello che sto cercando qui sono
alte combinazioni di membri ricordano
Sto cercando complicato importante
cose e voglio scoprire perché loro
esiste e quello che cattura il mio sguardo
ecco questo ragazzo del raggio UI con una cinquantina
tre e ventidue importanti e
complicato quindi andiamo a vedere perché io così
apro il raggio della UI SS e lo trovo
ragazzo adorabile che valuta i miei param
la parte preferita di questo metodo è di gran lunga
l’ ultima riga del metodo che
è valutare parametri extra è come il
lo sviluppatore si è stancato di digitare a
qualche punto oh dio okay valuta extra
Carrozzine Credo di aver finito così che questo codice
fa struts come una struttura web componente
e a volte fa la magia automatica
cose i parametri URI ea volte
li passa semplicemente attraverso invisibilmente
ea volte le mappature avvengono
quei ragazzi così sono i parametri di valutazione
e valutare i parametri extra ora come ho fatto io
ho iniziato a sbirciare tra le gambe
Ho notato che molti e molti di questi
valutare i parametri per valutare i passeggini extra
metodi che stiamo mostrando e così ho ottenuto
davvero curioso, certo che puoi farlo
in IDE ma l’ho fatto sulla linea di comando con
un po ‘di judo da linea di comando come
sta iniziando il percorso dei montanti dare
me tutti i metodi o mi dai tutto
i file di origine Java e trovare tutto il
quelli che hanno una dichiarazione per
valutare qualcosa di param e qui loro
ho trovato un modello idiomatico
e puntoni e questo è un esempio perfetto
di uno schema idiomatico perché quindici
anni fa, quando ho iniziato a lavorare
non c’è modo in cui hanno detto che lo sai
quello che in 15 anni è il più complicato
parte dei montanti sarà il modo in cui gestiremo
Parametri URI perché è così
problema semplice è così semplice in effetti
hanno reimplementate più e più e
ancora e ancora e ancora nel
codebase senza rendersene conto
manifestando dappertutto così
c’è un epilogo interessante a questo
storia Ho scritto questa analisi e quella
serie di lavoro degli sviluppatori stavo parlando
circa e uno degli sviluppatori di stress
mi ha contattato e ha detto che aveva fine
scoperto la stessa identica cosa
manifest nei codebase di puntoni e lui
era in procinto di risolverlo
estraendo tutto quel parametro uri
maneggiare roba come componente interno
di puntelli quindi se guardi puntoni ora
tu o I parametri sono gestiti da questo
componente interno e facendo ciò lui
buttato giù diverse migliaia di righe di
codice e diverse centinaia di complessità
indica puntoni senza cambiare
la funzionalità dei montanti lui solo
notevolmente semplificato perché nessuno aveva
mai usato quel particolare obiettivo per
illumina quella parte del codice base
è come se questo codice duplicato fosse
correre in giro dappertutto
ma letteralmente non potevi vederlo
perché è in agguato e si nasconde dietro
tutte le altre cose che ci sono così una volta
hai trovato queste cose, cosa fai?
con loro come li catturi e
ci sono un paio di semplici modi per fare
questo semplice modo per farlo è giusto
catturalo come un’API questo è il
il modo più semplice è l’unità di come tu
catturare le cose nel mondo Java così
esempio che ti ho mostrato per questo
unità di lavoro idiomatica questo è il codice
che voglio catturarlo da così dentro
Java Posso entrare molto facilmente qui e
diciamo usiamo un design corretto per la gang a4
schema qui e lo estraeremo
usando lo schema di comando così ora il mio
comanda lassù e questo è ora il mio
metodo che probabilmente vale la pena notare
l’intera diapositiva piena di codice che io
ti ho mostrato prima di questo perché non l’hai fatto
quell’essere è questo un metodo proprio qui
dopo tutto ciò che aveva la roba utile riutilizzabile
stato risucchiato fuori di esso, una volta abbiamo determinato
in cosa consistevano le utili cose riutilizzabili
Infatti se guardi questo questo piccolo
la cosa della transazione rapida sembra molto simile
Le molle fanno nel wrapper transazionale che
fondamentalmente molte delle stesse cose
Java forza una discreta quantità di sintassi
rumore su di te perché davvero tutto ciò che vuoi
fare è questo avvolgere questa roba in a
transazione e lingue di livello superiore
ordinare funzioni come groovy e di
Ovviamente Java 8 lo faremo a
molto più pulito e semplice perché si ottiene
sbarazzarsi della classe middleman che è solo
lì come detentore per quell’esecuzione
metodo e così ad esempio in groovy if
hai scritto esattamente la stessa cosa che sarebbe stata
molto più pulito perché questo qualcosa
parentesi graffe in groovy è un blocco di codice
e questo viene passato qui e quello è
zucchero sintattico
la stessa identica cosa che puoi fare in a
lingua delle funzioni di ordine superiore e
in modo che in realtà pulisce molto
e questo risulta essere un bel
cosa importante
la pulizia sintattica è davvero
importante perché il tuo codice è tuo
documento di design e quindi design e
la leggibilità è strettamente intrecciata
l’uno con l’altro sulla base di quello che Jack
Reeves stava dicendo che la leggibilità fa un
grande differenza nell’altro modo in cui puoi
raccogliere questi ragazzi in lingue come
Java usa annotazioni che non penso
la gente usa questo abbastanza questo è
in realtà un meccanismo molto potente in
Java perché aggiunge un livello extra di
espressività alla lingua che tu
normalmente non ce l’ ho è stato davvero bello
cosa da avere ma non ne spenderò più
tempo in cui molte strutture usano
questo ma non molti usano gli sviluppatori
questo meccanismo e non è adatto per
tutto ovviamente, ma la cosa bella
è che le annotazioni vivono molto vicino a
la cosa che stai cercando di modificare
e quindi c’è un bel tipo di località
alle modifiche che stai facendo lasciare
io parlo solo di un secondo sull’astrazione
stili perché ho citato il
f-word la parola di programmazione funzionale
qui come ho detto Landers siamo tutti
interessati sono tutti in anteprima con
linguaggi di programmazione imperativi
strutturato e modulare e
orientati agli oggetti sono tutti in stili
e periodo di stili di astrazione, ma tu
ascolta molto sulla programmazione funzionale
in questi giorni capisco che anche se lo è
davvero solo una diversa gamma di strumenti
è letteralmente una cassetta degli attrezzi diversa e
nessuno dei due è particolarmente adatto a
risolvere ogni problema meglio del
altro ma un sacco di volte l’uso di uno è
più adatto a un particolare tipo di
problema perché corrisponde all’essenziale
la complessità è migliore di un’altra e
finiamo per essere presi molto in
tipo di paradigma di fondo nel
il linguaggio supporta perché è il
modo predefinito in cui le cose funzionano ma tu
non c’è bisogno di farsi prendere in questo e
un grande esempio di questo è questo concetto
di un oggetto anti che proviene da a
carta che è stata consegnata a Uppsala in
2006, credo chiamato collaborativo
diffusione e hanno creato questo
concetto di un oggetto anti nella loro carta
Dicono che la metafora di Rob è che puoi andare
troppo lontano costringendoci a creare oggetti
molto ispirato al mondo reale
un oggetto anti è tipo di oggetto quello
fa il contrario di ciò che pensi
dovrebbe fare come un modo di modellare
qualcosa che è più semplice un po ‘come
questa illusione ottica è questa di a
fonte in due fasi e il classico
arriva un esempio di approccio anti oggetto
a noi in forma di pac-uomo ora ho
per avvisarti che sto per spiegare come
pac-man funziona se vuoi mantenere
giocando a pac-man e goditelo, dovresti
vattene ora e capirò
a volte la conoscenza ha un costo e
il costo per questo è che non lo farai
godi pac-man abbastanza perché lo sono
Spiegherò l’algoritmo a te quando
pensi al gioco della console pac-man
che è uscito nei primi anni ’80 loro
aveva meno memoria e potenza di elaborazione
di quello che la maggior parte degli orologi ha ora e loro avevano
un problema davvero difficile risolvere è come facciamo a
calcolare la distanza tra due
gli oggetti in movimento in un labirinto non l’hanno fatto
avere ovunque un’elaborazione quasi sufficiente
potere di farlo
quindi hanno adottato un approccio anti oggetto
questo piuttosto che costruire l’intelligenza in
va al singolo pac-man
ecc. hanno costruito tutte le informazioni
il labirinto il labirinto è fondamentalmente uno stato
macchina che per ogni cella viene eseguita
regole per ogni volta durante il gioco
ciclo e hanno inventato questo concetto di
odore di pac-uomo e quando è pac-man
seduto su una cella ha il pac-man massimo
odore e la cella che ha appena lasciato
ha il massimo odore di pac-uomo meno 1 e it
decade molto rapidamente e tutti i fantasmi
fare è vagare in giro in modo casuale fino a quando
incontrano l’odore di pac-uomo a cui vanno
il prossimo argento adiacente più forte e
si muovono leggermente più velocemente di pac-man
e questo è l’intero gioco pseudo-casuale
i numeri e l’odore di pac-uomo e hanno fatto a
cosa davvero subdolo per te perché il
i fantasmi hanno dato loro occhi ma loro
dovrebbe solo dargli un naso
perché non possono vedere voi a venire
può correre su di loro e loro non possono
ci vediamo ma possono sentire l’odore di dove sei
stato
quindi i fantasmi hanno davvero bisogno di nasi giganti
ma senza occhi ma ti hanno ingannato
mettendo gli occhi su di loro ma ora il prossimo
volta che si gioca a Pac-Man si può correre a destra
su un fantasma ea meno che non lo faccia
si gira casualmente verso di te, non lo fa
sai che sei lì perché possono solo
segui questo è un grande esempio di
prendendo un progetto che era troppo complicato
costruire e gli strumenti che avevano al
tempo e venire con un modo di
sfogliando l’abstract
all’indietro e essere in grado di costruire
qualcosa e quando miss pac-man è uscito
hanno mantenuto lo stesso algoritmo proprio loro
ha reso il generatore di numeri casuali migliore
quindi un sacco di questo è in questo posto di
ricerca e raccolta idiomatica
schemi ma voglio tornare per a
secondo all’ultimo momento responsabile e
parla di come lo determini
punto di flesso quindi se si guarda
complessità nel tempo sul progetto che guardi
a particolari componenti come parte del tuo
lo stack architettonico che noterai
che nel tempo assumono variazioni
gradi di responsabilità e se quelli
punti di flesso dove stanno prendendo
su più responsabilità o sul serio
cambia a loro quella è la volta che leggi
e dire che hai davvero raggiunto il tuo
ultimo momento responsabile e quindi questo
in realtà va verso uno dei
caratteristiche di Architects su agile
i progetti hanno bisogno di molto di più
consapevolezza del tipo di eventi attuali di
cosa sta succedendo nel codice perché loro
bisogno di essere in grado di fare questo tipo di
le determinazioni abbiamo raggiunto l’ultimo
momento responsabile ha questa componente
ha iniziato ad assumerne troppi
responsabilità di cui siamo anche grandi fan
facendo picchi che sono sperimentali
esercizi di codifica per determinare di liberarsi
di incertezza per cose come le stime
ce n’è un altro davvero famoso
anti-modello chiamato il dammi
stima ora anti-pattern e il modo
questo modello si manifesta è che qualcuno
ti ha chiesto di stimare qualcosa e tu
non ne so nulla come dire
me quanto ci vorrà
geocoding questa applicazione e il
la cosa veramente pericolosa qui è indovinare
perché mi danno delle stime ora
anti-modello dice che non appena
i numeri escono dalla tua bocca che hai
inavvertitamente entrò in una corazza
contratto che si rischia la vita per
rendere tale data avverata, non importa come
molte parole cialda ti mettono di fronte ad essa
i picchi ti permettono di allontanarti da quello
perché ora puoi guardare e
determinare e sbarazzarsi di alcuni dei
incertezza che sta portando al
speculazione su quanto durerà
prendi questo per riassumere
ovviamente architettura evolutiva e
la progettazione emergente richiede una buona ingegneria
pratica se hai un buon codice TDD
base su cui puoi fare il refactoring
è molto più facile fare questi esercizi
non ti preclude dal farli
certamente lo rende molto più facile se
hai già una buona ingegneria
pratica il
la più avanzata pratica ingegneristica
quale l’ architettura e il design spaziano
diventa più facile cercare di prevedere il
il futuro porta all’ingegneria che
è una brutta cosa e questo sta per essere un
sottile distinzione ma penso davvero
importante perché nel mondo agile
stiamo cercando di preferire essere professionisti e
reattivo al predittivo non stiamo provando
per predire il futuro quello che stiamo provando
fare è essere proattivi di cose che
so che succederà in futuro
e quindi essere immediatamente reattivo come
le cose accadono nel nostro codice base che noi
bisogno di essere in grado di rispondere al
combinazione di Pro e reattivo penso
funziona molto meglio di cercare di ottenere
sempre meglio a predittivo perché
come dirà ogni angolo della strada psichico
stai cercando di migliorare
predire il futuro è davvero davvero
difficile da fare, sono fuori dal tempo e non lo faccio
vogliono tagliare a pranzo perché so
questo è un argomento molto importante per l’ agenda
molti di voi sarò qui per il resto
settimana se avete domande o
qualcosa di simile, grazie molto per
in arrivo spero che ti sia piaciuto
Please follow and like us: