quindi ho intenzione di parlare di funzioni e
programmazione reattiva oggi ma mai
usando la parola monad così l’intenzione sarà
essere di attenersi alla pratica di
funzionale in stile funzionale
programmazione e programmazione reattiva o
asincrono e quindi sostanzialmente alla fine
di questo voglio che tu sia in grado di
capire l’ approccio che abbiamo preso
comporre funzioni in modo reattivo
modo e ciò significa che sei tu
può prendere un flusso di dati trasformarlo
dall’uno all’altro come è a
che scorre in modo sincrono attraverso un sistema
ma più interessante che puoi
iniziare a combinarlo insieme e di nuovo
fai tutto in modo reattivo e
c’è un sacco di dibattiti su cosa
dovremmo chiedere questo abbiamo iniziato
usando reattivo funzionale per nominarlo
prima che nessuno di noi avesse davvero qualche idea
riguardo l’accademia dietro di esso e io sono
pienamente consapevole di FRP e Connell Elliott
e Fran e quelle cose se qualcuno può
dammi un nome migliore per quello che siamo
facendo qui oggi mi piacerebbe sentirlo ma
gli aspetti funzionali sono sei tu
andando a vedere un sacco di chiusure lambda
le funzioni saranno per lo più
pura l’ unica parte in cui non lo sono
il puro è in genere la fine stessa
simile alla monade i / o in Haskell e
li vedrai come componibili
e il lato reattivo di cosa si tratta
riferendosi a è che è tutto asincrona che
hai valori ed eventi sono in corso
spinto attraverso il sistema e tu sei
reagendo ad esso mentre fluiscono quando
abbiamo iniziato a lavorare su ciò che volevamo
scegliere come target un ambiente poliglotta e noi
mirato alla JVM nel suo insieme, non a nessuno
particolare linguaggio a Netflix è
principalmente ancora il linguaggio Java con
un bel po ‘di groovy e una discreta quantità
di Scala ci sono frammenti di
chiusura mostrando e stiamo cercando
avanti a ciò che Java porterà otto come
bene sta andando a cambiare in modo significativo
in che modo viene usato quel linguaggio in particolare
come abbiamo adottato i principi funzionali
la maggior parte degli esempi che ho intenzione di dare
oggi sono mostrati in groovy con pochi e
Java otto ma ce ne sono molti
esempi di questi
noi siamo e il lato Scalla è davvero dentro
le ultime sei settimane sono drammaticamente
migliorato come la comunità dei typesafe
ottenuto coinvolto nel lavoro sul Scilla
adattatori per renderli molto idiomatici
Scalla stessa così che cosa è rx Java loro
è una libreria che abbiamo implementato come
la porta non è una porta diretta ma stiamo provando
per essere abbastanza fedele alla rete RX
versione di rx che è stata costruita in
Microsoft e c’è anche un JavaScript
implementazione rxjs e così sei
iniziando a vedere la RX e poi a
nome della lingua
si presenta in varie lingue PHP è
ottenendo uno ce n’è uno per il cacao
non si sono attenuti alla convenzione
anche se hanno abbattuto, c’è reattività
il cacao e quello che è è fondamentalmente
i principi di un asincrono
osservabile con molto ordine
funziona su di esso e così sto andando
per iniziare a farlo prima di noi
arrivare e voglio darti un contesto
è per questo motivo Netflix ha finito per andare giù
questo percorso così Netflix è una TV e un film
società e siamo attualmente in oltre 50
paesi e territori con oltre 37
milioni di clienti in Nord America noi
avere un impatto piuttosto grande sull’ultimo
miglio a valle consumo di Internet e
oltre un miliardo di ore di video sono
consumato ogni mese la crescita delle API e
questa è la squadra su cui ho lavorato
come quello negli ultimi anni e
l’API è che si può pensare ad esso come solo
come qualsiasi altra API è la facciata
parte superiore dell’architettura orientata ai servizi
internamente a Netflix, che è molto
macchine e quella facciata è fondamentalmente
lì per fornire l’accesso a tutti i
funzionalità ai mille plus
diversi dispositivi che possono accederci e
Rx è stato scoperto quando eravamo come eravamo
andando su quella curva di crescita e come il
il numero di dispositivi che ci accedono è aumentato
iniziamo a correre nei limiti di cosa
la nostra aqua riposante stava facendo abbiamo avuto un
tipica api riposante era tipica come
puoi aspettarti
di uno stack Java stava usando Russell
e le annotazioni e tutte le imperative
ed erano chiamate API molto dettagliate
e i dispositivi con cui ognuno ha interagito
loro ma quello che voleva dire è che lo era
ottimizzato per nessuno
era generico e avevi dispositivi in quel modo
dovrebbe fare 12 chiamate di rete a
rendere una esperienza utente e il
pazzia degli argomenti che eravamo
iniziando a passare in questi servizi web
chiama per provare e personalizzare i dati che
veniva consegnato per utente diverso
le esperienze stavano sfuggendo di mano
e quindi volevamo essere in grado di prendere questo
tipo di esperienza e ridurlo a
una singola chiamata di rete per un singolo utente
sperimentare e spingere tutto il the
chiamate di rete dalla vittoria alla LAN
all’interno del nostro data center a cui capita
essere tutti nei servizi Amazon AWS e
sfruttare la bassa latenza della rete
la comunicazione di quello strato riduce tutto
la replica dello sforzo su ogni
rete che autentica il recupero dell’utente
metadata quelle cose ed essere in grado di
sfruttare la concorrenza di gran lunga migliore
caratteristiche dei server sopra il
piccoli dispositivi che supportiamo un iPhone
o un iPad o qualcosa del genere è un
dispositivo incredibilmente potente rispetto a
l’ampia portata dei dispositivi che noi
target $ 40 di silicio seduto su un set-top
box è un’esperienza molto diversa in a
portatile o un telefono moderno e così via
logica condizionale annidata doveva essere tutto
fatto parallelamente esecuzione parallela
altrimenti avremmo fatto un passo
all’indietro da dove eravamo prima
dove almeno avevamo l’implicito
concorrenza che stava accadendo attraverso
tutte le più chiamate di rete la maggior parte di
i client HTTP dai dispositivi potrebbero a
almeno sai sostenere come per
chiamate in rete in parallelo e noi
necessario almeno per essere così buono, ma noi
voleva anche permettere a chiunque di creare
questi endpoint non sono solo il team API
perché se fosse solo quella squadra noi
sarebbe un collo di bottiglia per la creazione di questi
endpoint personalizzate in modo che volevamo
consentire ciascuno dei diversi team di dispositivi
per costruire i propri servizi web che vogliamo
essere poliglotta per supportare il diverso
lingue che i team potrebbero voler utilizzare
e volevamo risolvere la concorrenza
problema senza che tutti debbano leggere
questo libro più e più volte che amo
questo libro è un grande libro che ho letto
più volte ma il punto era questo
non volevamo che fosse il
prerequisito per le persone in grado di
costruire con successo altamente concomitante
sistemi su Netflix e quindi cosa
significato per noi è che il proprietario del
API doveva mantenere il controllo del
comportamento concorrente chiunque fosse
esponendo quella facciata dovevamo essere in grado
mantenere il controllo di questo stava facendo
blocco o non blocco delle chiamate di rete
stava recuperando qualcosa dalla memoria
e sincronicamente sparagli colpendolo con a
conosci la ricerca al microsecondo o era questo
qualcosa che prenderà decine o
centinaia di millisecondi, quindi stiamo andando
per averlo in una discussione o un non-blocco
I / o evento dovevamo mantenere il controllo di
quelle cose e cosa significava per noi
è la nostra API se avessimo un metodo
firma come quella tutto ad un tratto questo
stava cuocendo nel contratto del nostro
livello di servizio un sacco di decisioni che
ha impedito la nostra capacità di apportare cambiamenti e
anche per i clienti che consumano i dati
E se ad un certo punto che era o
una chiamata di rete molto veloce che noi
preteso di fidarsi o era qualcosa
stavamo recuperando un ricordo che doveva
cambia tutto ad un tratto non abbiamo scelta
ma per rompere la firma per farlo
restituire qualcosa in modo asincrono anche se
il cliente vuole davvero essere in grado di
dare il via a due di queste cose
contemporaneamente perché sanno che loro
dovrebbe essere quello che stiamo andando a farli
facciamo davvero li vogliamo fare
decisioni come i thread di generazione e il
la risposta è stata molto No
e così molto rapidamente siamo andati giù
percorso di dare un’occhiata a bene ovviamente
potremmo iniziare a mettere callback in noi
potrebbe restituire le cose come futuri e se noi
avere elenchi di cose hanno un futuro
con una lista di futuri e inizia a
disordinato ma questo è dove eravamo
cominciando ad essere e fortunatamente abbiamo un
miscela molto varia di ingegneri e
programmazione di lingue e sfondi
e Netflix e quindi c’era
gente là che, come ho interagito con
loro sono stato in grado di essere istruito sul
i concetti di rx che Eric Meyer aveva
inventato in Microsoft attraverso un
ingegnere il
stato a Microsoft e vieni a
Netflix e gli ci è voluto un po ‘per arrivare
attraverso il mio grosso cranio di java e prendimi
pensare in questo modo e anche 15 anni di
programmazione imperativa non ero ancora
pensando che quella inversione di pensiero
a muoversi nel mondo funzionale,
mi ha preso un po ‘di tempo ma oltre
il mese o due durante quello
fase di scoperta i concetti di rx
iniziare a diventare più chiaro come molto puro
teoria su come fare asincrono
programmazione e finisce per essere molto
semplice miglioramento della Gang of Four
modello di osservatore per spostarlo da un
imperativo mondo sincrono in a
dichiarativo mondo asincrono e così via
finisce per essere un doppio di iterable quindi se
hai mai sentito Eric Meyer parlarne
parlerà della dualità e può farlo
guidarti attraverso tutta la teoria delle categorie
e la matematica alla base di questo io saltare
tutto ciò perché onestamente non lo faccio nemmeno
capisci tutto ancora ma ovunque
che avresti un iterabile che è
spingerlo dove si estrae i dati da esso
ora puoi avere un osservabile e spingere
dati in basso e puoi lavorarci dentro
allo stesso modo le due aggiunte ad esso ora
sono così avanti su un intervallo è il prossimo
con un osservabile e poi perché lo è
tutto asincrono ora hai bisogno di due cose nuove
dillo allo stato terminale in modo che il
lo stato terminale è che stanno per
essere tutto completato con successo, quindi è così
dicendoti che non ti aspetti di riceverne
nuovi eventi emessi o un errore
evento che è il terminale lo dichiara
dice che non stai andando a ricevere qualsiasi nuovo
eventi ma ci siamo conclusi con questa eccezione
in realtà è un gettabile e quindi se tu
guarda un iterable con ordine più alto
funzioni ad esso applicate come
fondamentalmente tutte le lingue jvm che
sono stati costruiti negli ultimi anni
avere e poi di recente con Java otto
interfaccia di streaming che puoi costruire
funzioni di ordine superiore in cima a
iterabile in modo che tu sia un tu
in modo dichiarativo può dirgli come elaborare
i dati bene si può fare esattamente lo stesso
cosa con l’osservabile tranne che è
ora tutto asincrono
e quindi è tutto non-bloccante e il
l’unica differenza tra loro è quella
invece di uno per ciascuno alla fine che
per definizione è un evento di blocco tu
iscriversi ad esso si può anche fare un for
ogni inosservabile se vuoi rompere
nel blocco ma questa dualità
tra di loro ha iniziato a guidarci
verso la decisione su cosa
astrazione vogliamo usare sopra il nostro
dati nel nostro livello di servizio e così abbiamo
questo quadrante di diverse scelte di
come trattare i nostri dati così il primo
e uno più semplice che siamo stati tutti
usando sin dalla prima volta che abbiamo toccato a
la riga di codice è scalare sincrono
valori e lo prendi e quando lo sei
facendo qualche logica condizionale su di te tu
ottenere quel valore e si esegue la logica
su di esso imperativo e sincrono
quando hai più valori che fai
allo stesso modo, tranne che iterate su un
iteratore iterabile in un ciclo e poi tu
condizionatamente fai la tua logica al suo interno
e sto mostrando la pace condizionale
perché è importante nei prossimi passi
ci muoviamo nel voler comportarci
asincrono, futures o promesse
loro sono esistiti per un bel po ‘
tempo e lavoro abbiamo il futuro
ea prima vista sembrano come
sono una soluzione piuttosto buona ma loro
sono viziati in molti modi divertenti una volta
inizi a provare a fare nidificati
logica condizionale la prima cosa qualsiasi
Lo sviluppatore Java fa con il futuro è
loro bloccano loro ottengono il futuro
indietro e poi non appena vogliono
qualcosa con esso loro hanno dereferenziato
il valore al suo interno e quindi il sistema
blocchi e questo è davvero difficile da fare
evita se stai facendo una specie di nidificazione
logica condizionale va bene lo stesso
in modo che i callback siano abbastanza semplici se
hai solo un livello se non lo fai
bisogno di dereferenziarlo fino alla finale
uscita ma se hai bisogno di fare nidificare
logica a un certo punto è necessario
blocca immediatamente su di esso e non bloccare
finisci per avvolgere i fili intorno
fili e diventa davvero triste davvero
veloce ci sono soluzioni migliori però
la biblioteca di guava ci dà futuro
callback così ascolti futuri e così
questo inizia a risolvere quel problema quando
non blocchiamo invece noi asso
abbiamo una richiamata e poi dentro quella
abbiamo gestori di callback dove possiamo
in modo asincrono esegui questa logica
un futuro completabile in java 8 che dà
questo solo con nomi nuovi per tutto
apparentemente non volevano usare nessuno
delle convenzioni dell’industria e
quindi hanno nomi diversi per
tutto ma eseguirli esattamente
allo stesso modo e in modo da poter applicare a
richiamata a una funzione in seguito
chiusura e scusa non chiudendo Scala e
i futures di akka sono molto eleganti
futuri composibili che hanno
in realtà ottenere è molto molto vicino a dove
vogliamo essere se non avessi scoperto Rx
probabilmente useremmo questi futuri
e questo dà un futuro molto elegante
dove possiamo quindi mappare la risposta
e trasformalo fare qualunque cosa sia annidata
logica che faremo e ci darà
l’esatta composizione e trasformazione
funzionalità che vogliamo su scalare
Valori comunque se prendiamo quel futuro
e basta passare a un noi osservabile
ottenere lo stesso identico comportamento, ma noi
ora posso lavorare anche sui vettori
risposte scalari e quindi quello che abbiamo trovato è
che il meglio delle implementazioni di
il futuro e l’osservabile ci danno
astrazioni simili ma osservabili
era un passo avanti nell’astrazione
e quindi per semplificare il nostro ambiente
ho scelto di adottare osservabile attraverso
la scheda per la gestione asincrona
programmazione perché ci permette di
raggiungere queste funzioni di ordine superiore per
trasformazione e composizione su entrambi
vettori e risposte scalari e così via
questo significava per noi in pratica
il livello di implementazione è invece di
l’ API di blocco è ogni altro servizio
strato che vogliamo in giro e cambiarli tutti
alle API osservabili e così via
significa per noi è questa astrazione
ora libera l’ implementazione per dire
forse voglio sinceramente io
so che ho parlato in modo asincrono
tutti insieme con la stessa interfaccia I
potrebbe restituire un valore in modo sincrono ma
lo sviluppatore che sta consumando questo
lo consuma in modo asincrono ma forse
Ho già seduto nella cache
e così ho intenzione di
inviarlo immediatamente senza il
sovraccarico di un filo o ho potuto sostenerlo
con una filettatura separata da una filettatura
pool o posso avere più thread da
un thread tira ognuno omettendo diverso
valori come sono elaborati o potrei
utilizzare un attore o più attori da fare
quel lavoro o potrei fare una chiamata niño
con un ciclo di eventi o potrei essere una coppia
un piano e un attore con un ciclo di eventi se
Non volevo che i miei callback accadessero
i fili del lavoratore e tutti questi
astrazioni tutte queste implementazioni
i dettagli sono astratti da come il
i dati vengono consumati e quindi il codice cliente
tratta tutte le interazioni
in modo asincrono ma il proprietario di quello
quell’API è libera di cambiare il
implementazione tuttavia che desiderano e
sono anche in grado di controllare se
sta bloccando o non bloccando così questo
l’astrazione appare come non bloccante
asincrono e quindi l’ implementazione
il dettaglio può scegliere quali risorse esso
sta usando così ho intenzione di iniziare a ricevere
per programmare ora e per guidarti
esempi di codice e alcuni dei più
comuni funzioni di ordine superiore che si applicano
a questo e così quella cosa in cima a noi
chiama i diagrammi di marmo che sto per
usa molti di quelli nel resto del
presentazione per provare e dare un visual
rappresentazione di come sono i dati
scorre così se non l’hai mai fatto
programmazione funzionale o reattiva
programmare la speranza è che si può
inizia a visualizzare il flusso di dati
attraverso e se si inizia a pensare alla
dati come letteralmente pipe of of data
il fluire insieme e poi questi
le funzioni di ordine superiore sono come il
connettori che hai con i tubi
e quell’immagine visiva può iniziare ad aiutare
tu riconosci fondamentalmente cosa sta succedendo
con i dati mentre scorre attraverso il
sistema e quindi ho intenzione di iniziare
le basi di come crei e
iscriversi agli osservabili quindi a
osservabile è davvero solo una funzione
che può accettare un osservatore e quando lo fa
riceve quell’osservatore che emetterà
via su prossimo bene una volta che hai ottenuto quello
osservatore e si è iscritto a voi possibile
emettere 0 o più eventi tramite il
al prossimo evento e poi hai un
stato terminale di incompleto di successo
o uno stato terminale di errore se c’è
un fallimento e quindi ecco alcuni esempi
questi sono volutamente prolisso in
mostrando da dove proviene la concorrenza
normalmente ci sono modi molto migliori di
introducendo la concorrenza ma io sono
farlo qui per essere esplicito in
dimostrando che è il massimo
osservabile per quanto riguarda dove la fonte
di concorrenza o di esecuzione asincrona
viene da e così in questo caso il
la parte interessante è giusta
lì e quello che fa è con questo
osservabile è una funzione che una volta
sottoscritto a prenderà un video
valutazione dell’oggetto oggetto dati su una rete
chiama e poi emettilo e poi completa
quella sequenza osservabile e tu lo farai
notare che in questo caso sono esplicitamente
farlo all’interno di un esecutore Java che
esegue sedersi su qualche thread in background
e tipicamente nel nostro codice di produzione
non farlo così di nuovo voglio solo essere
chiaro che questo è solo per dimostrare
che è pienamente la scelta del
osservabile quindi cosa sta succedendo qui a
esempio sincrono che mostra questo
l’osservabile può essere bloccante e
sincrono se vuole essere e così
questo semplicemente restituisce i dati
e l’ abbonamento bloccherà di fatto
Non consiglio di farlo in genere
ma se hai qualcosa che è in a
cache e ci vuole microsecondo a
prenderlo fuori ed emettono generalmente
in realtà è meglio farlo quindi generare
una minaccia o qualcosa del genere
natura quindi in questo caso siamo in realtà
restituendo più valori e emettiamo
loro e poi completano ecco un
asincrono con più valori
generalmente probabilmente non stai facendo un
chiamata di rete in un ciclo come questo ma se
hai avuto qualche motivo per farlo
in genere hai un po ‘più efficiente
approccio streaming dove è un singolo
chiamata in rete o streaming dei dati
fuori dalla linea ma il più importante
l’implementazione è la prossima cosa
i valori che ricevono e poi tu
completo e quindi questi sono molto banali
esempi della sorgente dei dati
l’osservabile
auto così l’osservatore più semplice ora così noi
flip dal produttore al consumatore
lato è il consumatore ha tre possibili
eventi che può ricevere tipicamente da te
in realtà non ho bisogno di incompleto a
Alla fine è una specie di implicito
in genere e così generalmente sembra
scusa, sto saltando solo accorciando
per mostrare come appare quando sei
non facendo il pieno verboso
implementazione che è quello che sembra
quando usi tipicamente i lambda
non è necessario il completamento e l’errore
gestendo questo è la gestione degli errori solo a
alla fine ho intenzione di entrare in
errore asincrono che gestisce un po ‘
più in dettaglio più tardi è uno dei
maggiori sfide nella programmazione asincrona
tipicamente ma questo è il basic
osservatore che vorresti passare e tu
non sempre è necessario avere l’errore
gestore se non vuoi preoccuparti
loro ma generalmente questo sarebbe dove
sei a, ma tutto quello che abbiamo fatto finora è
basta fare un pub glorificato / sub e
niente di interessante a questo punto dove
diventa interessante è dove iniziamo
avere funzioni componibili e quindi alcune delle
questi tipi di funzioni questa è una lista
di alcuni dei più comuni e io sono
andando a camminare attraverso ora alcuni di
quelli che sono semplicemente fondamentali per
abbastanza bene qualsiasi applicazione, quindi vado
per iniziare con come si combinano più
flussi di dati che utilizzano l’operatore di fusione
quindi ciò che fa l’operatore di unione è
ti permette di prendere due osservabili
sequenze dello stesso tipo e si fondono
loro in una sequenza osservabile
sequenza che ha tutti quelli tutti
eventi combinati e quindi qui abbiamo due
le sequenze ottengono i dati a e B e entrambi
restituire gli stessi oggetti dati alcuni dati
e così queste due linee in alto
rappresentano due sequenze di dati sopra
tempo a cui entrambi stanno emettendo valori
diversi punti di tempo e quello superiore
emette un evento di errore è il terzo
evento lì che X rappresenta un non
errore di chiamata che vuoi prendere questi due
e passali attraverso un operatore di fusione
e che unire operatori è questo è il modo
sembra e che unisce l’operatore al
dall’altra parte quello che vuoi è un singolo
sequenza osservabile che combina questo
uscita e quindi vedrai che
combina i primi quattro eventi e poi
lo stato terminale di errore e quindi
uno
questo stato terminale non si verifica più
gli eventi arriveranno e poi fuori
dall’altra parte hai un singolo
abbonamento che riceve tutti quelli
gli eventi univano un altro comune
uno è con cerniera lampo viene utilizzato quando si è
combinando più sequenze di dati
più osservabili di diversi tipi
quindi qui abbiamo due osservabili di due
diversi tipi di dati alcuni dati e
stringa così la differenza qui è quella
non puoi semplicemente combinarli insieme
e con una supposizione di due loro come
il loro tipo e quindi se abbiamo questi
cerchi e rombi o triangoli al rialzo
giù triangoli e vogliamo combinare
li insieme dobbiamo passare loro
attraverso una funzione che poi sa cosa
fare su quelli e così quella funzione
qui è dove passiamo in a e B come il
sequenze e poi questo è groovy
sintassi qui così i primi due sono i
i nomi di quei parametri vengono in x
e y e poi l’altro lato di tutto
sta facendo è restituendo una tupla di
xey e questo è il più semplice
cosa puoi fare con una zip e così via
vogliamo fare è combinarli in
una tupla e così finiamo per emettere
queste tuple di questi valori combinati
insieme e poi possiamo uscire
quella tupla e recupera i due valori
da quelle coppie come desideriamo errore
gestendo così il modo più semplice sei tu
dichiara la tua composizione di tutto il
le sequenze e alla fine quando
ti iscrivi ad esso passi nel tuo
gestore di frecce questo è equivalente a
avendo un grande tentativo di cattura intorno a un intero
blocco di codice imperativo è quasi
come avere il try-catch in giro come in
il tuo metodo principale proprio intorno al tuo intero
chiamata di applicazione e o come se tu abbia
un servizio web nel tuo comprato nel
porzione stiamo facendo il corpo la prova
Memorizza tutto intorno a questo ora
può essere molto utile e cosa tu cosa
voglio prendere tutto ciò che va storto
e che lo farà eccezione ovunque
si verifica sarà appena passato e
allora l’intera sequenza termina
tuttavia è molto più comune che tu
voglio essere in grado di catturare errori
chirurgicamente dove sono si verificano in
la sequenza di eventi e quindi ci sono
una varietà
di diversi operatori a cui puoi candidarti
quello e uno di loro è il curriculum in onda
dopo e fa quello che dice che dice
errore
Voglio riprendere con questo altro
sequenza di dati quindi diciamo che ho avuto
che a e B sequenze e voglio aggiungere
una sorta di gestione degli errori in B
sequenza e così ogni volta che B fallisce
qualsiasi punto nel tempo invece di causare
il tutto per fallire voglio essere
in grado di gestirlo in qualche modo così
sarebbe equivalente ad avere come ottenere
metodo in normale imperativo
orientato agli oggetti se fallisce non l’hanno fatto
restituire qualche altro valore e così in questo
caso bene come si muovono le sequenze B
lungo esso emette tre valori e poi
fallisce con un evento non errore quando quello
errore si verifica sta andando a innescare questo
su errore riprendi la prossima funzione e cosa
quello che farà è l’equivalente di
nel blocco di cattura sarebbe allora
dì esegui questa altra sequenza di dati
Ho intenzione di iscriverti ad esso e poi
è quasi come se accendesse semplicemente il
scorre o piace se pensi al treno
tracce e aveva quella leva che cambia
le tracce si sposta l’abbonamento
in un altro flusso di dati e ti consente
quindi per emettere qualunque sia il backup o
i dati di riserva sarebbero così in questo caso
quel backup è qui ed è passato
questa è l’altra funzione per cui si ottiene il fallback
essere per semplicità sulla diapositiva non lo faccio
avere quello che sarebbe, ma sarebbe
essere un’altra funzione osservabile che tu
passare in esso e quindi quale funzione
fa è ottenere sottoscritto e poi esso
emette due eventi correttamente e poi
termina ora quali potrebbero essere
quelli a volte puoi a volte
significa solo che vuoi solo
terminare immediatamente si potrebbe solo
incompleto immediatamente e tu vuoi solo
per prendere diciamo che lo eri
aspettandomi una lista di 50 film è
cosa comune in Netflix ma hai solo ottenuto
a come 37 di loro e ha fallito bene noi
potrebbe solo poi riprendere il prossimo con un
completamento immediato e diremo noi
preferirei che l’ interfaccia utente diventi 37
film e manca quelli ultimi 13 piuttosto
che far saltare l’intera esperienza dell’utente
o potresti avere qualche oggetto tombale
sei tramandato o potresti averne un po ‘
legittimi legittimi dati di riserva a
ritorno
su error return è una versione più semplice di
questo tutto ciò che fa è che quando quell’errore
si è verificato un valore effettivo
per farlo basta immediatamente ritorno in modo
questo è molto più comune giusto
tombstoning
o semplicemente completando immediatamente così sono
inizierò a scavare in qualche reale
casi d’uso e quindi basta andare oltre il
gli operatori così molto semplici da usare è l’HDV
chiama così voglio gestirlo
in modo asincrono così in questo caso lo voglio
recuperare da ciò che Wikipedia in questo caso
e mi ritornerà questo
è tutto appena dichiarativo a questo punto
niente è in realtà in esecuzione quando questo
è fatto creo questo osservabile da
e io sono nei commenti che sto per fare
mostra solo cosa è la tipizzazione statica
intenzionalmente in alcuni posti ed essendo a
un po ‘più verboso solo per quello che vedi
che i tipi sono ma la maggior parte di questi
le cose stanno includendo Java AAA quindi lo farò
appena dedotto attraverso le catene questo
osservabile quindi che restituisce un
risposta HTTP osservabile è possibile flatmap
finita e tornerò un po ‘di più
in seguito a ciò che la mappa piatta ti fa cosa
questo fondamentalmente sta dicendo è quando io
ricevere indietro questa risposta che poi voglio
fare sempre una logica annidata su di essa
in modo sincrono e dentro quello allora io
voglio dire che voglio da quella risposta
Voglio ottenere il contenuto in modo che
oggetto di risposta in quel punto contiene
è il modo in cui funziona HTTP è restituisce
tornare indietro come l’informazione di intestazione vedere
il codice di stato le intestazioni e quelle
cose e poi puoi iniziare a consumare
il resto dei dati e così questo
Risposta in due fasi Sono in grado di convalidare
lo stato e quelle cose e poi
Posso ottenere questa risposta che contiene un
osservabile di un array di byte e in questo
caso voglio solo mappare su a
trasformalo in una stringa, se lo fosse
dati che vorresti lasciare il suo array di byte
fai ciò che desideri e poi
sarebbe in questo passo che potresti
quindi esegui la tua trasformazione JSON ecc
quando ti iscrivi è quando
in realtà fa il lavoro e così tutto
nella nostra X è pigro, fa tutto solo
dichiarativo fino al punto che a
abbonamento si verifica quindi è il
equivalente a te connetti tutto il
tubi e poi si accende l’acqua a
la fine
e così una volta tutto è connesso allora
accendi il flusso e poi tutto
succede a quel punto e di cosa si tratta
emetterebbe quindi in modo asincrono
riceverebbe appena la risposta dal
in questo caso Wikipedia
ora solo per permettere di scoppiare da un
mondo asincrono a volte hai bisogno di rompere
fuori di esso
c’è questa capacità di tornare indietro
in un osservabile bloccante che poi
espone un sacco di operatori di blocco tali
come per ogni questo è utile per se siete
semplicemente facendo una piccola app o unità demo
test e questi tipi di cose
ora quello non era molto di più
interessante di un tipico client asincrono
questo è un po ‘ più interessante
se capovolgo questo da Wikipedia a in
questo caso è un prodotto è un altro
libreria open source che usiamo Netflix I
per tolleranza ai guasti ma questo particolare
cosa è un flusso di dati il
metriche che escono da ognuno dei nostri
server e quindi utilizza l’ html5
server inviato di tali eventi indietro e quando
si collega a questa connessione HTTP è
rimarrà in vita fino a quando manterrai
si apre e emette solo costantemente
eventi bene ora cosa farà
perché i vettori di supporto osservabili
di dati questo ora sarà davvero giusto
iniziare emettendo ogni singolo evento che
scende il filo che emetterà come un
evento osservabile e così sarà solo
continua a chiamare il prossimo quindi in questo caso io
voglio filtrare i ping nel noi
invia questi ping giù ogni 15
secondi fa parte della salute della rete
roba e quindi in questo caso puoi applicare
un operatore per filtrare quelli fuori e poi
diciamo che io sono solo fuori Voglio solo
per avere un campione di quello che sta succedendo
potrebbe prendere 30 di loro e poi
disconnetti e questo è un esempio di come
la stessa interfaccia ora l’ ho appena usata
per una risposta scalare in cui il
La pagina di Wikipedia restituisce una singola risposta
indietro o posso consumare da un flusso di
dati e continuerà a emettere il
i risultati quando arrivano voglio
ora vai in un caso d’uso più complicato
che è questo il caso dell’uso che
in realtà ha guidato la nostra adozione di
programmazione reattiva funzionale questo è
è una versione semplificata di ciò che facciamo
rendiamo l’interfaccia utente che ha la griglia di
film su di esso e che coinvolge un sacco di
comportamento annidato e molto diverso
Le chiamate di rete per renderlo e così il
il diagramma di marmo è un po ‘di più
complicato e il modo in cui inizia è
in cima la prima cosa che noi
farebbe dopo aver ottenuto tutto il tuo
le credenziali dell’utente e tutte quelle cose lo sono
chiediamo al servizio video per un elenco di
film c’è in realtà un livello sopra
questo ancora dove si ottiene la griglia di
prima i film e poi inizi una volta
torna indietro nella griglia e poi vai su ciascuno di essi
elenco per semplicità e solo per un singolo
elenco a questo punto e quindi questo video
servizio lo prendi e questo sta andando
per restituire un osservabile la prossima cosa
Facciamo è diciamo che siamo su un
interfaccia utente più piccola e in realtà solo noi
voglio prendere dieci non il 50 o il 75 o
cento che possono esistere in fila e così
vogliamo prendere dieci bene cosa c’è
sta accadendo quando quell’operatore si innesca
che dietro le quinte questo è pigramente
emettere i dati e poi prendere
operatore una volta che colpisce il decimo elemento
cancellerà dal
quello precedente e quindi l’annullamento dell’iscrizione
evento sarà poi propagarsi il
sequenza asincrona e dire al
genitore nella catena per smettere di lavorare e
allora questo e se questo è comunque molti
livelli profondi è questo si propaga e così
che cosa questo significherebbe è che se tu fossi
continuamente facendo attività di rete
dietro le quinte potresti fermarti
quella attività di rete e quindi è solo
facendo il lavoro fino al punto che tu
in realtà ne ha bisogno pigramente piuttosto che
cercando impazientemente tutto ora
l’implementazione potrebbe aver recuperato tutto
in gruppo potrebbe aver già recuperato 100
di loro in una chiamata di rete in quel caso
tutto quello che hai intenzione di fare è andare
per fermare l’ iterazione in memoria ma il
il principio è che lo emette sempre
porta l’annullamento dell’iscrizione fino in fondo
per consentire la pulizia delle risorse e il
la pigra esecuzione del lavoro e poi
è la scelta delle implementazioni da fare
cosa lavoro sto facendo che in realtà ha bisogno
essere ripulito quando lo ricevo
i dati su cui poi voglio mapparlo
trasformarlo così che cosa mappa fa è
trasforma
scrivi T per digitare R così da farmi fare
qualunque cosa io voglia lì dentro
manipolare i miei dati comunque stiamo andando
fare qualcosa condizione annidata e così
useremo la mappa piatta invece è
noto anche come mappa molti o in dotnet
mondo selezionare molti abbiamo adottato la mappa piana
come convenzione di denominazione sulla JVM da allora
questo è più comune nel mondo di Java e
in realtà è più descrittivo di noi a
quello che sta facendo è che la mappa piana è fondamentalmente
quello che è è la stessa cosa della mappa
tranne che stai restituendo un
osservabile di R anziché di R e quindi di te
potrebbe pensarlo come una mappa che ritorna
le sequenze e quindi la mappa piatta è giusta
unendoli insieme quindi è il
equivalente di fare una mappa e poi
emergere e così finisci con se è
emettendo queste sequenze si fonde semplicemente
loro in una sequenza altrimenti tu
otterrebbe una sequenza di sequenze che
a volte vuoi ma generalmente o no
e quindi cosa facciamo?
in questa mappa piatta è che stiamo andando ora
ricevere 10 chiamate di questo per ciascuno di
gli oggetti video saranno
emesso possiamo ricevere 10 oggetti video
per ognuno di quei 10 vogliamo poi fare
una logica nidificata e quindi la prima
vogliamo fare è vogliamo andare a prendere un po ‘
metadati per quel video e così andiamo
fuori e prendi quello e vogliamo anche farlo
recuperare segnalibri e valutazioni ci sono
altri li recuperiamo ma questi sono tre
molto comuni e ognuno di questi tre
le cose saranno fatte
in modo asincrono possono o non possono
risultato in chiamate di rete e tutti questi
stanno tornando osservabili quindi sono tutti
async e poi vogliamo su di loro
trasformali in alcuni dati che sono
pronto per essere consegnato al nostro cliente e
quindi di nuovo ci mappiamo sopra e in questo caso
lo stiamo trasformando altrettanto bene
semplice dizionario di coppie di valori chiave e
vogliamo farlo per ognuno di loro e
così dentro quella mappa molti o piatta noi
verrà quindi condannata scusa lo faremo allora
in modo annidato prendi i metadati
e mappare e fare la stessa cosa per
i segnalibri e le valutazioni sono davvero schizzinosi
tutto questo sullo schermo e così abbiamo
ottenuto il segnalibro e il punteggio dei metadati
quello che abbiamo appena definito ci sono tre
sequenze osservabili tutto ciò che abbiamo fatto è
dichiarali che li abbiamo dichiarati
sequenze con trasformazioni di mappe
e se dovessimo eseguire il codice come
questo proprio ora non lo farebbero mai
vengono eseguiti perché sono dichiarati
ma in realtà mai abbonarsi e così via
loro perché è tutto pigro vorrei correre
questo e io in realtà non tralasciare nulla
sarebbe come la mia applicazione ha fatto
niente farei la rete iniziale
chiama per ottenere i video che emetterebbe il
video in questo e poi sarebbe solo
un po ‘come restituire i dati vuoti, quindi ho bisogno
iscriversi a loro in un modo che
li combina insieme e quindi voglio
chiudili insieme e tu potresti farlo
a c’è altro ci sono varianti che
potresti fare un’unione con una lista
e cose del genere ma funziona molto
bene in questo caso e quindi voglio zip
l’mbnr perché voglio averli
insieme in un posto e la funzione
che mi rivolgo a questo
quei tre e mi dispiace e lo farà
combinarli insieme in un singolo
dizionario e quindi di nuovo quello che zip è
facendo sta prendendo quei valori di input
e l’applicazione di una funzione e ho intenzione di
Potrei restituirli come una tupla ma cosa
In realtà voglio fare qui è voglio
trasformali in un dizionario questo è
la sintassi groovy per il primo è il
mappa letterale quindi sto creando un dizionario
che contiene solo l’ID della chiave e poi
l’ID del video e poi i tre off
al lato di esso sono solo essere
concatenato in esso quindi è molto molto
rappresentazione concisa di concatenazione
tre dizionari in un nuovo creato
uno così quello che esco in fondo
questo ora ho intenzione di tornare un
mappa o dizionario osservabile e quello
l’operatore di chiusura lampo è l’ultimo pezzo di questo
dichiarazione su come voglio consumare
un elenco di video trasformati in manipolazione
fa logica annidata per andare davvero e
prendere altre chiamate di rete e altro
fuori dal fondo voglio solo emettere un
dizionario dei dati per ciascuno dei miei video
e quello che uscire da quella a ciascuno
di quei dieci video che ora otterrò
dizionario che assomiglia a quello in cui io
avere valori chiave combinati dai tre
chiamate di rete nidificate e il genitore
La rete ha chiamato V ID ovviamente nel
vero nella vita reale, questo è molto
dizionario più grande
e ciò che questo ciò che questo tutti gli spettacoli è
che tutte le interazioni con il
API sono stati trattati come se lo fossero
asincrono e tutto è stato fatto in modo pigro
modo dichiarativo e tutti i dettagli
per quello che succede dietro le quinte
sono controllati dall’API e quindi in
il nostro ambiente di produzione tutto intero
processo sarebbe risultato in tre
Chiamate di rete anche se potrebbe essere
fatto in modo efficiente con 3131 Network
chiama se dovessimo farlo nell’ingenuo
modo e così i metadati sono sempre tirati
dalla cache in memoria perché è così
attivo abbiamo che tutto il cache del
segnalibri e valutazioni li collassiamo
in chiamate a lotti singoli dietro il
le scene e la lista dei video sono tutte tirate
anche in gruppo, ma quelli
i dettagli di implementazione sono completamente in aumento
a noi scegliere come fare e siamo in grado di
cambialo senza mai influenzarlo
che aspetto ha l’API perché è tutto
fatto in un dichiarativo asincrono
modo così come guardiamo indietro sul nostro
architettura che sentiamo di avere
raggiunto con successo ciò a cui miriamo
cosa è la realtà della nostra struttura
della nostra architettura è ora che è il
varie squadre di UI effettivamente costruiscono le loro
proprio endpoint i loro servizi web e
distribuirli sopra di noi in produzione
il team API di Netflix è uscito
di attività di costruzione di servizi web e
ora costruiamo e gestiamo solo il
piattaforma su cui tutti i vari
i team di Netflix costruiscono la propria rete
servizi su di noi e sono in grado
per distribuirli dinamicamente nel prod ito
dura circa 30 secondi dal momento in cui
distribuirlo per propagare in tutto il nostro
flotta di centinaia di server e loro
può rivoltare e fare qualsiasi cosa
desidero con esso e tutto il codice a
quel livello è tutto fatto usando rx
programmazione reattiva dallo stile funzionale
al di sotto usiamo hystrix per tutti i nostri
intestazione back-end di massa del nostro sottostante
sistemi e ci è piaciuto il modello reattivo
così tanto che abbiamo recentemente
isterici riadattati per essere non bloccanti
dall’inizio alla fine
ed esposti meccanismi osservabili per
interagendo con esso e nel tempo siamo
vedendo l’approccio di questo reattivo
stile spingendo sempre più in profondità nel nostro
impilare in modo che ci stiamo avvicinando e
più vicino al punto ora che quando un
richiesta in arrivo viene nel
Dichiarazione di tutto il lavoro in realtà
quindi si connette a un livello successivo di
tutte le sequenze osservabili e superiore a
in fondo alla chiamata dalla rete in arrivo
alla rete sottostante chiama il
l’altro lato e poi indietro è uno solo
dichiarazione reattiva e quindi ci sentiamo
piuttosto bene su come l’osservabile
le API hanno funzionato e penso che il
parte più interessante di questo alcuni di
le lezioni apprese sono lo sviluppatore
la formazione era una chiave abbastanza grande per noi in
adottandolo così quando sono stato coinvolto
il design originale e l’architettura di
questo di questo nuovo approccio per la nostra API
piattaforma e mi ci è voluto un po ‘per
brontolare le idee e ci sono voluti un sacco di
spargimento di pregiudizi e disimparamento di
approcci che erano solo lo status quo
e una volta un gruppo centrale di noi avrebbe capito
che fuori e abbastanza iterato ci ha portato
un paio di mesi per sentirsi davvero convinto
che ne abbiamo avuto il livello successivo
il lavoro con gli sviluppatori è stato il prossimo
parte difficile di prendere gli sviluppatori che hanno
10 15 20 anni di radicata solo
pensando a come implementare
un codice come questo e quindi quello che abbiamo trovato è
che la prima coppia di sviluppatori ha preso
un mese quattro a sei-otto settimane per
loro per essere veramente all’altezza
pensavo davvero così e così è stato
i primi due mesi come fase alfa di
dopo ciò abbiamo scoperto che ci volevano circa due
settimane per ogni determinato sviluppatore
oltre quell’ostacolo di brontolii e
borbottando e lamentandosi e davvero
chiedendosi perché mai erano
ha chiesto di fare la programmazione in stile funzionale
– uscendo dall’altra parte andando a prendere
non voglio tornare indietro all’altro
modo e per facilitare ciò che noi
effettivamente assunto uno scrittore tecnico per
entra e scrivi documentazione per questo
ed è stata una delle migliori decisioni che abbiamo
ha reso alcuni dei migliori interni
documentazione che abbia mai visto in a
azienda
perché riconosciamo che questo non dovrebbe
solo alcuni ingegneri stanno solo cercando di farlo
come buttare qualcosa in un wiki ma noi
in realtà ha portato qualcuno in realtà
aiuta a scrivere e questo è stato un grande
affare e poi facciamo anche solo interni
formazione per i nuovi sviluppatori in arrivo
consiglio di amministrazione e questo non è solo un gruppo di
come 10 o 15 persone perché questo è tutto
le diverse squadre dell’interfaccia utente che vogliono
supportare i loro dispositivi e così è
Ingegneri JavaScript e c-sharp
chiusura ingegneri e ingegneri Java
Scala groovy tutte queste persone diverse
da diversi background che sono tutti
potenzialmente creando servizi web per
i loro dispositivi su cui stiamo lavorando
questa la prossima cosa è che il debugging
e la traccia di async è sicuramente
diverso
impostare un punto di interruzione è solo diverso
in codice asincrono quali sono i migliori
cose che non rx se è sedersi in
la produzione che non puoi fare è questa
quasi con la stessa facilità, ma quando il vostro sono in
il tuo IDE rx supporta l’idea di virtuale
scheduler o test schedulers che cosa
rimuove tutta la concorrenza e puoi farlo
incrementare il tempo artificialmente e così via
rende davvero molto il test unitario
efficace e in modo da poter avere
approcci deterministici al pensiero
attraverso le sequenze di dati e
incrementare il tempo come ci si aspetta e poi
eseguendo le asserzioni c’è
sicuramente lavorerò ancora per questo
spazio e stiamo cercando di avere un
console simile a ciò che Chrome ha per
visualizzare eventi asincroni nel tempo
ma essere in grado di gestirlo contro il nostro
server e quella roba che siamo
esplorare oggi l’unica regola che abbiamo
dovevo davvero far rispettare la gente
finisce per auto-rafforzarsi alla fine una sola volta
hai segnato il dito del piede abbastanza volte ma
è perché siamo sulla JVM e sul
la maggior parte delle lingue li utilizzava
non far rispettare questo è non farlo
lo stato di mutante al di fuori di te generalmente
non muta lo stato ma se stai andando
per mutarlo, mutalo dentro il tuo
funzione e questo è tutto ciò che vuoi fare
dentro una specie di cosa imperativa
stiamo bene ma entro le barriere di a
funziona fintanto che le persone si attengono a quello
tutta la concorrenza e il parallelismo giusto
si prende cura di se stesso
e questo in realtà si adatta bene ad alcuni di
le altre presentazioni precedenti oggi
che lo stato mutabile è molto cattivo
cosa quando inizi a entrare in questi
sistemi altamente concomitanti e così in a
in poche parole questa combinazione di funzionale
stile e reattivo asincrono
l’elaborazione ha dimostrato di essere in un molto
approccio efficace per noi nella gestione
sistemi ad alto volume su larga scala dove noi
ha un sacco di logica condizionale annidata
ed è molto guidato dalla rete e c’è
molto di più di ciò che è stato scritto
questo ed i progetti open source che
sono disponibili abbiamo avuto circa
abbiamo più di 30 collaboratori finora
il nostro X Java rxjs non sono direttamente
coinvolto ma lo usiamo molto a
Netflix e adoro avere il tuo
coinvolgimento nel progetto, se lo sei
interessato a questa roba o solo a te
può andare e solo imparare di più sul
approccio anche se non lo usi
biblioteca particolare c’è un sacco di
approcci diversi per funzionale e
stili reattivi e se non altro
ti raccomanderei di imparare il
idee, perché penso che troverete che
cambia davvero le tue abitudini di codifica
per il meglio grazie
la risposta breve è stata quella
in realtà non è stato un grosso problema come
quello che prima pensavamo di testare l’unità
allo stesso modo di qualsiasi altro codice al
Alla fine della giornata è solo il codice e questo
in realtà finisce per essere più semplice per il
le stesse ragioni per cui le presentazioni precedenti
da boat’ll e altri dove una volta
iniziare a rimuovere tutto lo stato mutabile e
hanno queste sequenze di
trasformazioni in realtà diventa molto
facile da leggere e capire e
allora diventa semplicemente una codifica normale
pratica se hai solo una grande palla di
codice che è come 20 trasformazioni tutte
in uno poi diventa un po ‘più difficile
prova se usi buone pratiche di codifica
e spezzali in funzioni e tu
prova ogni funzione in modo indipendente e fallo
normale buona codifica è lo stesso
concetti l’unica cosa reale è che se
stai usando operatori che di
esigenze di definizione o una sorta di
concurrency come windowing o buffering
quelli iniziano a coinvolgere elementi del tempo e
allora è lì che la capacità di passare
tutte queste decisioni sono astratte
scheduler nella nostra X e quindi puoi
il tuo test unitario ha utilizzato gli scheduler di test
che poi ti permettono di rimuovere tutto il
concurrency reale e quindi è possibile
incrementa o sposta il tempo in cui ti trovi
voglio affermare a quel punto e permette
a ragionare sul tempo senza tutto il
non determinismo degli scheduler dei thread a
un po ‘di più sul parallelismo e
ossessiona parallelismo e osservabili così
da ciascuna sequenza osservabile il
contratto è che non entrerà in congedo
una qualsiasi delle prossime chiamate e così via
questo è il contratto che ti dà
ma poi ti permette di farlo se tu
unire per esempio più osservabili
si iscriverà a tutti loro
parallelamente c’è anche il parallelo
operatori molto simili a come il
flusso parallelo in Java otto o
mappa di coppie parallele e ogni lingua ha
qualche variazione di esso in modo si può dire che
esplicitamente che va bene andare in parallelo
all’interno di una sequenza osservabile e il
gli scheduler ti consentono di accedere al thread
piscine o
sempre tu puoi scegliere così i sordi di
definizione perché stai usando un
stile funzionale senza mutevolezza
sei in grado di essere molto libero circa
eseguire le cose in parallelo e usando
la piena capacità del numero di core
nella tua macchina di default se solo
non pensarci nemmeno se lo farà
appena generalmente fare la cosa giusta su
a tuo nome e verrà comunque utilizzato
molti core attorno alla Macchina correttamente
possiamo usarlo su Android sì, lo è
codificato in Java sei standard che funzionano
su così stiamo mantenendo a quel livello
specificamente così funziona su Android
ovviamente non hai le sottigliezze di
lambda ma ce ne sono alcuni abbastanza grandi
nomi come SoundCloud che stanno usando
questo in produzione sulla loro app su questo
su Android e ne hanno scritti alcuni
davvero ottimi articoli su di esso e fatto
alcune presentazioni su di esso, se si voleva
per cercare solo la ricerca
SoundCloud rx Java e io sappiamo che c’è
alcuni altri in qualche altro abbastanza grande
aziende che non penso siano in
produzione ancora ma sono un po ‘
seguendo la guida di ciò che SoundCloud è
fatto su Android ok , non capisco
questa domanda, ma come creeresti un?
Staffa uccello una staffa di uccello Yep buona
domanda che mi hai preso, vieni a parlare con me
dopo penso che porteremo il
domande per chiudere e questo è stato
ancora
tu
programmazione reattiva oggi ma mai
usando la parola monad così l’intenzione sarà
essere di attenersi alla pratica di
funzionale in stile funzionale
programmazione e programmazione reattiva o
asincrono e quindi sostanzialmente alla fine
di questo voglio che tu sia in grado di
capire l’ approccio che abbiamo preso
comporre funzioni in modo reattivo
modo e ciò significa che sei tu
può prendere un flusso di dati trasformarlo
dall’uno all’altro come è a
che scorre in modo sincrono attraverso un sistema
ma più interessante che puoi
iniziare a combinarlo insieme e di nuovo
fai tutto in modo reattivo e
c’è un sacco di dibattiti su cosa
dovremmo chiedere questo abbiamo iniziato
usando reattivo funzionale per nominarlo
prima che nessuno di noi avesse davvero qualche idea
riguardo l’accademia dietro di esso e io sono
pienamente consapevole di FRP e Connell Elliott
e Fran e quelle cose se qualcuno può
dammi un nome migliore per quello che siamo
facendo qui oggi mi piacerebbe sentirlo ma
gli aspetti funzionali sono sei tu
andando a vedere un sacco di chiusure lambda
le funzioni saranno per lo più
pura l’ unica parte in cui non lo sono
il puro è in genere la fine stessa
simile alla monade i / o in Haskell e
li vedrai come componibili
e il lato reattivo di cosa si tratta
riferendosi a è che è tutto asincrona che
hai valori ed eventi sono in corso
spinto attraverso il sistema e tu sei
reagendo ad esso mentre fluiscono quando
abbiamo iniziato a lavorare su ciò che volevamo
scegliere come target un ambiente poliglotta e noi
mirato alla JVM nel suo insieme, non a nessuno
particolare linguaggio a Netflix è
principalmente ancora il linguaggio Java con
un bel po ‘di groovy e una discreta quantità
di Scala ci sono frammenti di
chiusura mostrando e stiamo cercando
avanti a ciò che Java porterà otto come
bene sta andando a cambiare in modo significativo
in che modo viene usato quel linguaggio in particolare
come abbiamo adottato i principi funzionali
la maggior parte degli esempi che ho intenzione di dare
oggi sono mostrati in groovy con pochi e
Java otto ma ce ne sono molti
esempi di questi
noi siamo e il lato Scalla è davvero dentro
le ultime sei settimane sono drammaticamente
migliorato come la comunità dei typesafe
ottenuto coinvolto nel lavoro sul Scilla
adattatori per renderli molto idiomatici
Scalla stessa così che cosa è rx Java loro
è una libreria che abbiamo implementato come
la porta non è una porta diretta ma stiamo provando
per essere abbastanza fedele alla rete RX
versione di rx che è stata costruita in
Microsoft e c’è anche un JavaScript
implementazione rxjs e così sei
iniziando a vedere la RX e poi a
nome della lingua
si presenta in varie lingue PHP è
ottenendo uno ce n’è uno per il cacao
non si sono attenuti alla convenzione
anche se hanno abbattuto, c’è reattività
il cacao e quello che è è fondamentalmente
i principi di un asincrono
osservabile con molto ordine
funziona su di esso e così sto andando
per iniziare a farlo prima di noi
arrivare e voglio darti un contesto
è per questo motivo Netflix ha finito per andare giù
questo percorso così Netflix è una TV e un film
società e siamo attualmente in oltre 50
paesi e territori con oltre 37
milioni di clienti in Nord America noi
avere un impatto piuttosto grande sull’ultimo
miglio a valle consumo di Internet e
oltre un miliardo di ore di video sono
consumato ogni mese la crescita delle API e
questa è la squadra su cui ho lavorato
come quello negli ultimi anni e
l’API è che si può pensare ad esso come solo
come qualsiasi altra API è la facciata
parte superiore dell’architettura orientata ai servizi
internamente a Netflix, che è molto
macchine e quella facciata è fondamentalmente
lì per fornire l’accesso a tutti i
funzionalità ai mille plus
diversi dispositivi che possono accederci e
Rx è stato scoperto quando eravamo come eravamo
andando su quella curva di crescita e come il
il numero di dispositivi che ci accedono è aumentato
iniziamo a correre nei limiti di cosa
la nostra aqua riposante stava facendo abbiamo avuto un
tipica api riposante era tipica come
puoi aspettarti
di uno stack Java stava usando Russell
e le annotazioni e tutte le imperative
ed erano chiamate API molto dettagliate
e i dispositivi con cui ognuno ha interagito
loro ma quello che voleva dire è che lo era
ottimizzato per nessuno
era generico e avevi dispositivi in quel modo
dovrebbe fare 12 chiamate di rete a
rendere una esperienza utente e il
pazzia degli argomenti che eravamo
iniziando a passare in questi servizi web
chiama per provare e personalizzare i dati che
veniva consegnato per utente diverso
le esperienze stavano sfuggendo di mano
e quindi volevamo essere in grado di prendere questo
tipo di esperienza e ridurlo a
una singola chiamata di rete per un singolo utente
sperimentare e spingere tutto il the
chiamate di rete dalla vittoria alla LAN
all’interno del nostro data center a cui capita
essere tutti nei servizi Amazon AWS e
sfruttare la bassa latenza della rete
la comunicazione di quello strato riduce tutto
la replica dello sforzo su ogni
rete che autentica il recupero dell’utente
metadata quelle cose ed essere in grado di
sfruttare la concorrenza di gran lunga migliore
caratteristiche dei server sopra il
piccoli dispositivi che supportiamo un iPhone
o un iPad o qualcosa del genere è un
dispositivo incredibilmente potente rispetto a
l’ampia portata dei dispositivi che noi
target $ 40 di silicio seduto su un set-top
box è un’esperienza molto diversa in a
portatile o un telefono moderno e così via
logica condizionale annidata doveva essere tutto
fatto parallelamente esecuzione parallela
altrimenti avremmo fatto un passo
all’indietro da dove eravamo prima
dove almeno avevamo l’implicito
concorrenza che stava accadendo attraverso
tutte le più chiamate di rete la maggior parte di
i client HTTP dai dispositivi potrebbero a
almeno sai sostenere come per
chiamate in rete in parallelo e noi
necessario almeno per essere così buono, ma noi
voleva anche permettere a chiunque di creare
questi endpoint non sono solo il team API
perché se fosse solo quella squadra noi
sarebbe un collo di bottiglia per la creazione di questi
endpoint personalizzate in modo che volevamo
consentire ciascuno dei diversi team di dispositivi
per costruire i propri servizi web che vogliamo
essere poliglotta per supportare il diverso
lingue che i team potrebbero voler utilizzare
e volevamo risolvere la concorrenza
problema senza che tutti debbano leggere
questo libro più e più volte che amo
questo libro è un grande libro che ho letto
più volte ma il punto era questo
non volevamo che fosse il
prerequisito per le persone in grado di
costruire con successo altamente concomitante
sistemi su Netflix e quindi cosa
significato per noi è che il proprietario del
API doveva mantenere il controllo del
comportamento concorrente chiunque fosse
esponendo quella facciata dovevamo essere in grado
mantenere il controllo di questo stava facendo
blocco o non blocco delle chiamate di rete
stava recuperando qualcosa dalla memoria
e sincronicamente sparagli colpendolo con a
conosci la ricerca al microsecondo o era questo
qualcosa che prenderà decine o
centinaia di millisecondi, quindi stiamo andando
per averlo in una discussione o un non-blocco
I / o evento dovevamo mantenere il controllo di
quelle cose e cosa significava per noi
è la nostra API se avessimo un metodo
firma come quella tutto ad un tratto questo
stava cuocendo nel contratto del nostro
livello di servizio un sacco di decisioni che
ha impedito la nostra capacità di apportare cambiamenti e
anche per i clienti che consumano i dati
E se ad un certo punto che era o
una chiamata di rete molto veloce che noi
preteso di fidarsi o era qualcosa
stavamo recuperando un ricordo che doveva
cambia tutto ad un tratto non abbiamo scelta
ma per rompere la firma per farlo
restituire qualcosa in modo asincrono anche se
il cliente vuole davvero essere in grado di
dare il via a due di queste cose
contemporaneamente perché sanno che loro
dovrebbe essere quello che stiamo andando a farli
facciamo davvero li vogliamo fare
decisioni come i thread di generazione e il
la risposta è stata molto No
e così molto rapidamente siamo andati giù
percorso di dare un’occhiata a bene ovviamente
potremmo iniziare a mettere callback in noi
potrebbe restituire le cose come futuri e se noi
avere elenchi di cose hanno un futuro
con una lista di futuri e inizia a
disordinato ma questo è dove eravamo
cominciando ad essere e fortunatamente abbiamo un
miscela molto varia di ingegneri e
programmazione di lingue e sfondi
e Netflix e quindi c’era
gente là che, come ho interagito con
loro sono stato in grado di essere istruito sul
i concetti di rx che Eric Meyer aveva
inventato in Microsoft attraverso un
ingegnere il
stato a Microsoft e vieni a
Netflix e gli ci è voluto un po ‘per arrivare
attraverso il mio grosso cranio di java e prendimi
pensare in questo modo e anche 15 anni di
programmazione imperativa non ero ancora
pensando che quella inversione di pensiero
a muoversi nel mondo funzionale,
mi ha preso un po ‘di tempo ma oltre
il mese o due durante quello
fase di scoperta i concetti di rx
iniziare a diventare più chiaro come molto puro
teoria su come fare asincrono
programmazione e finisce per essere molto
semplice miglioramento della Gang of Four
modello di osservatore per spostarlo da un
imperativo mondo sincrono in a
dichiarativo mondo asincrono e così via
finisce per essere un doppio di iterable quindi se
hai mai sentito Eric Meyer parlarne
parlerà della dualità e può farlo
guidarti attraverso tutta la teoria delle categorie
e la matematica alla base di questo io saltare
tutto ciò perché onestamente non lo faccio nemmeno
capisci tutto ancora ma ovunque
che avresti un iterabile che è
spingerlo dove si estrae i dati da esso
ora puoi avere un osservabile e spingere
dati in basso e puoi lavorarci dentro
allo stesso modo le due aggiunte ad esso ora
sono così avanti su un intervallo è il prossimo
con un osservabile e poi perché lo è
tutto asincrono ora hai bisogno di due cose nuove
dillo allo stato terminale in modo che il
lo stato terminale è che stanno per
essere tutto completato con successo, quindi è così
dicendoti che non ti aspetti di riceverne
nuovi eventi emessi o un errore
evento che è il terminale lo dichiara
dice che non stai andando a ricevere qualsiasi nuovo
eventi ma ci siamo conclusi con questa eccezione
in realtà è un gettabile e quindi se tu
guarda un iterable con ordine più alto
funzioni ad esso applicate come
fondamentalmente tutte le lingue jvm che
sono stati costruiti negli ultimi anni
avere e poi di recente con Java otto
interfaccia di streaming che puoi costruire
funzioni di ordine superiore in cima a
iterabile in modo che tu sia un tu
in modo dichiarativo può dirgli come elaborare
i dati bene si può fare esattamente lo stesso
cosa con l’osservabile tranne che è
ora tutto asincrono
e quindi è tutto non-bloccante e il
l’unica differenza tra loro è quella
invece di uno per ciascuno alla fine che
per definizione è un evento di blocco tu
iscriversi ad esso si può anche fare un for
ogni inosservabile se vuoi rompere
nel blocco ma questa dualità
tra di loro ha iniziato a guidarci
verso la decisione su cosa
astrazione vogliamo usare sopra il nostro
dati nel nostro livello di servizio e così abbiamo
questo quadrante di diverse scelte di
come trattare i nostri dati così il primo
e uno più semplice che siamo stati tutti
usando sin dalla prima volta che abbiamo toccato a
la riga di codice è scalare sincrono
valori e lo prendi e quando lo sei
facendo qualche logica condizionale su di te tu
ottenere quel valore e si esegue la logica
su di esso imperativo e sincrono
quando hai più valori che fai
allo stesso modo, tranne che iterate su un
iteratore iterabile in un ciclo e poi tu
condizionatamente fai la tua logica al suo interno
e sto mostrando la pace condizionale
perché è importante nei prossimi passi
ci muoviamo nel voler comportarci
asincrono, futures o promesse
loro sono esistiti per un bel po ‘
tempo e lavoro abbiamo il futuro
ea prima vista sembrano come
sono una soluzione piuttosto buona ma loro
sono viziati in molti modi divertenti una volta
inizi a provare a fare nidificati
logica condizionale la prima cosa qualsiasi
Lo sviluppatore Java fa con il futuro è
loro bloccano loro ottengono il futuro
indietro e poi non appena vogliono
qualcosa con esso loro hanno dereferenziato
il valore al suo interno e quindi il sistema
blocchi e questo è davvero difficile da fare
evita se stai facendo una specie di nidificazione
logica condizionale va bene lo stesso
in modo che i callback siano abbastanza semplici se
hai solo un livello se non lo fai
bisogno di dereferenziarlo fino alla finale
uscita ma se hai bisogno di fare nidificare
logica a un certo punto è necessario
blocca immediatamente su di esso e non bloccare
finisci per avvolgere i fili intorno
fili e diventa davvero triste davvero
veloce ci sono soluzioni migliori però
la biblioteca di guava ci dà futuro
callback così ascolti futuri e così
questo inizia a risolvere quel problema quando
non blocchiamo invece noi asso
abbiamo una richiamata e poi dentro quella
abbiamo gestori di callback dove possiamo
in modo asincrono esegui questa logica
un futuro completabile in java 8 che dà
questo solo con nomi nuovi per tutto
apparentemente non volevano usare nessuno
delle convenzioni dell’industria e
quindi hanno nomi diversi per
tutto ma eseguirli esattamente
allo stesso modo e in modo da poter applicare a
richiamata a una funzione in seguito
chiusura e scusa non chiudendo Scala e
i futures di akka sono molto eleganti
futuri composibili che hanno
in realtà ottenere è molto molto vicino a dove
vogliamo essere se non avessi scoperto Rx
probabilmente useremmo questi futuri
e questo dà un futuro molto elegante
dove possiamo quindi mappare la risposta
e trasformalo fare qualunque cosa sia annidata
logica che faremo e ci darà
l’esatta composizione e trasformazione
funzionalità che vogliamo su scalare
Valori comunque se prendiamo quel futuro
e basta passare a un noi osservabile
ottenere lo stesso identico comportamento, ma noi
ora posso lavorare anche sui vettori
risposte scalari e quindi quello che abbiamo trovato è
che il meglio delle implementazioni di
il futuro e l’osservabile ci danno
astrazioni simili ma osservabili
era un passo avanti nell’astrazione
e quindi per semplificare il nostro ambiente
ho scelto di adottare osservabile attraverso
la scheda per la gestione asincrona
programmazione perché ci permette di
raggiungere queste funzioni di ordine superiore per
trasformazione e composizione su entrambi
vettori e risposte scalari e così via
questo significava per noi in pratica
il livello di implementazione è invece di
l’ API di blocco è ogni altro servizio
strato che vogliamo in giro e cambiarli tutti
alle API osservabili e così via
significa per noi è questa astrazione
ora libera l’ implementazione per dire
forse voglio sinceramente io
so che ho parlato in modo asincrono
tutti insieme con la stessa interfaccia I
potrebbe restituire un valore in modo sincrono ma
lo sviluppatore che sta consumando questo
lo consuma in modo asincrono ma forse
Ho già seduto nella cache
e così ho intenzione di
inviarlo immediatamente senza il
sovraccarico di un filo o ho potuto sostenerlo
con una filettatura separata da una filettatura
pool o posso avere più thread da
un thread tira ognuno omettendo diverso
valori come sono elaborati o potrei
utilizzare un attore o più attori da fare
quel lavoro o potrei fare una chiamata niño
con un ciclo di eventi o potrei essere una coppia
un piano e un attore con un ciclo di eventi se
Non volevo che i miei callback accadessero
i fili del lavoratore e tutti questi
astrazioni tutte queste implementazioni
i dettagli sono astratti da come il
i dati vengono consumati e quindi il codice cliente
tratta tutte le interazioni
in modo asincrono ma il proprietario di quello
quell’API è libera di cambiare il
implementazione tuttavia che desiderano e
sono anche in grado di controllare se
sta bloccando o non bloccando così questo
l’astrazione appare come non bloccante
asincrono e quindi l’ implementazione
il dettaglio può scegliere quali risorse esso
sta usando così ho intenzione di iniziare a ricevere
per programmare ora e per guidarti
esempi di codice e alcuni dei più
comuni funzioni di ordine superiore che si applicano
a questo e così quella cosa in cima a noi
chiama i diagrammi di marmo che sto per
usa molti di quelli nel resto del
presentazione per provare e dare un visual
rappresentazione di come sono i dati
scorre così se non l’hai mai fatto
programmazione funzionale o reattiva
programmare la speranza è che si può
inizia a visualizzare il flusso di dati
attraverso e se si inizia a pensare alla
dati come letteralmente pipe of of data
il fluire insieme e poi questi
le funzioni di ordine superiore sono come il
connettori che hai con i tubi
e quell’immagine visiva può iniziare ad aiutare
tu riconosci fondamentalmente cosa sta succedendo
con i dati mentre scorre attraverso il
sistema e quindi ho intenzione di iniziare
le basi di come crei e
iscriversi agli osservabili quindi a
osservabile è davvero solo una funzione
che può accettare un osservatore e quando lo fa
riceve quell’osservatore che emetterà
via su prossimo bene una volta che hai ottenuto quello
osservatore e si è iscritto a voi possibile
emettere 0 o più eventi tramite il
al prossimo evento e poi hai un
stato terminale di incompleto di successo
o uno stato terminale di errore se c’è
un fallimento e quindi ecco alcuni esempi
questi sono volutamente prolisso in
mostrando da dove proviene la concorrenza
normalmente ci sono modi molto migliori di
introducendo la concorrenza ma io sono
farlo qui per essere esplicito in
dimostrando che è il massimo
osservabile per quanto riguarda dove la fonte
di concorrenza o di esecuzione asincrona
viene da e così in questo caso il
la parte interessante è giusta
lì e quello che fa è con questo
osservabile è una funzione che una volta
sottoscritto a prenderà un video
valutazione dell’oggetto oggetto dati su una rete
chiama e poi emettilo e poi completa
quella sequenza osservabile e tu lo farai
notare che in questo caso sono esplicitamente
farlo all’interno di un esecutore Java che
esegue sedersi su qualche thread in background
e tipicamente nel nostro codice di produzione
non farlo così di nuovo voglio solo essere
chiaro che questo è solo per dimostrare
che è pienamente la scelta del
osservabile quindi cosa sta succedendo qui a
esempio sincrono che mostra questo
l’osservabile può essere bloccante e
sincrono se vuole essere e così
questo semplicemente restituisce i dati
e l’ abbonamento bloccherà di fatto
Non consiglio di farlo in genere
ma se hai qualcosa che è in a
cache e ci vuole microsecondo a
prenderlo fuori ed emettono generalmente
in realtà è meglio farlo quindi generare
una minaccia o qualcosa del genere
natura quindi in questo caso siamo in realtà
restituendo più valori e emettiamo
loro e poi completano ecco un
asincrono con più valori
generalmente probabilmente non stai facendo un
chiamata di rete in un ciclo come questo ma se
hai avuto qualche motivo per farlo
in genere hai un po ‘più efficiente
approccio streaming dove è un singolo
chiamata in rete o streaming dei dati
fuori dalla linea ma il più importante
l’implementazione è la prossima cosa
i valori che ricevono e poi tu
completo e quindi questi sono molto banali
esempi della sorgente dei dati
l’osservabile
auto così l’osservatore più semplice ora così noi
flip dal produttore al consumatore
lato è il consumatore ha tre possibili
eventi che può ricevere tipicamente da te
in realtà non ho bisogno di incompleto a
Alla fine è una specie di implicito
in genere e così generalmente sembra
scusa, sto saltando solo accorciando
per mostrare come appare quando sei
non facendo il pieno verboso
implementazione che è quello che sembra
quando usi tipicamente i lambda
non è necessario il completamento e l’errore
gestendo questo è la gestione degli errori solo a
alla fine ho intenzione di entrare in
errore asincrono che gestisce un po ‘
più in dettaglio più tardi è uno dei
maggiori sfide nella programmazione asincrona
tipicamente ma questo è il basic
osservatore che vorresti passare e tu
non sempre è necessario avere l’errore
gestore se non vuoi preoccuparti
loro ma generalmente questo sarebbe dove
sei a, ma tutto quello che abbiamo fatto finora è
basta fare un pub glorificato / sub e
niente di interessante a questo punto dove
diventa interessante è dove iniziamo
avere funzioni componibili e quindi alcune delle
questi tipi di funzioni questa è una lista
di alcuni dei più comuni e io sono
andando a camminare attraverso ora alcuni di
quelli che sono semplicemente fondamentali per
abbastanza bene qualsiasi applicazione, quindi vado
per iniziare con come si combinano più
flussi di dati che utilizzano l’operatore di fusione
quindi ciò che fa l’operatore di unione è
ti permette di prendere due osservabili
sequenze dello stesso tipo e si fondono
loro in una sequenza osservabile
sequenza che ha tutti quelli tutti
eventi combinati e quindi qui abbiamo due
le sequenze ottengono i dati a e B e entrambi
restituire gli stessi oggetti dati alcuni dati
e così queste due linee in alto
rappresentano due sequenze di dati sopra
tempo a cui entrambi stanno emettendo valori
diversi punti di tempo e quello superiore
emette un evento di errore è il terzo
evento lì che X rappresenta un non
errore di chiamata che vuoi prendere questi due
e passali attraverso un operatore di fusione
e che unire operatori è questo è il modo
sembra e che unisce l’operatore al
dall’altra parte quello che vuoi è un singolo
sequenza osservabile che combina questo
uscita e quindi vedrai che
combina i primi quattro eventi e poi
lo stato terminale di errore e quindi
uno
questo stato terminale non si verifica più
gli eventi arriveranno e poi fuori
dall’altra parte hai un singolo
abbonamento che riceve tutti quelli
gli eventi univano un altro comune
uno è con cerniera lampo viene utilizzato quando si è
combinando più sequenze di dati
più osservabili di diversi tipi
quindi qui abbiamo due osservabili di due
diversi tipi di dati alcuni dati e
stringa così la differenza qui è quella
non puoi semplicemente combinarli insieme
e con una supposizione di due loro come
il loro tipo e quindi se abbiamo questi
cerchi e rombi o triangoli al rialzo
giù triangoli e vogliamo combinare
li insieme dobbiamo passare loro
attraverso una funzione che poi sa cosa
fare su quelli e così quella funzione
qui è dove passiamo in a e B come il
sequenze e poi questo è groovy
sintassi qui così i primi due sono i
i nomi di quei parametri vengono in x
e y e poi l’altro lato di tutto
sta facendo è restituendo una tupla di
xey e questo è il più semplice
cosa puoi fare con una zip e così via
vogliamo fare è combinarli in
una tupla e così finiamo per emettere
queste tuple di questi valori combinati
insieme e poi possiamo uscire
quella tupla e recupera i due valori
da quelle coppie come desideriamo errore
gestendo così il modo più semplice sei tu
dichiara la tua composizione di tutto il
le sequenze e alla fine quando
ti iscrivi ad esso passi nel tuo
gestore di frecce questo è equivalente a
avendo un grande tentativo di cattura intorno a un intero
blocco di codice imperativo è quasi
come avere il try-catch in giro come in
il tuo metodo principale proprio intorno al tuo intero
chiamata di applicazione e o come se tu abbia
un servizio web nel tuo comprato nel
porzione stiamo facendo il corpo la prova
Memorizza tutto intorno a questo ora
può essere molto utile e cosa tu cosa
voglio prendere tutto ciò che va storto
e che lo farà eccezione ovunque
si verifica sarà appena passato e
allora l’intera sequenza termina
tuttavia è molto più comune che tu
voglio essere in grado di catturare errori
chirurgicamente dove sono si verificano in
la sequenza di eventi e quindi ci sono
una varietà
di diversi operatori a cui puoi candidarti
quello e uno di loro è il curriculum in onda
dopo e fa quello che dice che dice
errore
Voglio riprendere con questo altro
sequenza di dati quindi diciamo che ho avuto
che a e B sequenze e voglio aggiungere
una sorta di gestione degli errori in B
sequenza e così ogni volta che B fallisce
qualsiasi punto nel tempo invece di causare
il tutto per fallire voglio essere
in grado di gestirlo in qualche modo così
sarebbe equivalente ad avere come ottenere
metodo in normale imperativo
orientato agli oggetti se fallisce non l’hanno fatto
restituire qualche altro valore e così in questo
caso bene come si muovono le sequenze B
lungo esso emette tre valori e poi
fallisce con un evento non errore quando quello
errore si verifica sta andando a innescare questo
su errore riprendi la prossima funzione e cosa
quello che farà è l’equivalente di
nel blocco di cattura sarebbe allora
dì esegui questa altra sequenza di dati
Ho intenzione di iscriverti ad esso e poi
è quasi come se accendesse semplicemente il
scorre o piace se pensi al treno
tracce e aveva quella leva che cambia
le tracce si sposta l’abbonamento
in un altro flusso di dati e ti consente
quindi per emettere qualunque sia il backup o
i dati di riserva sarebbero così in questo caso
quel backup è qui ed è passato
questa è l’altra funzione per cui si ottiene il fallback
essere per semplicità sulla diapositiva non lo faccio
avere quello che sarebbe, ma sarebbe
essere un’altra funzione osservabile che tu
passare in esso e quindi quale funzione
fa è ottenere sottoscritto e poi esso
emette due eventi correttamente e poi
termina ora quali potrebbero essere
quelli a volte puoi a volte
significa solo che vuoi solo
terminare immediatamente si potrebbe solo
incompleto immediatamente e tu vuoi solo
per prendere diciamo che lo eri
aspettandomi una lista di 50 film è
cosa comune in Netflix ma hai solo ottenuto
a come 37 di loro e ha fallito bene noi
potrebbe solo poi riprendere il prossimo con un
completamento immediato e diremo noi
preferirei che l’ interfaccia utente diventi 37
film e manca quelli ultimi 13 piuttosto
che far saltare l’intera esperienza dell’utente
o potresti avere qualche oggetto tombale
sei tramandato o potresti averne un po ‘
legittimi legittimi dati di riserva a
ritorno
su error return è una versione più semplice di
questo tutto ciò che fa è che quando quell’errore
si è verificato un valore effettivo
per farlo basta immediatamente ritorno in modo
questo è molto più comune giusto
tombstoning
o semplicemente completando immediatamente così sono
inizierò a scavare in qualche reale
casi d’uso e quindi basta andare oltre il
gli operatori così molto semplici da usare è l’HDV
chiama così voglio gestirlo
in modo asincrono così in questo caso lo voglio
recuperare da ciò che Wikipedia in questo caso
e mi ritornerà questo
è tutto appena dichiarativo a questo punto
niente è in realtà in esecuzione quando questo
è fatto creo questo osservabile da
e io sono nei commenti che sto per fare
mostra solo cosa è la tipizzazione statica
intenzionalmente in alcuni posti ed essendo a
un po ‘più verboso solo per quello che vedi
che i tipi sono ma la maggior parte di questi
le cose stanno includendo Java AAA quindi lo farò
appena dedotto attraverso le catene questo
osservabile quindi che restituisce un
risposta HTTP osservabile è possibile flatmap
finita e tornerò un po ‘di più
in seguito a ciò che la mappa piatta ti fa cosa
questo fondamentalmente sta dicendo è quando io
ricevere indietro questa risposta che poi voglio
fare sempre una logica annidata su di essa
in modo sincrono e dentro quello allora io
voglio dire che voglio da quella risposta
Voglio ottenere il contenuto in modo che
oggetto di risposta in quel punto contiene
è il modo in cui funziona HTTP è restituisce
tornare indietro come l’informazione di intestazione vedere
il codice di stato le intestazioni e quelle
cose e poi puoi iniziare a consumare
il resto dei dati e così questo
Risposta in due fasi Sono in grado di convalidare
lo stato e quelle cose e poi
Posso ottenere questa risposta che contiene un
osservabile di un array di byte e in questo
caso voglio solo mappare su a
trasformalo in una stringa, se lo fosse
dati che vorresti lasciare il suo array di byte
fai ciò che desideri e poi
sarebbe in questo passo che potresti
quindi esegui la tua trasformazione JSON ecc
quando ti iscrivi è quando
in realtà fa il lavoro e così tutto
nella nostra X è pigro, fa tutto solo
dichiarativo fino al punto che a
abbonamento si verifica quindi è il
equivalente a te connetti tutto il
tubi e poi si accende l’acqua a
la fine
e così una volta tutto è connesso allora
accendi il flusso e poi tutto
succede a quel punto e di cosa si tratta
emetterebbe quindi in modo asincrono
riceverebbe appena la risposta dal
in questo caso Wikipedia
ora solo per permettere di scoppiare da un
mondo asincrono a volte hai bisogno di rompere
fuori di esso
c’è questa capacità di tornare indietro
in un osservabile bloccante che poi
espone un sacco di operatori di blocco tali
come per ogni questo è utile per se siete
semplicemente facendo una piccola app o unità demo
test e questi tipi di cose
ora quello non era molto di più
interessante di un tipico client asincrono
questo è un po ‘ più interessante
se capovolgo questo da Wikipedia a in
questo caso è un prodotto è un altro
libreria open source che usiamo Netflix I
per tolleranza ai guasti ma questo particolare
cosa è un flusso di dati il
metriche che escono da ognuno dei nostri
server e quindi utilizza l’ html5
server inviato di tali eventi indietro e quando
si collega a questa connessione HTTP è
rimarrà in vita fino a quando manterrai
si apre e emette solo costantemente
eventi bene ora cosa farà
perché i vettori di supporto osservabili
di dati questo ora sarà davvero giusto
iniziare emettendo ogni singolo evento che
scende il filo che emetterà come un
evento osservabile e così sarà solo
continua a chiamare il prossimo quindi in questo caso io
voglio filtrare i ping nel noi
invia questi ping giù ogni 15
secondi fa parte della salute della rete
roba e quindi in questo caso puoi applicare
un operatore per filtrare quelli fuori e poi
diciamo che io sono solo fuori Voglio solo
per avere un campione di quello che sta succedendo
potrebbe prendere 30 di loro e poi
disconnetti e questo è un esempio di come
la stessa interfaccia ora l’ ho appena usata
per una risposta scalare in cui il
La pagina di Wikipedia restituisce una singola risposta
indietro o posso consumare da un flusso di
dati e continuerà a emettere il
i risultati quando arrivano voglio
ora vai in un caso d’uso più complicato
che è questo il caso dell’uso che
in realtà ha guidato la nostra adozione di
programmazione reattiva funzionale questo è
è una versione semplificata di ciò che facciamo
rendiamo l’interfaccia utente che ha la griglia di
film su di esso e che coinvolge un sacco di
comportamento annidato e molto diverso
Le chiamate di rete per renderlo e così il
il diagramma di marmo è un po ‘di più
complicato e il modo in cui inizia è
in cima la prima cosa che noi
farebbe dopo aver ottenuto tutto il tuo
le credenziali dell’utente e tutte quelle cose lo sono
chiediamo al servizio video per un elenco di
film c’è in realtà un livello sopra
questo ancora dove si ottiene la griglia di
prima i film e poi inizi una volta
torna indietro nella griglia e poi vai su ciascuno di essi
elenco per semplicità e solo per un singolo
elenco a questo punto e quindi questo video
servizio lo prendi e questo sta andando
per restituire un osservabile la prossima cosa
Facciamo è diciamo che siamo su un
interfaccia utente più piccola e in realtà solo noi
voglio prendere dieci non il 50 o il 75 o
cento che possono esistere in fila e così
vogliamo prendere dieci bene cosa c’è
sta accadendo quando quell’operatore si innesca
che dietro le quinte questo è pigramente
emettere i dati e poi prendere
operatore una volta che colpisce il decimo elemento
cancellerà dal
quello precedente e quindi l’annullamento dell’iscrizione
evento sarà poi propagarsi il
sequenza asincrona e dire al
genitore nella catena per smettere di lavorare e
allora questo e se questo è comunque molti
livelli profondi è questo si propaga e così
che cosa questo significherebbe è che se tu fossi
continuamente facendo attività di rete
dietro le quinte potresti fermarti
quella attività di rete e quindi è solo
facendo il lavoro fino al punto che tu
in realtà ne ha bisogno pigramente piuttosto che
cercando impazientemente tutto ora
l’implementazione potrebbe aver recuperato tutto
in gruppo potrebbe aver già recuperato 100
di loro in una chiamata di rete in quel caso
tutto quello che hai intenzione di fare è andare
per fermare l’ iterazione in memoria ma il
il principio è che lo emette sempre
porta l’annullamento dell’iscrizione fino in fondo
per consentire la pulizia delle risorse e il
la pigra esecuzione del lavoro e poi
è la scelta delle implementazioni da fare
cosa lavoro sto facendo che in realtà ha bisogno
essere ripulito quando lo ricevo
i dati su cui poi voglio mapparlo
trasformarlo così che cosa mappa fa è
trasforma
scrivi T per digitare R così da farmi fare
qualunque cosa io voglia lì dentro
manipolare i miei dati comunque stiamo andando
fare qualcosa condizione annidata e così
useremo la mappa piatta invece è
noto anche come mappa molti o in dotnet
mondo selezionare molti abbiamo adottato la mappa piana
come convenzione di denominazione sulla JVM da allora
questo è più comune nel mondo di Java e
in realtà è più descrittivo di noi a
quello che sta facendo è che la mappa piana è fondamentalmente
quello che è è la stessa cosa della mappa
tranne che stai restituendo un
osservabile di R anziché di R e quindi di te
potrebbe pensarlo come una mappa che ritorna
le sequenze e quindi la mappa piatta è giusta
unendoli insieme quindi è il
equivalente di fare una mappa e poi
emergere e così finisci con se è
emettendo queste sequenze si fonde semplicemente
loro in una sequenza altrimenti tu
otterrebbe una sequenza di sequenze che
a volte vuoi ma generalmente o no
e quindi cosa facciamo?
in questa mappa piatta è che stiamo andando ora
ricevere 10 chiamate di questo per ciascuno di
gli oggetti video saranno
emesso possiamo ricevere 10 oggetti video
per ognuno di quei 10 vogliamo poi fare
una logica nidificata e quindi la prima
vogliamo fare è vogliamo andare a prendere un po ‘
metadati per quel video e così andiamo
fuori e prendi quello e vogliamo anche farlo
recuperare segnalibri e valutazioni ci sono
altri li recuperiamo ma questi sono tre
molto comuni e ognuno di questi tre
le cose saranno fatte
in modo asincrono possono o non possono
risultato in chiamate di rete e tutti questi
stanno tornando osservabili quindi sono tutti
async e poi vogliamo su di loro
trasformali in alcuni dati che sono
pronto per essere consegnato al nostro cliente e
quindi di nuovo ci mappiamo sopra e in questo caso
lo stiamo trasformando altrettanto bene
semplice dizionario di coppie di valori chiave e
vogliamo farlo per ognuno di loro e
così dentro quella mappa molti o piatta noi
verrà quindi condannata scusa lo faremo allora
in modo annidato prendi i metadati
e mappare e fare la stessa cosa per
i segnalibri e le valutazioni sono davvero schizzinosi
tutto questo sullo schermo e così abbiamo
ottenuto il segnalibro e il punteggio dei metadati
quello che abbiamo appena definito ci sono tre
sequenze osservabili tutto ciò che abbiamo fatto è
dichiarali che li abbiamo dichiarati
sequenze con trasformazioni di mappe
e se dovessimo eseguire il codice come
questo proprio ora non lo farebbero mai
vengono eseguiti perché sono dichiarati
ma in realtà mai abbonarsi e così via
loro perché è tutto pigro vorrei correre
questo e io in realtà non tralasciare nulla
sarebbe come la mia applicazione ha fatto
niente farei la rete iniziale
chiama per ottenere i video che emetterebbe il
video in questo e poi sarebbe solo
un po ‘come restituire i dati vuoti, quindi ho bisogno
iscriversi a loro in un modo che
li combina insieme e quindi voglio
chiudili insieme e tu potresti farlo
a c’è altro ci sono varianti che
potresti fare un’unione con una lista
e cose del genere ma funziona molto
bene in questo caso e quindi voglio zip
l’mbnr perché voglio averli
insieme in un posto e la funzione
che mi rivolgo a questo
quei tre e mi dispiace e lo farà
combinarli insieme in un singolo
dizionario e quindi di nuovo quello che zip è
facendo sta prendendo quei valori di input
e l’applicazione di una funzione e ho intenzione di
Potrei restituirli come una tupla ma cosa
In realtà voglio fare qui è voglio
trasformali in un dizionario questo è
la sintassi groovy per il primo è il
mappa letterale quindi sto creando un dizionario
che contiene solo l’ID della chiave e poi
l’ID del video e poi i tre off
al lato di esso sono solo essere
concatenato in esso quindi è molto molto
rappresentazione concisa di concatenazione
tre dizionari in un nuovo creato
uno così quello che esco in fondo
questo ora ho intenzione di tornare un
mappa o dizionario osservabile e quello
l’operatore di chiusura lampo è l’ultimo pezzo di questo
dichiarazione su come voglio consumare
un elenco di video trasformati in manipolazione
fa logica annidata per andare davvero e
prendere altre chiamate di rete e altro
fuori dal fondo voglio solo emettere un
dizionario dei dati per ciascuno dei miei video
e quello che uscire da quella a ciascuno
di quei dieci video che ora otterrò
dizionario che assomiglia a quello in cui io
avere valori chiave combinati dai tre
chiamate di rete nidificate e il genitore
La rete ha chiamato V ID ovviamente nel
vero nella vita reale, questo è molto
dizionario più grande
e ciò che questo ciò che questo tutti gli spettacoli è
che tutte le interazioni con il
API sono stati trattati come se lo fossero
asincrono e tutto è stato fatto in modo pigro
modo dichiarativo e tutti i dettagli
per quello che succede dietro le quinte
sono controllati dall’API e quindi in
il nostro ambiente di produzione tutto intero
processo sarebbe risultato in tre
Chiamate di rete anche se potrebbe essere
fatto in modo efficiente con 3131 Network
chiama se dovessimo farlo nell’ingenuo
modo e così i metadati sono sempre tirati
dalla cache in memoria perché è così
attivo abbiamo che tutto il cache del
segnalibri e valutazioni li collassiamo
in chiamate a lotti singoli dietro il
le scene e la lista dei video sono tutte tirate
anche in gruppo, ma quelli
i dettagli di implementazione sono completamente in aumento
a noi scegliere come fare e siamo in grado di
cambialo senza mai influenzarlo
che aspetto ha l’API perché è tutto
fatto in un dichiarativo asincrono
modo così come guardiamo indietro sul nostro
architettura che sentiamo di avere
raggiunto con successo ciò a cui miriamo
cosa è la realtà della nostra struttura
della nostra architettura è ora che è il
varie squadre di UI effettivamente costruiscono le loro
proprio endpoint i loro servizi web e
distribuirli sopra di noi in produzione
il team API di Netflix è uscito
di attività di costruzione di servizi web e
ora costruiamo e gestiamo solo il
piattaforma su cui tutti i vari
i team di Netflix costruiscono la propria rete
servizi su di noi e sono in grado
per distribuirli dinamicamente nel prod ito
dura circa 30 secondi dal momento in cui
distribuirlo per propagare in tutto il nostro
flotta di centinaia di server e loro
può rivoltare e fare qualsiasi cosa
desidero con esso e tutto il codice a
quel livello è tutto fatto usando rx
programmazione reattiva dallo stile funzionale
al di sotto usiamo hystrix per tutti i nostri
intestazione back-end di massa del nostro sottostante
sistemi e ci è piaciuto il modello reattivo
così tanto che abbiamo recentemente
isterici riadattati per essere non bloccanti
dall’inizio alla fine
ed esposti meccanismi osservabili per
interagendo con esso e nel tempo siamo
vedendo l’approccio di questo reattivo
stile spingendo sempre più in profondità nel nostro
impilare in modo che ci stiamo avvicinando e
più vicino al punto ora che quando un
richiesta in arrivo viene nel
Dichiarazione di tutto il lavoro in realtà
quindi si connette a un livello successivo di
tutte le sequenze osservabili e superiore a
in fondo alla chiamata dalla rete in arrivo
alla rete sottostante chiama il
l’altro lato e poi indietro è uno solo
dichiarazione reattiva e quindi ci sentiamo
piuttosto bene su come l’osservabile
le API hanno funzionato e penso che il
parte più interessante di questo alcuni di
le lezioni apprese sono lo sviluppatore
la formazione era una chiave abbastanza grande per noi in
adottandolo così quando sono stato coinvolto
il design originale e l’architettura di
questo di questo nuovo approccio per la nostra API
piattaforma e mi ci è voluto un po ‘per
brontolare le idee e ci sono voluti un sacco di
spargimento di pregiudizi e disimparamento di
approcci che erano solo lo status quo
e una volta un gruppo centrale di noi avrebbe capito
che fuori e abbastanza iterato ci ha portato
un paio di mesi per sentirsi davvero convinto
che ne abbiamo avuto il livello successivo
il lavoro con gli sviluppatori è stato il prossimo
parte difficile di prendere gli sviluppatori che hanno
10 15 20 anni di radicata solo
pensando a come implementare
un codice come questo e quindi quello che abbiamo trovato è
che la prima coppia di sviluppatori ha preso
un mese quattro a sei-otto settimane per
loro per essere veramente all’altezza
pensavo davvero così e così è stato
i primi due mesi come fase alfa di
dopo ciò abbiamo scoperto che ci volevano circa due
settimane per ogni determinato sviluppatore
oltre quell’ostacolo di brontolii e
borbottando e lamentandosi e davvero
chiedendosi perché mai erano
ha chiesto di fare la programmazione in stile funzionale
– uscendo dall’altra parte andando a prendere
non voglio tornare indietro all’altro
modo e per facilitare ciò che noi
effettivamente assunto uno scrittore tecnico per
entra e scrivi documentazione per questo
ed è stata una delle migliori decisioni che abbiamo
ha reso alcuni dei migliori interni
documentazione che abbia mai visto in a
azienda
perché riconosciamo che questo non dovrebbe
solo alcuni ingegneri stanno solo cercando di farlo
come buttare qualcosa in un wiki ma noi
in realtà ha portato qualcuno in realtà
aiuta a scrivere e questo è stato un grande
affare e poi facciamo anche solo interni
formazione per i nuovi sviluppatori in arrivo
consiglio di amministrazione e questo non è solo un gruppo di
come 10 o 15 persone perché questo è tutto
le diverse squadre dell’interfaccia utente che vogliono
supportare i loro dispositivi e così è
Ingegneri JavaScript e c-sharp
chiusura ingegneri e ingegneri Java
Scala groovy tutte queste persone diverse
da diversi background che sono tutti
potenzialmente creando servizi web per
i loro dispositivi su cui stiamo lavorando
questa la prossima cosa è che il debugging
e la traccia di async è sicuramente
diverso
impostare un punto di interruzione è solo diverso
in codice asincrono quali sono i migliori
cose che non rx se è sedersi in
la produzione che non puoi fare è questa
quasi con la stessa facilità, ma quando il vostro sono in
il tuo IDE rx supporta l’idea di virtuale
scheduler o test schedulers che cosa
rimuove tutta la concorrenza e puoi farlo
incrementare il tempo artificialmente e così via
rende davvero molto il test unitario
efficace e in modo da poter avere
approcci deterministici al pensiero
attraverso le sequenze di dati e
incrementare il tempo come ci si aspetta e poi
eseguendo le asserzioni c’è
sicuramente lavorerò ancora per questo
spazio e stiamo cercando di avere un
console simile a ciò che Chrome ha per
visualizzare eventi asincroni nel tempo
ma essere in grado di gestirlo contro il nostro
server e quella roba che siamo
esplorare oggi l’unica regola che abbiamo
dovevo davvero far rispettare la gente
finisce per auto-rafforzarsi alla fine una sola volta
hai segnato il dito del piede abbastanza volte ma
è perché siamo sulla JVM e sul
la maggior parte delle lingue li utilizzava
non far rispettare questo è non farlo
lo stato di mutante al di fuori di te generalmente
non muta lo stato ma se stai andando
per mutarlo, mutalo dentro il tuo
funzione e questo è tutto ciò che vuoi fare
dentro una specie di cosa imperativa
stiamo bene ma entro le barriere di a
funziona fintanto che le persone si attengono a quello
tutta la concorrenza e il parallelismo giusto
si prende cura di se stesso
e questo in realtà si adatta bene ad alcuni di
le altre presentazioni precedenti oggi
che lo stato mutabile è molto cattivo
cosa quando inizi a entrare in questi
sistemi altamente concomitanti e così in a
in poche parole questa combinazione di funzionale
stile e reattivo asincrono
l’elaborazione ha dimostrato di essere in un molto
approccio efficace per noi nella gestione
sistemi ad alto volume su larga scala dove noi
ha un sacco di logica condizionale annidata
ed è molto guidato dalla rete e c’è
molto di più di ciò che è stato scritto
questo ed i progetti open source che
sono disponibili abbiamo avuto circa
abbiamo più di 30 collaboratori finora
il nostro X Java rxjs non sono direttamente
coinvolto ma lo usiamo molto a
Netflix e adoro avere il tuo
coinvolgimento nel progetto, se lo sei
interessato a questa roba o solo a te
può andare e solo imparare di più sul
approccio anche se non lo usi
biblioteca particolare c’è un sacco di
approcci diversi per funzionale e
stili reattivi e se non altro
ti raccomanderei di imparare il
idee, perché penso che troverete che
cambia davvero le tue abitudini di codifica
per il meglio grazie
la risposta breve è stata quella
in realtà non è stato un grosso problema come
quello che prima pensavamo di testare l’unità
allo stesso modo di qualsiasi altro codice al
Alla fine della giornata è solo il codice e questo
in realtà finisce per essere più semplice per il
le stesse ragioni per cui le presentazioni precedenti
da boat’ll e altri dove una volta
iniziare a rimuovere tutto lo stato mutabile e
hanno queste sequenze di
trasformazioni in realtà diventa molto
facile da leggere e capire e
allora diventa semplicemente una codifica normale
pratica se hai solo una grande palla di
codice che è come 20 trasformazioni tutte
in uno poi diventa un po ‘più difficile
prova se usi buone pratiche di codifica
e spezzali in funzioni e tu
prova ogni funzione in modo indipendente e fallo
normale buona codifica è lo stesso
concetti l’unica cosa reale è che se
stai usando operatori che di
esigenze di definizione o una sorta di
concurrency come windowing o buffering
quelli iniziano a coinvolgere elementi del tempo e
allora è lì che la capacità di passare
tutte queste decisioni sono astratte
scheduler nella nostra X e quindi puoi
il tuo test unitario ha utilizzato gli scheduler di test
che poi ti permettono di rimuovere tutto il
concurrency reale e quindi è possibile
incrementa o sposta il tempo in cui ti trovi
voglio affermare a quel punto e permette
a ragionare sul tempo senza tutto il
non determinismo degli scheduler dei thread a
un po ‘di più sul parallelismo e
ossessiona parallelismo e osservabili così
da ciascuna sequenza osservabile il
contratto è che non entrerà in congedo
una qualsiasi delle prossime chiamate e così via
questo è il contratto che ti dà
ma poi ti permette di farlo se tu
unire per esempio più osservabili
si iscriverà a tutti loro
parallelamente c’è anche il parallelo
operatori molto simili a come il
flusso parallelo in Java otto o
mappa di coppie parallele e ogni lingua ha
qualche variazione di esso in modo si può dire che
esplicitamente che va bene andare in parallelo
all’interno di una sequenza osservabile e il
gli scheduler ti consentono di accedere al thread
piscine o
sempre tu puoi scegliere così i sordi di
definizione perché stai usando un
stile funzionale senza mutevolezza
sei in grado di essere molto libero circa
eseguire le cose in parallelo e usando
la piena capacità del numero di core
nella tua macchina di default se solo
non pensarci nemmeno se lo farà
appena generalmente fare la cosa giusta su
a tuo nome e verrà comunque utilizzato
molti core attorno alla Macchina correttamente
possiamo usarlo su Android sì, lo è
codificato in Java sei standard che funzionano
su così stiamo mantenendo a quel livello
specificamente così funziona su Android
ovviamente non hai le sottigliezze di
lambda ma ce ne sono alcuni abbastanza grandi
nomi come SoundCloud che stanno usando
questo in produzione sulla loro app su questo
su Android e ne hanno scritti alcuni
davvero ottimi articoli su di esso e fatto
alcune presentazioni su di esso, se si voleva
per cercare solo la ricerca
SoundCloud rx Java e io sappiamo che c’è
alcuni altri in qualche altro abbastanza grande
aziende che non penso siano in
produzione ancora ma sono un po ‘
seguendo la guida di ciò che SoundCloud è
fatto su Android ok , non capisco
questa domanda, ma come creeresti un?
Staffa uccello una staffa di uccello Yep buona
domanda che mi hai preso, vieni a parlare con me
dopo penso che porteremo il
domande per chiudere e questo è stato
ancora
tu
Please follow and like us: