/home/lucio.albenga.es

Setting Up a GCC Toolchain For Programming Arduino In Plain C

lfa — Mon, 01 Dec 2025 00:00:00 +0000

I'm not an Arduino power user but when I decided to start with it I knew I wanted to program it in plain C and I knew I would buy a compatible board instead of the real thing just to take the feel of it. Probably because I'm a programmer, I found much more interesting to go down the rabbit hole of low-level details, datasheets¹, etc., instead of letting the Arduino IDE and libs to hide things from me. I also didn't find of any use to learn a pseudo C++ when I already knew C.

During these past weeks, since Qualcomm acquired Arduino, there was a lot of talking about if they will enshittify Arduino, etc. Right now it seems I was right from the start about doing things in pure C and not using Arduino's software because right now it doesn't affect me at all whatever Qualcomm does.

In this howto I will explain to you how to set up a GCC based toolchain so that you can also program your Arduino in C, or if you prefer it in C++, and I will show you all the steps from typing a program all the way to loading it on your board without using Arduino's official software.

The first thing you should do is to install the required sofware and it's quite likely that your POSIX compatible OS already have packages for it. In this howto we will see how to do it on FreeBSD and Devuan GNU + Linux.

pkg install avr-gcc avr-binutils avr-libc avrdude      # FreeBSD
sudo apt install gcc-avr binutils-avr avr-libc avrdude # Devuan

Once the programs are installed, open your preferred editor and type the program below. This program is the typical one that blinks the light of your Arduino, and you'll use it for testing the toolchain and see how everything fits together. For the purposes of this howto this file is called blink.c.

#include <avr/io.h>

#define F_CPU 16000000UL /* required by <util/delay.h> */
#include <util/delay.h>

#define DELAY 1500 /* milliseconds */

int
main (void) {
        DDRB |= _BV(DDB5);
        for(;;) {
                PORTB |= _BV(PORTB5);
                _delay_ms(DELAY);
                PORTB &= ~_BV(PORTB5);
                _delay_ms(DELAY);
        }
}

The F_CPU constant should reflect the CPU frequency (the clock speed) of your Arduino model. I have an Arduino UNO compatible board and in my case this value is 16MHz.

Now it's time to compile the program. Type the following command on your terminal:

avr-gcc -Os -mmcu=atmega328p -o blink blink.c

Once you have the compiled binary file blink you should convert it to a valid Arduino *.hex binary:

avr-objcopy -O ihex -R .eeprom blink blink.hex

Now it's time to connect your Arduino to one of the USB ports of your computer. Check out the port it's connected. You can use the command dmesg to do this. On Devuan the output of dmesg, once connected my Arduino compatible board, looks like the following:

[3975174.307519] usb 2-1: new full-speed USB device number 79 using xhci_hcd
[3975174.456593] usb 2-1: New USB device found, idVendor=1a86, idProduct=7523, bcdDevice= 2.63
[3975174.456606] usb 2-1: New USB device strings: Mfr=0, Product=2, SerialNumber=0
[3975174.456612] usb 2-1: Product: USB2.0-Serial
[3975174.458699] ch341 2-1:1.0: ch341-uart converter detected
[3975174.459258] usb 2-1: ch341-uart converter now attached to ttyUSB0

This means that, in my case, it is connected to /dev/ttyUSB0 (/dev/ttyU0 on my FreeBSD). To load the program into your Arduino type the following command (replace /dev/ttyU0 or /dev/ttyUSB0 with your device):

avrdude -F -V -c arduino -p m328p -P /dev/ttyU0 -U flash:w:blink.hex    # FreeBSD
avrdude -F -V -c arduino -p m328p -P /dev/ttyUSB0 -U flash:w:blink.hex  # Devuan

The output will be something like the following:

avrdude: AVR device initialized and ready to accept instructions
avrdude: device signature = 0x1e950f (probably m328p)
avrdude: Note: flash memory has been specified, an erase cycle will be performed.
         To disable this feature, specify the -D option.
avrdude: erasing chip
avrdude: reading input file blink.hex for flash
         with 176 bytes in 1 section within [0, 0xaf]
         using 2 pages and 80 pad bytes
avrdude: writing 176 bytes flash ...

Writing | ################################################## | 100% 0.06 s 

avrdude: 176 bytes of flash written

As I said before, the program blinks the Arduino light so you can take a look at your Arduino and if its light is blinking it means everything worked fine. Congratulations! You already have a working toolchain and you know the basics to create and load your programs on your Arduino board.

I hope you find this howto useful and that it helps you to start programming your Arduino board with C. This is only a starting point and I recommend you to read the help and/or docs of all these programs, that's where the magic happens.

Footnotes:

ATmega328P Datasheet at Arduino Website

100% "Free as in Freedom" Versions of Devuan and Debian

lfa — Sun, 16 Nov 2025 00:00:00 +0000

I had seen in Simon Joseffsson's blog that he released the project "Debian Libre Live". A project that aims to release Debian GNU/Linux Live images with only free software, i.e. what Debian was before taking the decision to include non-free things inside the main distro Live images. Simon talks about this project in his blog¹ and you can check out his Gitlab repository² too.

At the same time, via Simon himself, I learned about the existence of a similar project that targets Devuan GNU+Linux, the distro I use, which is a fork of Debian without SystemD and other aberrations. This project is Gnuinos Linux-Libre³ and it uses the Linux-libre kernel⁴. We could say that, at least in theory, Gnuinos could be what Debian should be if they weren't taking so many bad decisions during so many years.

If you use Debian or Devuan and you care more about free as in freedom software than open source software, here you have two 100% "free as in freedom" GNU/Linux distros that you may find interesting.

Footnotes:

Simon Joseffson: Introducing The Debian Libre Live Images

https://gitlab.com/debdistutils/debian-libre/debian-libre-live

https://www.gnuinos.org/

⁴

https://www.fsfla.org/ikiwiki/selibre/linux-libre/

Mark McCahill & Farhad Anklesaria video interview on Gopher

lfa — Sat, 15 Nov 2025 00:00:00 +0000

I found at the Internet Archive a file by John Goerzen¹: "2007 Gopherspace Mirror"² and inside it there is a rare interview with Mark McCahill and Farhad Anklesaria, part of the team who created the Gopher protocol. I decided to upload it to my PeerTube³, in fact is the very first video I publish on PeerTube, because I think it's a great part of the history of Gopher and the Internet. You can watch it here and I hope you'll enjoy it as much as I did.

Footnotes:

John Goerzen's Website

2007 Gopherspace Mirror at the Internet Archive

Video at LFA's PeerTube

From Git to Fossil

lfa — Wed, 12 Nov 2025 00:00:00 +0000

People at Git has started to work on a proposal to make the Rust¹ programming language mandatory. I don't like Rust and, above all, I don't like its community of little extremist characters who are trying to make everyone swallow their crap by rewriting projects that have been working for decades, doing social media brigading, and other nice little gems worthy of any tiny group with totalitarian delusions. That's why when I see that a project aims to "force" the use of or the switch from C to Rust, to the extent of my possibilities, I flee from it as if I were pursued by the Balrog of the Lord of the Rings with his whip.

I'm old enough to have used (or tested) many version control systems: RCS (Revision Control System), CVS (Concurrent Version System), SVN (Subversion), HG (Mercurial), BZR (Bazaar), and the aforementioned Git, which means I have no problem in switching again, so I started to think about a Git substitute for my personal projects.

The options were to go back to one of the already known or look at something else, and I remembered Fossil. I started looking over the source code and reading the official documentation² to learn its features, its dependencies, how to install and configure it, etc., and I noticed it had many things I like:

