Brython, Python in the browser

I write lots of Javascript; mostly 'raw' Javascript in the webGL space. Here's just of the top of my head what's wrong with Javascript:

* looping over elements has too much boilerplate

* the mindfulnesss of 'this' is distracting

* the duality of dictionaries and lists and how that's an easy lie to fall for is fustrating

* that there are multiple frameworks trying to use $

On the other hand, their anonymous functions are very nice. And, I rather like prototypes vs classes. A bit. Sometimes

With Python, I like significant whitespace (so sue me) and especially the syntax for collections and packing/unpacking them.

I've blogged along these lines a lot in the past e.g. http://williamedwardscoder.tumblr.com/post/18319031919/progr...

By this I refer to that in Python, most syntactic constructs map to more primitive operations that are accessible (and overridable) in the language itself. For example, anything can be made callable, indexable, sliceable, iterable, etc., by providing the right interface. It is like operator overloading on steroids. Even attribute access (the dot operator) can be overridden in extremely powerful ways. This is great for library writers, who can use it to provide the simplest possible API to their users.

I also like very much Python's data model. Things consistently behave as references (even primitive values which all behave as immutable singletons, although of course they are not implemented as such). It just somehow fits and makes sense once you have the model in your mind. JavaScript is slightly less intuitive in this way, and while it makes sense once you understand it, there are a few caveats you need to keep in mind (variable hoisting, scoping, anticipating different context objects). Prototype inheritance works fine but requires a special mind-set, and to me it seems JS fits better for functional programming than object-oriented Java-style.

Python's shortcomings are mainly syntactical (not counting the shortcomings of CPython's implementation specifically), such as not having an easy syntax for function expressions. This is the main reason functional programming can get slightly awkward in Python.

To be honest I'm not intimate enough with JS to give a big list of my biggest language-level annoyances off the top of my head. It's just a general distaste/annoyance that occurs every time I get involved in JavaScript code, either the reading or the writing of it. Python, on the other hand, is nearly readable by non-programmers, and is otherwise super cool. I recognize that others may have a different opinion on this than I have and while they're not necessarily wrong for themselves, I believe Python is more accessible in general.

I think the facts that a) almost no one writes bare in-browser JavaScript anymore, it's all through jQuery and b) CoffeeScript and other persistent "rewrite/simplify/improve JS" movements exist and keep coming up are ample evidence that the basic tools provided by the browser and the JS language are insufficient.

Where do you get this? The only instance where I see Python becoming unreadable due to whitespace is when a developer abuses whitespace where it's not needed e.g. a = [ 'a', 'list' ]

Another example could be chaining method calls Java-style, but all of this is alleviated by just following PEP8.

The significance of whitespace has no effect on the readability of a language.

You can't make such a statement confidently unless you examine the specs of both languages.

For example, Python integers promote to bigints automatically while JS numbers don't. For one more, in Python you can overload attribute access, while in JS you can't. Both of these are language features rather than implementation details, and both potentially affect performance. There are probably others.

I personally would choose any other modern language over javascript.

ANY.

I've learnt it and used it 8 or 9 years now, to me it just sucks. And still no-one knows how to write it well, no-one agrees how to structure it and every 2 years there is a whole new way to write javascript that comes out. I'm beginning to suspect it's because there is no good way to write it.

btw: it's not a decorator :) but a camelCase->under_score renamer it's pretty easy to write

    import re
    
    def unCamel(obj, *maybe_camels):
        if not maybe_camels:
            maybe_camels = filter(lambda n: not n.startswith('_'), dir(obj))
    
        for maybe_camel in maybe_camels:
            underscore = re.sub(r'([^A-Z])([A-Z])([^A-Z])',
                lambda m: '%c_%c%c' % (m.group(1), m.group(2).lower(), m.group(3)),
                maybe_camel)
            if underscore != maybe_camel:
                setattr(obj, underscore, getattr(obj, maybe_camel))
    
    if __name__ == '__main__':
        class CamelCase(object):
            def multiWordMethod(self):
                print('called multiWordMethod')
        
        def multiWordFunction():
            print('called multiWordFunction')
    
        unCamel(CamelCase)    # magic
        import sys
        unCamel(sys.modules[__name__], 'multiWordFunction')    # magic
    
        CamelCase().multi_word_method()
        multi_word_function()

threading.Thread would seem to be consistent with the Google Python Style Guide (threading = module, Thread = Class)

http://google-styleguide.googlecode.com/svn/trunk/pyguide.ht...