Life goes by fast, and blogs gather dust… as this one has.

So what have I been up to…

Well, I continue to work in software development in a fully remote capacity. I’m building software in the recruitment software area and it’s a mix of legacy code and new. I’m mainly managing others and helping us all to navigate the new AI tools and technologies.

Outside of work, my family is fine (thanks for asking).

What has changed is that I’ve gotten involved in the amateur Sumo world. And somehow have entered several competitions and even won some medals in UK even at a European Cup in Norway. Beyond that I am on the board of both EnglandSumo and BritishSumo. This has been an invigorating and it’s been great to be involved.

Project wise, I’ve continued to keep https://en.fantasy-judo.com/?utm_source=rss&utm_medium=rss going with James. More recently I started https://keiko-league.com/?utm_source=rss&utm_medium=rss which is a different idea, but related to Judo and Sumo. It allows informal tracking and competition at training sessions.

Running/jogging was something I was doing; but knees did not like it as much as riding bicycles. But riding bikes is a literal pain in the backside. So I tried recumbent bicycles and am a little addicted to riding them now. Take a look at https://hampshirerecumbentcycle.com/?utm_source=rss&utm_medium=rss to see a little more.

Well thats a brief catchup, talk soon!

Lance

Mastodon has now become far more valuable to me, and email returning to be the main social networking tool in my bag. Newsletters have really improved things. Though RSS feeds may still hold first spot for news and information.

New is Nostr, which for me is taking the place of SSB/Manyverse, which with Andre and other stepping away seems to have had it’s day. Nostr has a similar vibe to SSB when I discovered it, hopefully the good things from SSB transition.

I am enjoying exploring the niches of the web again. As brands and corporations steamroll the internet, little pockets of creativity and innovation flourish in the wreckage. The Gemini Protocol for example is fascinating to me.

LinkedIn is a wreck, Facebook attrocious. Both lost as they try to out compete one another and try and survive twitter destroying expectations. The smaller innovators like WhatsApp, Instagram, TikTok getting wrecked in the venture capital hellscape.

Pockets of sane appear, like Beeper, Readwise, Hey.
These services that (currently) focus on giving a great experience at a reasonable price, where I am the customer and not the product really appeal more. And I am happy to pay real money for the serenity of these apps as escapes from the broken internet of Twitter, Facebook, etc.

The reason for the tool, is that to test the graphics software you need packets of data.
That means running four computers with the scoreboard software running. This is inconvenient and also requires manual operation of the scoreboards. It’s the right way to test at an event where you care that those specific laptops can communicate with the wider systems… but for bug investigation or even regression testing after making changes it is not very convenient.

I originally started in Perl, which is my preferred language for most things.
But to be frank… it did not feel comfortable. The other feeling I had was that I wanted to share this tool with people; and Perl can be difficult to make portable for non-techies. I thought of NodeJS (which the main live stream graphics is written in), but again it is difficult to make portable at times.

So I was looking for a language with good network libraries that is portable… and I felt I could make a working prototype in.

Go has networking in the standard libraries, so no need to find a third party module. Go also compiles to a single executable; and building a Windows exe from my Linux workstation was/is easy to do. Lastly, I’ve written Go and have friends who know it well, so I felt I had a good tool.

So one Saturday morning, coffee in hand; I started.

Thankfully, people have walked this path before me. I was able to find a blog from Mihalis Tsoukalos that got me started.
With this as my guide I was quickly able to build a server and client pair, and using go run server.go was able to quickly capture the contents of the packets coming from the scoreboard software.

Using these packets as my template, I was able to alter the “client” code to send a packet out; and after minimal adjustments, saw the packet data display on the graphics system we use to overlay on the video people watch online.

Having proven this much, I tested building a Windows (32-bit) executable and ran that on a windows machine off a USB stick with no problems at all.

Missions accomplished !

So then I made some adjustments, such as sending multiple mat information and tweaking the data packets. I refactored some of the IJF specifics into a module so that the main code is pretty small:

package main

import (
	"fmt"
	"ijf/ijf"
	"net"
)

func main() {
	s, _ := net.ResolveUDPAddr("udp4", "255.255.255.255:5000")
	c, _ := net.DialUDP("udp4", nil, s)


	fmt.Printf("Broadcasting UDP to %s\n", c.RemoteAddr().String())
	defer c.Close()

	for {
		for i := 1; i < 5; i++ {
			packet := ijf.Mat(i)
			data := []byte(packet)
			_, _ = c.Write(data)
		}
	}
}

As you see, there is simple infinite loop, within which it loops around creating and sending packets for each of the contest mats.

(And yes, I have cut out all the error checking of err to make it even smaller for this post)

The windows EXE file is now with my colleague who will test it in anger next weekend in Tbilisi, Georgia.

Next?

I have started on a change to read a config file and send a specific scoreboard situation; and after Tbilisi I’ll be adding the ability to read the data file we capture of a scoreboard over an event and play that back. This will be helpful as a debugging tool when people tell us something rendered strangely. We should be able to use the exact data from the scoreboard(s) and replay it so that the TV graphics software can be observed, altered, and tested.

The weekend project was really rewarding and reminded me of how important it is to choose the right tool for the job (Go-lang). Not just the tool I know best (Perl)… or even the tool that has been used before (Javascript/Node).

In $dayjob, a big project has some to a key point and gone pretty well. Last week was spent in many ways doing admin and answering queries around the work.

Outside of work; I pushed some more updates to the WebService::SmartRow module on CPAN. It’s in a pretty good state and I have been able to get all the data I want to tell me the things the website isn’t. Which is handy as I now have set a 10,000 meter personal best; so was able to confirm that with code I wrote using the module!

Fantasy-Judo.com has taken up some brain space, I have 80% of a very slow coming change written that allows people to see what they “spent” on their team at the time they picked it. As ever, the code bit took a while as it’s in Go and I write Perl most of the time; and it takes a while to change mental gears.

It’ll soon be ready, I am not happy with the words I am using to describe the numbers I am now storing and displaying. There is an old saying about the hard things in computing including naming.

But once that is done I can do the last 80% of the work and see if I can push it live.

I/we have pushed a couple of things live on the site recently. Most recently a small change to handle incoming data being oddly formatted. What is great about the project is that it’s easy to work with despite it really not having had much attention for a couple of years. That is in part Go perhaps and partly the fact that it’s built in what we humbly think is a sensible way… ok mainly Go. It is one of the selling points I read about for Go is that it is good for long-term maintenance.

My kata competition software has been taking a little bit of a backseat. It “works” now; I think I need a tweak in how the calculations of scores work; but mainly I want a set of scoresheets to enter and results to compare against.

PlanetJudo.com potters along; I am really pleased with how the Digital Ocean app service is working for it. Basically, there is zero effort to build and deploy. It “just works”.

That is a bit of a theme I guess, both PlanetJudo and Fantasy-Judo have super easy “pipelines”; this leads to being able to push a small change easily. With lots of small changes over time rather than big deployments. It’s a lesson to be remembered for all professional (and hobby) projects. As GeePaw would say “Many more, much smaller steps”.

I also managed to write a little something about the impact the Russia ban in Judo might be; this is based on some super quick work with Webservice::Judobase.

That’s about it for now, thanks for reading.

I took to rowing as running has this bad habit of me getting injured… and it’s cold outside!

I’ve recently updated my rowing machine to have a SmartRow power monitor wheel. I hate some frustration with the statistics it provides via their website. I discovered it’s mainly javaascript with a JSON API. So I have started a small open source project wrapping the API (https://metacpan.org/pod/WebService::SmartRow?utm_source=rss&utm_medium=rss). This has allowed me to more easily see things like the average power (watts) per row and chart that to see if I am improving.

This work has been interesting and gave me an opportunity to write up a small tale about the Dist::Zilla tool I am using to do most of the important parts of publishing a module to CPAN. It’s over on my Perl.Kiwi site at https://perl.kiwi/tales/2022/03/05/using-dist-zilla-to-create-a-new-cpan-module/?utm_source=rss&utm_medium=rss

On Tuesday evening this week I spent some time with James on fantasy-judo.com mainly looking at some of the many todo items while James added some new team name options. Later in the week I received from a user some German translations so I updated those. I have a feature I hope to work on this weekend and next week.

I did a small amount of work on the Judo Kata Competition software project; mainly testing the UI and calculations.

I was also able to write up a couple of blog posts on my Judo sites. On judocoach.com I wrote a short piece on the kata I have been doing to help with the shoulder pain I sometimes get (http://judocoach.com/blog/index.php?entry=entry220223-154007&utm_source=rss&utm_medium=rss). Then on JudoMetrics I was able to promote an interesting site I have been reading (https://judometrics.com/2022/03/marcus-augustines-judo-de-base-website/?utm_source=rss&utm_medium=rss).

In my $dayjob, I have been busy deleting dead code and retrofitting tests. Specifically adding some coverage around a new system I have not worked on and some customer support issues have been escalated to the development team.

I’ve been pretty busy; but not too much. The balance is pretty good so I am happy with the “rolling” of the proverbial ball.

This week, I have been pretty busy catching up on some side projects and trying to get some structure in place for some of the ones that are the dustiest.

Fantasy-Judo

The site has been really busy, possibly the steady flow of events meaning people have been choosing players for one event whilst results for the current one are still coming in.

This week the site had a large part of the “plumbing” changed; James moved it to Chi for our routing system. This caused one small bug, one small side effect with a difference in how we had to handle parameters on team picks. We got that fixed up and a couple of other small things.

The Discord has been busy of late and it’s causing us to want to have a bit of a hackathon on some new game modes.

Judo Kata Competition system

This got a little love this week; mainly tidy up work after having made quite a lot of progress in February generally. The next phase is to do some thorough testing and usability improvements along with styling.

At the moment the system is black text on white background. No styling or customisation. I’ll be adding in the ability to configure event details including logo and starting on the printable reports.

Judo Blogs

I’ve run lots of Judo blogs over the years and a bunch of them have deteriorated and I have not kept them up to date or posted anything recently.

So I took a few down, gave them a clean and brought them back; I posted a few short entries on a couple. I have missed writing about Judo so that was refreshing.

ijf_ical

This is a small project that creates a ical feed (so you can subscribe to all the IJF competitions in Outlook etc). I finally got around to writing up one of the features about that; to calculate an approximate carbon footprint calculation for the IJF World Tour.

perl.kiwi

In part driven by some activities at work and on these side projects; I spent some time working on Perl tooling and wrote it up on perl.kiwi

Perl has some excellent tools, it was good to write some of that up.

$dayjob

My current work involves working on a heavily used legacy system and this week has included adding a new reporting feature. So it’s been good to build something into the existing framework.

With this sort of work it’s always a challenge to fit the style of the existing code; but it does mean often that most of the components you need are already there and that was the case this week.

It was good to be able to quickly prototype the frontend; then work backwards initially cobbling the required code together, then incrementally tidying it up after confirming the frontend idea was sound.

After initially being quite untidy; it was nice to observe as the code got tidier and tidier by the end of the week.

March

In March, my hope is to get the Kata software near complete so it can be used in a real way. I am lucky that people are showing interest so I have some feedback to collect.

PlanetJudo needs some more work; specifically I want to work on some of the unicode handling and see about working through the backlog of things I want to sharpen.

Fantasy-Judo we hope to catchup one evening this week and then implement some ideas this month. Potentially an entire new game mode.

Should be a good month!

I’m currently working developing Perl again full-tme which is a nice change from being heavily involved in managing people through a pandemic.

Outside work I am also working on a fun project; I’m building a Judo Kata Competition software solution. Along with this I recently rebuilt my PlanetJudo project and am really happy with the DigitalOcean app hosting solution I used.

Fantasy-Judo is quietly running; I am always happy when we get nice messages from people and each event we see more people play on the site.

What has not been good, and this post is part of solving it, many of my sites are dusty and neglected. Someone said something in passing about the lack of content (specifically in Judo) which got me thinking about how I was prolific in the past. Blogs, podcasts, etc but I have been very quiet of late.

So I am going to try and rekindle the habit of regular content. I am not going to be specific about how much or how often; but more content across my various sites and projects is the goal. Regular content.

So… thats that.

Welcome to 2022, stay tuned and please do say hello.

Lance

Specifically, I have been updating an Electron app that listened for UDP packets and displays them on the screen using HTML and CSS. We then chromakey that onto the camera feed of a Judo contest.

This software is used at every large IJF and EJU event and seen by people all over the world. So it is really “valuable”, it also “legacy”. In many sense of the term.

It is legacy in that it does not have tests, it is legacy in that it’s old and not well maintained. It is legacy in that it provides value. It is legacy in that it is relied upon.

I have been updating the software to match the latest style of graphics. But I have also been trimming away dead code, un-used features and general “cruft”.

Having done that, I am not embarking on the classic “re-write”, changing it to use Elm and elm-ui on the front-end rather than JQuery/HTML/CSS(Bootstrap).

The re-write builds on the foundations of the original. The Node code that listens to the UDP packets is not going away. It’s a slightly revised (smaller) version with less features, but fundamentally building on the legacy.

The front-end although entirely new and written in a new language, is still building on the legacy of the original code. Again some features are gone and it’s simpler.

And that is the point, legacy software informs new software. All new software builds on it’s legacy. And… within minutes of being written/released becomes legacy software itself. Which in turn becomes the legacy upon which the next thing is built.

So although I sometimes describe myself as more of a “maintainer” than a “creator” I see the two intertwined. Both greenfield and legacy software are one in the same, yin/yang, two sides of the same coin.

Creating software is an act of building on legacy software and creating legacy software. So only legacy software really matters… right?

In creating this “new” version of the software, I am extending the life of the legacy software at it’s core. The UDP listener I recall is actually built on top of an even older piece of software I wrote tweeted contest results (which never gained traction) which was built on an even older piece of software that wrote all the packets to a database for analysis later… which was used twice I think before it became apparent it was not a good idea.

So this shiny new version, written in a shiny new language is in fact just a new layer upon many layers of legacy code.

It too will soon be legacy code.

That said, I did do some Perl coding for someone looking at doing some research into Judo. They reached out to me as a result of my http://rwjl.net?utm_source=rss&utm_medium=rss site I think. On that page I ran a research project into an alternative ranking system for Olympic Judo using the ELO system used in Chess.

So the request via email, was a great surprise. It came from someone I deeply respect; so helping was a pleasure.

Perl, has always been a tool for automating tasks. It is the superglue for many tasks. So this week I used it to automate collating some competition results into a format that suited.

Specifically… the dreaded CSV format.

But being Perl, this was easy! just two lines and it was done.

So skipping to the CSV bit, I have an array of hashes. Each entry is the result of a contest in a international Judo competition. To write this data out to a .CSV file in perl looks like this:

use Text::CSV_XS 'csv';

...

my $err = csv( in => \@data, out => "summary_data.csv" );

That’s basically it; copied directly from the POD documentation for the module (Text::CSV_XS).

This took the 167,000+ lines of data and produced a CSV with almost zero fuss. Perl rocks!

I livecoded both:

• Challenge-74, Task 1: https://www.youtube.com/watch?v=uM0TTQZaZ2Q&utm_source=rss&utm_medium=rss
• Challenge-74, Task 2:
  • Part 1: https://www.twitch.tv/videos/716304993?utm_source=rss&utm_medium=rss
  • Part 2: https://www.twitch.tv/videos/716329311?utm_source=rss&utm_medium=rss

So what did Task 1 look like:

package Majority;

use strict;
use warnings;

use List::MoreUtils 'frequency';

sub element {
# Majority element in the list is the one that appears more than floor(size_of_list/2).
    my ( $self, @A ) = @_;
    my $majority_element = -1;

    my $floor = @A / 2;

    my %frequencies = frequency @A;

    for my $element ( @A ) {
        if ( $frequencies{$element} > $floor ) {
            $majority_element = $element;
            last;
        }
    }

    return $majority_element;
}

1;

So pretty simple module; I used List::MoreUtils to get the frequencies and from there it was pretty simple. If you watch the live coding you will see that I struggled a little with the documentation. As Mohammad Anwar was watching the result was he raised a PR on the module to change the POD to make it clearer for people like me!

For the second challenge, my module looks like this:

package FNR;

use strict;
use warnings;

use List::MoreUtils 'frequency';

sub from_string {
    my ( $self, $string ) = @_;
    my $sequence = '';

    my $end = length $string;

    for my $offset ( 1 .. $end ) {
        my $chars = substr $string, 0, $offset;
        $sequence .= $self->_fnr($chars);
    }

    return $sequence;
}

sub _fnr {
    my ( $self, $chars ) = @_;
    my @characters =  split '', $chars;
    my %frequencies = frequency( @characters );

    for my $key ( reverse @characters ) {
        return $key if $frequencies{$key} == 1;
    }

    return '#';
}

1;

In this one, I enjoyed breaking the task down into two methods.

The first method did the string manipulation; looping around the substrings. The second “private” method being called from the first which again used the frequency function from List::MoreUtils to determine the actual FNR.

I was happy with the TDD approaches I took with both. Here is the test file for the second task:

use Test2::V0 -target => 'FNR';

subtest 'from_string()' => sub {
    subtest 'Example 1' => sub {
        note "Input: ‘ababc’";
        note "Output: ‘abb#c’";
        is $CLASS->from_string('ababc'), 'abb#c',
            'The first example is correct';
    };

    subtest 'Example 2' => sub {
        note "Input: ‘xyzzyx’";
        note "Output: ‘xyzyx#’";

        is $CLASS->from_string('xyzzyx'), 'xyzyx#',
            'The second example is correct';

    };
};

subtest '_fnr()' => sub {
    my %tests = (
        'a'     => 'a',
        'ab'    => 'b',
        'aba'   => 'b',
        'abab'  => '#',
        'ababc' => 'c'
    );

    while ( my ( $input, $expected ) = each %tests ) {
        is $CLASS->_fnr($input), $expected, "$input should return $expected";
    }
};

done_testing;

The second subtest I wrote in a style where I had my inputs and expected outputs in a hash, then loop around them and repeat the test. It’s a mixed blessing. I mainly prefer manual tests and to have input, expected and got all together. But in this case it seemed to make sense.

Like I said above; I was happy that I solved this task by

1. Solving the looping around the string
2. Solving the FNR part

Doing part one first helped me explore the problem without worrying about the solution. The examples in the challenge were helpful as it showed the loops. So as you see in the video; I was able to replicate that.

Solving the fnr part was interesting as I hit the “flakey tests” problem. I had tests that passed some of the time. Why? Because I was looping around the keys of the hash… and hashes have random order. This was interesting as there was one situation in the test where it would fail. Changing to looping around an array (which has a fixed order) solved the problem.

Having the tests running repeatedly via the linux watch command saved me from potential problems. If I had run them manually; or only tested the final script; then I might have missed the edge case. A lesson there for future Lance; testing repeatedly even after you have a passing test is a good thing.

Anyway… please do checkout the twitch or youtube videos. The solutions are in the PerlWeeklyChallenge git repo if you want to check them out in detail: https://github.com/lancew/perlweeklychallenge-club/tree/branch–1/challenge-074/lance-wicks/perl?utm_source=rss&utm_medium=rss