On the design of distributed programming models

August 17, 2017 ~ Adrian Colyer ~ 2 Comments

On the design of distributed programming models Meiklejohn, arXiv 2017. Today's choice is a lovely thought piece by Christopher Meiklejohn, making the case for distributed programming models. We've witnessed a progression in data structures from sequential (non-thread safe) to concurrent, to distributed (think CRDTs). Will the same thing happen with our programming models? And if ... Continue Reading

Writing parsers like it is 2017

August 15, 2017 ~ Adrian Colyer ~ 15 Comments

Writing parsers like it is 2017 Chifflier & Couprie, SPW'17 With thanks to Glyn Normington for pointing this paper out to me. Earlier this year we looked at 'System programming in Rust: beyond safety' which made the case for switching from C to Rust as the default language of choice for system-level programming. Today's paper ... Continue Reading

System programming in Rust: beyond safety

June 14, 2017 ~ Adrian Colyer ~ 20 Comments

System programming in Rust: beyond safety Balasubramanian et al., HotOS'17 Balasubramanian et al. want us to switch all of our systems programming over to Rust. This paper sets out the case. Despite many advances in programming languages, clean-slate operating systems, hypervisors, key-value stores, web servers, network and storage frameworks are still developed in C, a ... Continue Reading

Typed Architectures: architectural support for lightweight scripting

May 22, 2017 ~ Adrian Colyer ~ 3 Comments

Typed Architectures: architectural support for lightweight scripting Kim et al., ASPLOS'17 JavaScript, Python, Ruby, Lua, and related dynamically typed scripting languages are increasingly popular for developing IoT applications. For example, the Raspberry Pi is associated with Python; Arduino and Intel's Galileo and Edison are associated with JavaScript. In these constrained hardware environments though, using JITs ... Continue Reading

Programming with Abstract Data Types

October 20, 2016November 11, 2019 ~ Adrian Colyer ~ 3 Comments

Programming with Abstract Data Types Liskov & Zilles, ACM SIGPLAN Notices, 1974 This is paper 6/7 from Liskov's list, and it's by Barbara Liskov herself. What an enormous impact this paper has had on how we program today. Has there been any single advance in programming languages since this work (42 years ago) which has ... Continue Reading

Protection in programming languages

October 19, 2016November 11, 2019 ~ Adrian Colyer ~ Leave a comment

Protection in programming languages Morris Jr., CACM 1973 This is paper 5/7 on Liskov's list. Experienced programmers will attest that hostility is not a necessary precondition for catastrophic interference between programs. So what can we do to ensure that program modules are appropriately protected and isolated? We still need to allow modules to cooperate and ... Continue Reading

Hierarchical program structures

October 18, 2016November 11, 2019 ~ Adrian Colyer ~ 4 Comments

Hierarchical Program Structures Dahl and Hoare, 1972 We continue to work our way through Liskov's list. 'Hierarchical program structures' is actually a book chapter, and is notable for defining a 'prefix' mechanism that looks awfully like a form of class inheritance, paving the way for hierarchical program structures (i.e. Class hierarchies). The main takeaway for ... Continue Reading

Go to statement considered harmful

October 13, 2016November 11, 2019 ~ Adrian Colyer ~ Leave a comment

Go to statement considered harmful Dijkstra, CACM 1968 It sounds like the Heidelberg Laureate Forum this summer was a great event. Johanna Pirker was there and took notes on Barbara Liskov's talk, including 7 papers that Liskov highlighted as 'must reads' for computer scientists. I'm sure you've figured out where this is going... for the ... Continue Reading

Why Functional Programming Matters

September 14, 2016November 11, 2019 ~ Adrian Colyer ~ 7 Comments

Why Functional Programming Matters John Hughes, Research Topics in Functional Programming, 1990 (based on an earlier Computer Journal paper that appeared in 1989). 1989/1990 must have been a fairly dark time to be a functional programmer. Object-oriented programming was rising in prominence and the dream that industry would pay attention to functional programming looked like ... Continue Reading

Ownership and Reference Counting Based Garbage Collection in the Actor World

February 18, 2016 ~ Adrian Colyer ~ Leave a comment

Ownership and Reference Counting Based Garbage Collection in the Actor World - Clebsch et al. 2015 Yesterday we looked at the reference capability based type system of the Pony language. Pony is a safe (data race free), fast actor language. Today we're looking at another aspect of how Pony achieves its speed and clean programming ... Continue Reading

the morning paper

a random walk through Computer Science research, by Adrian Colyer
Made delightfully fast by strattic

Programming Languages