In what seems like a normal day at the trough for large companies and their patent lawyers, Oracle America (née Sun Microsystems, now a subsidiary of Oracle) has issued a lawsuit against Google for violation of seven patents and some copyrights (PDFs of the complaint document are available in many places on the Web). At its core, the fight is over Google's Dalvik virtual machine used in Android.

Whilst Dalvik implements the Java Virtual Machine (JVM), it is not a licenced product, it is a “clean room” implementation. Of course, clean room is not a defence against patents, if you use something on which there is a patent, you are liable to pay royalties to the patent holder, even if you didn't know about the patent. Oracle, via its purchase of Sun, now owns patents it thinks applies, and it wants to collect.

Somewhat predictably, the initial knee-jerk reaction of large swathes of the JVM using community on the various mailing lists is one of being up in arms against Oracle, complaining that Oracle are attacking Java, and that this is the beginning of the end for Java. Later on in the various threads, the voices of reason begin to appear. But this article is not about whether Oracle is trying to cause the demise of Java and the Java community, that is really rather unlikely given the importance of Java middleware to Oracle's core income stream. This article is about the instruments being used in this case.

Oracle has purchased a collection of patents, many of them software patents, as part of its purchase of Sun. Many of these patents relate to techniques used in the Sun implementation of the JVM, pure software patents. Patent documents, at least in the USA, often start “A method and apparatus to . . .”, the interesting (!) thing about all software patents is there is no apparatus, there is just a method realized as an algorithm encoded in source code. It is a pity that patents do not get rejected for lying when using the standard language.

I have skimmed over the PDFs of six of the seven patents that are the focus of this case (6,125,447; 6,192,476; 5,966,702; 7,426,720; RE38,104; 6,910,205; and 6,061,520), and it seems clear that these are all pure software patents revolving around various techniques used in the JVM, but which are actually so broad that they are techniques used in many other varieties of virtual machine. So this case could be seen as the beginning of a programme to extract royalties from any and all purveyors of virtual machines.

In the end, Oracle have purchased a company with assets and they are trying to create a return on investment from those assets. Natural business activity. The problem is the nature of some of those assets, and in particular software patents. Moreover it isn't just the seven patents listed in this case. Each of those seven make reference to many other patents of similar type, all part of the portfolio. There is therefore a whole pool of patents in play here, and the “long play” may well be to validate all of these patents in court so that they can then be used as mechanisms for extracting more royalty revenues from more companies, and in the end create an effective monopoly on the whole concept of a virtual machine.

Thus one could imagine that Microsoft with its CLR, IBM's implementation of the JVM, possibly VMWare, Parallels, all hypervisors and virtual machines are being lined up. Could they perhaps even go after the Python, Ruby and Perl virtual machines as well? Here lies the seeds of paranoia, but it indicates how dangerous a legally validated software patent might be, at least in the jurisdiction of that patent. Here we see another indication of why the UK and EU must not allow these sorts of patent. They destroy competition and innovation.

From a strategy perspective, it is interesting that Oracle have targeted a big player first, rather than starting with a small player, as is usual in these quasi-extortion rackets. Little players often have to fold for lack of resource, so there is a build up of apparent validity to the patent caused by wining cases, albeit out of court. The problem though is no actual case law has been created, so there is still the risk that when you finally start with the big players, you have to go the full distance anyway, having already paid out a lot to deal with the small fry. Perhaps then the strategy here is to have the big game first, go the whole distance to a judgement, and by doing so immediately create case law. All other players, big or little, then have to fall in line; it is then a simple sweeping up operation, money for old rope.

Over the next few weeks there will be a lot of mud thrown at Oracle, much of it unreasonable, some of it reasonable. Google will try and appear like the FOSS (free and open source software) world's white night, when in fact they are just as grey a player as any other big company (after all they tried to leverage the JVM without paying their dues). The real culprit here is the USA patent system and its penchant for issuing software patents willy-nilly, and indeed at all. Patents are tools for big players to stifle little players, and as noted above competition and innovation. Any pretence that patents are tools for the little guy to get remuneration from their ideas has surely been seen through long ago.

There is though another count in the lawsuit which is potentially far more important in many ways than the software patents ones, and that is the breach of copyright claim (Count VIII). Currently it is not totally clear from the documents available what the claim really is. There are issues of timing and exact claim that introduce uncertainty. One interpretation is that Google simply reused in Dalvik Sun JVM code from a time prior to that code being released as open source under the GPL licence, even though they were claiming Dalvik to be a clean-room implementation. If so this would seem to be a straightforward violation of Sun's copyrights. Another interpretation is that Google have relicenced GPL licenced code under the ASL licence without permission – the ASL is a more permissive open source licence than the GPL, and in order to relicence GPL code under ASL you have to have the permission of the copyright holder. Under this interpretation Oracle is the white knight and Google the enemy of FOSS. This is so against all (prejudiced?) expectation that it is immediate to doubt this is the case, yet it might be. If it turns out that this is, in fact, the case then everyone currently saying Oracle are no longer to be trusted as the owners of Java and the JVM, may have to reassess their position. On the other hand this is all speculation until more details are available: Paragraphs 37 to 46 of the complaint document are not specific enough to do anything other than speculate on the actual claim.

This case is going to be one to watch. Hopefully Groklaw will take this one up. There is The Oracle-Google Mess: A Question - Are Any of the Patents Tied to a Specific Machine?, so possibly yes.

In breaking news: Oracle have jumped into the Evil Empires League straight at number 3, forcing Dell, The EU Patent Office, The USA Patent System, Amazon, and even Google, down one place. We conclude that there may be a direct relationship between position in the table and the extent to which bully boy tactics and the patent system is used to extort monies.

[10:41] (0 Comments)

In a comment to my posting “Python Adapts to the Multicore Era”, Sam Aaron asked about the arguably contradictory position of mentioning Clojure when arguing for a processes and channels model for Python. He also raised the question of the future of Python's GIL in a world dominated by parallelism. I thought I would respond with a full posting rather than just a comment.

Clojure emphasizes the use of software transactional memory (STM), threads and agents as tools for handling concurrency and parallelism rather than processes and channels – as is used in Scala, Go, Python-CSP, PyCSP, and GPars; which variously use CSP (Communicating Sequential Processes) or the Actor Model. For me STM is really a bit of “sticking plaster” to make sure that shared-memory multi-threading is more viable than it is using explicit locks, monitors and semaphores. However, others think STM has a promising future.

In surveying the field of STM you may come across implementations that talk of storing values in databases. These are not implementations of STM, they are implementations of persistent data storage, which is something very different. Databases generally have transactional state and the abstract concept of transaction is the same as STM, but the realization is something very different – or should be.

The real questions that drive thinking about STM and threads vs. processes and channels are:

1. Which computational model best allows programmers to express the parallelism in their application.
2. Which computational model provides the smaller translation distance between expression of the application in code and the execution model of the machine executing the application.

So which is best: STM and threads or processes and channels.

As stated so baldly, the question is probably answered by “choose whichever suits you”; there really isn't any other answer to such a general question with no context. We need to restrict the context so as to be comparing things a little better.

Clojure operates on the JVM which promotes threads and a single global virtual machine viewpoint. The best comparison then is with Scala (and Akka) and GPars – which supports Groovy-based actors and CSP. Also there are STM implementations for Java and Scala which would help comparison. To be honest though, no amount of philosophizing is going to result in any truly useful indicators. Data is what is needed. So there need to be experiments implementing a number of different problems using this set of languages and libraries, and then the following questions need addressing: which programs are the easiest to write; which programs the easiest to comprehend for the author and for people other than the author; and which programs are the most efficient and speedy of execution. I have not yet done such experiments, and am unlikely to as I do not have the resources just now. Of course there is the question of whether Clojure is the version of Lisp that will finally allow Lisp to really make the big time; or will Clojure slide into relative obscurity as all other Lisps have. Lisp has the property of being the most fundamentally unique approach to programming language whilst at the same time never really catching on. This should not of course affect the core “which of STM and threads vs. processes and channels is better for parallelism” debate.

