Python’s dark corners. Covering 2.x with a few tips on 3; things to avoid, etc. Python is a fantastic language but it’s not perfect and there are a few dark corners which need to be worked around.
Python is a deceptively simple language: the surface simplicity hides a deal of complexity.
Reference to the algorithmic trading incident.
Python really is object oriented. This has a few more implications: “modules” and functions are first-class.
Python uses references by default. Use is for reference equality, not ==.
Some types (int, tuple, etc) are immutable.
Rebinding is sometimes an accident. When of a built-in, it’s often
catastrophic. Use __builtin__ to get these things back.
Pass by reference is the default (and only option). The only pass by value is
to copy it. Lots of options for lists (slice [:]), the copy module.
No ++ or -- operators. “Mutating” operators are designed so as not to be
mutating: +=, etc. rather than ++.
If you’re checking types, you’re doing it wrong. “Duck typing”. #sigh
Floating point arithmetic is floating point arithmetic.
Immutable, but only the tuple itself (i.e. the references it contains, not their referents).
Support both ordinal and keyword parameters.
Default values. Default values are created at load time, so should probably be immutable.
Scoping: scoping of variables is based on use within the scope, not dynamic.
Visibility of globals. Better to just avoid variables in global scope.
]]>I’m still puzzling through the examples, but it looks pretty cool. The essential idea is to use the type system (an extension of System F with references and ownership called System Fown) to ensure that the internal details of modules cannot be messed with.
They give an illustrative example involving customers in one domain, banking machinery in a second and account details in a third. The customers are allowed to call the banking machinery, and the banking machinery can access the account details, and all other access is invalid. The goal of System Fown is to prove these sorts of properties.
]]>While MapReduce and GFS allow Google to use their massive computer clusters effectively, the use of C++ can make programming for such a systems more difficult than it needs to be. Cue Sawzall, a new language that Google use to write distributed, parallel data-processing programs for use on their clusters. While the language isn’t particularly attractive (I’ve never liked C-style syntax’s), the approach is very interesting and the implementation issues they describe are enlightening.
]]>After a bit of um-ing and ah-ing, I finally settled on Benjamin Pierce’s Types and Programming Languages, Peter Seibel’s Practical Common Lisp and Concepts, Techniques and Models of Computer Programming by Peter Van Roy and Seif Haridi.
That’s a bit of $300-worth of books, so I hope to get around to reading them at some point between when they arrive (somewhere between a week and a month away, I imagine) and the end of the year.
Suggestions of other books suitable for beginners in the areas of type systems, programming language theory, and related fields are most welcome in the comments.
]]>