Just came back from the very interesting talk (which seems to be obliged with its taking place to twitter and to AgileHolland community) by Robert Martin.

The announced topic was "next programming languages", but the discussion was more broader than that. It was not a specially prepared event, which was just right.

For me, the most noticeable moments were (in no particular order):

- Brief introduction to Ruby and Clojure. What a pity I've not been involved with Ruby earlier! Seems like fun. Clojure - at first glimpse, not sure if it's the language for biological humans but who knows... it does seem to be very concise, but the code with minimal syntax is far from being easily understood. Well, may be, those who did program in List think otherwise. I didn't. Wouldn't mind to give it a try though!

- More about Ruby: the absense of interfaces, or rather, the interfaces reduced to the logical end: every separate function is an interface. Have to think about it. From one side, it seems to be logical. From another side, my feeling is that in this case, you definitely need other methods (like TDD) to ensure you are not getting an unexpected mess, if some object you use does have the method you want to call, but it's not what you think of it!

- The discussion about Scala which followed afterwards. Everybody present appeared to be very interested! Great that Scala seems to be "in the spot". May be transition from Java to Scala might occur in the same way as the transition from C to C++ occured? Again, who knows?.. The key question in relation to this statement was: "What is that little difference in Scala in comparison to Java which would make it like C++ was to C?"  (For me, the biggest similarity is really in the possibility to more or less painlessly switch from Java to Scala, without the need to immediately introduce big changes... and the little difference is "functionality" - the same way as "object orientation" was in C++).

- Seeing somebody at hand distance who can quote the number PI up to 200 digits after decimal point...

Also, the audience (which consisted of an intersection between the Dutch twitter community and the members of Agile Holland) was very enthusiastic and helpful, otherwise the discussion would not be that interesting.

By the way, what would be the next next step? If the functional languages, as it was also mentioned tonight, are on the raise because of the need to handle concurrency properly, what could happen if - for now still very mystical - quantum computation would prove to be a reality after all? Or will it be considered just a very specific type of concurrency? Will assembly still have a chance then? ;)

Last but not least: recommended reading: the book "Structure and Interpretation of Computer Programs" (available online here). "This book will explain, why assignments are bad and why concurrency is a disaster, and how we still can handle concurrency if we get rid of assignments", - according to our guest:)

Now, that's it.