“Meaningful distinctions deserve to be maintained.” — Errett A. Bishop
Likewise, memorable quotations deserve to be read in context. In this spirit, I am happy to present the above “basic principle” in its context: Schizophrenia in contemporary mathematics (pdf)
Read on for a brief summary.
Christos Dimoulas is currently teaching a “History of Programming Languages” class at Harvard. The class is, as Christos writes, “definitely not about this”; instead, each meeting is a deep examination of a single, mature research topic, in terms of three to five key papers from the literature.
On Monday, I presented “the History of Actors” for the class. I’ve made the written-out talk notes and an annotated bibliography available here.
In the early days of the famous Emacs/Vim debates, Emacs was often ridiculed for its bulkiness (Eight Megabytes-of-RAM And Constantly Swapping, etc.). The computational power of our computer has grown much faster than Emacs’ bloat: it takes exactly one second to load on my machine. However, our workflows have also changed, and my workflow implies frequently starting new text editors — on each git commit for example, or when I use a Firefox extension to edit a textarea content in a proper editor.
In this blog post, I describe how to use
emacsclient to reuse an existing Emacs process when creating a new editor window, which reduces editor startup times from 1s to 0.150s on my machine.
If you are interested in learning about the internals of the CompCert C compiler but would rather not read its source code, this post is for you.
The next edition of the New England Programming Language Seminar (NEPLS) will be held on Friday, October 7th at Northeastern University. Organizers are Gabriel Scherer and Max New. See you there!
Performance matters for software systems, but performance is not always easy to measure. At the PRL we recently had a scare with some unreliable measurements. Here is the story.
Racket is excellent for incrementally growing scripts into full-fledged programs.
This post steps through the evolution of one small program and highlights the
Racket tools that enable incremental advances.
This is part 3 of my tutorial for using the Racket FFI. You can find part 1
and part 2
In this post, we will experiment with some low-level operations with pointers,
union types, and custom C types. The main takeaway will be the custom C types,
which let you define abstractions that hide the details of the C representation
when manipulating data in Racket.
This is part 2 of my tutorial on using the Racket FFI. If you haven’t read
part 1 yet, you can find it
Update: part 3 is also now available
Part 2 will continue with more Cairo examples. In this installment, I plan to
go over some more advanced FFI hacking such as handling computed argument
values, custom return arguments, and using C structs.
Update: this post is now part of a series. Part 2 is
and part 3 is
I’ve seen several people ask for a tutorial on Racket’s foreign
function interface (FFI), which allows you to dynamically load
C libraries for use in Racket code. While I think the
for the FFI is quite good, it is a lot of information to process and
the overview examples may be tricky to run for a beginner.
With that in mind, this blog post will provide a step-by-step tutorial
for Racket’s FFI that requires minimal setup. All that you will need to
follow along is a copy of Racket and ideally a DrRacket window.