If you are interested in printing banners, or just curious, read ahead.

It’s also worth checking this Veronica Explains video about printing dot matrix nowadays.

Dot Matrix printers

Dot matrix printers are just incredible. Granted, they are slow and noisy, and quality of print is nowhere near the one of a laser, but they have their own good points.

It’s fascinating to see how printing actually happens, with the rows which appear one after another: taking a look at the printing head is also very instructive, as you understand how the ink is transferred to paper. They’re not a closed box like modern lasers or inkjets.

New dot matrix printers are sold even now, as they are still used in some business environments. However, maybe shelling out 500-700 Euros can be a bit steep, so why not use an old printer? They still work fine after 30 years, and using old hardware can be sustainable choice.

For this article I’m using a NEC Pinwriter P20, a printer I’ve owned since when it came out in 1992. It’s a parallel printer of course, but a USB-to-Centronics cable costs just 10-15 Euros and does its job nicely. Also, it’s very easy to find ink ribbons for such printers.

It works surprisingly well with Linux (Pop!Os 22.04): CUPS automatically sees it once connected, even though you have to choose the driver manually: there is the PPD a driver for NEC PinWriters, so once chosen from the list the printer just works, and you can print anything as if it were a laser. Awesome, if not unbelievable, for a 30-year-old printer.

Printing a banner on multiple sheets of continuous paper, however, is another matter, as it’s non-obvious to have it come out as expected.

Paper sizes

If you are in Europe, like I am, you may only know of A4 as paper size for printing on a computer, which is the format 99% of people use nowadays. However, it has not always been that way.

Until mid-90s, when dot matrix printers began to go out of fashion, US Letter (8.5” x 11”) was widespread across Europe. Why? Because continuous computer paper was available in that size, at least for standard 80-columns printers.

The continuous paper is actually 9.5” x 11”, because it has the side strips for the tractor. In Europe the format is better known as 24 x 11”, where 24 is the width in centimeters (including side strips) and 11 the height in inches. A bizarre side note: the width is expressed in centimenters and the height in inches.

If you are interested in more information about US Letter paper size, take a look at this video.

Creating a banner

I’m using LibreOffice Draw these days, which does its work well.

First off, we have to set the page size, creating a user-defined one. This depends on how many sheets you want the banner to occupy: the longer, the nicer… but it also takes longer to print and more ribbon ink. 😉

A good idea is to set the page in Horizontal (landscape) orientation, so reverse width and height, so that you can easily see what you are writing, and you get a better idea of the final result.

I recommend to set all margins to 0: dot-matrix printers can print right to the edges of the paper: that’s really cool, isn’t it?

You can download this banner here: in ODG format or PDF format.

The font comes from a fantastic web site with loads of fancy fonts, like the ones we used in the 90s… and they’re even free for personal use! Here’s the link to this awesomeness: 1001 Free Fonts.

Properly printing the banner

I found many suggestions on the web, which basically were down to “select the LO Draw option which allows to print across multiple sheets”. These methods do not work, because - even when I managed to not print a complete mess - form feeds are put between one page and the other, which make no sense when printing banners and create empty space, thus breaking the banner.

What you need to do is to create a custom page size for printing, which is as big as the banner: exactly the same thing we did earlier for the page in LibreOffice Draw: now it has to be done in the printing dialog as well.

Now the problem is that LibreOffice Draw uses itss custom printing dialog, which is a bit limited compared to the system one, i.e. it doesn’t allow you to enter a custom paper size in the printer configuration.

So, just save the banner in PDF format.

Open the saved PDF with your viewer. At present I’m using Evince Document Viewer, which is the default in Pop!OS, and choose the print function: this will open the printing dialog.

Just like LibreOffice, some viewers have their own printing dialog, which may not offer all the options of the system one. In my case it didn’t offer the option to set a custom page size, but luckily there was a button called Use system printing dialog which opened the full-featured one. LibreOffice Calc lacks this button, which makes it necessary to go through a PDF conversion.

The important thing here is to set the page size: in the Page settings tab of the system printing dialog, look at the Paper size selector: inside it you can find a Manage custom sizes option, which opens another dialog. In this dialog you can add the size you need (the screenshots are in Italian language, sorry).

As before, I’d set all margins to 0.

The good thing is that of the above process is that you only need to add page sizes once: the system will then remember them. The bad thing is that LibreOffice custom dialog won’t see them anyway, so you still need to use PDFs.

Ça va sans dire, you need to select Horizontal (landscape) orientation. Printing begins from the end (like in my photo). I actually found out that (in some cases I am still investigating) this setting adds unwanted white lines before printing something, so I recommend Reverse horizontal, which prints from the beginning instead (basically, the banner is rotated 180 degrees before being sent to the printer).

Happy banner printing!

How does 2FA work?

Two-factor authentication (TFA) is just a generic concept, which means you need to provide two sets of security credentials (factors). These are usually username, password and a code (usually 6-digits long). This one may be sent you via text (SMS) by the website, or generated by an app on your phone.

The second system is now widely used. Putting it simple: based on a secret key provided at activation, the app generates a different code every 30 seconds, which you provide at login and the service will check if it matches.

Many people use Google Authenticator, which is the most famous app for token generation. However, most folks do not know that, even though the web site or service might ask you to install Google Authenticator, it really doesn’t matter what app you use: it just has to support the Time-based one-time password (TOTP) algorithm. I, for instance, use Microsoft Authenticator, which is still free of charge but provides better security and some backup options.

2FA in Perl

There are a couple of Perl modules to perform 2FA: Auth::GoogleAuth and Authen::TOTP. I chose the first one because it had more recent updates, however the name of the latter seems more appropriate as this kind of authentication system is not tied to the Google app, or any other one.

First off, you need to create a ID and secret for the user when he activated the 2FA.

