Cat's Eye Technologies: New Developments

Note, this feed dates back to 2019. For older news items, please see the Archived News Items article.

Release of version 0.4 of Eqthy

A new version of Eqthy has been released! Not only does this version (version 0.4) have one less crippling bug in it than it did previously (thanks to Proloy Mishra), it also allows Eqthy documents to be embedded in Markdown, and to build upon other Eqthy documents in a natural way (using Markdown links to indicate dependencies). It also ships with a greater selection of theories and more theorems (with, again, thanks to Proloy Mishra for contributing these.)

Fountain 0.5 released

Fountain is a grammar formalism that can both efficiently parse and efficiently generate strings in context-sensitive languages. And now, with the release of version 0.5, it finally supports a feature that you would certainly expect from a grammar-based string generator; so much so that it was already coded in Fountain itself by Charles Horn; and that feature is: it can, at long last, generate a randomly-selected string. All you need to do is give it a non-deterministic grammar and a random seed to use. Then, when processing a non-deterministic part, the list of choices that will be collected to be used during backtracking, will be scrambled before proceeding.

Chainscape, an exploration of the algebraic properties of Markov chains

For NaNoGenMo 2019, we implemented a text generation method described as "taking the intersection of a Markov chain and a finite automaton", in order to get a random text generator that also obeyed some of the rules of punctuation. More recently we wondered: can this be generalized? Can one take the intersection of two Markov chains? Or their union?

For NaNoGenMo 2023 we undertook to answer this question and, more generally, explore the algebraic properties of Markov chains. This project was (eventually) called Chainscape and it culminated in

Release of version 0.6 of ellsync

ellsync is an opinionated poka-yoke for rsync, for the primary purpose of maintaining a backup system.

Version 0.6 has been released, which brings with it two major features.

First, since it is occasionally useful, but also quite dangerous, to run the sync in the opposite direction from usual, ellsync now supports it by means of a --reverse command-line option. The danger is mitigated by insisting certain files exist in the (altered, non-usual) destination directory before ellsync will begin executing the sync.

Second, as a more robust and flexible alternative to the --thorough option, the verify subcommand has been added. This uses diff to compare both sides of the backup stream for discrepancies, and operates in a resumable manner (the manifest of files to be verified is written to a text file, and ellsync can be directed to pick up in this text file where it left off.)

An implementation of Gemooy in Lua

We've written another implementation of Gemooy, in Lua this time. We'd like to call it the second implementation, but it's actually the third implementation, because there is not only the primary implementation in JavaScript, there was also an implementation in Java as part of the now-defunct yoob distribution.

Why rewrite it in Lua? A large part of the reason is because, while Gemooy is shipped as part of The Cat's Eye Platform, it could not, until now, actually be executed there, because the only implementation was in JavaScript and no JavaScript implementation is included in The Platform.

(This is the same situation Etcha and Wunnel are in, so it would be reasonable to expect to see second implementations in these two sometime in the future as well.)

Strelnokoff is Turing-Complete

The esoteric programming language Strelnokoff was released in 2001 in the form of an undocumented and incomplete interpreter written in Perl and an example program that prints "Hello, world!".

A year or two ago I realized this was a somewhat sorry state, and put it on my TODO list to do something about it. Like, at least add documentation or something.

The thing is, for 23 years, no one had bothered to try show that it was Turing-complete or not. Well, the general feeling was that it is obviously Turing-complete, or at least it would be if it supported arrays, because it works mostly like Thue, and Thue is Turing-complete, so there is not really any reason to doubt it, so why bother.

But since I was intent on updating it anyway, I took a swing at it. It wasn't quite as simple as that, because it's restricted in a way Thue isn't: a (nondeterministically-selected) instruction can only update one variable, before the next instruction is selected (nondeterministically). So a way to encode the needed state information into a single variable was needed. But after that, it all came together.

In the process of doing this, the language was documented and its semantics were clarified (and there still are no arrays). Also, a second implementation was written, in Lua. And these materials are available in version 1.1. of the Strelnokoff distribution.

Gradual adoption of REUSE 3.0 Convention