It's made in C (although it uses some js and tcl for its web functionality) and is a small and efficient program that consumes few hardware resources.
It's simpler to use and it feels more natural (at least for someone who knows other systems such as Subversion) because it does not contain overkill functionalities such as the staging area, which may be useful in large and complex projects such as the Linux kernel, but for me they have no practical use.
It allows you to self-host a server on your own quickly and easily because it is already prepared for it. In fact it has a web server and a web interface with version control views, wiki, tickets, etc. On the other hand, with Git you have to use an external software such as GitLab, Gitea or Forgejo, and each one of them is at least one extra software dependency.
Commit messages don't use email addresses, they use user names so if you have a public repository you don't have to be worried about spam and you don't need a specific email address for this use only.
It's interoperable with Git in the sense that if there is a need to change a repository back to Git you can do it and it also supports two-way synchronization between a Fossil repository and a Git³ one (this is the functionality used by Fossil and Sqlite projects to manage their GitHub mirrors).

Taking all this into account, I decided to install Fossil and switch my projects from Git. Below you'll see how to do it.

Installing Fossil

The first step is to install Fossil and it's quite likely that the package manager of your operating system already has it available:

sudo apt install fossil # Devuan GNU+Linux
pkg install fossil      # FreeBSD

Once your package manager ends the installation you can check its availability with the following command:

fossil version

The command above should return something like the following:

This is fossil version 2.21 [3c53b6364e] 2023-02-26 19:24:24 UTC

Importing Git repositories

Fossil's documentation⁴ has the following example to export a Git repository and import it as a Fossil repository:

cd repository
git fast-export --all | fossil import --git repository.fossil

I did it differently because I wanted to adjust some things to have the imported repositories "right". As I have several repositories I created two different folders, one, git-exported, to store the exported repositories and another one, fossils, to store the new Fossil repositories:

mkdir ~/git-exported
mkdir ~/fossils

Now you can get into each Git repository folder and export it:

cd repository
git fast-export --all > ~/git-exported/repository.export

Once you have exported all your Git repositories you should go inside the ~/fossils folder and import them one by one with the command:

fossil import --git \
       --rename-master trunk \
       --attribute "your@mail.com your_username" \
       repository.fossil ~/git-exported/repository.export

The --rename-master trunk option renames your Git master branch as trunk in your new Fossil repository. Fossil, like other version control systems such as Subversion, uses trunk as the name of the master branch. If you are among the unfortunate ones who have their master branch named as "main" this option is not for you and you should check Fossil's documentation if you want to rename it.

The --attribute "your@mail.com your_username" option changes the email address "your@mail.com" from Git commits to "your_username" in the imported Fossil commits. In Fossil the default username is the same as the one you're currently using in you operating system. Obviously the given email address should exist in one or more commit messages.

If you want to change more than one email address you can do it using several --attribute options:

fossil import --git \
       --rename-master trunk \
       --attribute "your@mail.com your_username" \
       --attribute "rms@gnu.org rms" \
       --attribute "linus@kernel.org torvalds" \
       repository.fossil ~/git-exported/repository.export

The output of the import command looks like the following:

Rebuilding repository meta-data...
  100.0% complete...
Vacuuming... ok
project-id: e64b112b40eb3db188060ddb8deeaa96a6ad3b71
server-id:  bfbcd4bf8f0f64eaa2d832ddc3b4af00639624a6
admin-user: your_user (password is "XAxPVZcNQ6")

If you look closely, the output gives you the repository administrator's user and password. Keep it because you'll need it to do certain things on your repository.

Setting Up a Fossil Server

Fossil has an embedded web server so you can take advantage of it to create a self-hosted server quickly and easily. The following method is enough for a system with few users, in a private network that cannot be accessed from the outside. There are different ways to set up a Fossil server and some are better than others depending on your needs, so I recommend you to check out the official documentation.

First you should create a folder to store the Fossil repositories on the server:

mkdir /path/to/your/fossils

Next copy your "fossils" to the folder on the server:

scp *.fossil user@your_server:/path/to/your/fossils/

Now you can start the server with the following command:

fossil server --port 8043 \
       --cert /path/to/your_cert.pem \
       --pkey /path/to/cert/key.pem \
       --repolist /path/to/your/fossils/

If you don't have a valid certificate you can use the follwing command:

fossil server --port 8043 \
       --cert unsafe-builtin
       --repolist /path/to/your/fossils/

Once the server is running, if you put the following url https://server_address_or_hostname:8043/ in your browser you'll access a web page with the list of your repositories. If you click on one of the repositories listed, you'll see the repository web page. In the navigation menu you should see a "login" option. Click on it and use the repository administrator's username and password. Now you can configure the repository to your liking. Check out Fossil's documentation to learn more.

If you lost your Fossil repository administrator's password, you can recover it by following these steps:

Go to the repositories folder in your server
If you don't have Sqlite installed, install it following the usual method of your operating system.
Open repository.fossil with Sqlite:
```
   sqlite3 repository.fossil
```
Once inside sqlite execute the following query:
```
   select login,pw from user;
```
The query above will return something like:
```
   your_user|My3w2jRxt1
   anonymous|57EBCBD1AAE663B4
   nobody|
   developer|
   reader|
```
The password is the value on the second column (in this example the string My3w2jRxt1).
Exit Sqlite with the following command
```
    .quit
```

Using Fossil

Here is a very brief guide on how to start working with Fossil. This guide assumes that you know how to use Git, at a very basic level, and it's just a starting point, so I recommend you to read Fossil's documentation and the Fossil Book⁵.

Getting Help

The help command is essential to see which commands are available and the uses and options of each one of these commands. The help command works just like Git:

fossil --help
fossil command_name --help

Creating and cloning repositories

These are similar to Git's but with differences. In Git it's usual that the repository matches the current working folder. In Fossil this is not so, there is a clear separation between the repository, file repository.fossil, and the working (check-out) folder repository_folder.

Creating a repository

You can create a new repository with the command:

fossil init repository.fossil

This command will create only the repository, i.e. the file repository.fossil. To start working with it you have to "open it". Create a folder, move inside it, and open the repository:

mkdir my_working_folder
cd my_working_folder
fossil open /path/to/repository.fossil

You can also tell Fossil the name of the working folder and if it does not exist Fossil will try to create it:

fossil open --workdir my_working_folder /path/to/repository.fossil

Cloning a repository

You can clone a repository using the command fossil clone followed by the repository url. The url can be a web url, a ssh url, a file path, etc.:

fossil clone https://host/repository

This command will automatically download the file repository.fossil and it will create, at the same level, the working folder repository_folder. If you don't want it to create the working folder you can do it by using the command like:

fossil clone --no-open  https://host/repository

Once the repository is cloned, if you want to send your commits to the remote repository (and you have permissions for it), you should configure inside the working folder the remote fossil repository:

fossil remote https://user@host/repository

The command above will asks you for your user's password and it will also asks if you want to save it for future use.

TIP: Because Fossil has this clear separation between the repository file on one hand and the working folders on the other, I keep all the *.fossil files inside a folder named fossils in my /home and I have the working folders where is most appropiate in each case.

Getting Info

For getting the information about the working folder and repository status there are some differences compared to Git, especially in the name and use of the commands.

Viewing the timeline

In Fossil the fossil time and fossil timeline commands are the equivalent of Git's git log command. Here are some examples from the one that provides less information to the one that provides more:

fossil time --oneline # similar to git log --oneline
fossil time
fossil time --medium
fossil time --verbose # similar to git log

Viewing changes in your working folder

To see the changes in your working folder compared to the repository there are several commands and each one of them has different options.

To see which files and folders are not under version control:

fossil extras

To see files that are under version control and have been modified:

fossil changes

To see a combination of the two previous commands:

fossil changes --differ

To see the working folder and repository status in a way more closely to the output of Git's git status command:

fossil status --differ

Viewing the Diff(erences)

To see the differences between the contents of our files in the working folder and what is in the repository, Fossil, like Git, has a diff command:

fossil diff

To see the differences between a specific commit and the working folder:

fossil diff --from 2c26dd6b69 # 2c26dd6b69 is the hashtag of the commit

To see the differences between two specific commits:

fossil diff --from 2c26dd6b69 --to cd086a1045

Fossil's diff command doesn't show colorized diffs. Check out the Wiki if you want colorized diffs⁶

Getting changes

Fossil has an option called autosync that is enabled by default. This option keeps your local repository synchronized with the remote repository. If you have the autosync option enabled, you can get all the changes from the remote repository (if any) with the command:

fossil update

Otherwise it would be more similar to Git's. You have to do first a pull to get the changes and then an update for these to appear in your working folder:

fossil pull
fossil update

Commiting changes

As Fossil does not have the staging area, the commit is much more likely to version control systems like Subversion than Git.

If you want to make a commit with all the pending changes:

fossil commit

The command above will open an editor for you to enter the commit message, but you can also provide the commit message as an option:

fossil commit -m "My commit message"

You can commit specific files with:

fossil commit file1 file2
fossil commit file1 file2 -m "My commit message"

If you have the autosync option enabled, the commit command will also send your changes to the remote server (if any). Otherwise you'll have to send the changes to the remote server with the command:

fossil push

Adding and deleting files

When you need to put new files under version control you can do it with:

fossil add filename

If you want to remove a file from the version control you can do it with:

fossil delete filename
fossil rm filename

By default the rm and delete commands do not physically delete the file from the file system, they simply mark it as no longer under version control.

There's also a command fossil addremove which adds to the repository all the files in the working folder that are not under version control and removes from the repository all the files that are under version control but that no longer exist in the working folder.

Ignoring files

Configuration is one of the points where there are several important differences between Fossil and Git, so I recommend you to check out Fossil's documentation. To ignore files and folder you have to create the file .fossil-settings/ignore-glob inside the working folder:

cd working_folder/
mkdir .fossil-settings
touch .fossil-settings/ignore-glob

Then edit it using glob patterns⁷:

build/
3rdparty/
*.o
*/a.out

Branches and Tags

Git's paradigm encourages an intensive use of branches and tags but Fossil's paradigm and features are different so the workflows are different too.

As I don't make much use of branches in my personal projects, I think that in order for you to get an idea of the differences so that you can adapt Fossil's features to your workflow, or your workflow to Fossil's features, you better read the following links from the Fossil Wiki:

Local web interface

I don't want to finish this little Fossil guide without making it clear that you can access and use the web interface without having a Fossil server. To do it, run the following command from within the working folder:

fossil ui

Final Thoughts

I like Fossil very much and, in my opinion, it's an almost perfect mix between a centralized version control system like Subversion and a distributed one like Git. I like how easy is to put it in server mode, its web interface and, above all, the simplicity of its command line and of the most common tasks.

I think it's a great program that has a lot to offer, especially to indie programmers and small groups who are interested in self-hosting solutions. If you are looking for a simple and effective alternative to Git do not hesitate to take a look at Fossil because it may be exactly what you are looking for.

Footnotes:

Git Mailinglist [PATCH RFC 0/3] Introduce Rust and announce that it will become mandatorty

Fossil's Wiki

How To Mirror A Fossil Repository On GitHub

⁴

Import And Export To And From Git

⁵

Fossil Book

⁶

Fossil Colorized Diffs

⁷

Fossil File Name Glob Patterns

Gopher.fr

lfa — Sat, 08 Nov 2025 00:00:00 +0000

A friend has started a website to advocate for Gopher. Currently the site is a starting point for newcomers. Originally the website was in English and French, someone did the German translation, and yours truly did the Spanish and the Italian translations, so, little by little, the site is taking on an European feel, i.e multilingual ;-)

Without further ado, here's the link for you to check it out and share: https://gopher.fr/

From The Printing Press to The Internet And Back Again

lfa — Mon, 20 Oct 2025 00:00:00 +0100

The need of expressing ourselves freely and to share our things with fellow human beings is something that has always been there. In ancient times people did it with rock paintings and stories were shared through oral tradition. Later humans started to write on different media and, finally, the invention of the printing press made it possible to share information on a large scale. The miracle of the printing press not only made possible to share books but it also gave people the chance to publish and share their opinions and creations.

Chapbooks

Thanks to the printing press, during the 16th century, a type of publication known as chapbooks started to proliferate. Different names were used in different countries: "pliego suelto" in Spain, "livre bleu" in France, "volksbuch" in Germany, "libri da risma" in Italy, and so on. This publications ranged from a folded loose sheet to books composed of several printed, folded and unbounded pages.

This street literature was a mean of information, entertainment and outreach among ordinary people. The contents were varied and ranged from a song or poem to the account of curreant events. There were general publications and more specialized publications aimed at certain sectors.

Contrary to what we can think, chapbooks were produced on a non negligible scale in view of the resources of the time as well as the literacy of the people, which was not as large as nowadays. In 1520s the Oxford bookseller John Dorne recorded in his day-book the sale of up to 190 ballads a day, the inventory of the stock of The Sign of the Three Bibles on London Bridge in 1664, included books and printed sheets to make approximately 90,000 chapbooks and 37,500 ballads sheets. The inventory of The Sign of the Looking Glass, also on the London Bridge in 1707, recorded 31,000 books, in addition to 257 reams of printed sheets. A conservative estimate of sales in Scotland in the second half of the 18th century was over 200,000 per year¹

Fanzines And Ezines

During the 20th century, and especially throughout its lastest three decades thanks to the invention of the Xerox machine, the fanzines made their appearance, which are, as a general rule, a group of xeroxed sheets of paper, folded in half with a cardboard cover and binded with stapels. Fanzines were essential to disseminate what was known as counterculture.

Although there are cases of fanzines that were so successful that they ended up becoming magazines² and that the fanzine phenomenon was so large that there were some of them created and managed by large corporations (such as the well-known fanzine "U Don't Stop" that was part of a Nike advertising campaign), commonly these publications were a one person (or a very small group) operations, with a more or less short lifespan.

As the Chapbooks of the previous centuries, fanzines were about many different things: literature, comics, music, politics, etc. Some were more specialized than others and there were even fanzines about only one band or musician like the fanzine "exclusively Elvis".

Later, with the coming of BBS, the first ezines appeared. Usually, they were files in plain ASCII text format. One of the oldest and still alive is Phrack³. The coming of the Internet continued to drive the ezine phenomenon and a little later, with the coming of blogs first and "social" networks later, people had the potential chance to publish and share their things on an unprecedented scale. During this time some fanzines became digital and many others simply disappeared (as it happened to many magazines and newspapers).

Past And Present

As we've seen technological progress such as the printing press and the Xerox machines made it easier for people to publish their own things and avoid all kinds of censorship. At the very end of the last century and the very beginning of the current one, with the coming of the Internet, there was an optimism for all things digital, the revolution that would be the Internet for regular people.

Three decades later all that's left of that promise of the Internet, of that utopia, are shattered pieces. From the technological progress has emerged a terrifying reality of corporations and corrupt governments willing to destroy everything just to increase their benefits, and increasingly confident in creating a new totalitarian and dystopic world order, in which they can keep doing what they like by subjugating the masses without any interference or resistance. The technology that had to make us free has turned out to be the one that is being used to put chains on us.

We can see every day how the Internet, and especially the web, has become a hostile place where private groups of unpresentable people can block web pages at their will⁴, where publications and ebooks are removed, written and rewritten according to the tastes, affinities and purposes of certain groups and organized interests⁵, where the cancellation culture used by the Nazis and the communists one hundred years ago is the norm, and where the so-called AI scans the entire web 24 hours a day, 7 days a week, stealing everything from everyone without paying a dime⁶.

