A few things have been going on, I'm reviewing patches for Emacs 30.1 to be readily available in Guix, building a native PDF reader for Emacs (which is currently crashing :/), solving AIME and AMO problems in Lean, getting used to wgpu-rs for work, and slowly starting work on a SymPy alternative in Haskell. Also, a website/blog for this channel is in its final stages, after being ready, this channel would merely crosspost from the website with RSS.

More importantly, me and two fellow Guix/Guile developers have been working on writing a general-purpose build-system from scratch in Guile Scheme. This was born out of a collective frustration for having to use the typical Autotools and Make in GNU software. When working on something like Guix using Guile and having to rely on Make, it is disappointing to say the least. I originally considered it "too radical" of an idea, but after having enough brainstorming, we realized it is indeed possible to have something like this, in fact one of the developers working with me has been using something similar for his projects since last 2-3 years.

The current prototype of the build tool (we're yet to settle on a name) is very much well-suited to build C/C++ packages with ease, all without ever leaving the comfort of Scheme. Below is the time it takes to get a fresh build of st (suckless terminal`:

 time ./project-repl --emulate-make-flags all
  CC  /mnt/code/src/st-guile/x.o
  LINK  /mnt/code/src/st-guile/st

real  0m0.189s
user  0m0.257s
sys  0m0.067s

And this is what it takes for GNU Make to do the same:

$ time make
gcc -I/usr/X11R6/include  `pkg-config --cflags fontconfig`  `pkg-config --cflags freetype2` -DVERSION=\"0.9.2\" -D_XOPEN_SOURCE=600  -O1 -c x.c
gcc -o st st.o x.o -L/usr/X11R6/lib -lm -lrt -lX11 -lutil -lXft  `pkg-config --libs fontconfig`  `pkg-config --libs freetype2`

real  0m0.292s
user  0m0.259s
sys  0m0.025s

As you can see, even after we get:
- the extensibility of a lisp-based build-system,
- an actual REPL for the specific project,
- a containerized development environment for the project independent of your OS, and
- Easily customizable TUI ála Emacs

you still have the same, if not faster, speed as make. It is going to remain in prototype phase as we experiment few things and choose certain abstractions, but the Proof of Concept is right here!

P.S: How does the name Goblet sound? It's an acronym for GNU's Orchestration for Building Libraries and Environment Transformations.

The program is given as a flowchart with the nodes identified by labels. Without loss of generality I consider flowcharts with two distinguished nodes: the start node (the one node without an incoming arc) and the halt node (the one node without an outgoing arc). For a correctness proof each label is associated with an assertion.

An assertion is a formula of first-order predicate logic. As such it is restricted to a given vocabulary, which consists of function and predicate symbols and of variables. The variables can be bound or free; only the latter concern us here. The set of assertions that belong to the same flowchart are restricted to the same vocabulary. Whether an assertion is true depends on an interpretation of the function and predicate symbols and on the state (the values of the variables).

To follow a computation by a flowchart one has to know what the current state is and at what node control has arrived.

Maarten van Emden, History of "Structured Programming"

My first remark is that, although the programmer’s activity ends when he has constructed a correct program, the process taking place under control of his program is the true subject matter of his activity, for it is this process that has to accomplish the desired effect; it is this process that in its dynamic behaviour has to satisfy the desired specifications.

Edsger W. Dijkstra, “Letters to the editor: go to statement considered harmful.” (1968)

Nicholas Bourbaki, Elements of the History of Mathematics (1984)

Craig Fraser, Joseph Louis Lagrange's algebraic vision of the calculus (1987)

Donald Knuth in conversation with Peter Seibel.

Peter Seibel, Coders At Work: Reflections on the Craft of Programming (2009)

Stoll, C., “The Curious History of the First Pocket Calculator,” Scientific American (2004)

Programming language design benefits from constructs for extending the syntax and semantics of a host language. While C’s string-based macros empower programmers to introduce notational shorthands, the parser-level macros of Lisp encourage experimentation with domain-specific languages. The Scheme programming language improves on Lisp with macros that respect lexical scope.

The design of Racket—a descendant of Scheme—goes even further with the introduction of a full-fledged interface to the static semantics of the language. A Racket extension programmer can thus add constructs that are indistinguishable from “native” notation, large and complex embedded domain-specific languages, and even optimizing transformations for the compiler backend. This power to experiment with language design has been used to create a series of sub-languages for programming with first-class classes and modules, numerous languages for implementing the Racket system, and the creation of a complete and fully integrated typed sister language to Racket’s untyped base language.

Tobin-Hochstadt, et.al, Languages as Libraries (2011)