Bestand wählen
Merken

The Future of Ember Templating

Zitierlink des Filmsegments
Embed Code

Automatisierte Medienanalyse

Beta
Erkannte Entitäten
Sprachtranskript
and
so we're not quite starting at but before we start I like to I give you forewarning and what is now happening examine our is you see a lot of very dense intended content and W. be typescript code involved and it would probably not help you with your job and you might actually want to reconsider going to limits on its component parts and so it's going to be a great talk and it's going to be very practical it's going to help you with your job and I you should only stay here you for really really bands technical content yet been warned thank if no 1 wanted right will be but OK so let's get started and low and got can find me on the Internet as genuine code if you were around last year you might remember me as 1 of his favorite speakers will move on glowing reviews from
twitterverse like I have no idea what this talk is about and the chain can build deliberately misspelt and temperature so you may also remember me
as a canadian or perhaps for my very important technical
contributions such as the Canadian she's back from this Vinci effects is some of the glaring typos in this year's suspect and me a lot of things more polite in general so the UK this
is actually an imbecile I get there but unfortunately but it doesn't have a lot of points on Amber observer because then have of downloads but nothing can fix with a few hundred people in the same room and you can fix that for me the but anyway
unfortunately it's not a new job last year but a company called to the since they're located in Portland have no choice but to move Canada to Portland so and very pleased to year for speaker at the conference were community portal Canada and you don't believe me look mobile OSes
my job title as an in-house Canadian at the and it's listed on the conference website singer was true and anyway with my
credibility and blown away from last year's talk I figured the best way to recover from that is to do really technical problem here and and so it probably here for clarity sublimity is if you project and the hidden I have been working on this for over half of the year and they're just way too many but way too much content to fit into a 3 minute talk so I just want to warn you that there will be a lot of waving going on in this talk and yet but I I figured that would fit in pretty well with the
the conference theme anyway our before
began I just want to thank to their and linked for sponsoring out time to work on limited with all the help we probably couldn't take on such an ambitious projects
you probably don't know this but is really cool company as you can see they own the most unable to letter word and the entire English language so as you can imagine there are a lot of times they're aware in the office but I don't think they realize the full potential of the axes there exits so I decide to and give them some suggestions of the of online and I think there signs to
the parking lot to use some work and perhaps they should rename their design
team I and II fix their
websites well on so and I
also thinks they're at campaign
i if you if you know anyone from Lincoln's marketing department please consider hiring as for an exam playing and anyway with all that out the way let's get started
but limited so the history remember we have always been pretty hard on declarative templates in fact all original goal all the amber project was to add templates support to use Brokaw and 1 of the things we love about templates is that it's just a shame on CSS security know how to write them in additive designers of remote to write them and H. all instances is great but and but that's easier said than done because there are actually a lot of expertise is in H moles back on but thankfully it's carefully stacked so people work on browser know how works so that the best way to handled actually is a nation on this is basically the implementation most back and we did that with additional cost we have the spy compliant supports a G and all the weird things in there and I think that result pays off and the other thing like about templates is that they're very declarative and turns of declarative is just a fancy way of saying their pure functional states but when poly they're actually on therefore a few programs whatever that means that basically means and their program that you can run over and over again to get the latest result for them it's way and so I guess I will and leave the rest you here and the rest of the area and fortunately we only have 3 minutes but for jokes about freedom the whole thing comes in and writing it the so the core primitive of glamor is the reference that structure that fundamentally a reference is just a stable object it represents the result of a pure Seyfert for computation were the result of the computation might change over time that so here's the interface is in fact this is like the simplest interface you capacity right underneath you know if you break the metaphor Peters this is pretty similar to a discrete FRP signal are the key difference between references and similar concepts in other libraries including gonna 1 is that references are completely pull based with no notion of subscriptions in education and what we found the experience having done this for a few years now example bases is a better fit for the kind of problem can solve especially when the maximum efficiency is at stake acid to give you an idea for the flavor of references but take a very simple reference that captures the full variable over its lifetime that is a very simple example but it illustrates the power of the reference abstraction you know Johnston variables we just a verb is always contain values that we passed around and held onto by other functions but very by themselves and others you are not first-class values and the idea by references that using a reference system is trivial to pass a variable by reference and hence the name for the reference pattern but to give you a so I I now interestingly because the reference is such a simple concept to begin with it's very easy to compose 2 references so they look here at the which is the ad reference as the group was France and and hand we've had when you have to know exactly how this works but it's pretty small you can competition works pretty nicely I'm it's therefore also really easy to create functional commentator for them and in fact it's very easy to write the usual functional company would have expected from any streaming and when we are affirmative as 1 makes sense for a discrete guidance and I can go into this so much more about reference also has a lot of particle properties for example there also a natural fit for lazy evaluation which makes it easy to implement things like short circuit boolean logic correctly what OK I'm so so at a high level this slide with this I think is template using before actually closes represented by reference on the initial renderer for about a lot of people reviews would pull value and replace the so with that that's very good that of simple you're probably be OK if that's a complicated that will and so what is cool that the core reference interfaces so simple and so flexible and they could also be hiding and or encapsulating expensive computation under on their hearts usually a good idea to avoid recomputing reference value more often than necessary In particular because references modeling pure computations so that means they're basically just taking some inputs and making some based on inputs and is the inputs and change then there's no there's no reason to redevelop the that the value of a reference for example the helpers and words are required to be pure functions that operate solely on its input arguments so is the arguments din change then the result of the helper invocation also wouldn't change and the here we have to have a spherical helpers content which joins arguments together into a single string and upper which takes a single string as input and capitalize all letters in the string so let's see how we can mold that as references and let's start the uppercase helper under these over basically describing a simple map operation that takes a single input and apply one-to-one transmission on it the implementation is pretty simple on basically takes a single references input and to compute the value it takes a value from the input reference which returns a string and call to case on it under content helper is pretty similar story except that it's describing a reduce operation that takes multiple inputs and reduce them into a single value and the implementation is pretty similar though it takes an array of references as input and to compute the value it evaluates all the references into an array of strings and then called join on the rate you arrive at a single strand as you can see the inputs of both of these helper reference are very clearly enumerated out uppercase references a map operation that takes a single input reference as an input so it should only be recomputed if and only if the input reference also needs to be but recompute or if the input reference has changed on the other hand the content reference is a reduce operation that takes an array of references as input therefore and it needs to be recomputed if and only if any of the inputs has changed this % of recursive problem but if we have a way to determine the freshness of the input references and then we also know how to model the freshness of these helper references on in other words we need a system that allows us to describe the freshness of the computation in terms of its inputs this is exactly what the validation system and glamorous assigned to the the core primitive here is called an entity tags an entity tag is a stable object that provides certain guarantees about the freshness of a computation of or a competition result and specifically an entity fact has a value method on it that returns an opaque donation ticket and when you want to catch the computation which also acquired delegation to get from the associated attack on this ticket it can later be passed back in to develop the method on the same entity tags to determine the freshness of the catch value from which returns a boolean value indicating whether the catch the good or not on spent more specifically or more accurately determined whether the catch result have chain might have changed since the validation pick it was printed on I can't spend too much time on this but
so let's set aside the fundamental question of how to derive fraction is in the 1st place and focus on the composition composition aspect of system so let's say we have an extension to the reference interface that requires each reference the have a corresponding tech this tag would tell you whether you need to re compute the value of reference again now again we're just assuming this tag works by magic from now on but with this primitive we can go back to the helper references more and wave and here we have updated the cave of Turkey's helper of reference to implement the tag reference interface so to satisfy the interface we need to have a tag on the reference and from the here we trying to express that is the input reference in changed and uppercase reference also didn't change so we can just proxy detect from the input reference directly the no the and that the content reference is slightly more involved because we need to combine all the tags and all the input text into a single day but but the concept is not that complicated so the idea is very simple instead of having to get up give all single value as the content reference elevation ticket you cannot in rate of validation tickets and reject all them against each of the upstream tickets string of validation so while the energy tax system is frequent very flexible if we're willing to forego some of those for flexibility and we can implement that much more efficiently in Glymour we use a specialized version of the energy tax a simple revision tagging and this system cares the globalization counter with a per object revision on which I can't get into too much details here but the biggest benefit of this approach is that when and allows us to compress an arbitrarily arbitrary number of television tickets into a single integer of making is significantly more efficient use will store and compute the Revell dictionary so working with our there are a lot of details that we couldn't cover here but I've started to write them in a book on the rapport with a lot more details that I couldn't cover here so you should check it out after the talk so far it let's take a deep breath everyone now we have just went through a very quick tour of the glimmer of primitives but how old do we actually build a rendering engine of that so British cells we are are leaving the station again elected give you a very quick high-level overview of other glimmer one-time works and 1 of the biggest realization when we're building limited is that on the template is actually describing African program so we should just do whatever the programming language implementors usually due to make the program as fast as possible and so we build a JIT compiler and by code VM for our templates so what does that actually mean and so what happens when you have a template like this and you want to render that and limited the 1st that actually happens in real time when you run ever built in the terminal it 1st composite into something called a wire format but here's a formatted version of the wire format but is basically just a simple representation of the precompiled to place and this allows us to frontload some of the cost of course in the template at build time so users have to pay any of the cost of notable IEEE we switch from emitting jobs could functions in just coding level 1 to emitting on object in this step and limit which is how we reduce the template size by 5 times and furthermore because now data not coat the browser doesn't have to eagerly you felt a cold and we can differ some of the parts cause until the template is actually needed but before a template is render for a 1st time to user we run the wire format through on the runtime compiler to produce a list of instructions for OWL version machine and for simple operations like appending said trying to non it's pretty much a one-to-one compilation but for more complicated syntax like that if conditional on the compilation is a little bit more involved if you have worked with us and we're by community for the compilation is probably roughly in line with where you expect otherwise might be a limit L a little bit intimidating but you can safely hand without away from the point of this runtime compilation phases that we can take advantage of the information we have at runtime and encode them into program that we can use when we ran the same template of over at 1 over again in the future like for example you might switch away from running around and then press that button you rear-ended that template from scratch again or the most obvious case of this is you have a loop and is the single single components anything you repeat Oregon you have to do is work on time for the entire loop right so I kind example is that when we see it simple Curley's or in other words the curly bracket with a single from string inside it and built and we don't actually know whether that is a variable look out or what is a helper invocation or a component of education because they all have the same syntactical form and however at runtime we can do the triage once and for once for each templated and avoid repeatedly asking that question over and over again as we have we rented a template and the loop or in some in a different so finally only actually get to executing this program and Q different artifacts for I will be produced in the process of 1st it would render this template into the dominant you would expect from because that's kind of the whole point of this thing and now the more importantly it also produce an updating for and then you could run again to rear-ended a template now so even though the origin template might look pretty complicated and there are exactly 2 dynamic dynamic things here that needs to be dirty check every time if you still remember the things went through in the 1st half of the talk of each of these Curley's here are represented by a single reference inside the updating of code and furthermore we also take advantage of the revision tagging system to avoid rechecking anything in most cases on this is how we got to 60 frames per 2nd rendering performance this on the keynote yesterday um that and finally and when we're developing this obviously is very important that we understand what of poems doing so would build this and visualize the thing that you can type in some life templates and play with well look at the compilation of phone and play with the results and with that in a positive you to talk about some of my stations in future work so the point of this section of here to say that if you thought we already did was pretty cool it's actually sort of the big you from line the 1st line of what we can do in here under possess a bunch of optimization is a requirement and in the future there are relatively small deltas were what we've already done I fact the first one is an optimization that we already did I 1 of the earliest optimizations that we target we will we already implemented is what we call the classic optimization and so if you take a look at this is an example of the
optimization at work when we landed at the ah so as doctors as we always take a look at the visualize working at an optimisation try to figure out what's going on and 1 way to think about this is that there's a lot of that we have a component you might have some of properties in the components that are dynamic you say you might say for example the font also out of a library might have a thing I can't I can't equals and then something dynamic or you might say at the I I equals and spring board and if you see the same but obviously there's a lot less things that actually change in practice and so in this case about what were able to do it is in this is actually it was more like what we were doing before was unnecessarily stupid but interestingly if you don't have this architecture 1st it's hard to figure out exactly what's going on so that the short version of this is to say and if there's a constant value that somewhere floating around when construct a reference for the constant I remember that it's a constant value and and whenever we do have any dynamic updating step that we would want to be made based on the input value if we see that the values constantly just don't bother the updating opcode and there's no reason even a minute and in England references can say that the constant we will avoid work at this and is another another part of that
same change on this same at the same optimization could be applied to an immutable Jess object in a read-only field as well as the unbound helper so expressing that something is unbounded do the same thing and we get a lot of leverage at this I want to add this optimization actually pretty significant matter fact because the exam in real application that you do have a decent amount constant values that come from the template in natural ways 2nd although the VM architecture also makes it pretty easy to do adaptive optimizations based on run-time information so let's say that the FBI kind of component doesn't happen to have a component class as so if you look at what happens when you can visualize what happens when you but start running component is that we have to use a bunch of stuff on the bottom IRA that represents the components and after running it does things like run by cycle works constructed upon in the 1st place etc. etc. I'm and the point of the of the supposition that we see it is not the point we can pretty much eliminate the vast majority of that work but we can only do that once we notice there's no component class at runtime and because of this again once at compile time and we get the better the atomization every time a place called which is very important moves but also and if there is the same use many times we only have to do this work on time I'm buffer there's of let's say that we have a component that does not component class and the template is very simple selectively at the simplest way to implement the FAI component is you just it's a template that has a tagging and says classicals FAI I kind of AI kind by mimicking every curly curly for the input right and there again there's really no reason they should not be able to just take the results and and and in line you act compile time of course usually people's architectures can figure that out but the idea is that we we want do something about this I'm so view invoking like again with a dynamic value it's hard to do something you are very good but if you invoke it with the static content you would like to effectively replace the of the invocation with literally just like classical that the icon at the bottom and eliminate the component and the Glimmer architecture so about this optimization I just talked about is basically noticing that the thing that you're trying to do is relatively simple and just by doing the work the evaluation at compile time this is a thing that I've had in mind literally from the beginning of the women to work and it's something that we built the entire architecture to make this optimization way out time so the idea is that if you look at the i at the visualizer the bottom right of the of the icon up was like 10 apples there and what we can do is we can simply we can base eliminate all those up was because almost we know for a fact all the things that it it's doing our for it I of ofyour another optimization that we've had in mind is is chunked rendering and idea behind front rendering is you would like to be able to stop what you're doing but some people have observed that basically you start rendering and some time goes by users from a scroll and things of that the light of only I could just plot elected rather go back in and out come back to the vendor after a millisecond and keep doing that is 1 that the awesome and this is something that is an architectural question it's not always so easy to break in the middle especially most the work is happening user code and in our case because of the fact that again if you look at this thing what's happening is a big list of opcodes of have interpretable that's just running the upward 1 of time it's actually quite easy for us to say some amount of time has done by OK given at the time has done by will just yield to the browser and we come back we'll just continue from exactly we adopt we have written this optimization yet but the actual architecture is a bunch of Caltech that next so it's very easy to just not whole by maximum stop on it again later I'm so again because provide a glimmer rendering is interpreted as pretty trivial for the positive process at any time which will give us a responsiveness which is also pretty important for rehydration and the idea behind region as as you might know is that our we're entity type and and surrendered update once it gets the clients but the thing about reiteration that that is also pretty straightforward with glamor and that's because all operations in Glymour go through elements that which basically works with the band you can see that this is basically the implementation of the Act HTML parser algorithm and its suspect find mentation of the 9 subset of each you how to build algorithm so for example if there's an operation upholstery element and the elements that during rehydration all we have to do is say we instead of actually reading elements Media cursor position and if is great element is being called and the cursor is sitting in front of an element that thing that we simply return elements instead of creating a new 1 so we replaced Justice interfaces these 10 or so methods with something that knows how to process existing Don and that's it addresses system works exactly the same I am not announcing believe not working on that but is also the case that the process exact of executing a glimmer templates of this highly abstract here are the at interfaces that deal with components so there's nothing really stopping somebody from component interfaces in a different way that was designed specifically for I was decisively for native again remember that all that's happening with a template that's emitting much opcodes and the interfaces that you would need to implement cognitive already extracted so you can do something different but I finally got if if that wasn't enough to be in interphase that you need to build the entire freeze the entire system are also well defined and this is the environment of a they ever so if you implement these handful of methods that you also gonna be good so the the the it ever system is built by making the environment which has some some reports here and I'm pretty excited to see people experiment with alternative pose for the glamor system that for example might be more heavily you will models or RTS whatever interesting technology people are excited about want to explore more thoroughly and 1 of the greatest strengths of glamor in general is that it's primitives are simple enough and powerful enough to allow people to model all kinds of data abstractions and that's a match them if they need to instead of the were sort of forced into a particular paradigm and excited to see what people do with so we you can take a deep breath again at we than with the technical part but before about and there's some people I will like to think so this all these labor to work and once again would not be possible is to the inlet them was were not sponsoring for a time but that's not it on the a few weeks ago I will like a strategy are as world is very long quest region did have and aligning a lot of work that we love to ground work that was done after due to get limitation In Amber and um and the time at honestly wasn't sure if this is going to be a good use of time because of its free closed ever come with a lot of work to do and this up like took an entire afternoon to write and not sure we will read it and but in the end with community has proved me wrong but just a few hours later after this was he she was postponed on over and over the weekend and we have received many may 4 plus flowing in from people and to find that now there's no tuning fork less waiting from user review on and that's very also on in particular chat and Gavin has paved the way to supporting a lot of these new tests and so for example Robert on a core team has landed the actual future flight that allows you to enable is on and but a lot of contributors of new contributors that have never contributed to ever before has responded to the call for help and open multiple poor request you help with this effort and that that's not even because we couldn't have built amber to limit you will focal 1 with lational boss will handle bars and all the words that have paid paved the way up to here and so on a lot of contributors have paved the way for us and that got us here today and based on what you could use talked about I think the future here is some pretty bright for us and I just wanna say thank you everyone for being an awesome community member and yes thank you for being also and even they've actually there 2 more things of speaking of letting you the community you know what they thank you community you should actually give yourself a round of applause few a few that's speaking of thinking someone from India today we're told me someone made
these stickers for me and thought they were pretty also but I don't know if you make them so I don't know if you to think in this on this secret person also drum more stickers years so if you know who this person is aware of you know how I can get more of them because there 1 some of these come talk to me afterward and there are there is or have some figures use so you want them in come us for them off the dock and and finally there's 1 more thing
good so 3
or more months ago 6 while the labels is like the year time we started so we had a good idea for slide and becomes an idea to get a lot of work and we thought we would definitely get a by yesterday but for a whole bunch of comedy there's begin end up getting a demand of arriving on time but we didn't give off it is less than hours on the phone with various people and these things are here but you know I give up again and I we have special final slide and for those of you have made it through to the end of the conference so here's the here's the slack at the 3 different pathways everyone gets just 1 if you stop by the registration desk for 620 others such as random you get whatever staff member graph out of the bag of words we don't get to choose and please don't otherwise trial negotiate chain is encouraged if you want to complete a collection you can buy them at a deflected will involve 8 run out thank you very much thank my
Datentyp
Content <Internet>
Code
Internetworking
Dichte <Physik>
Videokonferenz
Komponente <Software>
Prozess <Informatik>
Gruppe <Mathematik>
Code
Mereologie
Inverser Limes
Skript <Programm>
Zusammenhängender Graph
Inhalt <Mathematik>
Soundverarbeitung
Verkettung <Informatik>
Punkt
Prozess <Informatik>
Kategorie <Mathematik>
Luenberger-Beobachter
Auswahlaxiom
Web Site
Prozess <Informatik>
Projektive Ebene
Inhalt <Mathematik>
Vektorpotenzial
System F
Vorzeichen <Mathematik>
Formale Sprache
Binder <Informatik>
Wort <Informatik>
Projektive Ebene
Hilfesystem
Office-Paket
Web Site
Sampler <Musikinstrument>
Korrelation
Offene Menge
Mereologie
Extrempunkt
Browser
Compiler
Extrempunkt
Poisson-Klammer
Dämpfung
Mustersprache
Radikal <Mathematik>
Gerade
Phasenumwandlung
Schnittstelle
URN
Pay-TV
Kategorie <Mathematik>
Computersicherheit
Gebäude <Mathematik>
Boolesche Algebra
Bitrate
Einheit <Mathematik>
Rechter Winkel
Zellularer Automat
Bildschirmsymbol
Fitnessfunktion
Zeichenkette
Instantiierung
Schnittstelle
Subtraktion
Mathematisierung
Diskrete Gruppe
Überlagerung <Mathematik>
Virtuelle Maschine
Loop
Variable
Bildschirmmaske
Datentyp
Programmbibliothek
Primitive <Informatik>
Inhalt <Mathematik>
Datenstruktur
Maßerweiterung
Ganze Funktion
Programm
Videospiel
Protokoll <Datenverarbeitungssystem>
Just-in-Time-Compiler
Rechenzeit
Programmfehler
Zeichenkette
Echtzeitsystem
Wort <Informatik>
Rekursive Funktion
Boolesche Algebra
Partikelsystem
Resultante
Bloch-Funktion
Bit
Punkt
Prozess <Physik>
Minimierung
Atomarität <Informatik>
Natürliche Zahl
Selbstrepräsentation
Gruppenkeim
Versionsverwaltung
Computerunterstütztes Verfahren
Template
Übergang
Deklarative Programmiersprache
Prozess <Informatik>
Mapping <Computergraphik>
Stützpunkt <Mathematik>
Bijektion
Inklusion <Mathematik>
Nichtlinearer Operator
Parametersystem
Lineares Funktional
Bruchrechnung
Deltafunktion
Template
Abstraktionsebene
Systemaufruf
Ähnlichkeitsgeometrie
Ein-Ausgabe
Rechenschieber
Verkettung <Informatik>
Ganze Zahl
Deklarative Programmiersprache
Garbentheorie
Projektive Ebene
Information
p-Block
Versionsverwaltung
Schlüsselverwaltung
Aggregatzustand
Wellenlehre
Implementierung
Zahlenbereich
Zellularer Automat
Gebäude <Mathematik>
E-Mail
Term
Code
RFID
Referenzmodell
Message-Passing
Rendering
Arbeitsplatzcomputer
Inverser Limes
Zusammenhängender Graph
Optimierung
Leistungsbewertung
Leistung <Physik>
Programmiersprache
Lipschitz-Bedingung
Rechenzeit
Validität
Einfache Genauigkeit
Kanalkapazität
Datentransfer
Mailing-Liste
Physikalisches System
Fokalpunkt
Konstruktor <Informatik>
Quick-Sort
Mapping <Computergraphik>
Objekt <Kategorie>
Energiedichte
Flächeninhalt
Zahlzeichen
Mereologie
Verbandstheorie
Speicherabzug
Quelle <Physik>
Compiler
Browser
Iteration
Anpassung <Mathematik>
Client
TUNIS <Programm>
Algorithmus
Gruppe <Mathematik>
Gerade
Schnittstelle
Softwaretest
Gebundener Zustand
Elektronischer Programmführer
Kategorie <Mathematik>
Güte der Anpassung
Konstante
Benutzerschnittstellenverwaltungssystem
Rechter Winkel
Programmierumgebung
Cursor
Schnittstelle
Subtraktion
Klasse <Mathematik>
Mathematisierung
Ordinalzahl
Unrundheit
Whiteboard
Informationsmodellierung
Reelle Zahl
Globale Optimierung
Datentyp
Endogene Variable
Programmbibliothek
Äußere Algebra eines Moduls
Primitive <Informatik>
Inhalt <Mathematik>
Konvexe Hülle
Rechenzeit
Parser
Zeichenkette
Bildschirmmaske
Offene Menge
Wort <Informatik>
Compiler
Resultante
Prozess <Physik>
Punkt
Element <Mathematik>
Minimierung
Natürliche Zahl
Versionsverwaltung
Kartesische Koordinaten
Element <Mathematik>
Arbeit <Physik>
Font
Minimum
Programmierparadigma
Visualisierung
Nichtlinearer Operator
Dynamische Optimierung
Template
Abstraktionsebene
Klassische Physik
Systemaufruf
Programmierumgebung
Ein-Ausgabe
Bildschirmsymbol
Rendering
Teilmenge
Datenfeld
Strategisches Spiel
Information
Ortsoperator
Gefrieren
Implementierung
Sprachsynthese
ROM <Informatik>
Code
Puffer <Netzplantechnik>
Multiplikation
Rendering
Inverser Limes
Zusammenhängender Graph
Operations Research
Hilfesystem
Leistungsbewertung
Matching <Graphentheorie>
Diskretes System
Befehlscode
Mailing-Liste
Physikalisches System
Quick-Sort
Objekt <Kategorie>
Mereologie
Hypermedia
Dreiecksfreier Graph
Speicherabzug
Computerarchitektur
Verkehrsinformation
Term
Figurierte Zahl
Rechenschieber
Subtraktion
Verkettung <Informatik>
Graph
Registrierung <Bildverarbeitung>
Stab
Güte der Anpassung
Wort <Informatik>

Metadaten

Formale Metadaten

Titel The Future of Ember Templating
Serientitel Ember Conf 2016
Autor Katz, Yehuda
Chan, Godfrey
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/34716
Herausgeber Confreaks, LLC
Erscheinungsjahr 2016
Sprache Englisch

Inhaltliche Metadaten

Fachgebiet Informatik
Abstract This talk is a technical deep dive into the implementation of Glimmer 2, and what it will enable going forward. It will cover the basic architecture of Glimmer 2, how it integrates with Ember, and how it fits in with FastBoot, Progressive Web Apps, and Off Main Thread rendering.

Ähnliche Filme

Loading...
Feedback