People are starting to react to all this nonsense. The physical⁷ and offline⁸ is back in fashion and is valued because it really has value. A physical object will always generate a better experience than a virtual one because we humans have multiple senses. A physical object has a lot more options to survive and endure in time than a virtual one, proof of this are all those previous centuries chapbooks that are still with us, while we've already lost forever a large amount of digital content of a few years ago despite the efforts to preserve it. A physical and/or offline object is not as likely to be blocked, interfered, spied, stolen and manipulated as a virtual or online one. You can rewrite the text of an amazon kindle ebook and reupload it silently, but you can't rewrite my physical copy of George Orwell's 1984 published more than 30 years ago. It is and will be here, unchanged and unalterable, for current and future generations.n

In view of all this and taking into account how easy is to have access to a printer nowadays, it is not surprising that people are gradually returning to the dissemination of their thoughts, crafts and arts in the good old printed form, in chapbooks⁹ and fanzines¹⁰, because sharing our thoughts, our opinions and our creations freely is an inherent need of human beings and not a thing for machines.

Gopher, A Simple Alternative To The Bloatware Of The Web

lfa — Sat, 30 Aug 2025 00:00:00 +0100

Español en este sitio.
Français sur linuxfr.org

Nowadays more and more people are tired of suffering the bloatware and threats of the World Wide Web. When the web was released to the public in 1993 it was just a system for sharing files and documents with hyperlinks. Thirty years later it has become a minefield of bots, spyware, tracking systems, invasive advertising, unwanted notifications, and other bad stuff.

Actually we have normalized that for reading a post, a recipe, or seeing a timetable on the web, we have to download a huge amount of data distributed among an invasive pop-up with a privacy / cookie policy notice requesting us to authorize them to share our data and browsing habits with them and their 7126 partners, a lot of ads we don't want to see, a suscription pop-up for something we don't want to subscribe to, images and videos we don't care about, and finally, in the middle of all this crazyness and with a bit of luck, we can see the content we wanted to see in the first place, mixed with more ads.

It has also been normalized the fact that to see something as simple as a cooking recipe we have to have javascript enabled in our browser. For those who don't know, javascript is an environment that lives in your browser and run on your machine whatever javascript program the web page you're visiting is sending to you. This delivers a lot of security problems, privacy issues, misappropriation of data, and so on.

To give us an idea, if we want to see a cooking recipe on a website it's not at all uncommon that we have to download from 2 to 10 megabytes of data with an average of 50 requests to (down)load everything¹. If we make the numbers we will see that a plain text recipe is about 2 kilobytes. Adding to it html formatting and css styles to make it look neat will increase the size to about 3 kilobytes, let's be generous and put 4 kilobytes. So, how is it possible that to see something that is 4kB we have to download 500 to 2500 times more data? Because of all the bloatware: ads, videos, images, trackers, javascript, and the rest of things that you're forced to download want it or not.

Even though we are told to believe that this is inevitbale or even that it is fair by "put here the reasons that are good for the lobby, company or government of the moment", reality is that this is not so. The web was not this way and other options are available. One of those options is Gopher.

What is Gopher?

Gopher, like the WWW, is a protocol to share and access documents and files on the Internet that was published in 1991, two years before the World Wide Web. It was developed at the University of Minessota, hence its name because the mascot of the university and of the sports teams is Goldy Gopher².

Gopher has a navigation system, more structured than the web, based on menus commonly known as gophermaps. This menus contain links to files and other menus and it is a plain text interface so it is very fast and requires very few resources. It's also a single request protocol, one request delivers only one resource and closes the connection.

It's a protocol from a time in which bandwith was tight, slow and expensive, and computers were not as powerful as today, so the aim was to share as much relevant information as possible with the least possible resources.

Gopher Is Bloatware Free

The simplicity of Gopher makes impossible or very difficult the abuses and bloat so common on the web for several reasons, including:

Gopher has no sessions or cookies so it is impossible to track people³ and unnecessary to show a privacy and/or cookie's policy.
The simplicity of the single request plus tha fact that you only get a file avoids the scenario where in turn other requests are automatically made to simultaneously get images, videos, or other files whether from the same server or from different ones.
Because it is a protocol that only shares files it doesn't support javascript or any other similar things so it can not load and run directly a program on the user's computer.
By having only a textual interface and lacking a content design system, the information is lighter because it is commonly presented as plain text. If you want something that looks pretty you can always share files in formats like ODF, PDF, PS, etc., and the user can always decide whether he wants, and can, download them or not.

Taken together, this means that Gopher is a very light system that doesn't require too much bandwith to work. Here content is king because it lacks all the bells and whistles so common on the web, and it also provides peace of mind because there is no tracking, ads, and all the nowadays web abusive behaviours⁴.