What about natively? Well there is Go which supports processes and channels, animated with its goroutines; there is C++0x with threads, futures and asynchronous function calls; there is Haskell, which supports STM. The problem is, of course, that Haskell has a totally different computational model to Go and C++, so would it be a valid comparison? In a sense yes since Haskell is claiming to compete against C, C++, etc. So probably worth doing. Of course there are STM implementations for C++ and even C – Intel have a C++ STM system but it remains an experimental not production feature of the Intel compiler – so that should be added to the mix. Of course the same argument about data and experimentation applies here: no experimentation, no data, no conclusions just unsubstantiated opinions.

What about Python? Well here there is the GIL (global interpreter lock), at least for the standard CPython implementation. This means that a single PVM (Python Virtual Machine) can be executing only a single thread of Python code at any one time. Thus, no immediate potential for parallelism. There are two solutions to this, write things as extensions in C++ or C so that the GIL can be released by a thread, or use multiple PVMs. Using C ++ and C extensions is not a generally viable approach to parallelism in Python. It has its rightful place and is incredibly useful in that place, but it is not where most Python code is. So Python effectively mandates a process and channel approach to parallelism. Hence the multiprocessing package in the standard (post 2.6, but there are backports to 2.5 and 2.6) Python distribution or Parallel Python. This means that Python naturally gravitates towards CSP and the Actor Model for concurrency to the effective exclusion of STM. So if the GIL is to remain in CPython, multiple PVMs, processes, message passing, etc. are the way of structuring Python applications. This means CSP and actors will be core to the future of Python in the increasingly multicore, and hence parallel, world.

The real upshot of this posting is that there needs to be some experimentation organized to move things away from pure argumentation and creating results by arguing loudest and longest. The STM and threads vs. processes and channels debate needs some work done not just arguments made. Except with Python where, whilst the GIL is present, STM doesn't really have much of a place.

[09:46] (0 Comments)

This posting is an evolution of an email I posted in reply to a posting by Andrei Alexandrescu on the golang-nuts mailing list.

I have liked the D programming for a long while. It seems like a really nice evolution of many ideas that have evolved in C++ but without as much baggage. However, until there is a stable 64-bit v2.0, with AMD64 installers, alongside the 386 v2.0, it is not really a viable language in the modern age of a mixed 64-bit and 32-bit economy.

I really like the Go programming language because, via its goroutines and channels, it harnesses the process/channels model of computation which I think is the future of programming in the modern, multicore era. I have been a fan of CSP (Communicating Sequential Processes), and Actor Model, for over 25 years because it brings a structure to programming concurrent systems. Also Go brings to a statically compiled, native target language some reflection capabilities.

The Actor Model is getting a lot of promotion these days via Erlang and Scala (and the add-on library Akka). Software transactional memory (STM) is getting a lot of promotion via Haskell and Clojure. occam lives on as occam-pi in KRoC and JCSP (on which we have constructed GroovyCSP -- part of GPars a Groovy library for handling concurrency and parallelism), CSP is even getting airtime in Python (via PythonCSP and PyCSP). The overall goal here, which to a great extent strikes me as the goal of Go's goroutines and channels, is to commoditize processor and turn it into a resource that is managed by the run-time system just as memory is. Applications should not have to worry about multicore directly just about the abstract, algorithmic expression of parallelism in their application – though they do have to worry about communications distance between processors so as to avoid inappropriate assumptions about communications time and safety. This leads to having to manage locality and communications distance. As yet none of the CSP and Actor Model systems handle this properly, though there is good work happening in local and remote actors.

The problem for me with Go and D is that both languages give all the appearance of being backward looking – though this may just be conditioned by worrying about Posix compliance. The lowest level of libraries have all the naming and parameter feel of 1980s C.

For me there are two questions that should be driving programming languages:

1. What is the language for writing the next big operating system?
2. Do PGAS languages have the edge for writing applications in the future?

Linux and Mach, like Windows, are now really in “maintenance mode” their architectures and fundamental capabilities are fixed and unchangeable. Future hardware architectures show all the signs of heading directly towards multiple, heterogeneous, multicore, NUMA (non-uniform memory architecture) architectures with bus-level clustering, local clustering and wide-area clustering (if not more levels of communications) and operating systems and programming languages are not really ready to handle this. Languages like Chapel, X10, even Fortress are doing lots of interesting research in PGAS (partitioned global address space) but because they market themselves in the HPC (high performance computing) arena, they don't get taken as seriously as they should by a wider audience of programmers. Certainly though they are neither ready, nor possible never appropriate, for the leap of being languages with which to write operating systems.

So the question really is whether D and Go are just interesting sidelines in the interregnum between the era of network-connected uniprocessors and that of massively parallel, multi-level architecture systems. Or can one of them be the systems programming language of the next era of computing?

Go and its goroutines handle bus-level multicore processors quite nicely but then the next level is network, there is no concept of layered clustering. C++0x gives us futures and asynchronous function call to give similar, albeit different, functionality – and restrictions. D currently has the problem that it only has a 32-bit realization, the 64-bit realization is not yet released (though it is due soon). Till then it is not possible to experiment with D to see if its Threads library can support the sort of programming abstractions that are required for highly parallel systems and applications: shared memory multi-threading is not an appropriate tool for application programming, which may turn out to be the downfall of Chapel and X10 and the whole PGAS approach as it is now.

Go is probably the first statically compiled, native target language that has a built-in garbage collection system. Such a thing is possible with C++, but at least until recently the idea of using garbage collection and C++ was frowned upon. I suspect though there will be a lot of prejudice against using a language with garbage collection for writing a new operating system, which gives doubt about whether Go will get used for that – despite all the splendid Plan 9 related work. So can D really step up and be a candidate? Or will people just descend to the arguments “C is the only language to use because it is the only one with a low enough viewpoint to write an operating system”?

Then there is the question of what should the architecture of the next operating system be. Will it be an exokernel, a microkernel, a nanokernel or something radically new? Will people choose a modern language to implement them or will they just assume C? Will Google's might push Go (and possibly D) into the limelight. Is the JVM the future virtual machine of choice? What role do hypervisors have? What will VMWare, Parallels, VirtualBox do to perturb things?

To summarize: We live in interesting times.

[07:29] (0 Comments)

Thanks to Sarah Mount for pointing out Guido van Rossum's summary of his immediate impressions on EuroPython 2010 on getting home and getting rested. Paragraph 2 is clearly the one that I am most interested in as I get a “name check”. :-)

Guido's paragraph acts as an excellent executive summary of the message that I was trying to get across. Applications programming in the world of clusters of multicore machines should not be about shared-memory multithreading but should be about small, lightweight processes sending messages to each other. Dare I suggest that this is a return to the true spirit of object-orientation of the 1980s? cf. Smalltalk-80 and all the research languages that were under investigation in the late 1980s (*).