my $gauth = Auth::GoogleAuth->new({
    issuer => 'My Web Site Name',  # No high chars, stay in ASCII set
    key_id => $username,
});

The issuer is a text string which identifies the service, so that the user can actually choose the correct code (also know as OTP, one-time password) among the ones generated by his authentication app. I saw that this field must only be ASCII chars, but I don’t know if it’s by definition or the problem lies in Google’s QR generation service or in my authentication app or whatever.

The key_id is something related to the user itself, such as the username or the e-mail address. This value must be provided also when veryfing the secret, so if it changes the secret key will no longer work and a new one will have to be generated.

Now let’s compute a secret unique to the user. This is something random, which Auth::GoogleAuth can generate for you (or you can pass it, see the module’s documentation for details).

my $secret32 = $gauth->generate_secret32;

# Store the secret somewhere user-related, i.e. in it's profile
$db->query(
    'update users set secret32 = ? where username = ?',
    $secret32, $username
);

Now we can create an HTML which shows the QR and other information, which should appear as this (sorry, it’s in Italian language 😊):

The relevant part of the code is something like this:

<div>
    <% my $qrurl = $gauth->qr_code =~ s/200x200/500x500/xsr; %>
    <img src="<%= $qrurl %>" class="img-fluid">
    <br>
    <b><%= $gauth->secret32 %></b>
</div>

This CPAN module supports generating QR Codes using Google’s service, but it always passes 200x200 as dimension, so in the above code I tweaked the URL a bit. You can also use modules such as Imager::QRCode to generate the QR code by yourself. I may submit a patch in the near future to at least support passing the dimensions to qr_code().

Now the user can scan the QR with his app (or enter the code manually) and have it appear in his app. He will then have to enter one code/OTP in order to go through verification and enable the whole this: this process should be well known to most Internet users.

The verification process, usually when logging in, is something like this:

my $gauth = Auth::GoogleAuth->new({
    # No high chars, stay in ASCII set
    issuer => 'My Web Site Name', 
    key_id => $username
});

# Retrieve the secret
my $secret32 = $db->query(
    'select secret32 from where username = ?',
    $iduser
)->hash->{secret32};
$gauth->secret32($secret32);

my $isvalid = $gauth->verify(
    $q->param('otp'),     # code
    1,                    # range
);

The range can be a value of 0 or greater. This tells the verification method how many “nearby” codes (OTPs) to accept as valid besides the exact one of this moment. Since device clocks are not always perfectly synchronized, it’s possible that the client has one code when the server already has another one: or that the user loses some time in typing it in and it expires. A value of 1 is ideal, as it accepts also the code generated before and the one generated after the current time of the machine which checks it.

And that’s it!

The module has a series of other interesting options which I encourage you to check.

What does it do? It simply defers the execution of some code to the end of the enclosing block. It’s a very useful construct, because (in my opinion) it allows to make code much cleaner.

I put down a simple example which renders a checkout page for an fictional e-commerce site. There are some conditions which bring to different result, with instruction

The first version uses a classic if/else approach. Since there are functions to be called between evaluation of conditions, the if/elsif approach on a single level does not fit, so a nesting of conditional statements is needed.

sub checkout() {
    my $tplargs;

    if ( !is_user_logged() ) {
        $tplargs->{error} = 'not_logged';
    } else {
        my $user = get_user();
        my $cart = get_cart_contents();
        if ( !@$cart ) {
            $tplargs->{error} = 'empty_cart';
        } else {
            my $shrate = calc_shipping_rate($user, $cart);
            if ( !defined $shrate ) {
                $tplargs->{error} = 'cant_ship_there';
            } else {
                my $res = finalize_order($user, $cart, $shrate);
                if ( $res->{status} eq 'ko' ) {
                    $tplargs->{error} = 'processing_error';
                } else {
                    $tplargs->{success} = 1;
                }
            }
        }
    }
    render_template('checkout.html', $tplargs);
}

Not he best, uh?

The second attempt moves everything to a single level, using return statements. Without nesting, code is more straightforward but longer, especially the render_template('checkout.html', $tplargs); instruction.

sub checkout() {
    my $tplargs;

    if ( !is_user_logged() ) {
        $tplargs->{error} = 'not_logged';
        render_template('checkout.html', $tplargs);
        return;
    }

    my $user = get_user();
    my $cart = get_cart_contents();

    if ( !@$cart ) {
        $tplargs->{error} = 'empty_cart';
        render_template('checkout.html', $tplargs);
        return;
    }

    my $shrate = calc_shipping_rate($user, $cart);
    if ( !defined $shrate ) {
        $tplargs->{error} = 'cant_ship_there';
        render_template('checkout.html', $tplargs);
        return;
    }

    my $res = finalize_order($user, $cart, $shrate);
    if ( $res->{status} eq 'ko' ) {
        $tplargs->{error} = 'processing_error';
        render_template('checkout.html', $tplargs);
        return;
    }
    
    $tplargs->{success} = 1;
    render_template('checkout.html', $tplargs);
}

Enter defer, which allows to define at the top (or somewhere else) in the sub something which must happen at the end of the execution scope.

sub checkout() {
    my ($error, $tplargs);

    defer {
        $tplargs->{error} = $error;
        render_template('checkout.html', $tplargs);
    }

    if ( !is_user_logged() ) {
        $error = 'not_logged';
        return;
    }

    my $user = get_user();
    my $cart = get_cart_contents();

    if ( !@$cart ) {
        $error = 'empty_cart';
        return;
    }

    my $shrate = calc_shipping_rate($user, $cart);
    if ( !defined $shrate ) {
        $error = 'cant_ship_there';
        return;
    }

    my $res = finalize_order($user, $cart, $shrate);
    if ( $res->{status} eq 'ko' ) {
        $error = 'processing_error';
        return;
    }
    
    $tplargs->{success} = 1;
}

