Saturday, January 29, 2011

Marc on Hudson/Jenkins

I haven't been tracking the Hudson/Jenkins issue in depth, but from what I do know I have to agree with Marc. Community is critical to the success of an open source project, and if your licence allows a fork of the code then it's also possible to fork the community too. Even if forking the code isn't possible, if you don't embrace, support and nurture your communities then they'll either go elsewhere or start a competitive effort themselves. This may sound strange, but this is one of the things that I love about working in open source: it's not just about having the best technology; you need to have the best communities too.

HPTS 2011

Anyone who knows me probably knows how much I love the High Performance Transaction Systems workshops that Jim created and mentored for years. I've been going to it for many years and have been on the program committee for the past few. Well I'm pleased to say that we've just announced the Call for Papers for the event this year. If the past workshops are anything to go by then it'll be a great workshop and I'm really looking forward to October!

Sunday, January 23, 2011

Beanstalk and PaaS?

I didn't get a chance to write up everything I've got to say about the Amazon Beanstalk announcement, particularly as it applies to JBoss. I agree with some of what Sacha and the CloudBees team have to say: it's a good step for Java, but I also think it's pretty obvious that this would happen. I'm not sure if this is an "I told you so" moment.

However, once again I have to say that I agree with Paul on his assessment: it's not quite a PaaS ... yet. It seems that others agree, though not everyone is so sure. I'm sure we will see (have to see) further improvements to what is being offered, but as things stand, this doesn't fit my definition of PaaS. But this is a fast moving arena at the moment, so I wouldn't be surprised to see things change in the future, particularly as the competition starts to heat up.

Steve on public vs private Cloud

Steve Jones makes some very similar points to my earlier posting on data and its role in the public versus private cloud debate. Definitely worth checking out.

Thursday, January 13, 2011

Edsac being rebuilt

Wonderful news. Guess I'll be making a trip once it's completed then!

Wednesday, January 12, 2011

Sunday, January 09, 2011

IO, objects and messages

I mentioned that one of my Christmas projects involved playing around with the IO programming language. I took it a little further than I'd planned originally and started to look at integrating transactions with it (in the form of the C++ version of Arjuna). I got to know the language pretty well, despite the poor documentation which often caused more delays and hair pulling.

One of the things I realised about half way through was that I really like IO because it has a lot in common with Smalltalk: everything is an object and methods are invoked via the exchange of messages. In some ways it made me realise how much I miss programming with Smalltalk, though that's not to suggest that I preferred one language over the other; it's been a few years since I really used Smalltalk so I'd have to refresh that knowledge to make a qualified judgement.

IO also reminded me that while I love C++ and probably still like it above others, as an object-oriented language it has a number of quirks that don't make it, or similar languages, ideal for beginners learning the ins and outs of OO. One of the things I miss, which was part of the original Smalltalk implementation and Simula, though removed from Smalltalk-80, is the concept of message passing to interact with objects. I always found this concept more natural when thinking about object orientation.

It's probably one of the reasons I took to distributed systems: in the early days of Arjuna, when C++ was chosen as the implementation language over Concurrent Euclid and others, we (mainly Graham) spent a lot of time on making C++ (opaquely) distributed (trailblazing this at the time). Obviously what we ended up with was a system where C++ objects interacted via messages! Since the work Graham did also supported multiple inheritance as well as overloading, it went much further than simply distributing an object's implementation.

Looking back at that period now, I could imagine doing something with that work to move a non-distributed C++ language varient in the direction of message passing, but that would probably have been pointless. C++ is good for what it was aimed at. But I think it, and similar languages such as Java, may not necessarily be the right basis from which to learn initially about object orientation (I still long for multiple inheritance and operator overloading in Java!) I believe that programmers should always have a broad knowledge of languages under their belts and I'm glad I came at C++ through the likes of Simula, Smalltalk, Lisp, Fortran and Forth, to name just a few. Some of them have little to say about object orientation, but I'm sure that all of them have influenced the way in which I think about and approach problems, no matter what the implementation language.

So back to IO. It may have a small following compared to the mainstream languages and it may suffer from poorer documentation than most, but if you've used Smalltalk or thought about learning it, then I'd recommend looking at IO as well. It's not perfect (which language is?) but I'm sure you'll learn something, or perhaps it'll refresh your memories about other languages as it did for me. The result may well be that you chane the way in which you think about object orientation or at least the way you use your favourite language today.