Merken

Breaking Bad - What happens when you defy conventions?

Zitierlink des Filmsegments
Embed Code

Automatisierte Medienanalyse

Beta
Erkannte Entitäten
Sprachtranskript
to the young sir on welcome everybody and then succumbing at today
I'm going to talk a bit about gradients and wholesome matters and I think part of why this also midwives grade this is community and the
huge ecosystem around it and when I tried to explain rails to newcomers to the industry or even colleagues I think of raves
about like this city maps this huge massive statement it's it's big and consists of different areas cycle when there's the at the broker district and there's the initialize it how and all these things and in our day-to-day work it can feel kind of intimidating
sometimes even Lake your surrounded by all this functionality and we don't know what's happening and you can constrain sometimes even and what it's true various has
certain ways and patterns how things should be done this is not mean that we cannot find or create our own little areas of freedom and today I'm going to talk about some of the areas we explored a slight in order to help us work in a more efficient way whether it's so at beginning 1 talk a
little bit about the status quo and then we talking a bit of log breaking of some things but followed by a quick wrap-up about general application architecture and then talk about some of the trade-offs for so quick question
to around who you know status quo offenses for coal so in contrast to rails so the school had a very simplistic approach they always only played with 3 courts and what I'm not going to continue today have to talk about the bands at a school of thought
coming in from London I should at least think of a British reference so we're done with that we continue with the actual status quo has and the current state of affairs 2 years ago
JH mentioned that the risk on and embedded radius for him is his proper pack the they indel-dense tomorrow he you still want to be able to use rails in order to write Web applications and I think this is a really cool feature and the idea behind it because I think everything everything comes with the rails like batteries included you can continue of or you can start writing weapon kitchen without the need of an anything else I'm more of ultralight
backpacking person myself and while I'm not prepared for those on the cup apocalypse the I always have just enough you with me for McKernan venture and this is
reflected in the Pareto principle mostly known al also as the 80 20 rule
so for example and papers and of the user sees only 20 per cent of your products and functionality on rails case the 80 % of ratifications or there is only 20 per cent of what grades officers features and the
background of this talk um has something to do with former casa applications and do you drug several years and having done a couple of RES projects we felt the same pain over and over again and that is that Omar Macao's arrays applications the need to slow test suites and this is a problem for us at a plate and because we use to quick TD cycles we wanna be able to write a little cold run the test suite to get feedback immediately so this running the code and
running the test happens on L 5 to 6 times a minute sometimes it I'm typing sloppy 10 times and I want this fast and quick feedback unfortunately the bigger the risk of grows if you follow the regular among the style from you out on these things and to In a previous
application where B the that the panel was the last application we built in this way I am this will be our reference application for throughout this talk and the end of the project with run about 4 thousand on a test and the full test lead ran in about 6 minutes and waiting 6 minutes until you know whether the refactoring repair not use too long in my opinion so I need my code
base mandible In order to make a quick decision yet OK this refactoring works continue this but a fixed or it's not fakes I wanna get this feedback really really quick so after having seen that brought a couple projects we went back to the drawing board we put
on our thinking units and started to really begin to what is the actual issues and this is me with my thinking at all and to 1 hotspot we identified was there is would a process
um which looks roughly like this at the beginning the rest framework is loaded then it will it all dependencies from a gentile and then it takes off its initial Aspang process which was also called from all configurations and so on and so forth the and during the process of some something like the called the unloading in the box it's called were referred to as the loading takes an Amiga loading and requires was responsible for acquiring all coal bed is inside you have directed for example and we send to modify our configuration a little bit and Sabena Tiberius applications you see in the application of our you see line like this require result require the whole world and continued so we change that a little bit In order to only require the 2 rail ties on 2 frameworks we actually needed for this particular application which only action control and sprockets Western management am journal out which Alan after the that this change that there's also already support for this kind of some configuration by reason you if you run raise new with the miners mines how like we get a list of all configuration options you can provide their and it actually allows you to us skip a couple of glycans already and and you see there's defective records direction table if you don't need them you can already tell rail state Don generate new project with these dependencies because I don't need and so I did run and the this command with a minus minus skid test because I usually use our stake from existing so what brings new generates then is an application that our be under looks like this it does require is all anymore on the rails which is the bare minimum and then it actually tells you may think the remedy 1 can choose arm and it commended out the test unit rose hi already for me because I was giving the the previous step so that's the then well the next thing after requiring that them the initial wagons and there's a line that will look like this 1 the require raise groups than in the previous version of arrested look a little bit different and the default and then the radius and and that have been changed and on which version but this tells wonder to require all gems from a gentile for your current environment the problem with that is that this line will and a linear tweeple process which means the more you at uh the more time will be spent when you load of the application and this is unfortunately off fact than are true we need to accept it and moan there's no way around that and so we continued their a couple more settings we saw that the tweak and 1 of them is some active support supports a ban flag In order to say I don't know everything from active support but only the dependencies that action needed in order to grab um and then there are 2 more settings cash classes in order to yeah keep keep a class cash it into the class has been loaded keep it loaded and then we disable specifically the dependency loading and this is because at that time um we were big fans of a thing
called screening architecture which I will go to i which will come back to them at a later point in the presentation but as a quick heads up to now that you the idea behind that was that it should be obvious for a new person on a team that the to know by just looking at the director structure what kind of applications that and if you take the
arrays codebases example generate new basis have been completely needed public and I don't know what domain is represented in this 1 particular application just because of serious before I have an idea yet that seems like a rather and use of real dominant but in the directory very more subdirectories which do not really reveal intent beyond the application itself so what we started doing as we moved everything there was an into the lib directory with a proper name space the so in this example there was it was a movie organization application soul there you can see there's an and its index and show them you're be template there is a movie model of movie repository and also the movie controllers like everything that used be after we move to that we need the directory altogether and in order to really make sure that nothing will be really all loaded on look that anywhere they're a couple of more settings for the application of our the the we made sure OK you load false don't trying to load anything and we made sure don't even try to look up any path because we pretty much them by them I am all well until he and so we would have all recitation Norris whatsoever trying to hit the next page the what where an exception under stress constant movies controller so I mentioned before is expects and everything to be loaded up front that's why this preloading out you loading happens in first-place so now raise some final some oracle efficient control anymore lucky for us this the thing calling owing to the rescue cross and what we did there I in a separate you can see the call
to active support constant ties so at that time raves tries to constant ties a controller name based on the RLD definition we provided there so because through its flexible and also we monkey batch content eyes more specifically the this particular 1 line you see there let me wrap existing constant eyes and say OK what it you try to constant as 1 the actually require this controller as well and this made the trek everything works we could serve regress everything worked fine um but it had an interesting effect on codebase because now we needed to have explicit requires everywhere and this is a bit the constants decision in within wouldn't team an but it's also not very rare z you wanna say so um what I like about it like it makes it obvious how many dependencies my phylum looking at hats so I refer to this as a manual of static analysis but if your mother filing has like 20 require statements that gives you at least into well maybe this thing is doing a much and then you can start thinking about extracting things or splitting up in different ways so maybe it's OK but at least you can start having conversation and think about this this thing doing too many things and with all the setting stuff on figure and we were able to start a new printer project which will be our example 1 so creature project we had
everything at our disposal we could do what everyone because we were in complete control of what we wanted to an all-in-one 1 approaches so we did all this configuration settings and here's the
existing what the previous application again with these 6 minute runtime of the sweep I was a part of the project when we take it off I join the project when there was already 5 thousand 500 specs then ran in 23 seconds and what I don't have percentage here I think this is a pretty big increase but um additionally to that with all the tweets about like how many files need to be loaded at the beginning loading were testing 1 control in isolation used to take around 18 seconds until you new OK at this controller exporters work now with the new approach and enumeration settings we only need to wait 2 seconds which I think it's still pretty good and 1 coming out here no is we made a couple also the choice to not use active record at all with me switch to the sequel jam and a repository pattern
in that way which is you don't need to discard at the record for that it's mostly about that you can switch you implementations for persistency depending on the environment you're and so when we're testing we had an in memory recall story in order to help us gain more speak um introduction of course we use a real repository and the lecture connected to oppose worst database but we could still have used as a matter of record for that it's just we switch to sequel um no particular reason it's it was just the the way we started working with that um it's worth mentioning you know that this constant burden on us when we needed to maintain 2 separate versions of for each repository but we needed to maintain a all stressing implementation as well as an in memory implementation but the benefits for that that we gain a lot of speed for a test suite so it was worth for us in by investing into this double maintenance the way we did that was with shared make examples that ran for both implementations so we actually only need to write the test ones but implemented twice basically and the 2nd example I have was uh application we took over from new client um and that started with 12 20 genomes and liberal usage of Active Record the provisions of came with 2
thousand 600 tests out of which were 730 control fast
and the rest of them were not just plain rule object tests there at bunch of some cucumber tests and of kind of our tests as well as this that integrated or verified some ElasticSearch behavior as well as rare find this IP job was kicked off so it wasn't just controller and the regularly the full suite ran in around 8 and a half minutes
so we got OK let's optimize our way in which the and
running a single controller with the existing applications whether require is always and took around 14 seconds in that case after we did all the um configuration changes and all the required statements because now we actually needed to at all require statements many back into the code base which rendered before because it was a regular across arrays application um we're only to kind of able to cut it down to 9 seconds still with better but not to the benefit we had before and for non-control aspect it look a little better if we were running a single non-control respect to around 6 and a half seconds um and we were able to come this down at least 2 around half a 2nd so there was more some optimizations if there was a better optimization for us then with the control test but um we weren't able to just that slide throughout all base because many adding or require statements I took a lot of effort and it all benchmarking for 2 controllers and at the end of it a limited status show me I have 150 pulse change so because of the planned project we can't be right we can't build the client for refactorings that we want to do for a factor and say so we would need to find a way to slide in that as we add more features and so we couldn't just but the switch and say yeah no replication is faster and we have a better development experience but we could them do some projections so um the made enough minutes was the previous and runtime for this week and with the knowledge about it like it's not just the control test and uncontrolled test for us um we project the numbers that we were able to cut it down to it he's 5 to 6 minutes which is still fairly long too long for my own taste but In the better than before and but
with all the changes in all the explicit requires some and all that not many people would agree with me main point I'm trying to make is that launching a test suite should not be a daunting
task you should you you want to be able to run a test suite model times a minute to get this fast feedback and if you only take 1 thing away from the start this
Split obvious that covers it which is better of us in a spec over that has um just that just loads are spec and maybe find single them that does however said you want to be using 2 of the testing and a set of rules that cover that requires the existing spec cover and also redress environment this way you have this is a real weighing proved in order to release optimized all your non rates test that you can just test the class that does not require anything from rails you get a huge speed benefits the um to having said all of that the sum of the what the rails
way so what is this actually means In raises doctrine we can read that
there's a bit we value conventional configuration we made a very conscious decision in our team that we favor explicitness orbit interested in this I like to read explicit and boring code they magical does not I I'm only you have I don't really like it that doesn't mean that I don't like rails but it's just like favor explicit told over knowing that pockets something will be loaded something will be done for me in the background as worth mentioning that conventions are heuristics they're non rules you can break them and if you learn something new you might even realize spam punks convention used to follow for 3 years maybe it's not mentioning what we should use something else and it's not a bad thing this becomes so the 80 20 rule applies here again but all these conventions we find areas work very very well for all in Iran's itself there but the remaining 20 cent might be something else and that's fine not back and doesn't mean that race is not the right fit for them to just that still offers enough flexibility in order to support the remaining 20 % you just need to maybe work a little bit harder to read these benefits
from some mentioned earlier I wanna talk a little bit about general architecture as well more I don't want bore you with 97 this material about what's up product it should look like there are a couple of more recent architectures of there
the 1st 1 is clean architecture which the find some entities in the core of the application that will be orchestrated by so called use case implementations and then these use cases will be exposed through controllers in our result of application for example through the web and in a similar vein there is a thing called hexagonal architecture and coined by as the worm which goes in a similar direction like at the core of few application action actual applications and you provide different adapters for different clients thank you can have it weird after an hour to connect the Qt going to eat for nation T adapter to connect maybe a browser to replace think of radius here and these adapters do not only work for at like bound to some connections also for album connections like you have an inductor in order to connect to your persistence layer posters or my sequel will you have an adapter for the house arrest adapter that connects to sales force for example the and last but not least I mean Martin promised book Patterns of Enterprise Application Architecture is this thing called Service land same idea again you have a user interface that connects service layer which guards you the main model which then it in itself has access to this it's copied 1st it's it's your database at the end of day and we look at these 3 and architectures they look very similar they all have the same idea behind them and it's not something completely new even because if we take the service there's as an example and we focus on 1 particular area and we zoom in on that it's pretty much the layered architecture again like nothing new to learn yeah we're back in the future but in the nineties on its fine like in new words for old concepts like isolate the application from the outside world that's pretty much it it's important to remember those that raises not your application and this is why I was emphasizing the um architectures of that and I wanna show you an example of pictures e-commerce platform here begin e-commerce platform we might have a huge class that's if you looks and you have 0 customer class representing this particular user and you can have a basket glass again consists of a couple of products and each product as a category and while the checking out what's and we need to select a delivery method as well as payment method and at the end of the the payment process we get an invoice PDF for example and this is our core application where we don't see a controller that we don't see a section hash or any non rails all where the notes but this is the core of our application this goes in the direction of
fundamental designed with a book a highly recommend to read um and in order to tie them back to the and I think that at least actually so before that's a overcome that
applies to our is that we can hope that would apply to erase applications the result from top to bottom or user interface is unity browser and this browser connects the rich EPA to our is implication or our chicken of controller and the checker control of then translates this web progressed to a thing called are check out which is our use case implementation this instance and the check a process of that check use cases that mediates between several domain model objects which ideally should just be final rule objects that defined some behavior and then at the end it will create an order which is what which acts as our gateway to our database and this is pretty much at like a top down 1 request comes in you might have something new in the database how does that tie bacteriocins NBC idea and we see has become this more of an abstract concept and design pattern like thing like that um and
we've seen that a couple years back in there is community in and where there was talk about where we should Arafat models or always stick to escape controllers and you realize OK these models that really really hard to pass so we went to the other extreme and said OK let's keep the models really thin and put all the data in the controller switch May degree artists of drawers it it's not enough to all the finger talk about these 3 buckets use I see this as a balloon that you just squeeze in
1 and you know magically them removing air all responsibilities from from things like you just squeezing it here with and it will expand the balloon on the other side so it's important to not think
about them or focus on Skinner fat anything we should focus on healthy everything because spreading the responsibilities and small chunks will help us make Dridan easier to understand coal-based like if we only worry about classes that have 5 to 10 lines it's immunity it should be easier to understand than following 15 that long um method for example um and when I was
preparing this talk I had a chat with a friend over coffee and I was going through the topics and areas I wanna discuss with him and he was asking UK so we did this type of Ray's style for a couple years now and he was a senior would you do it again would you still do all your as applications like this and I was thinking moment but well all the preloading and slowing optimizations yes for sure but the idea would be and screening yard like removing the directory and moving everything to live probably not I think this is finally overrated and because if you think back to
be default the director structure the um I don't necessarily need to know that this is a movie orientation database or uh e-commerce platform for all flowers or something like that it's OK to so I will characterize application of a wonder no more at probably look into live or if there's source directory the source and then I have my nice namespaces responsibilities laid out there um and with the separation of concerns or like separately application from everything that its of specific I actually like the idea to have half these physically separated now my core application isn't it nothing race-specific should league intuitive everything rains and Web related should should stay in this makes not trivial but at least easier to operator is well because we don't need to worry about anything that is a little maybe we wrap some active some job dependencies in silent but this is reloaded lipase our application nothing operators should leak in there the so everything comes with a trail and I'm not trying to sell
you the promised land here like me it's not that magically all of a sudden you end up writing more and more awesome raise and there aren't traders and their heart of you make for example explicit requires this is something that is not necessarily some used in the typical res application and if you
take back the city example or the city metaphor at the beginning we put up some big construction sites and just come through a couple of blocks not without thinking but it we need to be aware that it comes with a cost because we need to remember like we work in teams usually and we're not an
island right it needs to be a team decision because at the end of life in the end it's the team's effectiveness is more important than our own idealistic view of how applications should be structured because at the end of the day that is the technical detail of the final for controllers in this directory of that there are 3 who cares really what every
project like this now that this new approach probably not I will wait until I some until a few a pain of having a soul tested and then worry about OK how can optimize this for some of will put up Iran's application for people to sign up for my birthday party that I will put on create Europe scaffold that lot of it and deployed in college they really it's really thinking about how much maintenance you expect for this particular problem of problem and a much benefit do you get from all these them optimizations and the
and we should remember to not just follow whatever has been done before us question things break things fix them again but break things and question things like a cleaning Tower of Pisa for example it's a great attraction at this massive amount of people go there every year is that indicated that we should build every telling this now probably not and less only someone
we know your tools like know why you follow certain rules but also know why and when to break them make a conscious decision and on that note I think to time for I will leave some for some
questions but 1st thing thank you for listening to me few part so I
arms SHS and
Bit
Mereologie
Computeranimation
Gradient
Mapping <Computergraphik>
Subtraktion
Befehl <Informatik>
Flächeninhalt
Dreiecksfreier Graph
Serviceorientierte Architektur
Lineares Funktional
Flächeninhalt
Mustersprache
Ordnung <Mathematik>
Computeranimation
Bit
Architektur <Informatik>
Gruppe <Mathematik>
Kontrollstruktur
Kartesische Koordinaten
Kontrast <Statistik>
Computerarchitektur
Login
Computeranimation
Radius
Web-Applikation
Schreiben <Datenverarbeitung>
Strömungsrichtung
Ordnung <Mathematik>
Computeranimation
Aggregatzustand
Lineares Funktional
Pareto-Verteilung
Funktion <Mathematik>
Schlussregel
Biprodukt
Pareto-Verteilung
Computeranimation
Office-Paket
Gradient
Softwaretest
Rückkopplung
Suite <Programmpaket>
Dreiecksfreier Graph
Ablöseblase
Projektive Ebene
Kartesische Koordinaten
Softwaretest
Rückkopplung
Projektive Ebene
Kartesische Koordinaten
Ordnung <Mathematik>
Refactoring
Whiteboard
Code
Computeranimation
Entscheidungstheorie
Resultante
Subtraktion
Bit
Prozess <Physik>
Quader
Extrempunkt
Gruppenoperation
Mathematisierung
Klasse <Mathematik>
Gruppenkeim
Versionsverwaltung
Kartesische Koordinaten
Framework <Informatik>
Computeranimation
Data Mining
Richtung
Datensatz
Einheit <Mathematik>
Datenmanagement
Gruppentheorie
Fächer <Mathematik>
Fahne <Mathematik>
Konfigurationsraum
Default
Gerade
Softwaretest
Mailing-Liste
Gruppenoperation
Konfiguration <Informatik>
Linearisierung
Quelle <Physik>
Generator <Informatik>
Framework <Informatik>
Menge
Last
Gamecontroller
Projektive Ebene
Ordnung <Mathematik>
Programmierumgebung
Tabelle <Informatik>
Aggregatzustand
Punkt
Selbst organisierendes System
Kartesische Koordinaten
Computeranimation
Homepage
Domain-Name
Informationsmodellierung
Konstante
Programmbibliothek
Datenstruktur
Schreib-Lese-Kopf
Array <Informatik>
Namensraum
Dokumentenserver
Systemaufruf
Ausnahmebehandlung
Konstante
Generator <Informatik>
Menge
Basisvektor
Gamecontroller
Computerarchitektur
p-Block
Eigentliche Abbildung
Ordnung <Mathematik>
Verzeichnisdienst
Normalspannung
Orakel <Informatik>
Bit
Fortsetzung <Mathematik>
Computeranimation
Hydrostatik
Socket
Lineare Regression
Inhalt <Mathematik>
Figurierte Zahl
Konfigurationsraum
Gerade
Analysis
Modul
Soundverarbeitung
Befehl <Informatik>
Elektronische Publikation
Instantiierung
Entscheidungstheorie
Konstante
Menge
Thread
Heegaard-Zerlegung
Gamecontroller
Server
Projektive Ebene
Stapelverarbeitung
Sweep-Algorithmus
Dokumentenserver
Implementierung
Kartesische Koordinaten
Fortsetzung <Mathematik>
ROM <Informatik>
Computeranimation
Eins
Datensatz
Client
Mustersprache
Auswahlaxiom
Softwaretest
Suite <Programmpaket>
Dokumentenserver
Datenhaltung
Open Source
Zwei
Rechenzeit
Elektronische Publikation
Softwarewartung
Festspeicher
Mereologie
Gamecontroller
Aufzählbarkeit
Projektive Ebene
Ordnung <Mathematik>
Programmierumgebung
Objekt <Kategorie>
Softwaretest
Suite <Programmpaket>
Prozess <Informatik>
Gamecontroller
Schlussregel
Computeranimation
Minimierung
Mathematisierung
Zahlenbereich
Kartesische Koordinaten
Code
Computeranimation
Client
Puls <Technik>
Softwaretest
Gamecontroller
Datenreplikation
Kontrollstruktur
Softwareentwickler
Konfigurationsraum
Array <Informatik>
Softwaretest
Befehl <Informatik>
Axonometrie
Rechenzeit
Zwei
Rechenzeit
Rechenschieber
Suite <Programmpaket>
Einheit <Mathematik>
Gamecontroller
Projektive Ebene
Refactoring
Task
Softwaretest
Suite <Programmpaket>
Informationsmodellierung
Punkt
Mathematisierung
Computeranimation
Softwaretest
Gewichtete Summe
Menge
Last
Klasse <Mathematik>
Schlussregel
Ordnung <Mathematik>
Bitrate
Programmierumgebung
Computeranimation
Überlagerung <Mathematik>
Heuristik
Bit
Architektur <Informatik>
Heuristik
Orbit <Mathematik>
Schlussregel
Biprodukt
Code
Computeranimation
Schlussregel
Entscheidungstheorie
Arithmetisches Mittel
Flächeninhalt
Computerarchitektur
Ordnung <Mathematik>
Konfigurationsraum
Fitnessfunktion
Resultante
Schnittstelle
SCI <Informatik>
Domain <Netzwerk>
Subtraktion
Prozess <Physik>
Sechseck
Browser
Gruppenoperation
Klasse <Mathematik>
Implementierung
Fortsetzung <Mathematik>
Kartesische Koordinaten
Dienst <Informatik>
Systemplattform
Computeranimation
Open Source
Informationsmodellierung
Client
Hash-Algorithmus
Einfach zusammenhängender Raum
Radius
Architektur <Informatik>
Benutzeroberfläche
Datenhaltung
Datenmodell
Wurm <Informatik>
Dichte <Stochastik>
Biprodukt
Dienst <Informatik>
Flächeninhalt
Forcing
Anpassung <Mathematik>
Gamecontroller
Speicherabzug
Wort <Informatik>
Garbentheorie
Computerarchitektur
Ordnung <Mathematik>
Lesen <Datenverarbeitung>
Domain <Netzwerk>
Prozess <Physik>
Browser
Implementierung
Kartesische Koordinaten
Computeranimation
Eins
Open Source
Informationsmodellierung
Domain-Name
Benutzerbeteiligung
Gamecontroller
Gateway
Modallogik
Benutzeroberfläche
Abstraktionsebene
Datenhaltung
Entwurfsmuster
Datenmodell
Schlussregel
Objekt <Kategorie>
Minimalgrad
Gamecontroller
Ablöseblase
Ordnung <Mathematik>
Instantiierung
Klasse <Mathematik>
Endogene Variable
Gerade
Computeranimation
Trennungsaxiom
Orientierung <Mathematik>
Namensraum
Momentenproblem
Datenhaltung
Minimierung
Kartesische Koordinaten
Quellcode
Systemplattform
Computeranimation
Weg <Topologie>
Benutzerbeteiligung
Flächeninhalt
Prozess <Informatik>
Endogene Variable
Datentyp
Zustand
Speicherabzug
Datenstruktur
Default
Verzeichnisdienst
p-Block
Computeranimation
Softwarewartung
Soundverarbeitung
Videospiel
Sichtenkonzept
Rechter Winkel
Minimierung
Gamecontroller
Projektive Ebene
Kartesische Koordinaten
Verzeichnisdienst
Computeranimation
Entscheidungstheorie
Kraft
Ruhmasse
Kontrollstruktur
Vorlesung/Konferenz
Schlussregel
Turm <Mathematik>
Mereologie
Vorlesung/Konferenz

Metadaten

Formale Metadaten

Titel Breaking Bad - What happens when you defy conventions?
Serientitel RailsConf 2017
Teil 17
Anzahl der Teile 86
Autor Gockel, Christoph
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/31233
Herausgeber Confreaks, LLC
Erscheinungsjahr 2017
Sprache Englisch

Inhaltliche Metadaten

Fachgebiet Informatik
Abstract With Rails being over ten years old now, we know that the Rails way works well. It's battle tested and successful. But not all problems we try to solve fit into its idea on how our application should be structured. Come along to find out what happens when you don't want to have an app directory anymore. We will see what is needed in order to fight parts of the Rails convention and if it's worth it.

Ähnliche Filme

Loading...