Het beste van 2018 in Tech Talks

De afgelopen twee jaar publiceerde ik een lijst van mijn favoriete tech-talks van het voorgaande jaar (hier is de 2016-editie van dit bericht en hier is de 2017-editie).

Deze lijst is zeker niet volledig en ik weet zeker dat er veel technische gesprekken uit 2018 zijn die ik pas veel later zal ontdekken. Maar onder de gesprekken die ik heb bijgewoond of bekeken, waren deze enkele van de beste (in willekeurige volgorde).

  1. De toekomst van microprocessors, Sophie Wilson

Sophie Wilson, beroemde pionier van de originele ARM-chip, lijkt de overtuiging te hebben dat de wet van Moore ten einde loopt (samen met bepaalde anderen die later in dit bericht worden vermeld). Dit was een fenomenale toespraak van JuliaCon die ingaat op de geschiedenis, evolutie en toekomst van microprocessors.

Video

2. De vlinder van de orkaan: pathologische systemen debuggen, Bryan Cantrill

Twee van de gesprekken die op de lijst van vorig jaar kwamen, waren Zebra's helemaal naar beneden en debuggen onder vuur: je hoofd vasthouden wanneer systemen hun verstand hebben verloren. Dit was een toespraak in dezelfde geest en geleverd met de typische Cantrilliaanse flair, kracht en kracht die we zijn gaan verwachten. Software is gebouwd als een stapel abstracties, met schijnbaar kleine problemen in één laag (de vlinders) die het potentieel hebben om te transformeren naar systemische pathologische prestatieproblemen in een andere (de orkaan). Hoe vind je bij zo'n orkaan de vlinders?

Dia's video

3. Close Loops & Opening Minds: Controle over systemen, groot en klein, Colm MacCarthaigh

Toegegeven, ik heb niet alle talks van AWS re bekeken: Invent, maar van degene die ik wel heb bekeken, was dit misschien wel mijn favoriete talk. Het bevat enkele ontwerpprincipes voor het bouwen van zeer stabiele en betrouwbare systemen (zoals besturingsvlakken).

  1. Controleer alle dingen
  2. Cryptografische authenticatie
  3. Cellen, schelpen en "Poison Tasters"
  4. Asynchrone koppeling
  5. Gesloten feedbacklussen
  6. Kleine duwtjes en grote trekjes (voor configuratie)
  7. Vermijd koude starts en koude caches
  8. gashendels
  9. Deltas
  10. Modaliteit en constant werk

Het was fascinerend om te leren hoe bepaalde antipatronen en niet-intuïtieve ontwerpen in feite de stabiliteit van systemen kunnen helpen verbeteren. Misschien wel het meest interessante deel van het gesprek was het idee dat stabiele besturingssystemen een "PID-lus" vereisen - proportionele, integrale, afgeleide componenten, en dat het kunnen kijken naar het ontwerp en de plek van een systeem als een van deze ontbreekt, is een supermacht. Dit is de eerste keer dat ik over deze "PID-lus" hoor; the talk beveelt het boek Designing Distributed Control Systems aan om meer te weten te komen over hoe principes van besturingstheorie van toepassing kunnen zijn op distributed systems engineering.

Het was ook interessant om de hiërarchie of prioriteiten bij AWS te leren: veiligheid, duurzaamheid, beschikbaarheid, snelheid.

Videodia's

4. Een gouden eeuw voor computerarchitectuur, David Patterson en John Hennessy

Dit was een fantastisch verhaal over de geschiedenis en evolutie van microprocessors, de overgang van CISC naar RISC-machines naar het einde van de wet van Moore en de schaling van Dennard, die op zijn beurt ongekende mogelijkheden biedt voor vooruitgang in de "domeinspecifieke architectuur" -ruimte. "Domeinspecifieke architectuur" omvat zowel verbeteringen in hardware (neurale netwerkprocessors voor machine learning zoals TPU's, naar NVIDIA's GPU's naar FGPA's) samen met domeinspecifieke software (zoals Swift voor TensorFlow). Het gesprek wordt afgesloten met het verhaal van de oprichting en groei van de RISC V ISA.

