Monthly Archives: January 2014


Go To, Typing, Inheritance etc

Go To There And Back Again. Watched this yesterday, and it was a really good talk on Dynamic Typing, Class Free programming languages like Javascript from a historical perspective. After this I feel like the progress is going too slow, not too fast!


JS Wizardry

Saw this video today. The nerdiest, coolest and most mindblowing thing iv seen in a long time!

Some links from the talk:

His collection of 1k JS stuff, including the titris:

P01, alot of really cool JS stuff:

The Matraka intro, with sound and all:

Write all JS with 6 characters:



The Zen of Python

Pretty funny.

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren’t special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one– and preferably only one –obvious way to do it.
Although that way may not be obvious at first unless you’re Dutch.
Now is better than never.
Although never is often better than right now.
If the implementation is hard to explain, it’s a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea — let’s do more of those!

Interesting stuff about Duck Typing

The discussion started with Eric Lippert, the Microsoft Guru’s post about Duck Typing

And here it gets REALLY interesting:

.. So today I learned some about the term “Structural Typing”, and that some languages have taken Duck Typing further!

This piece of Scala code points to something iv been looking for for a long time!

def executeRule(rule: {def execute(): Unit}) =  {