Merken

Just Because You Can, Doesn't Mean You Should

Zitierlink des Filmsegments
Embed Code

Automatisierte Medienanalyse

Beta
Erkannte Entitäten
Sprachtranskript
1st needs so this is the you can find me on various places on the internet like
everyone else these days uh give of Twitter heresy fine afterwards and so 1st of all
I have to thank ideas to people number 1 at the same as I work for a tech company called magnetic our home offices in New York City and we also have offices in San Mateo on the west coast of the US and in London and thankfully for account conference policy defining out here I guess this is now my 2nd year of life on them so I think that's the conference and that this year was great and so the same my company differently for sending out you but 250 employees of the wording advertising if you're interested come talk to me and afterwards we run by by and production we have been for for about a year and a half now spot involve a of the Fund technologies but again so
this is a talk about object API is not particularly talked about Web API is I wanna talk a little bit about what you wrote some libraries some piece of code and inflicted on the world and some some sort of simple common pitfalls that come up when that happens there now inflicting it on the on the on the world might be a small world media the only user other than that the person that you end up kissing office probably you in a couple months after you wrote it and so I suspect that some of these things will still apply and
I don't really want talk very much at at the higher level of concern over the entire about level design stuff for abstract concepts and things like that and sort of just gonna pick 3 or 4 were somewhat common specific things that tend to come up as examples for more general concepts of there's sort of 1 General higher-level things that I think is worth keeping in mind which is that someone who 1st comes to your library or who has used the library for a little while but and then you know uses a bit more of it that comes in with some expectations right so there a programmer they've used other libraries or the views parts of your library they're gonna have some expectation for how some new part of your library works and they might be surprised if they find out that it doesn't and this display play between being able to have some intuition about what a particular piece of code is going to do and then some result that doesn't match that intuition is often 1 of the things that I think causes frustration for people when they're when they're using libraries and so when when you're when you're designing things think it's important to keep keep that specific idea in mind when you when you make choices and how they affect the predictability for a given piece of code so let's just sort of jump right in here and the so the the
the most agreeable classic example for something that they can go wrong is checking
items everyone has his heard of duck typing around has heard you know I don't I checked don't do this sort of thing was so so what's going on here right so you have some generic compute function unspecified here which is going to do some very exciting computation sure as and and before you do so you you have this is instance checking check to make sure that some numbers that you being passed so our sitting inside a list and if they're not then you can raise an exception and so you people they don't do that you don't I check y and what was the actual problem here or a least 1 of them this so I have possibly a way to say what the problem is here is what you're function says that it needs is an actually what your functioning bunch of course it's possible for the for your function to exactly needed a list but generally speaking in the overwhelming majority of cases that's not actually true what you what you really need is some piece of functionality that you can rely on for the object that you're being given to have maybe that's you know that it's maybe sequence at at at at best is 1 of those things generally and and so by artificially enforcing that'd that'd be of a specific type of Europe limiting the amount of extensibility that someone who might want to use this function has end user who you know since the system find such a thing is is can end up being pretty frustrated because there's very few ways actually get around that right you have a function in front of you that's exactly what you need it is a simple of barrier in front of it that's saying you have an object that would work here and there is an exception being thrown that's going to prevent you from actually doing what you want the results I think type-checking is probably the most classic example of natural and artificial barriers that put up when when designing and some particular piece of code other side that some other ones so I I should've mentioned to start with there's probably depending on your perspective some heavy opinion in here so I'm sure there will be things that people disagree on both about that dispatch and so a couple of different talks at the conference have discussed graphs and so it is a simple graph Coupling Nodes couple edges between them and we can represent this for our on graphing library rates were let's was create graph class so looks pretty much as he expects at least on the top you have a graph class this can take some argument that actually constructed and actually what we're going to do here is there's going to be 3 separate kinds of arguments that will take so we'll take a bunch of different representations and end up constructing from them a graph because there's a lot of different ways that we might that we might have our graph represented as data and and a lot of different ways that we might want to construct a and suppose we have a list in which case the way will interpret that is if you give me a list of 1 2 and 3 those are probably the nodes that you want so in a graph is a 1 2 3 that create your graph with 3 nodes and no edges and another possible thing that you might have is a vector mapping which will probably be some adjacencies so adjacencies you have a dictionary has a bunch of keys so in a dictionary is the key 1 and its value is a list 2 3 4 and what that is interpreted as it is note number 1 should exist and have connections to nodes 2 3 and 4 so you can build up a dictionary that looks like that and the dictionary is you're adjacency matrix here this is a mapping President of the graph class and that will create a graph with those nodes in those edges and maybe some 3rd form that our graph might take that we might wanna actually support and is some form of serialized graph right so I guess in an artificial example might be J. son so maybe have some graph represented as Jason dumped string that you want work as a way of actually constructing a graph in a more realistic case there you know varying formats for actually storing graphs and files and representing them on as bytes and so and if we want support 1 of those so you can you take a string in its a . or 1 of those other formats worse the string and construct a graph the sum format the year in the U . 1 except there and so we have these 3 different past creating a graph so what's the problem here and so the problem with at the eyes that do that sort of thing is generally speaking the person calling function actually knows what they want right so you have 1 of those 3 things you're someone using a library that does this you know exactly which 1 of those 3 cases you are you know if you're someone who has an adjacency MIT matrix that you want to construct a graph Graph from you know if you have a file that you need to read and parse and you know if you have a bunch of nodes that you wanna create a and what the source of EDI do it this take someone who knows some information thrown away immediately and then try to get it back again right so the about that as and work you're going to have an init method in your class it's going to take an argument of 1 of those 3 types it's going to say a you know is this case 1 of its case 1 this is a case to it so this is a case 3 of so do this and sort of artificially introduced some complexity there where the person calling that function probably knows exactly which of those 3 cases she has or she has a knows exactly which of those he wants to happen but but just ignoring that information in your API in just telling someone here throw your stuff over here and I'll I'll just for you which 1 you want so don't don't create API is that throw away information that
someone might happen just to make at all the more concrete imagine that you have an API that specified in the mentioned before so you have something some documentation some pros probably that says you can create a graph I accept the format of the the list of nodes addict's with adjacencies or string which I will deserialize and create a graph from what's going to happen if I ask you something like this so I have a generator expression where I have some free calculated list of nodes I want some filtering and pass it into the to the class and create you know just just some just a just a graph of some some notes from that was what's your gas as a user right if if you if you see a library that documents those 3 possibilities is this likely to work I let's actually do a poll so if if if you saw the condition of those 3 things do you expect this to work stories and if you expect it to work dead so about the order of I actually probably would side with the people that say that this probably would work because generally when I read that and that API documentation says that it accepts a list I assume that the person doesn't actually mean a list hasn't done any type checking and so they probably will accept intervals so this 1 I probably would assume works but the actual problem here is that we actually have to guess like a quarter of the people in this room would guess yes 3 quarters would guess no and the fact that you have to guess is the problem and similarly you let's do the same thing so some people find this to be surprising some people don't but roughly strings and lists and by sort of the same thing we now have different methods but roughly a string a list is the same sort of objects and so you pass a string that looks like this in with with the intention would say being I want to create a graph with 6 nodes and their letters a through F so let's do the same and people would assume that this would work same people most of the they probably read the documentation as I do have an ice in the rest of you I would assume that it doesn't and about this 1 and so the problem with this 1 is this thing is an adjacency matrix right someone has a dictionary they don't actually mean but that 1 is gonna map to some string cat and 3 is mapped to some string dog of some of just happen have a dictionary that they got from elsewhere they 1 actually pass into the function but they want PPI I let's say to treat this as an interval of nodes and so they just want a graph with nodes 1 and 3 in there and so there is a branch in those 3 that says you know if you have if you have a bunch of node i can be a graph from that just a bunch of nodes but someone who actually wants to do this so this 1 I if we do the same poll honey people expect this to work OK now I disagree because I I would assume reading that I least personally if I saw that something said that it takes effect and considers it to be adjacency matrix that that probably is via some sort of branch that's you know and saying you know is this a little bit is this an adorable if it is ah sorry if this a mapping if it is then the adjacency matrix part in which case that's gonna probably this this object will probably hit that branch and be misinterpreted so I wasn't personally when I read the documentation that this wouldn't work but again the fact that we have to guess is the problem I have an object here I wanted to be treated via 1 of those 3 branches I know exactly what I have and what I want and then being presented with an API that's telling me I'm going to 1 of 3 things good luck figuring out which 1 it is so so what's the what's the right thing here or what what am I getting and so provide provide EDI is that that let users say exactly what they mean so that has class methods they're great for alternate constructors and so he if you want to be able to create graphs from intervals are list so whatever creative ways of doing so that explicitly say here's what I'm gonna take in here's what I'm gonna do and don't get that information out same thing you you want build take adjacencies greater method actually is gonna often do that and to do this for each of your input formats 1 frame for each input format document and well and no 1 has to guess if I have a dictionary which might not actually be an adjacency matrix and I wanted to actually be treated as an interval of nodes while now I would assume if we connect the sample if you saw methods that sent from measurable and from adjacencies how many people in here would assume that if you pass the dictionary to the from interval method that would do the thing that you want in that case so I hope more now the 0 2 and so on you have methods that better represent the actual operations that people want perform do you get better results and even your your errors will be better me you know you have you guys that do this sort of guessing and when someone passes and passes in an object doesn't actually managed to catch any of the branches was likely to trace back they you end up getting says things like in the object has no attribute data items and you say yes I know why we try call it a items on my integer you know what I was trying to do x y z and maybe I was assuming that I want to do something else if if you passed you know 12 into from interval that error message makes a lot more sense it's going to be at least on a branch the expected to be taken I and the last thing to say about this is you can still get the actual thing that you might still want which is you know maybe you actually do want the guesswork so you you wanna provide some sort of convenience for someone who doesn't know that taking some data they don't know which which form it might be in I personally I wouldn't do it in this specific case but it has come up
in in in some cases you can still do it and now it's it's
just a simple just calls out to methods that other people can call directly and so if you know what you have to build a called directly the method that you want if you don't know what you have to be able to use a method that just doesn't dispatch and just don't do it in in right let people opt out and and make people have not been is that is the point for this 1 and so shifting gears a little bit of about something else
resource management so you're you know talking as if the or some other you know saying you what you want be able to upload files somewhere see this class a client for years FTP server something with a method for uploading your files and ignoring issues of remote pounds or whatever the other methods and it takes a single argument which is the path to the file on disk just open the file and sensor bytes of the file again ignoring you know how to name the file on the remote server and so was the problem with this 1 this is what it is you can write on this gap well uh um read and write yeah yeah that's probably 1 problem at least of no generic enough yes exactly so you're adding doesn't actually care about file systems or it shouldn't care about file systems it it's not generic enough is exactly it right so and you're you're object here it concerns all are or should be sending some are right you it it out as if the to some remote server which means its core competency is speaking as FTP it shouldn't need to know about file systems we should need to know about taking a bath and this and finding a file on a file system and why is that because like I guarantee you well for 1 when you see things like this I think it's uh decreases the likelihood that such an object has tests which I of the curious to hear whether others agree but but when you see things like this assuming that the subject does have test if you go find and you will find at least 1 place that most likely does not actually want this object to look at a file system but you'll find 1 place that at least that's trying to do something other than load a file from disk with this object which is an immediate example for it's not generic enough at so what's the what's the the lesson here the lesson is don't sandwich functionality inside don't say much of functionality inside resource management right you you're going to need some resources from somewhere don't hide here functionality behind the actual access that's needed to get those resources that's what you do instead so yeah make it more generic there is no need to actually go off and read files in your object let the user worry about how to get the resources from wherever they need them from so your you upload method can just take of i like objects like we said before in which case you know now not only In this object not have to deal with file systems anymore but you know you're fire like objects can come from string I just in memory strings they can come from and you know something I was loaded database that there's a lot more of functionality that you'll get for free despite not having to deal with resources and besides the fact that that test case which probably didn't exist before is now more likely to exist and more likely to not involve Monte patching but wait possibly objects you actually have to deal with file systems right that's probably a fair objection enter most of the time objects don't actually need to deal with file system they could just deal and fire like object but there are objects out there that might actually really want to talk to file systems a fantastic it's not actually the core idea of this talk but now possibly this is a great example for that reason path libraries exist right so but I think there is 1 in the standard library and place on 3 I know there are others 3rd party libraries but the exact function or 1 of the functions that have management that path libraries are trying to solve is exactly this problem if you do have to deal with a file system how you represent that in a way that doesn't actually require dealing with a file system on this and so I did their work recently you have an object instead of a string that represents a path and that object knows how to open itself and so your users will profit pass in you know file path objects which will actually hit this but in your tests or if someone actually wanted to know what how to do something else in real life they can pass in you know some past backed by a database so that when you called open on it you actually go off such the data from the database but were an memory file system that when open was called in it just fetch some data from some in memory objects and so this is exactly why those sorts of things that things exist is exactly to solve this problem of but I really wanna talk to a file system and you still can I just don't do with strings ask those
same topic uh if there is anything worse than file systems it's probably the network so the dealing with the network is even less funded think the so let's talk about the network
as a some people possibly heard about that's the which I think was mentioned in a couple talks here at the conference but it's just a simple example of a protocol and so on the left side over there is a simple step to the message and so that's that's the is a metric protocol so what the message on the left means is the symmetrical called request that serve which is a metric that you're gonna let's say increment every time user request and the colon is part of the protocol delimiter and then 3 means increment this metric called request that served 3 times c means it's a counter so it's just an account of the total number of times that that was implemented so it's a very simple message when you send this to that's the server what that means is I just served 3 requests and the service can aggregate all those and possibly display them for you do all sorts of simple and things like that as he had this plan on the right side that's going to speak states the inner part to the server this descend over these messages and to someone in their application is going end up constructing 1 of these and calling the counter method saying hey I want count some requests so they would feel cold the counter method passing request that served as the name of the metric that 1 incremental and then specify account of 3 and so what the what the body here is going to do is all it does is it assembles 1 of those messages and sends it over the network and by just sort of writing it I guess that should be well send all from 1 of the nice so it just write some bytes to a socket more or less and what's the problem with this 1 it's very similar to the problem with the last 1 and the object doesn't care about the network or again to be somewhat more correct it shouldn't care about the network and why is that as well to be a specific about this case there's 2 pieces of work that are being done here 1 of them is very nice and 1 of them kind of stinks and so protocol assembly and how they actually construct some data in a proper format is great right we have a ton of different protocols some object needs to know how to actually take the action of I want to count some requests and convert that into whatever format that's the actually is over the line but so that words fantastic but actually getting those bytes on the wire sending them someplace else that's a mask why is it a mass because your application your of your library is that's the library most likely doesn't actually implement a full networking stack that's not a networking library and you're users might want to plug in their own transport methods like this always comes up for every library out there that there's does some networking there's somebody out there who has wanted to you know to use g event to send the actual networking but instead of the standard libraries argument like instead of using blocking sockets our raising Kyowa twisted or a tornado or any of these things right that someone wants to send the bytes in some way other than how you decided to do so in a library but but but when you couple the 2 that the 2 things together what you end up as with 1 object that actually combines the actual data transformation with the actual transport which means everyone ends up implementing the same exact date assembly i every single client that just once the talks density so have 2 objects 1 object knows how to construct the protocol 1 object if you'd like implements the actual networking parts so that the next guy who comes along and actually once the node send send send some stuff in some other way doesn't need to do both parts and you test again will appreciate it because as similar to what
I said before about file systems when I see something like what's on the right but it also decreases the likelihood and I think that that
object will end up having tests because psychics are even more annoying that same thing tends to happen with API clients when I mean Web API client which also I think there workable really get toxin at this conference every API kind in the world more or less it's you know the rest over HTTP stuff this 2 parts there's 1 part that actually construct some URL to hit and then there's another part which actually does the requesting right so you have you know Facebook API to iterate the irony of these clients and they have 2 parts 1 of them implements the actual Facebook Twitter API whatever else and the other part actually makes no recalls split those apart right have have things that actually not implement API from from the client side and then bolt on the networking afterwards actually make those requests that someone's gonna wanna do some some other way and find Twitter clients and further out these 500 of them and sure each 1 of them actually implemented the same actual assembly of Twitter's API that well would be sure about that it's definitely a possibility so yeah I have it you create an API how many of clients actually implement the same simple building of urals so don't make them splits with part of people reuse 1 part of it and not the other 1 and uh let's go to another example and so now we will actually implement HTTP client right so again make some requesting back some responses and the question responses have a couple of attributes maybe have some headers and maybe have some cookies associated with them and so I'm sure everyone seen that like this request headers just a mapping between you and that is the name of the header and the value so this is constant i planes and there is no standard same thing for cookies now there's a session ID and a color preference but the problem is that that's not actually a proper representation of either of those things because headers and cookies are actually unordered mappings of a string value pairs and but the person that's doing that is actually trying to be malicious right there is this the fight between convenience and the compromises that you have to make right over example pairs all well when the coming off the wire the ordered and also you know you can have multiple repeated of the same had the right to have multiple lines with the same header and HTTP as is the case and find what to do and how to combine those and all those things so it's not actually a one-to-one mapping but it's not actually so that might be an ordered by the specification would still might be useful to know what the order was when it came in all of that thing and so on someone who's designing API that does this sort of thing is is probably trying to make it convenient because in 99 per cent of the cases most likely that an acceptable compromised make but that if you provide convenience provided as a layer right so similar to the ideas before i do provide an API for accessing cookies and you wanna do that in a convenient way build access the cookies just by specifying the key in getting back and I get the value that was in the request the response and the layer by for provide access to the actual underlying things and so you may have seen the cookie living standard library modules specifically the cookie jar object in their cookies have a bunch of other values associated with them right so quickly has an expiration date potentially as a domain and its associated with all those things are metadata besides the actual value of the cookie itself to don't hide details when you're providing convenience later provide means later but still give access to some actually need something else other than what Europe layer provides so terrified that 99 % case in a way that also let someone get what they need but if they have to just because it's better but if you're providing abstraction layers it's better to provide at least a leaky abstraction layer than just about abstraction layer that you don't actually have any way of avoiding last 1 um so how many people have seen API that do something clever like this and so now maybe were implementing css selection it's going to go find some see it some elements on the page and the way that hypothetical API works is use a CSS that by ID and then the thing that you put after that is the actual name of the element that you're looking up at people seen API is not necessarily for CSS but I assumed in other domains that do things like this and so I assume that distance smattering of hands the sold all
these are all of the well some of the things that can go wrong this from 2 minutes of thinking about it right so what are all the things that you need to access valid quasi-identifiers if they're not well now you're going pretty wooden API that was like CSS that by ID done whatever and not so pretty API because anyone wants to access CSS element with whose ideas class for whatever reason needs of the get function call so just something very simple like is it that it does that the actual set of valid things match up with a set of valid Python identifiers is just 1 thing at what happens when you access a non-existing attribute right so you have an API that looks like this you access know CSS that by the . 4 borrows doesn't actually exist on the page and what's your prediction as a user what whatever will you get right so again predictability you you try access anatomy that doesn't actually exist on the page what you against and and there's 2 choices as and probably of most people would go 1 of those 2 ways about 1 is you get some specific application area that's there no such CSS on the page or the other 1 is actually there which we used to getting for all sorts of actually missing attribute of things right so so again you have to guess you provide an API where someone is most likely going to have to guess what they're going to get and what happens when you accidentally pass your object is something that's doing some nasty dispatching or not even nasty dispatching but trying to access at tributes on random objects so for example a common example things that do this are you know editor tools that are trying to do some runtime things right which article get random access referendum attributes on your object and check to see if you know the actually is there individually they do something right so you're object which might actually return for any attribute might actually return an object is gonna just utterly confused that object in API just randomly tries to access some stuff on your on your object and of course the things they're trying to access random attributes on the greatest thing in the world the but they definitely exists I
and even worse than that offered for general API stuff what happens when you need to add a specific active you right so you you forgot that you need some specific method but there's no way of actually adding that without breaking backwards compatibility because whatever you add to that the thing that someone could have already decided to use CSS selector or in whatever other form the CPI takes and you you just can't have it and not break backwards compatibility weapons when you need to parameterize how you actually access the specific things like this happens with properties as well with the property decorator you know he usually you're accessing and the specific elements of and I figure out there some parameter that actually you wanna use to control something that happens during that access again you have no way of actually implementing them because you just use the attribute access there's no actual parameter passing so you just can't and ultimately the reason why not it's just like what's wrong with that there's there's nothing particularly ugly to me about just passing arguments to functions so just to summarise
communities also everyone should make the libraries convenient and all of these things are fantastic just don't sacrifice your users predictability or the ability for them to come on and extend what you have choose the right interface for your problem and stay away from file systems networks databases all those things let other people have to deal with those as a but
Thomas command of the of understand dates standard and people have some sort of expectation that the API and names are as usual basically and if you follow Pepe maybe most people will agree with the names and not have to rename your names in Europe in the uh yeah as not to question just a comment evolve type shaking play on 1 thing where you might need it even when you're all functions access their beautiful and you might want to check that it's not a strange because otherwise human endeavor sending e-mails to reply will have to have well as it is in now up than than others others comments or questions really was as agreeable has way more agreeable than I expected would you mention this comment about this would you mention about research resources and you have the resources that's that's can be extended to extend that to any situation is like a skull separation of concerns that you that's a Bulgarian to design principles so it's not only for resources but by anything what class should be 1 particular just not opening 5 of you open the file % the 5 yeah I think the only specific reason why did just write separator concerns is because I think when a separation of concerns and for specific things like the file like files networking like it's important to just be very specific there like literally any time you have to deal with file systems or the network or sockets I think it's probably a moment of Paul's square separation concerns sort of like a general thing and we all try to keep in mind but it's easy work is beneficial I think have like specific touchpoints that say like 0 I'm about to define an API that takes half a string that probably means and doing something wrong and I should I should stop probably I agree it's it's covered separation of concerns thanks you mentioned separating the protocol and the transport and so on do you have any examples of someone reasons do that correctly that so I can learn from that it sounds like a good idea but I pictures how to go about doing it correctly true so there probably well possibly interested there's still here maybe uh so so the real answer to question is no not really except in 1 sense so the reason why I brought that up is that there are some of libraries that use like or come there was a push at 1 point is that using like actual context-free grammars to do the passing of particles in which case if you actually encapsulate that part and yeah that parts going to be reusable so I can and 1 of those down and pass that along to you as FIL the 1 example of a place that would actually separating had a password create actual particle language itself from doing the actual transport so no unfortunately I don't have very many good examples I wish there were more and just another comment about the file system example those another bad effect of doing that if you open the file inside your function and you may be so what if you return to the upper layer you maybe have to really open and again due due to some other reasons or even you had already opened and you need to close it and so it's just the wrong layer yeah and and in the in the same thing I can't even count it's probably 3 or 4 at this point the number of libraries and that had to 40 and patch up because not only were they doing resource management inside some function but they're doing it incorrectly without using with statement was causes nasty things on I use the you know file descriptors and things like that for us just don't do it the and the question the and I think you called me
Videospiel
Twitter <Softwareplattform>
Zahlenbereich
Vorlesung/Konferenz
Wort <Informatik>
Biprodukt
Computeranimation
Office-Paket
Resultante
Bit
Programmiergerät
Datensichtgerät
Code
Computeranimation
Übergang
Erwartungswert
Benutzerbeteiligung
Wechselsprung
Prognoseverfahren
Geometrische Frustration
Programmbibliothek
Auswahlaxiom
Umwandlungsenthalpie
Sichtenkonzept
Matching <Graphentheorie>
Physikalischer Effekt
Abstraktionsebene
Quick-Sort
Office-Paket
Objekt <Kategorie>
Rechter Winkel
Mereologie
Hypermedia
Resultante
Matrizenrechnung
Gewichtete Summe
Natürliche Zahl
Selbstrepräsentation
Computer
Ungerichteter Graph
Komplex <Algebra>
Computeranimation
Eins
Typprüfung
Feuchteleitung
Umwandlungsenthalpie
Lineares Funktional
Parametersystem
Datentyp
Typprüfung
Klassische Physik
Ausnahmebehandlung
Quellcode
Bitrate
Endlicher Graph
Rechter Winkel
Dateiformat
Information
Schlüsselverwaltung
Instantiierung
Zeichenkette
Subtraktion
Klasse <Mathematik>
Zahlenbereich
Code
Graph
Mailing-Liste
Knotenmenge
Bildschirmmaske
Perspektive
Datentyp
Programmbibliothek
Maßerweiterung
Trennungsaxiom
Einfach zusammenhängender Raum
Graph
Mailing-Liste
Physikalisches System
Vektorraum
Elektronische Publikation
Quick-Sort
Data Dictionary
Zeichenkette
Objekt <Kategorie>
Mapping <Computergraphik>
Serielle Schnittstelle
Verträglichkeit <Mathematik>
Adjazenzmatrix
Neuronales Netz
Sichtbarkeitsverfahren
Resultante
Bit
Freeware
Rahmenproblem
Klasse <Mathematik>
Ungerichteter Graph
Graph
Mailing-Liste
Arithmetischer Ausdruck
Knotenmenge
Stichprobenumfang
Datentyp
Programmbibliothek
Attributierte Grammatik
Soundverarbeitung
Lineares Funktional
Nichtlinearer Operator
Konstruktor <Informatik>
Datentyp
Graph
Güte der Anpassung
Verzweigendes Programm
Mailing-Liste
Rechnen
Ein-Ausgabe
Quick-Sort
Zeichenkette
Objekt <Kategorie>
Mapping <Computergraphik>
Rechter Winkel
Ganze Zahl
Konditionszahl
Mereologie
Dateiformat
Boolesche Algebra
Information
Ordnung <Mathematik>
Computerunterstützte Übersetzung
Adjazenzmatrix
Lesen <Datenverarbeitung>
Zeichenkette
Fehlermeldung
Bit
Punkt
Freeware
Filetransferprotokoll
Klasse <Mathematik>
Datenmanagement
Schreiben <Datenverarbeitung>
Computeranimation
Sandwich-Satz
Graph
Client
Datenmanagement
RPC
Mini-Disc
Programmbibliothek
Dateiverwaltung
Drei
Softwaretest
Videospiel
Lineares Funktional
Parametersystem
Elektronische Publikation
Datenhaltung
Likelihood-Funktion
Objektklasse
Elektronische Publikation
Quick-Sort
Objekt <Kategorie>
Last
Rechter Winkel
Festspeicher
Server
Speicherabzug
Message-Passing
Standardabweichung
Lesen <Datenverarbeitung>
Zeichenkette
Subtraktion
Total <Mathematik>
Fächer <Mathematik>
Gruppenoperation
Automatische Handlungsplanung
Datenmanagement
Zahlenbereich
Keller <Informatik>
Kartesische Koordinaten
Transformation <Mathematik>
Socket-Schnittstelle
Metropolitan area network
Client
Datennetz
Zählen
Programmbibliothek
Dateiverwaltung
Gerade
URL
Formale Grammatik
Softwaretest
Parametersystem
Protokoll <Datenverarbeitungssystem>
Datennetz
Ruhmasse
Objektklasse
Ereignishorizont
Quick-Sort
Verdeckungsrechnung
Dichte <Physik>
Objekt <Kategorie>
Arithmetisches Mittel
Dienst <Informatik>
Rechter Winkel
Mereologie
Server
Dateiformat
Socket
Message-Passing
Aggregatzustand
Standardabweichung
Browser
Selbstrepräsentation
Element <Mathematik>
Statistische Hypothese
Homepage
Client
Cross-site scripting
Trennschärfe <Statistik>
Dateiverwaltung
E-Mail
Gerade
Umwandlungsenthalpie
Softwaretest
Datentyp
Datennetz
Abstraktionsebene
Gebäude <Mathematik>
Arithmetisches Mittel
Twitter <Softwareplattform>
Rechter Winkel
Heegaard-Zerlegung
Client
URL
Ordnung <Mathematik>
Schlüsselverwaltung
Standardabweichung
Zeichenkette
Ebene
Facebook
Implementierung
Domain-Name
Benutzerbeteiligung
Endogene Variable
Programmbibliothek
Abstand
Attributierte Grammatik
URL
Likelihood-Funktion
Cookie <Internet>
Modul
Quick-Sort
Endogene Variable
Mapping <Computergraphik>
Objekt <Kategorie>
Injektivität
Mereologie
Parametersystem
Cookie <Internet>
Kantenfärbung
Klasse <Mathematik>
PASS <Programm>
Kartesische Koordinaten
Element <Mathematik>
Homepage
Bildschirmmaske
Prognoseverfahren
Existenzsatz
Randomisierung
Attributierte Grammatik
Umwandlungsenthalpie
Lineares Funktional
Parametersystem
Kategorie <Mathematik>
Validität
Rechenzeit
Systemaufruf
Quick-Sort
Objekt <Kategorie>
Texteditor
Wahlfreier Zugriff
Flächeninhalt
Menge
Rechter Winkel
Parametersystem
Attributierte Grammatik
Identifizierbarkeit
Dateiverwaltung
Schnittstelle
Prognoseverfahren
Datennetz
Datennetz
Dateiverwaltung
Schnittstelle
Punkt
Momentenproblem
Kontextfreie Grammatik
Klasse <Mathematik>
Formale Sprache
Zahlenbereich
Schreiben <Datenverarbeitung>
Socket-Schnittstelle
Erwartungswert
Datenmanagement
Datentyp
Programmbibliothek
Dateiverwaltung
Vorlesung/Konferenz
Passwort
E-Mail
Soundverarbeitung
Umwandlungsenthalpie
Trennungsaxiom
Lineares Funktional
Befehl <Informatik>
Datennetz
Protokoll <Datenverarbeitungssystem>
Elektronische Publikation
Quick-Sort
Patch <Software>
Quadratzahl
Mereologie
Partikelsystem
Message-Passing
Standardabweichung
Zeichenkette

Metadaten

Formale Metadaten

Titel Just Because You Can, Doesn't Mean You Should
Serientitel EuroPython 2015
Teil 145
Anzahl der Teile 173
Autor Berman, Julian
Lizenz CC-Namensnennung - keine kommerzielle Nutzung - 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/20146
Herausgeber EuroPython
Erscheinungsjahr 2015
Sprache Englisch
Produktionsort Bilbao, Euskadi, Spain

Inhaltliche Metadaten

Fachgebiet Informatik
Abstract Julian Berman - Just Because You Can, Doesn't Mean You Should Python is a powerful language that provides many tools for creating highly dynamic programs. It offers tools all across the complexity spectrum that library authors can use to make their libraries seem convenient to use for users. While it's true that there are a wealth of techniques with huge positive benefits, there are a number of common antipatterns which can deceptively cause a net-loss in flexibility, readability, and predictability for users. We'll explore a few specific commonalities in this area of library and object API design, and talk about the ramifications they have on each of these programmer concerns.
Schlagwörter EuroPython Conference
EP 2015
EuroPython 2015

Ähnliche Filme

Loading...