Voor degenen die de voorkeur geven aan een geschreven artikel boven een video, heeft de Communications of the ACM van deze maand een artikel geschreven door Hennessy en Patterson (auteurs van het beroemde boek Computer Architecture) over dit onderwerp. De wet van Moore voor transistoren is misschien afgelopen, maar er lijkt een Moorse wet-achtige groei te zijn in het aantal artikelen over machine learning dat de afgelopen jaren is gepubliceerd.

Video [Hennessy op Stanford, ~ 1 uur]

Video [Patterson op Facebook's @Scale Conference ~ 30 minuten]

5. Veilig klantgedrag, Ariel Goh

Dit moet voor de hand liggen van gedistribueerde systemen, maar het is de moeite waard om te herhalen dat klanten een belangrijk onderdeel van een gedistribueerd systeem zijn en dus moeten deelnemen aan veerkrachtinspanningen. Dit is een fantastisch verhaal van SRECon Asia / Australië over best practices voor klantontwerp voor het verbeteren van de veerkracht van het hele systeem. De voorgestelde technieken omvatten jittering client-verzoeken, het toevoegen van willekeur zodat alle clients niet per ongeluk synchroniseren wanneer ze verzoeken doen, wanneer niet opnieuw proberen, jittering retries, pogingen met exponentiële backoffs (en bijkomende gotchas), "retry budgetten" (zoals foutbudgetten) ), een deel van de besturing naar de server verplaatsen en een terugkoppeling tussen de server en clients tot stand brengen, adaptieve throttling op clients en nog veel meer.

Video

6. Hoe te dienen en beschermen (met clientisolatie), Frances Johnson

Dit is weer een uitstekend verhaal van SRECon Asia / Australia over het beschermen van een service zoals Google Maps (met een overvloed aan interne en externe clients) tegen overbelasting. Het gesprek raakt aan problemen zoals systeemoverbelasting (en bijbehorende problemen zoals downstreams zich niet bewust zijn van de overbelasting van een systeem), trapsgewijze mislukking, de valkuilen van statische quota, de voor- en nadelen van het implementeren van sierlijke degradatietechnieken in verschillende lagen van de stapel (client, rand, frontend, backend).

Video

7. Toegepaste prestatietheorie, Kavya Joshi

Dit is een ongelooflijke lezing (zoals altijd) door Kavya van QCon London over het gebruik van technieken voor prestatiemodellering om vragen te kunnen beantwoorden zoals welke extra belasting een systeem kan ondersteunen zonder de responstijd te verslechteren en hoe de knelpunten in het gebruik van een systeem kunnen worden gedetecteerd. Het gesprek leidt ons eerst door een typisch voorbeeld van een webserver om aan te tonen hoe de prestaties in "open systemen" kunnen worden geanalyseerd, gevolgd door een voorbeeld van "gesloten systemen", en hoe beide afhankelijk zijn van verschillende veronderstellingen en verschillende technieken vereisen om te analyseren.

Dia's video

8. Amazon Aurora: ontwerpoverwegingen voor cloud-native relationele databases met hoge doorvoer, Sailesh Krishnamurthy

Dit was een absoluut kraakpraatje van Facebook's @Scale Conference over enkele ontwerpbeslissingen en afwegingen die Amazon Aurora ondersteunen, de opslagmotor die vele populaire AWS-database-aanbiedingen aandrijft. Er wordt beweerd dat Aurora tot 64 TB per database-instantie automatisch schaalt en hoge prestaties en beschikbaarheid levert met maximaal 15 leeslatenties met lage latentie, point-in-time herstel, continue back-up naar S3 en replicatie over drie beschikbaarheidszones.

