Jon Udell has some thoughts up on dynamic languages:
The notion of custom-built "little languages" goes all the way back to Lisp and Smalltalk, as ultimately everything related to dynamic languages does. It's one of those deeply elegant principles that can take decades to unfold.
Interactivity is another. When I met with Jim Hugunin recently, he told me that when he shows IronPython to folks inside Microsoft, they're most impressed by his ability to wield .NET libraries in an exploratory way from the command line. Who would have thought that the read-eval-print loop would seem like breakthrough technology in 2005?
It's kind of amazing to see simple interactivity still blowing people away. I did a webex demo yesterday, where I spun up a workspace inside the BottomFeeder runtime and proceeded to demonstrate the idea of finding related content - by searching the live data and then slamming the results into the application - here's the code snippet:
| relations items feeds viewer| relations := Dictionary new. relations at: 'aggregator' put: #('rssbandit' 'rss bandit' 'bottomfeeder' 'newsgator' 'feeddemon' 'feed demon'). feeds := RSSFeedManager default getAllMyFeeds. zooms := Core.List new. feeds do: [:each | items := each allItems. items do: [:eachItem | relations keysAndValuesDo: [:key :values | | matchOrNil toMatch | toMatch := eachItem description. toMatch notNil ifTrue: [matchOrNil := values detect: [:eachValue | ('*', eachValue, '*') match: toMatch] ifNone: [nil]. matchOrNil notNil ifTrue: [| zoom | zoom := RSSZoomItem new. zoom feed: each. zoom item: eachItem. zooms add: zoom]]]]]. viewer := RSSFeedViewer getSingleInstance. viewer zoomFeedItemsView. viewer addColumn. viewer lastStateChange: #goToAllNew. viewer feedItemsList list: zooms
What that does is define a set of search terms, and then grab all the results together - nothing earth shaking. The part that surprised the demo audience was that I was doing it in a runtime - i.e., a delivered executable. Which leads me to this from Jon:
I do think that professional tools can help dynamic languages consolidate the ground they've been gaining. And to that end, conventional capabilities -- such as suport for testing, debugging, and version control -- will be prerequisites. But dynamic languages really are different in important ways, and their tools should be as well. It's time for some fresh thinking on this topic, and for some new approaches.
Well, the tools aren't only different - they are more flexible. Part of that is the simple fact that in Smalltalk, the environment is built in itself. That gives you a level of flexibility that Iron Python - which has to live within the closed strictures of the CLR - will never achieve. In Smalltalk, I can modify pretty much anything - sure, there's a wall at the VM level, but it's a fairly small one - all the interesting stuff is happening in the image.
This kind of silly putty flexibility gives you a lot of potential - have a look at this screen shot:
That's a browser, running inside the BottomFeeder runtime. I don't normally have source access there, so I'd see decompiled code if I selected a method. However, I could copy the sources for the component in question over and end up with a normal browsing environment if I wanted to.
This is what really separates the mainstream Java/C# stuff from a language like Smalltalk - and it also separates Smaltalk from things like Iron Python, which hae been pounded to fit into the CLR. There's very little separation between runtime and development time, and the developer can shrink that gap down to nothing if he so chooses. In anything JVM or CLR based, you'll always have that separation - always.