Gopher Is Not For Everyone (And That's Ok)

Although many people don't like ads, being tracked, cookies, pop-up windows, etc., it's also true that they think they can't live without much of that same blotware that makes possible all the things they dislike.

The web is like a bustling market while Gopher is more like a library. They're are two different things for different people and/or for different moments. If on the WWW everyone yells at us selling their goods, on Gopher we are in the coffee shop talking with friends and like minded people. Sometimes we like one thing and other times we like (or need) the other, and it's okay.

The use of Gopher declined in favour of the WWW in the late 90s but this protocol has survived to this day mainly thanks to small communities known as Pubnixes (Public Unix Access Systems) and tildes. Although in these communities there are many people with a technical profile and/or interests, there is a variety of people with different profiles, interests and hobbies.

Pubnixes are usually machines with few resources funded by a single person and some donations, so each pubnix has a limited number of users and this fosters the creation of more small communities as the number of people increases. Small communities favour people to interact more with each other and to get to know each other better promoting more genuine and relevant interactions.

People in some communities interact with people in others, which helps building and sustaining a social fabric connecting all the communities. Usually someone who is part of a community, at a given time, decides to create his own pubnix to accommodate new people so there are always intercommunal exchanges and people who belong to more than one community.

This whole ecosystem is an important part of the beauty of Gopherspace. Here people write and share because they have something to say or because they feel the need or the desire to do so. No one publishes twenty daily banalities to improve their SEO and those who read do so because they care and/or are interested, not because of the "Fear Of Missing Out"⁵.

On the other hand, people who need or want to interact almost in real time with a lot of multimedia content that is updated every single second, and people who want to create a personal brand to sell things, get thousands of followers and get tens of thousands of likes, are likely to feel out of place on the Gopherspace.

What I Should Do To Browse The Gopherspace?

Now that we already have an idea of what Gopher is and what it's not, chances are we'll want to take a look. As with for browsing the WWW we need a web browser, to explore the Gopherspace we need a Gopher client.

Years ago many web browsers supported both the WWW and Gopher but as times went on they decided to drop Gopher. One of the browsers that continues to support it is Lynx. Below there is a list⁶ of Gopher clients and extensions to activate Gopher support on Firefox-based browsers and Chromium-based browsers:

Lagrange: is a graphical client available for GNU/Linux, BSDs, Macos, Windows and it also has beta versions for iOS and Android. In its web you'll see that is a client for Gemini but it also supports Gopher and other similar protocols.
Bombadillo: is a TUI client for GNU/Linux, BSDs and Macos.
Elpher: is a client for GNU Emacs.
OverbiteWX: is an add-on for Firefox-based browsers.
Burrow Gopherspace Explorer: is an add-on for Chromium-based browsers

Once you have the client installed, Gopher works with URIs of type gopher:// You can start visiting some gopher holes⁷ like the following:

FloodGap Gopher Docs: gopher://gopher.floodgap.com/
Here you'll find lots of information and resources about Gopher.
SDF Public Access UNIX System: gopher://sdf.org/
One of the oldest and largest pubnixes.
Bongusta!: gopher://i-logout.cz/1/bongusta
A phlog aggregator.

If you feel like it you can visit my gopher hole at gopher://lucio.albenga.es/. I have a links section with these and other links to phlog aggregators, pubnix communities, and more Gopher resources like search engines.

Final Thoughts

Probably most people will discard Gopher claiming that it's an "obsolete technology" or other similar arguments, others will be curious to see what goes on and will be visiting it sporadically, a smaller number will continue to visit their favourite gopher holes and a few will end up creating their own gopher holes or even a pubnix server. All that is fine, Gopher does not intend to sell anything to anyone or to solve the problems of the world.

As I said before, Gopher is one of the alternatives to the bloat and abuses of the web. There are others like Spartan or Gemini, but the important thing is to know that at a time when many people are complaining about the bloatware on the WWW, are talkink about the indie web, the small web and the smolweb, permacomputing, small online communities, and other similar things, Gopher has been providing a lot of it since 1991 and here it is, waiting for us to decide to meet it and give it a chance like a veteran craftsman who may not look as good as when he was young, but whose ability and precision are able to create a tool that lasts us a lifetime.

See you on the Gopherspace (or not).

Footnotes:

I tried different websites from among the first search results. Take into account that I have some blockers so the real numbers could be higher.

Wikipeda Goldy Gopher

Some people has developed primitive session systems by autogenerating unique links "per session". These systems only work on single gopherholes and in no case something gets stored on the user's computer that allows to track him in the entire network or over time.

⁴

Keep in mind that Gopher is not an encrypted communication so if someone monitors you, he can see the contents you access, but that monitoring would have to be a man in the middle or your own Internet service provider. Although there are ways to have the Gopher equivalent of the WWW https, this is not part of the protocol specification.

⁵

Wikipedia FOMO

⁶

The proposed list contains only a few options, there are a lot more. Unlike the WWW that only has 2-3 main browsers, making a Gopher client is simple so there are many, which is another advantage because it avoids factual monopolies.

⁷

A gopher hole on Gopher is the same as a web page on the WWW, and a phlog (Gopher Log) is the the same as a blog on the WWW.

Why I Don't Use Creative Commons Licenses?

lfa — Fri, 29 Aug 2025 00:00:00 +0100

From almost two decades it's pretty common that the majority of content published on the Internet is done under some sort of Creative Commons license. In the past I did it too, but recent (or recent to me) events made me change my mind.

Many years ago I had a problem where part of my content was used on a website trying to impersonate me and I had many problems with their hosting company because they didn't want to remove those contents because they were released under Creative Commons. Anyway that didn't change my mind about CC, my mind changed because of the following two recent events:

The Creative Commons Signal proposal¹. You should see the discussions on GitHub² where you can see how CC turns a deaf ear to people's comments against the proposal.
A blog post³ that IMHO is too much in favour of the so-called AI. The post is from 2021 but I noticed it recently because someone shared it on Mastodon.

If we take into account that a great number of content released under a Creative Commons license is done under the CC BY-NC-SA⁴ and the CC BY-NC-ND⁵ licenses, that both licenses require that if you use a work under them you should attribute the original author and also forbid you to use the work for commercial use, we will see that Creative Commons has passed from being an organization that was allegedly in favor of artists and creators to one that seems to have ultimately sided with companies and organizations that to a great extent breach the terms of their licenses.

So, given this scenario and for ethical reasons, I can't keep using Creative Commons licenses nor support and/or encourage its use.

Footnotes:

Creative Commons Signal Proposal

CC Signals Open Feedback, Suggestions and Ideas

Should CC-Licensed Content be Used to Train AI? It Depends.

⁴

Creative Commons BY-NC-SA Deed

⁵

Creative Commons BY-NC-ND Deed

On Software, Licenses, Morals and Ethics

lfa — Sun, 20 Jul 2025 00:00:00 +0100

From time a discussion takes place on issues related to free software vs open source licenses. In this type of discussion, there are always free software advocates who defend the GPL and the AGPL and open source advocates and detractors of the free software movement (and more specifically of Richard Stallman and the Free Software Foundation), who defend the use of more permissive licenses such as MIT and the various BSD.

Generally speaking when people talks about open source software they focus on the technical side of things: collaborative development, better software quality by being developed by more people, greater security by having more eyes to review it, etc. Others focus more on the economic side which is mainly that they don't have to pay for the software. On the other hand when people talk about free software, they inevitably talk about concepts of a more humanist nature: ethics and morality, what is just and unjust for people, the greater good to say it in some way.

More or Less Free (As In Freedom) Licenses

The classic argument against the GPL and the AGPLv3 is that these licenses enforce certain restrictions so they are not really free while other most permissive licenses are. In short, these people complain about the fact that the GPL and, especially, the AGPLv3 doesn't allow someone to take a free software program and make a proprietary version of it.

Another argument that comes up from time to time is that, because of these "restrictions", if you license your project under the terms of the GPLv3 or the AGPLv3 no one is going to use it, so why do you want to do something no one will use? This is nonsense because many people use software under both licenses every single day, very likely even those who make such ridiculous comments.

When the free software movement talks about freedom, it talks about freedom for the users, understanding as a user someone who uses a program and / or the source code of a program, so the freedom to protect is mainly the freedom of individuals. Therefore both, the GPLv3 and the AGPLv3 seek to give a number of rights while ensuring no one can take them away.

This is why these licenses contain terms that allow users to redistribute the software with or without changes, free of charge or charging an amount, but with the obligation to do so under the same license. On the other hand the most permissive licenses do not include such "restrictive" terms, so in practice they allow anyone to deprive others from the same rights he is enjoying.

Both the GPL and the AGPL give these rights when the program is distributed, that is, a copy of it is given to the user. According to the GPL, the distribution occurs when the user receives a copy of the program to run it on his or her device, either by an online download of a file or set of files, or by distribution on a physical support: diskette, data tape, pendrive, cdrom, etc. As the saying goes, "where there's a law, there's a loophole" and certain actors found a way to take advantage of free software, make a profit from it and give nothing back. Thus Software as a Service (Saas) was born.

Those who offer software as a service, according to the terms of the GPL don't give a copy of the software, so they have no obligation to give back the changes they made to the software. The AGPLv3 comes to solve this loophole by adding the following in Section 13:

… if you modify the Program, your modified version must prominently offer all users interacting with it remotely through a computer network (if your version supports such interaction) an opportunity to receive the Corresponding Source…

This renders nearly impossible to offer the software without giving the source code to the user.

Who Profits From What?

Taking into account all of the above, it is quite easy to realize that a program under a more permissive open source license is interesting for companies of a certain size that have the means to capitalize this software either by selling it as a service, or by making some changes to it and by reselling it as proprietary software. The typical cases are, of course, those companies known as big tech. Apple took permissively licensed software under BSD licenses, modified it and made their propietary OSes Mac OS X and iOS. Microsoft and Amazon with their cloud computing services are another example of how to profit from GPL-licensed software without having to give anything back.

Regarding the argument of "why do you do something if no one is going to use it", I think that "no one" mainly refers to this type of companies. One example is Google prohibits its engineers to use any code licensed under the AGPLv3¹.

Among the affected there are many cases to choose from, individuals and, not so big, tech companies alike. Some famous ones are the case of javascript colors and faker packages² (licensed under the MIT license), Log4j³ (licensed under Apache APL 2.0) and Redis⁴ (originally licensed under BSD-3 clause), MongoDB⁵ (originally licensed under AGPLv3) and ElasticSearch⁶ (originally licensed under Apache APL 2.0).

Anyway, Software Has To Be Open Source, Right?

Taking into account the criticism made by members of the open source community to Redis, MongoDB, ElasticSearch and even to the colors and faker developer, Marak Squires, anyone could think that the only thing everyone agrees with is that software has to be open source. However, some facts seem to indicate that it depends.

If you are a small actor like an indie developer, a small development team or a company that is not extremely large, it matters a lot that your software is not proprietay. On the contrary, much less importance is given when the proprietary software turns out to be the MacOS operating system running on the MacBooks used by many open source developers, or if the proprietary software makes nVidia graphics cards and Qualcomm WiFi chipsets work properly on Linux kernel based systems.

No surprises here given that an important number of those who give ethical and moral lessons, and advise on software licenses, do so as they are on their way to the bank in order to cash their checks signed by RedHat (IBM), Google, Meta, or Microsoft, among others. In this charming panorama, you'll find all sorts of gems, from the open source community leader who get mad because someone tries to reverse engineer a proprietary program to make a free version of it⁷, to the open source flagship company that takes all the free software it wants and make a de facto proprietary product out of it⁸.

Final Thoughts

Time and experience taught me that free and open source programs can be made and used for abusive purposes, the very same way that I have also seen indie developers and small development teams make proprietary programs that provide them with a decent income without exploiting, extorting or taking advantage of anyone. I think everyone can do with their time and money whatever they want and like, as long as they don't harm anyone.

I'm ok with people who make free software under whatever license they like, even though I always recommend the AGPLv3, because they want to contribute altruistically to society and/or make a living out of it, and I'm also ok with people who make an honest living by doing proprietary software. On the other hand I'm absolutely not ok with people who act in bad faith, who say one thing while they're doing the opposite, who are trying to give an appearance of commitment to society when they actually manipulate things so that the coporations that sign their checks get outrageous earnings by deceiving and exploiting everyone else.

The bad is not in licenses or programs. The bad is not in whether you do free software, open source software, or proprietary software. The bad lies in the lack of critical thinkng and the lack of honesty. The bad is in people's egos and sick ambitions.

Footnotes:

Google Open Source AGPL Policy

Bleeping Computer: Dev Corrupts NPM libs Colors and Faker Breaking Thousands of Apps

The Register: Log4j doesn't just blow a hole in your servers, it's reopening that can of worms: Is Big Biz exploiting open source?

⁴

Redis Adopts Dual Source-Available Licensing

⁵

The Register: Fed up with cloud giants ripping off its database, MongoDB forks new 'open-source license'

⁶

Geeker's Digest: Elastic changes its open source license, becomes "less open"

⁷

Torvalds knifes Tridgell

⁸

Red Hat strikes a crushing blow against RHEL downstreams

Mega65 a modern retromachine: first contact through the emulator

lfa — Sat, 14 Jun 2025 00:00:00 +0100

Figure 1: Image of the Mega65 from the official website.

Some years ago I found by accident the Mega65¹, a new 8-bit computer, the succesor of the never released Commodore C65. In fact this machine is based on Commodore C65 prototypes and its ROM was based on that of the original C65, which logically contained many bugs yet to be fixed, as it was only a prototype still in development.

This computer uses an FPGA and, besides being an enhanced Commodore C65, it offers C64 compatibility both through the Mega65's own core, which replicates the compatibility layer the Commodore engineers originally planned to include in the C65, and through a dedicated core that fully emulates the C64. Currently there are other cores too like one of a ZX Spectrum and another of a Gameboy.

A few days ago, I remebred this project and I wanted to take another look at it to see how it had evolved. I found out that besides BASIC and Assembler, now it could be programmed with C and there is also a PASCAL environment available. I also noticed there was an emulator called Xemu² so I decided to install it and check out the Mega65.

Installing and setting up Xemu

You can find the source code of Xemu on GitHub³, but the developer provides several packages⁴, including one for Ubuntu that works perfectly on my Devuan GNU+Linux system. I downloaded and installed it.

As usual, the emulator requires the system ROM. I followed Xemu's official docs⁵ and everything worked flawlessly. The process is not difficult but it does require some work on our part. First I obtained the Commodore C65 ROM searching for 910828.bin on the internet. Then I downloaded the Mega65's ROM changes from the official files site⁶ (search for BDF).

Once I had all the files I patched the C65 ROM with Mega65's changes. I installed bsdiff and then I used the command bspatch which is part of bsdiff.

sudo apt install bsdiff
bspatch 910828.bin new-920364.bin 920413/920413.bdf

910828 is the C65's original ROM
new-920364.bin is the name of the patched ROM
920413/920413.bdf are the Mega65's changes

With the ROM and the emulator installed I launched the emulator and said YES when the program asked if it should generate the initial virtual SD Card, etc. You can launch it from your DE menu or from your cli with the command:

xemu-xmega65

To load the ROM I right clicked on Xemu's screen and then I chose "Disks" -> "SD-card" -> "Update files on SD image". Then right clicked again on Xemu's window and I chose "Reset/ROM Switching" -> "Reset". After that I got the emulator working.

Figure 2: Image of the Mega65 system running under Xemu.

Checking out and enjoying the Mega65

Next thing I did was to get the offical docs in order to see how to do basic tasks on the system. I also did a few BASIC, basic tests ;), and I downloaded and played the game "Meteor Defense" to check out if the emulator was working. You can get the official docs, games and more from the official Mega65 files site (check out the footnotes).