Er zijn twee [1] [2] bijbehorende whitepapers gepubliceerd door Amazon op Aurora. De toespraak verwijst in het bijzonder naar veel punten uit de tweede paper, met als belangrijkste punt dat de gedistribueerde consensus de prestaties tenietdoet en dat de lokale staat eigenlijk een goede zaak kan zijn. Met het gebruik van een onveranderlijk logboek als de bron van waarheid, vermijdt Aurora gedistribueerde consensus over lidmaatschapsveranderingen door gebruik te maken van enkele "oases van consistentie" met het gebruik van tijdperken als bewakers als een vorm van schrijfquorum en het vermijden van het doen van quorum leest helemaal. Het is interessant in een tijdperk waarin transactionele systemen iets van een comeback maken en Google predikt over waarom we sterke consistentie moeten kiezen, waar mogelijk, Amazon kiest verschillende afwegingen.

Video

9. Toekomst van FoundationDB Storage Layer, Steve Atherton

Dit was een opwindend gesprek over de toekomst van de opslaglaag van FoundationDB van de FoundationDB Summit. FoundationDB is een gedistribueerde, geordende sleutelwaardeopslag, maar de opslaglaag zelf is niet gedistribueerd en is toegankelijk via een enkel proces vanuit een enkele thread. Het gesprek gaat in op de vereisten van een nieuwe opslag-engine, niet-vereisten (gelijktijdige schrijvers, lage vastlegtijd) en onderzoekt vervolgens de voor- en nadelen van verschillende datastructuren du jour (B + -bomen, LSM-bomen) en de redenen achter het kiezen van Redwood-versies B + boom.

Video

Een ander geweldig verhaal van de FoundationDB Summit was dat op de documentlaag, waarvan de video hier te vinden is.

10. Autonome tests en de toekomst van softwareontwikkeling, Will Wilson

Allereerst is Will mogelijk een van de beste sprekers die ik ooit heb zien spreken (zijn vorige lezing over het testen van gedistribueerde systemen met deterministische simulatie van Strangeloop 2014 is een van mijn favorieten aller tijden).

Dit is een fenomenale toespraak van de inaugurele Foundation DB-top die een behoorlijk overtuigende reden is voor een AI-gestuurde benadering van testen. Het gesprek identificeert 3 belangrijke problemen met testen: kwetsbaarheid (uw test is afhankelijk van incidentele eigenschappen van uw systeem - dat zijn niet degene waarvan u dacht dat u deze testte), gebrek aan volledigheid en schilferigheid.

De toespraak beweert dat tests geweldig zijn voor het verschijnen van regressies, maar bijna volledig nutteloos voor het detecteren van onbekende-onbekenden. Het gesprek gaat verder met het beschouwen van alle bovengenoemde problemen als de symptomen, met het echte onderliggende probleem dat testen nog steeds volledig handmatig is. Zelfs bij "geautomatiseerd testen" wordt alleen ooit Jenkins betrokken bij het uitvoeren van een testpakket dat handmatig door mensen is geschreven. Het gesprek legt vervolgens de droom van autonoom testen neer als de noodzaak van geautomatiseerde creatie van tests, naast geautomatiseerde uitvoering van tests.

Video

11. Ontwerpen van gedistribueerde systemen met TLA +, Hillel Wayne

Dit was een prachtig toegankelijk verhaal van CodeMesh over het gebruik van formele specificaties voor het ontwerpen van gedistribueerde systemen. Zie het als een zachte introductie tot TLA +. Quotable takes omvatten:

Geef een systeem voldoende tijd en het zal alles doen, inclusief falen.
Code is geen ontwerp. Code laat niet zien hoe uw systeem werkt. Het is gewoon uw implementatie; het hoort niet jouw ontwerp te zijn, het kan jouw ontwerp niet zijn. En als je denkt dat je een systeem kunt ontwerpen en een systeem met alleen de code kunt begrijpen, heb ik een brug om je te verkopen, en ik ga het je twee keer tegelijkertijd verkopen.

Video

12. Wat we verkeerd hebben: lessen uit de geboorte van microservices bij Google, Ben Sigelman

