Episode 49: Dynamic Languages for Static Minds

Filed in Episodes by on March 18, 2007 1 Comment

Recording Venue: OOPSLA 2006
Guest(s): Niclas Nilsson
Host(s): Markus
In this Episode we talk about dynamic languages for statically-typed minds, or in other words: which are the interesting features people should learn when they go from a langauge such as Java or C# to a language like Python or Ruby. We used Ruby as the concrete example language.

We started the discussion about important features with the concept of dynamically changing an object’s type and the idea of message passing. We then looked at the concepts of blocks and closures. Next in line is a discussion about functions that create functions as well as currying. This lead into a quick discussion about continuations. Open classes, aliasing and the relationship to AOP was next on our agenda.

We then looked considered a somewhat more engineering-oriented view and looked at the importance of testing and what are the best steps of getting from static programming to dynamic programming. Finally, we discussed a bit about the current (as of October 2006) state of dynamic languages on mainstream platforms.

Links:

Tags: , , , , , ,

Comments (1)

Trackback URL | Comments RSS Feed

  1. supermule says:

    This comment was a mistake. Please just delete it.

    Hi,

    First of all, thank you for a great show. I recently discovered you show and I am listening though your series of podcasts. However, I discovered a small error in this podcast.

    In the episode you mention currying and explain what it is. However, it seems to me that it is not currying you are explaining, but partial application. Currying means turning this function:


    f :: (X, Y) -> Z /* Z is the result of applying the function */

    into


    g :: X -> (Y -> Z)

    that is f takes two arguments X and Y. Currying then turns f into g. The function g takes one argument and returns another function from Y -> Z.

    The two terms are related though. You cannot do partial application to f (above). However, by currying it becomes possible.

    Also see currying on wikipedia http://en.wikipedia.org/wiki/Currying . If you speak Haskell you can also look at Haskell’s definition of curry http://haskell.org/ghc/docs/latest/html/libraries/base/src/Data-Tuple.html#curry .

    Greetings and keep up the good work,

    Mads Lindstrøm

Leave a Reply

Your email address will not be published. Required fields are marked *


*