Press "Enter" to skip to content

GOTO 2018 • Rust Async Programming in 2018 • Katharina Fey


[Musica]
va bene ciao benvenuto al mio ringraziamento
per essere venuti sarò che sto per dire
in primo piano qualcosa che questa diapositiva dice asincrona
e Rus 2018 e il discorso
descrizione potrebbe dire qualcosa sulla
caratteristiche e async async ‘caratteristiche e
2018 ruggine ma questo discorso è davvero il
storia di come è ruggine 2019 così sia
avvertito giusto prima di iniziare
Chi sono il mio nome è Katerina Fey, sono
da Berlino sono un ingegnere del software I
avere uno sfondo nella programmazione dei sistemi
piloti e quel genere di cose che passo
che ho gestito sono nella maggior parte dei social media
e github qualunque cosa sviluppi molto
software open source Sono coinvolto in a
pochi progetti diversi con diversi
le priorità e quindi ho una specie di visita
di comunità a volte solo
effimero e raccogliere concetti e
idee che sono solo localmente
essere pensato in modo diverso
comunità bevo molto tè e
a volte ho hackerato con l’hardware
anche se non quanto fossi abituato a fare
alcuni giochi di parole davvero atroci e io dico
questo per avvisarti della diapositiva
mazzo che stai per vedere mi dispiace
Ho un brutto senso dell’umorismo e non posso
aiutarmi
quindi questo è un discorso arrugginito così si farebbe
penso che io faccia un po ‘di ruggine cose che sono un
contributore al gruppo di lavoro della CLI
che è un gruppo di persone che tipo di
esiste vicino al core team che si occupa
con lo sviluppo e la creazione di librerie CLI
lo sviluppo delle applicazioni CLI
più gentile sono un membro della comunità
squadra e Berlin RS che è una specie di a
gruppo di comunità locale a Berlino
organizzo eventi e seminari che sono stato
Ho dato un ponte di ruggine che è uno
workshop diurno organizzato da o in giro
Eventi di Mozilla
insegnare fiducia alle persone
sottorappresentato nella tecnologia due volte
una volta a Parigi e una volta a Portland e io
mantenere un sacco di librerie quindi se
stai scrivendo CLI è probabile che sia così
stai usando il mio codice e se non lo sei
allora probabilmente non dovrai farlo così
voglio iniziare questo discorso con un po ‘di speranza
affermazione molto incontrovertibile che è
quella concorrenza è davvero difficile è la
tipo di duro che ti fa trovare il 99% di
bug davvero facile e poi quello scorso
Percento ti costa la tua sanità mentale e poi
vuoi lasciare i computer per sempre
perché sono sempre tristi, non c’è
due diversi tipi di concorrenza
problemi che di solito incontri
quelle sono le macchine che saltano l’una sull’altra
e l’altro non è abbastanza auto
andare oltre la stessa strada ora non è abbastanza
auto in modo inefficiente ridimensionamento di solito
non è un grosso problema se non quello che sei
sprecare le risorse hardware, ma
essi in genere non causano alcun bug che cosa
è il problema o le condizioni di gara come te
visto in una corsa letterale, quindi le condizioni di gara
Darò un po ‘di primer
su alcune gare di concorrenza
le condizioni alla fine si riducono al
problema di quale thread possiede un pezzo di
dati quindi se hai due thread quello
entrambi vogliono cambiare il tuo valore e dire
leggere il valore incrementato di uno e
scrivilo indietro se non stai attento
a seconda del momento in cui il tuo
i thread saranno eseguiti dal tuo
scheduler se il valore sta andando
essere uno o saranno due e
solo una di queste è la risposta corretta
l’altra è una corsa dati che fa
perdi dati e questo è esattamente dove
ci viene la ruggine quindi normalmente parlo
più a conferenze di fiducia dove posso
supponiamo che le persone generalmente capiscano
di che lingua parla, quindi lo farò
dare un po ‘ di una panoramica di alto livello e
stiamo andando a tuffo giù in un paio di più
concetti specifici in tutto il discorso
quando diventano rilevanti quindi la ruggine è a
linguaggio di programmazione dei sistemi che viene eseguito
incredibilmente veloce previene errori di seg e
garantisce la sicurezza del filo che è il
piano di marketing sul sito e io
pensa che la risposta corretta sia a
essere un po ‘confuso perché mentre se
sei nel mondo della programmazione dei sistemi
già e potresti avere familiarità con a
molti di questi concetti ce ne sono molti
gergo lì e così per abbattere la parola
la ruggine riguarda davvero c’è una parola
quello riassume certo che è la sicurezza
questa è la sicurezza in due diversi domini
è stata sviluppata la sicurezza della memoria per una ruggine
in sostituzione di C ++ e Firefox e
ci sono alcune altre decisioni di design
quello viene da quello per esempio molto
facile interoperabilità con il codice C che
può essere abbastanza divertente e il secondo
la cosa è la sicurezza del filo così tanto
problemi di concorrenza ruotano attorno a cosa
thread possiede i dati e fa ruggine bene
questo molto esplicito con proprietà così dentro
ruggine tutti i dati ha un proprietario e tutti i dati
è sempre di proprietà anche se questo è proprietario
il binario statico che è quindi il
proprietario e dati statici che possiedi
essere preso in prestito con regole specifiche e
c’è infatti regole molto severe circa
come puoi possedere e prendere in prestito i dati e in
in quali contesti questo è permesso e
seguono alcuni piccoli esempi
quindi prendiamo questo pezzo di codice e io
di nuovo non so quante persone qui
in realtà mi piacerebbe vedere quanti
le persone hanno programmato la ruggine in questa stanza
prima
okay, forse è circa il cinque percento
okay, la sintassi dovrebbe essere corretta
semplici due cose che farò
menzione è che questo punto interrogativo è un modo
per riprodurre con grazia gli errori verso l’alto
quindi F in questo caso o sarà di
da tutti o la funzione verrà chiusa
presto con un errore
è il lasciare qualcosa errore e se
errore ritorno era da andare non scrivo
molto, ma come ho visto
modello e come molte persone sanno
quel modello non ci sono eccezioni e
Russ quindi è così che ti occupi degli errori
puoi semplicemente dire ok questo è adesso
un file e se l’apertura del file non è riuscita
quindi la funzione restituirà un errore
la seconda cosa che potresti essere un
un po ‘confuso da whoops
ok calma la mossa con i tubi così il
i tubi aprono una chiusura con una pausa riccia
contro l’ essere in cui la funzione reale si sposta
questo contesto significa che l’ambiente
della chiusura viene catturato in un mutabile
in qualche modo che è importante se tu
voglio quindi cambiare qualcosa a riguardo
e così se si guarda a questo codice questo è
non correggere questo non funzionerà e dentro
qualsiasi altra lingua questo causerebbe a
problema di runtime mentre in ruggine
semplicemente non lo compila no
compilare a causa della proprietà perché il
prima volta questa discussione viene invocato
assume la proprietà del valore F e quindi
F è caduto che è l’equivalente di
chiudendo un file ma così la prossima volta
vorrei fare qualsiasi cosa sia
letteralmente il ciclo e il compilatore
capisce che il thread è in corso
generato in un ciclo è la proprietà
è già stato spostato nel primo
thread in modo che non puoi farlo e non lo farà
compilare e semplificare questo
Ad esempio un po ‘anche questo non lo farebbe
compilare quindi abbiamo un abbiamo alcuni
funzione legge dal file che prende solo
un file e fa qualsiasi cosa e poi se
vuoi aprire un file e leggere da esso
due volte o chiamare questa funzione due volte
anche non compilare per lo stesso
ragione per il fatto che ci provi
spostare la proprietà invece di prendere in prestito il
dati ora potrei parlare per un grandissimo
lunghezza sul prestito e
c’è un componente in the
il compilatore di ruggine ha chiamato il correttore di tana
che è la fonte di frequente
frustrazione per le persone che sono nuove
la lingua è realisticamente
qualcosa che si deve imparare a
capire e controllare il prestito e
le dinamiche del prestito in ruggine ti hanno costretto
pensare ai dati in un modo diverso
che impedisce un sacco di concorrenza
questioni da sempre accadendo persone come
per mettere i linguaggi di programmazione su alcuni
spettro immaginario non so esattamente
quale sarebbe lo spettro ma tu sai
tutto è PowerPoint apparentemente e
e la ruggine rende l’essere messo in un
spettro come questo molto difficile
perché ha la sicurezza della memoria senza
avendo un garbage collector è thread
sicuro nonostante sia un livello molto basso
lingua e non richiede un runtime o
un ambiente virtuale o qualcosa del genere
quello
e penso che se dovessi riassumere la ruggine
come linguaggio vorrei usare questa citazione
dalla prefazione del libro della ruggine che
dice che la ruggine riguarda il potenziamento
gli sviluppatori di avere fiducia in cosa
si sviluppano e possono espandersi
i loro domini di utilizzo di una lingua
oltre a quello che programmano prima e
abbiamo visto che molte persone lo sono
programmazione e ruggine nei sistemi
programmare anche se hanno te
conoscere uno script Java o un Python
sfondo e hanno fatto principalmente script
o qualunque cosa o il contrario così
così con quello spero che ti spero tu
avere un po ‘ di foto su quale ruggine
è e perché è interessante parliamo
A proposito di ciò che asincrona è che ciò che fa
sapere che non sa nulla e andiamo
scoprire
programmazione asincrona per le persone che
non fare la programmazione asincrona può essere a
poco confuso perché si riduce
per questa frase si prega di fare questa cosa
ma non farmi aspettare
riguarda l’I / O non bloccante, ma lo è
per quanto riguarda l’I / O non bloccante in questo modo
semplicemente non crea solo nuove
discussioni
e il modo in cui funziona è una specie di
interessante e di solito si traduce in
due componenti o ne richiede due
componenti uno di loro è il futuro e
vedremo cosa non sono quei tipi
dei futures ma i futures sono calcoli
che non è ancora successo
quindi quando con la programmazione asincrona
I / o non bloccante o non bloccante
le operazioni generalmente diventano speculative
A proposito di quello che sarà in futuro e in
la maggior parte delle lingue è chiamata letteralmente
un futuro anche se javascript Koston
promette che significa che qualcosa è
probabilmente succederà ad un certo punto
e dovresti continuare a chiederlo e
la cosa interessante qui è ogni volta che io
parlare con persone che non hanno un
familiarità con la programmazione asincrona e I
dì loro che mi hanno chiesto bene
che non solo un filo e un giunto
gestire e intendo in un modo che mi piace
generando un thread e quindi aspettando
quel thread per terminare e fare
qualcosa e ti restituisco qualcosa
ha somiglianze con questo ma il grande
la differenza è il ciclo degli eventi, quindi i futures
eseguire all’interno di un ciclo di eventi che significa
che è un programma di pianificazione che funziona
le tue caratteristiche è responsabile
tirando i futures per la prontezza e
quindi chiama il codice che vuoi
per chiamare quando diventa un futuro
pronto questo è può essere visto come un utente
lo scheduler spaziale per il futuro dei pozzi ora
i loop degli eventi possono essere multi-thread ma
non devono essere per definizione loro
può essere nodejs a thread singolo per
esempio è un ciclo di eventi a thread singolo
e quello che significa è che ci vuole tutto
della responsabilità di programmare il tuo
applicazione e prende dal
sviluppatore dell’applicazione reale e
lo mette allo sviluppatore dell’evento
ciclo Allora perché si vuole fare questo
si riduce alla complessità del contesto
commutazione
quindi quando noti un nuovo thread che è a
molto lavoro ci sono un sacco di spese generali
coinvolto devi allocare memoria a te
copiare i registri intorno al tuo
il kernel ha bisogno di fare molto lavoro di gambe e
c’è un syscall coinvolto, quindi lo sai
tutto ciò richiede un po ‘ di dedizione
se hai generato un thread letteralmente
ogni chiamata che fai la tua domanda
sarebbe molto più lento perché si deve
così tanto sopra la testa che non si vede mai il
ritorna o hai rendimenti decrescenti
da spotting thread c’è questo
foto e penso che abbia qualche anno
e non penso che mi piaccia, penso questo
dovrebbe essere preso con un po ‘di sale
perché ovviamente Apache e Nginx lo sono
non confrontabile in molti domini ma
fondamentalmente Apache spawns è molto di più
desideroso di generare nuovi thread quando si tratta
con connessioni di nginx nginx
di solito alloca un pool di lavoratori e
puoi sapere che può crescere se lo fa
ha bisogno di ma usa la programmazione asincrona
paradigmi per utilizzare i thread che esso
ha già nei lavoratori che
ha già con più efficienza e
bene puoi vedere questo nella memoria
utilizzo questo è per esempio anche il
motivo per cui nginx è fondamentalmente immune a
il camion lento una dose o attacco DDoS
dove apri le connessioni a un Web
server e poi lasciarli andare
al fine di come rendere i server per
molti lavoratori e dove nginx fa
giusto in cura, quindi spero che tu
avere un anche se non si ha familiarità con
programmazione asincrona prima che ti spero
capire di cosa si tratta e con il
la storia della ruggine in mente o un po ‘
po ‘di contesto su Rust in mente io sono
qui per mostrarvi un certo codice e parlare
sulla storia e stavo per dire che lo sono
tutto fuori codice ma poi ne ho aggiunto alcuni
codice quindi sono per lo più senza codice e noi
bisogno di viaggiare indietro nel tempo per l’ anno
fine 2013 per capire dove fosse una ruggine
venendo da e
dove sta andando e perché questo è
interessante nel contesto del
sviluppo che è successo nel
l’anno scorso o negli ultimi anni così dentro
Alla fine del 2013 la ruggine era ancora instabile
il linguaggio è diventato stabile nel maggio di voglio
per dire maggio o marzo del 2015 quindi nel 2013
c’erano molti cambiamenti che erano
succede ancora alla lingua se tu a
il programma per Neda sarebbe molto frequente
che avresti scaricato la nuova luce
versione notturna del compilatore e del tuo
il codice non si compilerebbe più perché
le parole chiave che stavi usando sono scomparse
in quel periodo c’era una biblioteca
chiamato lib verde e threading verde è
un nome diverso per questo concetto di
generando micro processi che non lo fanno
corrisponde necessariamente al numero di
thread di sistema che hai Lib Green
è stato introdotto nella ruggine
libreria standard al 26 dicembre 2013 per
gli sforzi di sviluppo prima di questo
siamo ovviamente già e sul posto e
quindi c’erano due direttive di threading
e e pianificare gli errori di pianificazione
essenzialmente per ulteriori aggiunge uno che
usato una sorta di questi asincroni
micro-thread non bloccanti e l’altro
uno che in realtà limita come uno a
un thread di sistema questo abilitato il
ruggine libreria standard per non bloccare
I / O e faccio un sacco di asincroni
programmare molto presto il problema è
o il problema era quello richiesto
la libreria standard per includere effettivamente
un tempo di esecuzione o un tempo di esecuzione per un evento
loop per queste funzionalità o per
asincrono non c’era un futurista
astrazione eppure era solo in generale
chiamate asincrone e questo è venuto con a
molti problemi e come molti di loro
sono specifici di come il compilatore di ruggine
è stato implementato e come il resto del
la libreria standard è stata implementata ma
in definitiva
la decisione di rimuovere di nuovo questo era
perché la ruggine voleva entrare in un
direzione diversa
la ruggine non voleva dover contare su a
runtime e voleva essere più di basso livello
e il metallo nudo, solo un anno dopo
fine 2014 21 novembre 2014 verde labbra
è stato rimosso e quindi era morto e molto
poco dopo la gente voleva avere un lavandino
I / o ancora e così questo progetto me ors
iniziato che sta per metallo I / O e
quello che mio o me ORS ti permette di fare è
ti permette di fare i / o non bloccanti in
un modo leggermente diverso da lib verde
usato per farlo perché era verde lib
integrato nella libreria standard e
doveva convivere con un nativo
modello di filettatura con un comune
astrazione che su entrambi loro così
era un po ‘ scomodo da usare mentre mio
è davvero solo un’astrazione molto sottile
su piattaforma asincrona specifica
primitivi e a questo punto ha
cresciuto un ecosistema intorno ad esso
ci sono essenzialmente plugin per me oh
in modo da poter avere l’I / O asincrono
su ogni sorta di bene diverso non solo
piattaforme ma dispositivi realisticamente e
quindi sì, questo è qualcosa che il
la comunità continuava a svilupparlo semplicemente
gestito da poche persone nel nucleo
squadra quindi non è solo come la comunità
ma Missoula sta mettendo il suo peso
Dietro
quindi sì, prima di andare oltre
è un secondo concetto o tecnicamente
terzo, immagino se contiamo i prestiti e
la proprietà è di due concetti diversi che
Ho bisogno di spiegare a voi e questo è
davvero dove un sacco di magia deriva dal
che costa zero astrazioni quindi io
mostrerebbe di nuovo la travolta e
perché è uno di quei marketing
ancora una volta che un sacco di gente butta
intorno e confonde le persone che non lo sono
nello spazio della ruggine
un modo in cui l’ho sentito essere spiegato
è che un’astrazione a costo zero non ha
overhead di runtime discernable e quello
sembra interessante ma poi mi fa
poni la domanda in confronto a cosa
tempo di esecuzione così come se si confronta un po ‘
codice ruggine che è zero astrazione zero
costo di astrazione per Java JVM e
beh, naturalmente sai che i tuoi costi sono
sarà diverso dal tuo runtime
caustico non sarà paragonabile quindi a
modo molto migliore di guardare su di esso guardare
è che è un codice che non puoi
ho scritto meglio a mano anche se tu
ci ho provato e ci sarò
parliamo di un esempio in un secondo così
in sostanza che astrazione a costo zero
è un’astrazione che scompare a
compilare il tempo è un concetto un tipo che
il compilatore lo sa nel primo
pochi passi di te conoscono la compilazione
il controllore preso in prestito lo sa
il sistema di tipo sa di te
come può usare uno sviluppatore ma quando lo fa
in realtà arriva alla generazione del codice lì
non è rimasto niente e questo è
particolarmente bello in incorporato
sviluppo dove puoi usare molto
tipo tipo di informazioni e intelligenza
sui tipi di nidificazione e tipo di
allegando metadati al tipo
informazioni in modo che il compilatore possa
verificare alcune cose mentre il tuo finale
il binario si adatterà ancora a 4k di
memoria su alcuni microcontrollori che tu
bisogno di target oh e così per esempio io
Ho dimenticato l’esempio che pensavo fosse
codice qui l’esempio di questo molto
di persone come per considerare è iteratori
così in iteratore di ruggine è l’ API iteratore
un’astrazione a costo zero che significa questo
se si genera un iteratore su a
collezione e poi ne fai qualcuno come
piega la mappa come una mappa del filtro e un errore
o qualcosa del genere e tu vai fuori di testa
combinatori e poi li raccogli
in una raccolta non allocante dire a
array in pila
allora quello genererà il codice che nel
binario finale se si dovesse invertire
programmalo e applichi tutto il
ottimizzazioni della modalità di rilascio che è
importante che non saresti in grado di dire
se hai usato l’API iterator o
in effetti hai scritto un ciclo per te
a volte perché le informazioni sul tipo possono
essere rintracciati attraverso alcune parti del
compilare passaggi a volte l’ API iteratore
è in realtà più veloce di scrivere per
loop perché il compilatore può fare cose
come la località cache che conosci te
altrimenti non potrebbe assumere perché tu
avere un campo di applicazione più ampio che ci porti
a maggio 2016 questo punto era stato ruggine
stabile per circa un anno e una biblioteca
è emerso che cambierebbe asincrono
programmare per sempre quale è il futuro RS
puoi vedere un tema e i meme e
le diapositive così i futures RS sono a costo zero
astrazione per i futures quindi la stessa cosa
cosa che puoi fare per iteratori e
un ciclo for se usi questo futuro
biblioteca e tu costruisci questi questi futuri
essenzialmente queste macchine a nastro asincrono
puoi essere sicuro che il codice che
finisce nel tuo binario non ha allocazione
sovraccarico e nessun sovraccarico di runtime in
confronto a se avessi scritto tutto
te stesso
e tu stavi mano ottimizzando questo esatto
scenario che sai di avere
programmato sul tuo computer e mi piace
lo stai facendo tutto da solo no
voglio andare fino a dire scrivere a mano
montaggio perché mi piace il LLVM ma
Non ho fiducia nelle sue ottimizzazioni
tanto ma puoi essere tu puoi essere
garantito che non potresti scrivere non
codice di montaggio te stesso meglio se tu
usa questa astrazione che è
brillante e ha permesso un secondo
progetto
Il core dei Tokio a questo punto è solo
chiamò Tokyo ma a quel tempo fu chiamato
Nucleo di Tokyo per combinare due librerie
esisteva nella costa arrugginita
che erano mio l’asincrono
generalmente threading e programmazione
modelli e futures come un futuro
astrazione e aggiungere un reattore di eventi a
e questa è stata la situazione da allora
circa 2016 fino all’inizio di questo
almeno quest’anno, questo stack tecnologico
generalmente è stato generalmente stabile
dal 2016 non è in una 1.0 quindi sai
la riserva il diritto di urtare il minore
versione che non è ancora successo così il
API è rimasta stabile per questo tempo
e la gente si è chiesta come andare
da qui
costruzione di codice asincrono in ruggini
fino ad ora e ancora adesso sembra un po ‘
po ‘come questo così mi sono offerto di fare un po’
alcuni buffer di lettura perché è semplice
e abbiamo avuto un incendio prima, quindi c’è
varietà quindi abbiamo definito lo standard in e
standard fuori dal codice che non ho
vogliamo che il blocco di codice sia troppo grande noi
definisci un lettore e abbiamo definito a
buffer il lettore è un buffer
lettore su standard N e il buffer è
un vettore un vettore in ruggine è un mucchio
struttura dei dati allocata che cresce
con diverse dimensioni quindi se si aggiunge
le cose cresceranno e se tu
rimuovili nuovamente si restringerà
a seconda di cosa si prova
appropriato ma sotto il cofano è
implementato come array non collegato
elencare così per costruire un futuro con il
biblioteca dei futures che puoi dire per esempio
beh, leggiamo fino a qualcosa, quindi noi
leggi fino a quando non colpisci una nuova riga, solo la B
dice che è una stringa binaria e lo faremmo
leggerlo nel buffer e quando questo
succede e ora stai costruendo un futuro
o stai allegando un pezzo di
informazioni per il futuro che dovrebbero
eseguire quando è pronto quale è
la prontezza è definita dalla lettura del bordo in
la tua linea e poi chiamiamo questo codice
qui dargli uno standard come sai
forse vuoi leggere di più e il
buffer, ma quello che facciamo è ignorare
standardin
e scriviamo due standard out la
contenuto dell’intero errore della mappa del buffer
a proposito in questo caso, proprio come la matematica
errore ti panico
significa che se c’è qualche tipo di errore
non vogliamo gestirlo con grazia noi
voglio andare nel panico ed esaurire la stanza con
un messaggio di errore e lo stesso vale
qui non sto bene
selezionando le cose oggi
questo errore di mappa qui è essenzialmente il
alternativa a se il processo di lettura
colpisce qualsiasi tipo di problema il tuo tubo va
via o qualsiasi altra cosa poi andrà nel panico
okay, abbiamo definito un futuro ma il
la cosa interessante qui è che questo è
solo alcune informazioni di tipo questo è un
raccolta di tipi di dati che
sparirà in un minuto e questo è
in realtà dove ciò non va, Tokyo è
il ciclo degli eventi della nostra scelta qui e noi
dare a Tokyo questo futuro e lo farà Tokyo
ora assicurati di continuare a leggere
standardizzare e chiamare la nostra catena futura
ogni volta che è pronto e questo è
fondamentalmente come questo sono le basi e
puoi espandere questo facilmente tu
potrebbe fare TCP come si potrebbe leggere da
da un socket TCP anziché simile
lo standard nelle API è lo stesso di te
potrebbe leggere da una porta seriale se tu
volevo, che è carino se lo sei
incorporato così come questo sono questi sono
i blocchi elementari di costruzione
costruire applicazioni asincrone e davvero
la cosa da ricordare a te stesso qui
è che tutto questo tipo di complessità tutto
dei combinatori e sai di avere
una chiusura e si salta in qualche codice
e come te fai tutto ciò giusto
scompare al momento della compilazione e cosa
sei rimasto con un codice di metallo molto nudo
questo è altamente ottimizzato
un’altra cosa che ho menzionato la proprietà
in precedenza e vi ho mostrato come la proprietà
tipo di ti impedisce di fare alcuni
cose come chiudere un file di troppo
volte o chiamando una funzione con il
stesso valore due volte senza prendere in prestito
la cosa interessante del
il modello di proprietà qui è che accediamo
lettore e buffer e sia lettore o
lettore immagino sia accessibile solo da
prima parte del passo, ma il buffer è quindi
passato al prossimo Combinator entrambi
questi valori sono consegnati al a
l’inizio della catena futura e così via
questo futuro ora possiede i dati che
significa che quando passiamo questo intero
il futuro a Tokyo Tokyo possiede questi dati
ciò significa che se tu se la tua
il codice viene eseguito puoi essere sicuro che
sei il solo come a causa del modo
che la proprietà funziona, puoi essere sicuro
che tu sei l’unica funzione nella tua
applicazione che accede al buffer in
stessa ora se dovessi metterlo in un
loop o scusa se dovessi correre Tokyo
in su più thread poi questo
non funzionerebbe più
perché ti direbbe esattamente lo stesso
messaggio di errore che abbiamo ottenuto con il
thread dicendo hey ti sei appena mosso
proprietà in questo thread e
stai cercando di generarne altri sette
questo non funziona e a quel punto tu
bisogno di fare come hai bisogno di esplicitamente
assicurati che la struttura dei dati dica
tu usi il nostro thread sicuro che non ci sono andato
in quello perché è tutto
lattina di vermi o è molto complicato
problema ed è qualcosa che quando
si impara la ruggine è qualcosa che si deve
abituarsi ma il punto è concorrenza
i problemi qui vengono resi espliciti
può avere accidentalmente una condizione di competizione
perché il compilatore controllerà e come
il compilatore non lascerà il tuo codice
compilare se c’è qualche ambiguità in merito
essendo thread-safe
quindi hmm finora è stato bello questo discorso
intitolato ruggine 20 18 e non ruggine 2013 a
2016 qualcosa che è successo a questo
anno come parte della ruggine 2018 async / await
così ruggine 2018 è una versione di marketing che è
numero di versione attuale se ricordo
correttamente sta andando essere un punto 31
perché penso che sia un punto trenta
attualmente fuori, quindi è ancora indietro
compatibile con tutto il resto del codice
hai scritto e visto e qualunque sia il
modo che caratteristiche e nuove funzionalità sono
essere abilitato e le funzionalità sono in corso
mi sono piaciute anche alcune caratteristiche interessanti
abilitato con una base opt-in così
puoi dichiarare il tuo progetto come un
ruggine 20 18 progetto e poi una ruggine 2015
il compilatore non capirebbe più
queste caratteristiche come parte di questo e
piuttosto interessante in realtà come è possibile
combinare le librerie ruggine 2015 e 2018
nello stesso progetto il compilatore può
passare al volo tra qualsiasi cosa
ha bisogno di così ha una corsa diversa
modalità quindi non ci sarà un
caos delle dipendenze in cui le tue dipendenze
non può essere usato perché stai usando il
nuova versione e stanno usando il vecchio
versione che funziona ancora come parte di questo
lo sforzo di sviluppo ce ne sono stati alcuni
gruppi di lavoro che sono stati creati e a
poche spinte per stabilizzazioni e
le caratteristiche sono state fatte e asincrone / attendono
era uno di loro quindi l’idea che sta dietro è
fondamentalmente lo stesso di ce ne sono alcuni
altre lingue che lo fanno in questo modo
scrivere codice che sembra sincrono
normale codice di blocco ma quale davvero
non è che utilizza un ciclo di eventi nel
di fondo che si deve configurare
prima perché la ruggine non ha ancora
un runtime implicito che è necessario
scegli esplicitamente un runtime che tu
voglio ma poi invece di doverti
conoscere definire il tipo futuro e il pensiero
su che tipo di valore di ritorno si dispone
e il nesting come le firme dei tipi
Saranno davvero nodosi e così
invece si contrassegna semplicemente una funzione come
asincrono che questa è l’ idea
e questo asincrono di fronte alla funzione
la dichiarazione qui bene significa che questo
la funzione prima di tutto è una specie di
inutile perché il grilletto no
restituire qualsiasi cosa, ma sarebbe restituito a
futuro di niente invece che è
interessante e poi invece di avere
per passare questa funzione o questa funzione
catena credo che si finisce per essere
a un ciclo di eventi c’è questo un peso
macro che chiami che poi
interagisce implicitamente con il runtime
che hai precedentemente impostato in modo esplicito
e in questo modo puoi scrivere il codice che è
fondamentalmente un peso che questa cosa attende
questa cosa fa queste cose
in modo asincrono e quindi attendere tutti e tre
di loro o qualcosa di un sacco di cose
diventa possibile così e così via
generalmente pulisce il codice che tu
scrivi perché non finisci per avere
queste enormi macchine statali perché sì
possono essere davvero carini ma a volte
sarebbero diventati un po ‘ grandi e loro
diventare non gestibile e in questo modo tu
può evitare questo, quindi come funziona?
è un po ‘complicato e intelligente
persone stanno lavorando su di esso
in gruppi potresti persino chiamarli
gruppi di lavoro che è il networking
gruppo di lavoro quindi questo è un mucchio di
persone o dalle squadre di ruggine
loro stessi o periferiche così come sono
nel gruppo di lavoro CLI e non sono attivo
il core team che è la gente che
implementare queste funzionalità nel compilatore
e fornire un ecosistema di biblioteca la strada
che questo funziona è che questo futuro
astrazione che ti ho mostrato prima
si è trasferito nel laboratorio standard di Lib
core o parti di esso sono stati trasferiti in Lib
nucleo della lingua che significa questo
è possibile utilizzare tutte queste funzionalità per
in qualche misura anche su embedded
microcontrollori in cui non hai
accesso al laboratorio standard perché è
troppo grande per questo
e poi c’è la loro certa API è
che i tempi di esecuzione e come i loop di eventi possono
utilizzare per rendersi compatibili con
questo alla sintassi in modo che tu in realtà
avere una scelta che ti runtime
vuoi usare puoi usare Tokyo se tu
so che è un buon runtime per tutti gli usi
se stavi correndo su qualcosa di bizzarro
dispositivo incorporato è possibile utilizzare uno
il runtime incorporato di uno esiste o se
sei un’azienda e hai bisogno di piacere
in particolare, scegli come target un dispositivo che puoi
scrivi il tuo e puoi ancora esserlo
compatibile con tutti gli altri futuri
roba che significa che puoi prenderti
può approfittare di tutto il lavoro che
altre persone stanno mettendo nel
ecosistema dei futures così bene si puoi
utilizzare questo e la risposta è un po ‘così
la sintassi async / await stessa è a
stabile o stabile-ish nella notte
compilatore richiede un flag di funzionalità
l’uso non è cambiato negli ultimi pochi
mesi e come preparazione a questo discorso
Ho intervistato alcune persone che lo sono
lavorando su di esso e loro non se lo aspettano
cambiare molto in modo da conoscere le possibilità
è così se inizi a scrivere del codice
usando questo non si spezzerà ma tu
sai che stai ancora vivendo un po ‘
pericolosamente con la notte il problema
è l’ecosistema libreria vale a dire che
I loop di eventi mancano che sia inutile o
la loro usabilità non è perfetto eppure io
indovina e realisticamente i primi
mesi come gennaio febbraio marzo
qualcosa del genere nel 2019 è supposto
essere quando questo diventa stabile lì
sono stati alcuni ritardi durante tutto l’anno
quando si trattava di qualche altro blocco
problemi sul compilatore che è il motivo per cui questo
è tutto un po ‘in ritardo, il che significa che
non è ufficialmente in questo ombrello
termine di gelo 2018 va bene um e
è così che ho pensato che il mio spazio di conversazione sarebbe
essere molto più basso di quanto non fosse in realtà
Finito per essere puoi così non voglio
per rispondere alla tua domanda sulla domanda o
domande sul palco, ma lo sarò
in giro se vuoi parlare con me
seguirmi su Twitter, se si desidera avere
terribili giochi di parole sulla tecnologia e il tuo
feed se stai guardando questo da remoto o
sei timido e non vuoi venire
per me puoi mandarmi una email o il mio DMS
su Twitter sono sempre aperti e io voglio
Ringrazio i miei datori di lavoro, così faccio
Letto abituato al lavoro ai primi sistemi
ed è per questo che sono davvero entusiasta
alcune delle cose future quando arriverà
per incorporare soprattutto incorporato
networking con TCP come overhead basso
gestione per esempio su a
microcontrollore e anche io
i sistemi distribuiti configurano l’architettura
e una specie di operazioni simili a uno spaventatore
che è una seconda compagnia da Berlino quindi
Si grazie
[Applausi]

Please follow and like us: