This week I have worked on some Go-lang for Fantasy-Judo.com adding some internationalisation (Italian support and French translation). I also did a Perl live coding session where I worked on a command line tool I wrote last year for my Zettelkasten note taking system.

The script originally added back links to files that related to one another automatically; I've decided not to do that as many people suggest this is an anti-pattern in the Zettelkasten world. But I did/do still want to know when I have notes that:

• Don't link to other notes.
• Don't have links from other notes.

So I picked up the repo and started working on it, the stream is just me pottering around in Perl, so although I include it above and am leaving it up, it's pretty dry/dull... you have been warned.

What sticks in my mind from the session were a couple of things:

• Deleted code is debugged code (Jeff Sickel)
• Test2::V0 and Test::MockFile don't play nicely together
• TDD is a skill that comes with practice

"Deleted code is debugged code." – Jeff Sickel

— Programming Wisdom (@codewisdom) April 30, 2021

This tweet resonated with me after the live coding session. The reason being that I knew I had a small bug in my code, where an additional blank line was added each time I ran the script and it added back links. I had done some debugging back in August 2020 when I worked on this script last, but not solved the problem.

Today the code is fully "debugged" as I have now deleted the code in question. As a developer the quote an experience is important to remember. When we find bugs, should we dig into them and write complicated fixes/tests? Or as per this example maybe the best answer is to delete the code. "Less is More" and all that good stuff.

Test2::V0 vs Test::MockFile

As I'd not worked on the code for a while I started by running the tests (Always run the tests first is a mantra we could all do with chanting... especially developers in practical coding interviews, run the darn tests).

In my situation, the there were odd errors being thrown, I am presuming this has something to do with the version of Perl and modules on my current machine and the machine I was writing the code on originally as I don't recall seeing the errors back then.

On the video you'll see me scratching my head, then starting a new test file, with no tests, just the including the initial use statements. This showed that including the two libraries together caused the error. I realise now as I write this perhaps I could have done some more diagnosis (and probably will later) but at the time I solved my problem the easiest way I could... deleting the code.

Well, sort of. What I actually did was stop using Test2::V0 and switched to Test::More and seeing as the errors went away I made minor changes to my tests to use that instead.

Test Driven Development (TDD) is a skill that comes with practice.

If you watch my live coding sessions, you'll notice I try and work in a TDD style. Which when you are doing an abstract problem is a form of "deliberate practice". This week when working on an actual tool I was also operating in a TDD style. And it felt I think pretty smooth; and smooth as a result of the using it in the Perl Weekly Challenge solutions.

This is not a surprise, all the TDD people I trust do suggest that you should learn TDD outside of your job, as it's hard and you get it wrong at first. That you should not slow down your salary earning work learning the skill. This weeks coding felt like the TDD was flowing nicely as a result of the practice done in other weeks.

I found myself describing is comments what I wanted in pseudo-code comments in the script, then writing tests and code that delivered that, then replacing the pseudo-code with calls to the tested methods I'd written. The code feels pretty comfortable. I also find that I am writing a module that is larger than the script. So the script is pretty expressive and understandable:

use strict;
use warnings;

use lib './lib';
use Zettlr::Backlinker;

my $ZB = Zettlr::Backlinker->new;

my $files = $ZB->get_file_list('/home/lancew/zettel');

for my $file (@$files) {
    if ( $ZB->number_of_links_out($file) == 0 ) {
        print "NO LINKS OUT: $file\n";
    }

    if ( $ZB->number_of_links_in( $file, $files ) == 0 ) {
        print "NO LINKS IN: $file\n";
    }

}

As you can see, I am not doing much, just getting a list of files, checking the number of outbound links and checking the number of inbound links. The code has three corresponding methods. Tidy.

The tests I wrote in parts, but the overall tests I wrote that evening look like this:

use strict;
use warnings;

use Test::MockFile;
use Test::More;

use Zettlr::Backlinker;

my $CLASS = Zettlr::Backlinker->new;

my $file_1_content = <<HERE;
# This is the first file
#tag1 ~tag2

Paragraph one has no links.

Paragraph 2 links to [[20200716164925]] Coding standards.
Which is only the ID and not the full file name

Paragraph 3 links to [[20200802022902]] Made up at the time I wrote the test.

Paragraph 4 links to [[20200802022902]] and [[20200716164911]] to test a bug.

Paragraph 4 links to the second file [[22222222222222]] So should be a backlink for that file

