This new stropping regime aims to be more appealing to contemporary programmers, and also more convenient to be used in today's computing systems, while at the same time retaining the full expressive power of a stropped language and being 100% backwards compatible as a super-extension.

The stropping regime has been already implemented in the https://gcc.gnu.org/wiki/Algol68FrontEndGCC Algol 68 front-end and also in the Emacs a68-mode that provides full automatic indentation and syntax highlighting.

The sources of the godcc program have been already transitioned to the new regime, and the result is quite satisfactory. Check it out!

Comments and suggestions for the draft are very welcome, and would help to move the draft forward to a final state. Please send them to algol68@gcc.gnu.org.

Salud, and happy Easter everyone!

For DWARF 5, DW_LANG_Algol68 = 0x44.

For DWARF 6, DW_LNAME_Algol68 = 0x2e with versioning schema YYYY, starting with 1973 for the original Revised language. The language extensions we are working on will be encoded in subsequent versions, 2025 etc.

DWARF issue 250304.1.

Thanks to Marc Poulhiès the Compiler Explorer instance at godbolt.org now has support for compiling Algol 68 programs using ga68, the Algol 68 GNU compiler based in GCC which is under development.

https://godbolt.org/z/6s9aqvW4K

On a related note, the demo application that I am using as both as a test and a showcase for the front-end, called godcc, is precisely a full-fledged command-line interface to Compiler Explorer, written in Algol 68. It hopefully shows how powerful, clear, concise and modern the language is.

godcc: a command-line interface to Compiler Explorer

Finally, yesterday support for Algol 68 in Automake got integrated upstream and shall be available at the next release. The corresponding support for Autoconf is still being reviewed in the project's development list. The Emacs a68-mode mode, that provides syntax highlighting and smart indentation of Algol 68 programs, got also added to the ELPA archive. The development of the front-end itself is progressing and soon we shall be able to get it integrated in GCC proper.

GCC Algol 68 front-end development page

Just posted a WIP series for an Algol 68 front-end for GCC. It is about time to have support for the best programming language ever designed in the best optimizing compiler ever made ;)

Thanks to Marcel van der Veer for his awesome parser, that I took the liberty to borrow from Algol 68 Genie. Free Software for the win!

WIP patch series in gcc-patches...

I have decided to start using sourcehut for a few of my projects. The first projects landing there are bugz-mode and a68-mode, two Emacs modes. The first implements a quite efficient and comfortable interface to bugzilla. The second is a programming mode for Algol 68.

Let's see how it goes!

https://git.sr.ht/~jemarch

During tonight poke online office hours our friend hdzki came with an interesting use case. He is poking at some binary structures that are like sparse tables whose entries are distributed in the file in an arbitrary way. Each sparse table is characterized by an array of consecutive non-NULL pointers. Each pointer points to an entry in the table. The table entries can be anywhere in the IO space, and are not necessarily consecutive, nor be in order.

It is often the case in binary formats that certain elements are separated by some data that is not really used for any meaningful purpose other than occupy that space. The reason for keeping that space varies from case to case; sometimes to reserve it for future use, sometimes to make sure that the following data is aligned to some particular alignment. This is known as "padding". There are several ways to implement padding in GNU poke. This article shows these techniques and discusses their advantages and disadvantages.

Mohammad-Reza Nabipoor has written a nice short tutorial called "Learn the Poke Language in Y minutes". The tutorial has the form of a Poke program itself, and I think it really highlights the most uncommon (and useful!) features of our domain-specific language.

Editing data with GNU poke mainly involves creating mapped values and storing them in Poke variables. However, this may not be that convenient when poking several files simultaneously, and when the complexity of the data increases. poke provides a convenient mechanism for this: maps and map files.

The development of GNU poke is progressing well, and we keep hopes for a first release before the end of the year: we are determined for something good to happen in 2020! ;)

This article briefly reviews the latest news in the development of the program, like changes in certain syntax to make the language more compact, support for lambda expressions, support for stream-like IO spaces and how they can be used to write filters, support for using assignments to poke complex data structures, improvements in data integrity, annoying bugs fixed, and more.

This weekend I finally implemented support for the so-called "integral structs" in poke. This expands the expressivity power of Poke structs to cover cases where data is stored in composited integral containers, i.e. when data is structured within stored integers.

GNU poke is, first and foremost, intended to be used as an interactive editor, either directly on the command line or using a graphical user interface built on it. However, since its conception poke was intended to also provide a suitable and useful foundation on which other programs, the so-called binary utilities, could be written. At last, the development of poke has progressed to a point where we can start writing such utilities, and the purpose of this article is to show a small, albeit working and useful example of what can be achieved by writing a few lines of Poke: an extractor for ELF sections.

Poke struct types can be a bit daunting at first sight. You can find all sort of things inside them: from fields, variables and functions to constraint expressions, initialization expressions, labels, other type definitions, and methods.

Struct methods can be particularly confusing for the novice poker. In particular, it is important to understand the difference between methods and regular functions defined inside struct types. This article will hopefully clear the confusion, and also will provide the reader with a better understanding on how poke works internally.

The ID3V1 tag format describes the format for the tags that are embeded in MP3 files, giving information about the song stored in the file, such as genre, the name of the artist, and so on. While hacking the id3v1 pickle today, I found a little dilemma on how to best present a pretty-printed version of a tag to the user.

Poke has loops. It also does IO (yeah, right :D). On one hand, this means that Poke programs that never finish are definitely possible (here is one: while (1) {}) and, on the other, a Poke program acting on an enormous amount of data may take a long time to finish, depending on what it does. Maybe hours, maybe even days?

FOSDEM 2020 is over, and hyperlink support has just landed for GNU Poke!

What do hyperlinks, a web concept, mean for GNU Poke, a terminal application?

For many years now, terminal emulators have been detecting http:// URLs in the output of any program and giving the user a chance to click on them and immediately navigate to the corresponding web page. In 2017, Egmont Kob made a proposal for supporting general hyperlinks in terminal emulators. Gnome Terminal, iTerm and a few other terminal emulators have already implemented this proposal in their latest releases. With Egmont's proposal, an application can emit any valid URI and have the terminal emulator take the user to that resource.