What is a dynamic language? Whether or not a language is dynamic typically refers to the type of binding the compiler does: static or late binding. Static binding simply means that the method (or method hierarchy for virtual methods) is bound at compile time. There may be a virtual dispatch involved at runtime but the … Read more
Malbolge would be a good place to start. Every instruction is self-modifying, and it’s a lot of fun(*) to play with. (*) Disclaimer: May not actually be fun.
IoC provides a mechanism to break the coupling you get when an object calls ‘new’ on another class. This coupling ties the calling object with the instantiated implementation of whatever interface it implements. In static languages when you reference a class by name (to call new on it), there is no ambiguity. This is a … Read more
Ruby is slow. But what parts of it are the most problematic? It does “late lookup” for methods, to allow for flexibility. This slows it down quite a bit. It also has to remember variable names per context to allow for eval, so its frames and method calls are slower. Also it lacks a good … Read more
obj = type(‘obj’, (object,), {‘propertyName’ : ‘propertyValue’}) there are two kinds of type function uses.
I think the reason is that people are used to statically typed languages that have very limited and inexpressive type systems. These are languages like Java, C++, Pascal, etc. Instead of going in the direction of more expressive type systems and better type inference, (as in Haskell, for example, and even SQL to some extent), … Read more
Basically performSelector allows you to dynamically determine which selector to call a selector on the given object. In other words the selector need not be determined before runtime. Thus even though these are equivalent: [anObject aMethod]; [anObject performSelector:@selector(aMethod)]; The second form allows you to do this: SEL aSelector = findTheAppropriateSelectorForTheCurrentSituation(); [anObject performSelector: aSelector]; before you … Read more
The ability of the interpreter to deduce type and type conversions makes development time faster, but it also can provoke runtime failures which you just cannot get in a statically typed language where you catch them at compile time. But which one’s better (or even if that’s always true) is hotly discussed in the community … Read more
In a language implementing classical inheritance like Java, C# or C++ you start by creating a class–a blueprint for your objects–and then you can create new objects from that class or you can extend the class, defining a new class that augments the original class. In JavaScript you first create an object (there is no … Read more