Expressions of Change

☰

    All Posts

  1. Homoiconicity revisited

    In which we explore the possible meaning of “Homoiconic” by ignoring all pre-existing definitions and providing one of our own.

  2. Animating history: Implementation

    In the previous article we have seen how we can show animations in the history pane of the editor to subtly illustrate how the construction of different levels of our program relate to each other. Here we provide some notes on these animations are implemented.

  3. Animating history transitions

    We can use animations to show transitions between histories of different part of the program structure when navigating.

  4. Source code published

    The source code of the project is now published on Github under an MIT license.

  5. Talk at the European Lisp Symposium

    Video of the talk at ELS 2018, Marbella

  6. ELS 2018: Paper accepted

    The paper “Clef design: Thoughts on the Formalization of Program Construction” has been accepted for the European Lisp Symposium 2018

  7. Talk at Clojure Meetup

    The Amsterdam Clojure Meetup is “a bunch of Clojure enthusiast who meet every month to discuss every thing Clojure.” I was honored to speak at the celebratory 100th edition of the event.

  8. Don't say “Homoiconic”

    When asked what’s so great about Lisp, many aficionados will say that the language is Homoiconic, and that this property gives it certain magical advantages over other languages. When asked what homoiconic means, however, the answer is often much less clear.

  9. Lambda Days 2018

    Video of the lightning talk at Lambda Days 2018

  10. Expressions of Change in under 15 minutes

    A short video-presentation on Expressions of Change

  11. Constructing S-Expressions

    In Expressions of Change mechanisms of construction are put center stage. The first and most practical application of such methods is the actual construction of s-expressions; an algorithm is presented and its performance characteristics explored.

  12. Catamorphisms and change

    Some recursive functions can be described as catamorphisms; in the context of controlled modification of the input data structure, efficient mechanisms for recalculation are available. This article describes those.

  13. Static Form Analysis

    A first step in the static analysis of our language L is to identify the various special forms as they occur in the s-expression that is our program.

  14. L - A toy language

    Before turning our attention to static analysis we need to define the semantics of the programs under consideration. We do so by describing a small language called L.

  15. Static Analysis - Introduction

    In this project, we put changes to computer programs more central in the programming experience. As a result, the ability to do static analyses is lifted from single programs to the full dimension of any program’s construction. This has some useful applications, which are demonstrated in a series of articles.

  16. Constraints on Replace

    The operation Replace replaces a child node with a new one. This new node is recursively described using a history of changes. In this article we compare two scenarios: in one we impose the constraint that the new history must be an continuation of the history so far. In the other we don’t impose this constraint, which is to say that the new history may be anything.

  17. T-Indices

    The editor presented on this website is an editor of s-expressions that treats modifications to those expressions as first level citizens. This opens up the possibility to reference the children of a given list-expression by their order of appearance.

  18. Git is ignorant by design

    This article explores a very particular problem of Git, namely its ignorance, in some detail.

  19. September status update

    After spending some time on the editor, I have now switched my attention to working on a small Lisp interpreter which takes the editor’s output as its input.

  20. Ship of Theseus

    The ship of Theseus is an ancient thought experiment that poses some questions about the nature of identity of changing objects. In this article we examine the real life implications of this riddle on modeling the world in computer programs.

  21. Lehman's SPE-classfication

    In the 1980 article “Programs, Life Cycles, and Laws of Software Evolution” by Meir Lehman, a classification of computer programs into 3 types (S, P & E) is put forth. This classification forms a useful background against which to understand software evolution.

  22. Hash Consing

    Some operations from our clef take a full history as one of their arguments. In this article we’ll show how this can be efficiently implemented using a technique similar to Hash Consing.

  23. CLIs are reified UIs

    Many of the advantages of Command Line Interfaces can be attributed to the fact that they reify the user interaction: the interaction itself is made into something that’s visible and can be interacted with.

  24. Dijkstra's Mozart

    Approximately two years before his death, Edsger Dijkstra was interviewed by the Dutch television program Noorderlicht. On that occasion he made an interesting comparison between two programming styles, which he characterized as Mozart versus Beethoven.

  25. The Editor - First Video

    A short video of the editor has been posted to YouTube. It can be viewed below.

  26. Introducing the Editor

    The first step towards making expressions of change available in some programming language is to build an editor that can construct them. The first steps towards this editor have been made and are presented here.

  27. Existing tools

    Because dealing with change of the software itself is such a central part of the challenge of software development, a myriad of tools to manage these changes has sprung up. Examples are version control systems, build systems, provisioning tools and package management.

  28. The power of Undo

    The undo command is probably one of the most powerful commands in any document editor. It is hard to imagine an editor without undo to be taken seriously, let alone gain any popularity - be it an editor of text, images, movies or any other kind of document.

  29. Self applicability

    Self applicability is one of the most powerful ideas in computer science. In this article we’ll see how this idea can be applied to Expressions of Change such as Version Control, and how this compares to existing solutions such as Git.

  30. Build once, maintain forever

    The state of the art of running a small website is to build once, manually maintain forever. This burden of maintenance is largely caused by changes in other software, as opposed to changes in our own requirements.