The thing with hosting code on a non-profit code host operated in the public interest is that they are (completely justifiably) selective about the license that said code is distributed under. GitHub doesn't stop anyone from uploading their junk accompanied by no license whatsoever. That's not the end of the world but it's, generally speaking, a bad habit to get into. Do people want to just admire your brilliant code? No, they want to fix it and improve it and build on it, and they can't really do that without you giving them license to do so. And if you're going to give them that license you might as well do it by some formally recognized and commonly accepted method; and that is what open-source licenses are for.

So. In our migration to Codeberg we've cast an eye over the licenses under which Cat's Eye Technologies has been distributing its software, and tried to apply them more consistently. This is ongoing.

By a happy coincidence, we discovered while undertaking this undertaking REUSE, which is a convention for declaring licensing information in a fine-grained fashion. While we don't agree with every single plank of their platform, we do have a distinct need that matches this; that is, we have lots of repositories whose contents are not all under the same license. And the REUSE convention works really well for identifying which file is under which license. A lot better than trying to describe it in English in the README, anyway.

Having license information identified in this fine-grained way also permits (and, we hope, encourages) redistribution and recombination at a similarly fine-grained level. This has particular promise for bundled dependencies, especially when those dependencies would otherwise be awkward to obtain and install.

So we have begun to adopt it. (Version 3.0 of it, specifically.) It has been especially useful in repositories like Chrysoberyl, The Dossier, and The Dipple, to unambiguously state what the licensing terms of each file are.

The adoption continues.

Migrated from GitHub to Codeberg

Even though this newsfeed hasn't been updated since July of last year, we actually did a number of interesting things in the second half of 2023. But, they were overshadowed by something that was not all that interesting, but something we felt had to be done: stop using GitHub.

There was no one issue causing this; it was an accumulation of really unimpressive turns of events. The final analysis, though, is that the sheer amount of irony behind an open-source code host based on an open-source distributed version control system becoming "too big to fail" -- which it clearly has become -- is simply unsupportable.

So, when I say "stop using GitHub" I of course mean "as far as is humanly possible". Insofar as what Cat's Eye Technologies produces is open-source, I can't actually prevent anyone from uploading it there. So the immediate manifestation of "stopping using GitHub" consists in (a) not visiting the site if I don't have a very good reason to, (b) not hyperlinking to content on GitHub if there is any other option, and (c) promoting viable alternatives, such as what we're now using: Codeberg.

Codeberg (codeberg.org) is a public code host running open-source Forgejo software, operated by Codeberg e.V., a non-profit foundation. It is free to use for open-source projects.

Cat's Eye Technologies can be found on Codeberg at https://codeberg.org/catseye/. The majority of our git repositories have been migrated over, and development continues on them there.

Meanwhile, our repositories on GitHub will serve as mirrors, but these will not be updated regularly, and may eventually be decomissioned. We encourage you to update your bookmarks.

Whothm has a new online installation

Cat's Eye Technologies hasn't implemented many things in Java, but it has implemented a few, and when it has released them, the final product has tended to be a Java Applet. Nowadays, of course, the Java Applet form is as dead as a doornail. Deader'n' the dodo. Wouldn't "voom" if you put fifty thousand volts through it. You get the picture.

So our Java Applets, what we had to do, see, was to put them on a sort of life support by converting them into JNLPs. But JNLPs are clunky and can't really be said to "run on a web page" given that you need to have Java installed locally and your browser needs to be taught that that's what "JNLP" means.

So we are undertaking the (slow) process of converting the remaining JNLPs into forms that can be said to "run on a web page".

Part of this has been discontinuing some online installations that run on Java-based emulators of old computers. So if you want to try Bubble Escape 2K or Apple Befunge in your web browser, you can view their entries on the Internet Archive.

But more excitingly, there is a new implementation of Whothm, this one written in Lua instead of Java. So not only does it run in your web browser (thanks to Fengari), it will also run on the command line (which the Java version has never supported, it being GUI-only).

Fountain, a grammar formalism for both parsing and generating CSLs