Cleaner and elegant, isn’t it? It is also informative, as reading the beginning of the sub, it’s immediately obvious what happens at the end.

I think defer will become a very appreciated addition to the Perl language.

Why would I want to leave Gmail?

There are plenty of reasons:

• Privacy: most major email providers have serious privacy issues, but at least stalking you isn’t their core business, as it happens with Google.
• Webmail: Gmail web interface was nothing short of revolutionary when it was launched, back in 2004, but it evolved into a bloatware full of mostly useless - if not totally worthless - features.
• Ads: unless you pay for a Google Workspace subscription, you get tons of ads in various shapes, some of which are very creative: they vary from suggestions put between your messages (which is reasonable, a free service needs to pull money in some way) to custom sponsored content which haunts you everywhere in your online experience.
• IMAP support: folders - a bizarre IMAP representation of Google’s own labels concept - are clumsy, deceptive and tend to leave you with tons of duplicated messages.
• Biodiversity: Internet was born with great ideals of freedom and distributed governance: show that these principles are still alive in you, don’t allow all e-mails in the world to be in the hands of a few companies (Google, Apple and Microsoft in particular).

What are the options?

I’m not recommending any particular provider, but just what I think are the rules to help choosing it:

• Enter in a state of mind where you have to pay for good e-mail service. Be willing to shell out from 20 to 50 Euro per months, for a 8 to 25 Gb quality mailbox.
• Prefer a relatively small email service provider - it is less likely they monitor your data to sell it to someone or to use it to target you with “content of your interest”.

Properly transferring away mail from Gmail via IMAP

Now to the important thing. How to migrate away all my email from Gmail to the new provider?

Any decent provider will offer a tool for migrations, which will basically connect via IMAP to your Gmail mailbox, download all the messages, and transfer them to you new account. Many of these tools are quite sophisticated, and they will map the IMAP folder hierarchy perfectly, so that you will experience a smooth transfer.

If the provider does not provide a tool, look for another one. But there are also a lot of software packages (the best ones are not free, though) which download the e-mail from the old mailbox and upload it to the new one. Or, well, you could always do it by hand using Thunderbird or Outlook, but this is not particularly reliable for large boxes, in my own experience.

Even though Gmail’s folders are actually labels, everything tends to work well, as (for example) messages with the Sent label are mapped to a Sent folder and therefore correctly migrated.

There is, however, a problem in the All Mail folder, which contains (as the name suggest) all your mail: things your archived (that’s it to say, they live in no other place), but also everything else: Inbox, Sent, messages in other folders (=with other labels). The only messages which are spared are the ones in Spam and Trash. If you think this is awkward, it’s not only that: it’s also bad implemented on the IMAP side, because it insists putting every message into All Mail, this creating a lot of duplication, adding download time, and occupying more space on the client.

While one may just shrug (albeit not before downing a couple of pints) for this problem on an e-mail client, it’s impossible to avoid wanting to take care of it when migrating to another mailbox: if not for all the rest, at least for the (paid) space wasted to duplicated messages.

The first thing to make sure is that All Mail does not get copied to the new mailbox. To do this, it’s enough to remove it from the folders exported via IMAP by Gmail. Go to Settings, then Labels and remove the check from Show in IMAP from All Mail label. Note that the check only appears if you enabled IMAP access for the mailbox.

This avoids the disaster, but has a big downside: all the messages you archived that have no other label would get lost, because All Mail doesn’t get copied and it’s the only one containing them. So, you need to assign all your archived messages a specific label, using Gmail’s web interface.

But, how can you single out these messages among all the shit in All Mail? 🤔 Here’s the solution, that is to say the search string which finds all of them:

has:nouserlabels -in:Sent -in:Chat -in:Draft -in:Inbox 

Once you have the results, you check to select them all and then click Select all conversations that match this search. Assign them a labels (I use GoogleMail Archive) to the results: this will translate to an IMAP folders which all the messages, which will be safely translated to their new home.

I hope this information will help some of those who want to say Bye bye to Gmail.

This has unknown (=still to investigate) reasons. The problems appears to happen when there is heavy load on the Apache server: spikes are unusual and they’re made by malicious scanner probably. Still, the mySQL server shouldn’t die but just respond slowly, as it’s under heavy load because it powers some web sites on that server. This has to be investigated, of course.

I the meanwhile, mySQL server has to be up and Apache has to be responsive. Without implementing a “professional” solution with all the bells and whistles, a thing that can be done is to create a simple watchdog script in Perl.

The following script is made for Gentoo Linux, but it should trivial to adapt it to any Unix variant.

use Email::Address;
use Email::MIME;
use Email::Sender::Transport::Sendmail;
use Email::Sender::Simple qw/sendmail/;
use version;
use Arthas::Defaults::520;

our $VERSION = qv(1.0);
our $BASE = '/root/bin';
our $transport;
our $config = { };

lock_session();
configure();
chh();
unlock_session();

sub lock_session {
    die "Existing lock file" if -e "$BASE/checkhealth.lock";
    open (my $lfh, '>', "$BASE/checkhealth.lock") or die "Can't lock";
    print $lfh "PID\n";
    close $lfh;
} 

sub configure {
    $transport = Email::Sender::Transport::Sendmail->new;
}

