Let's #TalkConcurrency with Sir Tony Hoare

by Erlang Solutions

Back in November, we took a trip to Cambridge University with Francesco Cesarini to arrange a panel discussion revolving around concurrency. For the panel, we enlisted the help from the best; Sir Tony Hoare, Joe Armstrong, and Carl Hewitt! All pioneers in the concurrency field.

What followed was a fantastic discussion about how concurrency models have developed, and where they will be heading in the future.

We also interviewed Sir Tony Hoare personally about his work with concurrency that has spanned across 50+ years. Take a look for yourself!

About Sir Tony Hoare

Computer scientist Sir Tony Hoare FRS FREng is well-known for developing the sorting algorithm Quicksort in 1959/1960, which is a systematic method for placing the elements of an array in order. It is the most commonly used algorithm for sorting due to its speed, especially when compared with its related competitors. Quicksort is a comparison sort and sometimes referred to as “partition-exchange sort”.

In addition to Quicksort, Sir Tony has a list of other achievements under his belt; Quickselect, Hoare logic, Communicating Sequential Processes and Structured programming to name a few. In addition, he has won numerous awards and honours based on his brilliant work within the Computer Science field! This includes SIX Honourary Doctorates over the years and his Knighthood back in 2000. He is now the principal researcher at Microsoft Research in Cambridge and Emeritus Professor in the Department of Computer Science at Oxford University.


Tony Hoare: Hi, I’m Tony Hoare. I’m an honorary member of the Cambridge University Computing Laboratory, where this interview is being recorded.

I’d like to tell you something about how I got interested in concurrency as a subject from our research, and what the influences were in the development of my thinking about this subject.

In 1960, I got my first job as a programmer in a small computer manufacturer and led a small team towards the implementation of a programming language - a new programming language at that time called ALGOL 60. The project was successfully delivered. After that, the company decided that it would need an operating system for its new computer, and I was put in charge of its design and its development.

Unfortunately, the operating system, two years later, turned out to be undeliverable. It was just terribly slow. I put the cause of my failure down to the fact that I didn’t understand concurrency. This was one of the motives which led me, in 1968, to change my profession and join a university as professor of computation at the Queen’s University in Belfast.

One of the objectives of my research I made was the exploration of what concurrency really meant and how to tame it. In 1965, I had met Ole-Johan Dahl and Kristen Nygaard, who were the designers of a language called Simula 67, which had an enormous influence on the propagation of ideas of object-oriented programming, and it impressed me greatly. They had a concept of timing which was implemented as a simulated time train in the way that is completely standard nowadays. That gives a framework within which one could explore the meaning of real concurrency.

After I had joined the Queen’s University Belfast, I teamed up with a colleague, Jim Welsh, to design a new version of Pascal; a language which is then current for implementation of compilers and other software, to design a new version which would import some part of the class structure of Simula 67. It was called Pascal Plus. Jim Welsh wrote its compiler and tested it and delivered it. It’s rather a splendid exercise because he only ever found one fault. He found one fault in the compiler that he’d written. It was a no-reference fault. Otherwise, he had implemented the language completely from its specification without testing it, any part of the implementation, before putting it all together and compiling it.

The only other Pascal compiler that was in existence at that time produced a running compiler, which we used. I used that compiler to implement an idea which was based on the Simula class concept called the monitor. I published an article about it. The monitor’s essentially a single object which would accept method calls with an object with many available methods and would accept calls from many concurrent callers. It was protected automatically by an exclusion mechanism so that the calls could not be simultaneous.

Using that language, I wrote, with the help of a colleague Mike McKeag, a thing which we called a structured operating system, and gave a course on the structured operating system at a summer school in Marktoberdorf in Bavaria.

The director of the summer school was one Edsger Dijkstra, well known worldwide, and a very good friend of mine. He told me after I’d given the course of lectures, that he thought maybe I had a good idea here, which from Edsger Dijkstra, was high praise. That he said the notation is terrible, we need to design a different notation. When we had a free afternoon, we went and sat in our hotel garden and talked about the design of what eventually turned out to be CSP, where there were many, many objects, processes running concurrently and communicating with each other by message passing rather than just by method calls. That was crucial.

After this discussion with Edsger, I worked continuously. I made this my most interesting research project. I worked on it for three years before the publication of an article describing my ideas under the title, Communicating Sequential Processes, published in the communications in the ACM. It had taken me three years to write that article, and one of the years was full-time research. Perhaps it is was a just reward and that it was a very widely referenced article, and still is gathering references, I believe about 2,000 references a year. I still felt I needed to have an exact definition of what the semantics of this language was sufficiently complete and precise that I could use it for specifying and proving the correctness of programs written in this language.

In 1977, I moved to Oxford University where I met Dana Scott and learnt something about denotational semantics as a way of describing the meaning of programming languages. I slightly adapted his semantics into a trace semantics and worked out a really remarkably simple semantics for CSP of a what I might call a conditional correctness variety. It was a very good approximation, but it didn’t allow the proof of termination. It assumed, and it didn’t properly model deadlock as a phenomenon which could not be recovered from. Fortunately, I had two very good students at Oxford, mathematics graduates, Bill Roscoe and Steve Brookes. I got them to help me with working at the theory of this language, which they did very successfully and republished an article in the– Sorry, I’ve forgotten where. Both Roscoe and Brookes have worked, like I have, for a long period on pursuing their research into the theory of CSP. Bill Roscoe, in particular, has published two substantial monographs on the subject and has built it into an automatic tool which will help in getting correct programs written in a CSP language. He extended the language very usefully, and he implemented it many times, improved it enormously through a period of about 35 years of development. This is now, I think, one of the fastest proof-checkers for concurrent programs that exist in the world today. The world today is, I think, where I will leave this story.

Thank you very much.

[00:10:13] [END OF AUDIO]

If you like this, you may like Francesco’s Retrospective; detailing the last 20 years of open source Erlang! Take a journey through the Ericsson Labs up to present day.

Go back to the blog


Thank you for your message

We sent you a confirmation email to let you know we received it. One of our colleagues will get in touch shortly.
Have a nice day!