We present Fountain, a grammar formalism for context-sensitive languages. Fountain strongly resembles an attribute grammar, but supports the following properly: from a single grammar, strings may be both efficiently parsed and efficiently generated, with a minimum of "programming" (i.e., fiddly detail work to support the efficient implementation, rather than to merely describe the grammar structure).

To the best of my knowledge, there are no existing attribute grammar systems with this property; most are oriented towards efficient parsing only.

The current released version of Fountain is 0.3; after the two initial releases, it's at a point where it could be used for simple applications of the idea that originally spawned it.

Which was, incidentally, NaNoGenMo 2022. I wanted to write a novel generator that could also parse the novel that it generated, and I wanted to write it in a non-ad-hoc way. I soon realized that if it was written as a definite clause grammar in a logic programming or relational programming language, these goals would be satisfied. However, I soon again realized that that approach doesn't scale up to 50,000 words -- not without objectionable amounts of "programming". Thus the path towards Fountain was taken, passing through relwrite and Parc along the way.

Version 0.5 of The Platform released

On May 19, 2023, version 0.5 of The Cat's Eye Technologies Platform was announced.

This is 6 years to the day since version 0.4 was released. What could be the explanation for such a long pause?

It's pretty straightforward actually. Python 2.x reached end-of-life. Newer projects developed by Cat's Eye Technologies in Python used Python 3.x. And I didn't want to include both Python 2 and Python 3 on the The Platform image.

Thus began the arduous journey of upgrading every Cat's Eye Technologies project written in Python, from Python 2 to Python 3.

For some of them, it wasn't that bad. For others, it was pretty unpleasant. Indeed, there was one -- Tamsin, if you must know -- that is so built around Python 2 assumptions, that it was deemed not worth it to convert it.

But in the end we did it. And in the meantime we accumulated a number of other projects. And we put them all onto a NetBSD 6.1.5 image, and we got them all to work, and we simplified a couple of things in the process.

You can find a pre-built image of The Platform 0.5, and instructions for using it, on the Internet Archive here:

and from that page you can download the image directly, or via the torrent.

Parc: a series of experimental, ultra-simple parser combinator libraries

Parc started as "the simplest parser combinator library that could possibly work". Written in Haskell, no fancy types, fits on a page.

It was followed by a series of experimental variations on the theme. These built up to having a parser combinator library (called "ParcConsume" here) that is putatively able to parse all context-sensitive languages (CSLs), but not any language more complex than a CSL.

The driver for formulating ParcConsume was a number of observations made during NaNoGenMo 2022 about definite-clause grammars (DCGs), primarily that they can express languages more complex than the context-free languages (CFLs), but they are not restricted in their complexity beyond that (i.e. one can, in Prolog, add clauses to a DCG that make it Turing-complete). ParcConsume is an attempt to provide a grammar formalism with a similar ability to go beyond the CFL, but with more restricted complexity. (Parsing CSLs is a PSPACE-complete problem -- and PSPACE is still an immensely large complexity class, but it is at least not Turing-complete.)

Release of Eqthy 0.2

Version 0.2 of Eqthy has been released. The following small improvement to the language has been made: the variables in an axiom or previously-proved theorem can be renamed when applying it in a step. This adds a few lines to the implementation of the proof checker, but allows proofs to be simpler. Error messages in the proof checker have also been improved somewhat, and more example proofs have been included in the distribution (namely proofs in Boolean Algebra and Combinatory Logic).

Some long-overdue updates to Burro

Burro is a brainfuck-inspired programming language where the set of programs form a group (the algebraic structure from group theory); in particular, for every program there exists another program which, when concatenated to the first program, annihilates it.

Version 2.0 revision 2003.0225 of the Burro distribution has been released. There have been no changes to the language, but several other significant updates have been made. Notably,

Eqthy, a formalized language for proofs in equational logic

Eqthy is a formalized language for proofs whose design attempts to reconcile simplicity of implementation on a machine with human usability. Each line gives an equation which is derived from the equation on the previous line, using only the rules of equational logic along with any previously defined rules of inference or proved theorems.

This, the first release of the Eqthy distribution (Eqthy 0.1), includes a description of the language, a proof checker called eqthy written in Python 3, and a number of example proofs (including a proof of the Socks and Shoes theorem in group theory, and a simple proof in Propositional Algebra).