sub chh {
    # Get all mySQL and Apache processes
    my @processes = split m/\n/xs, `/bin/ps ax`;
    my @p_mysql = grep { $_ =~ m/mysqld/xs } @processes;
    my @p_apache = grep { $_ =~ m/apache/xs } @processes;
    
    # Parse uptime command output, and get system load in last minute, last 5 minutes and last 15 minutes
    my $uptime = `/usr/bin/uptime`;
    my ($ul1, $ul5, $ul15) = (0, 0, 0);
    if ( $uptime =~ m/(\d+),\d+,\s*(\d+),\d+,\s*(\d+),\d+/xs ) {
        ($ul1, $ul5, $ul15) = ($1, $2, $3);
    }

    # Server name is used when reporting via e-mail, because if we run the same script on more than one
    # server we want to know which server had a problem.
    my $uname = `/usr/bin/uname -a`;
    (undef, my $servername) = split /\s+/, $uname;

    my $body = '';

    # No mySQL process active? Restart!
    if ( !@p_mysql ) {
        $body .= "MYSQL server not active, restarting...\n\n";

        my $rsout = `/etc/init.d/mysql restart`;
	    $body .= $rsout."\n\n";
    }

    # No Apache process active? Restart! Unlikely, never happened, but I don't need to spare 5 lines of code
    if ( !@p_apache ) {
        $body .= "Apache server not active, restarting...\n\n";

        my $rsout = `/etc/init.d/apache2 restart`;
	    $body .= $rsout."\n\n";
    }

    # If load in that past minutes is over 6 (it should be 2 at most, it's a 2-core VPS)
    if ( $ul1 > 6 ) {
        $body .= "Server under heavy load, restarting Apache...\n\n";

        my $rsout = `/etc/init.d/apache2 restart`;
	    $body .= $rsout."\n\n";
    }

    # Notify, but only in case of a problem - we surely don't want to get an useless e-mail every 5 minutes or so
    if ( $body ) {
        # Add uname and uptime output, which can be useful
        $body .= "SERVER DATA:\n" . $uname . $uptime . "\n";

        my @parts = (Email::MIME->create(
            attributes => {
                encoding        => 'quoted-printable',
                content_type    => 'text/plain',
                charset         => 'UTF-8',
            },
            body_str => $body,
        ));

        my $msg = Email::MIME->create(
            header_str  => [
                From    => 'domain@cattlegrid.info',
                To      => 'mb@cattlegrid.info',
                Subject => "$servername: health notice",
            ],
            parts       => \@parts,
            );
        sendmail($msg, { transport => $transport });
    }
}

sub unlock_session {
    unlink "$BASE/checkhealth.lock" or die "Can't unlock";
}

The script is designed to be run as a cronjob, because it’s the safest thing: there is no need to ensure the script itself is always running, as it’s called every few minutes. The definition “few minutes” depend on how long you want it to check the health of the system.

The locking system, basically just a simple lockfile, is needed to prevent the script being executed twice at the same time. It’s actually an extremely unlikely event, which could happen only if you schedule the script to be run very often, like every minute.

Here’s an example of the notification e-mails that are being sent in case of a problem.

MYSQL server not active, restarting...

* Checking mysqld configuration for mysql ... [ ok ]
* Stopping mysql ... [ ok ]
* Starting mysql ... [ ok ]

SERVER DATA:
Linux cattlegrid 5.14.17-x86_64-linode150 #1 SMP Thu Nov 11 13:17:05 EST 2021 x86_64 AMD EPYC 7601 32-Core Processor AuthenticAMD GNU/Linux
17:47:28 up 11 days, 18:06,  2 users,  load average: 0,09, 0,19, 0,23

The rest of the script is explained in the comments. It’s actually very simple, maybe even silly, but works like a charm.

Perl came to the rescue, and in some 15 minutes I wrote a working script.

What I needed to know

Basically, I wanted to know the number of hits and the bytes transferred for each of the web sites, in order to make a ranking.

The Apache log is something that is a standard now, and is something like this:

75.137.96.53 - - [16/Dec/2021:00:01:16 -0500] "GET /assets/js/main.js?v=5.6.0 HTTP/1.1" 200 6696 "https://www.mydomain1.com/" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:95.0) Gecko/20100101 Firefox/95.0"

Being a shared Apache, my log also has an extra field at the beginning, with the various domain names:

www.mydomain1.com 75.137.96.53 - - [16/Dec/2021:00:01:16 -0500] "GET /assets/js/main.js?v=5.6.0 HTTP/1.1" 200 6696 "https://www.mydomain1.com/" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:95.0) Gecko/20100101 Firefox/95.0"

The script

The script is meant to be used feeding a log on its standard input, so for instance.

# tail -1000 access_log | process_log.pl

Here goes the script, with some comments where needed.

use Path::Class qw/file/;
use Number::Bytes::Human qw/format_bytes/;
use Text::Table;
use Arthas::Defaults::520;

my $sites;
my $totbytes = 0;

while (my $row = <STDIN>) {
    chomp $row;

    # Regex which parses a line of the Apache log.
    my (
       $sitename, $clientip,  $rfc1413, $username, 
       $when,     $reqstring, $status,  $bytesout,
       $referer,  $useragent
    ) = $row =~ /^(\S+) (\S+) (\S+) (\S+) \[(.+)\] \"(.+)\" (\S+) (\S+) \"(.*)\" \"(.*)\"/o;

    $sites->{$sitename} //= {
       hits    => 0,
       okhits  => 0,
       bytes   => 0,
    };
    $sites->{$sitename}->{hits}++;

    # Don't care about byte count on non-OK hits. Maybe we should add that as well, but... no.
    next if $status != 200;

    $sites->{$sitename}->{okhits}++;
    $sites->{$sitename}->{bytesout} += $bytesout;
    $totbytes += $bytesout;
}

# Create a nicely-formatted table
my $tb = Text::Table->new('Site','OK Hits','Transfer Out');

