Four Python Pains

1,070 views

Published on

This talk was actually given in 2012 due to the cancellation of the original workshop.

Published in: Technology, Education
2 Comments
0 Likes
Statistics
Notes
  • Be the first to like this

No Downloads
Views
Total views
1,070
On SlideShare
0
From Embeds
0
Number of Embeds
9
Actions
Shares
0
Downloads
18
Comments
2
Likes
0
Embeds 0
No embeds

No notes for slide
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • Four Python Pains

    1. 1. Four Python Pains Stefane FermigierScripting Languages Workshop, IRILL, May 2011
    2. 2. Part1: Some context
    3. 3. Wrong(on several points)
    4. 4. Python (“Scripting Language”)• Has built-in syntactical support for arbitrarily complex data structures (lists, dictionaries)• Supports significantly complex applications: ERP5, Plone, Nuxeo CPS (~320 KLOC), OpenERP (~150 KLOC), Komodo (~250 KLOC)• Is compiled (to bytecode)
    5. 5. Scala (“Sys. Prog. Language”)• Is interpreted (it as a REPL)• Is a high-level language - in other words, has a high CPU instructions / statement ratio (comparable or higher than Python)
    6. 6. Other counterexamples• Java, pre-generics (Java SE < 5, i.e. at the time of Ousterhout’s paper), had really weak support for static typing• Clojure (that many consider in the same league as Scala) is not even statically typed
    7. 7. At which expense?
    8. 8. • Execution speed?• Safety?• Maintainability?• What else?
    9. 9. Or maybe Python is ascripting language after all ?
    10. 10. Uses of Python• Education• Small to medium sized sysadmin and software engineering project• Medium to large web frameworks (Zope, Django...) and applications (Youtube...)• Scientific computing (numpy, scipy...)• Scripting of games, desktop apps, etc.
    11. 11. Recap: 4 pain points• Speed• Scalability• Type-safety• Adherence to external code bases, and an implementation (CPython)
    12. 12. Part 2: Discussion
    13. 13. Speed• Python (seems to be) slower by 10x than Clojure and V8 (JavaScript)• Both Clojure and JavaScript are dynamically typed languages• TODO: look at Clojure and V8 and see how they do it
    14. 14. Scalability• CPython multi-threading / multi-core performance is constrained by “the GIL” (global interpretor lock)• It doesn’t have to be there (Jython doesn’t have one) but removing it from Python is controversial• Python has support for some par prog constructs (see: http://wiki.python.org/moin/ ParallelProcessing) but not the fancy new ones (a la Scala, Clojure, Go, etc.)
    15. 15. Type Safety• Static typic is good to create safer programs, and also to ease refactoring (necessary condition for agility)• Since Python 3, type annotations are possible on variables, parameters, etc.• Some tools (e.g. Jetbrains’ PyCharm) have support for type inference on Python, and enable: code completion, errors detections, refactoring...
    16. 16. Adherence to CPython• There are at least 4 major Python implementations: CPython, Jython, IronPython and PyPy• But only CPython is mainstream• Why? Because all the “system programming lang” extensions written for CPython cannot be used with the others• And we’re talking about hundreds of packages
    17. 17. Solution?• There are also tools, languages and extensions that ease up the task of writing a CPython extension: SWIG, ctypes, Pyrex, Cython...• By encapsulating part of the complexity and low-level details of creating a Python extension, it could make is both easier, more robust and easier to share extensions between language implementations
    18. 18. Conclusion
    19. 19. • Python could maybe be made 10x faster by applying ideas from Clojure and V8• Python could be made more scalable by removing the GIL (probably needs to rewrite the interpreter, though) and adding modern parallel programming paradigms
    20. 20. • Python programs could be made more robust with the help of static typing analysis tools + a little help from the developers (i.e. add a few type annotations in their programs and libraries)• Python is a scripting language after all (but not only), and could benefit from a way of writing extensions that is higher level than the common one (but then: how to convert the existing code base?)

    ×