In a world where applications are developed as small interacting processes either CSP-style or actor-style, or even dataflow-style (a model that didn't get much air time at EuroPython 2010 but is arguably equally important) CPython's GIL (global interpreter lock) is much less of an issue than ensuring that the multiprocessing package (and, perhaps bizarrely, the threading package) are as efficient as it is possible for man and machine to make it: multiprocessing (or something basically the same) is the foundation on which actor, dataflow and CSP based frameworks will be based, so it needs to be as fast as it is possible to make it. I have no doubt that the Python-CSP and PyCSP teams (or a merged team if that happens) will pick up on Guido's invitation to make proposals for evolving multiprocessing if it is seen to be needed.

This raises the question of whether there are efforts to create Python packages to present actor-based and dataflow-based models. I haven't seen anything relating to dataflow, and all the actor frameworks I have seen have been solely about handling concurrency in a single PVM context, they have not been about parallelism in a multi-PVM context. So clearly there are two obvious projects here:

1. Evolve one of the present actor model packages to foster parallelism as well as concurrency.
2. Start a dataflow model package.

The only questions are who, where and how. Feel free to email me ideas. Hopefully out of this we can create dynamic and productive activities that will see Python programming evolve to meet head on the challenges that multicore computing brings.

Looking over at the JVM-based milieu, the GPars project (**) has brought actors, CSP and dataflow to the Groovy and Java world. Scala, Scalaz and Akka are bringing actors and data parallelism to the JVM. Clojure, with its STM, actors and agents has truly modernized Lisp. The energy and progress in these communities needs to be replicated in the Python community in order for Python to retain relevance in a world increasingly awash with processing cores. So Pythonistas, sign up, your language needs you.

(*) Including Solve the language for which I led the design team. Solve was an active object based, parallel, object oriented language with static strong typing and transactional state that we developed as part of a large ESPRIT project 1986-1991. There is no point in reviving this work per se, but I must find and publish all the documents so they are available.

(**) Yes, I am involved in GPars activity.

[07:29] (3 Comments)

EuroPython 2010 was great. It came in three parts:

1. The tutorials: I ran a full-day tutorial on SCons. The group was small, but that made for an intimate atmosphere which I thought worked well. I thought the day went well, but you'll have to find members of the group and ask them for a less biased opinion. A couple of people said they would be switching from Autotools to SCons immediately on returning to work, as a consequence of the tutorial.
2. The conference: I did the opening keynote: The Multicore Revolution: We've Only Just Begun. The original opening keynote person pulled out late in the conference planning and I was asked if I would step in. I had thought it was a 45min slot, but then realized it was 30min, only to have delays in starting leave me 14.5min. In the end I took 25mins, but the conference organizers were fine with that. The talk was a (major) reworking of my keynote from ACCU 2010 to shorten it and aim it at a Python audience. The audience seemed to enjoy the presentation as people kept coming up to me all the way through the conference saying how much they enjoyed it. The slides are here but probably won't mean much unless you were there. There will be a video once Michael Sparks has encoded and uploaded all the material recorded by his video cameras. Single biggest outcome of the presentation was that Guido van Rossum collared me for an hour after the presentation to chat about parallelism and the CPython GIL. My take on this is that the fact that the CPython PVM (Python Virtual Machine) is basically a sequential interpreter really doesn't matter: the future is about lots of smallish processors with local (distributed) memory so having one PVM per processor with the PVMs sending messages to each other. This line of reasoning is obviously a segue into my second presentation.
   I did a 45min presentation Python Parallelism using CSP. CSP here is Communicating Sequential Processes, a model of concurrency and parallelism created by Tony Hoare in the late 1970s and early 1980s. The core idea is that having many sequential processes with no shared memory but lots of channels down which messages can be passed gives a way of constructing concurrent and parallel applications that means you don't get undebuggable deadlocks and livelocks. The slides are here. There are two implementations of CSP for Python, PyCSP and Python-CSP. Currently there are some differencves but many similarities between them, hopefully soon the two projects can merge to provide a single Pythonic way of managing parallelism using CSP.
   All the other sessions I went to were great. I was really pleased when Guido, in his keynote Q&A session, mentioned that he had been to all the CSP-related sessions and was going away with a lot to think about.
3. The sprints: Sarah Mount organized a sprint to work on Python-CSP. Given that I am one of the team it was necessary to be there! We had a small but incredibly active group of people and achieved masses in the two days we had. It was great fun.

The only downside was that my server died during the conference and it has taken me a while to lash up something to cover the email and Web-based activities pending getting a new one.

[19:15] (1 Comments)

United States Patent Application 20100175018

QED.

And they didn't even proofread the application before submitting it. The proof is left to the reader.

Are Microsoft trying to overtake Apple as the Evilist Empire?

Actually the more interesting question is will the USPTO investigate the application or just grant it?

[16:16] (0 Comments)

People, including lawyers, have now had time to research and reflect on the US Supreme Court opinion “In Re Bilski”. Having perused some of the analysis, it is interesting that there might be the beginnings of a fundamental shift in attitudes towards software patents -- well by the analysts and pundits, definitely not by the big companies and lawyers.

One really interesting piece is this one. It is good to see the argument that patents are tools for big, monied organizations being increasingly recognized. Also that startups are the point of innovation, not big organizations. Big organizations is where engineering happens: new products are harnessed, made smaller, faster, more efficient. Startups don't do this (at least not generally), they create the first implementations of new ideas. Some innovation are generated in big organizations but nothing like the amount that happens via startups.

Ironically (perhaps), the big US software companies often imply that software patents are somehow the “American Way” and they have the right to be able to destroy or buy out any potential competitor because that is how capitalism works and capitalism is the “American Way”. Of course another part of the “American Way” is opportunity for all: every startup should be allowed to try its hand without the fear of being hounded out of play – especially if that is by means of financial muscle. There seems to be two diametrically opposed “American Way”s here.

Big software organizations have as reported in many places been on a campaign to try and convince the EU to adopt the US patent approach. But if patents are a tool for big organizations to preserve their status, often near monopolies, how can the EU justify creating a patent system that stifles innovation, destroys competition, and promotes monopolies? Surely the EU should see through the gambit and cease all moves to allow any form of software patent. Of course it may be that “big money” is getting as powerful in the lobbies of the EU as it is in the lobbies in Washington. If the “big money” was European it would be more understandable, but it is all US.

Let us assume the US patent system stays in the US, and the rest of us have a more sane system. Then it is clear that software innovation cannot happen within US jurisdiction. Innovation is about having an idea and getting on with realizing it. Having to spend all your time trawling patent databases to see if a technique you have used violates a patent, is a 100% killer of enthusiasm and thus innovation. So I agree with Sawyer, it seems like the right move to have all software innovation happen outside the borders of the USA. This means the role of Silicon Valley is due for reassessment. Of course the USA has (arguably) the best infrastructure for supporting startups (and hence innovation) whilst at the same time has the biggest tool for supporting monopolies and the killing of innovation (its patent system).

I guess the interesting question is what happens about importing into the USA innovative software developed outside the USA which violates some US patent. Import will be banned, and the USA will fall further and further behind in the technology race. China is already the centre of manufacturing, is it also destined to become the centre of all innovative software development? I suspect not given the governments view on freedom of information, speech, etc. This is an ideal opportunity for Europe, indeed the UK, to become a serious power in software innovation. Perhaps the UK government should itself innovate and provide the legal and financial infrastructures to support innovation and startups far, far better than the UK does at the moment.

Of course “Silicon Fen” and “Silicon Corridor” are the stomping grounds (literally in terms of stopping startups) of the big money organizations, so it is unlikely that they could be the replacements for “Silicon Valley”. Where can be though, and what trendy name can we give it?

[14:13] (0 Comments)

I have been asked to give the opening keynote! So be there . . . Adrian Boult Hall, Birmingham Conservertoire 2010-07-19 09:15+01:00 – check the details here.

And of course I will be presenting a 1-day tutorial on SCons starting 2010-07-17 09:15+01:00 as part of the tutorials lead up to the conference.

I also get to present my session “Pythonic Parallelism with CSP”, 2010-07-20 17:45+01:00.

The only question left, apart from can I get all the material together in time, is whether to organize a sprint for after the conference. And if yes on SCons or Python-CSP?

[09:22] (0 Comments)

So the BCS EGM called by Len Keighly et al. is over and the resolutions all went against him and his group that chose to challenge the actions being taken by the BCS Trustee Board and the CEO. No doubt the Trustee Board and CEO will publicize this widely as a huge vindication, but is it really? Only 32% of the members voted, which means 68% didn't care about the result. So the whole thing was about as interesting to the electorate as a local government election.

What I did find mildly interesting was that whilst around 75% of votes cast were for the Trustee Board and CEO on all but one of the resolutions, for the one that really mattered (Resolution 3) only 62% of votes were for them. So although the resolution to terminate further spending on the transformation until full account was taken was defeated there was clearly less support than for all the other resolutions.

Personally, I was in two minds about the whole thing:

1. The BCS needed a revamp. Due to the success of ECDL and other ventures the BCS has clawed its way out of the quagmire of some years ago where it was nigh on destitute, and is now relatively flush. It's image though remained the old one which was looking tired. I am not a great fan of the brand, but I am pleased there is a new one.
2. I had little confidence in the Trustee Board and CEO. The way the CEO and Trustee Board managed the whole revamping thing with the members showed significant condescension. Worse the way the Trustee Board and CEO have handled their side of the EGM campaign has involved throwing members money at a campaign of vitriol against the people who called the EGM. This really irked me.

A particular hobby horse of mine is the members magazine, which I think is very poor. Compare “IT Now” from BCS with “Physics World” from the Institute of Physics. I flick through “Physics World” and generally read some of the articles. I flick through “IT Now” and immediately consign it to the recycling. Thus, apart from having some postnominals, what do I get for my membership fee? Recycling.

OK so I could attend specialist group meetings and branch meetings, and very occasionally I do. However far too few are actually interesting to me, and all to often they happen on a Thursday. I can't do Thursday evening. Actually, somewhat like Arthur Dent, I still haven't got the hang of Thursdays.

[20:12] (1 Comments)

My N900 is telling there is a Maemo upgrade, and the list of new features looks enticing. However if you try the upgrade, it goes through the first few stages of preparation, and then stops and tells you that you can't do it over the air, you have to download the install file onto a PC and use the USB connection to do the upgrade.

When you read the instructions it tells you a whole collection of bizarre things you have to do to get things to work. OK, so it seems like you have to have a PhD in Linux administration to upgrade a Maemo N900. What is actually worse are the warnings about how the upgrade will completely anihilate all data on the phone. That isn't going to win friends and influence people -- at least not positively. It is making me think twice about doing the upgrade at all. Even though I back up my data on the phone and then copy the backup file out to my fileserver. The thought of being left with a phone that doesn't work is a real mountain.

If this is the upgrade strategy then this phone is definitely not a general consumer device, it is definitely a programmer's toy. I wonder if Android phones are as bad?

[16:44] (2 Comments)

The US Supreme Court today issued its opinion in the case most people know as “In Re Bilski”. Although there is actually much more to it, this case is about whether business processes can be patented. A lot of people (mostly large corporates) have a lot riding on the patentability of business processes, so this is an important opinion, it has the ability to fundamentally change the US patent system. The software industry is interested in this case because there is the side issue of whether software is patentable. Currently the US system allows software to be patented, but many, for example http://endsoftpatents.org/, think this is wrong. The UK patent system technically does not allow software patents, but is coming under increasing pressure (mostly from big US corporates) to allow them. The EU patent system appears already to have succumbed to pressure (mostly from big US corporates) to allow software patents, which leads to real problems in the EU since there is conflict between the two systems. The correct outcome would be for EU Patent Office to agree that software itself cannot be patented and for the UK Patent Office to reaffirm that this is its position.

Why are people worrying about business and software patents? Patents are weird things in that you can be in violation of the law without knowing it. A patent is a legal instrument given to someone to create a monopoly on exploitation of an invention. The patent holder can licence others to manufacture and sell products based on the invention. Anyone found to be manufacturing a product that uses the same information as in the patent documentation is in violation of the patent and can be sued in the courts. Not only does this lead to (potentially huge) damages, but there are the costs as well. The really important issue here is that ignorance is not a defence: you can be guilty of violation of the patent even if you didn't know the patent existed. Even if you didn't know anything about the invention that was patented you can still be in violation of a patent.

Some people argue that patents are tools for small players to benefit from inventions. Someone can create an invention but not have the resources to exploit it. By taking out a patent they can benefit by getting a big player who does have the resources to manufacture and sell product based on the invention to do so and pay royalties to the inventor. Whilst this scenario is possible, and indeed does happen, it is no longer the real purpose of the patent system.

Patents are now tools for businesses to do business with each other, and to ensure their ability to stop new players from entering into a market, i.e. to preserve monopoly positions against all comers. Businesses build up patent portfolios as an offensive or defensive measure.

• As offence you create (or more usually buy) patents and then search round all the products on sale looking for ones that violate (or appear to violate) your patent. You then threaten to sue the manufacturers of violating (or apparently violating) products unless they pay royalties. If they don't pay up you then actually do sue them if you think you can win – notice the patent holder may not actually believe they can win, they may just have been trying it on. Without the patent involved this sort of behaviour would be labelled extortion or demanding money with menaces and be a criminal offence, but with the patents it is a business process.
• As defence you stockpile patents that others might find useful so that when an organization approaches you wanting to talk to you about some product or other, you have bargaining chips so you can cross licence patents you are interested in for zero cost enabling you to make products that otherwise you would not be able to because of the need to make royalty payments.

The only defence for a small organization against a patent is “prior art” or proof that the invention is obvious – large organization generally have patent portfolios and can find a patent the other party is interested in so can do a deal. Any legal action is hugely costly – this is the main barrier, unless you have deep pockets you cannot afford to enter into any legal action. Patents are tools for big organizations.

OK so that is the backdrop, why are software developers worried?

Let's use an extreme example. Say I took out a patent on the for loop being used to create the sum of values in a sequence:

    var sum = 0.0
    for ( item in sequence ) { sum += item }

As soon as I have my patent in a given jurisdiction, everyone who uses code such as this in that jurisdiction owes me royalties for every use – and remember this is true even if they didn't know that there was a patent granted in this.

So in a world with software patents what role is there for the independent developer of software? There isn't one. Large corporates would be the only people capable of developing any software because only large corporates have the resources to take a playable position in the patent wars. It's no wonder that the large corporates want software patents, they want to kill off free and open source software. The large corporates want a world in which they control all software.

Unless you are one of the monopolistic corporates desperate to remove all potential opposition, you should be against software patents.

Reports to date seem to indicate that “In Re Bilski” finds that the Bilski process patent is not allowed, but they have not offered an opinion on business processes in general and definitely not on software patents. So this is not a close, just the beginning of the next phase of activity.

I am not a lawyer, the above is not a legal opinion, just my understanding as a person involved in software development.

Groklaw is also a good place to follow this sort of thing.

[18:31] (0 Comments)

Yesterday (yes, Saturday!) the London Google Technology User Group put on an all day session about the Go programming language. Initially this was going to be a 90min talk followed by a “hack” session, but at the last minute it got turned into an exercise-led tutorial. Andrew Gerrand (a member of the Go development team within Google) led the session which had been organized by Anup Jadhav. In effect this was a re-run of the session Russ Cox did at USENIX 2010

I think I would have started the session in a very different way to the way Andrew did, but once things got going, it was a fun day. Certainly the guys I ended up in the pub with were great. Bizarrely, the pub we had originally been going to end up is was closed and shuttered. On a Saturday night, in a fairly residential area. Anyway the place we ended up was OK, roomy enough, and the London Pride wasn't too dreadful.

I have been looking at Go on and off for a few months now – I didn't look at it immediately it was announced because of all the fanfare and hype, which was reminiscent of the fanboi-ism rampant in the Apple product arena and now spilling over into the Google product arena. However, once all the initial fuss had died down, I started taking a look at it.

Go is marketed as a general purpose, statically typed, compiled to native code programming language suitable for systems programming. It is aimed at the place where C and C++ currently hold sway but bringing to that area some of the “speedy development” aspects of Python, Java, etc.

I have to admit, as soon as I started using the language I liked it. I am not keen on the massive fascism regarding code layout and the use of Make, but the language is appealing enough functionally that I can get over this. I am not a fan of the logo, mascot or even the language name, but can live with these – mostly, trying to do Web searches for things associated with Go really is hard. (Experience from Groovy indicates that programming languages with twee names suffer a take up barrier, especially by the suits running most companies.)

The most obvious thing when you first see any Go code is that the types are on the right of the names, Pascal style. Actually there is a really interesting backdrop to token ordering in Go: Go can be parsed without performing symbol table lookups. This enforces a left-to-right consistency of all tokens making complex type specifications readable. Contrast this with C and C++ where some type specification are literally incomprehensible unless you are an LL(k) parser.

What I like most about Go is the goroutines – though again I don't think the name is anything other than a twee joke. Go recognizes that the Multicore Revolution is in full swing (unlike C++ which is only just getting to the “threads are part of the language” stage of development): Go has a high-level, very usable model of concurrency based on processes and channels – threads are infrastructure the programmer should never have to work with.

Go's antecedents are the AT&T series of languages associated with the Plan 9 operating system. Process and channel based thinking has been an integral part of this development from the outset. Newsqueak led to Alef which led to Limbo which led to Go, this has been positively confirmed by Rob Pike on the Go users mailing list:

Russ's [Russ Cox] historical analysis is right, except that there were two CSPs. The original 1978 paper did not have channels; the later book did. Newsqueak was the first programming language I ever used that had channels, but that is not a claim of invention. I honestly have no memory of where idea for channels in Newsqueak came from, but I'm pretty sure I didn't see the CSP book until afterwards. I do have a vivid memory of getting the idea for the implementation of hyperthreading in Newsqueak by generalizing something I read in the HUB paper by O'Dell, which was based on much earlier work by Masamoto; that was the trigger to write the language. Winterbottom grafted Newsqueak's communication ideas onto a C-like systems language to create Alef. Limbo arrived when it was time to build a virtual machine for embedded processing.

Neither Occam nor Erlang influenced those languages. I didn't learn much about Occam until after Newqueak, and about Erlang until after Limbo. It was a long time ago but I believe I ignored Occam primarily because of its lack of first-class channels; its roots in hardware did not enable that generality.

So the process and channel approach of Go is a different thread of development compared to Erlang, Scala, Python-CSP, GroovyCSP, etc. yet leading to exactly the same paradigm, a paradigm yet to have impact in the C, C++, Fortran and Java communities. This software architecture paradigm fits superbly with massively multicore processors predicted for the medium and long term. Contrast this with the shared memory multi-threading paradigm which is increasingly causing problems for C, C++, Fortran and Java code.

Most of yesterday's session was about Web applications – not really surprising given that the session was led by Google – and didn't really cover the package structuring, code testing and parallelism aspects of things, which for me are the unique selling points (USPs) of Go. I think Go will rapidly replace C for all software development that uses C because it is the default language of development. I suspect C++ will lose some to Go, but C++ has capabilities and a fanatically loyal user base that more or less guarantee it will still be used for many years to come. Also some applications using Python (and Ruby, Perl, etc.) will use Go because it has many of the ease of development aspects that these languages have but it is compiled to native code and so very much faster of execution. Python (and Ruby, Perl, etc.) are of course dynamic languages and so have meta-object protocol capabilities that are impossible with compiled languages such as Go, C, C++, Fortran. Though, like Java, Go has a reflection system.

But Go is just a Google language the purpose of which to promote the monopoly of Google over everything in everyone's lives. I hear you say. Well it is true that Go is currently being developed by Google staff with an eye to Google's use, but it is an open source project in the full FSF definition.

Go is still a very young language, but the libraries are being built at a fairly astonishing rate. It will very soon be ready for production code usage by all and sundry.

[08:40] (1 Comments)

It seems that Google can remove applications from your Android phone without first asking your permission. Though they do at least do you the courtesy of telling you after such a thing has been completed..

This facility that Google has is being marketing as something to benefit users and protect them against malicious software, and in some sense this is true. However, there is nothing to stop Google from deleting whatever application that they choose to, whenever they want. Are the applications supplied via the Android Market different to those supplied with the device on initial purchase? I have no doubt that anyone downloading an application from the Android Market has been forced to agree that Google has the right to delete the application whenever it wants. Perhaps more interesting is whether they have the same rights over applications supplied at the point of purchase: are the users rights under the Sale of Good Acts abrogated by the Android use licence? I am not a lawyer, so cannot give a view. It will be interesting if the case ever arises!

The obvious question is: can Google be trusted?

It is well known that Apple has the same capability for their products, and Amazon for their's, and indeed both facilities have been used. Can they be trusted?

There seems to be a bit of a trend here: manufacturers maintain control over the products you purchase. Are Google, Apple, Amazon just this centuries incarnation of "Big Brother" (from George Orwell's book 1984).

Where are the user's rights in all this? Nowhere. "Big Brother's" protection of you against malicious software clearly trumps any rights you thought you might have had over the products you thought you owned by paying money for them. It seems the very nature of sale and product are changing. But then I am not a lawyer so cannot say. Interesting issues though.

[14:10] (1 Comments)

As I had a spare partition on my laptop, I loaded Debian Squeeze (so the laptop can dual boot Debian Squeeze or Ubuntu Lucid on it and have been using it. Having spent a while getting the bulk of the things I use loaded – only a little bit longer than with Ubuntu since my set up doesn't look very much like the default configurations of either – my Squeeze desktop looks identical to my Lucid one. Well the obvious differences are the Debian rather than Ubuntu logo on the main menu entry and the different waste bin (aka trash can) icon on the panel. Actually this shouldn't really be much of a surprise to anyone, Ubuntu is built on Debian so everything is basically the same. Also of course all my filestore is a mounted partition and so is the same whichever operating system I boot. So what are the real differences?

Perhaps the single biggest issue is that with Ubuntu the Flash plugin works on Galeon, Epiphany, Firefox and Chromium whereas with Debian, the Flash plugin isn't available and won't load. Why is this an issue? The free replacement for Flash used by Debian does not emulate Flash and the BBC website explicitly checks the version of Flash being used before it allows you to do anything with any of its dynamic content -- such as cricket scoreboards. Cricket fans everywhere will appreciate that there is nothing more important in the universe than having the continuously updated scoreboard on your desktop and match commentary coming out of the speakers. OK, so the core of the problem is that the BBC is mandating Flash v10 or higher, but this really does mean that Ubuntu got it right and Debian got it wrong :-(

Of course on the downside for Ubuntu, they have not only removed Galeon from main, they have ejected it from universe and even multiverse. Aggressive or what? I know Galeon is ancient and totally untrendy in these days of more and more flaming vulpes and shinier and shinier reflective metal stuff, but I like it. Actually what I really like is having four different browsers so that I can use different ones for different categories of browsing. Oh well, down to three now. Of course Squeeze has an analogous problem, Chromium hasn't been allowed into Squeeze from Sid yet, so isn't available. So 3–3 on that score.

Huge irritant with Squeeze is that Python is still 2.5 by default. This really, really sucks. Fortunately 2.6 is available, but you have to manually hack the symbolic links because Python is not part of the alternatives system. Hopefully 2.6 will become the default in Squeeze soon.

Apart from Python, most of the versions of things in Squeeze are a bit more up-to-date that in Lucid, and haven't been tinkered with to be biased towards the default Ubuntu look and feel. Examples are the on screen display which in Squeeze obeys the GTK theme and is graphically rooted to the icon of the generating item, whereas on Lucid it is always black and always somewhere you don't expect it. Stupidly, it is trivia like this that end up leading to decisions. For example:

• pdfjam is v2 in Squeeze and v1 in Lucid. This causes me real pain as the scripts got changed such that all the options to commands are different so all my scripts now have to know whether they are running on Lucid or Squeeze :-(
• The power applet in the notification area tells me the percentage full my battery is on Squeeze but not on Lucid. Of course Ubuntu is abandoning the notification area in favour of indicators. Lucid is a transition for this but when I tried using their indicator area rather than notification area for the applications I used the spacing of the icons was ridiculously large and unchangeable. The Ubuntu team have a strong model of the applications you will use and how you will use them, and are not entirely keen on worrying about the applications that some of us really use. Hopefully they don't get too Apple-like in their user interface fascism.

On the upside, setting up Squeeze with my home directory on a filestore shared with Lucid has fixed most of the Compiz problems I was having with Lucid! There are lots of bug reports on Launchpad about problems with configuration of Compiz and lack of storing of options from session to session. Well the solution is: load Squeeze.

In other news: Network Manager works much better on Squeeze than on Lucid, at least for me. When I plug in or unplug the Ethernet wire, the routing tables are properly updated: Ubuntu seems to assume you will either use wired or wireless Internet but not mix both in a single session.

So, apart from the Flash problem, Squeeze is the winner of the competition for which distribution I am going to use for the foreseeable future. But note it's basically the trivial things that are the decision making points. Also I might change my mind -- flexibility over dogma I think.

[15:15] (0 Comments)

Along with many others, I have been increasingly irritated by certain aspects of the way Ubuntu has evolved recently. There is increasing obsession, and indeed hype, around the look and feel that is presented by default. This is not in itself a problem, at least not for me: having an interface that looks appealing and is usable is very definitely a good thing. At the surface of my problem is the Apple-like assumption that there should be a single, essentially unchangeable look and feel for all instances of Ubuntu. It is not the attempt to create a default, harmonious look and feel that is the problem for me, it is the fact that Ubuntu users are basically being blocked from anything different from that which is being handed down by the Ubuntu designer elite. In pushing their vision for Ubuntu, Ubuntu is losing the ability to work reasonably with anything other than the officially sanctioned default look and feel.

I have my own (highly idiosyncratic) user interface that works for me. It is minimalistic, yet Gnomic. It is just not post-Jaunty Ubuntuish. I want to keep my look and feel rather than fall in with the emerging Ubuntu standard. More importantly though I want to use the applications I prefer with the functionality that fits what I want to do.

I moved from Debian to Ubuntu early in Ubuntu's life, 5.04 Hoary Hedgehog in fact. My rationale was three-fold: Ubuntu was based on Debian (to which I had moved from Red Hat 7.3 instead of going to Red Hat 8.0) and so was not that much of a change; having a corporation managing a Debian-based release on a rigid 6-monthly update cycle appealed; and the staff of the company I was running at the time told me to.

Until 8.04 Intrepid Ibex, I had been happy with my choice and was very much an Ubuntu advocate. There had been some problems with sound in Hardy and Intrepid which hit me but which I sorted, and which I assumed was a one off problem. However, it turns out that this was the beginning of my disaffection with the way Ubuntu was developing. The upgrade to Jaunty Jackalope had various glitches associated with applications I think of as core and were in the main repository (not in the universe or multiverse repositories). The response to the bugs I reported were null: the bugs were ignored and the packages were subsequently dropped from main in favour of other applications with less usability but more trendiness. It seems that there was a turning point sometime around late 2008 that the look and feel of Ubuntu was more important than the functionality. Much of the default application set dumbs down the functionality beyond my ability to live with it. The volume control is perhaps the most trivial and yet is the most obvious instance of my irritations: the mixer is completely missing.

So I have a decision to make: do I retain allegiance to Ubuntu, or do I, like many others say “enough is enough” and, like many others have done, return to using Debian – probably Squeeze (aka Testing) but maybe Sid (aka Unstable). I still like the Ubuntu ideal as of 2005-2009, so still feel an affinity to using Ubuntu, but the continuously updated pool of things to choose from idea of Debian Testing and Unstable is increasingly appealing.

Given a decision of this enormity, I shall have to dither a while.

[18:05] (0 Comments)

I am just getting into constructing websites using Django. So I thought “buy some books, that will help”. Well the books I got, including the one by the Benevolent Dictators for Life of Django, tell you how Django works and how a final working site works, but they don't tell you how to construct a site, nor how to test a site – neither unit test or integration test are covered. Contrast this with the Grails books which heavily emphasize using test-driven development to create the sites, and have lots of material, and even index entries, about tests and testing. The Django books simply say “you should test, for information see the Django website”.

So the inference seems to be that testing is central to the use of Grails whereas with Django it is something you are told you should do, but it isn't something that needs to be presented in the books. Definite case of mixed messages. Conclusion: Django book authors really need to get their priorities in order.

[08:10] (0 Comments)

The USPTO has just granted patent 7,739,139 to Amazon Technologies Inc for “Social Networking System ” – grant date 2010-06-15, filing date 2008-05-27. This seems to imply that all social networking systems in the USA now have to start paying royalties to Amazon. Will Facebook, Linked-In, GitHub, Launchpad, etc., pay up or will someone fight this in the courts?

The obvious conspiracy theory here is that the lawyers in the USA are gaming the system so as to ensure maximal transfer of funds from clients to lawyers. Lawyers get paid for creating patents, whether or not they are sensible, and then get paid to battle out the subsequent litigation trying to decide if the patent is valid or even reasonable.

The other conspiracy theory is that USPTO is milking the system by allowing any and all applications to succeed and pocketing the money without doing any work, just waiting two years.

The only real conclusion here is that the USA patent system is broken. Let us hope that the UK and EU systems do not further descend into the same mess.

[13:30] (1 Comments)

Dell has entered the League of Evil Empires at Number 7. Dell claim to want to sell you a new computer where you choose whether to have Ubuntu or Windows installed as the operating system. However, they refuse to offer for sale any computers running Ubuntu, they all run Windows. This is Evil.

In the completely and totally unsurprising section, Apple retain their Number 1 position. They used to offer GNU Go to iPhone users in violation of the GPL, but instead of complying with the GPL, they removed the software. Apple only allow you to run software they approve of and for which you pay them, their licence is very restrictive and designed to create and maintain a monopoly over what you can do with equipment you supposedly own. This is Very Evil.

[13:25] (2 Comments)

If you are a C++ programmer and you do anything with threads in C++ then you really need just::thread, it is a good implementation of the C++0x standard. Version 1.4.0 just came out as noted at http://www.stdthread.co.uk/.

Shared memory multi-threading is anathema, futures are the future.

[10:35] (0 Comments)

Having finally got libboost-mpi-dev and the version specific packages into Debian and thence Ubuntu, it seems the Ubuntu management have decided it's far too much trouble and have now removed all Boost.MPI packages from Ubuntu, cf. the notification and proof it's not in Maverick. Debian are going the other way and providing backports of Boost.MPI so all versions of Debian support it, cf. proof it's in all version in one form or another.

The conclusion is clearly that whilst Debian are supporting all tools associated with multicore systems and HPC programming, the Ubuntu management have decided that C++ and MPI are an irrelevance to the future of Ubuntu.

Conclusion will be drawn. Mostly with the blue pencil of censorship.

If you care about having Boost.MPI in Ubuntu please visit this bug report and add your comment/support.

[07:10] (0 Comments)

Wiley got someone to translate Developing Java Software by myself and Graham Roberts into Simplified Chinese. I haven't a clue how good the result is as I do not read Chinese. If anyone can give me a comparison between the English original and the Chinese translation, I'd be very interested.

[11:35] (0 Comments)

Given the fact that the world is partitioned by language, enforcing one script as the only script for URLs is a form of cultural imperialism. So it seems a natural evolution of the Internet that non-English URLs should be allowed. However this means the Internet is now being partitioned in a way that allows greater state control and censorship – even more than there is already.

The story of the Tower of Babel, which appears in one guise or another in many ancient books, relates how there used to be one language and that everyone could communicate with each other, but that hubris and vanity led, indirectly, to the breaking up of society into tribes each using their own language.

It may not be vanity or hubris that is leading, directly or indirectly, to the partitioning of the Internet, but breaking up it certainly is doing. One just hopes that this isn't going to lead to ghettoization.

The Internet had been a tool for allowing one language, English, to become the lingua franca (and there is indeed irony in that phrase), to create a single world of communication. It is a pity that some tribes in the world saw this as imposition rather than opportunity. Maybe hubris and vanity are involved after all. More likely though it is power and politics. Sad.

[08:45] (0 Comments)

GPars is a framework of concurrency and parallelism constructs for Groovy programmers. GPars provides actors, CSP and dataflow constructs. Underlying GPars are the JSR166 libraries and JCSP, so the foundations are good and solid. GPars gives using these concurrency and parallelism tools a Groovily idiomatic feel.

[10:40] (0 Comments)

So HTC has signed a deal paying Microsoft royalties for HTCs use of Android in their smartphones. Microsoft are of course marketing this is part of their “Linux violates patents held by Microsoft” campaign. The question is Why has HTC really succumbed to this patent bullying tactic?

Microsoft of course claim this is because they have proved to HTC that their patent claims are real and genuine. Clearly this is just not the case, otherwise Microsoft would be chasing the really big Linux users. I guess that Microsoft have said to HTC that if HTC didn't pay up over Android then HTC would not be allowed to use Windows Mobile. But then does Windows Mobile matter any more in the smartphone market? Perhaps then Microsoft are playing a “long game”: by obtaining lots of smaller organizations actually paying royalties, they build up a snowball of opinion that the patent violation is real. This way they create a perception of truth of their claim without ever having to prove their case in court.

Perhaps then the question is: Are Microsoft channeling funds back to HTC in some way to pay them back for participating in this long game patent scam?

[10:20] (0 Comments)

30+ years ago Tony Hoare and colleagues developed CSP, a mathematically sound model of how to structure software so as to deal as safely as possible with concurrency. Parallelism wasn't such an issue then as it is now, post the beginning of the Multicore Revolution; at the time of development of CSP very few computers offered applications more than one processor.

Now as we enter a period of massive change in computer hardware structures (uniprocessor architectures are giving way to multiprocessor architectures), it is becoming increasingly clear that shared-memory multi-threading cannot be the software architecture of future applications. The need to correctly manage locks, mutexes and monitors, as is required in shared-memory multi-threading, is just too complicated to get right.

Erlang has been the major proponent of using lightweight processes and message passing over the last 25+ years. It's successes in the telecoms industry have generally been ignored by the wider computing industry as it rushed headlong into the quagmire that is shared-memory multi-threading. Joe Armstrong has noted in the past that although Erlang does not directly realize the Actor Model or CSP they were very strong inspirations in the development of the language.

The HPC (high performance computing) community have been working with parallel systems since almost the beginning of computing. Many models have been tried over the years, but the current winner is a combination of SPMD (single program multiple data) architecture with annotations to handle local thread management: MPI and OpenMP are the tools of handling parallelism with C, C++ and Fortran the programming languages of choice. No Actor Model, and certainly no CSP. Given the unwillingness of the HPC community to rewrite any of the codes they have developed over the last 40+ years, it seems likely that the traditional HPC community will become an increasingly irrelevant backwater of computing innovation.

On the Go (the programming language being developed by Google) programming language users mailing list, Rob 'Commander' Pike reminded us in one thread that although the goroutine concept in Go appears to have some inspiration from CSP, most of the ideas were developed independently during the development of the Squeak, Newsqueak, Alef and Limbo programming languages. He also pointed out that occam and Erlang were separate developments with there being no interchange of ideas.

Parallel and independent emergence of essentially the same idea is a strong indicator that some version of that idea is a great innovation. This has been shown many times in many different fields of human endeavour.

In the data mining arena, there is increasing dissatisfaction with SQL-based approaches; they are too slow to be useful. Employing a dataflow software architecture (an event-based approach based on lightweight independent operators, which is basically a subset of CSP), there is a revolution in the approach to data mining. SQL-based approaches gain no benefit from parallel processors, dataflow approaches gain huge benefit, and are now massively outperforming SQL-based approaches.

Thus it seems there is an "emergent property" appearing to come form all this: independent lightweight processes with no shared state is a good model of applications programming in a world increasingly dominated by parallel computers. Actor Model, dataflow and CSP are, increasingly, the future for software. The JVM world is heading that way, Scala has Actor Model, GPars provides Actor Model, dataflow and CSP to Groovy and Java programmers. Even the Python world is heading that way, cf. Python-CSP.

CSP is not a silver bullet, there are none in computing, but it is likely one of the best ways forward for structuring software in the post Multicore Revolution, massively parallel world of applications development.

[06:35] (0 Comments)

Two weeks ago the Cons and the LibDems were at each others throats, trying to convince the voters how appalling and evil the other was, and that the Labs were worse. As of yesterday, the Cons and the LibDems are the best of friends, indeed they are fawning over each other. Fawning is ugly at the best of time but this definitely appears as though they are mocking the voters.

Given that the Cons and the LibDems supposedly agree on very little and disagree on so much – well at least that is what they told the voters two weeks ago – it is fairly difficult to see what there is that can form the core of the programme for this government.

Clearly a politicians need to be in power overrides any thought of principles and policies.

I suspect the coming Queen's Speech will be entertaining.

[21:35] (0 Comments)

So Gordon Brown has resigned (as Prime Minister and leader of the Labour party) and the Queen has invited David Cameron to be Prime Minister. The Conservatives (Con) have declared a full coalition with the Liberal Democrats (Lib Dem) – whatever that means in reality. The question is whether the Lib Dems are stringing the Cons along or whether the Cons are stringing the Lib Dems along. What is truly certain is that the political, ethical and moral differences between them are far more than the similarities. A very strange collaboration. So who is more desperate for power, David Cameron or Nick Clegg?

I suspect the telling point is that the Conservative party has enough money to fight another general election, but the other parties do not. What odds on a second election in 2010 with the Conservative party going for an overall majority so as to drop the Lib Dems?

What we can predict is that all the politicians will be ensuring they get money in their and their friends pockets. The voters will lose. Whatever politicians say in public, you know they are not averse to lying. Blatantly.

[20:35] (0 Comments)

The Conservatives threatened the markets with panic if there was a hung parliament, there is a hung parliament, and the markets did a bit of panicking. Is this behaviour built into the system, or are traders a bunch of lemmings easily fooled by FUD? Rhetorical question.

We have a hung parliament for the first time in 34 years. Now we see politicians negotiating with each other in a desperate scramble for power. Fairly ugly in itself. Interestingly though, if the UK moves to proportional representation, we will see this sort of “horse trading” after every election. The “first past the post” system has its benefits as well as its clear unfairnesses compared to proportional representation. I wonder if there will be proper debate about this, or whether the political classes will just impose the solution that is best for the political classes on the electorate. Do the political classes just see the electorate as sheep to be herded? Not a rhetorical question.

[09:15] (0 Comments)

Many moons ago (about 1996), Web browsers included Java to provide client-side computation capability – applets became all the rage. Sadly most computers weren't really powerful enough at that time to properly support applets that weren't just trivial, and so client-side Java died off to be replaced by JavaScript (aka ECMAScript or whatever it is called this year). Actually client-side computation became unfashionable and seen as a “bad thing”. Everything moved to being server-side, generally to the detriment of good human–computer interaction (HCI) in the Web browser.

Fashions change. Now it is cool to do things client-side: AJAX, etc. mean that client-side is now considered a “good thing” – actually this could be good for quality HCI in browser-based application, sadly it rarely is as the developers all too often have no idea about HCI and what makes a good user interface.

Now there are rumours that people who like Mono are saying that CLI should be included in all browsers. Apart from all the software patent issues because Microsoft own patents in CLI, is this just Mono folk being shills for Microsoft trying to get .NET as the standard for all Internet-based activity?

History tells us that the JVM (of which CLI is a rip-off) can already be used client-side in browsers, so why not just return to using Java applets? Computers are now vastly more powerful than they were when applets stopped being all the rage. Perhaps if they were tried again, they could become all the rage again.

[15:15] (2 Comments)

So today is a general election in the UK. The only real outcome of this is that later tonight one tribe of people will be drinking a lot and smiling, and all the other tribes of people will be drinking a lot and frowning. The outcome for tomorrow will be just another bunch of politicians trying to tell us what we can and cannot do, whilst lining their own pockets by redirecting money we pay in tax into their own personal bank accounts.

If one party gets in the very rich will be happy and will set about putting more money in their pockets at the expense of everyone else. The rest of use will be shafted. If any other party gets in then the spongers on society will be happy as they will set about putting more money in their pockets at the expense of everyone else. The rest of use will be shafted.

So if you are in the middle, i.e. the vast majority of people in this country, then prepare to be shafted as of tomorrow morning.

Depressing, but sadly too true.

[14:40] (0 Comments)

Recently I have been taking a look at the Go programming language. I find it very interesting and feel it could have a great future. As with anything new though, people are studying it without appreciating the history that leads up to it. In one particular case, you get comments along the lines of: “their concept of Go routines and Channels, and I wanted to see if this really was a new paradigm for multi-threaded, multi-tasking programming.” (from http://gohelp.wordpress.com/). The answer is clearly “No” since the Go paradigm for handling concurrency and parallelism (goroutines and channels) is based fairly and squarely on CSP (Communicating Sequential Processes) which Tony Hoare and collaborators invented and about which he published a book in 1984. The Go documentation clearly points out this historical background to the goroutine concept. The problem is that people are either not reading it, or are choosing to ignore it. Fortunately the developers of Go are less dismissive of history. Possibly because some of the team were involved in making it 30+ years ago.

“Standing on the shoulders of giants&rdquo is a well used phrase to describe moving things forward by using the great work that people have done in the past. The Go development team are doing this. It is a pity that too many people are not realizing this, because they have failed to appreciate the history of their subject.

[08:25] (2 Comments)

The recent behaviour of two of the big computing companies, you know which ones, really has shown that bullying has become standard business practice. It is tantamount to extortion. If it were human beings and not corporates behaving like this they would be in court on criminal charges of bullying and extortion.

I have started a league table, currently based entirely on prejudice with no underlying data, of "Evil Empires". I will update it as and when, initially on whim, but if people start writing to me, I may turn the league table into one based on votes and commentary.

[13:49] (0 Comments)

Google seems to think that only www.google.co.uk should celebrate this and not www.google.com. I suspect there would be an international outcry if they only celebrated St Patrick's Day on www.google.ie. Perhaps there is a conspiracy at work?

Of course today is also the official birthday of William Shakespeare so double the reason to celebrate. But only with a comedy not with a tragedy.

It really is a shame that English pubs don't take as much trouble over selling English ale on St George's day as they do Irish stuff on St Patrick's Day. Bad marketeers I guess.

[07:55] (0 Comments)

Or is that “ashed”?

ACCU 2010 was volcanically good this year – though not for people who couldn't get there due to the Iceland volcano eruption that has paralysed air travel in Europe, nor for those stuck in the UK after the conference when they would much prefer to travel home. The situation led to massive rearrangement of the conference programme including shifting my sessions from Saturday to Friday.

I presented my keynote The Multicore Revolution: We've Only Just Begun at 2010-04-16 09:30+01:00 – a day earlier than originally scheduled. People seemed to like the session. The PDF of the slides used can be found here, they may not mean too much unless you were there! The basic message was that hardware has changed massively over the last two or three years, but that software has not; that there needs to be a revolution in software to match the revolution in hardware.

The day before I had presented my session Parallelism: The JVM Rocks; a session focused mainly on Java, Groovy and the Groovy library GPars. Functional Java was mentioned as were Scala, Clojure, Fortress and X10. The intention was to show that the JVM is an excellent platform for the sort of multi-language systems that are the clear future. Dynamic languages such as Groovy make great coordination languages where the “grunt” computation is in Java. The slides can be found here, but most of the material was based on the code examples. There is a Bazaar branch containing all these at http://www.russel.org.uk/Bazaar/Pi_Quadrature. You can get all the code using the Bazaar Explorer or the command line “bzr branch http://www.russel.org.uk/Bazaar/Pi_Quadrature”.

After my keynote, I did a session Parallelism: The Functional Imperative. This session was a follow up on all the recent interest in functional language, especially Haskell and Erlang. OCaml, Functional Java, Scala and Clojure made an appearance, as did Groovy/GPars. The slides can be found here, but most of the material was based on the code examples. There is a Bazaar branch containing all these at http://www.russel.org.uk/Bazaar/Pi_Quadrature. You can get all the code using the Bazaar Explorer or the command line “bzr branch http://www.russel.org.uk/Bazaar/Pi_Quadrature”.

[09:45] (0 Comments)

Last evening I gave a presentation on Groovy to the BCS Advanced Programming Specialist Group. After a short introduction to the history of Groovy in order to set the scene, the session was devoted to showing example code using the Groovy Console. We only had to do some scripting, we didn't really get on to writing classes. It really was a whirlwind introduction.

The session went well. At least I thought it did :-) The organizers must have done as well as they have already asked me if I would do a session on GPars next year.

The slides I used are here, and the start point source code of various examples is here.

[09:10] (0 Comments)

I did a tutorial on SCons last Tuesday as the pre-cursor to the UKUUG Spring 2010 conference. I thought the tutorial went well, and I definitely enjoyed the conference. As the last session of the conference there were lightning talks, and I gave one: Lightning Strikes. The slides probably won't mean much unless you were there but . . .

[11:07] (0 Comments)

I am doing a "webinar" about Groovy and GPars for the BCS Distributed and Scalable Computing Specialist Group at 2010-03-17T17:30+00:00. See here.

From the announcement mailed out to group members and others:

[20:36] (0 Comments)

I will be giving a 1-day SCons tutorial on 2010-02-23 the day before the UKUUG Spring 2010 conference, Manchester Conference Centre. See http://spring2010.ukuug.org/ for more details.

[15:51] (0 Comments)

As a new year pressie to myself I bought a Canon EOS 5D Mark II (*). The camera is superb – unlike the weather which is all slush rather than the more photogenic snow. I tried getting support software for the USB link from Canon's site. They advertise Linux and Unix on the drop down menus, leading to an expectation that they have Linux and Unix versions of all their software tools for the camera. Wrong. They only have Windows and Mac OS X variants of their software. This means I can't do the firmware upgrade unless I get a Windows or a Mac OS X machine. Extreme disappointment.

When asked, Canon report that there is no expectation of support for Linux at this time. Sad as well as disappointing.

(*) If anyone wants a well-used, but still totally working, Canon EOS 10D with battery grip, 4 batteries and charger, email me to negotiate. Also I have a Tamron 28–200 lens with hood, Skylight 1A, circular polarizer, and UV filter also in need of a good home.

[09:31] (0 Comments)

JAX London 2010 is being held 2010-02-22 to 2010-02-24. There is a track on Groovy and Grails. I have been asked to do sessions on Gant and GPars. Should be fun.

[13:30] (0 Comments)