HERE

my $file_2_content = <<HERE;
# This is the second file
#tag1 ~tag2

Paragraph one has no links.

HERE

my $file_3_content = <<HERE;
# This is the second file
#tag1 ~tag2

Links to [[11111111111111]] and [[22222222222222]]

HERE
my $mock_file_1
    = Test::MockFile->file( '11111111111111 some file.md', $file_1_content );
my $mock_file_2 = Test::MockFile->file( '22222222222222 another file.md',
    $file_2_content );
my $mock_file_3
    = Test::MockFile->file( '33333333333333 third file.md', $file_3_content );
my $mock_file_4 = Test::MockFile->file( 'README.md', $file_1_content );

my @file_list = (
    '11111111111111 some file.md',
    '22222222222222 another file.md',
    '33333333333333 third file.md',
    'README.md',
);

my $mock_dir = Test::MockFile->dir( '/foo', \@file_list, { mode => 0700 } );

subtest 'number_of_links_out' => sub {
    is $CLASS->number_of_links_out('11111111111111 some file.md'),
        4, 'Has 4 unique links in it, 5 in total as one is repeate2d';
    is $CLASS->number_of_links_out('22222222222222 another file.md'),
        0, 'Has no links in it';
    is $CLASS->number_of_links_out('33333333333333 third file.md'),
        2, 'Has 2 links in it';
};

subtest 'number_of_links_in' => sub {
    is $CLASS->number_of_links_in(
        '11111111111111 some file.md', @file_list
        ),
        1, 'Only the third file links to file 1';
    is $CLASS->number_of_links_in(
        '22222222222222 another file.md', @file_list
        ),
        2, 'Both the other files link to this file';
    is $CLASS->number_of_links_in(
        '33333333333333 third file.md', @file_list
        ),
        0, 'Neither of the other files link to this file';
};
done_testing;

As I hope you can see, I have two things I am testing links in links out, broken into two subtest blocks. I like using subtest to give clarity in TAP output and visibly in the test file itself. I could/should move the here-docs lower in the file as that's noise. Though arguably, it give the reader the content of the three test files before they see the tests.

I used Test::MockFile for the first time on this project. I don't think it's particularly popular and ideally I'd not use it and structure things in different ways. But the tool is all about reading (and originally writing) to files on disk so this test library was great for allowing me to create files and directories without actually creating temp files.

The methods I wrote look like this:

sub number_of_links_out {
    my ( $self, $filename ) = @_;

    my $links = $self->get_links_from_files($filename);

    return scalar( @{ $links->{$filename} } );
}

sub number_of_links_in {
    my ( $self, $filename, @file_list ) = @_;

    my $links = $self->get_links_from_files(@file_list);
    delete $links->{$filename};

    $filename =~ m/^(\d+)/;
    my $occurances = 0;
    for my $key ( keys %$links ) {
        for my $link ( @{ $links->{$key} } ) {
            $occurances++ if $link eq $1;
        }

    }
    return $occurances;
}

The first one is pretty concise now, it was longer, but I did refactor a little. The second came later and I was tired, and it shows. It is still the verbose version I tend to start with and whittle down once I have a working solution. I actually finished this code off stream as I was not getting things right. Just after stopping the stream I stopped making small mental mistakes and got it working properly.

This makes sense too, coding is a skill. And your skills just as your skills improve with practice, they deteriorate with tiredness.

This is one of those things that a professional coder knows. You are creating something that requires skill, working tired or sick is something you learn not to do. I have told many people about "that time" when I wrote some code at work when I had a cold/flu. The (awesome) tester who worked with me took one look and straight out told me it was rubbish and looked like someone else had written it. They saw the result of using a skill sick/fatigued, it's just not as good as when you are fresh and healthy.

Given writing software is done in our heads, making sure that our heads are clear should be a priority you'd think. But how often do we ask that question of ourselves, let alone peers or reports (if you are a manager)? How much effort are we as an industry wasting because we are allowing people creating software to do it tired or sick?

So along with practice, I am adding "Rest and wellness matter!" to my list of things I learnt this week.

This week I have more l10n work to do on/in Go-lang and want to look at how to run the above script every time I push to my Zettelkasten and have the results emailed to me. I will also try and do the Perl Weekly Challenge (I seem to be settling into a fortnightly rhythm of doing them". I really should also put some time into the Judo simulation project I have been "renovating" from the early noughties.

Lance.

Tags: projects