Dit was een wervelwindpraat over de drijfveer van gedistribueerd computergebruik bij Google, waarbij alles aan de orde kwam dat Google recht had op praktijken die niet helemaal waren maar sterke parallellen hadden met wat we tegenwoordig 'microservices' noemen. Het gesprek benadrukt waar de bredere industrie in feite bepaalde dingen beter doet dan hoe Google het deed (zoals servicemasten), wanneer en waarom het emuleren van de technologische keuzes en praktijken van Google niet goed werkt voor de rest van ons en waarom het vooral belangrijk wordt om in staat zijn om bepaalde soorten vragen te beantwoorden voordat ze architecturale paradigma's du jour aannemen (zoals "serverloos").

Videodia's

13. Gedistribueerde log-verwerkingsontwerpworkshop, Laura Nolan, Phillip Tischler, Salim Virji

Dit is een absoluut ongelooflijke bespreking van de praktische aspecten van het ontwerpen van een grootschalig gedistribueerd systeem, inclusief het benaderen van schaling, het evalueren van afwegingen langs verschillende assen en tonnen achter in de envelopberekeningen om elke beslissing te rechtvaardigen.

Het SRE-werkboek (gratis online beschikbaar) van Google heeft een heel hoofdstuk met de naam Non-Abstract Large System Design gewijd aan dit onderwerp, en ik heb gehoord dat dit het cruciale interview is in de gehele Google SRE-interviewlus, want het is degene die is statistisch gezien het meest waarschijnlijk om een ​​kandidaat te laten struikelen, gevolgd door de coderingsinterviews. Persoonlijk denk ik dat dit niet alleen relevant is voor SRE's, maar zou moeten worden gelezen voor iedereen die gedistribueerde systemen bouwt en beheert.

Helaas heb ik hier geen video voor kunnen vinden.

slides

14. Load Balancing op Hyper Scale, Alan Halachmi en Colm MacCarthaigh

Dit is een echt fascinerend verhaal van de Networking @Scale-conferentie van Facebook over de evolutie van load balancing bij AWS. Het werpt licht op HyperPlane, een systeem dat ten grondslag ligt aan AWS's S3 Load Balancer, VPC NAT Gateway en PrivateLink, en meer. Ik vond het vooral leuk om te leren over het voorgestelde SCHOK-principe (Self Healing of Constant Work), wat suggereert dat wanneer je een systeem bouwt, het bestand moet zijn tegen zelfs grote schokken. Of anders gezegd: "als er iets groots verandert, zou het systeem gewoon door moeten kunnen gaan". Het gesprek stelt voor dat:

1. Constante inspanning en herstel van mislukking zijn de natuurlijke toestanden
2. Werk altijd in de reparatiemodus. Wanneer een knooppunt faalt, doet Hyperplane eigenlijk minder werk!
3. Bij het ontwerpen van grootschalige systemen willen we niet dat ze complex zijn. We willen dat ze zo eenvoudig mogelijk zijn. Daarom willen we zo weinig mogelijk bedrijfsmodi (Hyperplane heeft bijvoorbeeld geen nieuwe pogingen. Het spaarpotten op het aangeboren nieuwe pogingenmechanisme van TCP). Stapelen op verschillende werkingswijzen resulteert in een combinatorische explosie van complexiteit waardoor het systeem ongelooflijk moeilijk te testen is. We willen een systeem dat consistent is en altijd presteert zoals we verwachten.
4. Het gesprek introduceert ook het idee van shuffle-sharding, een DDoS-mitigatietechniek (waarbij isolatie de primaire mitigatietechniek is) die nu op grote schaal wordt toegepast in veel AWS-services.

Video

15. Isolatie zonder containers, Tyler McMullen