Figure 3: Screenshot of Meteor Defense running on Xemu.

After playing with the game I decided to write a bigger program in BASIC, so I typed the program "Monster Chase" from the book Stimulating Simulations by C. William Engel⁷. I run the program, saved it to a virtual disk image, reload it from the virtual disk and run it again.

The game worked flawlessly and I must confess I really enjoyed the experience of typing a game in BASIC from a book to play with it. Although this might seem like a joke nowadays, back when I started with computers in the 80s it was very common, and I doubt anyone who hasn't gone through this ritual can truly understand or appreciate it.

Figure 4: Screenshot of Monster Chase running on the Mega65 emulator.

After checking everything out with BASIC, I installed the llv-mos⁸ compiler on my system to cross-compile a C program for the Mega65. llvm-mos has a target for the C64, mos-c64-clang, but it also has a specific target for the Mega65, mos-mega65-clang. Sadly things didn't work out as expected.

Compiling the program for the C64 and runnig it on the emulator using the Mega65's compatibility layer for the C64 worked like a charm, but compiling the program for the Mega65 and running it under the Mega65 regular mode it crashed. I didn't know if it was something related to the compiler or the emulator.

Figure 5: C program runnig on Xemu under the Mega65's compatibility layer for C64.

Figure 6: The same C program running on Xemu under the Mega65's main mode.

Final thoughts

I have mixed feelings about this machine since the price isn't exactly low, and the fact that such a simple program written in C didn't work discouraged me quite a bit. However, I'll keep an eye on the project's progress. In the meantime, I will continue enjoying it through the emulator.

Who knows what surprises this machine might hold in the future!

Footnotes:

Mega65 Official Website

Xemu's Official Website

Xemu on GitHub

⁴

Xemu's Packages Download Page

⁵

MEGA65 ROM "how to get it" tutorial for Xemu

⁶

Mega65 Files

⁷

Stimulating Simulations at Archive.org

⁸

llvm-mos Official Website

How To Create and Publish Your Website With Emacs and Org Mode

lfa — Sun, 01 Jun 2025 00:00:00 +0100

This howto is a translation of the original one in Spanish.

Static site generators have been quite popular for some time now as a way to create websites and most of them use Markdown as the markup language to generate the site's HTML content. Org Mode is part of many Emacs users daily routines, and once you are comfortable with it, it becomes a real pleasure to use, so why not leverage it for website content creation as well?

In this howto we will see how to use Pelican static site generator to create a website using Emacs Org Mode. This howto is not intended to cover all of Pelican's features, capabilities, or configuration options. For a complete reference, you should use the official documentation¹, which is actually quite good and comprehensive.

