Merken

Class-based Views: Past, Present and Future

Zitierlink des Filmsegments
Embed Code

Automatisierte Medienanalyse

Beta
Erkannte Entitäten
Sprachtranskript
and I'm going to try and better so that this was not only but it also a light day job is as this is here and the founder of traits that we're a cloud provider of services as offices for traits that also follows electricians like at that point that is my day job but the
reason that I'm here is that of been a court from gender projects as since January 2006 about the present the dagger Software Foundation since 2010 datasets as I said my introductions morning is that the RIP legal and fund-raising arm of gender part so if you are interested you write here represent a company that has money of like talking about this because we need your money and
that's what that's not why I'm here today today here to talk about class by use class-based views were introduced in Jenga 1 . 3 but have not been have put this greeted with universal enthusiasm at so let's other reason giving this talk is is the uh uh uh I read you talk like that about a month ago at a generic on Australia and on a clear up the mess what what our cost base views why do they exist and why should anyone care have now I like to emphasize this isn't a tutorial and its attempts to sort of sit the big picture straight in the hope that by getting the big picture straight RBI at some of the broader discussions about class-based views that I keep saying on mailing lists in Twitter and things like that and try those discussions during a slightly better direction or ugly stuff from being quite so badly wrong as the fundamentals of was discussions on the right so if we're talking big picture and to explain why these what we've got we've got it helps to know where we come from and and people with more history than to repeated so cast your mind back
the halcyon days in 2005 um To Django was introduced as a as a mechanism for building web sites uh the use of their for displaying content there are lots of common patterns in the use of you'll like being driver like not repeating ourselves so gender had this concept of of of generic views while and they were they were added because we want those properties they went in very original release they were added on July 25th their 2005 release 304 was about 2 weeks after Jagger went public class based views officer a generic views and 1st landed in gender progress and are added because we had these common problems was solving more will avoid uh a reproducing the same code again sorry you refactor all code you have
you identify those key patterns generic views of the year to do things like display a template display a single object on a page display a list of objects on page display a form we used to create update and delete Connor consequences of displaying display an archive of of of objects based around item j j goes coming from a a journalism or strong journalism background such as a list of articles by died is a common problem that they were trying to solve those generic views and wrapped up into the inner and isn't that kind of key features each of you is a function and you can figure that function by passing in arguments to to control 1 that functional operate sort for example a common this is of running through the code that you would have written for 1 in its view for a book the the book the view you like request object in passing the ID number of the book you want in its and you do a try catch still try except to get the book the book doesn't exist which for a for uh if it's outposts they were actually saving the result of the former case of you instantiate the form with the dog from the request and the instance of the book which kind its check of the form is valid how we provide all the rate information is required if it is then say that form and then redirect to the URL for that particular book does if it's not like a post request and we're gonna shoot a GET request uh generate the form for just the empty instantiated shows what form should look like and render the um that form and the objects again some sort of template like I said actually boring vanilla code and you don't reproduce that occurred over over and over again for every object type that you want in it you then take that you when you deploy it into your all patterns again finite euro Pattern says I want to it's a books last books slash ideas we're gonna go to that view the book you were gonna call it in a book so we can do a euro and 9 biased you're look up uh and everything so not happy with now got have you for editing a book into our project but then generic views this I collect Cody's so cookie-cutter it so generic that we can replace that instead of talking about your generic procedure by idea up that object we can report on a book you we can replace it with this idea of updating an object and configuration to say this update object was specifically we're gonna be updating books so again be looking for books based upon object ID the 9 new world that signed the operation of the function is exact science so instead of having to rewrite the boilerplate to update an object have that try catch if follow you can just say well here is a pre version aligning to dropping is the model which is a book fantastic which means that I can we then we have books we also know that it alters the I think we need to change is with your old fits slash also instead of last book and the model reconfiguring is is also part of the book and the name of your own use it often is that a book as us the the best best practices of code reuse find the thing that you doing over over and over again factored out something the generic name can figure from each individual use the fantastic so there are some problems that are OK so configuration options the configuration options for that generic function view but a limited by the arguments you can pass the test is a function of the in the diarrhea passing in different ideas to make this thing happen if you want to instantiate a different form instead of the generic model form as being there being granted you when have a very specific form be instantiated based upon some sort of property of the object that you activatory will you can't do that you would perform sums of logic after the form has been validated but before performing say well unless you connect you put that logic onto the forms save method itself you don't have an entry point to inject that logic I you wanna passing extra arguments to the form instantiation like for example really something really simple like the request will not on the she supported would decorate or something like that uh that you you can't do it you have common permissions logic that you are under this view or parts you axis of the if you have a particular permission unless you could put that on a decorator you can't do it so how do we address these problems well OK you can keep adding new functional entry points you can take cycle is another configuration of a configuration item another configuration argument or you can say like configuration of we can actually a call and we can say OK we passing the function that you operate in this particular part of the function and go completely yeah and deep like that um but at some point which you basically end up doing is implementing half the features of class inherits the so as an example of what something thing up to about here in practice let me go back to where it book example few you've written this corridor 1 has written this card at some point and it's really really easy society like if the form is valid before we say if do something so and we want to prepare the book before we actually the fall true it if you got access to the full view almost impossible to do it if you go if you can't do it with a generic function by the use the wearing as of about 1 . 3 almost impossible to explain why would like to extend the loss function refused to make that use case really really easily the
so again we must reflect all things that instead of trying to pretend that were going to implement class-based used by having into a function let's actually got class but let's
actually make these things classes subclassing gives you these entry points you can say I've got some behavior my based behavior is to do nothing more to do a very simple thing but you can in some class and add additional behavior that you want or you can override specific pieces of logic you can use cost mixing to compose behavior and other uh at of a collection of objects and that's essentially what we did for gender 1 . 3 now it turns out that although that's the high-level architectural goal but in practice it turns out to be not quite that simple there are lots of little details needed sort out the discussion around class views went on for years uh there were several draft attempts made at landing something that was a class-based you uh Jacob couple most tried stressed Cochran strident Fishman tried iams of the person who stand on the shoulders of giants the I'm response on the person who did the final push and got building on top of the efforts of all those those gentlemen and finally ended up committing something for 1 . 3 to the architecture that I committed is most like the would be indeed been doing with the with the address of do just go over the shaky unfortunately that's where the wheels fell off the whole process and why why did that happen well there's a couple of reasons firstly there's a lot of confusion whether a lot there has been a lot of confusion about what class used actually are and what they should be or can be used for this a lot of folic confusion because this 2 very distinct purposes in the card by around this of this 1 can make that was to the got land and 1 . 3 and and those 2 very distinct purposes of 2 very distinct pieces of work were wrapped in a single commit and as a result of look like 1 feature the 2nd promise that the implementation is not necessarily obvious it's the way it's implemented all class but a implement the way they are for a very specific reason but that reason leads to non-obvious complexity that if you come to the idea for the 1st time thing was being done this way is this otherwise would about a lot more sense than a lot more obvious there's a reason quite a lot the surge of criticism that has been leveled is something that's label ravioli court I'll come back to exactly what this means it's a legitimate criticism that it religion architectural criticism and and all comes of an explanation of what maintenance and so that worst problem of all was that the documentation at the time but landed in 1 . 3 was to use the technical term bad and I take full blind that when I wrote the documentation of that such that it was in 1 . 3 and by it was not good documentation by any stretch the imagination uh if anything else it's it's it's an object lesson in the person who writes the code should be the documents that because it was obvious to me that was obvious to you guys that seems seems I landed my original documentation not Hammond any Greenfeld another others of my it's really contributions really the improvements in that area so that that situation ways has got a little bit better but the rest of them still exist so let's let's go through them in front cleanup is wonderful miss what I might 1st off purpose other are 2 very distinct pieces all work inside what is the feature of class by using gender 1 . 3 there are class-based views and there are class based generic views when people talk about the comedian usually gets tossed spoken about in terms of this class based view that is very true very distinct pieces of work class-based views are a class-based analog of a view function they it has been embedded in it as part of the implementation of method based on page to the the the the dispatch and that's the it's get a full of lost a few easy it's a way of saying I've got a GET request implement this piece of functionality will perform this piece of logic so for example we go back to our this is this is essentially a class view a gate is any class my class is my view and it stands I'd base class called view you had idea method guess what if someone makes a GET request that's the myth of the gets invert if someone might invoke supposed request the process request is what gets involved that is all class by the use of but because it is wrapped around a base class you be again a whole bunch of interesting features for free you could get Automated options handling so I care for those of you who have not that familiar with http we internal had to pay the hastily fever is of the request your that the name of the thing you're asking the web server due the ones that everyone knows about I get part because that's of the read and the right visions of what you're doing on the internet but is actually a whole bunch of other useful verbs options is the way you ask what verbs can I use if I go to this URL what can I do can i do we get can do a post cannot do will put can I do with the late guide to which Rice what options are available to me and you get that you get options handling for free when you use a class by you because we know if you've defined get method therefore you support gets you also get an automatic naive had request handling now I had request is essentially a way of asking the server hypothetically if I was to request this URL how big wouldn't be give me the head is not the content just the haters how big this request would be which is then useful to do in a performance optimization stuff for a large follower or something like that you can say how big is this content and then prepare yourself having the content is actually a bit you can implement function best given a class that you you can do a naive implementation I just do the do the GET request and then return the body count again you can get that for for it you also automatically get page P 4 5 on any isn't supported to hedge 2 BP for a file is method not allowed so if you've got a view that you specifically do not want to allow get requests just . implement get and anyone who doesn't get request on that URL will get had to be 4 or 5 that is particularly useful when you look at a function by the most people write a function based you if you don't have any other logic in their essentially it doesn't matter where you asked for it did put post options hated the function you return the same content which lies strictly but had to be standard is not what's supposed to do it OK so by doing it by by having this cluster structure you can deal with the verbs properly so that you can cite no you can't do that when someone does something that you're not supposed to be doing OK so that's class-based use layered on top of class-based use a class-based generic views these use the class-based view as as a base and then create analogs of all of the old function based generic used in class and a class form along the way addressing the limitations of the functional based approach so you can have the injection point you can have the extension point available to using by basic subclassing mixing that all the mass things you can do with object orientation without having to go into this and you know trying to invade class that you buck-passing callable passing in more uh more keyword arguments to the configuration the function the catch is that by addressing the limitations of the of the of the approach of function approach is if you introduce a whole new body of knowledge it's now you need to understand the class structure for how generic classes with generic you work in order to do anything with them that's the ravioli criticism essentially all come again I'll come back to exactly what's what what that means and what what are the only 2 the the 2nd criticism that
gets leveled against class that fuse is the implementation choice the approach that we talk is not the obvious 1 there are a couple of deployment things you have to do the way you put a class-based viewed in Q your patterns looks a little all it looks a little odd because it high can't be done the obvious way that would be the obvious approach just drop the class in the U has some side effects and would require at all either overhead on part of developers on hidden part of the framework that we were willing to leave I won't go through the details of what we've done the way we've done the good news is that as we actually has a complete tear down the history of the development prospects you figure that URL what you'll find is these are the 10 options we looked at here are the pros and cons every 1 of them and this is why we chose this 1 and so it's here is the design decision behind while we've got what we've got sorry if you if you're interested it's something worth a read and you can find the find that story for why you have to do as you the again problem 3 ravioli and this phrase came into being because 1 of the 1 agendas co-developers gone and we plot and it's describing the fact the Proc that we've got all ready all user as a product is delicious and tasty looks lovely on lessons square packet of trying to packet sitting a plate the internals however don't him a question the economy needs an unclear and may contain product you don't know about it also means that there is a price to becoming an expert unless you know what the internal might offer you can't just reproduced you wind up yes very attractive outside package the inside you need expert knowledge to know how to make use of the ravioli now this is an entirely legitimate criticism you know that the yeah the the generic class used to have a very very complex internal structure there are lots of entry points they're all this this is all sorts of subclasses and mixing they get that come together to give you the final end product that is an update you and unfortunately in order to use them as all for anything other than the most trivial case you need to understand all and that means that learning curve is hideously that thing gets compounded when you have really bad documentation and that doesn't explain how to get to the expert position really really quickly so yeah minimum quantum of knowledge to to actually operate is much larger than it should be so is my reveal a
cooking class 1 and let's have a look at
outputs of code version of original view is it you we need to get an object is supposed to get the form if the form solid handle form and redirect otherwise we need handle failure in some way if we go back and was a GET request then we need to get the form and then we need a return a response so how does this manifest in a generic class based that's the collection of mixing they go together to make that you have so let's step through them 1 by 1 in in internal running time in inside we've got a single object makes it we are dealing with a view that will be returning a single object words dealing with a single object we need to put that single object into a context so that we can actually deal with a single object so we have a context mixing which is subclassed into a single object mixing which essentially what does he say I can make sure that I can render a single object on a package for yes and that's basically doing the get objects cottage on dealing with a single object and again against an object persist form view is that it this is like a this is a view dealing with forms that means get a deal we get posts inputs so let's make sure that got a GET POST PUT entry point and that in the 1st 2 whatever it is the rest of this form of this this page is doing is doing a single object bottle design and our body together do get close to put them all the fair everything else subclasses the the what exactly we're gonna do well I again this case we're dealing with is a form of the form makes the handle and the way we deal with forms we need to instantiate a form and we need to check the form is valid we need to well handle the five-year year many extension form when we have daughter we don't have done but in particular this is I form it's being driven by model so we need to gotta generate a moral biased form so we have a full mixing which contributes to the moral for mixing the model for mixing knows is dealing with a single object so it is also bringing in a single object mixing to give you a amoral form dealing with a single object and then at the end the day having handle before got the object handle the form dealt with appropriately many to give a response back to someone we have a single object template response makes in which says given that I know of a single object in my context and it's being handled in an appropriate way render it render that single object into a template again again the single object template response fiction is an extension of template response mixing in which is the generic I need to return a temp like a single object templates 116 is I need to return a template that deals with a single object so there we go simple mind classes to go and get your non-ionic seems to get you a simple view that allows you to do updating a single object with a full what's the problem as I k so but this is a this is why it's so complicated let's say we want to move from being an interview to being a creative you what's the difference in the persisting will fundamentally it's exactly the same except instead of creating or getting an existing object we need to gotta instantiate a dummy object and make sure that only objectives that he was the new what we want react so we really want a modified is the bit rather the beginning to get objects need to turn into instantiate an object so we need to do is change the base updated due to a base created view that knows how to create objects rather than getting an existing 1 so the most of the code is gap science we just have to use 1 slightly by class which knows how to instantiate rather than in the retrieved from about us what I what about instead of creating this create you instead of responding as a temp light we wanna respond with Jason company would build an IPR well again the creation process to be dealing with a former student we dealing with instantiating object all that stuff is assigned this difference is down the bottom instead of rendering to attend we wanna rendered 2 adjacent spots so you can switch up the single template that as a single objective about response mixing with a single object Jason response mixing and all a sudden start generating Jason content and everything else can get reuse what is that
look like we're actually gets deployed OK well this is your generic function-based view you asking for up update object to pass in the class we want configured the book and we give you your own effectively this is all you're doing is saying instead of a passing in the function up that you you get the class update you and you say I wanna use this as a view for the book model that this is a bit of a story about the the that is not necessarily obvious way to use high class there's a reason to be done this way so I the into the that wiki page again if you wanna 1 wants to the reason why that doing it in 1 line if you do have a 1 0 well you bring it out as a class in your right and that's essentially the shorthand for saying I've got this class for book update view it extends generic up that you and it's configured to use a particular model is a book and any disciple cut that you as you and they got you can deploy that immortal times neural structure you want a case so that other than using up more lines of code and why would you want to blow this out as a separate class will the reason is it then you can extend it yourself so subclassing lets you dig into the internals overwrite your murine pieces of behavior if you want so remember we said you could mean gx logic in to the process to say if this form is successful and but before we say that we want this an extra processing will like and we would do is I he form valid by default form will save the form but we wanna do some processing 1st so the object of process and then just do whatever the base class to go often cite the form and so you can easily inject logic in all we need do is I right a single method you need to know that's the message you don't need 1 right but you are on 1 of the injector logic into the flow we want and you got but what about something more complex and let's have a look at some of the Commission's data you can use mix seems to define behavior and then inject that behavior into any class you want so what a really really complex missions in here are based on random number generation and you want any attempts to access a single object to be checked against DoS role if you pass the dice rolling city object fantastical you would do is override the way did you get that single object by default the implementation of get object will go and get an object based upon the arguments have been passed interviewed by the right of put some extra logic in that say if the random number exceeds whatever threshold but then you're like to see it otherwise return for a full not or any other fora for if you wanna do it in any other had to be response to 1 and then we would do is sigh is my mixing it defines get objects you can drop that into any of you update you create you whatever you got a reusable block of random biased commissions logic uh to to inject into any view which 1 do you 1 hand this now as a side note form valid method that I had on the previous slide you good on that as an extent as well and it's just a question of how reusable a piece of logic is in practice a specific post say behavior probably doesn't have a lot of reuse potentials are an overriding subclass makes a little bit of sense permission checking is some of what you want to have the same conditions scheme uh in existence for all objects like polenta mixing reuse that makes in urban the sorry In the dire remember regularly taste good is that there's a reason the Italians did make it and ravioli allows really coding is context let allows us to reuse call logic over over again you only need to define what's how do I get a single object and then you can reuse that logic everywhere you go of view that deals with a single object it's extremely flexible from new logic it's easy to add your mixing but unfortunately you need to grok although pieces to be out you know where you got it got so like I said the technical term for the documentation state at time delivery was bad and they got all the tells 100 % correct but completely miss the big picture and it's kind of like the big joke about the person sailing by in a year in a hot air balloon goes past the the the tall building yells at sites he's making his 2nd you tell me where where am I the guy says you're a hot air balloon 100 meters off the ground technically 100 % correct utterly useless information I am sorry yet the documentation makes the miss the big picture yeah you still also need to make some framework decision we have kind of not made at the project level decision about whether we should be using class decorators assistance and like a login required data a login requirement is easy to do in cluster on on a function by you you just it with a decorated is looking required to use a mixing you use a class that arise you use a method that right on the class there aren't there are multiple ways to skin that fact and as a result there is now kind of multiple ways to do it no officially blessed right way for as far as gender the projected and documentation instance so at 1 level as a quoting we kind of need to bite the bullet pick 1 and then encourage everyone come around with I so where we go from here uh documentation can always improve the they're awesome high-level decisions of accompanied make agreed that it documentation and we can extend colony in of when we when we landed and we land at 1 point in 1 . 3 the generic class views we very deliberately drew the line at replace what is there and we had a creative you we had an update you we had uh had that's the basic said let's just replace what's there we know there are an infinite panoply of things we could build let's stick to this deliver that and then we'll move on from there now at least what he Gertruda lots of additional class-based charities the could be built there there wasn't any function-based generic view for handling form sets so there isn't a class-based generative view for handling for this the the the obvious addition or object class online forms but this that of thing is an obvious um it's obvious construct have because we do in ad so there is room to expand had those generic class by fused into into general officially blessed so why haven't we added the meaning to be needs well 1st of all I need to ask the question have we solved the wrong problem here and we go back 30 on slides that I put up this
list of the features of generic views meaning together display a template our to display a list of a single object a list of objects of form we need to create update delete objects we need and displayed archive and these were all very very common problems in 2005 and we were coming from a well we had great big job of websites that you want to associated with and we've replaced this lot like fresh framework his build these functions really really easily because we were solving the problems we had in 2005
modern web sites have different problems or at least much more involved answers to the same problems a unite a genuine hey look this is a this is Ossianic modern web site
has multiple forms and forms its propriety which it has continuous scrolling rather than pagination based uh views of the world it will almost inevitably be doing I Jack's at some level including anything like in place editing and you on on on page life validation of content and you go have things like P. Jackson navigation so as to give something we use the page header is always there and you navigate and the euro changes but your only really reloading part of the pages content that you have the considering multiple actions that played you don't go to the create page to create you go to a page you have a whole bunch of different actions you can do to honor their indirectly it 1 of them and then you got your rich Johnston Driven driven user interfaces where you got the the there yes there is back in Dallas being provided to but would you go on the front end is is a rich API driven user interface the the mood the images of things like react angular in the economy this is what a told we're using to build the front front-end tools and and gender was kind historically said no we just set aside but we don't deal with the front end but as a result we can't have adapted well to these problems exist in interacting with this with the front and problems so In particular the idea like user interfaces something right I kind of 1 1 hop on as an audience I I think we can take as a given a good website are good good software Proxima delivering these days have API that documented vision full 1st class citizens of ecosystem we're trying to become a developed and like the made by by delivering this is a half of the site experience you actually genuinely build an ecosystem and enable other people to remix and reuse the functionalities website in ways that you as a person who just delivered a user interface and possibly have an envisaged or conceived of and if you think about it is there any reason that a properly authenticated automated process shouldn't be I would do everything that a properly authenticated actual humans human can do and the easiest way to make this happen is to make the user interface and the API have functional parity at the end point really a user interface is just a way to allow meat to invoke an API and then visualize the response to that in a way that we can understand so why not make the API that the same we working on here can put aside from the FSO of force reply benefit is a civil engineering benefit because API Zary's we tested at the user interface just invoking an API it a good good conceptual separation between waters were actually trying to achieve that we can then tests it seriously and we've got a user interface needs to invoke the user an API which we can test again you got good separation between the presentation between me and the actual and get that the functionality you try to drive digit testing that I juggling user interfaces out don't really easy to generate an index we got idealize really generated but gender framework but tasty pi and others that are out there but we're missing of the views the building the user interface we still need to be out to describe navigation and composition of various pieces of functionality on page and all this I would argue
requires that we have a strong base framework to work with the the and my argument is the class-based views provide that framework had not class based generic used by on very strong but putting putting that the class here if you are a great solution to the problem we had in 2005 I don't think the generic use we've got today are a great solution for today's problems but that doesn't mean the class-based views can't be the basis for what we do what I say that with confidence will to a certain level it already being done on gender country but I mean is a class based you it doesn't speak genders on dog food but it is class based in that same you've got this object i.e. an admin objected to deploy into your structure that they knows how to do other more interesting things interestingly it's implemented using a single call method which is 1 of the approaches that the bad class place views that was delivered as part 1 . 3 rejected because there is case of security implement the implications in it but again dig into the documentation when find about that will come and ask the American and but deluded the yeah and so we we got I proof that we can build a class-based complex user interface use class-based mechanisms to allow people to have extension points to add functionality to make complex user and facts I and I think this is something that's worth exploring a little bit more gender this this power
doesn't need necessarily teapot genders call genders admin and was distributed as part of called that's kind of the conceit of the packaging of the structure that existed in 2005 and which is to say that it wasn't packaging infrastructure in 2005 these guys could be installed gender food works and everyone knows it works and everyone just has the requirements following deploys websites to realize that we could conceptually pull django admin outlook put this separate package and then just have it automatically being stolen you still gender it's it's easy to do that kind of thing now the that being where so if we're going to genuinely replace Adnan water use admin as a testing ground for we can do long-term into of cluster structures and we can do this completely at sort of caught maybe with a long-term image of bringing is a quarter manage project something but exploring this idea of 10 we build rich user interfaces a code level class-based we easy extension points and what have you to support all these API here user interface controller here connected DAQ are like this is something we can test outside of generosity of call and then possibly bring in interesting part of it into core has a long term thing sorry I get
the so called reaction here if you are out in the field and you are discussing class-based using class generic views please be clear about which of those you actually referring to if you're criticizing class-based views are you criticizing class-based views alright click criticizing class-based generic views I will heartily endorsed anyone criticizing clostationary views they have unbearable your problems criticizing class-based views have of you have a lot more trouble getting an came across it because I think there are much much longer framework people get credit for documentation can still be improved so if you are interested in those class or ingesting cost views that there is a lot of what we could do improve imitation and we got sprints coming up this weekend so if you feel like controverting that would certainly be helpful way to contribute if you are interested extending what is there there are tickets things like I tonight 30 is a is a ticket that I wall back the right form collection of ways of getting richer functionality into class buys generic views without necessarily having a whole new farm of of cost-based generate you mixing have and but also experiment experiment ideologies of broad idea of building rich user interfaces at a functional level to cite agendas Adnan is really just up by deeply introspective but it's really just user interface to cite here is a list of things we can get here is a way of displaying an object having more pieces of functionality with filtering and I can play sitting in in in in place the form submission this is an idea we can play around with a not I I have any solutions on so the interesting talking about if anybody wants to talk about it on which to combine many things pregnant and so you add play around we don't we don't have to still live with it is because the tools we've got to we've got gender needs to continue to evolve or we run the risk of being taken over by project like your no Jason please but I wanna write out the rest of my life I have the only way we can get completely means you was a demo of a localized transceiver in in in training in 10 minutes is to have a compelling counterexample that we can build things much more complex than the tennis so format it even
questions I'm happy to answer questions and and I hopefully see some ideas in the community and then said a few things straight about that constitutes for thank you in this and in
Dienst <Informatik>
Punkt
Prozess <Informatik>
Objektklasse
Sichtenkonzept
Cloud Computing
Computeranimation
Office-Paket
Fundamentalsatz der Algebra
Sichtenkonzept
Klasse <Mathematik>
sinc-Funktion
Mailing-Liste
Objektklasse
Sichtenkonzept
Rippen <Informatik>
Quick-Sort
Richtung
Twitter <Softwareplattform>
Geschlecht <Mathematik>
Rechter Winkel
Mereologie
Projektive Ebene
E-Mail
Gerade
Kraftfahrzeugmechatroniker
Web Site
Sichtenkonzept
Kategorie <Mathematik>
Klasse <Mathematik>
Content <Internet>
Gebäude <Mathematik>
Web Site
Sichtenkonzept
Code
Office-Paket
Generizität
Druckertreiber
Arithmetische Folge
Geschlecht <Mathematik>
Mustersprache
Inhalt <Mathematik>
Resultante
Einfügungsdämpfung
Konfiguration <Informatik>
Punkt
Gewichtete Summe
Datensichtgerät
Versionsverwaltung
Template
Homepage
Mustersprache
Softwaretest
Parametersystem
Lineares Funktional
Nichtlinearer Operator
Sichtenkonzept
Kategorie <Mathematik>
Template
Systemaufruf
Ausnahmebehandlung
Bitrate
Algorithmische Programmiersprache
Konfiguration <Informatik>
Funktion <Mathematik>
Generizität
Projektive Ebene
Information
Schlüsselverwaltung
Instantiierung
Fitnessfunktion
Sichtbarkeitsverfahren
Objekt <Kategorie>
Mathematische Logik
Kontrollstruktur
Klasse <Mathematik>
Zahlenbereich
Mathematische Logik
Code
Datensichtgerät
Informationsmodellierung
Bildschirmmaske
Datentyp
Konfigurationsraum
Finitismus
Konfigurationsraum
Datenmodell
Mailing-Liste
Sichtenkonzept
Packprogramm
Quick-Sort
Chipkarte
Objekt <Kategorie>
Generizität
Mereologie
Dreiecksfreier Graph
Textbaustein
Resultante
Objektklasse
Bit
Konfiguration <Informatik>
Punkt
Prozess <Physik>
Extrempunkt
Minimierung
Zählen
Computeranimation
Homepage
Internetworking
Eins
Code
Mustersprache
Elektronischer Programmführer
Kurvenanpassung
Maschinelles Sehen
Auswahlaxiom
Analogieschluss
Funktion <Mathematik>
Umwandlungsenthalpie
Parametersystem
Lineares Funktional
Addition
Sichtenkonzept
Schreib-Lese-Kopf
Gebäude <Mathematik>
Ruhmasse
Plot <Graphische Darstellung>
Biprodukt
Entscheidungstheorie
Konfiguration <Informatik>
Softwarewartung
Verknüpfungsglied
Funktion <Mathematik>
Geschlecht <Mathematik>
Generizität
Ablöseblase
Server
URL
Overhead <Kommunikationstechnik>
Ordnung <Mathematik>
Message-Passing
Lesen <Datenverarbeitung>
Ortsoperator
Klasse <Mathematik>
Implementierung
Term
Mathematische Logik
Framework <Informatik>
Code
Bildschirmmaske
Benutzerbeteiligung
Adressraum
Objektorientierte Programmiersprache
Endogene Variable
Vererbungshierarchie
Quantisierung <Physik>
Inverser Limes
Inhalt <Mathematik>
Softwareentwickler
Maßerweiterung
Datenstruktur
Konfigurationsraum
Implementierung
Schreib-Lese-Kopf
Soundverarbeitung
Expertensystem
Lineares Funktional
Objektklasse
Elektronische Publikation
Sichtenkonzept
Quick-Sort
Inverser Limes
Objekt <Kategorie>
Auswahlaxiom
Quadratzahl
Analogieschluss
Identitätsverwaltung
Injektivität
Mereologie
Computerarchitektur
Inverter <Schaltung>
Subtraktion
Bit
Punkt
Prozess <Physik>
Klasse <Mathematik>
t-Test
Versionsverwaltung
Code
Computeranimation
Homepage
Bildschirmmaske
Informationsmodellierung
Minimum
Endogene Variable
Spielbaum
Mixed Reality
Inhalt <Mathematik>
Maßerweiterung
Funktion <Mathematik>
Sichtenkonzept
Template
Einfache Genauigkeit
Rechenzeit
Kontextbezogenes System
Ein-Ausgabe
Sichtenkonzept
Endogene Variable
Objekt <Kategorie>
Wort <Informatik>
Resultante
Vektorpotenzial
Bit
Punkt
Prozess <Physik>
Login
Template
Computeranimation
Entscheidungstheorie
Übergang
Homepage
Prozess <Informatik>
Existenzsatz
Speicherabzug
Meter
Mixed Reality
Notepad-Computer
Default
Gerade
Addition
Lineares Funktional
Parametersystem
Schwellwertverfahren
Sichtenkonzept
Prozess <Informatik>
Gebäude <Mathematik>
Nummerung
Kontextbezogenes System
Entscheidungstheorie
Rechenschieber
Arithmetisches Mittel
Framework <Informatik>
Menge
Rechter Winkel
Geschlecht <Mathematik>
Konditionszahl
Generizität
Projektive Ebene
Information
Message-Passing
Instantiierung
Aggregatzustand
Objekt <Kategorie>
Web Site
Mathematische Logik
Klasse <Mathematik>
Term
Mathematische Logik
Code
Framework <Informatik>
Datensichtgerät
Zustandsdichte
Bildschirmmaske
Informationsmodellierung
Multiplikation
Zufallszahlen
Endogene Variable
Vererbungshierarchie
Datenstruktur
Maßerweiterung
Datenmodell
Validität
Einfache Genauigkeit
Mailing-Liste
Sichtenkonzept
Datenfluss
Packprogramm
Unendlichkeit
Zufallsgenerator
Objekt <Kategorie>
Generizität
Bildschirmmaske
Resultante
Web Site
Subtraktion
Prozess <Physik>
Wasserdampftafel
Klasse <Mathematik>
Gruppenoperation
Mathematisierung
Baumechanik
Benutzeroberfläche
Kombinatorische Gruppentheorie
Framework <Informatik>
Computeranimation
Homepage
Übergang
Homepage
Stetige Abbildung
Multiplikation
Bildschirmmaske
Software
Front-End <Software>
Endogene Variable
Inhalt <Mathematik>
Maschinelles Sehen
E-Mail
Bildgebendes Verfahren
Trennungsaxiom
Softwaretest
Videospiel
Lineares Funktional
Sichtenkonzept
Benutzeroberfläche
Güte der Anpassung
Gebäude <Mathematik>
Validität
Web Site
Ideal <Mathematik>
Prozessautomation
Gruppenoperation
Forcing
Automatische Indexierung
Gerade Zahl
Geschlecht <Mathematik>
Digitalisierer
Debugging
Mereologie
Eigentliche Abbildung
Sichtbarkeitsverfahren
Web Site
Bit
Punkt
Wasserdampftafel
Klasse <Mathematik>
Term
Komplex <Algebra>
Code
Framework <Informatik>
Computeranimation
Übergang
Datenmanagement
Bereichsschätzung
Widget
Speicherabzug
Datenstruktur
Maßerweiterung
Bildgebendes Verfahren
Leistung <Physik>
Softwaretest
Parametersystem
Lineares Funktional
Kraftfahrzeugmechatroniker
Sichtenkonzept
Benutzeroberfläche
Computersicherheit
Systemverwaltung
Einfache Genauigkeit
Systemaufruf
Objektklasse
Sichtenkonzept
Quick-Sort
Objekt <Kategorie>
Arithmetisches Mittel
Generizität
Framework <Informatik>
Geschlecht <Mathematik>
Beweistheorie
Basisvektor
Mereologie
Projektive Ebene
Speicherabzug
Videospiel
Lineares Funktional
Demo <Programm>
Benutzeroberfläche
Wellenpaket
Sichtenkonzept
Klasse <Mathematik>
Stellenring
Mailing-Liste
Framework <Informatik>
Computeranimation
Gruppenoperation
Übergang
Objekt <Kategorie>
Gegenbeispiel
Generizität
Bildschirmmaske
Datenfeld
Rechter Winkel
Geschlecht <Mathematik>
Dateiformat
Projektive Ebene
Ereignishorizont
Beobachtungsstudie
Videokonferenz
Vorlesung/Konferenz
Computeranimation

Metadaten

Formale Metadaten

Titel Class-based Views: Past, Present and Future
Serientitel DjangoCon US 2014
Teil 12
Anzahl der Teile 44
Autor Keith-Magee, Russell
Mitwirkende Confreaks, LLC
Lizenz CC-Namensnennung - Weitergabe unter gleichen Bedingungen 4.0 International:
Sie dürfen das Werk bzw. den Inhalt zu jedem legalen 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/32822
Herausgeber DjangoCon US
Erscheinungsjahr 2014
Sprache Englisch

Inhaltliche Metadaten

Fachgebiet Informatik
Abstract One of the big changes in Django 1.3 was the introduction of Class-Based Views. Opinion on them is strongly divided; some love them, some hate them.

Ähnliche Filme

Loading...