Een van mijn interesses is wat ik aan vrienden heb beschreven als het "spectrum van compute" - VM's, microVM's, geneste VM's, containers (en smaken van "sandboxed containers" zoals Kata-containers) en "serverless" (of functies) als een service). Ik ben vooral geïnteresseerd in het 'spectrum van isolatie' dat deze bieden - van strikte procesniveau-isolatie tot isolatie via een sandbox zoals een V8. De afgelopen jaren zijn er verschillende technologieën ontstaan ​​in de virtualisatieruimte, zoals gVisor (een hypervisor die een subset van de Linux kernel API implementeert in de gebruikersruimte) naar Firecracker - een virtuele machinemonitor die is gebouwd voor het uitvoeren van lichtgewicht en serverloze workloads in micro-VM's , zelf gebouwd bovenop crosvm (Virtual OS Monitor van Chrome OS). Een van de meest fascinerende ontwikkelingen in deze ruimte is WebAssembly. Oorspronkelijk ontworpen als een doel voor native code om op browsers te worden uitgevoerd, wordt WASM nu door CDN-providers gebruikt om willekeurige code uit te voeren zonder enige vorm van procesgebaseerde isolatie. Hoewel ik nog steeds denk dat de jury er niet op uit is of deze vorm van isolatie echt op de proef wordt gesteld, was dit een fascinerend verhaal van Strangeloop over dit onderwerp dat de kenmerken van WASM verklaart dat dit zelfs enigszins houdbaar maakt.

Video

16. Hoe C ++ Debuggers werken, Simon Brand

De titel is vrij duidelijk. De gesprekken leggen alles uit van wat ELF binaries zijn, DRAWF symbolen, de mechanica van hoe breekpunten werken, wat het doorlopen van code echt inhoudt, werken met multi-threaded applicaties in een debugger en nog veel meer. Dit is absoluut een van mijn top drie talks op deze lijst met ongelooflijke talks.

Video

17. Een filosofie van softwareontwerp, John Ousterhout

Het boek A Philosophy of Software Design was zonder twijfel het beste technische boek dat ik in 2018 heb gelezen. Elk hoofdstuk in het boek is goud waard, maar het hoofdstuk over diepe modules is waarschijnlijk het hoofdstuk dat ik het meest heb geciteerd. Het gesprek raakt enkele van de belangrijkste ideeën en rode vlaggen die in het boek zijn geïntroduceerd, maar als ik jou was, zou ik het boek kopen en er klaar mee zijn.

Videoboek

18. Clangd: architectuur van een schaalbare C ++ taalserver, Ilya Biryukov

Een van de meest interessante ontwikkelingen van Microsoft in de afgelopen jaren is het Language Server Protocol. De 5.0-release van de clang-compiler introduceerde Clangd, LLVM's implementatie voor het Language Server Protocol. Clangd is een implementatie van het Language Server Protocol, voor functies zoals code-voltooiing, fix-its, ga naar definitie, hernoemen enz. Voor clients zoals C / C ++ broneditors. Dit was een goed gesprek van CPPCon dat enkele van de beperkingen van libclang aan de orde heeft gesteld en de motivaties achter de ontwikkeling van Clangd en de algemene architectuur ervan verklaart.

19. Coroutine-vertegenwoordigingen en ABI's in LLVM, John McCall

Coroutines in LLVM werd voor het eerst toegevoegd door Gor Nishanov van Microsoft en werd ontworpen rond de behoeften van C ++ coroutines TS. Dit was een ongelooflijke toespraak van de LLVM-ontwikkelaarsbijeenkomst die ingaat op enkele voor- en nadelen van verschillende overwegingen bij de implementatie, zoals cedecontrole (contextomschakeling, coroutinesplitsing met gedeelde hervatting en hervattingsfuncties per opbrengst), tot het opslaan van de lokale staat (stapelbare coroutines , nevenallocatie, stapel samenwonen) voor het opleveren van gegevens, evenals de uitdagingen van het genereren van code voor taalfuncties aangedreven door coroutines zoals generatoren. Het gesprek gaat vervolgens in op enkele details van een ander type verlaging genaamd "teruggezette continuation flavour" voor de programmeertaal Swift, waar sommige optimalisaties plaatsvinden op de SIL-laag van Swift en niet direct op het LLVM-niveau.

Video

PS: alle gesprekken van de LLVM Developer's Meeting zijn zeer leerzaam. Ik heb deze alleen maar zien praten, maar ik ben er zeker van dat ik alle anderen ook graag zou aanbevelen, als ik er eenmaal in ben om ze te bekijken.

20. Ontwikkeling van Kotlin / native infrastructuur met LLVM / Clang, Nikolay Igotti

