Parallelism can be Groovy - A Session for the BCS Advanced Programming

I had a plan for this session, let us call it Plan A. It involved a structured mix of material involving lots of demonstration of using Groovy, Java and GPars (possibly also some Scala) as well as Python and C++, C and Fortran. Plan A had to be trashed when, in trying out all the demonstrations a couple of days ago, I discovered that the quad-core laptop I had purchased wasn't quad core, it was a dual-core processor pretending to Linux to be quad core. Moral of story: be very careful when you buy a Core i7 machine as to exactly which version of the processor you are being sold.

Cue Plan B. Plan B involved using the quasi-quad core laptop locally, but doing most of the demonstrations on a twin Xeon (effectively 8 core as two 4 cores). This required Internet connectivity. About 12:49 on the day of the talk my ADSL connection started player "silly beggars" and then around 15:13 it failed completely. No access to the 8-core machine from the big wide world. Plan B trashed.

Enter Plan C - hastily put together in the hour prior to leaving to give the presentation - put more emphasis on the issues of hardware architectures, application parallelism, operating system involvement, and the consequences of the Multicore Revolution. A PDF file of the slides for this, which were the ones used in the end, can be found here. However, they are probably only useful if you were at the session!

The presentation was designed for a 1280x800 screen (the size of the laptop), but because the projector couldn't do that resolution, it ended up being shown at 1024x768 which made all the fonts and diagrams come out weirdly. This annoyed me, but members of the audience were happy that the material was still readable. No real change of plan needed then.

The session started, and I didn't go fast enough through the early material. Add to this various questions from the audience, and we started going in directions not in Plan C. Enter Plan D. Or should that be Plan Dynamic - the No Plan. Interactions with the audience evolved the session into something rather different to that which I had anticipated. Nonetheless, when asked, the audience were happy with what was happening. Indeed asked for more.

In the end the session lasted about 175% longer than a usual session, had covered about 55% of what I wanted and had planned to cover, had involved a whole lot of material I hadn't actually planned to cover, didn't do anything like enough in demonstrations, and wasn't at all structured. The end result was a session that was more of a scatter gun firing of issues and questions surrounding programming and applications in the post-multicore period. I did though get across the point that the future is most certainly going to be multi-lingual and that Python/C++ and Java/Groovy will be at the forefront of the drive.

After the session, many people came and said that they had really enjoyed the session even though it had been longer than anticipated and somewhat less structured that one would normally have liked. So all in all Plan Dynamic seems to have resulted in a successful session. It just wasn't the session original advertised.

Copyright © 2005–2020 Russel Winder - Creative Commons License BY-NC-ND 4.0