Merken

Turbo Rails with Rust

Zitierlink des Filmsegments
Embed Code

Automatisierte Medienanalyse

Beta
Erkannte Entitäten
Sprachtranskript
and this and that and the and the your whole EU should we get started are we ready for this OK let's do it welcome to or from the Kansas of I have always been very excited by this rules count because I always wanna come to cancers and I am I have always heard about this me of was that of loss and it's as you can tell us little bit ahead of my time but I watched it before I come here in preparation for a conference on but as we learned injuries you know the other day and it turns out that these lines on maps or state lines and Kansas is on the left and the other half is a mystery terms like Kansas City is so actually not in Kansas so I guess we're not in Kansas anymore I have sent you could if that I had to redo all my slides it colors them so if they don't for good that's probably what I time I got free you can find me on the Internet as Chen can go out and I'm very excited to welcome you to your employee a
new employee orientation of you in the right place yeah yeah if you're looking for real sound I'm afraid of used so that
just getting this is real found I welcome to
rest count and thank you for coming from
and I always said on there's a very personal thing but res come to mean a love coming back this is actually my 5th frills comes from 5 years ago and Austin that was my 1st rails continent actually attended there and intended risk of Austin as and I was on the students student scholarships so you were there and then to 4 on shipping format it and I think you were give me the opportunity to be part of this community and makes 0 went back to some real stuff LAN and for some reason I had so only the courage to go by parents a for a class and you merchants and for some reason I the end of merging it so I have 1st come rails and the next year soon after next of response in Chicago and I joined the rails 14 and the year of the eyes for the reals Conf for the 1st time which is last year and this year and various the part of the program committee and home community Program Committee on Brill's comments and then helped create the behind the magic and you in real sidetracked so if you want to go starts and like those tracks but that's where they come from and and the like generally said the other day and rails is real success because some of office communities so I think you for being part of this community so following errands
lead I will like to now some of the new rules 5 features and as you learned today real survival come what the the support and I falling asleep will likely announce Java script support for real life and in fact you don't even have to read it we forest fire you can just get it today by running gems Bojars scripts and once you have installed them all you need to do is required euroscript on the top of your review file and the their go you can disrupt the same just block and right you got the code in there and you can support things like functions and that's very handy because what is everyone's favorite jobs good features of course that's callbacks and what's everyone's favorite rails features but of course that's also complex so I'm the just condemn let you combine the best of both worlds like here's accurate model you can have your favorite before create call back then you can write that in JavaScript's so I actually I just like the the region this is a real thing you can use an an insane amount of engineering when the genome and if you want to learn more
about that I suggest you walk my talk and goal and call dropping down to a metal to you can find that on to on I haven't anything to block and if you want to
the lightning talk from history you would already noticed but some help coordinate a newsletter called this we can rails where you find on the latest and commits import words and things like that that when the rails does that week and and here is a sample from last week and that includes sensational headlines like look local centers discover new method to many playtime faster code found perform better under load Jeremy builds too flaky useful and Bridget experts applied debate left to right as right to left this 1 better than the other and if you haven't already go to bitly slash rails weekly this subscribe to this newsletter the next issue will be coming out in a few hours and you will come the you probably learned something new from there and speaking of newsletter I also am also
part the newsletter which is solved from newsletter so if you are not already signed up to scale you should I sign up his skeletal bio and selected almost daily inside a channel and e-mail preference and that will usually right about of the experience writing not building skeleton a lot of time so I red or things like 0 I have this problem today and we don't know how to do that and some of what customers will take a I had that problem last week and here is a gem I found that those that or sometimes the opposite would happen will be like that we solve this problem today in how customers would write back and say that's really great at the same problem at work so and if you're interested you should go sign up and if you have 10 paper might want to write down that secret neural that's actually my personal and referral euro and I heard we have plans to you on this true bonuses this year based on refer credits and I can't so please help me l anyway and let's talk about really so really is great we all of review that's why we're here I'm pretty has a lot of nice features at Greece really nice comment programming is pretty awesome but there is also a problem to review which is that it's pretty slow Moslem time it doesn't really matter but notationally and you might hit a wall when you try to do something really it's just on too slow for use case on the other end of the spectrum or perhaps in the other extreme of the spectrum there's which is simple level I'm just superfast basically it's like as close to metal as you can get with already assembly and that's great but it's also Humphrey dangerous you can very easily write code that crash a program at run-time and in this unexpected way and old barrels a lot of concepts that are living hard to graphs and so in Ruby we have this feature cognitive extensions that give you the best of both worlds so for example when you run German studies on what you're getting is actually 2 different things for the present 1 so but by default you would get I think countries on pure which is of purer the implementation of the JASigning important but if you're on a supported platform you also get anything colleges on call 20 eecs t which is needed extension from so it's the same and Jason encode API written in C and so that's like super fast but to you as a user you don't even notice a difference because you just called like a regular really callous and you call this method normally and and the under the hood is basically use and transparently called the coliseum methods that does the work for you and I a user don't have to care about that and chances are you're ready using the version without knowing it the I'm so native extensions they operate why don't we write more of them well there is a catch so it's indeed the best of all worlds but it's only the best of all worlds of years the end user is using a jam from this is this is fine and David who created rail as I have said something like this to me on gives a general value of rails development we will jump through whatever groups on implementation side to make user-facing API nicer and I think I will personally extrapolate that on user-facing HCI to developer experience in general and I think that's a good goal to have but it's good to know make the experience for developer uses as nice as possible and while keeping up so to think beautiful interface on the outside and do whatever you need on inside to make that work so that's a great goal to have and here is a good example of that so sense that from you
and you might have heard of you did a lot of really performance working was really hero from last year I'm so he noticed something and rails so in terms of in rails enacted support in particular there's a method called string not blank so and it turns out this method is called a lot both inside of and the Rails framework and also in the user cold so and this is also the implementation of the flip side called precedence so you might have seen things like the user or operands colon user adopt present right so this is actually the method is talking about and this is the implementation in the active support as of a few weeks ago there some improvement since then I will talk about the later so it's pretty short method really basically reopen the string class and it basically check if the string is an all whitespace characters and that's all there is to it this 1 liner agrees beautiful E like all during really cold and that's great an apparent lack of Beverly is a very useful method because and we use it enough in our application and rails to make it a performance hotspot according to send so what he did is he made a genome called fast blind that we implemented the same blank method in C and according to send this C implementation it's up to 20 times faster than the review version we saw and on the other side the slide and she said that in some applications including get up to 5 per cent of performance improvement on the natural but now as I said there are some recent improvement you rails version but for the purpose of this presentation this particle number doesn't really affect me that much because the optimisation wooden rails is about the and and educators or common case studies on when the string is empty the so now we can so as the user you don't really need to know the difference right you just get the fast like blank German you're out and all your code works seamlessly because it provide the same on strand of blank question mark method would have on just with a different implementation of the and so you can get the performance you once on and the user the fall for experience you want and then that seems great and we're done here a well there is a problem so the problem is you me being the developer that knows just enough seed to be dangerous if you get busy for RAM with variable called keep your eye if the called this and work of the 1st thing fries probably had a stop to it it and if so then work you try more stars most stars still those Figs and maybe try stand on and the problem with this is as I mentioned before that if you if you're like me you hear AUC collide this year program can Segfault fault at runtime and and that's pretty bad because you if you're embedding C code inside a review process of trash entire group process does not like the rectal exception that you can you can handle so as stellar
where we have a similar problem 0 by the way this is a of a mention but this is where I work and we have and we're performance analyzer for Rails apps and to do that we have to have a of the agent that we put inside have to collect performance data on production and so we are we want to make sure that all agent is a slightly as possible we don't want the thing is supposed to be measuring the performance to become the bottleneck itself on so we could write that agent and you possible us and fortunately most of engineers correspond need and it'll randomly at stores in ampersands to variables and see but even then I we don't feel very confident that we can get away with writing mean right in maintaining l come C code that goes inside of all of all customers perhaps but there are a lot of the native extensions in in the Ruby community like no Uriah adjacent genome and in their early days they all had various issues I'm offset falling at runtime and those who always more in me and if even after very careful about writing they still occasionally crashes then we definitely you won't want to recommend customers with something like this and the act so what is the alternative well at the time when we started this project and
and just announced that they would and therefore made some very good professor a very good for improvements at the time so it's not we will but perhaps give that a try so what makes rust different than writing here and natives extension and see a support thoughts the well let's look at the rest website and rest is the system programming language that runs blazingly fast and prevent sec faults and guarantees frets safety of that's a lot of words that doesn't mean a lot to me yet but that they have another slogan that tries to put the same thing in the the from words which is without fear that the goal of the reciprocity is allowed you to have to basically make system programming more accessible to you 1 more programmers and and it does that by having a the a
compiler that knows about a lot of these things so I what makes rust special is that is a compiler that can find was all these and wall actually all these errors that that is cause a program to crash at runtime and fly them at compile time and if you don't do everything correctly and if you don't satisfy the if you don't you cannot convince the Ruskin pallor that your hologram is sound it simply will it will simply refuse a comparative program and so therefore we don't have a thing to run at runtime and so it cannot crash at runtime from so there some features in rats that
makes that possible and I can't get into a lot of details on of rest today and this talk is not really about teaching you Russ and but I'll try to describe them at a very high level so that you can perhaps try to understand them without seeing the actual code and the 1st feature of Ross that makes this possible is and they take care of managing the safety of a memory without using garbage collector so really is also um a language that oversman safety guarantee and really cannot right and you cannot write code that on axis random the locations of memory in court positive pole and a crash of event and that way so it's maybe it perhaps some of on crazy to say that all your program cannot crash at runtime red and rust but in fact you're ready to use it because you re people and also crash at runtime on the difference is that Ruby I meant is that by using garbage collector and rust does that with all the garbage collector and what Russ This is basically tracks lifetime of all your variables at compile time so it knows exactly when you need when and where it needs to locate things and when companies to clean up so it is in the 2 possible program and clean up with regard reflected periodically and it also allow you to do and concurrency with filed and the data raises a race conditions and which I don't have time and again to you right now and in the final feature that is particularly relevant for us it it has this concept was 0 cost attraction so in Ruby on frankly many at most other languages and you always have to make a trade off between and abstracting your code versus performance so like maybe you notice that you're doing you're repeating a bunch of steps in a few places and you will want extract that into method and read so that's fine and that's what we should be most the time but unfortunately this incurs a cost of an extra method invocation and when when you're talking about really performance-sensitive code you have to make the trade off between how much you want to abstract code between and and help perform you you code to be right so in rails for example we have a lot of other modules and we call super a lot and that's how we decide we want to the abstract code ideally but occasionally there might be cases where we realize this is like really hot happens we really would prefer not to incur cost and with that in mind some of the things that so in RUS and this is 1 of the biggest feature knows where I you can actually you don't actually have to make the trade off between obstructions and performance because the Ruskin colors smart enough to notice that this method can be in line into that of things so just do that work in fact a lot of time if you use higher-level constructs in rats like iterators that is actually giving the compelling more information about how you should how the compiler can optimize your code and so it actually makes a poem month run faster so for example and really but you might want to read things in each loop and we often do and that's fine but that's anchoring the extra cost of making the calling that each method and stuff on the other hand on rest if you use an inter-rater actually makes it faster than writing a hand rolled loop because the compiler knows I this is going to be a safe iterations so it can remove some of bound checks inside the time for each iteration so I can get into a whole lot more details about yesterday
gave them a talk on rough that rules found here last year so if you are new to and you're curious about and why you might want to look into this language you can look at his talk from last year so let's get back to fast
like an and as I guess we'll look at the fast like implementations see quickly so this is the fast blank wall he so you probably cannot read it but its final walk through it step by step together so basically I'm at the top you basically have the meta-signature and some boilerplate to extract some pointers and I app so you have new then I have aligned that quickly check always this string is empty then returned right away so you know you can avoid doing a bunch of extra work and then the main part of the of the method is basically you lived through all the characters inside the strength and and the sum or Borel plays about pointers and finally you have a switch statement and if you encounter white states character you keep leaving basically and if you encounter non space characters you know that this string is not blank so we can return false immediately otherwise if you get to the end of the loop you know that all of your all the characters he of encounter them in the string of whitespace characters so you can return true so this probably looks a little bit more scary than it actually is perhaps only because this on the slide but this is like 50 line of coal bed and it's not particularly on particularly difficult to reason about so if we can get up to 20 times faster performance rating 50 lines of C code seems worth it so next let's look at the equivalent fast blank implement implementation in rusts and here is so this is literally a one-liner function rust that that's exactly the same thing and handles all the code edge cases correctly and let's walk through it so basically define and and external C function this basically tells rust please and I know that this code is going to be called from a C program so please keep the and users see function calling convention for when actually component poem and in that process particularly important except the To illustrate the point rust this approval levels a simple ring language that's designed to interact with other other C programs and the Ruby implementation that you probably using the MRI and or Serie Ruby implementation is a C program so that work pretty nicely together and because like as the Ruskin palate there's lot about safety so you have to do a little bit of work to the annotator code to the compiler and differed in enough information to know that you code is doing and correct so here we're telling and the compiler what the types of the inputs to this function will be and the specific type we use here is not particularly important except to point out that you need to tell the compiler which types each chair is going to be and it also helps for us to the cat Ruskin quality figure out how to have a look memory for a for these things because I'm estimates that as much as possible rest right you know look at things on the stack so this and have be which makes cleaning up a lot faster which is another key to be and rust performance so here we're annotating 2 I would tell the compiler that this method is going to return a boolean value because of the blank question mark method is expected to return either true or false on depending on whether the string is like a not and the actual body of the method is perhaps not remind you about on the Ruby code that you're used to writing so here we're from getting all the characters from I'm in the string s an iterator and we're using these high levels common like stop all you probably familiar with this and really is equivalent to a rate of all question mark method that loops through the rain check if each of those i items in that rate matches up a certain condition and you have things like block which is also a thing like to use in Ruby and finally you are for each character in the in the buffer you checking whether it is a way space character or not and this is what spaces method provided by the rust and library that knows how to and do the big switch statement and we have in this implementation so this is pretty terse and perhaps surprisingly so because we're now programming and system and system language and surprisingly here looks kind of similar to what you write and read right so is this going to be sacrificing a lot of performance compared to use the version because the so terse and so level what we ran some benchmarks and if you look closely this is iterations per and 2nd by the way so the higher the number the better so at the bottom you have the Puri implementation and on public rust and next it is this implementation if you look closely at the rust version is actually a limit fasteners aversion and even though we're using higher-level things like iterators and I don't all so performs and not being very scientific you're not trying to convince you that Russ's fashion see and just trying to convince you that you can get away with writing the high level code that uses the and without sacrificing performance at least you get called up in the same ballpark as the CD booklet so but let's look at this code again I turns of there's a catch it and tell you about and the catchers there is a lot of
glue code that I've show you here and if you look at the full Ross versus
the time extension you noticed that on the left the red part is the 1 liner I showed you and on the right that's the very big C function body that I showed you and indeed this assumption body is much larger than 1 liner on the left however if you count all the boilerplate code around it and they're roughly the same sites that in terms of line of codes on not all is lost so I'm I should point out that on the rest side a lot of those are the common shared abstractions like the buffer implementation and things like that that can be extracted out where as on the seaside that's literally your business logic so you have to read that manifold every time you want to read its expansion like this whereas on the left and that's actually the only of the 1 liner it's on the only thing that's specific to your extension still this is not very nice so yeah we in I have been working on this project and called helix and and
our goal is to make more muscles moral plate go away and take advantage of and thus features like 0 cause obstruction to make it to help you focus on running the thing you want to write without having to roll all the bowl of all the time so here is the entire fast blind extension written and Felix so we are using the rust macro feature which lets you write things that's pretty similar to cells and so here we are but at the top we're importing a library and your we're declaring a bunch of really types and the 1st thing we do is we try to reopen the Ruby string class and we add method called is blank and you might find this syntax somewhat from nowhere and finally in the In the code we have a 1 liner that we saw earlier and this is all the code you need to write to write an extension like fast fast like in rust into its so my personal i goal for this I'm going forward is and I would like to be able to experiment implementing some of the rails features in terms of and in and the like so we already have an extensive type test we and in rails and there was a lot of and modular parts that that is like string not blank that can be swapped out into India rust extension without affecting any of the use of using it so we can continue to iterate quickly on the Ruby implementation and on that surround the purity implementation on rail side while taking advantage of the of existing rails test suite and on right these experiment with these lower level implementation and as long as we keep running Indians rose test we will we can be fairly confident that some things are inherited and if I'm so they would of course be an optional thing that you can install just like fast blind but if you're if you're platform supports it and if you and trust enough and might give you some substantial performance gain and there are a lot of low-hanging fruit for small he's like and for example the active support duration class like when you do 1 they that's the active support duration class that's created and to so there are probably a lot of pieces and small pieces like that so we can experiment with using using helix and eventually we can probably work on my writing big accuses like perhaps the the core routing library and in West someday so that's all rates but but what about my at all so while we're working on this project we have a friend who works at syste and they have a pretty interesting and problem for us so they and they for the most part there the status of the stack and they are and catering company instances goal that tries to on and deliver organized news for for companies based in the Bay area and and 1 of the problems that they have is they have a new matching algorithm so for example but there will be some constraints like I some of my employees at these allergies so they cannot have meals with these items in it or sometimes and they'll be the opposite some of my employees preferred these features in the use and you should make sure that news have have the plight of the or gluten-free and accept so at the end of the day and there the problem boils down to something like this you have some some tax for for each meal and you have some tax for the different preferences on your users might have and what you want to find out is whether the meal the taxonomy or fully satisfy all the requirements and the in the 2nd array to right so this is the maximum of and we want to see is if this 1st array fully contains all the numbers in the other room and that basically boils down to what what we call a set containing problem and there is a no trick for that all I should mention the reason they care is but they have written this algorithm and revision is taking a long time to run like sometimes like and measured in minutes maybe up to 40 minutes right and they measured and a lot of time is being spent in and this 1 set in our from so it would be interesting to see what we can do it if you can implement ever from an rust so there's a known track for assigning and testing set containment you and go to stack overflow and look for it you probably find a solution similar to this basically and to check what an array fully contains another raid on you can do an intersection between interior is basically a make new array only contains on items that is in full force the original and the the other array right and then you can check if that rate is equal to 1 the preferences are so this would tell you whether your meal fully satisfied your preferences so this is a really nice to read like all of really cold that you're used to writing and and usually it's fine it right like I think it's good to be able to start with something like this and and and so they have this cynical base and they have an existing test we want to test of this is working so we have replicated that test we can replicated this method and we confirmed that it indeed works as ever ties the but we can do better than that because we know we happen to know that all the numbers in the array is sorted and all the numbers in the race argue neat so there no duplicates in their right so it's after thinking really really hard to realize that we can do better on so here is a different
algorithm impurity to do the same thing and I will walk through quickly so 1st of all you check some edge cases if have to raise empty and then you can very quickly decide on 1 way or the other with all having you wanted to work and then the some boilerplates you checking attracting the session and to like it the index of the array and basically you look through all the items on the longer array and keep pointing to and to the pointer into the other way and try to advance the point is you find the line if and finally if we get to n of the loop you know that you didn't have you there some items that is in the error rate is not in the original so I did told is a while to figure this out so you don't immediately understand door about it and but the point is we build this and we run it against the back and test we have and it passes and according to Benchmark
is up to 7 times faster and the usual case is more so depends on the particular test is great and the showcases more like to x and but it goes all the way up to 7 times 1 so that's 3 grade you basically figure out the who interview question you should give yourself a pat on the back at this point but what is we write and rust so that's what we tried next 1 again we're using the lake so
that we are using the plot types metro we're reopening the rate us and and we are defining the same fully contain method with the type annotations the and here is the same code that checks for the edge cases and on the same boilerplate for tracking array index and interestingly here in Ross Anderson mentioned earlier if you use iterators the compiler is actually able to do smarter things so here we're actually using an iterator instead of writing a hand to and because we're using an iterator and dilute body and looking slightly better than the review version in our opinion but and but otherwise the same exactly the same ever from and finally if you get the bottom return false and we benchmark this and
and that runs up to 1 is only 3 times faster than reversion depends on depending on the workload and a plot this on a chart probably
can't really see other details but each from basically we ran a bunch of different and test cases and the blue line is the purity implementation that's the 1 liner the green lines are and the fast I were from written Ruby and the yellow lines are the rest implementation of the same our reference so you probably can't see a lot of blue greens because they're mostly the bottom and a think the numbers are roughly in the Russ implementation is usually tend to up to like hundreds of different 3 times faster than the the grid implementation so that's pretty great and and here is that we
are almost out of time so rather quickly so to and so here is where you can find the code from the village project is a major work in progress but we're on a pretty good track and if you will likely help us on you can come talk to us after and finally I will like to close with and was this historically I scripting languages were a slow and they're still relatively slow today and because they're slow and they were mainly historically use as a coordination layer and that delegates to HIV-related heavier tools written in system languages like C so for example you might write your shell script and batch that delegates to Unix utilities likes for graph or work counts and to do that to do the heavy lifting I'm however it turns out that a lot of time we are actually doing I O-bound operations like reading and writing to the hard drive or and waiting for network or talking to database on because I will operations are usually so much slower the performance difference between scripting language and a system language doesn't actually matter so much but also a lot of time but because scripting language is so much easier to write and so much more pleasant use I We enemy using a lot more of the code into scripting layer and instead of writing everything in C so since web applications are so I'll have the and that worked out wonderfully for things like rails and the fact that you can have in 1642 unicorn of process on like it the core mission is probably a good thing it's probably a good empirical evidence to say that that's true the harbor at the end of the day and we still have some some vocational computationally heavy operations in our application turns out the business business logic is what the signs your application was set it apart from other apps so I think we're entering a new era where we have taken a lot of the advancement from script languages expecially on the ergonomic side and rear that into system languages like rats so what he likes you can really move any competition we have part of your app back into rust and without having to switch entire sectors something like gold and a melting and Russ is particularly suited for this task I'm in real scenes and thanks to safety guarantee offered by the Ruskin pallor and morbidity team members will be able to tinker and experiment with thrust code without worrying that it will cause problems at runtime the worst you can do is not compile and make the program not compel so like you probably try get help at that point I out seems everyone and a taking up enough for us to be able to fix bugs or make minor tweaks and recitation agent in roughly half a year or so and we think that will continue to be true but no fresh rocky and so our goal of the helix project is to make this even more accessible to more review teams and so even keep most of you code in the language you love with of hearing that it would be too slow eventually so because you can always drop down to rest if and when you need to do that so I ones again that's alive today and you can find me on the Internet that can encode Thank you for a time let's make really gradient think fj the the this is the 3rd
Mapping <Computergraphik>
Rechenschieber
Einfügungsdämpfung
Bit
Schlussregel
Kantenfärbung
Term
Gerade
Computeranimation
Aggregatzustand
Internetworking
Orientierung <Mathematik>
Klasse <Mathematik>
t-Test
Zählen
Computeranimation
Office-Paket
Weg <Topologie>
Rechter Winkel
Reelle Zahl
Mereologie
Endogene Variable
Vererbungshierarchie
Dateiformat
Optimierung
Ereignisdatenanalyse
Lineares Funktional
Videospiel
Wald <Graphentheorie>
Applet
Güte der Anpassung
Systemaufruf
Schlussregel
p-Block
Elektronische Publikation
Code
Computeranimation
Informationsmodellierung
Lesezeichen <Internet>
Reelle Zahl
Prozess <Informatik>
Rechter Winkel
Skript <Programm>
Subtraktion
Versionsverwaltung
Gruppenkeim
Automatische Handlungsplanung
Schreiben <Datenverarbeitung>
Implementierung
Systemzusammenbruch
Sprachsynthese
Technische Informatik
Newsletter
Ungerichteter Graph
Systemplattform
Punktspektrum
Code
Computeranimation
Übergang
Skeleton <Programmierung>
Stichprobenumfang
Maßerweiterung
Softwareentwickler
Optimierung
Default
E-Mail
Tonnelierter Raum
Hilfesystem
Schnittstelle
Beobachtungsstudie
Expertensystem
Stellenring
Informationsverarbeitung
Last
Mereologie
Wort <Informatik>
Extreme programming
Subtraktion
Prozess <Physik>
Stoß
Klasse <Mathematik>
Versionsverwaltung
Gruppenkeim
Systemzusammenbruch
Implementierung
Zahlenbereich
Kartesische Koordinaten
Kombinatorische Gruppentheorie
Term
Code
Framework <Informatik>
Computeranimation
Globale Optimierung
Äußere Algebra eines Moduls
Speicher <Informatik>
Optimierung
Softwareentwickler
Ganze Funktion
Beobachtungsstudie
App <Programm>
Topologische Einbettung
Rechenzeit
Ausnahmebehandlung
Biprodukt
Rechenschieber
Rechter Winkel
Partikelsystem
Zeichenkette
Subtraktion
Web Site
Compiler
Formale Sprache
Systemzusammenbruch
Rechenzeit
Wort <Informatik>
Systemprogrammierung
Optimierung
Maßerweiterung
Computeranimation
Fehlermeldung
Subtraktion
Ortsoperator
Compiler
Formale Sprache
Iteration
Systemzusammenbruch
Kartesische Koordinaten
Code
Computeranimation
Loop
Variable
Weg <Topologie>
Optimierung
Hilfesystem
Gerade
Konstruktor <Informatik>
Kraft
Rechenzeit
Schlussregel
Modul
Ereignishorizont
Polstelle
Konditionszahl
Festspeicher
Information
Kantenfärbung
URL
Speicherbereinigung
Bit
Gewichtete Summe
Punkt
Prozess <Physik>
Compiler
Formale Sprache
Versionsverwaltung
Iteration
Zahlenbereich
Implementierung
Raum-Zeit
Code
Computeranimation
Übergang
Loop
Puffer <Netzplantechnik>
Unterring
Datentyp
Minimum
Programmbibliothek
Inverser Limes
Zusammenhängender Graph
Zeiger <Informatik>
Optimierung
Figurierte Zahl
Gerade
Lineares Funktional
Befehl <Informatik>
Reihe
Physikalisches System
p-Block
Ein-Ausgabe
Bitrate
Rechenschieber
Rechter Winkel
Festspeicher
Konditionszahl
Mereologie
Information
Computerunterstützte Übersetzung
Textbaustein
Schlüsselverwaltung
Aggregatzustand
Zeichenkette
Nebenbedingung
Web Site
Disk-Array
Klasse <Mathematik>
Versionsverwaltung
Implementierung
Zellularer Automat
Zahlenbereich
Systemplattform
Term
Mathematische Logik
Code
Computeranimation
Übergang
Methodenbank
Puffer <Netzplantechnik>
Weg <Topologie>
Algorithmus
Datentyp
Programmbibliothek
Maßerweiterung
Topologische Mannigfaltigkeit
Gerade
Softwaretest
Suite <Programmpaket>
Lineares Funktional
Physikalischer Effekt
Abstraktionsebene
Schraubenlinie
Matching
Bitrate
Numerische Taxonomie
Menge
Flächeninhalt
Forcing
Rechter Winkel
Mereologie
Codierung
Speicherabzug
Projektive Ebene
Wärmeausdehnung
Textbaustein
Makrobefehl
Innerer Punkt
Instantiierung
Zeichenkette
Softwaretest
Loop
Punkt
Algorithmus
Automatische Indexierung
Bitrate
Zeiger <Informatik>
Textbaustein
Computeranimation
Gradient
Fehlermeldung
Benchmark
Compiler
Versionsverwaltung
Iteration
Bitrate
Code
Computeranimation
Beanspruchung
Reverse Engineering
Datentyp
Textbaustein
Verdünnung <Bildverarbeitung>
Array <Informatik>
Benchmark
Subtraktion
Prozess <Physik>
Punkt
Nabel <Mathematik>
Web-Applikation
Formale Sprache
Schmelze <Betrieb>
Zahlenbereich
Implementierung
Kartesische Koordinaten
Zählen
Mathematische Logik
Code
Computeranimation
Internetworking
Eins
Task
Demoszene <Programmierung>
Arithmetische Folge
Vorzeichen <Mathematik>
Reelle Zahl
Minimum
Skript <Programm>
Optimierung
Ganze Funktion
Gerade
Softwaretest
App <Programm>
Datennetz
Graph
Green-Funktion
Physikalischer Effekt
Softwarewerkzeug
Schraubenlinie
Rechenzeit
Physikalisches System
Programmfehler
Mereologie
Speicherabzug
Projektive Ebene
Stapelverarbeitung
Koordinaten
Lesen <Datenverarbeitung>

Metadaten

Formale Metadaten

Titel Turbo Rails with Rust
Serientitel RailsConf 2016
Teil 11
Anzahl der Teile 89
Autor 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/31570
Herausgeber Confreaks, LLC
Erscheinungsjahr 2016
Sprache Englisch

Inhaltliche Metadaten

Fachgebiet Informatik
Abstract Ruby is not the fastest language in the world, there is no doubt about it. This doesn't turn out to matter all that much – Ruby and its ecosystem has so much more to offer, making it a worthwhile tradeoff a lot of the times. However, you might occasionally encounter workloads that are simply not suitable for Ruby. This is especially true for frameworks like Rails, where the overhead wants to be as little as possible. In this talk, we will explore building a native Ruby extension with Rust to speed up parts of Rails. What does Rust have to offer here over plain-old C? Let's find out!

Ähnliche Filme

Loading...