I'm assuming you already know what Emacs and Org Mode are, and that you know how to use both. In fact, if you are reading this, chances are you are a regular Org Mode user.

Installing Pelican and Setting Up The Base Website

First step is to download and install Pelican. I do it with virtualenv but you can check out other alternatives at Pelican's website². I open a terminal, navigate to the directory where I keep my virtual environments, and then execute the following commands:

virtualenv pelican           # creates the virtual environment
source pelican/bin/activate  # activates the virtual environment
pip install pelican          # get and install Pelican

If you don't have virtualenv already installed, probably you can find it on your GNU/Linux distribution packages. If your system does not provide the package check out Virtualenv's official docs³.

The virtual environment stays active in this terminal session until you run deactivate. Don't do that yet, you still need it for the upcoming steps.

Once you have Pelican installed you should follow the quickstart steps to create the web site:

mkdir -p /local/path/to/your/website/project/folder   # create a folder for your web project
cd /local/path/to/your/website/project/folder         # mone inside the folder
pelican-quickstart                                    # execute quickstart

As part of the quickstart process, Pelican will prompt you with a set of questions to configure your website project. The answers will vary depending on your needs, but here are the prompts with sample responses to guide you:

> Where do you want to create your new web site? [.] 
> What will be the title of this web site? My Web Site
> Who will be the author of this web site? myself
> What will be the default language of this web site? [en] 
> Do you want to specify a URL prefix? e.g., https://example.com   (Y/n) Y
> What is your URL prefix? (see above example; no trailing slash) https://mysite.com
> Do you want to enable article pagination? (Y/n) Y
> How many articles per page do you want? [10] 
> What is your time zone? [Europe/Rome] 
> Do you want to generate a tasks.py/Makefile to automate generation and publishing? (Y/n) Y
> Do you want to upload your website using FTP? (y/N) N
> Do you want to upload your website using SSH? (y/N) y
> What is the hostname of your SSH server? [localhost]
> What is the port of your SSH server? [22] 
> What is your username on that server? [root] user
> Where do you want to put your web site on that server? [/var/www] 
> Do you want to upload your website using Dropbox? (y/N) N
> Do you want to upload your website using S3? (y/N) N
> Do you want to upload your website using Rackspace Cloud Files? (y/N) N
> Do you want to upload your website using GitHub Pages? (y/N) N

At this point, you can execute deactivate on the terminal to leave the virtual environment, we have a few things to take care of before we need it again.

Setting Up Pelican for Org Mode

To accomplish our goal we will need the org_reader plugin⁴. Let's get Pelican's plugins. The quickest way to get the plugins is by cloning the GitHub repo⁵ and put them inside a folder. Navigate to the folder where you want to store the plugins and clone the repo:

cd /path/to/folder/where/plugins/will/be/stored
git clone --recursive https://github.com/getpelican/pelican-plugins

Now open the file pelicanconf.py and add the following right at the beginning:

import os # this line shold be already inside the file

PLUGIN_PATHS = ["/path/to/pelican/plugins/folder"]
PLUGINS = ["org_reader"]

If you have an Emacs installation in a non-standard location, add the following line:

ORG_READER_EMACS_LOCATION = "/path/to/emacs/bin/emacs"

Adding Syntax Highlighting

One thing I was missing on my website was syntax highlighting for posts with source code like this one. After a bit of searching, I found Anten Linevich's site⁶, where he fixed it by creating a custom export backend. In order to do this let's open pelicanconf.py again and add the following:

ORG_READER_EMACS_SETTINGS = os.path.abspath("lisp/pelican-html.el")
ORG_READER_BACKEND = "'pelican-html"

Now you should create the custom export backend pelican-html. Just follow these steps:

Add inside your site's root folder a new folder named lisp/. You can name the folder whathever you want but the name has to match the path defined on ORG_READER_EMACS_SETTINGS.

