Tom Van Cutsem Me explaining the Unix Game to visitors at Bell Labs’ Unix50 event, October 2019

You’ve reached the blog of Tom Van Cutsem. I’m an associate professor of Computer Science at KU Leuven, within the DistriNet research group of the Computer Science department. My research interests are secure distributed computing, decentralized systems and smart contracts.

I am also a scientific advisor to Bell Labs, the research arm of Nokia (yes, that Bell Labs). Prior to (re)joining academia, I led the Software Systems research department at Bell Labs, focusing on trusted data sharing and AI pair programming solutions.

Prior to joining Bell Labs, I was a CS professor at the Software Languages Lab of the Vrije Universiteit Brussel. I also did my doctoral research there on AmbientTalk, a distributed programming language designed for mobile ad hoc networks, which got featured in MIT Technology Review.

In 2009/2010 I was Visiting Faculty at Google in Mountain View (US) where I got involved in the standardization of JavaScript (aka ECMAScript). My biggest claim to language design fame is the creation of the JavaScript Proxy API together with Mark S. Miller, now shipping in all major browsers.

I’m passionate about getting young people exposed to the art of programming. I’m the creator of The Unix Game, a coding game I built at Bell Labs on the occasion of the 50th anniversary of Unix. I’ve also been quite active in organizing programming contests: I was a jury member and organizer of the Flemish Programmign Contest, a regional ACM ICPC-inspired programming contest for students and professionals. For a time I was also a jury member of the Belgian Olympiad in Informatics.

Programming Languages

Programming languages, their history, their design and their implementation are my favourite part of computer science. I enjoy reading about the genealogy of programming languages, how ideas from one language find their way into other languages, and so on. I am particularly fond of Scheme, Self, Smalltalk, Javascript, Prolog, Ruby, Clojure and Erlang. If you want to read some of my musings, see this essay on why I do research on programming languages.

I’ve been inspired the most by the following language designers:

  • Mark Miller, creator of E, for showing that security and modularity are two sides of the same coin.
  • Rich Hickey, creator of Clojure, for clearly articulating the differences between state and identity.
  • Doug Crockford, discoverer of JSON, for showing that less can be a lot more.
  • Dave Ungar and Randy Smith, creators of Self, for stressing the power of simplicity.
  • Alan Kay, creator of Smalltalk, for stressing uniformity.
  • Rob Pike, creator of Limbo, Plan 9 and Go, for reminding me of the power of CSP-style concurrency.
  • Joe Armstrong, creator of Erlang, for showing that actors can be damned practical for building robust software.

One of the best talks on the history of computing I came across is a talk by Doug Crockford titled The Early Years where he describes the major influences on Javascript. A more whimsical treatment of the history of programming languages is Guy Steele and Richard Gabriel’s anniversary talk 50 in 50.

lambda Power to the lambda!
In its semantic structure Scheme is as closely akin to Algol 60 as to early Lisps. Algol 60, never to be an active language again, lives on in the genes of Scheme and Pascal. It would be difficult to find two languages that are the communicating coin of two more different cultures than those gathered around these two languages. Pascal is for building pyramids -- imposing, breathtaking, static structures built by armies pushing heavy blocks into place. Lisp is for building organisms -- imposing, breathtaking, dynamic structures built by squads fitting fluctuating myriads of simpler organisms into place. The organizing principles used are the same in both cases, except for one extraordinarily important difference: The discretionary exportable functionality entrusted to the individual Lisp programmer is more than an order of magnitude greater than that to be found within Pascal enterprises. Lisp programs inflate libraries with functions whose utility transcends the application that produced them. The list, Lisp's native data structure, is largely responsible for such growth of utility. The simple structure and natural applicability of lists are reflected in functions that are amazingly nonidiosyncratic. In Pascal the plethora of declarable data structures induces a specialization within functions that inhibits and penalizes casual cooperation. It is better to have 100 functions operate on one data structure than to have 10 functions operate on 10 data structures. As a result the pyramid must stand unchanged for a millennium; the organism must evolve or perish.
- Alan Perlis, from the foreword of the book Structure and Interpretation of Computer Programs by Abelson and Sussman.