# Only display the first 10 entries, sorted by number of 200 OK hits
my $ii = 0;
for my $sk(
    sort { $sites->{$b}->{okhits} <=> $sites->{$a}->{okhits} } keys %$sites
) {
    my $sv = $sites->{$sk};
    my $tout = format_bytes($sv->{bytesout});
    $tb->add($sk, $sv->{okhits}, $tout);
    last if $ii == 9;
    $ii++;
}

say $tb;

# We also want the totals, why not?
my $totbytes_h = format_bytes($totbytes);
say "TOTAL TRANSFER: $totbytes_h";

We use a couple of nice Perl modules here, which are Number::Bytes::Human, used to automatically convert bytes in something easier to read, and especially Text::Table, which produces a great nicely-formatted table on the console.

Here’s the output:

Site                             OK Hits Transfer Out
www.domain1.com                  128360  2.6G        
www.mydomain2.com                108854  3.5G        
www.thedomain3.it                98164   4.2G        
www.ourdomain4.com               59108   6.6G        
www.infodomain.info              35417   560M        
www.custdomain.com               29424   520M        
www.shopdomain.it                20547   623M        
www.bardomain.it                 12633   403M        
www.bdm.it                       11330   292M        
basehostx.com                    10030   1.4M   
TOTAL TRANSFER: 29G

Text::Table also supports borders for cells and other niceties, which I didn’t use.

This quick and dirty solution is very easy to adapt and improve, for example to show the IPs which hit the server most, grouped by web site.

I had been an Amiga user for a long time between the end of the 80s and the beginning on the 90s: these computers were ahead of their time, and I loved them. I owned an Amiga 500 (then sold) and an Amiga 2000 (which I’m trying to repair), both featuring kickstart 1.2.

I recently saw an Amiga 1200 on sale in a town not far from me, so I decided to take it to see what I could do with it. I then began jumping around online forums, and discovered a whole universe of Amiga enthusiasts. Shortly after, I decided to try to work on this glorious computer, and this is what I’ve done (so far).

I purchased most of the add-ons and hardware described here on AmigaStore.

Recap

One of the problems with old computers are capacitors: after so many years, they may not work as expected and (in the worst case scenario) also leak their fluids on the mainboard, causing various damage. So, I just switched the Amiga on a couple of times before sending it to a very competent folk here in Italy, which did the recapping and also checked that everything was in good working order.

Monitor

I indeed plan to get a Commodore or Philips CRT monitor, like the ones we used back in the days. In the meantime, however, the best choice was a LCD television, which has the required SCART connector.

Moreover, while it lacks the nostalgia factor, the LCD provides much better picture quality, and also the interlaced modes - which looked horrible on the CRT monitors - are very usable.

PSU substitution

The original external Power Supply Unit by Commodore was glued and impossible to open, so recapping was a no-go. It was also just 25 W, which wasn’t ideal with expansions, disk, etc.

Many current Amiga users stick with ATX PSUs, which are inexpensive and supply plenty of power. I wanted something more classic - at least in the looks - so I bought a white Amiga-specific PSU: it’s smaller and way lighter than the original one, and it supplies a decent (and enough for most classic uses) 50 W of power.

Kickstart 3.1

Amiga 1200 usually came with kickstart 3.0, which is fine but could use some bugfixes and improvements. There are two main improvement choices:

• Kickstart 3.1.4 by Hyperion Entertainment
• Kickstart 3.1 by Cloanto Corporation

I was initially tempted by kickstart 3.1.4, but then I decided to stay as traditional as possible. So, the Cloanto 3.x series looked like the best choice, being faithful to the original ones while featuring some needed patches such as the ability to use large disk partitions.

Installation was almost straightforward: with the help of a screwdriver I removed the old 3.0 ROMs and inserted the new ones (after adjusting the alignment of the pins, which were a bit too wide).

Everything looks fine, except for the copyrights on the welcome screen which are (of course) not by Commodore_ anymore like in version 3.0, but by Cloanto: I’ll live with that. 😊

RAM expansion and Real Time Clock

Amiga 1200 comes with 2 Mb of chip RAM, which is actually more chip RAM than I ever was able to use in any Amiga (my 500 and 2000 both had 512 Kb chip and another 512 Kb fast).

However, I feel Workbench 3.1, WHDLoad and other applications would benefit from having some more RAM, so I installed an A1208 expansion card, which adds 8 Mb of fast RAM: it should be more than enough for my needs, even for AmiBlitz, which I plan to play with.

The system reacted very well to the installation of this expansion card (which was easy enough, even though I didn’t remember how hard you have to push expansions in the slots in those old computers 😆). Before installation, upon booting Workbench, I only had about 1.3 Mb of free chip RAM. Now I almost have the full 2 Mb free, plus about 7.5 Mb of fast RAM.

The expansion card also includes a Real Time Clock (RTC), with battery. This was optional, but I really want a computer that can remember date and time.

Hard disk and Workbench 3.1

The computer had a 480 Mb IDE hard drive installed: even though fast, it was noisy and sometimes it turned off spontaneously: I though the problem was in the PSU, but even with the new power supply it didn’t work properly, and in the end it died altogether.

I opted to replace it with a IDE-to-CF adapter, to which I added a pre-installed Cloanto’s Workbench 3.1 CompactFlash card. As it happened with the kickstart, I was tempted to go with Hyperion’s Workbench 1.3.4 and all its nice coloured icons, but then I really wanted to stick to the Commodore era as much as possible.

The adapater is really nice: very easy to install, it doesn’t move around - I just put a thin plastic layer under it, to avoid the risk of contacts touching the metal. It doesn’t even need the power cable: it takes the (little) power it needs from the IDE cable. No more hard drive noise, it’s a true bootable disk, Workbench loads blazingly fast (less than 5 seconds!) and works like charm.

What now?

Now it’s time to transfer some applications and games into the Amiga. I will write about that in the next post!