relwrite, a tool for relating strings to strings

Last year, like most years since 2013, Cat's Eye Technologies planned to produce something for NaNoGenMo. The year 2022 was, actually, the first year I entered and failed to complete anything. The reasons for this were simple, and probably not uncommon: my plans were too ambitious, and were difficult to scale back to something modest enough to be completable in one month. So it goes.

What I did produce, along the way, is a tool called relwrite. Given a grammar and an input string, relwrite will find a set of output strings that relate to the input strings, either by parsing the input to obtain a nonterminal, or by generating a new string of terminals, at the user's choice.

One thing that makes this interesting is its generality. The input grammar doesn't have to be context-free; it can be literally anywhere in the Chomsky hierarchy.

And this poses complications. relwrite can be instructed to perform a naive breadth-first search for all the outputs that the input could rewrite to. But since that is an infeasibly large space to traverse, it supports a more sophisticated beam search algorithm, to aggressively trim down the set of possible parses (or generations), to allow it to find at least one of a desired length.

Release of Samovar 0.5

A new version of the Samovar distribution has been released. While there are no changes to the Samovar language, the reference implementation (samovar, written in Python) has some significant updates.

Notably, alongside the existing stochastic generator (which just performs random walks through the event-space in the hopes of connecting the initial state of the scene to a satisfactory final event of the scene) version 0.5 of samovar supports two additional generation strategies:

Some mildly humorous examples resulting from applying these two strategies to chapters of The League of Extraordinarily Dull Gentlemen are presented in this gist: "The League of Efficiently Dull Gentlemen".

Lariat: A Total ADT for Proper Lambda Terms

Y'know what? Over the years, I've designed lots of strange small programming languages, but I never implemented the lambda calculus. Until now.

And I only did it as a test case for an abstract data type representing lambda terms.

And I spent quite some time working on said abstract data type, trying to make something that works, in my opinion, nicely. The result being something that is total, in the sense that all operations are always defined, and that represents only proper lambda terms -- improperly bound variables cannot be introduced.

And I'm not even entirely sure anymore why I wanted to formulate said abstract data type for lambda terms. I believe it may have had something to do with macros.

Even though I dislike macros, and avoid them like the plague in my own code.

Well, that's how much sense my life makes.

Anyway, Lariat.

Philomath: Write proofs in ANSI C

Ever had an urge to write that natural deduction proof you're working on directly in a classic systems programming language like ANSI C? Well, look no further! Philomath is an LCF-style theorem prover for propositional logic in a natural deduction system, written in ANSI C. Values of type struct theorem represent proved statements, while functions that take struct theorems as arguments and return a new struct theorem value, implement rules of inference. Your proof-program includes the header file theorem.h, which only exposes the declaration of struct theorem, and not its definition; in this way, you can be confident (in ANSI C) that any struct theorem your proof-program produces indeed represents a theorem with a valid proof, and not just something you made up. In ANSI C. Smashing, no?

Feedmark 0.13 and Falderal 0.14 released

Two releases of two of Cat's Eye Technologies' formats (and associated tools) have been made.

The latest version of Feedmark, a structured subset of Feedmark designed to support curation and newsfeeds, is now version 0.13.

The latest version of Falderal, a format for writing literate test suites for programming languages, is now version 0.14 "Jean Baptiste Point DuSable Lake Shore Drive". (Falderal versions are named after notable locations in the Chicagoland area.)

Both of these formats have tools written in Python, and these packages are both available on the Python Package Index, at Feedmark and Falderal respectively.

Recent updates to the ZOWIE distribution

This year, a typo was found in the specification of our esoteric programming language ZOWIE -- a language where every instruction, including the structured "repeat" loop, is memory-mapped. (Thanks Sgeo!)

From this we decided it would be ideal if there was a second implementation of the language -- the idea being, with three reference materials (the spec and two reference implementations) one could use a "majority rules" approach to divine the canonical behaviour.

(Three cheers for coding theory! Hip hip, hooray! Hip hip, hooray! Hoop hoop, hirray!)