Inside the lisp/ folder, add a file named pelican-html.el and put the following inside it:

      ;; This code is (c) 2017 Anten Linevich and is released under
      ;; Creative Commons Attribution 4.0 Internacional License
      ;; https://linevi.ch/en/org-pygments.html

      (require 'org)
      (require 'ox)
      (require 'ox-html)

      (org-export-define-derived-backend 'pelican-html 'html
        :translate-alist '((src-block .  pelican/pygments-org-html-code)
                           (example-block . pelican/pygments-org-html-code)))

      (defvar pygments-path "pygmentize")

      (defun pelican/pygments-org-html-code (code contents info)
        "Process code block with Pygments See http://pygments.org/ for details"

        ;; Generate temp file path by hashing current time and date.
        (setq temp-source-file(
             format "/tmp/pygmentize-%s.txt"(md5 (current-time-string)))
        )
        ;; Writing temp file
        (with-temp-file temp-source-file (insert (org-element-property :value code)))
        ;; Processing
        (shell-command-to-string (format "%s -l \"%s\" -f html %s"
                                         pygments-path
                                         (or (org-element-property :language code)
                                             "")
                                         temp-source-file)))

      (provide 'pelican-html)

Save the file and syntax highlighting will be ready to go.

Writing Your First Post

Let's write a first post in order to see a basic template you can reuse when writing new posts.

There are a lot of properties (metadata in Pelican's jargon) which you can use to set up a post. Here I'm only including the ones I consider most common and/or important. You can check out Pelican's and org_reader's docs (see footnotes) to get the full list.

Inside the content/ folder of your Pelican website create a file hello-world.org with the following content:

#+TITLE: Hello World!
#+DATE: 2024-05-24
#+AUTHOR: admin
#+LANGUAGE: en
#+CATEGORY: Programming
#+PROPERTY: LANGUAGE en
#+PROPERTY: SLUG hello-world
#+PROPERTY: SUMMARY This is the post summary
#+PROPERTY: SUMMARY+ and it can have multiple lines
#+PROPERTY: TAGS programming, clang

Next we will see Hello World source code in C.
#+BEGIN_SRC c
  #include <stdio.h>
  int main(void)
  {
          printf("Hello World!");
          return 0;
  }
#+END_SRC


#+BEGIN_EXPORT html
<hr>
<center><small>
And this is a HTML block.
<p>
<a href="https://creativecommons.org/licenses/by-nd/4.0/">Creative Commons Attribution-NoDerivs 4.0 International (CC BY-ND 4.0)</a>
</p></small>
</center>
<hr>
#+END_EXPORT

Let's see the meaning of all these properties:

#+TITLE: Hello World! this is the only mandatory property.
#+DATE: 2024-05-24 the date of the document. It could be an iso format date or an Org Mode timestamp.
#+AUTHOR: admin author name
#+LANGUAGE: en document language for Org Mode
#+CATEGORY: Programación post category
#+PROPERTY: LANGUAGE es document language for Pelican
#+PROPERTY: SLUG hello-world if you don't use this property, Pelican will use file_name.org
#+PROPERTY: SUMMARY post summary
#+PROPERTY: TAGS programming, clang all the tags you want to use

Apart from the properties shown in the example, there is one I find essential: #+PROPERTY: STATUS. This property can have the following values:

published: this is the default status
draft: post will be stored inside the drafts/ folder, inside the website, and it will not be linked anywhere.
hidden: post is not linked anywhere, so you should know the exact URL to get to it.

Therefore, if you want to have a hidden post, you should add this property:

#+PROPERTY: STATUS hidden

Previewing and Publishing Your Website

The moment of truth has arrived, time to see the results of all the work you have done, check that everything works, and find out how to generate and publish your new website

From inside your site's root folder follow these steps:

Activate the virtual environment

   source /path/to/pelican/virtualenv/bin/activate

Start the site preview in your local system by running:
```
   make devserver
```
If you look closely, the previous command will return, among other things, the following:
```
   Serving site at: http://127.0.0.1:8000 - Tap CTRL-C to stop
```
Copy & paste the url http://127.0.0.1:8000 in your favourite web browser in order to see your website. The devserver mode automatically rebuilds the website whenever changes are saved in the *.org file, allowing you to view the updates instantly by refreshing the browser.
You can quit the devserver mode by pressing the keys CTRL-C. Now you can publish your website by running:
```
   make rsync_upload
```
Executing this command will rebuild the whole site and deploy it to the destination configured during the quickstart setup. If this doesn't work or isn't available, open the Makefile located in the root directory of your website, where you will find all the possible deployment options (ssh_upload, sftp_upload,…).

Next Steps

This howto has introduced the basics of creating a website using Pelican and managing content with Emacs and Org Mode. The next step is to explore Pelican in more depth to customize your site. Consult the Pelican documentation, choose a theme⁷ you like, or make a custom one.

Acknowledgements

I want to thank BxCx from #emacs-es channel on Libera.chat⁸ because the idea for this howto originated when he started talking about creating a static site with Emacs, and he asked me about how I built my site.

I want to thank Anten Linevich because without his post I wouldn't have figured out how to enable syntax highlighting.

Copyright

Footnotes:

Pelican Official Documentation

Pelican Official Documentation: Installing Pelican

Virtualenv Official Documentation

⁴

Org-reader Plugin

⁵

Pelican Plugins on GitHub

⁶

Anten Linevich's Website

⁷

Pelican Themes on GitHub

⁸

Libera.chat

FreeBSD: KLD i915kms.ko depends on kernel - not available or version mismatch

lfa — Thu, 17 Apr 2025 00:00:00 +0100

After upgrading from FreeBSD 14.1 to FreeBSD 14.2 some people like me had some problems because the graphics modules were built for 14.1 only. One of the drawbacks was loosing access to virtual terminals. Let's see how I solved that problem and I got rid of the: "KLD i915kms.ko depends on kernel - not available or version mismatch", error.

First attempt

At first, I checked out the internet and it seems it was a documented problem. Many people were telling to rebuild the drm-61-kmod package from ports tree, so I tried that approach first.

Following The FreeBSD Handbook¹, I cloned the ports tree from git:

git clone --depth 1 https://git.FreeBSD.org/ports.git /usr/ports

Then I built the drm-61-kmod:

cd /usr/ports/graphics/drm-61-kmod/
make
make install

I got a message about that I already have that module installed followed by the instructions to reinstall it, so I executed make reinstall on my console, restarted the system, and hoped for the best. It didn't work.

I kept searching for my problem and I found another thread about rebuilding drm-kmod too. I did it:

cd /usr/ports/graphics/drm-kmod/
make
make reinstall

But it didn't work. I noticed that I got the following error on dmesg: KLD i915kms.ko depends on kernel - not available or version mismatch. I know I have the module loaded, so I started to look for other modules that maybe I need to build in ports, especially things related to i915. I found the port /usr/ports/graphics/gpu-firmware-kmod, so I built it:

cd /usr/ports/graphics/gpu-firmware-kmod/
make
make reinstall

Restarted the system only to find out that the very same error was still there.

Second attempt

At that point I thought: "ok, maybe I messed up by building the modules in a wrong order or something. Let's redo it". First, I uninstalled and cleaned the build of all those modules:

cd /usr/ports/graphics/gpu-firmware-kmod/
make deinstall
make clean

cd ../drm-61-kmod/
make deinstall
make clean

cd ../drm-kmod/
make deinstall
make clean

Then I rebuilt the modules. This time I started by building drm-kmod. Doing this I discovered that drm-kmod automatically builds also drm-61-kmod. I built also the gpu-firmware-kmod, installed the modules and restarted the system. This time for sure things are going to work… Nope! After rebooting the system, dmesg was still showing that damn message.

Final solution

I'm new to FreeBSD, but I was using, setting up, and administering GNU/Linux systems since the 90s, thus I thought the solution to that pesky KLD i915kms.ko depends on kernel - not available or version mismatch error, could be solved by building a new kernel and the modules, to have everything in sync.

I cloned the kernel sources from FreeBSD's git²

git clone https://git.FreeBSD.org/src.git

Then I checked out the sources for the kernel version for FreeBSD 14.2 (at the moment of this writing they are under the tag release/14.2.0-p3):

git fetch --all --tags --prune
git checkout release/14.2.0-p3

Then I rebuilt the GENERIC kernel because I don't use a custom one. If you use a custom kernel, you already know the steps you should take to build it.

cd /usr/src
make buildkernel KERNCONF=GENERIC
make installkernel KERNCONF=GENERIC

With the new kernel, I rebuilt and reinstalled the modules:

cd /usr/ports/graphics/gpu-firmware-kmod/
make deinstall
make clean

cd /usr/ports/graphics/drm-61-kmod/
make deinstall
make clean

cd /usr/ports/graphics/drm-kmod/
make deinstall
make clean
make
make install

cd ../drm-61-kmod/
make install

cd ../gpu-firmware-kmod/
make
make install

Then I restarted the system and now everything works as expected. Mission accomplished!

Final words

I have to say that it was really fun because it took me back to the good old days when you had to compile the Linux kernel in order to make your hardware work. I haven't compiled a kernel in about 20 years or so. Probably there is a better approach but this one worked for me and maybe it will work for others too.

Footnotes:

FreeBSD Handbook

FreeBSD Git

Quasijarus2Gzip: How A Program Starts By Accident

lfa — Wed, 30 Oct 2024 00:00:00 +0000

It turns out that recently I got an old *.tar.Z file with source code of various very old Unix programs. I was curious about some of them like a very old version of sendmail, but when I tried to decompress one of the files I found out that I couldn't.

Previously I had already decompressed *.tar.Z files with gzip so the next thing I did was to see exactly what that *.tar.Z file was. To do this I used the file command and found out that it was a Quasijarus Strong Compression Data file. I didn't know what it was so I kept investigating.

My next step was to find out exactly what the Quasijarus Strong Compression Data format was. First I found a brief description of the format¹ which contained links to the Quasijarus project website. These links are no longer online, but thanks to archive.org² I was able to see the Quasijarus project website³ and specifically the information on the compression format⁴.

After reading it all, the main points for me were:

The file format is based on Gzip and both formats only differ in their headers.
The header of the Quasijarus Strong Compression Data format is only composed by the 0x1f 0xa1 bytes (magic number).

So I decided to make a Quasijarus Strong Compression Data to Gzip converter as it couldn't be very complicated. It also provided to me an excuse to have some fun ;p.

The last step was to find out the format of the header of the Gzip file format. According to its specification⁵, it has a header of 10 bytes distributed as follows:

2 bytes for the magic number 0x1f 0x8b
1 byte for the compression algorithm (08 for DEFLATE).
1 byte for headers flags that could be set to 0.
4 bytes for the file timestamp that can also be set to 0.
1 byte for compression flags that can be set to 0 too.
1 byte for the operating system identifier (3 for Unix)

With all this information I made my Quasijarus Strong Compression Data to Gzip converter. You can download it here.

(This post is a translation of the original one in Spanish).

Footnotes:

Quasijarus Strong Compression

Wayback machine at archive.org

Quasijarus Project

⁴

Quasijarus Compress

⁵

RFC1952

Hello World!

lfa — Wed, 15 May 2024 00:00:00 +0100

When you learn a new programming language it is customary to do the program Hello World!. My first programming language was BASIC and I didn't do the classic Hello World!, I did a program that displayed my name on screen.

My first Hello World!, like that of many other programmers, was the one from the book: The C Programming Language, also known as K&R, by Brian W. Kernigham and Dennis M. Ritchie.

I think it is quite appropriate to follow tradition and start with a Hello World!, and nothing better than making it in C.

#include <stdio.h>
int main(void)
{
        printf("Hello, World!");
        return 0;
}