Flickr allows to download all your data fairly easily, dividing it in ZIP archives of 500 photos each, so I downloaded by 26000+ photos. Problem is the pics are not divided into albums, so - especially if you have a lot of pics - you get a huge mess which is very difficult to manage.

Luckily, in the downloadable data Flickr also provides all the information to programmatically reconstruct all the structures. I was able to successfully move the files into different directories, divided by album name. I hope sharing this experience will be useful to anyone who either is moving away from Flickr or just downloading the data to keep a local copy.

In the downloaded data, there is an albums.json file, which has all album information in this structure:

{
    "albums": [
        {
            "photo_count": "11",
            "id": "72157696153620351",
            "url": "https://www.flickr.com/photos/arthas/albums/72157696153620351",
            "title": "2018-06-09: Iconocluster - Profumo DiVino",
            "description": "",
            "view_count": "2",
            "created": "1528666970",
            "last_updated": "1528799288",
            "cover_photo": "https://www.flickr.com/photos/arthas/42670192932",
            "photos": [
                "28846036158",
                "42670194192",
                "40908904860",
                "40908904790",
                "42670192932",
                "42701822032",
                "42751133711",
                "28877442928",
                "42701821872",
                "27882010047",
                "42751133381"
            ]
        }
    ]
}

Ain’t this perfect? Well, not exactly. You can’t just use the codes in the ‘‘photos’’ array as they are to find the files belonging to an album, because:

• The extension (JPG, MOV, PNG, …) is not provided
• Files in the data export have names including the title, such as dublin-castle_5303007241_o.jpg

So, a little bit of programming is needed. Here’s my commented Perl script which does the job. This assumes that you are in a directory containing:

• All the downloaded photos/videos in a photos subdirectory
• An empty albums subdirectory, where albums directories will be created
• The script itself

For the rest, it’s mostly self-explanatory but I provided comments here and there.

#!/usr/bin/env perl

use Mojo::File qw/path/;
use Mojo::JSON qw/decode_json/;
use Arthas::Defaults::520;

my $jdata = decode_json( path('./albums.json')->slurp ) || die 'No-albumdata';
my $photos = path('./photos')->list || die 'No-photos';
my @missings;

my $albums = $jdata->{albums};
for my $album (@$albums) {
    say "==> $album->{title}";

    # Create album directory, using a cleaned-up version of its title
    my $albumdir = path './albums/'.clean_albumtitle( $album->{title} );
    $albumdir->make_path();

    for my $photocode (@{ $album->{photos} }) {
        # Photo filename may have bizarre name but they always contain the code
        my $fphotos = $photos->grep(qr/$photocode/);
        my $fphoto = shift @$fphotos;
        print "    $photocode => $fphoto => ";

        # Check if we actually found a match
        if ( !-e $fphoto ) {
            push @missings, $photocode.'';
            say "MISSING!";
            next;
        }

        # Copy the pic in destination folder
        $fphoto->copy_to($albumdir);
        say 'copied!';
        # If you have a ton of photos, you may prefer to move them
        # Also, moving allows to easily find any leftovers just by looking at the
        # directory
        # And by the way: it's also way faster than copying!
        # $fphoto->move_to($albumdir);
        # say 'moved!';
    }
}

# Report any codes which we didn't find
# There's should be any, so reporting is useful for debugging (i.e. if you forgot to unpack one of the ZIP files)
say "\nMISSING CODES:";
say join "\n", @missings;
say "OK";

