Merken

What can python learn from Haskell?

Zitierlink des Filmsegments
Embed Code

Automatisierte Medienanalyse

Beta
Erkannte Entitäten
Sprachtranskript
and welcome to the next keynote from but I met to Bob when he was involved in the linear and in 2006 we was also hacking on the pipe project and of course he was also in several conferences but she actually instead of continuing with pi pi he went on doing something very commercially viable I found that want to media and the company around advertising and it's as happens seasonal doesn't need to work anymore for finding money but you cannot go to conferences and to give interesting talks and play with lots of other things and 1 very interesting things also doing is is involved in missions which is an educational program 142 in children in high school some programming all kinds of stuff and he's doing that on his own time simply and is also sometimes looking for the next big thing to be involved in but is not eager to actually get this week so I'm I'm very happy that we have in here because he is he also wrote the HTTP a major http server and along yes helped involved the green LED library in play from and lots and lots of different things I think you have also been involved in the adjacent symbol days parsing stuff and you know he's he's done lots of stuff in Python but also in a large and recently also in Haskell so I think he's a perfect guy to tell us a bit about what Python can learn from Haskell and functional languages you thank you very
much for inviting me to speak here today and I'm going to tell you about some
of the things that I don't like about Python but starting off I have done a lot of Python have been doing it for a long time since about 2001 most notably I'm the author this simple Jason library which I I still reluctantly maintained and sigh I worked on a bunch of specific stuff I Objective C and all of that stuff so there you you're welcome around sorry especially the Ronald over there who still maintains that as far as I know a and has holders said they founded a company called multimedia and I worked there for a while but not too long after I sold and I've been using
Haskell for a couple years now but most notably I ported the exorcism that 0 . 0 curriculum to their exorcism is a website which has a programming practice problems in many many different languages including Python but also languages like Smith's story of sharper hostile what not so I worked on a hassle curriculum and I provide a lot of code review to people that submit solutions and has these days I do a bit of advising investing and I wrote a great open source code on this side and I teach them on the board of the nonprofit called didn't separate Cisco but you know we we hope to expand beyond that at once we've sufficiently covered the San Francisco area and so but before I start writing a Python let's just say that pi bond is not all that but I only have 45 minutes to talk so I'm only gonna talk about that I I
love finance community there there's so many great ideas in libraries that come from here and you know I find works wonderfully for many users I'm sure most of you are perfectly happy with my and for the issues that do exist they're often good enough work-arounds like pipeline number of sites on and I'm actually not gonna talk too much about Haskell but uh suffice it to say that has not all good and I I learn a lot from it I think it's fantastic but notably it has a much smaller community this non-strict evaluation stuff is just so different from from how most other languages evaluate code sometimes the documentation it's not a website with with some nice documentation it's it's like a postscript file that you download that somebody wrote for the PhD thesis and and that's kind of OK that's accepted in the community although that's changing slowly and and it can be intimidating to some because the terminology mostly comes from mathematics so you
have to you become comfortable saying things like monoidal functor amount that etc. which you know it takes people tend to get used to if they haven't taken a category theory class and so if if you're perfectly happy with Python
and don't want to change even a little bit of you might wanna leave now and go downstairs and and hang out with all the coal companies in the basement and I you know I was a lot happier with Python and still until I started learning other languages like airline hostile and I I didn't look for other languages until I really is an area that that Python just wasn't very good at and that's concurrency and network programming and I I feel like I'm a better programmer having learned all of these different approaches to problems
and a nice little quote that I ran across recently and I think this explains some of what we have
in Python today nasty little paradox the better something works the less likely will be improved and so these are some of the things that I find that Python makes it
hard to do Python makes it hard to write code that works it makes it hard to maintain code and makes it hard to create good abstractions and it certainly makes it hard to run code efficient and so on the correctness topic and you're going to make mistakes in any language that doesn't matter if it has an amazing type system or anything else you going to make mistakes and the key is is to have tools
that tell you what those mistakes are but Python 1st all that to time so unless that code that happens is not going to tell you anything the only thing you can tell you is if you use tabs instead of spaces or you know maybe maybe if you put a colon in the wrong place and then suddenly the the static analysis tools for Python today are very very primitive they could be better but it just hasn't been an active area of research I think this is because the people that can understand this problem and know a lot about type systems in inference and what not to basically move on to other languages that support these things more readily and you can write code in Python that you know was correct and you do that by running a lot of tests but some of these tests are things that that it should just be able to do for you like when you write an integer literal somewhere you know it's not a string and you should be able to add it to extract and so forth given that here's here's a simple example of a perfectly happy compliant Python files that shouldn't do anything the language guarantees that this code will not work because and and string or a close to can override how they behave you can change what clusters so no matter what this code is just going to blow up at time and we can very easily just glance at this and know that that's the case there there's no universe to which this code should do anything unless maybe a introspecting the byte code and doing something horrible but don't do that and so let's see what Python thanks alright so we through the pipeline compiler and we use this nice compile all things which I often use in automated testing because it tells me if I screwed up the syntax and what is the do well nothing it compiles while it's totally fine I get by code know where no warning of and so on another popular tool for looking at the surface of Python modules as hyperlinks so I run flags it also tells me absolutely nothing and so what about island OK so I wrote all these nice docstrings and is perfectly formatted so this is this is 10 . 0 out of 10 I did nothing wrong here nothing whatsoever it runs all these tests and it's perfectly fine right but you know it's obviously not the case and do better tools exist well I I certainly couldn't find anything and if I couldn't find anything that's bad what we have willfully and I would love to hear more about that at some understanding that's that's an idea something but maybe we can talk about that in questions that OK so so nothing nothing that I could readily find to catch the simple case of most of the tools are concerned with just the general case of Python where where you know anything to happen and dynamism in school and and you can override things at runtime and that and there's nothing wrong with them and so on so it's very difficult to write 1 of these tools when you accept that that every feature of pipeline is great and it should be used all the time but I don't think that's the case I think we should write more restricted coaches that you know in the same way that that we should indent consistently by either 2 or 4 spaces depending on where you come from a where you work and and the thing is is that Python 3 already has the hoax that we need to do a very good annotations
and we can use those annotations to tell the tools what we expect to happen and there there is a tool that that works in precisely this way and I'll talk about that a little bit so here's with some other languages do without example here's the airline
version so it's so it's you know the moreover both in some ways
and what is the only compiler do well if I if I try and compile this is warning this expression will fail with a better it exceptions and the interesting thing to note here is that lying is a totally dynamic language is not statically typed anywhere but it has optional type annotations just like Python 3 dollars and are also has even better tools by has this tool called dialyzer which does static analysis and success typing and all this fancy stuff and this gives me a more specific error about exactly why this is wrong I can add 1 to 2 strange because it expects them to both the numbers given the 1st argument and the fact that plus doesn't work on lists there's separate operator for that in this language and here's the hostile example and maybe the you know where where is the type signature well there it is but but this is this is the full Haskell program you know that that it's it's you know just as simple as the Python 1 if not simpler because there's no underscores to be seen anywhere no equals a if the number that you just write main and what men should be and then that's and if I throw the hassle compiler added is going to give me an error says I can't add the number 1 to the string 1 and to explain this a little bit we can kind of gloss over this because it doesn't really matter so it's saying this no chair thing because by the fall list of chair our strings so that's what the chair in square brackets is and operations such as plus minus times negate etc. belong to the num type fast so it's saying that there is no instance of this number type last for lists of chair so and you could be theory implement such an entire class but you really should do that only truly numeric types such as in double rational etc. should implement this num type class at the Haskell for observed they like to write type classes only when there are algebraic laws that you can apply to them and here it's the the law for the this particular categories and so why is factory in Python hard well it's harder to refactor without protest and not everybody writes to test the types are very obvious test and they're also documentation so in 1 way or another you're writing the types here anyway and really has refactoring is much easier in household isn't Python due to these types and also referential transparency and can we do something like this and I thought well the answer is yes so 1st we have this pure Python nothing fancy preference breadth 1st traversal of a graph so we have a starting node which is some some number and then edges which is a dictionary of numbers to a list of outgoing edges and we do the simplest possible that algorithm we have a list of all nodes that we visited a list that is the Q of nodes to visit and so we simply go about our business traversing that independent to act as needed and so we're going to do 1 little thing here is we're going to add type annotations to it from this typing model and so it's going to tell you all the things that I just had to tell you in order to understand this algorithm the starting node is an integer the edges in the dictionary of integers to list of integers and it's returns an iterator over integers and the only other thing that changed here as I had to annotate that visited is a list of integers because as an empty list this particular tool could infer that but nothing else had to pollute this code it's not it's not see here you know old C + + right have to annotate visited into Q and a node and tell the compiler exactly what I expected to be taken for all the details and then what what I'm going to do is I'm going to make this algorithm will want more efficient so I know that that if I use a set for nodes that I visited and uh a double-ended adapt for the q then it's a more efficient algorithm but because that is not a linear traversal every time I look for and so all I've done so far as they just change the types the only changes I made so far just just these 2 lines and obviously this this
isn't going to work because these datatypes don't implement the same methods so I run this my title over it and it tells me exactly everything else I need to change to make this algorithm work and the only thing I had to do was was changed these 2 little lines are just the the types that set and then it's going to tell me everything that's wrong with my program it says that online 11 this is that has no attribute del items so that's that's right here and online
14 that has no attend because it uses a
different method and so I can simply look at the documentation and seeing what I need to change and so here's here's the correct them it's it's very very simple I just had to change this to a pop left in this to an atom now works but might I was able to tell me exactly where to look in the code to make that change and so
is marked by the solution of this problem well you know it's the most sensible approach that I've seen so far but the other needs some help there are many tasks that that need to be done in my pride that don't really require deep knowledge of my by itself a type systems such as annotating parts of the standard library or a third-party libraries and although my pride does great stuff but it doesn't yet catch the very simple integer clustering area but can catch many other mistakes such as the 1 that I just showed and so why why is type II error in Newark Garosci thunder whatever and not a solution the problem well these projects are mostly concerned with just performance they don't really try and help you make your code more correct they don't they don't help with code quality but my aims to do both but I think right now the important part it's helping us improve our code quality and the the nice thing is is that this is just a Python 3 annotations that code runs exactly the same whether you're using my height were Python 3 and Python 3 it's not going to do any of this type checking but the code works so it's fully portable to any Python 3 runtime so my modest my proposal here is that we adopt this is a standard we should start using this typing module reward you know some standard derived from it even in the middle Python 3 by all the code in the standard library should have these annotations the documentation tool should be able to read these annotations and automatically right out nicely formatted documentation with hyperlinks for all the types and all this nice stuff and we need to start using function annotations for anything else as far as I understand they haven't been widely adopted for any other purpose so I think it's a good time to draw a line in the sand and say that function annotations bar for type annotations and and just move forward this proposal I yeah help us improve titles code quality and that the nice thing is we don't we don't really have to rely on the quality of the mind by interpreter or compiler any that fancy stuff we can just use it as a limiting tool as as just a step in a just a set of tests to run over our code we can continue using type II 3 or Python 3 or perhaps even the older Python BM once my pies backwards and say what what you can do now is start contributing to my part i and and you know maybe maybe write an official kept for for this proposal because I'm probably not going to do and so so what well the code quality tools in Python are really far behind other languages and you know I don't know what pi pattern does but I suspect that that is not quite as good as airlines dialyzer or you know has and likewise a huge step forward and it can be used with the existing tool chain the only thing we have to do is upgrade the Python 3 to make it work today and you know that something that that we've all been trying to do for for the past couple years and the only thing we have to give up his using function annotations for any other purpose and you know I don't think that's a big deal because I haven't really seen too many elsewhere and in a way without giving any meaning the function annotations is hard to use them for anything at all except for some domain-specific library specific purpose there are only truly useful if you can use them you know in all the modules a year and another thing that that
I have trouble with in Python these days is is mutability is just everywhere you can turn it off and
I think it's the wrong people is a very very common saucebox even even the beginner case where where you using add DeVault arguments and you you have some keyword arguments that to the empty list a an empty dictionary the empty set and you get behavior that you don't expect as people expected to always be an empty set but you know if you have something to it will be empty anymore and it also prevents many optimizations you can't you can't do any multithreaded stuff without locks if if things are going to change all the time i in unpredictable ways and had mutability should really be up to and so what why should it be up to and well as sort understand called when the underlying data might change you can reason about locally but you really have no idea what else is going on especially in a multi-threaded environment the value of something could change from 1 line to the next any this means that you you you there you the give up and and just hope that nobody does anything bad or you do all kinds of defensive programming so any time you return a value from from your class so you're returning self got value you're going to make sure that that value is a is a deep copy or or you know something like that every time you you wrap it in some way or if you wanna use energy in a dictionary of to just copy copy copy and copying is slow especially for large nested objects and sharing is prevented by copying unless these already happened to be mutable types like frozen center frozen data integers or strings or what have you and these days we care a lot about concurrent access and concurrent access requires synchronization if everything is mutable all the time and so can we even fix this well had because to truly fix this you're going to need some really large changes to the language is that of language in the library so as we know because we've been trying to get rid of the deal for longer than i've been using Python and it just hasn't worked so far and but if if we're trying to fix this we can look towards languages like roster swift for good examples because these languages have opt-in mutability so in in swift for example if you use their then you're declaring immutable variable but if use lot then you're saying that that is a constant even even for a data structure like a dictionary or a set so maybe that's a bit more practical for for Python to adopt and another thing that that really gets me about Python is that all the abstractions for a really expensive and so some things like it can change some of the constant factors here and there but ultimately almost nothing is free function calls are free classes are free nothing is optimized away so you're you're encouraged to inline code all over the place in and like you know make local references to globals and and all these gnarly stuff like if you if you wanna see what what this does to you go go look at the simple Jason codebase because you know I I hate doing this all this in mind all this stuff because it's not fun and you don't want to do with with decorators were AST manipulation or anything like that you just do it and and and makes it more call this harder to maintain but you do it because you get a 20 % the bump here a 20 % speed bump there and you just live with it and and I I really don't like that and the other thing is is that it the classes in in Python are open you can always subclass them you can't you can do all sorts of nutty things in classes and it makes it really hard to analyze them for correctness so basically subclasses ruin everything and so a solution that other languages particularly in the ML family of languages have come to is having a syntax to easily declare algebraic data types and so I'm not including scholar here so other languages do this reasonably and Python over the years has charoen a lot a lot of hacks to to sort of give us some of this like the the new the nouns in Python 3 3 I think and named to and Saturday they solve little pieces of this problem and even like the destructuring assignments in Python it is sort of a subset of what you get with algebraic data types in other languages and so here's here's an example of of what a typical for other looks like 4 a possible developers said you're you're working with abstract syntax trees so here I am in Python I In order to say something is an abstract abstract syntax tree node i have to define this class all this class does is defined in the dollar method I and then I have to to find all the different types of AST nodes so there's a constant which takes some integer there's this minus thing which is like the unary minus to negate the node and then I have to define had and multiply and you can see that that is quite a lot a code to do this when when ultimately it could be a lot simpler and so here's the here's the whole thing in in Haskell have so in in Haskell I have the boilerplate to say OK this is a module this would exports so in Python I would have done that with under under all but I don't really have room for it and here I'm just clearing all of the different types of AST nodes there's a
constant node there's an ad node minus and multiply and all that is very succinctly described I can look at this and I can see so these are all of the things in AST can be if I look at the Python I look maybe I should grab this code base to see if anything else subclasses AST anyway you don't have to do that in Haskell it's close these are the only possibilities here there are ways to do extensibility but you don't always need that and it's it's harmful if you have that all the time because you can you can analyze this to say 0 you didn't even say implements the evaluation for minus a and we can't do that static and so here's here's the whole evaluator in Haskell you you typically don't do this
with separate functions for each type of node you just do it in 1 function and the compiler can tell me that I handle all these functions appropriately but the the the cool thing is is that in Haskell here it can do a lot for me so here I'm saying deriving Show and eat and so what this does is it automatically writes the code for me to make sure that these have a sensible rapper and implemented like under under each you in a reasonable way so if I were to do that in Python this is what it would look like for just that 1 specific node so so in Haskell here I have this amount of code to solve the whole problem but in Python is that much code to solve the problem for just 1 particular note but so it's very difficult for for me to go back to Python and and work on these types of problems without breaking my hair and because Python just gets in my way and none of the tools can tell me if I don't it right and the other thing is is that in in Haskell which we often write a lot of abstractions and we know that the compiler can enroll those that's what those abstractions for us you can use something called new tied to just make a wrapper around a datatype that totally evaporate at run time so if you say have a float in your library that really means time and you don't want to deal with had time to pounds have succeed you can run times the flow 4 times in a new type that that doesn't allow you to interface with other sites without unwrapping at 1st and this is also used for for things like like Booleans and 1 hour so although there is a representation for true and false that is better 1 and 0 appropriately you have to unwrap them with with from you know as so the there's no reason to have code like 1 plus true equals to in Haskell because you can you can have this very efficient representation and with and without paying all this cost all the time and the other thing that dead languages like household can do is is in these abstract data types if it sees the field the strength or you don't need the appropriate criteria it can on boxes and that this is something that that is very hard to do in Python you can get a little bit of it with type II and and you can erase some of the cost using slots and stuff but but with the like pastoralists laughter whatever you just get all this stuff for free you don't have to think about and even function calls can be online so you can you can write small functions that extract little bits of code and you know that you're not going to pay for it because the in mining actually works even crossed cross-model although you do get some of this with 5 and so on on on the performance topic and I'm not going to focus too much on that because everything I've talked about provides more ahead of time information and this information could be used by tools like 5 prime number I thought my power etc. and the important part is that these features save developer time by making it easier to write code but also this information can also be used for optimization and you can lead to better performance and the the trick here is is that once it's easier to write better code it's easier to optimize it because you can refactor and you can have these types guide you to correct implementation and the other thing is is we we really need to write less code in C and C + + and because this is this is what holds us back this is why it's hard to remove the guild because we all depend on number higher whatever and these these API eyes are written in C and they need to work with the reference counting and acquire the Guilin release guild and work when were held back by that it's very difficult to change anything uh but when we have implementations of all these things in pure Python is much much easier to change the semantics so thank you type I for spending all this effort over the past decade or so and making this I even reasonable today and so on unfortunately for for the same basic reasons the Python C API is is really holding us back from doing concurrency properly and it's not even something I can talk about solving until some of these other things are addressed like mutability and and not having so much on the C libraries but and but once we do those things than fixing the other deficiencies are going to be possible but you know there is there is somewhat of a silver lining here and it has been shown that it's possible to have a mixed approach where you you write code in a subset of Python like type parallel where that subset of Python can be compiled and work completely independently of the typical Python VM objects system and so on In in summary I have I really think that we should look long and hard at incorporating all the good ideas from my high and possibly even just the implementation as a and after that we can add some more the conveniences that we find from other modern languages and to to do that some of us are going to have to learn languages like Haskell Erlang here and now or square sharp and actually come back to Python but it is a worthy endeavor even if you don't go back to Python highly recommend learning other languages I have learned so much by branching out of it and if we manage to do some of these things that we can we can enjoy a safer faster and much more capable Python in the future and thank you so thank you but for
the very honest analysis I think typically conferences you get a lot of you know hailing great Python isn't and all this and I think it's a hundred was very much to have a common long-term by the user and also for involvement in which has got this honest analysis so um questions come to but is like yeah at a question because I'm going to have to myself you think it would be feasible to use Haskell as existentially from present writing all those things from currency recursiveness trees that really good and right extensions and we make them nice sized objects you think it's possible
I think it is possible uh certainly all of the amplifier that you would need is exposed by hostile to do that I'm not aware of any library that makes that particularly easy most of the effort is kind of the other way around where you're writing code in Haskell and you want to interface with CIA Objective C or something along those lines and so on and unfortunately I think we upfront cost would be high had to write all of the code so it to expose Haskell 82 is as nice Python objects and but if you were to do something that that was a little more D. couples were were maybe you're expecting primitive values and primitive values out that that would be a lot more straightforward implement but I think that that as as a learning exercise that might be a bit tricky like diving into the FFR and and how'd across these various I think it's much more reasonable to to try and learn Haskell a in isolation may be speaking over a network to Python rather than linking to as a c extension just a small comment about the
static analysis thing and jeopardize gonna be able to find most of those boxy presented and it's very new so you can't know it still the 1 that I talk about it on Wednesday OK great all of the candidates that's all thank you I thank you for the talk I just wanted to show you some of the ice is some correlation between the dynamicism of language and the size of its community if you look at the Javascript by my in PHP now dynamic languages with huge communities and if you look at the size scale up Haskell allowing that like very small tight commuters would vary correct various people who focused on good programming practice but also incorrect maybe there is some relation to make solving in in the fact that the dynamic that makes the commuters graphs also faster and so lively so maybe by proposing a more static approach from introducing that's what's what actually hard to to sites something to think about I think that's that's certainly
an interesting consideration but there are some very easy counter examples such as C or Java or C + + i which have have presumably larger communities than than many of the ones that you cited and in here what I'm proposing is not mandatory it is often the full dynamism it is still permitted it's it's simply encouraged to add these annotations where there possible and sensible and anything else would be is simply inferred so it's not like to see a job over you have to write it everywhere and it's more like the ML family of languages where where it just happens that I I think there there are other reasons that have nothing to do with the type system what why those particular communities on our smaller or larger than than others and you I have a question myself also
because I'm involved a lot and and testing and functional testing of systems to me it always felt that you have for any sufficiently large system you anyway have to do some kind of testing right and that will make you want to make sure that you have some kind of coverage and the code selection your code lines touched and as soon as you have something like that like the tests we bring a tester behavior not just the the types of much more than just the words to get as a side effect the tactic to solve your example of like the integer 1 last string 1 which usually cause of error on this test to be part of the test also provide much more so basically my question is if you have a more powerful type system of which I can see the use of course you still have to write tests so you basically have to to add more overhead and strictness there and you have to write the test suites so I actually in that much I I think that's an interesting point to bring up of of course
you would you would write tests that you no longer have to right so many of the obvious tests and in in languages where you do you have these annotations available there are tools that can either exhaustively or like randomly generated input like basically rights clauses for free so in in Haskell I can I can write a quick check property based only on the types that that will generate you know small inputs big inputs randomly to to try and find errors and those tests are much much shorter right because this information is available and and the the the advantage is is that it it tells you what tests you need to write and additionally like say for example you have as a library that except some input as Jason and you you write a test for OK 1 of the input is a list 1 the input is a dictionary What if the input is an integer but you forget to test 1 of the input is a float but but that the types because they're they're separate types for each of these things and you can look at you can try and compile it was something like Haskell and it can tell you that you don't have a case for floats so you can very easily write a lot of tests and a lot of coverage in in Python and but missed these these cases that the type checker is going to catch and on the this type annotations are a very distinct you you don't have to write many of them basically just in the arguments to your functions and and you end up writing that anyway in in some less principles docstring format somewhere because the user of your system has to know what goes where anyway so this is just moving that that information into something that that is actually verified a either at compile-time runtime about half of the thank you yeah and if you novel
I would just like to expand on your answer and other another thing of your question and it's not only about the correctness and testing that the rest of the year extended typing helps but also the documentation of the problem the problem problems become much more maintainable when the developer immediately sees what type is returned to and what type is expected of any arguments go into the function the function that makes the development much more but what you and also it also the tools to understand program to the tools to mitigate the problem much more could be like you can do in visual field poverty pie-chart melodic idea at the product thought to have developed much better tools that allow you to program much more efficiently it's not only the correctness part just adjustment yes thank you that is absolutely correct look at them and you come up with just directly going to start the story from your book thank you
Subtraktion
Bit
Green-Funktion
Code
Hypermedia
Programmbibliothek
Server
Symboltabelle
Projektive Ebene
Optimierung
Funktionale Programmiersprache
Computeranimation
Umwandlungsenthalpie
Multimedia
Autorisierung
Bit
Code
Programmbibliothek
Extrempunkt
Chatbot
Computeranimation
Trennungsaxiom
Web Site
Bit
Subtraktion
Mathematik
Open Source
Formale Sprache
Güte der Anpassung
Entwurfsmuster
Zahlenbereich
Elektronische Publikation
Statistische Hypothese
Code
Whiteboard
Computeranimation
Metropolitan area network
Flächeninhalt
Programmbibliothek
Leistungsbewertung
Programmiergerät
Bit
Flächeninhalt
Datenparallelität
Kategorie <Mathematik>
Formale Sprache
Programmschema
Klasse <Mathematik>
Monoid
Physikalische Theorie
Computeranimation
Funktor
Effizienter Algorithmus
Paradoxon
Paradoxon
Code
Abstraktionsebene
Datentyp
Formale Sprache
NP-hartes Problem
Physikalisches System
Schlüsselverwaltung
Code
Computeranimation
Bit
Inferenz <Künstliche Intelligenz>
Leistungsbewertung
Compiler
Formale Sprache
Abgeschlossene Menge
Schreiben <Datenverarbeitung>
Extrempunkt
Code
Raum-Zeit
Computeranimation
Hydrostatik
Metropolitan area network
Flächentheorie
Fahne <Mathematik>
Datentyp
Byte-Code
Auswahlverfahren
Cluster <Rechnernetz>
Grundraum
Funktion <Mathematik>
Analysis
Softwaretest
Diskretes System
Rechenzeit
Physikalisches System
Elektronische Publikation
Modul
Hoax
Flächeninhalt
Rechter Winkel
Ganze Zahl
Hyperlink
Bitrate
Zeichenkette
Bit
Compiler
Formale Sprache
Versionsverwaltung
Iteration
Schreiben <Datenverarbeitung>
NP-hartes Problem
Kardinalzahl
Extrempunkt
Gesetz <Physik>
Computeranimation
Metropolitan area network
Poisson-Klammer
Arithmetischer Ausdruck
Algorithmus
Polygonzug
Code
Total <Mathematik>
Gerade
Softwaretest
Nichtlinearer Operator
Parametersystem
Dicke
Datentyp
Kategorie <Mathematik>
Ausnahmebehandlung
Elektronische Unterschrift
Systemaufruf
Konfiguration <Informatik>
Diskrete-Elemente-Methode
Menge
Ganze Zahl
Rechter Winkel
Zellularer Automat
Refactoring
Ordnung <Mathematik>
Software Engineering
Instantiierung
Zeichenkette
Fehlermeldung
Klasse <Mathematik>
Mathematisierung
Zahlenbereich
Physikalische Theorie
Code
Hydrostatik
Knotenmenge
Informationsmodellierung
Datentyp
Delisches Problem
Optimierung
Analysis
Erlang-Verteilung
Graph
Mailing-Liste
Ausgleichsrechnung
Menge
Data Dictionary
Quadratzahl
Rationale Zahl
Faktor <Algebra>
Mathematisierung
Gerade
Code
Menge
Computeranimation
Metropolitan area network
Mailing-Liste
Algorithmus
Datentyp
Kondition <Mathematik>
Attributierte Grammatik
Optimierung
Gerade
Attributierte Grammatik
Compiler
Formale Sprache
Extrempunkt
Code
Computeranimation
Task
Metropolitan area network
Code
Datentyp
Mustersprache
Programmbibliothek
Pi <Zahl>
Hilfesystem
Gerade
Modul
Softwaretest
Umwandlungsenthalpie
Interpretierer
Rechenzeit
Physikalisches System
Modul
Speicherbereichsnetzwerk
Verkettung <Informatik>
Flächeninhalt
Menge
Hyperlink
Ganze Zahl
Mereologie
Projektive Ebene
Funktionale Programmiersprache
Fehlermeldung
Standardabweichung
Offene Menge
Bit
Freeware
Gemeinsamer Speicher
Datenparallelität
Minimierung
Formale Sprache
Familie <Mathematik>
Oval
Abstraktionsebene
Synchronisierung
Computeranimation
Metropolitan area network
Typentheorie
Abstrakter Syntaxbaum
Hacker
Gerade
Inklusion <Mathematik>
Parametersystem
Abstraktionsebene
Güte der Anpassung
Systemaufruf
Teilbarkeit
Teilmenge
Menge
Ganze Zahl
Deklarative Programmiersprache
Restklasse
Ordnung <Mathematik>
Programmierumgebung
Zeichenkette
Algebraisches Modell
Subtraktion
Abstrakter Syntaxbaum
Klasse <Mathematik>
Mathematisierung
Code
Knotenmenge
Multiplikation
Mustervergleich
Konstante
Datentyp
Programmbibliothek
Thread
Datenstruktur
Softwareentwickler
Optimierung
Maßerweiterung
Leistungsbewertung
Mathematisierung
Mailing-Liste
Modul
Quick-Sort
Data Dictionary
Objekt <Kategorie>
Exergie
Funktionale Programmiersprache
Textbaustein
Informationssystem
Abstrakter Datentyp
Bit
Web Site
Abstrakter Syntaxbaum
Datenparallelität
Minimierung
Compiler
Formale Sprache
Zahlenbereich
Implementierung
Oval
Zählen
Code
Computeranimation
Formale Semantik
Data Mining
Metropolitan area network
Freeware
Knotenmenge
Code
Objektorientierte Programmiersprache
Konstante
Wrapper <Programmierung>
Datentyp
Programmbibliothek
Softwareentwickler
Parallele Schnittstelle
Chi-Quadrat-Verteilung
Leistung <Physik>
Primzahl
Abstraktionsebene
Machsches Prinzip
Systemaufruf
Rechenzeit
Datenfluss
Portscanner
Teilmenge
Diskrete-Elemente-Methode
Datenfeld
Mereologie
Schwimmkörper
Boolesche Algebra
Information
Funktionale Programmiersprache
Informationssystem
Objekt <Kategorie>
Netzwerktopologie
Bit
Datennetz
Programmbibliothek
Primitive <Informatik>
Rekursive Funktion
Maßerweiterung
Gerade
Code
Computeranimation
Analysis
Zentrische Streckung
Web Site
Diskretes System
Applet
Güte der Anpassung
Relativitätstheorie
Formale Sprache
Familie <Mathematik>
Entwurfsmuster
Physikalisches System
Ungerichteter Graph
Kommutator <Quantentheorie>
Computeranimation
Eins
Gegenbeispiel
Hydrostatik
Prozess <Informatik>
Datentyp
Korrelationsfunktion
Analysis
Trennungsaxiom
Soundverarbeitung
Softwaretest
Parametersystem
Suite <Programmpaket>
Punkt
Kategorie <Mathematik>
Formale Sprache
Rechenzeit
Mailing-Liste
Physikalisches System
Ein-Ausgabe
Code
Computeranimation
Ganze Zahl
Rechter Winkel
Trennschärfe <Statistik>
Mereologie
Datentyp
Programmbibliothek
Dateiformat
Wort <Informatik>
Information
Overhead <Kommunikationstechnik>
Funktionale Programmiersprache
Gerade
Leistung <Physik>
Fehlermeldung
Zeichenkette
Softwaretest
Parametersystem
Datenfeld
Datentyp
Mereologie
Visualisierung
Softwareentwickler
Optimierung
Biprodukt
Funktionale Programmiersprache
Kreisdiagramm
Computeranimation

Metadaten

Formale Metadaten

Titel What can python learn from Haskell?
Serientitel EuroPython 2014
Teil 29
Anzahl der Teile 120
Autor Ippolito, Bob
Lizenz CC-Namensnennung 3.0 Unported:
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.
DOI 10.5446/19950
Herausgeber EuroPython
Erscheinungsjahr 2014
Sprache Englisch
Produktionsort Berlin

Inhaltliche Metadaten

Fachgebiet Informatik
Abstract Bob Ippolito - What can python learn from Haskell? What can we learn from Erlang or Haskell for building reliable high concurrency services? Bob was involved in many Python projects but argues that for some domains there may be better methods found elsewhere. He started looking for alternatives back in 2006 when building high concurrency services at Mochi Media (originally with Twisted), which led him to the land of Erlang and later Haskell. Bob is going to talk about what he learned along the way. In particular, he’ll cover some techniques that are used in functional programming languages and how they can be used to solve problems in more performant, robust and/or concise ways than the standard practices in Python. He is also going to discuss some potential ways that the Python language and its library ecosystem could evolve accordingly.
Schlagwörter EuroPython Conference
EP 2014
EuroPython 2014

Ähnliche Filme

Loading...