quindi il mio nome è Christopher Michael John
come Katie ha detto che sono uno studente di dottorato in a
università un catalizzatore in cui vivo
Belgio, noi non siamo nella parte francese
non la parte olandese e quindi sì
penso che questa sarà una ricerca
parla così basta andare su se non fosse così
chiaro dal programma e quindi penso di essere io
con successo ha ingannato tutti
venire a vedere una cose interne parlano
quello che stiamo davvero andando a parlare è di circa
sistemi distribuiti e quindi quando dico
l’Internet delle cose che conosci
Internet of Things è come una specie di
parola d’ordine che usiamo per riferirsi al tipo di
una classe di applicazioni in cui abbiamo
un mucchio di sensori simili e corriamo
elaborare su di loro con cose come
mirare a lamelle AWS e cose del genere ma
più in generale di cosa voglio parlare
ecco l’ idea del calcolo dei bordi
perché questo tipo di anticipa questo
precede molte Internet-of-things
lavoro da un bel po ‘e quindi cosa intendo
per calcolo del margine ci stiamo riferendo
al processo di tipo di spinta
sia il calcolo che i dati
calcoliamo agli estremi logici di
funziona così stiamo parlando di dispositivi
che stanno generando i dati che vogliamo
eseguire l’elaborazione ai dispositivi tanto
possibile e quindi questo potrebbe essere mobile
dispositivi questo potrebbe essere sensori questo potrebbe
essere tutto punti di dati di presenza
centri sai che sono tutti in una certa misura
del bordo e se venite dalla
mondo in rete sai che significa il bordo
una cosa piuttosto diversa dal tipo di
cosa pensiamo di oggi quando è
tipo di inquadrato in termini di networking
e così quando dico il calcolo cosa faccio
significare
Intendo calcolo arbitrario come qualsiasi
programma che scrivo e vado sul mio
computer dovrei essere con i dati sul mio
computer dovrei essere in grado di tipo di
spingere quel tipo di calcolo al limite
giusto così vorremmo che fosse arbitrario
bene vedere perché è difficile da fare
Pratica e finalmente voglio parlare
su ciò che veramente uno di questi
è interessante il calcolo dei bordi
ha una lunga storia e in una sorta di
auto-organizzato
sistemi auto-organizzanti e resilienti
e quindi se hai familiarità con questo lavoro
questa fusione viene diretta o digerita
dalla Cornell University negli anni ’90 e
si tratta di tipo di auto-organizzazione
sistemi che possono calcolare una sorta di
risultato insieme in un molto resistente
modo e quindi mi piace molto questo lavoro se
mi segui su Twitter sai che io
assolutamente amore come la storia del computer
e cose del genere e così questi documenti
sono interessanti da leggere perché questo
il lavoro era originariamente incorniciato sotto
DARPA concede a Cornell’s a Systems
Gruppo e l’idea era che tu lo sapessi
avevano a che fare con le reti di sensori
negli anni ’90 volevano essere in grado di
prendere un aereo e farlo volare sopra a
campo di battaglia ostile o un’area che loro
non potevo entrare in un sacco di
i sensori fuori da un dorso di un aeroplano
alcuni di loro hanno colpito il terreno alcuni di loro
vorrà continuare a lavorare, alcuni di loro lo faranno
break si auto-organizzeranno in a
sistema distribuito utilizzando un ad hoc
rete wireless e poi lo faranno
calcolare una sorta di risultato sul campo
e quindi questo è un caso piuttosto estremo di
edge computing è qualcosa che non facciamo
pensa a quando stiamo cercando di farlo
sai monitorare la temperatura di te
sapere se il tuo termostato nido al tuo
A casa , è molto meno sicuro
ambiente aggressivo e così c’è
c’è una buona quantità di storia qui
ed è una lettura molto interessante se tu
come questo tipo di lavoro quindi per ottenere un
un po ‘più pratico stiamo andando
parlare di un esempio su ospedale
frigoriferi e tanti colleghi di
il mio è andato a fondare un’azienda che è
facendo esattamente questo così ho passato
un bel po ‘di tempo a pensare al
problema e tipo di esplorazione
modi alternativi di risolverlo e così via
quello che stiamo per immaginare qui è quello
abbiamo un gruppo di ospedali
frigoriferi Ho questi sensori
I sensori stanno per innescare tipo di
avvisi sulla temperatura se
è per riscaldare a freddo e forse vogliamo
innescare comportamenti basati su quelli
eventi e così tipo di riferimento IOT
architettura che questo tipo di sguardo
a oggi e Peter sta per parlare
su uno alternativo dopo questo
che abbiamo un sacco di cose e noi
metterli su internet che è il
punto di partenza per arrivare dove è necessario
essere e e quello che vorremmo fare è quello
queste cose vorrebbero generare
eventi che stanno per generare campioni
e forse lo mettiamo in qualcosa di simile
Hadoop ha distribuito il file system qui e
allora sai se sarebbe stato il 2007
davvero invocato per utilizzare Hadoop per l’esecuzione
lavori batch su questo tipo di dati
produrre alcuni risultati e poi e
innescare una sorta di cosa ma ma abbiamo
spostato dal 2007 e così forse ora noi
usa qualcosa come scintilla o Kafka che
è stato accennato in precedenza
e così in questo modello vorremmo tipo
elaborare quegli eventi così come sono
accadendo in tempo reale e reagire a
quegli eventi mentre accadono, così possiamo
immagina un’esecuzione ideale con questo
tipo di topologia questo riferimento
l’architettura che ho progettato sarebbe
assomiglia a qualcosa così generiamo
alcuni semplici diciamo temperature bene noi
inviarlo al centro dati e ai dati
il centro non fa nulla ora quando generiamo
un esempio che dice che c’è un problema e
lo trasmettiamo al centro dati
di solito qualcuno viene chiamato da un telefono
o forse questa è la versione moderna
di voi conoscete un sistema di paging come pagina o
dovere o qualcosa di simile a destra e così
questa è la situazione ideale che vogliamo
qualcuno riceve una chiamata e tutte le cose dentro
il frigorifero non va male e quindi se
vogliamo iniziare a fare dei buchi
questo potremmo dire bene intendo il primo
il problema è l’ idea della connettività
tutti viviamo in rete con te
sappi che usi quello che sai che ottieni
partizionato tutto il tempo come abbiamo visto
da molti discorsi prima di oggi e e
per questo mi imbatto in questo
situazione in cui se generano un cattivo
campione e la mia connessione a internet
capita di essere giù e non riesco a trasmettere
quello di nuovo al centro dati allora io tutti
Ho tutto ciò che posso fare è tamponarli
eventi e quindi se bufferizzo questi eventi
Questo va bene questi dispositivi hanno di solito
abbastanza per tamponare gli eventi ma questo
non aiuta nulla nel
frigorifero giusto e quindi questo è gentile
di questo è un tipo non desiderabile ma
ma qualcosa con cui ci occupiamo noi
affrontare tutto il tempo e il tipo di questi
IOT sistemi che noi che tipo di
distribuire qui e quindi cosa succede se non riesco a ottenere
i miei eventi su Amazon IOT o sul mio Amazon
servizio in esecuzione su lambda o qualcosa del genere
così e così gentile della prima cosa
che potremmo fare qui è che potremmo
esplorare la nozione di fare locale
decisioni e quindi se pensiamo a cosa
significa prendere una decisione locale e
sai che abbiamo il nostro evento
generato come un sensore è trasmesso
a Hadoop non succede nulla di tutto
bene se generiamo un brutto evento se noi
hanno la capacità di agire per
eseguire le decisioni locali quindi potremmo
basta attivare la chiamata dal dispositivo
giusto e quindi è costoso, ovviamente
perché hai bisogno di un po ‘di backup
hardware ma c’è un presidente per questo
una delle aziende che così PG & E per
l’istanza non può inviare non può inviare electro
segnale elettromeccanico
per un paragrafo che è sovraccarico
perché le griglie di energia sono sovraccaricate correttamente
quindi questo è un tipo di problema che conosci
negli anni ’80 e ’90 quindi se sei dentro
forse la tua fine degli anni ’30 o 40s
ricordati che sai che è stato molto
comune avere una comunicazione di backup
meccanismi per cose come il tè freddo
linee e tè per i quali ho effettivamente lavorato
una telecom che ha fatto questo per la fedeltà così
avrebbero un sistema di backup per
canalizzazione out-of-band quando quando quando
le cose andrebbero giù se tu fossi in te
sapere nel mondo dell’informatica in
gli anni ’90 che conosci alla fine degli anni ’90
primi anni 2000 quando EMC introdusse il peccato
e poi come dispositivi Nazz avrebbero avuto un
modem collegato a loro con un telefono
linea e quando un disco stava generando crc
aree con cui in realtà piacerebbe chiamare
il modem per EMC e dire hey questo guida
per morire e poi sai il prossimo
mattina presso l’ufficio di EMC ragazzo sarebbe
bussare alla porta di avere un backup
camion e quindi questa idea di locale
le decisioni non sono qualcosa che è quello
un po ‘di nuovo abbiamo esplorato questo prima
e quindi l’utilizzo delle decisioni locali per tipo
di costruire un’applicazione è davvero
costoso perché richiede un sacco di
hardware aggiuntivo e quindi forse un
alternativa che potremmo esplorare è
questa idea di diffusione transitiva
e così in questa idea potremmo dire bene
forse ho questo campione che va bene è
va bene la connessione internet va giù
e ora genero il campione cattivo ma
Sono connesso tramite un altro wireless
protocollo per apparire e quel peer può
innescare può inviare gli eventi sul suo
per conto e così dovrebbe essere questo modello
molto familiare a chiunque sia usato
qualcosa come una trasmissione epidemica
protocollo che cerca di fare affidamento su
ti danno molto alta probabilità
garanzie sulla consegna dei messaggi ma
non garantisce che funzionerà
correttamente e quindi ovviamente lo sai
queste epidemie per i protocolli di trasmissione
sono stati studiati per un po ‘e il
problema che puoi banalmente vedere qui
è che si sa per conseguire un livello elevato
probabilità nelle emissioni della rete di massa a
portati al 100% che potenzialmente devi
invia questo in ogni singolo percorso
sapere e ci sono interi gruppi di
ricercatori che stanno lavorando per provare
per rendere questo problema più efficiente e
quindi allora ti si alternano
inoltre hanno il problema di bene se
Ricevo tutte queste copie sui dati
centro come faccio a sapere quali sono dati
che i messaggi possono andare fuori ordine come fanno
So quali sono i più
aggiornati quali sono stantii e
so quali sono duplicati ok?
e quindi finalmente potremmo vedere a
modello in cui inviamo semplicemente lo stato
giusto così piuttosto che generare un evento
flusso e cercando di garantire che noi
consegnare con altissima probabilità
all’interno di una sorta di quantità limitata di
il tempo dissemina tutti gli eventi
forse invece diffondiamo semplicemente lo stato
e quindi uno stato mutevole che descrive
lo stato del sistema e così in questo
caso possiamo immaginarlo con questo
frigorifero qui che cos’è il cerchio rosso
è problematico ma questi due vanno bene
possono diffondere questo stato
e costruire una sorta di stato complessivo di
il sistema e in questo modello ci conosci
abbiamo anche una sfida di
assicurando che con il fuori servizio
consegna tutto può sembrare il
così abbiamo un problema di equivalenza
qui e inoltre abbiamo anche questo
bel vantaggio aggiunto che nessuno dei nodi
nel sistema può fare il telefono
chiama per dire che qualcosa è sbagliato e
quindi non parlerò dell’idea
di come ci assicuriamo di averne uno solo
telefonata
perché questo è un problema di
sincronizzazione e farò un po ‘di giusto
lascia questo esercizio al lettore così io
parlato di molte cose e e
tipo di quello che sto cercando di fare è prenderti
pensare all’idea del locale
calcolo e sto cercando di arrivare a
tipo di sfida del riferimento
architettura e pensare in modo più critico
sulle applicazioni che sei
costruzione e quindi c’è una sorta di due principali
indica che mi piacerebbe guidare
a casa qui il primo è sai se
non si genera semplicemente un infinito
flusso di eventi che modellano ogni singolo
cambiamento nel sistema e tipo di lavoro
con uno stato mutevole o aggregato
quindi puoi ridurre la trasmissione di stato
e questo è molto importante perché molto
di dispositivi mobili e sensori e cose
come questo
operare con batteria molto bassa molto
poca batteria e l’antenna è uno dei
i componenti più costosi in
sistema per guidare la seconda cosa che
Ti sto prendendo Sto cercando di attraversare
è che l’idea di fare locale
decisioni se possiamo basare una decisione se
possiamo agire sul dispositivo che possiamo
avere un sistema che è in un certo senso più
vivo può essere più resistente a
fallimenti può prendere azioni e noi
non imbattersi in questa situazione dove se
conosci un sacco dei nostri dispositivi
che stanno facendo qualcosa sono
disconnesso dalla rete dove
dove non puoi fare niente okay tutto
giusto e così se voglio parlare
replicato lo stato condiviso di quello che mi serve
fare è un po ‘parlare di coerenza
e quindi probabilmente hai sentito un mucchio
su questo oggi già e combatti
sentito parlare di questo in passato e
quindi che tipo di brevemente fare un veloce
panoramica del tipo di idee di
coerenza dei dati replicati e così via
il tipo della prima nozione che faremo
parlare di coerenza è forte e così
se pensiamo a questo il singolo sistema
immagine quindi se pensiamo a un database
che vogliamo avere qualche tipo di totale
ordine degli eventi se ho un dato
elemento qui rappresentato da questo cerchio e
Ho due clienti che leggono quell’elemento di dati
contemporaneamente ora se c1 va a modificare
quell’elemento di dati e scriverlo al
storia usando un’operazione di confronto e scambio
questo succederà in questo
tipo di singoli database prima replica
sarà aggiornato ora il problema che tu
è qui che se c2 va a destra
e dire mentre leggo questo cerchio verde
Ho intenzione di scrivere questo triangolo rosso
questa operazione corretta fallirà
perché sta tentando di farlo
confronta e scambia e il valore ha
cambiato da già e così questi
sono una specie di questo ci dà questo tipo di
ordine totale sugli eventi e le cose
tipo di cambiamento in lockstep si legge solo
loro ragione e quindi questo è una specie di a
cosa standard che vediamo nello stesso tipo
di sistemi fortemente coerenti come
qualcosa come una console è così
sostenuto da qualcosa come zatterare la zattera
protocollo di consenso e così sai che sono
non andando a diagramma di Paxos ma vado
per schematelo quel tanto che basta per mostrarti
che se hai più repliche se
hai più copie dei tuoi dati
oggetti diventa molto più costoso
per fare quelle garanzie ci vuole molto
di tempo per ottenere tutti questi nodi
d’accordo su un ordine non importa il loro
requisito che questi nodi devono essere
online e stiamo specificamente parlando
sui sistemi oggi che vogliamo
operare mentre i sistemi sono offline così
tipo di sul lato opposto del
spettro abbiamo una nozione di finale
coerenza che tipo di diventato
popolare lentamente nel tempo e tipo di
è esploso dentro per assottigliare il tipo di
metà degli anni 2000 in una sorta di alla fine
sistema coerente abbiamo più
repliche
sai che puoi leggere i clienti
e la lettura di questi valori dal
database e poi se ne hai due
diritti simultanei in modo che il cliente uno scriva
questo Blue Square e poi il client due
scrive questo triangolo rosso, non possiamo
determinare quale è venuto prima e così noi
Devo tipo di assumere che entrambi i diritti
sono concomitanti e quindi questo è molto
simile a un sistema su cui ho lavorato
reagire e quindi in questo caso ciò che abbiamo
fare è avere un arbitro il prossimo lettore
decidere quale dovrebbe essere il valore
dovrebbe unire questi valori e quindi scrivere
torna all’archivio dati dist aggiornato
valore e quindi idealmente la cosa che
si desidera eseguire questa operazione di scrittura
per risolvere idealmente questi conflitti
voglio che questo sia un tipo deterministico di
il caso più banale si può avere di
questo è qualcosa di simile allo scorso vincitore dello scrittore
con cui basta inserire un timestamp
tutto e prende quello che è
deterministico per un insieme di eventi ma
ma questo non necessariamente modella il
modo in cui vogliamo che il sistema funzioni perché
è difficile ragionare sul tipo di cosa
gli aggiornamenti vinceranno perché non lo sai
quando le cose verranno consegnate
okay e quindi cosa voglio che la gente pensi
è quel tipo di coerenza finale è
è una specie di modello di cui stiamo parlando
qui vogliamo pensare a questi dispositivi
come generare un proprio tipo di dati
possedere le copie dei dati che
generano e quindi possiamo pensare
questi tre quadrati sono una specie di
eventi che vengono generati e noi
voglio tipo di condividere quegli eventi con
altri membri del sistema in un
modo peer-to-peer possediamo i nostri dati noi
calcolare con i nostri dati e noi vogliamo
avere la capacità di questi questi dati
articoli indipendentemente dall’ordine di consegna
andando a risolvere lo stesso valore
inoltre quando pensiamo al
i risultati dei calcoli ci piacciono
vogliono due proprietà qui, quindi vogliamo
proprietà di unire le capacità e vogliamo
la proprietà di questi calcoli
monitoraggio Provvidenza e e me ne vado
attraverso un esempio di ciò che intendo
che e così se immaginiamo che abbiamo un
frigorifero che ha eventi di scena in
il sistema a e C e un altro
frigorifero che ha visto lo stesso evento
ma un diverso evento B ora se noi
distribuire alcuni calcoli arbitrari F
a queste note e F è calcolato con a
e C e F sono anche calcolati con un e
B
quindi il risultato di questo calcolo
rappresentato da un D Prime e D doppio
primo qui dovrebbe tipo di tracciare il
input che provenivano da quel calcolo
questo è ciò che intendo per Provvidenza e così via
tipo di mettere questo in una nozione
potrebbero essere sistemi più familiari come
SPARC fai questo così quando sei un Hadoop
il lavoro è un po ‘fallito a metà strada e alcuni
i nodi vengono partizionati e possono guardare il
la struttura dei dati viene creata e identificata
i componenti mancanti che non riesce a capire
fuori ciò che quei componenti mancanti sono
e e tipo di capire dove andare
prendili e questo è il motivo per cui SPARC è di più
efficiente di qualcosa come un dupe e
quindi l’idea è che ognuno di essi
i risultati dei calcoli sono il monitoraggio
alcuni dati che rappresentano il
input che hanno contribuito a questo
computazione ora inoltre lo farebbe
essere anche bello avere la capacità di
unire questi così se ne computo alcuni parziali
risultato e calcolo qualche risultato parziale
su un altro nodo mi piacerebbe essere in grado di
unire i risultati e così potremmo
immagina di sapere che ho un dispositivo
e calcolo un aggregato su questo
dispositivo forse conosci la media di tutti
se sto giocando e seguo un
mazzo di spartiti e con quelli
I punteggi che produco in media forse lo voglio
condividere quella media con qualcuno
la media degli altri e combinala per creare
una nuova media destra e quindi vogliamo questo
idea di provenienza quindi sappiamo se due
i calcoli ne condividono alcuni
i dati e sappiamo cosa ne deriva
dati e ci piacerebbe anche avere il
capacità di unirli correttamente e così via
è un po ‘come il mondo ideale che conosci
e quindi è banale farlo se
riponi tutto correttamente e così via
che la sfida qui è quella di rendere è a
tipo di prova per fare di questo componente è
per cercare di rendere questo componente efficiente
okay e qui cosa sto solo mostrando cosa
questo D Prime e questo D doppio primo
ecco che dovremmo essere in grado di guardare
ai risultati e tipo di ordine loro
conoscere una sorta di relazione tra
loro qualunque sia quella relazione
okay, quindi è una specie di a
torta nel cielo idea immaginando di sapere
cosa potrebbe fare per un bell’edificio
blocchi per la costruzione distribuita
applicazioni che sono facili e molto
bello costruire corretto che hanno questi
buone garanzie di ordinazione e noi no
preoccuparsi dei ritardi sul
client o cose in rete o offline
Diventare partiti ok e quindi cosa sono
sta per fare è parlare di tre tre
tipo di lavoro qui che a
preliminare
che abbiamo e parliamo di specie di
se viene utilizzato in genere l’industria
di dove hanno visto l’ adozione fino ad ora
e poi tipo di fare una visione per il
futuro e appello alle persone a sfidare
il modo in cui costruiscono i sistemi e così il
il primo pezzo che andremo a guardare
qui si chiama conflitto chiaro replicato
tipi di dati quindi di nuovo io sono il CR DT
il tipo di discorso di CR DT del
conferenza suppongo e e cosa C o D
T sono strutture di dati che sono
progettato per la convergenza per
distribuzione e deterministico
convergenza e quindi vedremo un esempio
di ciò che significa una volta che abbiamo questi
tipi di dati che ci portano tutti questi bei
proprietà abbiamo bisogno di un modo per combinare
questi in un’astrazione di programmazione
che le persone possono effettivamente utilizzare che
può costruire e lavorare con e tipo di
operare con e finalmente abbiamo bisogno di a
meccanismo per ridimensionare questi calcoli
a destra e quindi non stiamo parlando di
reti di 30 nodi di cui stiamo parlando
reti su cui stiamo eseguendo applicazioni
su quello hanno 10.000 nodi e così questi
sono le reti di scala che erano quelle
al momento stiamo prendendo di mira e così è
non esattamente banale per costruire un sistema
quello può richiamare la scala come quella in a
cluster singolo okay e così gentile di un
panoramica su C o D T’s so Co mansione
di tornare al 2011 ci tipi di dati che
sono in modo da sapere si avrebbe nel
allo stesso modo in cui hai dati sequenziali
tipi e tipi di dati concorrenti Co DTS
sono tipi di dati distribuiti che arrivano
una varietà di sapori qui e quindi abbiamo
le cose che sembrano impostate multiple
diversi tipi di set che hanno
i contatori registrano le cose che sono
chiamate bandiere che sono booleano ‘z quello
può muoversi solo in una direzione e
finalmente dizionari quindi questo è il
tipo di dati ricorsivo che può tipo di
componi gli altri e cosa fanno i CRT T
forniscono una proprietà chiamata cosa?
ci riferiamo a come forte finale
coerenza e questo significa che se io
ho un CI DT e ho distribuito I make
tre copie di un set e io – io ne suono un po ‘
eventi fuori dall’acqua ne ho duplicati alcuni
gli eventi ho riordinato alcuni degli eventi
non importa la garanzia ordinamento non
importa la consegna dei messaggi e
non importa se vedo duplicati
tutti questi oggetti finché vedono
lo stesso insieme di eventi avrà il
stesso stato di esito e questo è molto
bella proprietà quando si ha a
database distribuito che eravamo
sistemi concorrenti che scrivono e prima
Ne mostro un esempio solo per darti
un’idea di dove
è stato usato in pratica sai a
lega della League of Legends chat
sistema di Riot Games utilizza CRD T’s
abbiamo visto che abbiamo parlato con una varietà di
altre persone che li stanno usando per
istanza utilizzabile e li usa
alcuni dei loro servizi point-of-sale
sistemi il servizio sanitario danese
il NHS a Londra quindi questi sono dati
strutture che hanno dimostrato di essere
in grado di essere utilizzato su larga scala
League of Legends in particolare la scala
c’è ovviamente piuttosto massiccio
familiarità con il gioco e così da dare
sei un esempio di come sia
e mi scuso per essere così piccolo
era molto più grande qui che andremo a
supporre che abbiamo tre repliche qui
replica a B e C ora quello che stiamo andando
fare è modellare le operazioni
sul set in modo diverso rispetto a noi normalmente
Sarebbe così che modelleremo il
operazioni del set come triple e così via
questa tripla qui è difficile da vedere ma
sarà una tripla che è la
valore uno un insieme di operazioni uniche
indicando aggiunte nel set e a
insieme di operazioni uniche che rappresentano
traslochi e quindi qui quando ne aggiungo uno a
la replica dell’insieme a genererà un unico
identificatore che chiamiamo in minuscolo
un qui e lo aggiungerà al
aggiunte quindi diremo replica a
il tempo logico in minuscolo a ha aggiunto il
elemento 1 all’insieme e poi lo farà
propagare questi risultati al
rete ora se C ne aggiunge uno contemporaneamente
al set che è un’operazione diversa
e così C ne aggiungerà uno al set con a
identificatore univoco uno con uno e il
identificatore univoco C minuscolo C a
rappresenti quello e che tu sai veramente
questi devono essere identificatori univoci per
per tutte le repliche sto solo usando C
per dimostrare di renderlo più facile da fare
segui lo schema e così quando C va a
rimuovine uno dal set che può solo
rimuovi le aggiunte già viste
aggiunto e quindi C ne ha mai visto uno solo
aggiunto il set da C così C può solo rimuovere
la sua propria aggiunta e così allora lo farà
eseguire questa operazione di rimozione e
replicare e quindi finalmente una volta tutto il
le repliche vedono tutti i messaggi uniti
parte del processo di fusione qui per questi
elementi di dati è che prendiamo un’unione di
le aggiunte e prendiamo un’unione di
le rimozioni e ora che sappiamo che
il set aggiuntivo è un superset rigorosa del
rimuove quello che sappiamo che uno dovrebbe
ancora essere nel set di oggi si potrebbe pensare
bene questo è davvero complicato da pensare
di
l’intuizione è piuttosto semplice quindi
questo è un set che spinge verso
aggiunte sotto concorrenza ma tu hai
arrivare a impostare i pregiudizi verso le rimozioni
e l’ intuizione qui è quella dell’annuncio
il pregiudizio ha senso perché normalmente tu
non aggiungere elementi a un set senza
questo quando l’elemento sono gli elementi
non sul set giusto è una specie di a
tecnica di programmazione comune e così via
c’è una sfida qui quando costruisci
questi tipi di dati che si uniscono a te
trovare una semantica distribuita
quello che si avvicina molto al
semantica sequenziale di un set regolare
che avresti nella tua programmazione
lingua e quindi è una sfida
capire come farlo in un modo dove
non impone questo onere massiccio
il programmatore e così gentile degli altri
cosa qui da notare è che lo sai
questa è una sorta di esempio banale di
costruire un CRE T ma puoi vederlo
la spazzatura cresce parecchio
ogni singolo aggiornamento che sia mai accaduto
e quindi ci sono ottimizzati
rappresentazioni di ciò che potevo
hanno mostrato ma sarebbe stato molto
più difficile da seguire e così una volta che abbiamo
questi elementi di dati questo ci permette di
replicare queste cose e al momento
modificarli e unirli ma il
la sfida ora è che un utente non può mai
prendere una decisione di programmazione basata sul
valore esterno dell’utente quello nel set
perché se lo facesse violerebbe questo
bella proprietà di unire le capacità che abbiamo
e quindi quello che dobbiamo fare è che dobbiamo
costruire un sistema che ci consenta di programmare
con questi oggetti dove ci pensiamo
programmazione contro il tipo esterno di
valore come quello è nel set senza
in realtà programmando con l’interno
rappresentazione e quindi stiamo lavorando
un sistema che è una libreria giusta
ora per Erlang chiamava un reticolo
elaborazione e questo è un dichiarativo
modello di programmazione funzionale per insiemi
solo in questo momento che rende i dati nucleo
tipo di astrazione del livello più basso
oggetto di trattare con B questi oggetti
questi CRT T sono questi jj di Ballabh mirja
e per questo c’è una sfida
nel garantire che quando prendo un set e io
tipo di te lo sai mappare o sai fare a
Prodotto cartesiano con un altro lato o
qualcosa del genere c’è una sfida
ciò garantisce che dobbiamo farlo
dobbiamo assicurarci che tutto questo
i metadati ti ho mostrato che è internamente
tracciare questa struttura dati per ottenerlo
diritto di convergenza dobbiamo essere sicuri
che lo trasformiamo correttamente e così
questo è un compito non banale come abbiamo
noi
lentamente imparato e stanno continuando a
dimostrare è corretto
e quindi per darti una specie di solo un
esempio di come potrebbe essere questo
questo è un po ‘come metà metà di Erlang
non renderlo più leggibile per
una diapositiva e quindi qui potremmo dichiarare
alcuni set s1 e potremmo aggiungere tre
elementi ad esso e quindi mappare le uscite
di s1 in un altro set s2 e quindi questo
sarebbe come la tua normale mappa funzionale
operazione che direbbe ogni volta che
cambia s1 quegli elementi andranno in s2
e questo è un prodotto come distribuito
processo che continua a farlo
il tempo va bene e quindi questo è un lavoro dentro
progresso su cui stiamo lavorando su questa parte
del mio dottorato di ricerca ora te l’ho mostrato
oggetto prima di quello che se andiamo
di nuovo qui quella che assomiglia a questo
e tu diresti wow c’è c’è abbastanza
un po ‘di informazioni qui è abbastanza
un grande oggetto da diffondere sul
rete e così i nostri colleghi sono avanti
con noi stiamo lavorando per cercare di capire
modi ottimali per diffondere il
stato in modo che non dovete spedire
attorno a questi oggetti interi e così ai nostri
colleghi in Portogallo hanno escogitato
questa nozione di stato base Delta
disseminazione e cosa sta succedendo
fare è tentare di invece di inviare il
l’intero oggetto invia solo un minimo
rappresentazione del cambiamento perché
che sta per essere molto più facile
disseminare e questi sono indicati come
CRD T dello stato del Delta e così via
il modo in cui il lavoro di Delta C IDT è quello che noi
operare sugli oggetti che creiamo localmente
le nostre modifiche a livello locale ci fanno un sacco
di delta o cose che sembrano
differenziali così simili a come un DIF
potrebbe sembrare un sink di R o qualcosa del genere
e poi periodicamente trasmettiamo
quelli sulla rete all’altra
i coetanei ovviamente questo è problematico se
hai clienti che vanno offline e
non tornare mai indietro perché il tuo buffer
cose a tempo indeterminato quindi dobbiamo essere gentili
di prendere misure pratiche per potare
cose e tipo di espellere i clienti
di questo tipo di sincronizzazione delta
elaborare quando sono offline anche
lungo e quindi dobbiamo tornare a
inviando l’intera struttura dati che
è abbastanza comune per tutto ciò che è
tipo di fare il calcolo mobile dove
qualcuno ha lasciato il telefono e mai
tornare indietro e quindi dare una sorta di
intuizione di come funziona se noi, se noi
generare uno sfogo qui
quindi se hai questo evento sul cerchio verde
che viene generato e questo cerchio blu
l’evento che viene generato viene archiviato anche
tipo di un dizionario sotto il quale è il
aggiornamenti che dobbiamo inviare su
rete questo tipo di get accumulata in
in ordine e poi quando andiamo a esibirci
la sincronizzazione che sincronizziamo
se possibile, spediamo solo il buffer Delta
a meno che quello stato non debba fare lo stato completo
sincronizzazione e quindi potiamo il
Tampone Delta e continuiamo a fare
progresso
quindi ovviamente questo ha alcune sfide come
bene perché non riesco a memorizzare un registro di
10.000 utenti
Non riesco a memorizzare un log di 10 a Delta
buffer per questi buffer di aggiornamenti per
10.000 clienti e quindi dobbiamo fare i conti
con le sfide di cercare di capire
un modo efficace per fare lo stato
disseminazione di cui abbiamo bisogno di fare a meno
dovendo presumere che la conoscenza lo presume
un nodo può sapere tutto quello che
esiste nel cluster e quindi questo
richiede una sorta di ripensamento nel modo in cui
costruisci un sistema di runtime per a
linguaggio distribuito e quindi c’è a
sacco di lavoro storico per cercare di
capire come si può fare qualcosa di simile
questo e così abbiamo deciso
è lontano che vogliamo costruire un
meccanismo di diffusione nel runtime
sistema per la spedizione di questo tipo di stato
su oggetti nella lingua o il
modello basato su un’epidemia
protocollo di trasmissione e così questi
i protocolli sono belli perché supportano
alto churn sostengono estremamente
fault tolerant e fornire molto forte
garanzie di consegna a seconda del tipo di
come si implementa e si prende
vantaggio del protocollo e
ottimizzazioni a parte il tipo del
il modo base in cui funziona è simile a come
se hai familiarità con il termine gossip
il protocollo è che si esegue a coppie
sincronizzazione di stato con ogni
cliente nel sistema così ogni volta che tu
fai un cambiamento, tipo di fan, e
mandalo a un gruppo di clienti e poi
fai un po ‘di coppia fino a tutto
i client vedono tutti gli aggiornamenti
le sfide è quella di farle
protocolli estremamente efficienti e tu
so che questo è un lavoro che sta succedendo
per 20 anni 30 anni per fare questi
protocolli estremamente resilienti e
tollerante nei confronti dei fallimenti
questi protocolli possono fare ben poco
garanzie sull’ordinazione dei messaggi e così via
questo significa che i messaggi potrebbero arrivare
qualsiasi ordine tu debba ragionare su quale
quelli sono venuti dopo quelli che devi
potenzialmente taggalo con poco
informazioni per capire come relazionarsi
questi oggetti e quindi questo si accoppia davvero
bene con l’astrazione di programmazione noi
costruito con tees CRT stessi
perché questi oggetti sono oggetti che
ancora
non fare affidamento sull’ordinazione dei messaggi per ottenere
il risultato corretto stanno andando sempre
unire indipendentemente l’uscita
indipendentemente dall’ordine dei messaggi e
quindi per ridimensionarlo al nostro numero di destinazione
il nostro numero obiettivo per la fine del
l’anno è 10.000 note per iniziare a muoversi
verso questo numero obiettivo ciò di cui abbiamo bisogno
fare è iniziare con un tipo di iscrizione
sovrapposizione che non memorizza tutto il
informazioni nel cluster, quindi non tutte
non tutti i nodi del sistema devono
conoscere ogni altra nota, ma lo fa
bisogno di garantire che ciò che fa
conoscere rappresenta un grafico connesso
quindi sa tutto ciò che può offrire
messaggi a tutti nel cluster ma
potrebbe non sapere di tutti nel
costruzione di cluster in cima a questo costruiamo
i nostri alberi di trasmissione che ci permettono di fare
disseminazione molto veloce quando ci sono
nessun fallimento e torniamo a specie
questa sincronizzazione peer to peer quando
i guasti si verificano nella rete e così via
per fare ciò nella pratica usiamo il lavoro
dai nostri colleghi in Portogallo il massimo
power view protocol per l’appartenenza e
il protocollo susino per broadcast e
così costruiamo una sovrapposizione quel tipo di
assomiglia a qualcosa di simile in cui noi
avere uno spanning tree attraverso la rete
e abbiamo questo tipo di ridondante
percorsi che possono essere usati per dichiararlo
può essere usato per la riparazione dell’albero quando un nodo
scende nel sistema ora ciascuno di
questi nodi nel sistema potrebbero essere a
nodo completamente transitorio come a
telefono cellulare o potrebbe essere qualcosa
come un tavolo hash distribuito, quindi questo
potrebbe anche essere supportato da qualcosa che
ha un più forte
garanzia di fault tolerance se ne abbiamo bisogno
per assicurarsi che i dati non vadano via
perché nel nostro sistema dobbiamo fare i conti
con il fatto che abbiamo a che fare con
data center mentre si occupano anche di
dispositivi mobili mobili potrebbero ottenere
partizionato non ci interessa
la replica su dispositivi mobili forse per
tolleranza d’errore tutto dipende dal
applicazione e quindi questo ci fornisce un
il modo flessibile di pensare lo fa
diversi criteri di coerenza e così via
quello che facciamo è che siamo tipo di livello o
lavoro tra qui così nostro
l’applicazione funziona è sotto si siede
sotto i primitivi di trasmissione e
presume che gli aggiornamenti saranno consegnati
dalla rete al nostro runtime e poi
tipo di diffondere attraverso quello
rete pure e quindi è un po ‘
ricorda approssimativamente un diagramma come questo se
pensi a come il networking
l’architettura funziona e, si spera, questo
ci porterà ai numeri che siamo
sperando di colpire lo scopriremo presto bene
e così ora hanno appena camminato
attraverso uno scenario di applicazione siamo
camminerò attraverso questa idea di un
contatore pubblicitario e così via
lavoro originale due anni fa stava funzionando
con intrattenimento Rovio su Angry Birds
ma poi lentamente abbiamo iniziato a realizzare
che gran parte del nostro lavoro è generalmente
è più applicabile a qualsiasi tipo di bordo
scenario di edge computing non solo mobile
giusto e possiamo pensare al cellulare è giusto
tipo di caso limitato o forse a
caso più generale di alcuni di questi
progetti applicativi e così per questo
esempio di contatore pubblicitario siamo
andando a supporre che abbiamo una sorta di
inserzionista mobile che sta per
visualizzare annunci su qualcosa come un iPhone
nel nostro caso d’uso da cui proviene
Rovio loro vogliono pubblicità
essere visualizzato un numero minimo di tempo
volte che è un minimo garantito
numero di volte in cui lo fanno
obbligo contrattuale credo e e
quindi a loro non importa se contiamo e
così che è una parte molto importante su
questo design di applicazione e lo faremo
lasciare che i client si disconnettano, così i clienti lo faranno
abbiamo una connettività limitata di cui abbiamo ancora bisogno
per registrare le impressioni dell’annuncio al
clienti offline e abbiamo bisogno di
sincronizzarli periodicamente dove siamo noi
non perdere nessuna delle impressioni dell’annuncio così
solo per tipo di reframe che e in dentro
in parole diverse è un vogliamo
garantire che abbiamo un numero minimo
di impressioni ma non ci interessa se noi
oltre il conteggio e quindi il grafico del flusso di dati
per la nostra applicazione sembra qualcosa
più o meno come questo
e quindi stiamo solo andando a prendere un mucchio
di tipo di annunci che rappresentiamo da CRD
contatori t e tipo di loro raggruppati
e basta combinarli con questa nozione
di contratti per fare l’esempio a
un po ‘più interessante che dice
che solo alcuni annunci possono essere visualizzati
in certi momenti diciamo voglio dire solo io
un certo numero di annunci può essere visualizzato
come per contratto come un altro
parti del
o qualcosa del genere e poi quello che abbiamo
voglio fare è solo trovare le cose che ho
contratti validi e quindi sai che possiamo
tipo di cose e tipo di unione
calcolare il prodotto cartesiano e poi
prendi il filtro che è equivalente a
sto solo pensando di prendere molto del nostro
annunci in una tabella sequel e facendo un join
con un sacco di contratti in un seguito
tavolo giusto e quindi è così che vorresti
rappresenta quello in un flusso di dati funzionale
tipo di grafico e cosa vogliamo fare è
vogliamo inviare tutti questi copic noi
voglio prendere copie di questi contatori
e metterli sui dispositivi in modo che quando
il dispositivo per inviare annunci che incrementano
questi contatori così ogni volta che visualizzo
un annuncio I incrementa il contatore display a
ad aumentare il contatore e poi io
invia periodicamente quei segnalini a
il server per esempio e unirlo
al server e così ogni volta un client
sincronizza con il server il server
sta per avanzare ed è un po ‘di
vista del numero globale di conteggi che
sono stati fatti in rete e poi
il server disabiliterà gli annunci e
abbiamo un modo di rappresentare il tipo di
traslochi di annunci in un modo in cui sembra
come una specie di crescita negli stati così
il programma continua a muoversi in avanti
in tempo logico e poi periodicamente
i clienti possono semplicemente sincronizzare per ottenere il
elenco di conteggio aggiornato giusto e così in questo
il design delle applicazioni è importante
tipo di nozione qui che tutto è
questo è modellato monotonicamente e e
quello che voglio dire è che solo è una specie di
accumuliamo sempre informazioni
questo ci permette di sapere se vediamo
qualcosa nel passato è tutto ciò che sono
dicendo cosa c’è di bello nell’applicazione
il design supporta arbitrariamente
distribuzione quindi nessuno di quei nodi in
quel grafico del flusso di dati che ti ho mostrato prima
potrebbe essere in esecuzione su qualsiasi nodo nel
rete potrei eseguire questo calcolo
diviso in 50 nodi diversi esso
non avrebbe importanza perché non dovevo
preoccuparsi per l’anomalia della rete
il programma per produrre un errore
risultato e infine una nozione di
divergenza diverrà così divergente
un fattore di sincronizzazione, quindi quanto spesso
i client sincronizzati con il server
ci farà sapere fino a che punto stiamo andando a
deriva dal numero di destinazione e così via
puoi vedere simili realizzazioni
in alcuni dei flussi di dati di Google funzionano
perché hanno tipo lo stesso il
la stessa nozione di dire bene non lo sappiamo
quando gli aggiornamenti si fermeranno
arrivando quindi abbiamo bisogno di fare una sorta di
elaborazione incrementale e gestione
Le cose di Avensis stanno accadendo e così noi
pensa solo alla nostra nozione di server
sta ottenendo questo tipo di lotti a partire da
eventi rappresentati come stato mutabile
piuttosto che un flusso di aggiornamenti dove noi
continua a inviare le cose tutto il tempo
e questo è un po ‘il tipo di
lati opposti dello spettro, quindi questo
tipo di grafico mostra solo che lo sai
il nostro tipo di server interagisce con tutti
i client allo stesso modo del server
solo la sincronizzazione peer-to-peer
piace qualcosa proprio come tutto il resto
in questo modello non abbiamo bisogno di un tipo di a
API speciale o qualcosa del genere a
il server è solo un client che ne fa un po ‘
elaborazione aggiuntiva che l’altro
i clienti non lo fanno e quindi l’idea è qui
quei server sono una specie di Pierce loro
potrebbe avere codice aggiuntivo forse alcuni
ulteriori elementi di sicurezza per tipo di
eseguire azioni aggiuntive ma qualsiasi nodo
può apportare modifiche al
contatori pubblicitari e tipo di nave
questo stato intorno e cuz il secondo
la nozione qui è davvero quando parliamo
sui server di cosa stiamo parlando
abbiamo bisogno di un posto dove fare qualcosa
esattamente una volta abbiamo bisogno di un posto per tipo di
sincronizzare e fare qualcosa esattamente
una volta e questa è la nozione di bene
trova tutti questi segnalini pubblicità
e alla fine, quando colpisco un bersaglio
numero Ho bisogno di caricare una carta di credito
Non posso permettere a tutti di addebitare il credito
scheda ho bisogno di sincronizzare e saperlo
Ho fatto pagare quella carta di credito a uno
posto e l’ ho fatto una volta e quindi ci stiamo provando
pensare a calcoli dove dove
le cose devono accadere una volta e
dove il resto del sistema può tipo di
piegare verso il modo in cui piegare al
requisiti del modello e quindi cosa io
quello che sono quello che sto cercando di attraversare
Immagino che tu sappia il genere del generale
tema generale di questo discorso e tipo di
tutte le idee pazze che ho
proposto è la testa o lo sai provato
per convincerti di è l’idea che
stiamo costruendo da zero
sincronizzazione che stiamo aggiungendo
sincronizzazione quando ne abbiamo bisogno piuttosto
che provare a costruire un sistema che forse
si concentra su qualcosa come il guardiano dello zoo
e poi dire bene come faccio come posso
separalo come posso farlo
sistema più veloce fammi trovare i posti
che sto sincronizzando che non ho bisogno
da e quindi vogliamo tipo di prendere questa
approccio bottom-up piuttosto che questo
approccio top-down che è il tipo di utilizzo
questi strumenti familiari e poi cercando di
ridimensionare l’infrastruttura una volta che abbiamo
costruito attorno a un nucleo comune va bene
e così per tipo appena come lentamente
concludere qui ci sono un sacco di
sfide andando avanti proprio così tanto
delle idee qui sembrano come loro
proiettili d’argento sai come suonano
sono incredibili il problema qui è
che alcune delle cose sono estremamente
costoso da fare ancora e così il primo
uno è una nozione di esplosione di stato
e così se tu se ne abbia familiarità
il tipo di programmazione funzionale
piega operazione piega è grande perché
soffia se stai costruendo una lingua da
i colpi pieni a terra aprono le porte
su ciò che puoi esprimere in una programmazione
lingua e si può esprimere un sacco di
cose in termini di piega e quindi se noi
pensa di avere un set e poi abbiamo un
Contro e quello che voglio fare è solo
eseguire una piega banale su questo set
presumendo che tu sappia che selezioniamo un ordine
piega quindi si presume che lexa abbia una grafica per
il momento è allora se vado a
produrre un contatore che rappresenta appena
solo il numero di elementi nel set questo
diventa molto costoso per memorizzare questo
informazioni di provenienza si ottiene così
costoso che memorizza il conteggio
in realtà finisce per essere più costoso
di memorizzare l’insieme stesso e solo
interrogando per il conteggio e così il
la sfida qui è come possiamo trovare di più
il più efficiente come possiamo capire
un limite minimo per alcuni di questi un più basso
destinato a capire come modellarne alcuni
di questa roba in cui non perdiamo
informazioni e così prima di coltivare il
espressività della nostra lingua e nostra
modello di programmazione è una specie di te
so che sta crescendo in una lingua
si tratta di un modello di società prima che tipo di
capire come aggiungere più operatori a
la lingua e ottenere una sintassi piacevole e fare
tutta questa roba che cosa abbiamo veramente bisogno di fare
è capire alcune di queste sfide
con esplosione di stato in aggiunta
la sicurezza è un’area enorme che abbiamo
alcuni colleghi stanno guardando ma è così
davvero impegnativo si può immaginare che
se abbiamo questo stato transitivo
diffusione a cui potrei inviare dati
qualche nodo che non dovrebbe ottenerlo perché
Voglio che vada da qualche altra parte
e quindi abbiamo qualche lavoro preliminare
che cerca di analizzare programmi e
capire attraverso il flusso di informazioni
controllo come possiamo trovare di più
percorso di distribuzione ottimale che lo garantisce
non usi mai un nodo che dovrebbe
non ottenere alcune informazioni per il transito e
quindi questo è simile a te un po ‘di questo
diverso questo materiale IFC decentralizzato
a cui Andrew Meyers ha lavorato
Università di Cornell e finalmente tipo di
il modo in cui molte di queste cose
funziona è che oh mio dio questo è quello che ho ottenuto
tagliare, ma questo dovrebbe dirlo
quanto è limitato è programmabile tutto il
le operazioni devono essere associative
commutativo e idempotente
via un sacco di cose come questa funziona
formiamo molto di questo intorno a semi
reticoli e tipo di teoria dell’ordine e
ed è estremamente difficile da fare
determinate operazioni quando è necessario
tutto per essere commutativo associativo
un oggetto potente per esempio come fai
fare qualcosa come una divisione giusta e
quindi le cose come le medie scelgono di finire
essere veramente problematici e così abbiamo
per capire un modo per identificare
dove sono i compromessi e tipo di
capire modi intelligenti di modellarne alcuni
di queste operazioni e di fornire tipo
di modi espliciti per il programmatore di
di si lo so che sto rinunciando alla sicurezza
di questo modello ma ho bisogno di farlo
operazione e quindi caricare una carta di credito
ovviamente non è commutativo associativo
un idempotente per la maggior parte dei casi per il
in gran parte giusto e quindi sai che abbiamo
fatto un sacco di lavoro e tu sai che siamo
continuando a fare il lavoro che questo è un questo è
tipo del lavoro principale dietro il mio dottorato
tesi ed e quello che voglio che tu genere
di portar via ancora una volta c’è un’altra diapositiva
tagliare per il prossimo quello che ti voglio
portare via è che ne ho presentati tre
tecniche di successo indipendente
queste tecniche sono state dimostrate
giusto quindi sappiamo che la nozione di
La Provvidenza è stata a sua volta
ampiamente successo in cose come scintilla I
significa che è metà del motivo per cui la scintilla è
così tanto successo che è uno dei due principali
tipo di contributi di scintilla sappiamo
che vedere i nostri doveri sono molto utili
in pratica e li abbiamo visti
successo abbiamo visto un successo enorme a
luoghi come la sala nazionale di Londra
il servizio sanitario nazionale del Regno Unito
servizi e l’ assistenza sanitaria danese
servizio e Riot Games dove loro
non sarebbe stato in grado di costruire il loro
applicazioni senza CRT T’s e infine
intorno ai protocolli di gossip questi
anche i protocolli sono stati estremamente
con successo questi protocolli sono alla base
sistemi come i metadati di Cassandra
disseminazione e metadati Reax
disseminazione quindi abbiamo visto queste cose
lavoro in pratica nella scala da 100 a
200 nodi e così le sfide sono le
impegnativo e la parte impegnativa
e l’idea e questa è la diapositiva che
sfortunatamente è stato interrotto a causa del
sedici per nove è quello che possiamo prendere
questi tre indipendentemente tipo di
tecniche di successo che sono state
schierato
nell’industria e utilizzato nella pratica e nel can
li combiniamo in una sorta di coesione
ambiente di programmazione per l’ utente finale
in modo che tu abbia questa bella libreria
potresti usare nella tua applicazione java
o la tua applicazione Scala che lo consente
tu per dire questa una parte del mio programma
voglio che sia in grado di lavorare offline
e scala davvero bene ma poi lo sai
allora devo fare il resto della roba
in modo simile al mondo Java di
Il mondo di Scala e così possiamo pensarci
come tipo di tipo di questo tipo di
sguardo monadico a un distribuito
programmazione suppongo e così è tutto
grazie mille sai che sarei
da nessuna parte senza l’aiuto di tutti questi
belle persone in Europa, quindi li ringrazio
grandemente per il loro supporto e quindi grazie
sei molto per venire
come Katie ha detto che sono uno studente di dottorato in a
università un catalizzatore in cui vivo
Belgio, noi non siamo nella parte francese
non la parte olandese e quindi sì
penso che questa sarà una ricerca
parla così basta andare su se non fosse così
chiaro dal programma e quindi penso di essere io
con successo ha ingannato tutti
venire a vedere una cose interne parlano
quello che stiamo davvero andando a parlare è di circa
sistemi distribuiti e quindi quando dico
l’Internet delle cose che conosci
Internet of Things è come una specie di
parola d’ordine che usiamo per riferirsi al tipo di
una classe di applicazioni in cui abbiamo
un mucchio di sensori simili e corriamo
elaborare su di loro con cose come
mirare a lamelle AWS e cose del genere ma
più in generale di cosa voglio parlare
ecco l’ idea del calcolo dei bordi
perché questo tipo di anticipa questo
precede molte Internet-of-things
lavoro da un bel po ‘e quindi cosa intendo
per calcolo del margine ci stiamo riferendo
al processo di tipo di spinta
sia il calcolo che i dati
calcoliamo agli estremi logici di
funziona così stiamo parlando di dispositivi
che stanno generando i dati che vogliamo
eseguire l’elaborazione ai dispositivi tanto
possibile e quindi questo potrebbe essere mobile
dispositivi questo potrebbe essere sensori questo potrebbe
essere tutto punti di dati di presenza
centri sai che sono tutti in una certa misura
del bordo e se venite dalla
mondo in rete sai che significa il bordo
una cosa piuttosto diversa dal tipo di
cosa pensiamo di oggi quando è
tipo di inquadrato in termini di networking
e così quando dico il calcolo cosa faccio
significare
Intendo calcolo arbitrario come qualsiasi
programma che scrivo e vado sul mio
computer dovrei essere con i dati sul mio
computer dovrei essere in grado di tipo di
spingere quel tipo di calcolo al limite
giusto così vorremmo che fosse arbitrario
bene vedere perché è difficile da fare
Pratica e finalmente voglio parlare
su ciò che veramente uno di questi
è interessante il calcolo dei bordi
ha una lunga storia e in una sorta di
auto-organizzato
sistemi auto-organizzanti e resilienti
e quindi se hai familiarità con questo lavoro
questa fusione viene diretta o digerita
dalla Cornell University negli anni ’90 e
si tratta di tipo di auto-organizzazione
sistemi che possono calcolare una sorta di
risultato insieme in un molto resistente
modo e quindi mi piace molto questo lavoro se
mi segui su Twitter sai che io
assolutamente amore come la storia del computer
e cose del genere e così questi documenti
sono interessanti da leggere perché questo
il lavoro era originariamente incorniciato sotto
DARPA concede a Cornell’s a Systems
Gruppo e l’idea era che tu lo sapessi
avevano a che fare con le reti di sensori
negli anni ’90 volevano essere in grado di
prendere un aereo e farlo volare sopra a
campo di battaglia ostile o un’area che loro
non potevo entrare in un sacco di
i sensori fuori da un dorso di un aeroplano
alcuni di loro hanno colpito il terreno alcuni di loro
vorrà continuare a lavorare, alcuni di loro lo faranno
break si auto-organizzeranno in a
sistema distribuito utilizzando un ad hoc
rete wireless e poi lo faranno
calcolare una sorta di risultato sul campo
e quindi questo è un caso piuttosto estremo di
edge computing è qualcosa che non facciamo
pensa a quando stiamo cercando di farlo
sai monitorare la temperatura di te
sapere se il tuo termostato nido al tuo
A casa , è molto meno sicuro
ambiente aggressivo e così c’è
c’è una buona quantità di storia qui
ed è una lettura molto interessante se tu
come questo tipo di lavoro quindi per ottenere un
un po ‘più pratico stiamo andando
parlare di un esempio su ospedale
frigoriferi e tanti colleghi di
il mio è andato a fondare un’azienda che è
facendo esattamente questo così ho passato
un bel po ‘di tempo a pensare al
problema e tipo di esplorazione
modi alternativi di risolverlo e così via
quello che stiamo per immaginare qui è quello
abbiamo un gruppo di ospedali
frigoriferi Ho questi sensori
I sensori stanno per innescare tipo di
avvisi sulla temperatura se
è per riscaldare a freddo e forse vogliamo
innescare comportamenti basati su quelli
eventi e così tipo di riferimento IOT
architettura che questo tipo di sguardo
a oggi e Peter sta per parlare
su uno alternativo dopo questo
che abbiamo un sacco di cose e noi
metterli su internet che è il
punto di partenza per arrivare dove è necessario
essere e e quello che vorremmo fare è quello
queste cose vorrebbero generare
eventi che stanno per generare campioni
e forse lo mettiamo in qualcosa di simile
Hadoop ha distribuito il file system qui e
allora sai se sarebbe stato il 2007
davvero invocato per utilizzare Hadoop per l’esecuzione
lavori batch su questo tipo di dati
produrre alcuni risultati e poi e
innescare una sorta di cosa ma ma abbiamo
spostato dal 2007 e così forse ora noi
usa qualcosa come scintilla o Kafka che
è stato accennato in precedenza
e così in questo modello vorremmo tipo
elaborare quegli eventi così come sono
accadendo in tempo reale e reagire a
quegli eventi mentre accadono, così possiamo
immagina un’esecuzione ideale con questo
tipo di topologia questo riferimento
l’architettura che ho progettato sarebbe
assomiglia a qualcosa così generiamo
alcuni semplici diciamo temperature bene noi
inviarlo al centro dati e ai dati
il centro non fa nulla ora quando generiamo
un esempio che dice che c’è un problema e
lo trasmettiamo al centro dati
di solito qualcuno viene chiamato da un telefono
o forse questa è la versione moderna
di voi conoscete un sistema di paging come pagina o
dovere o qualcosa di simile a destra e così
questa è la situazione ideale che vogliamo
qualcuno riceve una chiamata e tutte le cose dentro
il frigorifero non va male e quindi se
vogliamo iniziare a fare dei buchi
questo potremmo dire bene intendo il primo
il problema è l’ idea della connettività
tutti viviamo in rete con te
sappi che usi quello che sai che ottieni
partizionato tutto il tempo come abbiamo visto
da molti discorsi prima di oggi e e
per questo mi imbatto in questo
situazione in cui se generano un cattivo
campione e la mia connessione a internet
capita di essere giù e non riesco a trasmettere
quello di nuovo al centro dati allora io tutti
Ho tutto ciò che posso fare è tamponarli
eventi e quindi se bufferizzo questi eventi
Questo va bene questi dispositivi hanno di solito
abbastanza per tamponare gli eventi ma questo
non aiuta nulla nel
frigorifero giusto e quindi questo è gentile
di questo è un tipo non desiderabile ma
ma qualcosa con cui ci occupiamo noi
affrontare tutto il tempo e il tipo di questi
IOT sistemi che noi che tipo di
distribuire qui e quindi cosa succede se non riesco a ottenere
i miei eventi su Amazon IOT o sul mio Amazon
servizio in esecuzione su lambda o qualcosa del genere
così e così gentile della prima cosa
che potremmo fare qui è che potremmo
esplorare la nozione di fare locale
decisioni e quindi se pensiamo a cosa
significa prendere una decisione locale e
sai che abbiamo il nostro evento
generato come un sensore è trasmesso
a Hadoop non succede nulla di tutto
bene se generiamo un brutto evento se noi
hanno la capacità di agire per
eseguire le decisioni locali quindi potremmo
basta attivare la chiamata dal dispositivo
giusto e quindi è costoso, ovviamente
perché hai bisogno di un po ‘di backup
hardware ma c’è un presidente per questo
una delle aziende che così PG & E per
l’istanza non può inviare non può inviare electro
segnale elettromeccanico
per un paragrafo che è sovraccarico
perché le griglie di energia sono sovraccaricate correttamente
quindi questo è un tipo di problema che conosci
negli anni ’80 e ’90 quindi se sei dentro
forse la tua fine degli anni ’30 o 40s
ricordati che sai che è stato molto
comune avere una comunicazione di backup
meccanismi per cose come il tè freddo
linee e tè per i quali ho effettivamente lavorato
una telecom che ha fatto questo per la fedeltà così
avrebbero un sistema di backup per
canalizzazione out-of-band quando quando quando
le cose andrebbero giù se tu fossi in te
sapere nel mondo dell’informatica in
gli anni ’90 che conosci alla fine degli anni ’90
primi anni 2000 quando EMC introdusse il peccato
e poi come dispositivi Nazz avrebbero avuto un
modem collegato a loro con un telefono
linea e quando un disco stava generando crc
aree con cui in realtà piacerebbe chiamare
il modem per EMC e dire hey questo guida
per morire e poi sai il prossimo
mattina presso l’ufficio di EMC ragazzo sarebbe
bussare alla porta di avere un backup
camion e quindi questa idea di locale
le decisioni non sono qualcosa che è quello
un po ‘di nuovo abbiamo esplorato questo prima
e quindi l’utilizzo delle decisioni locali per tipo
di costruire un’applicazione è davvero
costoso perché richiede un sacco di
hardware aggiuntivo e quindi forse un
alternativa che potremmo esplorare è
questa idea di diffusione transitiva
e così in questa idea potremmo dire bene
forse ho questo campione che va bene è
va bene la connessione internet va giù
e ora genero il campione cattivo ma
Sono connesso tramite un altro wireless
protocollo per apparire e quel peer può
innescare può inviare gli eventi sul suo
per conto e così dovrebbe essere questo modello
molto familiare a chiunque sia usato
qualcosa come una trasmissione epidemica
protocollo che cerca di fare affidamento su
ti danno molto alta probabilità
garanzie sulla consegna dei messaggi ma
non garantisce che funzionerà
correttamente e quindi ovviamente lo sai
queste epidemie per i protocolli di trasmissione
sono stati studiati per un po ‘e il
problema che puoi banalmente vedere qui
è che si sa per conseguire un livello elevato
probabilità nelle emissioni della rete di massa a
portati al 100% che potenzialmente devi
invia questo in ogni singolo percorso
sapere e ci sono interi gruppi di
ricercatori che stanno lavorando per provare
per rendere questo problema più efficiente e
quindi allora ti si alternano
inoltre hanno il problema di bene se
Ricevo tutte queste copie sui dati
centro come faccio a sapere quali sono dati
che i messaggi possono andare fuori ordine come fanno
So quali sono i più
aggiornati quali sono stantii e
so quali sono duplicati ok?
e quindi finalmente potremmo vedere a
modello in cui inviamo semplicemente lo stato
giusto così piuttosto che generare un evento
flusso e cercando di garantire che noi
consegnare con altissima probabilità
all’interno di una sorta di quantità limitata di
il tempo dissemina tutti gli eventi
forse invece diffondiamo semplicemente lo stato
e quindi uno stato mutevole che descrive
lo stato del sistema e così in questo
caso possiamo immaginarlo con questo
frigorifero qui che cos’è il cerchio rosso
è problematico ma questi due vanno bene
possono diffondere questo stato
e costruire una sorta di stato complessivo di
il sistema e in questo modello ci conosci
abbiamo anche una sfida di
assicurando che con il fuori servizio
consegna tutto può sembrare il
così abbiamo un problema di equivalenza
qui e inoltre abbiamo anche questo
bel vantaggio aggiunto che nessuno dei nodi
nel sistema può fare il telefono
chiama per dire che qualcosa è sbagliato e
quindi non parlerò dell’idea
di come ci assicuriamo di averne uno solo
telefonata
perché questo è un problema di
sincronizzazione e farò un po ‘di giusto
lascia questo esercizio al lettore così io
parlato di molte cose e e
tipo di quello che sto cercando di fare è prenderti
pensare all’idea del locale
calcolo e sto cercando di arrivare a
tipo di sfida del riferimento
architettura e pensare in modo più critico
sulle applicazioni che sei
costruzione e quindi c’è una sorta di due principali
indica che mi piacerebbe guidare
a casa qui il primo è sai se
non si genera semplicemente un infinito
flusso di eventi che modellano ogni singolo
cambiamento nel sistema e tipo di lavoro
con uno stato mutevole o aggregato
quindi puoi ridurre la trasmissione di stato
e questo è molto importante perché molto
di dispositivi mobili e sensori e cose
come questo
operare con batteria molto bassa molto
poca batteria e l’antenna è uno dei
i componenti più costosi in
sistema per guidare la seconda cosa che
Ti sto prendendo Sto cercando di attraversare
è che l’idea di fare locale
decisioni se possiamo basare una decisione se
possiamo agire sul dispositivo che possiamo
avere un sistema che è in un certo senso più
vivo può essere più resistente a
fallimenti può prendere azioni e noi
non imbattersi in questa situazione dove se
conosci un sacco dei nostri dispositivi
che stanno facendo qualcosa sono
disconnesso dalla rete dove
dove non puoi fare niente okay tutto
giusto e così se voglio parlare
replicato lo stato condiviso di quello che mi serve
fare è un po ‘parlare di coerenza
e quindi probabilmente hai sentito un mucchio
su questo oggi già e combatti
sentito parlare di questo in passato e
quindi che tipo di brevemente fare un veloce
panoramica del tipo di idee di
coerenza dei dati replicati e così via
il tipo della prima nozione che faremo
parlare di coerenza è forte e così
se pensiamo a questo il singolo sistema
immagine quindi se pensiamo a un database
che vogliamo avere qualche tipo di totale
ordine degli eventi se ho un dato
elemento qui rappresentato da questo cerchio e
Ho due clienti che leggono quell’elemento di dati
contemporaneamente ora se c1 va a modificare
quell’elemento di dati e scriverlo al
storia usando un’operazione di confronto e scambio
questo succederà in questo
tipo di singoli database prima replica
sarà aggiornato ora il problema che tu
è qui che se c2 va a destra
e dire mentre leggo questo cerchio verde
Ho intenzione di scrivere questo triangolo rosso
questa operazione corretta fallirà
perché sta tentando di farlo
confronta e scambia e il valore ha
cambiato da già e così questi
sono una specie di questo ci dà questo tipo di
ordine totale sugli eventi e le cose
tipo di cambiamento in lockstep si legge solo
loro ragione e quindi questo è una specie di a
cosa standard che vediamo nello stesso tipo
di sistemi fortemente coerenti come
qualcosa come una console è così
sostenuto da qualcosa come zatterare la zattera
protocollo di consenso e così sai che sono
non andando a diagramma di Paxos ma vado
per schematelo quel tanto che basta per mostrarti
che se hai più repliche se
hai più copie dei tuoi dati
oggetti diventa molto più costoso
per fare quelle garanzie ci vuole molto
di tempo per ottenere tutti questi nodi
d’accordo su un ordine non importa il loro
requisito che questi nodi devono essere
online e stiamo specificamente parlando
sui sistemi oggi che vogliamo
operare mentre i sistemi sono offline così
tipo di sul lato opposto del
spettro abbiamo una nozione di finale
coerenza che tipo di diventato
popolare lentamente nel tempo e tipo di
è esploso dentro per assottigliare il tipo di
metà degli anni 2000 in una sorta di alla fine
sistema coerente abbiamo più
repliche
sai che puoi leggere i clienti
e la lettura di questi valori dal
database e poi se ne hai due
diritti simultanei in modo che il cliente uno scriva
questo Blue Square e poi il client due
scrive questo triangolo rosso, non possiamo
determinare quale è venuto prima e così noi
Devo tipo di assumere che entrambi i diritti
sono concomitanti e quindi questo è molto
simile a un sistema su cui ho lavorato
reagire e quindi in questo caso ciò che abbiamo
fare è avere un arbitro il prossimo lettore
decidere quale dovrebbe essere il valore
dovrebbe unire questi valori e quindi scrivere
torna all’archivio dati dist aggiornato
valore e quindi idealmente la cosa che
si desidera eseguire questa operazione di scrittura
per risolvere idealmente questi conflitti
voglio che questo sia un tipo deterministico di
il caso più banale si può avere di
questo è qualcosa di simile allo scorso vincitore dello scrittore
con cui basta inserire un timestamp
tutto e prende quello che è
deterministico per un insieme di eventi ma
ma questo non necessariamente modella il
modo in cui vogliamo che il sistema funzioni perché
è difficile ragionare sul tipo di cosa
gli aggiornamenti vinceranno perché non lo sai
quando le cose verranno consegnate
okay e quindi cosa voglio che la gente pensi
è quel tipo di coerenza finale è
è una specie di modello di cui stiamo parlando
qui vogliamo pensare a questi dispositivi
come generare un proprio tipo di dati
possedere le copie dei dati che
generano e quindi possiamo pensare
questi tre quadrati sono una specie di
eventi che vengono generati e noi
voglio tipo di condividere quegli eventi con
altri membri del sistema in un
modo peer-to-peer possediamo i nostri dati noi
calcolare con i nostri dati e noi vogliamo
avere la capacità di questi questi dati
articoli indipendentemente dall’ordine di consegna
andando a risolvere lo stesso valore
inoltre quando pensiamo al
i risultati dei calcoli ci piacciono
vogliono due proprietà qui, quindi vogliamo
proprietà di unire le capacità e vogliamo
la proprietà di questi calcoli
monitoraggio Provvidenza e e me ne vado
attraverso un esempio di ciò che intendo
che e così se immaginiamo che abbiamo un
frigorifero che ha eventi di scena in
il sistema a e C e un altro
frigorifero che ha visto lo stesso evento
ma un diverso evento B ora se noi
distribuire alcuni calcoli arbitrari F
a queste note e F è calcolato con a
e C e F sono anche calcolati con un e
B
quindi il risultato di questo calcolo
rappresentato da un D Prime e D doppio
primo qui dovrebbe tipo di tracciare il
input che provenivano da quel calcolo
questo è ciò che intendo per Provvidenza e così via
tipo di mettere questo in una nozione
potrebbero essere sistemi più familiari come
SPARC fai questo così quando sei un Hadoop
il lavoro è un po ‘fallito a metà strada e alcuni
i nodi vengono partizionati e possono guardare il
la struttura dei dati viene creata e identificata
i componenti mancanti che non riesce a capire
fuori ciò che quei componenti mancanti sono
e e tipo di capire dove andare
prendili e questo è il motivo per cui SPARC è di più
efficiente di qualcosa come un dupe e
quindi l’idea è che ognuno di essi
i risultati dei calcoli sono il monitoraggio
alcuni dati che rappresentano il
input che hanno contribuito a questo
computazione ora inoltre lo farebbe
essere anche bello avere la capacità di
unire questi così se ne computo alcuni parziali
risultato e calcolo qualche risultato parziale
su un altro nodo mi piacerebbe essere in grado di
unire i risultati e così potremmo
immagina di sapere che ho un dispositivo
e calcolo un aggregato su questo
dispositivo forse conosci la media di tutti
se sto giocando e seguo un
mazzo di spartiti e con quelli
I punteggi che produco in media forse lo voglio
condividere quella media con qualcuno
la media degli altri e combinala per creare
una nuova media destra e quindi vogliamo questo
idea di provenienza quindi sappiamo se due
i calcoli ne condividono alcuni
i dati e sappiamo cosa ne deriva
dati e ci piacerebbe anche avere il
capacità di unirli correttamente e così via
è un po ‘come il mondo ideale che conosci
e quindi è banale farlo se
riponi tutto correttamente e così via
che la sfida qui è quella di rendere è a
tipo di prova per fare di questo componente è
per cercare di rendere questo componente efficiente
okay e qui cosa sto solo mostrando cosa
questo D Prime e questo D doppio primo
ecco che dovremmo essere in grado di guardare
ai risultati e tipo di ordine loro
conoscere una sorta di relazione tra
loro qualunque sia quella relazione
okay, quindi è una specie di a
torta nel cielo idea immaginando di sapere
cosa potrebbe fare per un bell’edificio
blocchi per la costruzione distribuita
applicazioni che sono facili e molto
bello costruire corretto che hanno questi
buone garanzie di ordinazione e noi no
preoccuparsi dei ritardi sul
client o cose in rete o offline
Diventare partiti ok e quindi cosa sono
sta per fare è parlare di tre tre
tipo di lavoro qui che a
preliminare
che abbiamo e parliamo di specie di
se viene utilizzato in genere l’industria
di dove hanno visto l’ adozione fino ad ora
e poi tipo di fare una visione per il
futuro e appello alle persone a sfidare
il modo in cui costruiscono i sistemi e così il
il primo pezzo che andremo a guardare
qui si chiama conflitto chiaro replicato
tipi di dati quindi di nuovo io sono il CR DT
il tipo di discorso di CR DT del
conferenza suppongo e e cosa C o D
T sono strutture di dati che sono
progettato per la convergenza per
distribuzione e deterministico
convergenza e quindi vedremo un esempio
di ciò che significa una volta che abbiamo questi
tipi di dati che ci portano tutti questi bei
proprietà abbiamo bisogno di un modo per combinare
questi in un’astrazione di programmazione
che le persone possono effettivamente utilizzare che
può costruire e lavorare con e tipo di
operare con e finalmente abbiamo bisogno di a
meccanismo per ridimensionare questi calcoli
a destra e quindi non stiamo parlando di
reti di 30 nodi di cui stiamo parlando
reti su cui stiamo eseguendo applicazioni
su quello hanno 10.000 nodi e così questi
sono le reti di scala che erano quelle
al momento stiamo prendendo di mira e così è
non esattamente banale per costruire un sistema
quello può richiamare la scala come quella in a
cluster singolo okay e così gentile di un
panoramica su C o D T’s so Co mansione
di tornare al 2011 ci tipi di dati che
sono in modo da sapere si avrebbe nel
allo stesso modo in cui hai dati sequenziali
tipi e tipi di dati concorrenti Co DTS
sono tipi di dati distribuiti che arrivano
una varietà di sapori qui e quindi abbiamo
le cose che sembrano impostate multiple
diversi tipi di set che hanno
i contatori registrano le cose che sono
chiamate bandiere che sono booleano ‘z quello
può muoversi solo in una direzione e
finalmente dizionari quindi questo è il
tipo di dati ricorsivo che può tipo di
componi gli altri e cosa fanno i CRT T
forniscono una proprietà chiamata cosa?
ci riferiamo a come forte finale
coerenza e questo significa che se io
ho un CI DT e ho distribuito I make
tre copie di un set e io – io ne suono un po ‘
eventi fuori dall’acqua ne ho duplicati alcuni
gli eventi ho riordinato alcuni degli eventi
non importa la garanzia ordinamento non
importa la consegna dei messaggi e
non importa se vedo duplicati
tutti questi oggetti finché vedono
lo stesso insieme di eventi avrà il
stesso stato di esito e questo è molto
bella proprietà quando si ha a
database distribuito che eravamo
sistemi concorrenti che scrivono e prima
Ne mostro un esempio solo per darti
un’idea di dove
è stato usato in pratica sai a
lega della League of Legends chat
sistema di Riot Games utilizza CRD T’s
abbiamo visto che abbiamo parlato con una varietà di
altre persone che li stanno usando per
istanza utilizzabile e li usa
alcuni dei loro servizi point-of-sale
sistemi il servizio sanitario danese
il NHS a Londra quindi questi sono dati
strutture che hanno dimostrato di essere
in grado di essere utilizzato su larga scala
League of Legends in particolare la scala
c’è ovviamente piuttosto massiccio
familiarità con il gioco e così da dare
sei un esempio di come sia
e mi scuso per essere così piccolo
era molto più grande qui che andremo a
supporre che abbiamo tre repliche qui
replica a B e C ora quello che stiamo andando
fare è modellare le operazioni
sul set in modo diverso rispetto a noi normalmente
Sarebbe così che modelleremo il
operazioni del set come triple e così via
questa tripla qui è difficile da vedere ma
sarà una tripla che è la
valore uno un insieme di operazioni uniche
indicando aggiunte nel set e a
insieme di operazioni uniche che rappresentano
traslochi e quindi qui quando ne aggiungo uno a
la replica dell’insieme a genererà un unico
identificatore che chiamiamo in minuscolo
un qui e lo aggiungerà al
aggiunte quindi diremo replica a
il tempo logico in minuscolo a ha aggiunto il
elemento 1 all’insieme e poi lo farà
propagare questi risultati al
rete ora se C ne aggiunge uno contemporaneamente
al set che è un’operazione diversa
e così C ne aggiungerà uno al set con a
identificatore univoco uno con uno e il
identificatore univoco C minuscolo C a
rappresenti quello e che tu sai veramente
questi devono essere identificatori univoci per
per tutte le repliche sto solo usando C
per dimostrare di renderlo più facile da fare
segui lo schema e così quando C va a
rimuovine uno dal set che può solo
rimuovi le aggiunte già viste
aggiunto e quindi C ne ha mai visto uno solo
aggiunto il set da C così C può solo rimuovere
la sua propria aggiunta e così allora lo farà
eseguire questa operazione di rimozione e
replicare e quindi finalmente una volta tutto il
le repliche vedono tutti i messaggi uniti
parte del processo di fusione qui per questi
elementi di dati è che prendiamo un’unione di
le aggiunte e prendiamo un’unione di
le rimozioni e ora che sappiamo che
il set aggiuntivo è un superset rigorosa del
rimuove quello che sappiamo che uno dovrebbe
ancora essere nel set di oggi si potrebbe pensare
bene questo è davvero complicato da pensare
di
l’intuizione è piuttosto semplice quindi
questo è un set che spinge verso
aggiunte sotto concorrenza ma tu hai
arrivare a impostare i pregiudizi verso le rimozioni
e l’ intuizione qui è quella dell’annuncio
il pregiudizio ha senso perché normalmente tu
non aggiungere elementi a un set senza
questo quando l’elemento sono gli elementi
non sul set giusto è una specie di a
tecnica di programmazione comune e così via
c’è una sfida qui quando costruisci
questi tipi di dati che si uniscono a te
trovare una semantica distribuita
quello che si avvicina molto al
semantica sequenziale di un set regolare
che avresti nella tua programmazione
lingua e quindi è una sfida
capire come farlo in un modo dove
non impone questo onere massiccio
il programmatore e così gentile degli altri
cosa qui da notare è che lo sai
questa è una sorta di esempio banale di
costruire un CRE T ma puoi vederlo
la spazzatura cresce parecchio
ogni singolo aggiornamento che sia mai accaduto
e quindi ci sono ottimizzati
rappresentazioni di ciò che potevo
hanno mostrato ma sarebbe stato molto
più difficile da seguire e così una volta che abbiamo
questi elementi di dati questo ci permette di
replicare queste cose e al momento
modificarli e unirli ma il
la sfida ora è che un utente non può mai
prendere una decisione di programmazione basata sul
valore esterno dell’utente quello nel set
perché se lo facesse violerebbe questo
bella proprietà di unire le capacità che abbiamo
e quindi quello che dobbiamo fare è che dobbiamo
costruire un sistema che ci consenta di programmare
con questi oggetti dove ci pensiamo
programmazione contro il tipo esterno di
valore come quello è nel set senza
in realtà programmando con l’interno
rappresentazione e quindi stiamo lavorando
un sistema che è una libreria giusta
ora per Erlang chiamava un reticolo
elaborazione e questo è un dichiarativo
modello di programmazione funzionale per insiemi
solo in questo momento che rende i dati nucleo
tipo di astrazione del livello più basso
oggetto di trattare con B questi oggetti
questi CRT T sono questi jj di Ballabh mirja
e per questo c’è una sfida
nel garantire che quando prendo un set e io
tipo di te lo sai mappare o sai fare a
Prodotto cartesiano con un altro lato o
qualcosa del genere c’è una sfida
ciò garantisce che dobbiamo farlo
dobbiamo assicurarci che tutto questo
i metadati ti ho mostrato che è internamente
tracciare questa struttura dati per ottenerlo
diritto di convergenza dobbiamo essere sicuri
che lo trasformiamo correttamente e così
questo è un compito non banale come abbiamo
noi
lentamente imparato e stanno continuando a
dimostrare è corretto
e quindi per darti una specie di solo un
esempio di come potrebbe essere questo
questo è un po ‘come metà metà di Erlang
non renderlo più leggibile per
una diapositiva e quindi qui potremmo dichiarare
alcuni set s1 e potremmo aggiungere tre
elementi ad esso e quindi mappare le uscite
di s1 in un altro set s2 e quindi questo
sarebbe come la tua normale mappa funzionale
operazione che direbbe ogni volta che
cambia s1 quegli elementi andranno in s2
e questo è un prodotto come distribuito
processo che continua a farlo
il tempo va bene e quindi questo è un lavoro dentro
progresso su cui stiamo lavorando su questa parte
del mio dottorato di ricerca ora te l’ho mostrato
oggetto prima di quello che se andiamo
di nuovo qui quella che assomiglia a questo
e tu diresti wow c’è c’è abbastanza
un po ‘di informazioni qui è abbastanza
un grande oggetto da diffondere sul
rete e così i nostri colleghi sono avanti
con noi stiamo lavorando per cercare di capire
modi ottimali per diffondere il
stato in modo che non dovete spedire
attorno a questi oggetti interi e così ai nostri
colleghi in Portogallo hanno escogitato
questa nozione di stato base Delta
disseminazione e cosa sta succedendo
fare è tentare di invece di inviare il
l’intero oggetto invia solo un minimo
rappresentazione del cambiamento perché
che sta per essere molto più facile
disseminare e questi sono indicati come
CRD T dello stato del Delta e così via
il modo in cui il lavoro di Delta C IDT è quello che noi
operare sugli oggetti che creiamo localmente
le nostre modifiche a livello locale ci fanno un sacco
di delta o cose che sembrano
differenziali così simili a come un DIF
potrebbe sembrare un sink di R o qualcosa del genere
e poi periodicamente trasmettiamo
quelli sulla rete all’altra
i coetanei ovviamente questo è problematico se
hai clienti che vanno offline e
non tornare mai indietro perché il tuo buffer
cose a tempo indeterminato quindi dobbiamo essere gentili
di prendere misure pratiche per potare
cose e tipo di espellere i clienti
di questo tipo di sincronizzazione delta
elaborare quando sono offline anche
lungo e quindi dobbiamo tornare a
inviando l’intera struttura dati che
è abbastanza comune per tutto ciò che è
tipo di fare il calcolo mobile dove
qualcuno ha lasciato il telefono e mai
tornare indietro e quindi dare una sorta di
intuizione di come funziona se noi, se noi
generare uno sfogo qui
quindi se hai questo evento sul cerchio verde
che viene generato e questo cerchio blu
l’evento che viene generato viene archiviato anche
tipo di un dizionario sotto il quale è il
aggiornamenti che dobbiamo inviare su
rete questo tipo di get accumulata in
in ordine e poi quando andiamo a esibirci
la sincronizzazione che sincronizziamo
se possibile, spediamo solo il buffer Delta
a meno che quello stato non debba fare lo stato completo
sincronizzazione e quindi potiamo il
Tampone Delta e continuiamo a fare
progresso
quindi ovviamente questo ha alcune sfide come
bene perché non riesco a memorizzare un registro di
10.000 utenti
Non riesco a memorizzare un log di 10 a Delta
buffer per questi buffer di aggiornamenti per
10.000 clienti e quindi dobbiamo fare i conti
con le sfide di cercare di capire
un modo efficace per fare lo stato
disseminazione di cui abbiamo bisogno di fare a meno
dovendo presumere che la conoscenza lo presume
un nodo può sapere tutto quello che
esiste nel cluster e quindi questo
richiede una sorta di ripensamento nel modo in cui
costruisci un sistema di runtime per a
linguaggio distribuito e quindi c’è a
sacco di lavoro storico per cercare di
capire come si può fare qualcosa di simile
questo e così abbiamo deciso
è lontano che vogliamo costruire un
meccanismo di diffusione nel runtime
sistema per la spedizione di questo tipo di stato
su oggetti nella lingua o il
modello basato su un’epidemia
protocollo di trasmissione e così questi
i protocolli sono belli perché supportano
alto churn sostengono estremamente
fault tolerant e fornire molto forte
garanzie di consegna a seconda del tipo di
come si implementa e si prende
vantaggio del protocollo e
ottimizzazioni a parte il tipo del
il modo base in cui funziona è simile a come
se hai familiarità con il termine gossip
il protocollo è che si esegue a coppie
sincronizzazione di stato con ogni
cliente nel sistema così ogni volta che tu
fai un cambiamento, tipo di fan, e
mandalo a un gruppo di clienti e poi
fai un po ‘di coppia fino a tutto
i client vedono tutti gli aggiornamenti
le sfide è quella di farle
protocolli estremamente efficienti e tu
so che questo è un lavoro che sta succedendo
per 20 anni 30 anni per fare questi
protocolli estremamente resilienti e
tollerante nei confronti dei fallimenti
questi protocolli possono fare ben poco
garanzie sull’ordinazione dei messaggi e così via
questo significa che i messaggi potrebbero arrivare
qualsiasi ordine tu debba ragionare su quale
quelli sono venuti dopo quelli che devi
potenzialmente taggalo con poco
informazioni per capire come relazionarsi
questi oggetti e quindi questo si accoppia davvero
bene con l’astrazione di programmazione noi
costruito con tees CRT stessi
perché questi oggetti sono oggetti che
ancora
non fare affidamento sull’ordinazione dei messaggi per ottenere
il risultato corretto stanno andando sempre
unire indipendentemente l’uscita
indipendentemente dall’ordine dei messaggi e
quindi per ridimensionarlo al nostro numero di destinazione
il nostro numero obiettivo per la fine del
l’anno è 10.000 note per iniziare a muoversi
verso questo numero obiettivo ciò di cui abbiamo bisogno
fare è iniziare con un tipo di iscrizione
sovrapposizione che non memorizza tutto il
informazioni nel cluster, quindi non tutte
non tutti i nodi del sistema devono
conoscere ogni altra nota, ma lo fa
bisogno di garantire che ciò che fa
conoscere rappresenta un grafico connesso
quindi sa tutto ciò che può offrire
messaggi a tutti nel cluster ma
potrebbe non sapere di tutti nel
costruzione di cluster in cima a questo costruiamo
i nostri alberi di trasmissione che ci permettono di fare
disseminazione molto veloce quando ci sono
nessun fallimento e torniamo a specie
questa sincronizzazione peer to peer quando
i guasti si verificano nella rete e così via
per fare ciò nella pratica usiamo il lavoro
dai nostri colleghi in Portogallo il massimo
power view protocol per l’appartenenza e
il protocollo susino per broadcast e
così costruiamo una sovrapposizione quel tipo di
assomiglia a qualcosa di simile in cui noi
avere uno spanning tree attraverso la rete
e abbiamo questo tipo di ridondante
percorsi che possono essere usati per dichiararlo
può essere usato per la riparazione dell’albero quando un nodo
scende nel sistema ora ciascuno di
questi nodi nel sistema potrebbero essere a
nodo completamente transitorio come a
telefono cellulare o potrebbe essere qualcosa
come un tavolo hash distribuito, quindi questo
potrebbe anche essere supportato da qualcosa che
ha un più forte
garanzia di fault tolerance se ne abbiamo bisogno
per assicurarsi che i dati non vadano via
perché nel nostro sistema dobbiamo fare i conti
con il fatto che abbiamo a che fare con
data center mentre si occupano anche di
dispositivi mobili mobili potrebbero ottenere
partizionato non ci interessa
la replica su dispositivi mobili forse per
tolleranza d’errore tutto dipende dal
applicazione e quindi questo ci fornisce un
il modo flessibile di pensare lo fa
diversi criteri di coerenza e così via
quello che facciamo è che siamo tipo di livello o
lavoro tra qui così nostro
l’applicazione funziona è sotto si siede
sotto i primitivi di trasmissione e
presume che gli aggiornamenti saranno consegnati
dalla rete al nostro runtime e poi
tipo di diffondere attraverso quello
rete pure e quindi è un po ‘
ricorda approssimativamente un diagramma come questo se
pensi a come il networking
l’architettura funziona e, si spera, questo
ci porterà ai numeri che siamo
sperando di colpire lo scopriremo presto bene
e così ora hanno appena camminato
attraverso uno scenario di applicazione siamo
camminerò attraverso questa idea di un
contatore pubblicitario e così via
lavoro originale due anni fa stava funzionando
con intrattenimento Rovio su Angry Birds
ma poi lentamente abbiamo iniziato a realizzare
che gran parte del nostro lavoro è generalmente
è più applicabile a qualsiasi tipo di bordo
scenario di edge computing non solo mobile
giusto e possiamo pensare al cellulare è giusto
tipo di caso limitato o forse a
caso più generale di alcuni di questi
progetti applicativi e così per questo
esempio di contatore pubblicitario siamo
andando a supporre che abbiamo una sorta di
inserzionista mobile che sta per
visualizzare annunci su qualcosa come un iPhone
nel nostro caso d’uso da cui proviene
Rovio loro vogliono pubblicità
essere visualizzato un numero minimo di tempo
volte che è un minimo garantito
numero di volte in cui lo fanno
obbligo contrattuale credo e e
quindi a loro non importa se contiamo e
così che è una parte molto importante su
questo design di applicazione e lo faremo
lasciare che i client si disconnettano, così i clienti lo faranno
abbiamo una connettività limitata di cui abbiamo ancora bisogno
per registrare le impressioni dell’annuncio al
clienti offline e abbiamo bisogno di
sincronizzarli periodicamente dove siamo noi
non perdere nessuna delle impressioni dell’annuncio così
solo per tipo di reframe che e in dentro
in parole diverse è un vogliamo
garantire che abbiamo un numero minimo
di impressioni ma non ci interessa se noi
oltre il conteggio e quindi il grafico del flusso di dati
per la nostra applicazione sembra qualcosa
più o meno come questo
e quindi stiamo solo andando a prendere un mucchio
di tipo di annunci che rappresentiamo da CRD
contatori t e tipo di loro raggruppati
e basta combinarli con questa nozione
di contratti per fare l’esempio a
un po ‘più interessante che dice
che solo alcuni annunci possono essere visualizzati
in certi momenti diciamo voglio dire solo io
un certo numero di annunci può essere visualizzato
come per contratto come un altro
parti del
o qualcosa del genere e poi quello che abbiamo
voglio fare è solo trovare le cose che ho
contratti validi e quindi sai che possiamo
tipo di cose e tipo di unione
calcolare il prodotto cartesiano e poi
prendi il filtro che è equivalente a
sto solo pensando di prendere molto del nostro
annunci in una tabella sequel e facendo un join
con un sacco di contratti in un seguito
tavolo giusto e quindi è così che vorresti
rappresenta quello in un flusso di dati funzionale
tipo di grafico e cosa vogliamo fare è
vogliamo inviare tutti questi copic noi
voglio prendere copie di questi contatori
e metterli sui dispositivi in modo che quando
il dispositivo per inviare annunci che incrementano
questi contatori così ogni volta che visualizzo
un annuncio I incrementa il contatore display a
ad aumentare il contatore e poi io
invia periodicamente quei segnalini a
il server per esempio e unirlo
al server e così ogni volta un client
sincronizza con il server il server
sta per avanzare ed è un po ‘di
vista del numero globale di conteggi che
sono stati fatti in rete e poi
il server disabiliterà gli annunci e
abbiamo un modo di rappresentare il tipo di
traslochi di annunci in un modo in cui sembra
come una specie di crescita negli stati così
il programma continua a muoversi in avanti
in tempo logico e poi periodicamente
i clienti possono semplicemente sincronizzare per ottenere il
elenco di conteggio aggiornato giusto e così in questo
il design delle applicazioni è importante
tipo di nozione qui che tutto è
questo è modellato monotonicamente e e
quello che voglio dire è che solo è una specie di
accumuliamo sempre informazioni
questo ci permette di sapere se vediamo
qualcosa nel passato è tutto ciò che sono
dicendo cosa c’è di bello nell’applicazione
il design supporta arbitrariamente
distribuzione quindi nessuno di quei nodi in
quel grafico del flusso di dati che ti ho mostrato prima
potrebbe essere in esecuzione su qualsiasi nodo nel
rete potrei eseguire questo calcolo
diviso in 50 nodi diversi esso
non avrebbe importanza perché non dovevo
preoccuparsi per l’anomalia della rete
il programma per produrre un errore
risultato e infine una nozione di
divergenza diverrà così divergente
un fattore di sincronizzazione, quindi quanto spesso
i client sincronizzati con il server
ci farà sapere fino a che punto stiamo andando a
deriva dal numero di destinazione e così via
puoi vedere simili realizzazioni
in alcuni dei flussi di dati di Google funzionano
perché hanno tipo lo stesso il
la stessa nozione di dire bene non lo sappiamo
quando gli aggiornamenti si fermeranno
arrivando quindi abbiamo bisogno di fare una sorta di
elaborazione incrementale e gestione
Le cose di Avensis stanno accadendo e così noi
pensa solo alla nostra nozione di server
sta ottenendo questo tipo di lotti a partire da
eventi rappresentati come stato mutabile
piuttosto che un flusso di aggiornamenti dove noi
continua a inviare le cose tutto il tempo
e questo è un po ‘il tipo di
lati opposti dello spettro, quindi questo
tipo di grafico mostra solo che lo sai
il nostro tipo di server interagisce con tutti
i client allo stesso modo del server
solo la sincronizzazione peer-to-peer
piace qualcosa proprio come tutto il resto
in questo modello non abbiamo bisogno di un tipo di a
API speciale o qualcosa del genere a
il server è solo un client che ne fa un po ‘
elaborazione aggiuntiva che l’altro
i clienti non lo fanno e quindi l’idea è qui
quei server sono una specie di Pierce loro
potrebbe avere codice aggiuntivo forse alcuni
ulteriori elementi di sicurezza per tipo di
eseguire azioni aggiuntive ma qualsiasi nodo
può apportare modifiche al
contatori pubblicitari e tipo di nave
questo stato intorno e cuz il secondo
la nozione qui è davvero quando parliamo
sui server di cosa stiamo parlando
abbiamo bisogno di un posto dove fare qualcosa
esattamente una volta abbiamo bisogno di un posto per tipo di
sincronizzare e fare qualcosa esattamente
una volta e questa è la nozione di bene
trova tutti questi segnalini pubblicità
e alla fine, quando colpisco un bersaglio
numero Ho bisogno di caricare una carta di credito
Non posso permettere a tutti di addebitare il credito
scheda ho bisogno di sincronizzare e saperlo
Ho fatto pagare quella carta di credito a uno
posto e l’ ho fatto una volta e quindi ci stiamo provando
pensare a calcoli dove dove
le cose devono accadere una volta e
dove il resto del sistema può tipo di
piegare verso il modo in cui piegare al
requisiti del modello e quindi cosa io
quello che sono quello che sto cercando di attraversare
Immagino che tu sappia il genere del generale
tema generale di questo discorso e tipo di
tutte le idee pazze che ho
proposto è la testa o lo sai provato
per convincerti di è l’idea che
stiamo costruendo da zero
sincronizzazione che stiamo aggiungendo
sincronizzazione quando ne abbiamo bisogno piuttosto
che provare a costruire un sistema che forse
si concentra su qualcosa come il guardiano dello zoo
e poi dire bene come faccio come posso
separalo come posso farlo
sistema più veloce fammi trovare i posti
che sto sincronizzando che non ho bisogno
da e quindi vogliamo tipo di prendere questa
approccio bottom-up piuttosto che questo
approccio top-down che è il tipo di utilizzo
questi strumenti familiari e poi cercando di
ridimensionare l’infrastruttura una volta che abbiamo
costruito attorno a un nucleo comune va bene
e così per tipo appena come lentamente
concludere qui ci sono un sacco di
sfide andando avanti proprio così tanto
delle idee qui sembrano come loro
proiettili d’argento sai come suonano
sono incredibili il problema qui è
che alcune delle cose sono estremamente
costoso da fare ancora e così il primo
uno è una nozione di esplosione di stato
e così se tu se ne abbia familiarità
il tipo di programmazione funzionale
piega operazione piega è grande perché
soffia se stai costruendo una lingua da
i colpi pieni a terra aprono le porte
su ciò che puoi esprimere in una programmazione
lingua e si può esprimere un sacco di
cose in termini di piega e quindi se noi
pensa di avere un set e poi abbiamo un
Contro e quello che voglio fare è solo
eseguire una piega banale su questo set
presumendo che tu sappia che selezioniamo un ordine
piega quindi si presume che lexa abbia una grafica per
il momento è allora se vado a
produrre un contatore che rappresenta appena
solo il numero di elementi nel set questo
diventa molto costoso per memorizzare questo
informazioni di provenienza si ottiene così
costoso che memorizza il conteggio
in realtà finisce per essere più costoso
di memorizzare l’insieme stesso e solo
interrogando per il conteggio e così il
la sfida qui è come possiamo trovare di più
il più efficiente come possiamo capire
un limite minimo per alcuni di questi un più basso
destinato a capire come modellarne alcuni
di questa roba in cui non perdiamo
informazioni e così prima di coltivare il
espressività della nostra lingua e nostra
modello di programmazione è una specie di te
so che sta crescendo in una lingua
si tratta di un modello di società prima che tipo di
capire come aggiungere più operatori a
la lingua e ottenere una sintassi piacevole e fare
tutta questa roba che cosa abbiamo veramente bisogno di fare
è capire alcune di queste sfide
con esplosione di stato in aggiunta
la sicurezza è un’area enorme che abbiamo
alcuni colleghi stanno guardando ma è così
davvero impegnativo si può immaginare che
se abbiamo questo stato transitivo
diffusione a cui potrei inviare dati
qualche nodo che non dovrebbe ottenerlo perché
Voglio che vada da qualche altra parte
e quindi abbiamo qualche lavoro preliminare
che cerca di analizzare programmi e
capire attraverso il flusso di informazioni
controllo come possiamo trovare di più
percorso di distribuzione ottimale che lo garantisce
non usi mai un nodo che dovrebbe
non ottenere alcune informazioni per il transito e
quindi questo è simile a te un po ‘di questo
diverso questo materiale IFC decentralizzato
a cui Andrew Meyers ha lavorato
Università di Cornell e finalmente tipo di
il modo in cui molte di queste cose
funziona è che oh mio dio questo è quello che ho ottenuto
tagliare, ma questo dovrebbe dirlo
quanto è limitato è programmabile tutto il
le operazioni devono essere associative
commutativo e idempotente
via un sacco di cose come questa funziona
formiamo molto di questo intorno a semi
reticoli e tipo di teoria dell’ordine e
ed è estremamente difficile da fare
determinate operazioni quando è necessario
tutto per essere commutativo associativo
un oggetto potente per esempio come fai
fare qualcosa come una divisione giusta e
quindi le cose come le medie scelgono di finire
essere veramente problematici e così abbiamo
per capire un modo per identificare
dove sono i compromessi e tipo di
capire modi intelligenti di modellarne alcuni
di queste operazioni e di fornire tipo
di modi espliciti per il programmatore di
di si lo so che sto rinunciando alla sicurezza
di questo modello ma ho bisogno di farlo
operazione e quindi caricare una carta di credito
ovviamente non è commutativo associativo
un idempotente per la maggior parte dei casi per il
in gran parte giusto e quindi sai che abbiamo
fatto un sacco di lavoro e tu sai che siamo
continuando a fare il lavoro che questo è un questo è
tipo del lavoro principale dietro il mio dottorato
tesi ed e quello che voglio che tu genere
di portar via ancora una volta c’è un’altra diapositiva
tagliare per il prossimo quello che ti voglio
portare via è che ne ho presentati tre
tecniche di successo indipendente
queste tecniche sono state dimostrate
giusto quindi sappiamo che la nozione di
La Provvidenza è stata a sua volta
ampiamente successo in cose come scintilla I
significa che è metà del motivo per cui la scintilla è
così tanto successo che è uno dei due principali
tipo di contributi di scintilla sappiamo
che vedere i nostri doveri sono molto utili
in pratica e li abbiamo visti
successo abbiamo visto un successo enorme a
luoghi come la sala nazionale di Londra
il servizio sanitario nazionale del Regno Unito
servizi e l’ assistenza sanitaria danese
servizio e Riot Games dove loro
non sarebbe stato in grado di costruire il loro
applicazioni senza CRT T’s e infine
intorno ai protocolli di gossip questi
anche i protocolli sono stati estremamente
con successo questi protocolli sono alla base
sistemi come i metadati di Cassandra
disseminazione e metadati Reax
disseminazione quindi abbiamo visto queste cose
lavoro in pratica nella scala da 100 a
200 nodi e così le sfide sono le
impegnativo e la parte impegnativa
e l’idea e questa è la diapositiva che
sfortunatamente è stato interrotto a causa del
sedici per nove è quello che possiamo prendere
questi tre indipendentemente tipo di
tecniche di successo che sono state
schierato
nell’industria e utilizzato nella pratica e nel can
li combiniamo in una sorta di coesione
ambiente di programmazione per l’ utente finale
in modo che tu abbia questa bella libreria
potresti usare nella tua applicazione java
o la tua applicazione Scala che lo consente
tu per dire questa una parte del mio programma
voglio che sia in grado di lavorare offline
e scala davvero bene ma poi lo sai
allora devo fare il resto della roba
in modo simile al mondo Java di
Il mondo di Scala e così possiamo pensarci
come tipo di tipo di questo tipo di
sguardo monadico a un distribuito
programmazione suppongo e così è tutto
grazie mille sai che sarei
da nessuna parte senza l’aiuto di tutti questi
belle persone in Europa, quindi li ringrazio
grandemente per il loro supporto e quindi grazie
sei molto per venire
Please follow and like us: