Bestand wählen
Merken

State, Time, and Concurrency

Zitierlink des Filmsegments
Embed Code

Automatisierte Medienanalyse

Beta
Erkannte Entitäten
Sprachtranskript
and the same someone invalid some talking today about time the state time and concurrency and this is a a a
high school senior photo so as to establish some degree of humility on Monday former core team member now Amber core team Emeritus I work at a company called future-proof retail we build maintain a suite of and perhaps that kind of target retailers grocery stores are the most popular of the acts being a mobile line 3 out at Britain's skin items on fall and check out and skip the life and so that player experience last years doing mobile acts in dealing with that with so time currency maybe let's define a future so state is the data in your app that changes over time but basic operations which might be the men were picked up near app take time and usually cause state to change In concurrency is any time you have more than 1 a single operation happening at the same time and so I would so argue that the users kind of basic operations the user will get impatient more triple-click perform submit button and all that the refresh button things the low fast enough so any any Apple has any basing on so many timer need agents request is already concurrent because there's always the user and concurrent programming is pretty hard still it's pretty hard unfortunately much all that web development programming it's so ever concurrency is an add-on I wrote maybe a little bit more than a year ago that helps you manage and deal with state timing the and it's 1 more popular radon's maybe quick showing answers on the currency in production at debris dead like 50 per cent so the so to sort of highlight what's actually difficult I'm actually going to stick with pretty simple use case that gets Harry pretty quickly so this is actually a use case afflicted from my own at of for the mobile check out where on the 1st and then you have to do is chill OK it you're latitude longitude coordinates and for that information to the server so the server can tell you nearby locations our supported Jakarta using this act as organist start off doing this a very vanilla typical Amber fashion what is going to have a action called submit form it's going to make use of a geo-location service it's gonna make use of the store find out a story it's gonna say geo-location Cordes this return the promise the promise fulfills arena take the chords accordance returned from the successful hopefully geo-location requests Morgan for that to get nearby stores and that's going to return a promise that fulfills when we have a list of stories the nearby and really take that result were going to set it as a property ons component so that expose the template the template can render it so if I click this button did take 2 seconds in and the resulted in a show up as a flexible way there's a plug central is the flux of the US which transclusions Us which is a competitor and up throughout these examples in moving around the world so the results will change so this is not really ready for production e Winship this because clicking this button gives you absolutely no feedback as to the fact that something's happening behind the scenes so let's fix that the 1st thing we'll do is what is submitting flag and we're going to set it to true at the beginning of the action research a false right after we get the results back so we knew that is submitting to try the stated buttons announces finding and there's always some feedback that something is happening in the act but were still not done because of buy but match which you can tell I'm doing but if I chapters appointed time 0 actually of a bunch of facing operations and getting on its mobile lines in asking server multiple times to find nearby locations so we're still not reaction ship this to production traders is an issue of unwanted concurrency we've made it really easy to pick up in a sting operation but we also made it really easy to govern leasing operational ones are you running and that's the definition of currency and we want to constrain that so we just add a single line of code we reuse is submitting flag me check it at the beginning of the action in if it's true that mean your body action before that's not done yet so this early survive but match this at least solves the problem of taking off multiple operations are just make sure that only 1 fires off are we are we done very good unfortunately no because the log into our air water we log above Snyder whatever or see and there's a bunch of client-side areas along the lines of constant industry objects we get so frustrated with number that we brought over coding we rewrite reacts and apply the same methodologies only to realize that we run into the same area was slightly different copy it says this usually means you called set stayed on on Mount component so this is just the highlight this is not an amber specific thing this is something that frameworks in general that don't really give you greater basing primitives concurrency primitives it's something you have to deal with and everywhere but the summer stick with our on quickly degrading based example and so we had a little bit of our defensive programming we check if this is destroyed so because components extended the object and the object expose whether exposes whether an object is destroyed you just check this status destroyed returned early so that these potentially dangerous sets don't happen right an hourly any code value this is actually working it's honestly when we start really the by adding these 2 your codebase it's you're probably not testing each 1 maybe you are but it's everywhere in it's such a heroin past so that words but they need a feature request from state in about this as that's good but can you either get a cancel button we add some clients that the geo-location is in great they like to cancel maybe Jülich is some other means of proof that the at the store
spend and so you continue the downward spiral and I didn't actually finish writing this piece of code it's broken if you click Click fine you by stored click again it like really undoes does itself because why would I spent so much time writing on she just make it work so this is a work which you you could imagine doing something where track a sequence number of how many operations you done maybe you can also keep track of the last promise that you found would stash from the result of here and in every 1 of these callbacks to check if it's the most recent promises and not and that was called again where was canceled and then you need to the answers the worst the worst so I'm going on a limb and say that you probably bargained with the designer somebody making a feature request the sand previously had to water down what they're asking you to do because you did not to cancel the sink operation I know I have mn Simeon everyone else probably guilty of that that's fine you need to like build out every single harebrained feature that a at design ask for when suddenly at the same no 1 ever tell you know or reactor where says this is to order duration the this is where American currency comes in yeah and so every written in the previous code to use the so-called American currency tasks and really that that that active ingredients are just this part here where you're going coordinates and then also passing it you get the nearby list stores but this actually hits all all the use cases although court cases from the previous codified but match this thing about 2 times in a row it's not going to keep on setting the progress results and also I can cancel it and it doesn't break I don't really know the Council on risk that all I presentation of his no weird areas a set on destroying anything like that it's just say I on the different things that really go into it but if you never J. never concurrence before new with probably a lot of information so I just wanna point maybe a few things the interesting about this example 1 is that there's no is submitting for yeah that these people get excited about a number of the so is no is the mating flag so somehow that is addressed there's no is destroyed it kind of defensive programming checks there's no check to see if I'm already running because that means are you know at the prevent concurrency by returning early and this may be new to the today a concurrency veterans in a crowd there's no sex at all and line code is no setting sideways result property or anything so this is actually the 1 I'm sort of focusing more on this and this presentation I have before I Ch
the doing that so what
actually is immigrant content you example using about like is it a bunch of different API is just 1 thing is really just 1 thing it's a task primitive in 99 % of evident printers API involves using past really is like usually means you took an action something of an action Taschen moved into his task news the generator function syntax and women as a test that she so is the task of give you give you a better syntax for expressing a sting operations similar to the simple way but in a manner gives you and support cancelation 1st class is also declared API for constraining so not only can you express operation next affectionate cancelable by API that prevents these operations from happening at same time using any number of the proteins and when focusing on more in this Congress our presentation is it gives you want to derive state yeah so as an example the syntax side of things I've implemented the same basic operation twice once as American currency task in 1 as in a sinc function and they both just count of 3 here the task running here's task canceling after to here is the using function variant but this button is not actually possible to implement in any easy simple memory feeling manner because the functions as defined by the job queue classification are not cancelable the lovely but the fact that can be canceled is kind of a deal breaker because it means the only way you can cancel is basically any place personal way you have that some logic after the weights see if you can cancel that's kind of the exact sort of I defensive programming that will will avoid In his nose on to 39 spectral were facing function cancelation there was but it was withdrawn a few months back and layers occurred is that we should propagate used to just using generator functions for awhile which were referred to them using 4 year anyway so we not change anything and if this is like sad news if you'd rather use an existing function syntax at least you can take consultant effect that the way a concurrency traits generator functions as semantically identical to wasting functions the only thing you need to know to do is take any instance for your awaiting a promise and replace it with a year which is the generator function here that using not always so back to all the thing that has through its not just syntax is also a declarative character Kunst constraint concurrency it always nicer constrained introducing this means which only 1 of these is running a time so yeah yes this really often the hot hardest part it's not that every concurrency is empowering you just like spin 6 billion different asynchronous task the same time it's really you driven and you either usually dealing with the problem of how do we make sure that things are properly cleaned up the canceled and only 1 thing is happening at a time so this is where the so-called test modifier API comes so if you just run never concurrency task members not regards isn't which you prevent this from overlapping anyway that's that's the default the article currency constraints if you want to constrain concurrency to make sure that 1 thing is running you got a few options a few ways you can do that 1 is that is used . drop drop is probably the most common 1 it's 1 of these in the example before means that there is already an instance of this task running and any attempt to form a new task it immediately canceled in any cancel task instance that's cancel before in stock we say it's dropped and sets the at the word that use for the task of and she was a different version of news I never use and you I thought I would on but no 1 really is a handful did but it's a little bit too much too much magic our in practice but the other 1 is is really common populating most popular when the dropping restorable on this 1 or 2 more that I might ring up but restorable is when test already running which you transform again it's going to cancel any prior instances and then that makes room for the new 1 around it runs immediately and so you may or may not know there's a thing called task groups I don't use these but I want to sort of just highlight that they exist so all the previous example say constraint concurrency for a single task but what is different tested for operations in 1 make should only 1 runs at a time when you can do is you can use a task group you can say that upload files a task that is of the mind test my group is defined as a task group that is restartable and what that means is that if any of these at each other for many of the past and 1 these groups it's going to cancel any prior instances also in a group to make room for the new underrun soul as I go between these canceled once every time a performance it's canceling the other one's going on their use cases for this am actually personally used it yet but on a definite get sort of the early because people were early adopters have use cases for the surface and so this is all and presented before but I don't really think it talk too much about the so called dried state which I 1 of folks I'm a little bit more and by dry state and just mean there's always an opportunity ever swidden allow the flexibility to let you track your own state by introducing other property component controller or whatever and you can just manually update the state of that over time so you could have used as my test right you have done is submitting from the earlier example and then but much of this that sex to update the value over time but instead of doing that is actually a lot of properties that are kind of built into tasks in these test instances that you should know about because they can save you a lot of pain a
lot of error-prone does very basic example of some stuff it's given to you for free but is running an annex to show you any of the template code before I will soon on 4 that example with the geo-location but if you have a tacit scholarship widgets I'm probably throughout happening the by then you times ship widgets and as you perform then it is running is in good true perform counts in increments what were ones In currency has always been reflect the number the current number of running tax so this 1 doesn't have a concurrency constraints of funds but masses being concurrence is going to go up and it's gonna go down and if anybody ends up to be aware of the slides later it's kind of fun game to see how I can get concurrency before because back down somebody actually cheated medical degree plug in the that the 1 million times it's the things people get excited about that so just with this way more derive state and just what I showed on the previous slide but I wanna sort of highlighted quick thing because I don't think the very people appreciate this aspect of kind concurrency so much and I can I keep chance of how people are actually using this stuff on there's like public debt have repose and use it on sometimes people send code snippets separates you know something that came out the window using American concurrency but still came so 1 that I've seen on the Hampel times and it's it's almost as if people knowing knowing character sort exists on or they just haven't sort of practice this style of thinking but if ship widgets as a shipping widgets boolean property that's managing the state of it is tempting to say OK order so the true or the beginning of the test sensitive to false at the end but there's obviously some problems with that it's completely redundant why would you ever introduced more state that you need to track yourself and probably get wrong when you can use something is built in estimates of the point of failure your chances are you probably going to reorganize when these things get set the true and false and it's gonna break in very subtle ways because there's all we write code this way there's all these timing dependencies for winning set properties when you decide to mutate some property upon it and is actually broken such as their promises actually wrong because if you were to cancel this task well it's passed on this line of code then this line is the going it run in your in it's like you're in and have been shipping widget be set the true even know nothing is actually shipping others another instance that in right down here but Canada struck me but this can run concurrently because there's no constraints and if you run at at time role of the 1st pass to get to this line of code is in a state is shipping it falls even another might be 7 more instances still running so user rights state when you can because you probably get wrong otherwise has written with concurrency occur programs really hard so use what's what's given to you in a sort of a minor problem 1 of my out because the other issues but every property that you introduce several pieces they also needs to have a name and developers like to bicker over how to name things you would you call this flag is shipping widgets or is ship which it's running it olive over and have a problem with that because that meant you need to capitalize the S and then it's harder to grab and so is all these little death by thousand paper cuts problems and you can avoid when you just use on the state that is kind of buildings you attacks and then you can just very easily is record currency where all the components of updates when chip widgets state changes so it's a minor problem they can't comes up a lot in its twenties cases where it's just a little bit of convention that prevents a lot of like drift between apps between developers so if this test returns 1 2 3 you think that there some way that we can actually access that in your a on exemplary there with the other duty example we can use that set so obviously somehow we're taking the return value of that test and Prentice rate so wouldn't be ship widgets that value to be something else and so it was about how to ever concurrency is a lot a that letter a design went into it is there to respect the 4th dimension for dimension being time because there's a lot of seal of attempts to build nice conventions Over promises promise proxies but they don't really there really they become but get conventions cut a little to G but this is 1 way of putting it the kind of choose a happy path at plays favorites doesn't actually make it easy to design a variety of and basic use cases so we when we went on a convention configuration but we don't take it so far that actually hurts on creativity so think the conventional configurations great when chair about and about has the conventions don't limit your potential limit your creativity but when they do in when they play favorites made cosmic certain use cases and that articles really easy to do with others really hard and sort of make you feel that we trying and that's obviously not good so some trying to avoid that with found ever concurrency and an example of this and it's kind of API I worked on a few years back but the the but the fact that you're very much encouraged to load models in
root model of and so it can't is the service so shame that if you're trying to do that loading components the framers have display the punishers for 1 to do that but if you don't you will all of your data and the model hook then you're your sort of in a class of them wraps with that sort of feel very similar to all the other ones you know when you click the link it's you might use loading routing custom go over there and it just doesn't go there immediately you just you can tell you're dealing with like a 2013 2014 member at the same way that you know you started off using Twitter Bootstrap CSS framework and you never really fully separated in Bill your thing then you you it's just another avenue circuit would bootstrap at so this is sort of an effect applied to when conventional configuration x sort of favorites with certain use cases so evident currency doesn't always provided particular convention but has gives you conventional language to express it is issues for you how you what kind of data you want display on what is the most recent successful value for MacArthur completed all the will make sense just a moment promise unknown makes in the words of but this is a long way of saying that is just ship which it start value it ship widgets start last successful value and less successful actually be any number of things it's actually and what that means so it's not bad value this is always in the undefined but you could use ship widgets that lacks the value less successful value so what are these you see where these properties entirely last was less successful so we perform a task it creates a test instance which represents a single execution of task which may run to completion in my fail exceptionally be canceled might possibly be canceled before that you have a chance to run and use drop 1 of our and its these things that actually expose the dot value on the dot rather than being some sort of upper level I'm global property on that on the task object so if you recall this example if you perform a bunch of times your entry creating a bunch of task instances that belong to my task and that value and that there exist on here and when you want to actually have access to those values to the very useful for driving data template you basically have to say which 1 you actually want because multiple task instances of the created under a given task so in other words with the currency there is just 1 . value there is just 1 attempt to load the data on the screen there isn't 1 attempt to its server if the sort of tell American currency which is the 1 but you actually want and when you do you have the freedom this basically define how scalar how eager you're URI wise are when you Sir reloading you get into like reloading data so the top-level tax in this case ship widgets exposes properties to recently performed test instances 1 of his last which is the most the 1 that you just performed which might still be running my eventually 1 2 completion have air less examples the last 1 that ran completion return value last year is the 1 that through an error on which and useful sometimes for displaying like error loading banners and some other things I don't expect you to really take very much away from this slide but just to make it clear is that there will these the sort of the this last last successful in unless year the task and says that ship which just the task woman and maintain reference to every test instance has a value error is successful air so is this clown town is this up and you flip the bozo bit on 1 saying my really expecting to learn all this stuff out will really match expecting you to maybe if you're interested learned to properties on task in a few properties on instance and mentally construct that matrix and head of which piece of data you actually want a writing but at a worse than new unit with co disorder looks like like this so why would you ever do that so come back to this old example I really show you the template code for this but just so you know have a sense of what this looks like in practice so here's knowledge from I against to and here's what I just use the piece a code actually exposes data template we say with submit formed at last successful value as result and we just you know move over and display all the stores and that's how this works and what we use less successful here but with just a slight tweak of the property that you use to drilled on the specific capsids since the who values is data you care about with just a slight tweak you can sort changes you i from something that is always displaying data even if it might be stale even if the users are expressed interest in getting more up to date version of that data you can just make 1 change you can replace less successful with last which this is the but no I can't change down here and then when you've already got results than when you press the button again the results clear elements you basically chosen API that was as
fresh as possible and never wants to display stale data and this might seem like a minor thing but it's just is 1 of these cases that were usually the API guys play favorites they based the promise proxies you at this what other property which meant you lost access to the old attend effects data and if it's just 1 of these slight slight missteps that makes it really hard to for you to move between different styles of the data loading with any sort of like Alacron so it's really nice at all that you have to do is just change 1 property which value you want you want the 1 that last completed word you nearly 1 the newest value even if it doesn't exist yet makes a really really easy and so really this just boils down to so that the American currency there's a lot aspect to the concept of essential state versus accidental state music terms that are I'm sort originated from a white paper for in 2006 called out of pocket and basically paper that talks about the common cases of complexity in get like amount of software and they sort of say that the root of all evil and cause a lot of complexity is so all accidental state it's a state that you don't actually need to reconstruct you know the page interviewing or of the operation that you're doing just status so that duplicated you know you sort of expressive elsewhere and could just read write it in just a very simple example is if for some reason you had an object in your code that was a user's array had 2 elements in but you also had a user account saying to you you should wonder why this is there why did I need to actually make this a piece of data on that I may or may not up been over time was just and which is say users that like what you ever do that so it's a very simple example of accidental state In the antidote no status to use to ride states which is a way of just recomputing values in need based on his bare minimum essential and in in every European prior some experience with using state if you use computer properties so these should be familiar concepts unions know about concurrency is that it pays due respect to derive state over time monarchy to just not lot of information make it really easy to do from sort of comparisons as the data changes a bit stale all these different things that are usually pretty hard in without something like and concurrency requires a lot of mental state tracking which is really easy to get wrong in asynch concurrent environment so in general this is just the idea that you should prefer declare it guys Over the eyes because property mutations particularly when interleaved with a bunch of acing operations happening at the same time quickly leads to just a contour unreadable Mexico that is just going to be error-prone make them and it's really hard to change and evolve over time so much as is never going be a silver bullet and and currency deftly has its words as problems it's certainly worth taking sometimes thought sort of think about the facing problems using deride state and I'm hoping like more people interested in because I I Lambert comparison to give you more than there are idiots so takes practice practices thinking this way but I think it's worth the effort and I think it's also kind of exciting because members concurrency is kind of the only thing like I am saving like and there's a few but actually if you copy cast coming others a reactant currency on and the case on actual angular concurrency but I saw a particle that is re implementing that test function for for supplying generator a function that you know runs a sink logic and so I think people recognize that this is missing from other worlds in that underprivileged I never had this so like a site about this and talk to some of stuff for me but so in conclusion ever is really just 3 things to powerful syntax for expressing a single away that's cancel the powerful declared a API constraint concurrency in at the time and derive state that you can build really express the wise with without going on the the patterns mutating bunch of properties and managing state over time that thank you for uh you
just
Resultante
Bit
Datenparallelität
NP-hartes Problem
Aggregatzustand
Computeranimation
Eins
Komponente <Software>
Client
Serielle Schnittstelle
Code
Fahne <Mathematik>
Speicherabzug
Radon-Maß
Gerade
Umwandlungsenthalpie
Nichtlinearer Operator
App <Programm>
Synchronisierung
Chord <Kommunikationsprotokoll>
Kategorie <Mathematik>
Template
Güte der Anpassung
Biprodukt
Optimierung
Arithmetisches Mittel
Konstante
Dienst <Informatik>
Framework <Informatik>
Wechselsprung
Menge
Einheit <Mathematik>
Rechter Winkel
Beweistheorie
Datenparallelität
Server
Information
URL
Beweistheorie
Aggregatzustand
Rückkopplung
Existenzaussage
Wasserdampftafel
Gruppenoperation
Mathematisierung
Zahlenbereich
Fluss <Mathematik>
Code
Framework <Informatik>
Fluss <Mathematik>
Demoszene <Programmierung>
Multiplikation
Bildschirmmaske
Digitale Photographie
Zusammenhängender Graph
Gruppoid
Primitive <Informatik>
Operations Research
Speicher <Informatik>
Optimierung
Videospiel
Matching <Graphentheorie>
Konvexe Hülle
p-V-Diagramm
Einfache Genauigkeit
Mailing-Liste
Quick-Sort
Videokonferenz
Objekt <Kategorie>
Minimalgrad
Flächeninhalt
Codierung
Web-Designer
Wort <Informatik>
Speicherabzug
Innerer Punkt
Resultante
Folge <Mathematik>
Rundung
Punkt
Datenparallelität
Zahlenbereich
Kombinatorische Gruppentheorie
Gerichteter Graph
Code
Computeranimation
Fluss <Mathematik>
Task
Last
Weg <Topologie>
Datensatz
Arithmetische Folge
Spirale
Fahne <Mathematik>
Leitungscodierung
Kontrollstruktur
Speicher <Informatik>
Optimierung
Nichtlinearer Operator
Matching <Graphentheorie>
Kategorie <Mathematik>
Mathematisierung
Mailing-Liste
Menge
Spirale
Quick-Sort
Gruppenoperation
Arithmetisches Mittel
Flächeninhalt
Menge
Mereologie
Reelle Zahl
Hill-Differentialgleichung
Information
Stellenring
Bit
Datenparallelität
Nebenbedingung
Gruppenkeim
Versionsverwaltung
Aggregatzustand
Zählen
Computeranimation
Eins
Komponente <Software>
Arithmetischer Ausdruck
Gruppentheorie
Prozess <Informatik>
Tropfen
Default
Folge <Mathematik>
Softwaretest
Nichtlinearer Operator
Lineares Funktional
Äquivalenzklasse
Synchronisierung
Kategorie <Mathematik>
Zeiger <Informatik>
Systemaufruf
Konfiguration <Informatik>
Erzeugende
Funktion <Mathematik>
Rechter Winkel
Festspeicher
Datenparallelität
Deklarative Programmiersprache
Instantiierung
Aggregatzustand
Nebenbedingung
Subtraktion
Gewicht <Mathematik>
Klasse <Mathematik>
Gruppenoperation
Primitive <Informatik>
Zahlenbereich
EDV-Beratung
Derivation <Algebra>
Kombinatorische Gruppentheorie
Mathematische Logik
Punktspektrum
Task
Task
Flächentheorie
Warteschlange
Zusammenhängender Graph
Inhalt <Mathematik>
Primitive <Informatik>
Operations Research
Optimierung
Soundverarbeitung
Default
sinc-Funktion
Anwendungsspezifischer Prozessor
Elektronische Publikation
Quick-Sort
SLAM-Verfahren
Mereologie
Gamecontroller
Wort <Informatik>
Hill-Differentialgleichung
Momentenproblem
Datensichtgerät
Zählen
Twitter <Softwareplattform>
Computeranimation
Hausdorff-Dimension
Fahne <Mathematik>
Kontrollstruktur
Gerade
Softwaretest
App <Programm>
Objektverfolgung
Vervollständigung <Mathematik>
Kategorie <Mathematik>
Güte der Anpassung
Gebäude <Mathematik>
Ruhmasse
Bitrate
Instantiierung
Lesezeichen <Internet>
Dienst <Informatik>
Rechter Winkel
Server
Ordnung <Mathematik>
Instantiierung
Fehlermeldung
Mathematisierung
Klasse <Mathematik>
Informationsmodellierung
Lesezeichen <Internet>
Spieltheorie
Massestrom
Widget
Widget
Konfigurationsraum
Soundverarbeitung
Default
Binder <Informatik>
SLAM-Verfahren
Digitaltechnik
Wort <Informatik>
Boolesche Algebra
Resultante
Matrizenrechnung
Bit
Punkt
Datenparallelität
Bootstrap-Aggregation
Formale Sprache
Versionsverwaltung
Element <Mathematik>
Eins
Übergang
Komponente <Software>
Vier
Einheit <Mathematik>
Hook <Programmierung>
Bildschirmfenster
Weitverkehrsnetz
Wurzel <Mathematik>
Tropfen
Schnitt <Graphentheorie>
Torus
Synchronisierung
Rechenschieber
Softwarewartung
Twitter <Softwareplattform>
Framework <Informatik>
Datenparallelität
Kategorie <Mathematik>
Message-Passing
Varietät <Mathematik>
Aggregatzustand
Proxy Server
Nebenbedingung
Ausnahmebehandlung
Hausdorff-Dimension
Zahlenbereich
Code
Framework <Informatik>
Fluss <Mathematik>
Task
Multiplikation
Task
Inverser Limes
Zusammenhängender Graph
Optimierung
Softwareentwickler
Speicher <Informatik>
Touchscreen
Schreib-Lese-Kopf
Schätzwert
Fehlermeldung
Konfigurationsraum
Einfache Genauigkeit
Quick-Sort
Inverser Limes
Objekt <Kategorie>
Minimalgrad
Fluid
Formale Sprache
Entropie
Vollständigkeit
Bit
Datenparallelität
Snake <Bildverarbeitung>
Computer
Aggregatzustand
Komplex <Algebra>
Gerichteter Graph
Computeranimation
Homepage
Hausdorff-Dimension
Deklarative Programmiersprache
Gruppe <Mathematik>
Code
Mustersprache
Wurzel <Mathematik>
Kombinatorik
Lineares Funktional
Nichtlinearer Operator
Synchronisierung
Kategorie <Mathematik>
Auswahlverfahren
Framework <Informatik>
Wurzel <Mathematik>
Algorithmische Programmierung
Datenparallelität
Kategorie <Mathematik>
Information
Programmierumgebung
Aggregatzustand
Proxy Server
Nebenbedingung
Web Site
Mathematisierung
Derivation <Algebra>
Kolmogorov-Komplexität
Mathematische Logik
Term
Code
Fluss <Mathematik>
Weg <Topologie>
Lesezeichen <Internet>
Software
Operations Research
Soundverarbeitung
Distributionenraum
Paarvergleich
Tablet PC
Quick-Sort
Objekt <Kategorie>
Wort <Informatik>
Partikelsystem

Metadaten

Formale Metadaten

Titel State, Time, and Concurrency
Serientitel Ember Conf 2017
Autor Matchneer, Alex
Lizenz CC-Namensnennung - Weitergabe unter gleichen Bedingungen 3.0 Unported:
Sie dürfen das Werk bzw. den Inhalt zu jedem legalen und nicht-kommerziellen Zweck nutzen, verändern und in unveränderter oder veränderter Form vervielfältigen, verbreiten und öffentlich zugänglich machen, sofern Sie den Namen des Autors/Rechteinhabers in der von ihm festgelegten Weise nennen und das Werk bzw. diesen Inhalt auch in veränderter Form nur unter den Bedingungen dieser Lizenz weitergeben.
DOI 10.5446/33649
Herausgeber Confreaks, LLC
Erscheinungsjahr 2017
Sprache Englisch

Inhaltliche Metadaten

Fachgebiet Informatik
Abstract Modeling changes to state over time is a challenge that most modern app developers have to face. The ember-concurrency addon went a long way toward simplifying many of the challenges inherent in safely modeling asynchronous operations, but there is more work to be done. This talk is about time, state management, ember-concurrency, immutability, and how a lot of tricky problems disappear when you rigorously commit to the goal of minimizing non-essential state in favor of derived state.

Ähnliche Filme

Loading...
Feedback