Archive of posts with the tag Programming

• Oct 6, 2022: Effortless Language Servers

  Ever since my blog post in 2016, I have wanted a good language server for SOM and Newspeak. Though, I didn’t really have the time to implement more than a few features.

• Apr 9, 2019: Another Decade of SOM Language Implementation

  SOM, the Simple Object Machine, is a little dynamic language designed for teaching object-oriented virtual machine design. It originates in Aarhus, Denmark, and according to Lars Bak, it was implemented in the course of two days by Kasper Lund. They used it back in 2001 for a course at the University of Aarhus.

• Aug 24, 2018: Efficient Deterministic Replay for Actors

  Debugging concurrent systems is pretty hard, and we worked already for a while to make things a bit better. However, a big remaining problem is that bugs are not easily reproduced.

• Mar 13, 2018: How to Design Collection Libraries?

  Programming languages naturally come with a library of containers or collection types. They allow us to easily work with arbitrary number of elements, which is something all major languages care about. Unfortunately, it seems like there is not much writing on how to design such libraries. Even asking a few people that worked for a long time on collection libraries did not yield much of a structured approach to such a central element for our languages. The one major piece of writing we found is the Scala people describing their experience with bit rot and how they redesigned their collection implementation to avoid it.

• Oct 15, 2017: Debugging Concurrency Is Hard, but We Can Do Something About It!

  When we have to debug applications that use concurrency, perhaps written in Java, all we get from the debugger is a list of threads, perhaps some information about held locks, and the ability to step through each thread separately.

• Oct 25, 2016: Cross-Language Compiler Benchmarking: Are We Fast Yet?

  Research on programming languages is often more fun when we can use our own languages. However, for research on performance optimizations that can be a trap. In the end, we need to argue that what we did is comparable to state-of-the-art language implementations. Ideally, we are able to show that our own little language is not just a research toy, but that it is, at least performance-wise, competitive with for instance Java or JavaScript VMs.

• Sep 11, 2015: Why Is Concurrent Programming Hard? And What Can We Do about It? #vmm2015

  Yesterday at the Virtual Machine Meetup, I was giving a talk about why I think concurrent programming is hard, and what we can do about it.

• Jan 27, 2015: Partitioned Global Address Space Languages

  More than a decade ago, programmer productivity was identified as one of the main hurdles for future parallel systems. The so-called Partitioned Global Address Space (PGAS) languages try to improve productivity and explore a range of language design ideas. These PGAS languages are designed for large-scale high-performance parallel programming and provide the notion of a globally shared address space, while exposing the notion of explicit locality on the language level. Even so the main focus is high-performance computing, the language ideas are also relevant for the parallel and concurrent programming world in general.

• Sep 17, 2014: Fork/Join Parallelism in the Wild: Documenting Patterns and Anti-Patterns in Java Programs using the Fork/Join Framework

  Parallel programming is frequently claimed to be hard and all kind of approaches have been proposed to solve the complexity issues. The Fork/Join programming style introduced with Cilk enables the parallel decomposition of problems in a recursive divide-and-conquer style, and on the surface looks very simple with its minimalistic approach of having a fork and a join language construct. But is it actually simple to use? To find out, Mattias started to dig through the Java open source projects on GitHub and tried to identify common patterns. Next week, he will present our findings at PPPJ’14.

• Jul 15, 2014: Why is Concurrent Programming hard?

  In short, I think, it is hard because on the one hand there is not a single concurrency abstraction that fits all problems, and on the other hand the various different abstractions are rarely designed to be used in combination with each other.

• Feb 17, 2014: Towards Composable Concurrency Abstractions

  One of the big questions that came up during my PhD was: ok, now you got your fancy ownership-based metaobject protocol, and you can implement actors, agents, communicating sequential processes, software transactional memory, and many others, but now what? How are you going to use all of these in concert in one application? Finding a satisfying answer is unfortunately far from trivial.

• Nov 14, 2012: Sly and the RoarVM: Exploring the Manycore Future of Programming

  My second talk at Smalltalks 2012 was most likely the reason why the organizers invited me in the first place. It was a slightly extended version of the Sly and RoarVM talk for the FOSDEM Smalltalk Dev Room from the beginning of the year, reporting on the Renaissance Project.

• Feb 5, 2012: FOSDEM Smalltalk Dev Room: Sly and the RoarVM

  Today, FOSDEM featured that first incarnation of a Smalltalk developer room. Unfortunately, FOSDEM is always packed with interesting talks, so, I only managed to attend a couple of talks. Most notably the talk on Spoon.

• Oct 24, 2011: Transitioning to Multicore @SPLASH2011

  And here we go again: SPLASH 2011 has started with its first day of workshops.

• Aug 19, 2011: The Sly3 Programming Language

  The following introduction and analysis of the Sly3 programming language was written by Pablo Inostroza Valdera as part of his course work for the Multicore Programming course of Tom Van Cutsem. The assignment was to write a blog post about a topic of their own choice, and I repost Pablo’s work here with his permission to spread the word about Sly a bit wider. We made his article also available as part of his work for the Renaissance project itself.