To this end, we wrote a ZOWIE interpreter in Haskell, to go along with the one written in Python.

We considered using this new Haskell implementation as the basis for the online installation of ZOWIE, replacing the current Skulpt-based installation with it. That hasn't happened yet, though; I'm torn between getting rid of the Skulpt one because Skulpt is kind of goony and non-standard, and keeping the Skulpt one because Skulpt is kind of goony and non-standard.

Tandem interpreter installed online

Tandem, our esoteric programming language where string-rewriting rules form a Kleene algebra, has finally had an HTML installation for it established on Cat's Eye Technologies' website. You can try it in your web browser right here.

The Grammatical Rollercoaster that is Dissociated Parse

For NaNoGenMo this year, Cat's Eye Technologies developed a variation on the Dissociated Press algorithm. Instead of working on a sequential list of words as it conventionally does, it was adapted to work on parse trees instead. The result was dubbed Dissociated Parse, and the 50K-word novel The Lion, the Witches, and the Weird Road was generated using it, which you can read online here.

Vinegar, a semi-concatenative language

Vinegar is a new esolang from Cat's Eye Technologies, released in mid-November. It is a "semi-concatenative" language where every operation can fail.

"Semi-concatenative" is supposed to mean that there isn't just the usual implicit "concatenate" program-composing operator, there's also a second program-composing operator, "alternate" (notated explicitly by |).

This second operator is intended to gracefully handle the case where a program operation has failed -- which any of them can.

Lanthorn: `letrec` as syntactic sugar

Lovely language Lanthorn launches.

Look lucidly at its lexical lycanthropy — a leakproof lifting of letrec to let in lieu of lopsided letterbox loads.

A loquacious lucubration in laminar labour for lugubrious laity? It's likely!

Release of Castile version 0.4

After a long time lying fallow, a new version (0.4) of the programming language Castile has been released.

Mainly, I was disappointed that the C-language-generating backend of the compiler was left incomplete. So I completed it. Testing structs for equality was also unimplemented in several backends. So I completed that part of it too.

The language itself has few changes, primarily the tightening of some rules regarding comparing structs.

But significantly, the language project has been re-focused. The language is not quite as unremarkable as its documentation previously made it sound. Castile is a simple language with union types. The union types let it do a number of tricks, like being safe from null pointers, implementing enums, and taking a "Parse, don't validate" approach when programming.

A better experience on mobile, and DAM 0.2

The catseye.tc website has never exactly been "mobile-first" in its design. But we've recently taken some steps so that the experience on mobile is less bad. In particular, the gewgaws are much more mobile-friendly now. Many of them scale themselves down properly to the size of your device's screen. Others, such as A Non-Random Walk and Art Restoration Simulator, now function on mobile, when before they did not.

Incidentally, version 0.2 of DAM, the Document Awesome Model, has been released. Range controls now expose a method to set their value programmatically, and the project has a slightly more developed build system.

Version 0.3 of ellsync released

ellsync is an opinionated poka-yoke for rsync, for the primary purpose of maintaining a backup system.

Version 0.3 has been released, which, along with some cleanup of the internals, provides two more measures for quality assurance.

First, after rsync has completed, the system's sync command is run. So ellsync does not finish until all of the changes have been written to disk.

Second, a --thorough option has been added. This runs rsync in a mode where it thoroughly checks for differences between files, even if the source file's timestamp has not changed. This can detect files which have become corrupted, and also repair the backup file, if the original file has not been corrupted as well.

Version 0.8 of Robin released

A new version of Cat's Eye Technologies' excessively principled Scheme-like programming language Robin has been released.

This is a fairly major release for Robin, as there is a change of terminology: what were previously called "macros" are now called by the more obscure, but more accurate term "fexprs".

In Robin, both macros and functions are defined in terms of fexprs.

Fexprs also no longer get passed a self argument; instead, to achieve recursion, a recursive fexpr must be written. This is analogous to a recursive function.

The Robin Tutorial has also been significantly fleshed out. It aims to be a good overview of the language for programmers who are already somewhat familiar with Lisp or Scheme.