Kotlin Native is een super interessante ontwikkeling in de afgelopen jaren waarmee Kotlin-code kan worden gecompileerd tot platform binaries (ELF, Mach-O, WASM enz.), Zodat het native kan worden uitgevoerd naast het kunnen uitvoeren in een JVM. Dit was echt een goed gesprek van de European LLVM Developer's Meeting over de werking van Kotlin / Native, inclusief enkele uitdagingen van het implementeren van geheugenbeheer buiten de JVM, het omgaan met uitzonderingen en porten naar WASM (dat geen runtime heeft, geen geheugenallocator, geen uitzonderingen enz.), evenals enkele van de algemene problemen die zich voordoen met LLVM (trage codegen en koppeling, ontbrekende openbare LLDB plug-in-API enz.).

Dia's video

21. Verse Async Met Kotlin, Roman Elizarov

Het spectrum van asynchrone programmering is breed en gevarieerd. Dit was een fantastisch gesprek van Goto Copenhagen over de uitdagingen die ten grondslag liggen aan enkele van deze paradigma's van asynchrone programmering, in het bijzonder de op callback gebaseerde benadering met Futures. Het gesprek gaat vervolgens verder over hoe Kotlin dit probleem met coroutines wil oplossen door een synchrone interface te bieden aan de gebruiker (via de primitieve opschorting) terwijl hij onder de motorkap doorgangen en ophangpunten gebruikt om een ​​staatsmachine te bouwen. Het meest fascinerende deel van het gesprek was de vergelijking tussen de aanpak van Kotlin en de C # -benadering van async / await, met als drijfveer achter de ontwerpkeuzes van Kotlin dat concurrency moeilijk is en ergo expliciet moet zijn. Het gesprek eindigt met hoe zelfs CSP-achtige patronen kunnen worden geïmplementeerd met behulp van de coroutine-primitieven van Kotlin.

Video

22. Kotlin Native Concurrency Model, Nikolay Igotti

Kotlin heeft geen concurrency primitives op taalniveau. Kotlin-coroutines zoals hierboven beschreven in een lezing is een op de bibliotheek gebaseerd construct dat zich richt op de JVM. Kotlin / Native schuwt JVM-stijl gedeelde objectheap en vergrendeling door een invariant te behouden dat een object eigendom is van een enkele uitvoeringscontext of onveranderlijk is (gedeeld XOR mutable). Dit was een geweldig gesprek van KotlinConf dat gaat over hoe dit wordt bereikt met "niet extern verwezen objectsubgraphs"

Bovendien heeft Kotlin als taal geen onveranderlijkheid ingebouwd in het type systeem. Onveranderlijkheid wordt bereikt door het concept van bevriezen, dat de transitieve sluiting van alle objecten die bereikbaar zijn vanaf een bepaald object onveranderlijk maakt. Bovendien maakt Kotlin / Native ook de overdracht van eigendom van objecten over uitvoeringscontexten mogelijk. Het gesprek introduceert de basis veilige samenlooptijdprimitieven geleverd door Kotlin / Native zoals "afneembare objectgrafieken", atomaire en acteursachtige "werknemers", hoe referentietelling gebaseerd geheugenbeheer werkt in Kotlin / Native en hoe het interoperabiliteit met andere bewerkstelligt runtimes.

Dia's video

23. Is het tijd om een ​​besturingssysteem te schrijven in Rust, Bryan Cantrill

Ik ben vaak het onderwerp geweest van iemand of een andere leunstoel die theoretiseerde dat Rust "een taal is ontworpen om een ​​kernel in te schrijven".

Goed, is het?

Dit is een geweldig verhaal van de belangrijkste expert over het onderwerp waarom Rust bijzonder geschikt is voor het schrijven van systeemsoftware, evenals enkele uitdagingen van het potentieel schrijven van een hele kernel in Rust. Als je van reizen door de annalen van de computergeschiedenis houdt en dat zeldzame merk van hot takes die eigenlijk worden ondersteund door goed geïnformeerd en beredeneerd denken, is dit misschien iets voor jou.

Dia's video

24. Wat bedoel je met "thread-safe"? Geoffrey Romer

Dit was een prachtige toespraak van CPPCon die tot doel heeft termen als "thread-safe" of preciezere termen zoals "data race" en "race condition" die vaak op het verkeerde abstractieniveau werken, ondubbelzinnig te maken. De lezing stelt voor om het begrip 'API-race' te gebruiken en invarianten die kunnen worden opgebouwd rond een 'API-race', gevolgd door aanbevelingen voor zowel C ++ -bibliotheek als applicatie-auteurs rondom

Video

25. Snelle veilige veranderlijke staat, Ben Cohen

Als het gaat om de veranderlijke toestand, is het belangrijk om te onthouden dat het een gedeelde veranderlijke toestand is die slecht is, niet per se veranderbaar. Dit was een geweldig verhaal van de Functional Swift-conferentie over wanneer en hoe de lokale veranderlijke staat te gebruiken zonder in te boeten aan veiligheid of prestaties. Het gesprek loopt door enkele van de taalfuncties in Swift die het een bepaalde functionele smaak geven door bepaalde mogelijke foutencategorieën in muterende functies te voorkomen.

Video

26. De do's en dont's van foutafhandeling, Joe Armstrong

Ik heb het genoegen gehad om dit gesprek live te zien bij GOTO Kopenhagen. De hoofdgedachte van dit gesprek is dat het onmogelijk is om fouttolerantie te bereiken met behulp van een enkele machine; berichtdoorgeven wordt dus onvermijdelijk. Het bouwen van fouttolerante gedistribueerde systemen komt neer op het detecteren en handelen naar fouten. De filosofie van foutafhandeling die het meest verstandig wordt geacht, is er een waarin software tijdens het compileren als correct kan worden bewezen en waarbij wordt aangenomen dat software de facto onjuist is en naar verwachting tijdens de uitvoering mislukt. Grote verzamelingen van kleine dingen zijn onmogelijk te bewijzen; dus wordt het belangrijk om de "error kernel" te kunnen definiëren, een subset van het systeem die correct moet zijn. Als je als programmeur niet weet wat je moet doen, crash dan. Dan wordt uw software eenvoudiger.

Het zal je vergeven zijn om het als een 45 minuten durende verklaring voor het bestaan ​​van de Erlang programmeertaal te beschouwen.

Video

27. QUIC: Ian Swett en Jana Iyengar ontwikkelen en implementeren van een TCP-vervanging voor het web

Dit was een geweldige toespraak van NetDev die een inleiding geeft tot het QUIC-protocol ontwikkeld bij Google, de ontwerpbeslissingen (waarom het bovenop UDP plaatsen, beter verliesherstel, flexibele congestiecontrole), het is evolutie en talloze avonturen die QUIC op Linux schalen .

Dia's video

28. Introductie van Network.framework: een modern alternatief voor Sockets, Josh Graessley, Tommy Pauly, Eric Kinnear

Sockets kunnen moeilijk te gebruiken zijn als het gaat om het tot stand brengen van een verbinding of gegevensoverdracht (zelfs met niet-blokkerende sockets) of mobiliteit.

Network.framework is een moderne transport-API die een alternatief is voor sockets op Apple-platforms. Dit was een geweldige wandeling van WWDC 2018, die liep door de anatomie van een eerste verbindingsbedrijf naar de levenscyclus van een verbinding, samen met de talloze optimalisaties die in verschillende fasen zijn gemaakt. Het is misschien ook het best gepresenteerde gesprek op deze lijst.

Video

29. Kubernetes en het pad naar serverloos, Kelsey Hightower

Het is een toespraak van Kelsey Hightower.

Moet ik nog meer zeggen? Ik denk het niet.

Video

30. Rust gebruiken voor spelontwikkeling, Catherine West

Het gesprek begint met te zeggen: "Dit is waarschijnlijk het saaiste gesprek ..."

Het is niet.

Het is misschien wel het allerbeste gesprek op deze lijst.

Video