# File systems (depending on OS/FS) don't like some special chars, so I'm cleaning slashes, ampersands and colons.
# Tune this to match your own needs.
sub clean_albumtitle($title) {
    $title =~ s/[\/\'\:]/-/gxs;
    return $title;
}

The code relies on Mojo::File and Mojo::JSON to achieve a clean and elegant approach to the solution of the task.

Databases and time zones

One of the problems which usually arise when storing date+time in a database, is that it might then come out of it in a different time zone, which can be sort of a nightmare especially if you are writing software which schedules events or performs similar tasks.

mySQL date and time type is datetime, which knows nothing about time zones. So, when a date+time is stored there, it’s up to you to “remember” the the time zone you used. Let’s try an example on my computer (the database is MariaDB, but that’s the same), which is configured with the Europe/Rome (Olson) time zone (CET/UTC+1 in the winter, CEST/UTC+2 during summer):

MariaDB [dtest]> select now(), utc_timestamp();
+---------------------+---------------------+
| now()               | utc_timestamp()     |
+---------------------+---------------------+
| 2019-08-18 17:43:34 | 2019-08-18 15:43:34 |
+---------------------+---------------------+
Query OK, 0 rows affected (0.000 sec)

As you can see, the default time zone used is the local one, that is the one of the machine on which the server is running. Let’s set the session to use UTC instead:

MariaDB [dtest]> set @@session.time_zone='+00:00';
Query OK, 0 rows affected (0.000 sec)

MariaDB [dtest]> select now(), utc_timestamp();
+---------------------+---------------------+
| now()               | utc_timestamp()     |
+---------------------+---------------------+
| 2019-08-18 15:43:09 | 2019-08-18 15:43:09 |
+---------------------+---------------------+
1 row in set (0.000 sec)

All fine here, but let’s try storing a date/time into a table_

MariaDB [dtest]> set @@session.time_zone='+02:00';
Query OK, 0 rows affected (0.000 sec)

MariaDB [dtest]> create table tztest(sampletime datetime);
Query OK, 0 rows affected (0.020 sec);

MariaDB [dtest]> insert into tztest(sampletime) values('2019-08-18 17:24:17');
Query OK, 1 row affected (0.006 sec)

MariaDB [dtest]> select * from tztest;
+---------------------+
| sampletime          |
+---------------------+
| 2019-08-18 17:24:17 |
+---------------------+
1 row in set (0.001 sec)

MariaDB [dtest]> set @@session.time_zone='+00:00';
Query OK, 0 rows affected (0.000 sec)

MariaDB [dtest]> select * from tztest;
+---------------------+
| sampletime          |
+---------------------+
| 2019-08-18 17:24:17 |   <==== BIG PROBLEM
+---------------------+
1 row in set (0.001 sec)

See the problem? When changing session time zones, you still get the same time when reading data. That is, if a client sets a different session TZ than another, the same date will not be actually the same! Let’s say a web application enters a business meeting at 17:24 using the local time zone, and the user from a mobile phone when reading it sees 15:24: the business meeting would fail.

The trick here is to always set the session time zone to UTC (+00:00). This is still prone to difficult-to-find errors, of course.

PostgreSQL is much better, as it offers a timestamp with time zone type, which should always be used. When storing time in it, you need to pass the time zone, and this gets stored in the server, so TZ information is always kept and carried around. UTC should always be preferred (for reasons we will soon see), but with PostgreSQL you have the guarantee that a stored time will always be that one, regardless on how the database is accessed, which is a huge plus.

dtest=> select now();
              now              
-------------------------------
 2019-08-18 17:54:51.146696+02
(1 row)

Why UTC should always be preferred

Aside: we already introduced UTC as a name earlier. For the ones who don’t know about it, it’s Universal Time Coordinated. The UTC Wikipedia page has full explanations. In practice, the UK uses UTC (GMT, Greenwich Mean Time) in the winter, and UTC+1 (BST, British Summer Time) in the summer.

Let’s say we have a web application which collects times at which a movie meeting begins on TV. We will make a few examples in Perl.

The user enters a movie which begins at 02:00 local time (Europe/Rome), which is almost always fine, but not really always:

use DateTime;

my $dt = DateTime->new(
    year => 2019, month => 3, day => 31,
    hour => 2, minute => 0, second => 0,
    time_zone => 'Europe/Rome'
);

Ops, we get:

Invalid local time for date in time zone: Europe/Rome

This happens because this time does not exist: that night, after 01:59:59 there was directly 03:00:00, because that night, in Europe/Rome, we changed time from CET (UTC+1, winter) to CEST (UTC+2, summer).

But there’s worse, try this:

my $dt = DateTime->new(
    year => 2018, month => 10, day => 28,
    hour => 0, minute => 30, second => 0,
    time_zone => 'UTC'
);
my $dt2 = DateTime->new(
    year => 2018, month => 10, day => 28,
    hour => 1, minute => 30, second => 0,
    time_zone => 'UTC'
);
say $dt->set_time_zone('Europe/Rome');
say $dt2->set_time_zone('Europe/Rome');

This code doesn’t even throw an error, it just shows this scary awesomeness:

2018-10-28T02:30:00
2018-10-28T02:30:00

😱😱😱 How the f–k could this happen?!? Pretty simple, actually. When going back to winter time, it’s not a matter of time which does not exist, but a matter of time existing twice: that night, after 02:59:59 the time in Europe/Rome went back to 02:00:00, thus duplicating an entire hour. So, two different UTC times are the same Europe/Rome time.

If you only need a date, forget about the time

It’s tempting for software developers to always stick to date+time types, even when having to deal with dates (such as birth dates). This is not recommended.

One typical approach for a birth date is to set it as:

1977-11-04 00:00:00 UTC   <==== SINCE WE DECIDED TO STICK WITH UTC

which would even be fine for us in Europe, as it would convert to 01:00 or 02:00 when converted to local time. However this would cause a change of date when converted, say, to America/Montreal zone, showing the birth happening one day before.

Also, one might incur in a non-existing time problem like the one mentioned earlier, if dealing with local times instead of UTC. Say for instance:

1972-05-28 00:00:00 - Europe/Rome

In 1975 (in Italy at least) the change to Daylight Saving (summer) time happened in late May instead of March, and at midnight instead of 2am. I found about this by chance, but there may be a lot of other edge cases.

So the solution is just: use just dates when dealing with dates. Databases have the fields, and programming languages have that support in the libraries.

Time in the future

There is a lot of ongoing political talk regarding wether Daylight Saving (summer time) should continue to exist, and it might actually be dropped in Europe in the upcoming years.

Time zones themselves are at risk of extinction - because they just are not so handy - even though that won’t happen soon (should it ever happen). Different countries think in different ways: China, for instance, has a single time zone even being one of the biggest countries in the Word; on the other hand, the USA has some 6 different time zones.

There are also complications in sight. When humans will colonize space, there will be a series of new time zones: at least one per planet (being Mars the first one, of course), if not more. Conversions are not going to be as easy as adding or subtracting hours, because planet rotation (and therefore duration of a day) is different when you change planet. However, UTC will probably still be used as the reference: it’s Universal, after all.

The unend engine defines a trait which anything which the player can interact with (objects at present time; people, animals etc in the future) must implement:

pub trait Interagible {
    fn get_tag(&self) -> String;
    fn get_name(&self) -> String;
    fn interact(&self, _iact: Interaction) -> InteractionRes;
}

Basically, the interact() method accepts an interaction as a parameter, and returns a result for that. Among the “planned for the future” things, there’s method like this:

// Future development
fn interact_with<T: Interagible>(&self, _other: T, _iact: Interaction) -> InteractionRes;

in order to allow interaction between objects, such as use ink with paper. It would also allow the give interaction (as in give book to Alice) to exist. This is, however, absolutely too advanced for current development status. 😆

Interaction and InteractionRes are enums defined as follows:

/// A complete set of interactions (these come from Thimbleweed Park, with
/// just a few variations to keep them 1-word long)
pub enum Interaction {
    Open,
    Close,
    Give,  // Placeholder, needs `interact_with()` to exist
    Take,
    Look,
    Talk,
    Push,
    Pull,
    Use,
}

/// Possible results for an interaction. Plan for this is to be a complete
/// set of possible results. For now there are one two basic (but useful) ones.
pub enum InteractionRes {
    Info(String),
    GotoSection(String),
}

The first object I wanted to implement was a very simple one, that would just show a text message for each interaction: a description if it’s looked at, a nice “no, thank you” message if the player attempted to take it, etc. So, leaving aside trait instantiation and other boilerplate, all the action happens in this code:

impl Interagible for InfoObject {
    // ... cut ...
    fn interact(&self, iact: Interaction) -> InteractionRes {
        match self.av_interactions.get(&iact) {
            Some(s) => InteractionRes::Info(s.to_string()),
            None => InteractionRes::Info("That won't work".to_string())
        }
    }
}

The implementation of Interagible’s interact() method is just a few lines: the code looks into an HashMap (contained in the InfoObject struct) to see if there is a result for the interaction requested (we’ll see in a while how possible results are added when creating a new InfoObject): if a match is found, we return an Info value of the InteractionRes enum, which contains a simple string to show to the player; with no match, we return the same type, but with a default string.

Now to the main loop code:

let interaction_regex = Regex::new(r"^(\w+)\s+(\w+)$").unwrap();
loop {
    // ... cut ...
    match command.as_str() {
        // ... cut ...
        irx if interaction_regex.is_match(irx) => {
            // ... cut: get target `obj` and `interaction` from captures and look them up ...
            match target {
                UnendObject::Info(obj) => match obj.interact(interaction) {
                    InteractionRes::Info(s) => self.write_line(&s),
                    _ => panic!("InfoObject shouldn't interact this way."),
                },
                // ... cut ...
            };
        }
    };
};

The parser is just a regular expression at the moment. Once it matches the type of the target (the enum in which it’s contained was previously looked up via the object’s tag), the main loop invokes its interact() method, passing the (previously looked up) Interaction.

We use match in order to unwrap the InteractionRes enum: if the value is Info we show the contained string to the player; other result values are not supported for this specific kind of object, so a panic!() is probably the best option (=forces somebody to debug the thing).

Now that we have all of this setup, it is possible to modify the code - shown in previous article - which was used to create the kitchen, so that is becomes:

let kitchen = UnendSection::Basic(BasicSection::new(
    s!("kitchen"),
    s!("The grand kitchen"),
    s!("You are at the center of the kitchen and dining room. The only exit is south. There's a *book* on the table."),
    hashmap!{
        ExitDir::South => Exit::Visitable(s!("hallway")),
        ExitDir::East => Exit::Closed(s!("You can't exit through the window.")),
    },
    hashmap!{s!("book") => UnendObject::Info(InfoObject::new(
        s!("book"),
        s!("Pink Book"),
        hashmap!{
            Interaction::Look =>  s!("It is a strange pink book with a black sheep on the cover."),
            Interaction::Take =>  s!("I don't need this book."),
            Interaction::Use  =>  s!("Hmmm, I prefer to watch movies rather than read."),
        },
    ))},
));

The code should be self-explanatory enough. The only thing worth noting is that InfoObject is wrapped into an UnendObject::Info enum value: as we did for sections, this allows to have different object (Interagible) types inside the same containing HashMap.

So, let’s see if this works somehow:

And now… a slightly different implementation: a PortalObject, which we define as an object which transports the player to another section of the game when used.

Skipping the struct constructor and other service code (which you can find the in the repository), the interesting part comes (as before) with the interact() method:

fn interact(&self, iact: Interaction) -> InteractionRes {
    match iact {
        Interaction::Look => InteractionRes::Info(self.dsc.clone()),
        Interaction::Use => InteractionRes::GotoSection(self.destination.clone()),
        _ => InteractionRes::Info("That won't work".to_string()),
    }
}

Only two interactions are supported by PortalObject: the player can only look at it or use it. Everything else shows a default string. Compared to InfoObject, the difference here lies in how the Interaction::Use is handled, that is by returning an InteractionRes::GotoSection containing a string with the tag of the destination section. The main loop code will therefore know how to use that tag:

loop {
    // ... cut ...
    match command.as_str() {
        // ... cut ...
        irx if interaction_regex.is_match(irx) => {
            // ... cut: get target `obj` and `interaction` from captures and look them up ...
            match target {
                // ... cut ...
                UnendObject::Portal(obj) => match obj.interact(interaction) {
                    InteractionRes::Info(s) => self.write_line(&s),
                    InteractionRes::GotoSection(s) => {
                        self.current_section_tag = s;
                        continue;
                    }
                },
            };
        }
    };
};

Dead easy: either show the description or change the section the player is in and skip to the next loop cycle. Now we only need to actually create the portal object and put it inside a section/room.

let hallway = UnendSection::Basic(BasicSection::new(
    s!("hallway"),
    // ... cut ...
    hashmap!{s!("fireplace") => UnendObject::Portal(PortalObject::new(
        s!("fireplace"),
        s!("A strange fireplace"),
        s!("This fireplace glows like it's enchanted."),
        s!("secretroom"),
    ))},
));

A fireplace which happens to be a portal… how interesting! The secretroom, defined elsewhere, is a section for which there is no access from any of the other sections; the secretroom itself, however, has an exit which brings the player back to the hallway.

That’s all! See you next time with something else. I’ll likely try to implement inventory, and therefore objects which can be taken. This poses some challenges: as of now, everything in the game has an immutable state; using mutable states, besides the programming aspects (which may be non-trivial for a Rust newbie like me), will also likely lead to some changes in how Visitables are structures: if an object is taken, it must disappear from the section, and the section description (which is now a monolithic text block) should change. We’ll see…