Tandem, an experimental rewriting language

We've designed and released the first version of Tandem, an experimental rewriting language where the rewrite rules form a Kleene algebra. The object being rewritten by a Tandem program is a collection of labelled stacks — a finite mapping from strings to strings. The strings are always rewritten at the left edge, so they are effectively stacks.

Writing finite automata, push-down automata, Turing machines, and other automata is quite natural in Tandem, because transition rules such as "In state 4, if the next character in the input is g, consume it and push $ onto the stack and go to state 9" translate quite straightforwardly to rewrite rules such as

Q4 → 9 & Ig… → … & K… → $…

tagfarm, an ultra-lightweight categorization system for arbitrary files

We've designed an ultra-lightweight system for categorizing arbitrary files in a filesystem and christened it tagfarm.

tagfarm associates each file in a file tree with zero or more tags. Each tag is implemented as a directory containing symbolic links to the files that have that tag. And that, along with a little script to add, remove, and repair tags after the files themselves may have moved, is basically all it is - hence "ultra-lightweight".

Web-based interpreters for Emmental and Mascarpone

We've made new minor releases of our self-modifying programming languages Emmental and Mascarpone.

We've modernized the build systems in both of these language distributions, and in the process we've enabled web-based interpreters to be built for these languages, by compiling their Haskell reference implementations to JavaScript using the Haste compiler.

And we've put those web-based interpreters online at catseye.tc, here (Emmental) and here (Mascarpone).

We've also placed the contents of the Mascarpone distribution in the public domain, to match the Emmental distribution.

Version 0.7 of Robin released

A new version of Cat's Eye Technologies' "excessively principled" Scheme-like programming language Robin has been released.

The highlight of this release is that it is now allowed to define a symbol after it has already been defined, which is understood as providing multiple semantically equivalent definitions for the symbol. An implementation of Robin is allowed to (but not required to) try to disprove that the given definitions are semantically equivalent, and indeed the reference implementation has a way to run property tests (written using QuickCheck) on all such multiple definitions, trying to find cases where their behaviours differ.

Version 0.6 of Robin released

A new version of Cat's Eye Technologies' "excessively principled" Scheme-like programming language Robin has been released.

The highlight of this release is that exceptions and exception handlers have been removed from the language. Conventional exception handlers are in essence dynamically scoped, and thus break referential transparency, while lexical exception handlers have limited usefulness. Exceptions have therefore been replaced by "abort values", which are the wrong type for almost all operations, and in this manner bubble up to the top level of evaluation just as an exception would. Referential transparency has thus been restored to the language.

Falderal, Feedmark, NaNoGenMo 2019, and Cosmos Boulders

Tying up some loose ends of 2019 before we move on to 2020.

Firstly, our Markdown-based formats Falderal and Feedmark had some new minor releases.

But more importantly, their Python implementations are now available as Python packages: Falderal on PyPI and Feedmark on PyPI.

But wait, that's not all! They're also available as Docker images on Docker Hub: catseye/falderal and catseye/feedmark.

Secondly, at the tail end of 2019 Cat's Eye Technologies participated in NaNoGenMo 2019 (we just can't seem to stay away from it) resulting in three generated novels: Anne of Green Garbles, The Insidiously Rainbow-Wigged Dr. Fu-Manchu, and The Epic of Goog-a-MESH.

During the first of those novels arose the somewhat surprising (to me) result that the intersection of a Markov chain and a regular grammar is another Markov chain — one which obeys the rules of the regular grammar. You can read all about it in this write-up, which includes some snazzy state transition diagrams as well.

Finally, Cosmos Boulders is an arcade-style game written in JavaScript using reducers and immutable data structures. It's not particularly original, but it's written in a purely function style. We hope to write a second version using Nested Modal Transducers for comparison.

Our third esolang of 2019: Oxcart

Back in February, when we announced Wanda, we did say there would be other esolangs this year. They haven't been the ones I thought they'd be, back then, but they're pretty squarely esolangs, I think. And this is the third one!

We present Oxcart, a purely concatenative language (in the sense of Equipage) which is based on composing functions written in continuation-passing style. Instead of functions which take states to states, the symbols of the language represent functions which take an extra argument, a continuation, that represents the future of the computation.

