Concurrency paradigm shift

Check this up - JAOO 2007. Channel9 interviewers highlight the fact that we might be facing paradigm shift. In their opinion hardware has not changed dramatically over past 20 years mainly adding processing speed and decreasing sizes...

This supported statically typed, imperative languages. Now, when the limits seemed to be touched, multicore technology is being rolled out, which will bring the revolution. The era of functional languages and dynamic typing seems to come upon us ;)

Here are the links to follow:

Bob Martin and Chad Fowler - Debating Static versus Dynamic Typing

Joe Armstrong - On Erlang, OO, Concurrency, Shared State and the Future, Part 1

AOO 2007: Joe Armstrong - On Erlang, OO, Concurrency, Shared State and the Future, Part 2

Erik Meijer and Dave Thomas - Objects, Functions, Virtual Machines, IDEs and Other Fun Stuff

PFX, PLINQ and TPL

You must take a look at the Programming in the Age of Concurrency by Anders Hejlsberg and Joe Duffy: Concurrent Programming with PFX posted on Channel 9...

It is great to see this natural, one would think, progression of lambdas into task managing, which no doubt will be simplifying concurrent implementations. Think mutexes, semaphores, critical sections, monitors, locks, threads etc. being hidden behind API simply accepting lambdas expressing your execution requirements. The same with workload control and optimization. This looks fantastic.

Here are some more links to Joe's articles, simply copied from his blog:

1. Parallel LINQ: Running Queries on Multi-Core Processors. An overview of an implementation of LINQ-to-Objects and -XML which automagically uses data parallelism internally to execute declarative language queries. It supports the full set of LINQ operators, and several ways of consuming output in parallel.
2. Parallel Performance: Optimize Managed Code for Multi-Core Machines. Describes the Task Parallel Library (TPL), a new "thread pool on steroids" with cancellation, waiting, and pool isolation support, among many other things. Uses dynamic work stealing techniques (see here and here) for superior scalability.

By being declarative and not over specifying, isn't functional approach way for the future?

PS. Have you tried F#, which just went into production?

Herb Sutter's Talks

There is a very good series of recorded talks, given to the folks at Googleplex on concurrency by Herb Sutter. Check them up to learn about the caveats of memory utilization, synchronization techniques and gotchas in multi-core environments, processor pipe-lining , locality of reference and the effects they have on performance of the software.

The first talk

• Things Your Programming Language Never Told You

• Concur and C++ Futures

How is your broadband performing?

It has taken ages, but finally got my broadband reconnected. So the first thing was to test its performance.



Unfortunately it is not performing as blazing fast as yours, Dave ;)

BTW: Ain't those Flex analytics implemented by the SpeedTest pretty?