dynamic-languages

I am recently thinking about writing self-modifying programs , I think it may be powerful and fun. So I am currently looking for a language that allows modifying a program's own code easily. I read about C# (as a way around) and the ability to compile and execute code in runtime, but that is too hurting. I am also thinking about assembly . It is easier there to change running code but it is not very powerful (very raw). Can you suggest a powerful language or feature that supports modifying code in runtime? Example That what I mean by modifying code in runtime: Start: a=10,b=20,c=0; label1: c=a

Ruby is slow at certain things. But what parts of it are the most problematic? How much does the garbage collector affect performance? I know I've had times when running the garbage collector alone took several seconds, especially when working with OpenGL libraries. I've used matrix math libraries with Ruby that were particularly slow. Is there an issue with how ruby implements basic math? Are there any dynamic features in Ruby that simply cannot be implemented efficiently? If so, how do other languages like Lua and Python solve these problems? Has there been recent work that has significantly

Are dynamic languages slower than static languages because, for example, the run-time has to check the type consistently? All other things being equal, usually, yes. No. Dynamic languages are not slower than static languages. In fact, it is impossible for any language, dynamic or not, to be slower than another language (or faster, for that matter), simply because a language is just a bunch of abstract mathematical rules. You cannot execute a bunch of abstract mathematical rules, therefore they cannot ever be slow(er) or fast(er). The statement that "dynamic languages are slower than static

I'm hoping that Ruby's message-passing infrastructure means there might be some clever trick for this. How do I determine the calling object -- which object called the method I'm currently in? As an option, there is a binding_of_caller gem that allows you to execute code in context of any caller on the call stack (caller, caller's caller and so on). It's useful for inspecting (read do anything at any position on the call stack ) call stack in development, as used in better_errors . Objects of class Binding encapsulate the execution context at some particular place in the code and retain this

Someone on the Herding Code podcast No. 68, http://herdingcode.com/herding-code-68-new-year-shenanigans/ , stated that IOC containers had no place with Python or Javascript, or words to that effect. I'm assuming this is conventional wisdom and that it applies to all dynamic languages. Why? What is it about dynamic languages that makes IOC containers unnecessary? Nigel Thorne 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

When I want to call a function in javascript with arguments supplied from elsewhere I can use the apply method of the function like: array = ["arg1", 5, "arg3"] ... someFunc.apply(null, array); but what if I need to call a constructor in a similar fashion? This does not seem to work: array = ["arg1", 5, "arg3"] ... someConstructor.apply({}, array); at least not as I am attempting: template = ['string1', string2, 'etc']; var resultTpl = Ext.XTemplate.apply({}, template); this does not work wither: Ext.XTemplate.prototype.constructor.apply({}, template); Any way to make that one work? (In this