It's also installed online, so you can run Oxcart programs without leaving your web browser.

Carriage, Erratic Turtle Graphics, and DAM

Since 2012, our first "purely concatenative" language, Carriage, existed only in the form of an article on the esowiki.

It now has a real reference distribution, and it's also installed online, alongside its successors Equipage and Wagon, so you can run Carriage programs without leaving your web browser.

Elsewhere, we've also installed a gewgaw we concocted a little while ago (though not as long ago as Carriage), which we call Erratic Turtle Graphics.

It's possibly also worth mentioning that this gewgaws, and several other of our recent online installations, use a tiny Javascript library that we released this year, called DAM, to build their user interfaces. It replaces yoob.js's "element factory" library, and it's what we're switching to as we phase out yoob.js.

PL-{GOTO}, Robin, Equipage, and Wagon installations

As we mentioned in a previous news item, the Haste compiler allows us to easily create web-based installations for things implemented in Haskell.

And some things we've had a penchant for implementing in Haskell are programming languages of all stripes — experimental, esoteric, and didactic.

So, four more programming languages have come online; you can write programs in them and run them right in your web browser. It isn't a fantastic development environment, of course, but you can get a taste for what the language is like, without having to download or install anything.

Thus we present online installations for four languages we implemented in Haskell:

Our second esolang of 2019: Wagon

Back in February, we did say there would be other esolangs this year, so here we go with the second one!

We present Wagon, a purely concatenative language (in the sense of Equipage) which is "second-order concatenative": instead of functions which take states to states, the symbols of the language represent functions which take functions from states to states, to functions that take states to states.

Also, we have recently made a few updates to our probably-not-esoteric but-not-exactly-mainstream-either language Robin, bringing it up to 0.4. Mainly this involved cleaning up its specification.

Quylthulg, Pail, Flobnar, and Maze Clouds installations

Lots more updates to installations.

First, we have discovered that it is possible to use the Haste compiler to create web-based installations for little things we have implemented in Haskell, by adding only a small module to hook up the internals to some HTML5 controls.

