Merken

React Native & Rails, A Single Codebase for Web & Mobile

Zitierlink des Filmsegments
Embed Code

Automatisierte Medienanalyse

Beta
Erkannte Entitäten
Sprachtranskript
the and here
and their books that things that and start so what I've always loved about rails is just how productive I feel when I'm using it and before rails I spend lot of time working in Python Django in PHP and don't natural sort of thing unlike a lot of things about them but nothing is ever come close to rails as a framework language combination the began to move so quickly from an idea to something that works the working version of that idea under the given working in rails I don't feel like I'm spending lots of time solving web development problem Felecan spending time solving the problems that relates to the thing that I'm building things that are unique to the following I'm trying to solve the I just never felt like that about mobile spend time building native mobile applications and in Java Android while I quite like languages adding the 2 and very impressive I've always felt that spells felt like I spend a very long time solving fairly standard mobile development problems very simple things like making API calls like assisting data things that I assume every other mobile developers also solved I feel like has been unusually large amount of time trying to solve both myself if you add to that the fact that realistically if you're targeting native apps that I listen and draw it and you have a Web version as soon as you start supporting all 3 platforms for every feature you build you've already 3 developers to build and at some levels really pushed back that means I've always been the guy sitting in the back of the room has been planning saying no but I want to the native yet because of me to be hit a rapid activity and because of that Isabella time over the last few years looking for magic bullets which calls don't exist spend time building a of fiber applications employing with fungi and so trying compiled to native solutions such as accelerator right a wild birds have a lot going for them I've never might make item fiber application that actually feels like a native application it was feels like a web application has been made a the federal Mobile and the compiled later frameworks 1 impressive for anything nontrivial seem to jet generate quite quickly into if and do this if I West do this which is hard to test it's hard to maintain and uses a lot of the supposed benefits and that's until about 18 months ago may 2 months ago have a couple of our work we thought pain react for our web applications and and little mistakes we firstly the act but relatively quickly over a few months we got to stop we were quite happy with we started in converting small amounts of our front to it very quickly with whatever they cross now Facebook um cells all I'm to put react forward as as learned once white anyway as opposed to write once run anywhere the was kind of sceptical this because this thing so much of this if Android do this if I let's do this type code the platforms as a same thing but we very pleasantly surprised we started working in react we found that almost everything that we learned building react applications for the Web was applicable to react applications on mobile if you try really hard as possible to make exactly the same mistakes on both platforms and but not only was what we learned architecture development we found that the libraries we're using in react where a majority of cases we can reuse those exact libraries only at native and that was brilliant because that meant for the developer productivity point of view any developer who provided the work when I went codebase could pretty much instantly get up to speed to start working mobile code that's and that's really exciting I sort of a big lead to go from well libraries adjust the people's code to why can't we then we use our own code across platforms and the point we started to get to is that a large a large portion of our business logic and so the vast majority our code we can now share across and completely native applications and how Web applications and the outcome of that reason I care about it so much is that if we want to create native applications and a complete set web interface lower than that being 3 point the effort to support the platforms it's maybe plus 10 % for the additional platforms we want to have the we want to support and as a result I no longer the guy said about the room going going to native yet because we any profound may develop do it but so and then by the way I answered your company could catapult to stopping platform based in London and splitting up the type of orbital within about docker or and deploying service why can't a full stack developer and Jimmy much more comfortable setting up into structure or building API is that I am doing front-end development I would much prefer front-ends essentially just bootstrap or at least often so I started working with react and we know what a coming this tool is because this reaction react native stack is the 1st time I really felt the tools that although I have made me is productive building front-end applications as a can be building wells applications so the kind 3 areas I want to cover it think we have enough time for and 1 of them is just a high level what is a production react application look like where the components of then a little bit more detail on what is it what are the important considerations for that stack if our main aim is the a minimum level of fiction when sharing code between a where any native and then finally a kind of the other end of the detailed spectra of the looking back over the last 18 months when I waste much time 1 of the very small things that I spent a disproportionately large of time try a large amount
of time trying to work out and I was sort of thing that which people told me and others 1 through a few was anecdotal bits of I hope be useful to anyone who tries to pursue this this part themselves so the 1st of many important thing is we act is not a framework it's not like something like angular that include pretty much everything you need in order to build a front-end or a JavaScript application we have is essentially a view that we act provides us with a decorative model for defining components we passed into those components of the past data into components and react works out what needs to be rendered to display those components based on in so if we're building for the web that we react dome it we hate e-mail that's coming up with for us and for building native badly native components to react native but fundamentally we have doesn't provide any of the rest of the stuff it doesn't provide a way to make API calls it doesn't quite a way to deal with the systems and that can be a little bit confusing when people talk about this is built in react all of course is meant by this is built in the act is that the act is being used as a view laughter and a collection of libraries are being used divide everything else and as a rails developer I'm quite spoilt I'm quite used to the fact that generally for any given component of the stack if it's not provided by rails there is probably a community consensus on always a 1st time doing it just use this and just that well that tends not to be the case it was you should use this that this we can probably this next week and it's all very stressful very tired and so when the god now we by no means the react stack but I mean we're not just it's the best 1 or the only 1 they suspect that we've been very happy with this 1 I probably seen most usable prof other large and codebases at 1 we found is very very friendly if you main aim is to be able to share your codebase across wet and mobile with maximum reuse so look at stack is going to need forming components is going to need a richer and a rich job in reactants is purely to take for example slash logging in a browser a work out based on this you're well which components need to be rendered similarly in native mobile application it knows that you on a login screen and it needs to work out which components need to be rendered to provide a login screen yeah shockingly in talk about the actually going to need some implementation of we have for the web we're going to need that doll and phonated wouldn't need react native state is a little bit more complicated now as we said we act is not a framework the so there is no right way of managing global applications they can react with no react way but that said there are certain patterns that have been quite widely adopted across the community and patterns that we found to be very beneficial and rate conducive to this culture and this estimation approach and you may have heard of them referred to as the flux pattern which is I think of the original wall or popularized it or you may have heard it referred to and by the name of the implementation of pattern of for example the docs which is my personal favorite all those implementations and these patterns these implementations are developed was a reaction to the fact in a modern JavaScript applications it can be really hard to answer the question what is the current state of mind and how did we get if you imagine at at a good after the application now you may well have a selection of model getters and setters and you may then have callbacks within the dome which are directly updating those models and you political to make the cools which will also when they return update those models and very very quickly we end up with quite complicated race conditions where it's unclear well was this updated by bottle likely 1st or was it by the API call and was more importantly it feels by non deterministic it feels like each time we do it but we can't get it something different will happen so we don't really know what I state walls and we definitely can't replicate that states the and so what something like products us is a imagine that state the entire state replication is represented by a single job script object the is additional delisted application what we might do if we want to change something in that state is just have a callback someone clicks on something and then we directly manipulate the contents of that object and to reflect the new that the new values that what the problem there is the potential lots of things in it plating it once so it's unclear exactly what the value should be at any given time but when the sensing like redox at your state is immutable the habitation state can only be changed in 1 way the only way to change the state is to dispatch was called an action and action is a description of the change that you wish to make to the states and when the action is despite you you so you pass that action on and the current state of the application into a function without functions job to work out what should the next state B and return a completely new object without state it the rest of the application can subscribe to updates to the state so that you why for example can respond accordingly but can't directly change state this maybe however linear Q of changes everything that wants to make a changes back to something and they go through this process 1 by 1 and there is some amazing truing in around this approach that allows to step through that so we can at any point to get a completely deterministic answer to what is the current state or application and how they get almost more we want to we can rewind through that we can step backwards through our state and understand what would application of applied at each of the states the whether the the as little bit of an
example because this is quite call to the the architecture that we've adopted they have a very very simple example imagine that which is just 1 bottom and you press the button and increment the count of name the amazing game is to get the count was highest possible I've seen worse in the of but is and so and so see labeled initial state unit your JavaScript Object represents a global states it has a property count which it begins as warning has the name of our current news and the rise in a traditional jobs that application if we want to update the count we might have a callback for the bottom and when that's it goes in and updates this object if using readouts we don't do this what we do is dispatched the action bottom the action is a very simple joules that object which has a type property in case increment and a payload which in this case the increment by but can be any combination of the GoScript properties of objects within pass these 2 things are applications come state and and the action into this reduces the counter rejects that's a very simple switch all it's doing is looking at the type of the action and then working out what changes need to make the states but still it doesn't change the state it creates a new object it emerges in the existing state and then makes any changes to this new object it and returns this and is a real object which is the new state of application for the rest of IUI for example of subscribe changes to this and then the next action which is in the queue to be applied will be applied to this new state we have a very simple very linear way of modeling what her application status finally we need something
to and manage side effects and I found side effects the term quite confusing to never heard it before and it turns out that when the what about side effects and very short we just mean asynchronous stuff
and so in the case of ah counteract ImageNet because it's become very popular we want to maintain leaderboards we no longer doing this just in the when you press that button we want to kick off an API call out which can then update the server and and maybe get back the current leaderboard rank all values of the so this case you would have a library and if what when working with redox suddenly leaves some redox or the for this and this basically listens factions being dispatched and then it kicks off and something asynchronous so in this case you've been API call when the asynchronous action returns it will then generally do something to handle it most of the time that will be dispatching additional actions for example in this case we might expect action that updates the lead the rank value and and used in our states and to reflect the user's current right the so those exclude the 4
components that will end up with no real sort of other libraries things wrapping API architectually those are the 4 big components and so we don't have a question all of what should be should what should be shared and what can be shared between a web and mobile codebase it's quite important at this point the reason I was interesting this originally wasn't because I wanted a way to make peace unified versions of native applications I haven't come across very many production applications where the web version is just a scaled-up version of the mode of action so my assumptions going into this is the the purview layer of a key to review layout of a member of a mobile application will probably be very very different to the label web applications that can be anything from the fact that forms which only 1 screen on a web application may well be 3 4 or 5 screens on mobile the fact that the entire structure the application may be I kind of like mystery we're working in rivals if we build a web application want to Jason API roughly what we expect that to look at is all about business logic will be sitting in the fat models or possibly these data service objects and then will have some scanning control of some reading and some views which take care of the active display that data we would never consider having a single view for Jason API and and our HTML Web you and because of the full of if Jason view that this is within this and that is very different things I we found applying the same approach to sharing code here makes a lot of sense that recommended reading and the actual components the view that I'm on shared but the management of state so how does the state replication change when at 1 particular actions occur and the might side effects a thing like API calls can be shared very easily and that bits angry at the bottom tend to make up the vast majority of the codebase so the benefits and efficiency from sharing them are quite large worth having a look at a practical examples and pretty much any application will have some sort of looking page so to begin with we're going to go to a log-in page every 2 would determine what components to display and then we don't have the the layer that displays and the 1 feature they could be very different 11 mobile what we need to the log but it doesn't really matter what your platform there's something quite similar is going to be happening the we don't want to dispatch of action to update applications global states at the very least with public and want to update some sort of flag which says that we are currently trying to log in that way whatever you why we have can listen for this flag and if it's true then display some sort of limiting progress in the harmful at the same time we're also going to dispatch something asynchronous an API call actually local using it so that I have a side-effect listening for that node in action think itself is API calls of this API call is gonna go off the server and come back to that side effects going to wait his can listen for a successful response to a failed response and have passed handling each 1 we get a successful response at the very least we don't want to update our states to say we're no longer trying to log in to that progress there could be hidden what's more fully stalls next today so it'll be analyst or a unloading token for example profile data about the user and ideally we leave them on the look pay within redirect them to a dashboard often page your travel game account for the account 1
and so the simplest way to do this is we than have a side-effect issue redirect and are rooted in sense and page and this is a bit looks very simple but it all starts to come will fall up but but closer pension that what really well and this will start to crumble fall apart and because what we have here is a side effect which is city shared doesn't matter what platform where on what was going to want to have something that happens after login but this side effect is not talking to our intuitive cities non non-shared so I decided that and have some have to have some sort of if where do this is my body this in it or would have to stop sharing this side effect 3 we don't want to do this and as is often the case in the jobs that world it turns out the solution to this is callbacks are we
actually want to do is if we go all the way back to the start of the slogan flow when that log-in button the component containing the log-in button will will also define callback functions it would define on success and 1 failure and recall that the non-shared component of you compile Abby layer is non checked so it's fine for component to know about the route to know how the root worked and know with someone should be directed afterward on the side effect has to know is the kulaks will be passed in and they will correspond to a given interface i.e. what parameters to policy then a side effect is completely shareable and callbacks also have retained their encapsulated within that non-shared logic that been what
this shows is that In the same way we end up with a we which shared business logic by including it in models or service objects in males by following something like this approach where we stand share
actions and reduces side effects how we don't share average to AC components we end up with something that a lot like building a regular react application this is really important because we found as long as we follow this and pattern will using the same libraries for native and for and for wet and so developer who can work on 1 is pretty much in the productive in the other 1 and now that this letter we don't like it seemed disingenuous not to include it is in my head is is very all did this before a very clean side effects or we shared and view as was yet this you can see we have is very often the kind of faded out side effects that the goes in the non-shared categories and it is actually the 1 particular area where there would definitely be side effects that you choose not to share and the sample AppleShare the end as an example of this and that's generally a native white uh native functionality of the device I'm talking about things like uh if you want to interact with a GPS you clearly have asynchronous pages there which is devices GPS returning you cornets and it takes a lot of contortion to come up with a way that should be shared between 2 platforms because you never need their on web and I waited quite a lot of time I started doing this trying to be overly purist about it and make sure that this done in a component that was passed to this in the shared and side effect and is this is really important and at this point the talk is that this makes quite a big difference to how you structure the Oval application because 1 approach is to structured in such a way that all of the code the glues the libraries together and says which side effects in which I'm reduces which actions are related at 1 approach is to have at a standardized and then make exceptions to other approach to how whether native define that set up behavior explicitly which makes it very easy to add these exceptions in when you want to know where a lot more sensitive example code at the end and but if you choose 1 approach changing the other 1 is something of a pain so it's worth designing for that that from the very beginning we have and that pretty much covers the project actually what I found that works and we found that this is generally quite a production environment working it's quite simple environment to work in and importantly promote which if you'll falling into 2 willful react web I form or those moment because react with popular much longer generally it will be completely applicable to react native as well and this makes experience working on of working on this very very simple and you find that NASA would react native sensing devices and specific obviously 1 applied to the web but in general this is just like working on a regular react application nothing particularly special about it and that kind of covers the full architecture side and what we are and how we found sharing works so the rest of this is mainly about the bits like kind of really messed up early on this that's why with a lot of time the 1st
1 is that we all building native applications that means that we do need uh next card project we do need a cradle file we do need Objective C code beginning Java code and happily react native includes a CLI which generates all of this for very very efficiently and now what we had native of generators quite minimal be different works out because I never want to try and retrofits uh react native interweb project again even if I'm making a web project by things any chance or want to build a native version of start by generating the native version just so without boilerplate is that then Apple where it afterwards now the built-in sailor generator is fine but very minimal it's completely on opinionated is the bare minimum code you need for react native and other rails develop I don't really really have an aversion to writing boilerplate and we don't like it and as a fantastic generated by the guys infinite red uncoded now did not generator is just a layer on top of the and the regular react CLI at seed-only divided is introducing additional dependency it's not something where it goes away will cause problems for your at all it's doing is generated by deployed Stephen ignite generator and and the full components motor on it will take some of the most popular libraries from those it will set them up and syllable boilerplate that links it for you this is not a good reason to use something they also generated at folder which is a well developed mechanical far more comfortable and because everything is an actual and that foldable popular vote of each with familiar you have in their subfolders for things like sagas which is for a side effects of a redox which is for estate management components which is 4 components ready and the 1st thing I'll do is we factor those into 3 subfolders the only reason that that you work its slide is because something you may want to do quite early on is take a shared code and turn into an M package and if you've done this from the very start it's pretty much trivial to pull that shared code out and then B M package because all of file possibly relative everything already be properly namespace and that process will take a few hours rather than a couple of days if you haven't to unwind this from other places the final
1 which ended up taking an awful lot of time and the way more time I like to think about really really and is Babel RC and now table is a all Babel can be used to transport oil more mores and a dialects adjustment like yes 6 into and forms a task at which a compatible with much older browsers so if you've use react with before you almost certainly will come across Babel for this process the working with react for web the standard way of configuring a Babel is bagel lossy file in the roof project and the in here you define what transformations should be applied to your job could immortal term that water is really really important and now we have native doesn't use of velocity file it has it does you Babel somebody has definition baked into it a workflow I discovered them in a very painful way is extremely possible is you wouldn't add lossy file to the roof the project to configure the web the web site of the project we are native it seems a babe lossy find with the root of the project but will then use that gave us the file to the exclusion of all own configuration so far so good so good to a lot of and tutorials that explain how to set up a Babel rc file and for you to the native the problem comes because we have native and have the packager which caches incredibly aggressive this is to make it so that when you make a change to 1 filed you don't have to go through we Transfile everything in node models essentially the now what is very easy to do is you make a change your Babel rc file you test it on web text on my bot everything works brilliantly you committed feature move on in days or weeks or hours whatever past and then something happens which invalidates the cash and you suddenly get most uninsured your messages you will ever encounter like favor this type have no other words on the screen just type are in white on a red background it like a some sort of um and so then you do it any response would about a dozen step backwards through your commits to once you knew working that everything stopped working again but calls nothing does start working again because the change debate velocity occurred a week 2 weeks 3 weeks ago and then eventually you consider scrapping the whole thing of becoming a power mower carpenter or something that about working with JavaScript I the the and this solution is painfully simple whenever you make a change of a velocity start react package manager with Python hyphen reset cash that it will break immediately and you will know your problems occurred due to the changes to your by velocity file true story and now hopefully what kind of covered here is the high level architecture stuff in terms of what makes sense to share you can share it I hopefully the kind of and the across the some really was very real productivity gains arising from its Reznicek excited to talk about it is this has completely changed what stage in a project I now think it makes sense to start supporting native application because I now don't see supporting both whether native as something that is only going to require either a big drop in velocity of features or too high a lot more developers and to me that's really the change so why can't we cover this tool is the kind of detail of how you know these like these together what I sharing actually looks like so I've done is put a sample project that's talking computer could predicate forward slash Brill's called 2017 is a personal project I've playing with for a few months until geolog us you will run different countries and it tells you where you been shows on maps of an important thing is it and demonstrate what the sharing looks like in the in practice and the both the IRS and web bits are open source as is the rails API Server behind it so you can get a completely functioning up and running and play around and see which bits of this approach you like with with the dice and the much everything I forgot to questions and so we're public based in London we of course hiring if you think this stuff is interesting and please drop me an e-mail and then a joint edible DoCoMo Grammy hearing a coffee and were in London but most the polity his remote um and yet become trapped at thank you so much listening to this and was really good fond of any questions the few yeah absolutely aquatic wouldn't get it is when your um structuring actions is the way that you need to restructure it and when the act we structure from a single file they at the big and yes is a short 1 so I'm a big fan so redox and eloquently source which is basically some nice and syntactic sugar on top of redox and that pretty much provides a framework for having multiple and multiple edges of files and then ensuring that so if we go back to that 1 you can have 10 or 15 or 20 files containing these functions and it takes care of making sure that when action comes in it passes it to every single 1 of those in sequence as you can break this code up and make you very very much that sort of yeah great question so if if you do actually need a sponsor also the mobile interface of the web version in which do that is that direct yes to having said I was originally interested in making item 0 5 versions of that that that'd exact I have moment it that we also do need a unified version of our application which is upsetting yeah and so 2 approaches and not entirely both from the moment so I'm not sure which is the best 1 the simplest long uh we found is um because we tend to use the bootstrap as the basis for everything it's very easy to convert our web interface to be a response of my bar there is also a new framework for Microsoft Microsoft a loads of really really cool react stuff which wasn't unlike the export expect a year ago and and they're working on the likely which actually allows you which is intended and to be an abstraction layer on top of react at which allows you to you and define components and then have it work out what
component would this be for web of war component would this be for mobile so that's what you really want to do if you had to have news a little bit of flexibility in terms of what native components what components you can use that may be a solution and 2 that I haven't used it as a combination of it if you google it might reacts cross-platform it would have come yet the question was how do you manage keep it wet when I was and would have a different components had you might keeping them separate and the honest answer for majority of stuff is I try not to some generally uh I haven't heard because many of them quite a good job of working out given the reactor component what the native component should be and providing a common interface across that I incredibly sceptical of things doing that because everything else like tried that never really worked so far reacts worked quite well and so I don't think we have any production code the moment where we've got switches for display something different for virus Android because generally the react defaults for how to display this particular control type on each platform on how to use the the native combines the platform has been good enough for us to know something had to deal with and he but was very questions what the party some sort of standard sort of and what about my old-fashioned side rails versus the kind of this clients I just application and honestly I've never found anything that I'm as productive in as making a server-side well sensible to make something incredibly quickly a rails + Hamel I just find that incredibly fast I think what we found with this is once you get sort of a few months and so it's beyond so the simplest application on those different in that it actually swung the other way so it's far quicker to build the 1st version in and in server side rails but having this very clean separation of the API server and then the front-end application has actually been formal maintainable you doing maintainable fashion and so I think a lot of projects I would actually I never thought I'd say this I would tend now toward wells is the API server and and um so sort of some variation of a stock as a front-end that because after 2 or 3 months I probably expect to be more productive in this version than in this over and the come iris and each node star that make it absolutely not i is I was super impressed even without smoothing I generate and so on and you a download react CLI and you will have to follow some of the Getting Started stuff all elements of X code projects and and we project just installing STK but it actually did just what I never believe when someone says it just works in the context of mobile development but but he really didn't of generates a project run the command and it was of money a simulated theories know a thing this yes gray great and so it is it is the element of web you to this was a native you I combine it all Native UI components there is no there's no when viewed as a of 5 magic going on and anything any component the computer react native I will generally map or does mapped to native components and so does have a corresponding bill in Germany and corresponding performance and could of course sort of course money performance for a standard applications that are displaying lists of things and patient taking data and I'm sure it so that it would be simple making games but for most typical applications that are just taking information and putting information out as compared with providing prenatal components that pretty much made people had any pain points working that made it only given sigh Android that really unfair um but yes actually Android to an extent no because we energy any was an Android but just because the development price is a bit different but because pretty much of it what someone iris device works everywhere in the world to want a device it different work everywhere because they're significantly different so sort of an automated testing that sort of thing we found are very reliable ways of identifying bugs in my was applications and in the majority of Android applications but you can't get away from thank you need the extra labor testing across and we devices with different capabilities co and so what was strategy we want to do a lot full of customization UI I always to levels that 1 is the increasing if and when you look at a lot of the very custom components that is quite heavily styled Jimmy react is quite good at doing that and so you can get quite a long way like that and if you reach a point where I you actually need to write a custom control that platform and this is something I've only done wants and so I'm a long way from Objective C or Java Expert under the program for the the UN program process developing native plug-ins is relatively simple um and making sure you do batteries when making testable and so it's it's fairly easy to do if you have to do that is not something I have a mass amount experience with show so I'm an experience working with the native wrappers for Turbo links and all that like working with an what that compared working with the act and ideas in in test projects to try to myself but never used production so 4 be taken as there is a big interest so I was quite impressed with them are more broadly about the reason of shied away from using in production is they just seem bravery Nietzsche and there isn't a huge longitudinal people with experience using them so just as it does from a selfish point view in terms of attracting developers there lots into being will develops out there who really want to work with the react react native and far fewer who want to work at turbulent because it's in support of length of native just because it's in something that it's not necessarily clear how in demand that skills going to be in 2 3 4 5 years time and so it's not something I've been particularly keen to put into production called uh that everything thank you very much fewer
home patterns used FIL
Resultante
Bit
Facebook
Punkt
Extrempunkt
Natürliche Zahl
Applet
Schaltnetz
Formale Sprache
Web-Applikation
Versionsverwaltung
Zellularer Automat
Kartesische Koordinaten
Maschinensprache
Mathematische Logik
Systemplattform
Framework <Informatik>
Code
Computeranimation
Übergang
Benutzerbeteiligung
Front-End <Software>
Datentyp
Programmbibliothek
Zusammenhängender Graph
Urbild <Mathematik>
Softwareentwickler
Datenstruktur
App <Programm>
Architektur <Informatik>
Benutzeroberfläche
Vervollständigung <Mathematik>
Sichtenkonzept
Mobiles Internet
Gebäude <Mathematik>
Humanoider Roboter
Biprodukt
Quick-Sort
Dienst <Informatik>
Menge
Flächeninhalt
Rechter Winkel
Heegaard-Zerlegung
Web-Designer
Computerarchitektur
Standardabweichung
Router
Bit
Vektorpotenzial
Punkt
Prozess <Physik>
Extrempunkt
Browser
Kartesische Koordinaten
Login
Computeranimation
Deskriptive Statistik
Prozess <Informatik>
Trennschärfe <Statistik>
Mustersprache
Datenreplikation
Skript <Programm>
App <Programm>
Lineares Funktional
Sichtenkonzept
Benutzerfreundlichkeit
Gebäude <Mathematik>
Mobiles Internet
Systemaufruf
Strömungsrichtung
Bitrate
Biprodukt
Teilbarkeit
Linearisierung
Framework <Informatik>
Konditionszahl
Grundsätze ordnungsmäßiger Datenverarbeitung
Ordnung <Mathematik>
Aggregatzustand
Mathematisierung
Gruppenoperation
Soundverarbeitung
Implementierung
Fluss <Mathematik>
Framework <Informatik>
Informationsmodellierung
Benutzerbeteiligung
Determiniertheit <Informatik>
Programmbibliothek
Zusammenhängender Graph
Inhalt <Mathematik>
Softwareentwickler
Ganze Funktion
Schätzwert
Architektur <Informatik>
Einfache Genauigkeit
Physikalisches System
Quick-Sort
Keller <Informatik>
Objekt <Kategorie>
Mereologie
Router
Schaltnetz
Gruppenoperation
Mathematisierung
Kartesische Koordinaten
Aggregatzustand
Zählen
Term
Computeranimation
Fluss <Mathematik>
Informationsmodellierung
Einheit <Mathematik>
Datenmanagement
Prozess <Informatik>
Spieltheorie
Datentyp
Minimum
Warteschlange
Soundverarbeitung
Kategorie <Mathematik>
Default
Wurm <Informatik>
Ranking
Keller <Informatik>
Gruppenoperation
Linearisierung
Objekt <Kategorie>
Funktion <Mathematik>
Computerarchitektur
Message-Passing
Aggregatzustand
Router
Punkt
Datensichtgerät
Web-Applikation
Versionsverwaltung
Kartesische Koordinaten
Aggregatzustand
Maschinensprache
Computeranimation
Homepage
Datenmanagement
Fahne <Mathematik>
Datenreplikation
Gasdruck
App <Programm>
ATM
Addition
Sichtenkonzept
Mobiles Internet
Systemaufruf
Profil <Aerodynamik>
Strömungsrichtung
Biprodukt
Systemaufruf
Ranking
Gruppenoperation
Dienst <Informatik>
Rechter Winkel
Login
Datenfluss
Schlüsselverwaltung
Aggregatzustand
Lesen <Datenverarbeitung>
Gruppenoperation
Mathematisierung
Soundverarbeitung
Mathematische Logik
Systemplattform
Code
Bildschirmmaske
Informationsmodellierung
Erwartungswert
Benutzerbeteiligung
Knotenmenge
Arithmetische Folge
Rangstatistik
Spieltheorie
Reelle Zahl
Endogene Variable
Programmbibliothek
Zusammenhängender Graph
Datenstruktur
Touchscreen
Soundverarbeitung
Einfache Genauigkeit
Quick-Sort
Objekt <Kategorie>
Gamecontroller
Soundverarbeitung
Lineares Funktional
Parametersystem
Bit
Routing
Systemplattform
Login
Datenfluss
Mathematische Logik
Computeranimation
Homepage
Prozess <Informatik>
Login
Zusammenhängender Graph
Wurzel <Mathematik>
Datenfluss
Schnittstelle
Subtraktion
Sensitivitätsanalyse
Bit
Mathematische Logik
Punkt
Momentenproblem
Gemeinsamer Speicher
Gruppenoperation
Kartesische Koordinaten
Mathematische Logik
Systemplattform
Code
Computeranimation
Homepage
Informationsmodellierung
Benutzerbeteiligung
Mittelwert
Mustersprache
Stichprobenumfang
Programmbibliothek
Zusammenhängender Graph
Softwareentwickler
Schreib-Lese-Kopf
Soundverarbeitung
Lineares Funktional
Oval
Kategorie <Mathematik>
Gemeinsamer Speicher
Ausnahmebehandlung
Objekt <Kategorie>
Dienst <Informatik>
Flächeninhalt
Projektive Ebene
Computerarchitektur
Programmierumgebung
Bit
Abstimmung <Frequenz>
Prozess <Physik>
Momentenproblem
Gemeinsamer Speicher
Extrempunkt
Browser
Applet
Bootstrap-Aggregation
Versionsverwaltung
Kartesische Koordinaten
Maschinensprache
Computer
Computeranimation
Übergang
Chatbot
Datenmanagement
Prozess <Informatik>
Wurzel <Mathematik>
Tropfen
E-Mail
Schnittstelle
Lineares Funktional
CLI
Namensraum
Abstraktionsebene
Disjunktion <Logik>
Quellcode
Biprodukt
Dialekt
Rechenschieber
Generator <Informatik>
Server
Projektive Ebene
Message-Passing
Tabelle <Informatik>
Geschwindigkeit
Web Site
Folge <Mathematik>
Wasserdampftafel
Gruppenoperation
Mathematisierung
Transformation <Mathematik>
Term
Framework <Informatik>
Code
Task
Informationsmodellierung
Bildschirmmaske
Knotenmenge
Multiplikation
Benutzerbeteiligung
Fächer <Mathematik>
Reelle Zahl
Datentyp
Endogene Variable
Stichprobenumfang
Programmbibliothek
Zusammenhängender Graph
Softwareentwickler
Konfigurationsraum
Touchscreen
Leistung <Physik>
Soundverarbeitung
Benutzeroberfläche
Open Source
Gemeinsamer Speicher
Elektronische Publikation
Quick-Sort
Chipkarte
Mapping <Computergraphik>
Objekt <Kategorie>
Last
Basisvektor
Wort <Informatik>
Computerarchitektur
Textbaustein
TVD-Verfahren
Bit
Prozess <Physik>
Punkt
Momentenproblem
Datensichtgerät
Applet
Versionsverwaltung
Kartesische Koordinaten
Element <Mathematik>
Computer
Übergang
Arbeit <Physik>
Client
Prozess <Informatik>
Mustersprache
Default
Softwaretest
CLI
Multifunktion
Dicke
Sichtenkonzept
Mobiles Internet
Ruhmasse
Turbo-Code
Humanoider Roboter
Kontextbezogenes System
Biprodukt
IRIS-T
Strategisches Spiel
Server
Projektive Ebene
Information
Standardabweichung
Subtraktion
Computervirus
Schaltnetz
Systemplattform
Term
Physikalische Theorie
Code
Knotenmenge
Benutzerbeteiligung
Front-End <Software>
Wrapper <Programmierung>
Datentyp
Zusammenhängender Graph
Optimierung
Maßerweiterung
Softwareentwickler
Trennungsaxiom
Expertensystem
Universal product code
Plug in
Mailing-Liste
Binder <Informatik>
Quick-Sort
Portabilität
Programmfehler
Objekt <Kategorie>
Energiedichte
Gamecontroller

Metadaten

Formale Metadaten

Titel React Native & Rails, A Single Codebase for Web & Mobile
Serientitel RailsConf 2017
Teil 60
Anzahl der Teile 86
Autor Dixon, Ben
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/31279
Herausgeber Confreaks, LLC
Erscheinungsjahr 2017
Sprache Englisch

Inhaltliche Metadaten

Fachgebiet Informatik
Abstract Rails made building CRUD apps efficient and fun. React Native, for the first time, does this for mobile Apps. Learn how to create a single React codebase for Android, iOS and Mobile Web, backed by a common Rails API.

Ähnliche Filme

Loading...