Thus we present online installations for three languages we implemented in Haskell: Quylthulg (where goto's is allowed, but only inside data structures), Pail (if Lisp stands for LISt Processing, Pail stands for PAIr Language), and Flobnar (where Befunge went drinking on its 18th birthday and got really quite remarkably drunk).

Since we developed a little system for doing these with Haste, we can expect a few other of Cat's Eye Technologies Haskell implementations to have online interpreters in the near future.

Second, we finally put together a distribution for Maze Clouds (a simple generative technique to generate mazy, cloudy forms) containing implementations in both Python and Javascript, and we put the Javascript one online here: Maze Clouds

SixtyPical 0.19 released

Sometimes you go down a rabbit hole because it opens up under your feet. That's what it felt like this time, anyway; I hadn't thought about SixtyPical for months, and then suddenly I find myself rewriting half of the compiler's internals.

The big thing, I guess, is that I realized the language doesn't need separate buffer and table types; only let tables have more than 256 entries, but say only the first 256 can be accessed by index; and let pointers point into tables, and say that is how you access entries past the 256th. Then you can just get rid of buffer completely. Which is what I did.

And then it because fairly obvious that "which table is this pointer pointing into?" could be tracked in the analysis context just like all the other things we're tracking, and after some consideration I decided a lexically-scoped block for it would be nice, and so the language now has point ... into blocks.

Doing these introduced or revealed a bug whose root cause seemed to simply be that hand-rolling immutable objects in Python (or rather, objects that you would like to consistently pretend are immutable) is a pain in the neck. Addressing that problem triggered another wave of changes, wherein the internal representation of type information was refactored into a single context (the symbol table) shared amongst the phases of the compiler, in which namedtuples are stored. It was a lot of refactoring, but the massive test suite helped keep things together, and it was quite satisfying being able to delete the __hash__ methods from objects, knowing they would now be given appropriate ones under the hood. And that fixed the bug.

Finally, I thought the loadngo.sh script was getting a bit grotty, so I incorporated the "load-and-go" mechanism into the main sixtypical script itself.

Cyclobots, Chzrxl, Wanda, Velo, and ILLGOL installations

Lots of updates to installations.

First, our little dynamical systems Cyclobots and Chzrxl have had their implementations re-fitted to use PixiJS. PixiJS uses WebGL for display when it is available, so these installations now have the potential for having much nicer visuals than the previous versions. It's only minimally leveraged at this point — you can select "Blurred" or "Noisy" visuals — but the potential is there, I tell you.

In the process of switching over to PixiJS, these two projects have been given their own reference distributions instead of residing in the HTML5-Gewgaws distribution alongside everything else.

You can see these in action here: Cyclobots and Chzrxl.

Second, two of our languages that are implemented in Lua, namely Wanda and Velo, have been made to run on a web page thanks to Fengari, an implementation of the Lua VM in Javascript.

So, you can try these out online here: Wanda and Velo.

Finally, a distribution of ILLGOL running under FreeDOS is now installed online, under v86, an emulator for IBM-compatible PC architecture in Javascript. (We actually built this distribution a while ago, but at the time, v86 wasn't able to run it correctly. Now it is. Kudos to all v86 contributors.)

You can try it out online here: ILLGOL.

Our first esolang of 2019: Wanda

We present Wanda, a Forth-like, "concatenative" programming language that's arguably not concatenative at all, nor even "stack-based", because it's based on a string-rewriting semantics.

Wanda was actually started in 2009, but never really got off the ground. But it never really went away, either, so here we are, ten years later.

Ah, also, are you slightly surprised, or even alarmed, to hear that this is only our first esolang of 2019? It's true, there will be others this year (weather permitting). But you'll have to wait for those.

git.catseye.tc and other website improvements

As you might know, Cat's Eye Technologies hosts git repositories of its projects on GitHub. And as you might also know, several months back, GitHub was acquired by Microsoft.

We do not regard this, in itself, to be a problem. There's nothing GitHub-specific about git; it's a distributed protocol, and a git repository can be hosted basically anywhere. The GitHub-specific things that GitHub does offer are handy, but we've intentionally avoided relying too much on them. For instance, we've tried to describe planned features in TODO lists in the repo itself, instead of opening issues for them. And shall we point out that Microsoft is only one of several 800lb gorillas in the tech world these days, and perhaps it's not the one you should be the most worried about anymore?

Ah, but I'm editorializing. The point is, one can lessen one's dependency on GitHub very easily by hosting one's git repositories elsewhere, and that's just what we've done. Deploying an instance of klaus, we've set up git.catseye.tc. You can browse repositories from it and clone from it and download zipfiles from it and everything. (The repositories we have on GitHub will stay on GitHub, too, so if you want to fork them on there or open issues or pull requests there, you can, still.)

We've also done a fair bit of maintenance on the catseye.tc website in conjunction with this.

First — many would say this is long overdue — it's all https now. Don't worry about changing any links; it's not required, http requests will simply redirect to https.

Second, we've released version 0.8 of Feedmark, and the website is using it in the backend to read Markdown files directly as Feedmark. This lets us do things like format it more nicely in templates.

Lastly, we've cleaned up the Retrocomputing article, in particular, moving the things that are dependencies (even if they are "retro dependencies") rather than projects to the Project Dependencies article.

SixtyPical 0.18 released

We've released the latest version of SixtyPical, our low-level 6502-like language with abstract analysis. In particular, how blocks are analyzed has been cleaned up. When two block diverge (such as in an if statement), they no longer need to keep the same values initialized; instead, the two contexts are merged afterwards — any location that is trashed in one block will continue to be trashed after both blocks. (And if that introduces a problem after both blocks, the analyzer will catch that problem there.) Also, a goto may appear at the end of any reasonable block, not solely at the end of a routine, so long as the initialization constraints all work out as declared. (The context at the goto must be compatible with the context at the end of the routine.)

Our hope is that these changes will pave the way for optimizations such as tail calls and dead code removal.

Older news items from this feed, dating back to 2007, can be found in the Archived News Items article.