I have released Test2::Plugin::SubtestFilter for Perl tests, which allows filtering test targets by subtest name, similar to --testNamePattern in jest and vitest. I think it is useful when you want to run only specific tests.

# t/test.t
use Test2::V0;
use Test2::Plugin::SubtestFilter;

subtest 'foo' => sub {
    subtest 'nested foo1' => sub { ok 1 };
    subtest 'nested foo2' => sub { ok 1 };
};

subtest 'baz' => sub {
    ok 1;
};

done_testing;

# Run tests matching `foo1`
❯ SUBTEST_FILTER=foo1 prove -lvr t/test.t
t/test.t ..
# Seeded srand with seed '20251020' from local date.
ok 1 - foo {
    ok 1 - nested foo1 {
        ok 1
        1..1
    }
    ok 2 - nested foo2 # skip
    1..2
}
ok 2 - baz # skip
1..2
ok
All tests successful.
Files=1, Tests=2,  0 wallclock secs ( 0.00 usr  0.00 sys +  0.04 cusr  0.00 csys =  0.04 CPU)
Result: PASS

Originally published at Perl Weekly 743

Hi there,

Last week I went to a small conference on "Teaching Computer Science in the era of AI/LLMs" hosted at The Academic College of Tel Aviv-Yaffo. It was very interesting to hear how at various institutions, for example at the Technion, at the Tel Aviv University and at Ben Gurion University the lecturers feel the need to change things as LLMs can now implement basically everything at the level of a CS student in a BSc program. How do you teach them to actually learn the syntax? How much should you let them use LLMs for the assignments and during the exams?

I personally teach a course at the Weizmann Institute of Science to Master's and Phd students of Biology and Life Sciences. I think 15 years ago there was a course in Perl, but now this is in Python. It is very different from teaching CS students. My students use the language a lot more to write one-time programs to analyze some data and most of them don't see themselves as 'programmers'. So they are way less interested in syntax, or 'good code'. They mostly want to get nice graphs.

It is quite clear that giving them well written assignments is rather pointless. They can just put the assignment in an LLM and get the result. So what can be done?

As the semester starts this coming Sunday I really need to figure out how and what to teach them. Should I basically teach them prompt engineering?

Related to this I'd love to hear from you - either in an email or better yet in a blog post - on how do you use LLMs to write code? Especially Perl code. Which LLMs do you use? How do you make your prompts better? Anything special to Perl code?

What would you recommend to fellow Perl developers, how to best use LLMs while writing Perl code?

I know we are all still trying to figure this out, but learning from each other could make this process easier.

Enjoy your week!

--
Your editor: Gabor Szabo.

Articles

The joy of rediscovering Perl

Wait a minute, Mr POSTman

Debugging POST request headers in under 40 screen rows. Doesn't actually use Postman.

Clipadd Cookbook

clipadd, a CLI included in the App::ClipboardUtils distribution, lets you add items to the desktop clipboard. It is clipboard-manager-agnostic, supporting backends like xclip and Klipper. It also has some convenient features which will be demonstrated in this document.

Porting from Perl to Go: Simplifying for Platform Engineering

Rewriting a script for the Homebrew package manager taught me how Go’s design choices align with platform-ready tools.

Discussion

Full stack javascript developer looking to find a perl job

Compute the Reverse Polish Notation using Perl

Would you like to add comments to this post with your suggestions on how to improve the code?

Managing memory in the GPU with Perl

Task-MemManager-Device

perl XS modules for CUBIN files patching

Would love a good web hosting company to run Perl in a fcgi or plack or whatever

There are a number of companies where one can have a full VPS for 4-5 USD / month with root access. You can run your own code there directly on the VPS or you can run a Docker container on it and as the load on the system growth you can upgrade the VPS to something bigger for slightly more money. I have been using Linode and Digital Ocean for many years and I am very satisfied.

Perl

This week in PSC (204) | 2025-10-13

The Weekly Challenge

The Weekly Challenge by Mohammad Sajid Anwar will help you step out of your comfort-zone. You can even win prize money of $50 by participating in the weekly challenge. We pick one champion at the end of the month from among all of the contributors during the month, thanks to the sponsor Lance Wicks.

The Weekly Challenge - 344

Welcome to a new week with a couple of fun tasks "Array Form Compute" and "Array Formation". If you are new to the weekly challenge then why not join us and have fun every week. For more information, please read the FAQ.

RECAP - The Weekly Challenge - 343

Enjoy a quick recap of last week's contributions by Team PWC dealing with the "Zero Friend" and "Champion Team" tasks in Perl and Raku. You will find plenty of solutions to keep you busy.

TWC343

Clear, effective, and showcasing strong Perl programming abilities. While Task 2 efficiently counts wins in a match matrix with clear logic and sensible hash usage, Task 1 demonstrates succinct numeric handling with strong absolute value comparisons. All things considered, the answers are clear, accurate, and elegantly demonstrate how to solve real-world problems using Perl.

Team Zero

For both inexperienced and seasoned Raku developers, this is a great resource. It explores the nuances of the language and offers insightful lessons in efficient coding techniques in addition to offering workable answers to typical issues.

Friendly Champions

These solutions demonstrate superior algorithmic thinking and Perl programming at the expert level. This submission is incredibly impressive because it combines mathematical insight, language proficiency, and innovative problem-solving.

Perl Weekly Challenge 343

The solutions demonstrate the useful application of PDL for array and matrix operations and are technically sound and reliable. They are great illustrations of algorithmic problem-solving in Perl since they are not only accurate but also optimized for readability and maintainability.

The Zero Champion

In addition to overcoming the obstacles, Matthias did so in a way that inspired and educated others. Programming challenges are valuable because of contributions like this one.

Ze-ro the CHAMPIONS!

In addition to accurately resolving the difficulties, Packy has produced a superb analysis of how to apply the same algorithm across various programming paradigms while honoring the idioms and advantages of each language.

No friends among the champions

Both solutions demonstrate a thorough grasp of Perl's capabilities and are executed with clarity and efficiency. They make sure the code is both functional and maintainable by following best practices for coding.

The Weekly Challenge #343

Robbie's solutions show a thorough comprehension of the problem requirements and the ability to apply efficient algorithms. They are both elegant and mathematically sound. His creative method of breaking the tie in Task 2 gives the solution an additional level of complexity.

Zero to Champion

Roger's solutions exhibit a thorough comprehension of the problem requirements and are well-structured. The code is efficient and simple to understand because it makes use of Perl's built-in functions and simple logic. These implementations are great illustrations of how to precisely and clearly approach algorithmic problems.

It’s hard to make friends when you’re a zero

The two challenges are thoughtfully and technically insightfully explored in Ryan's post. His elegant and effective solutions demonstrate a thorough comprehension of Perl's capabilities.

Absolute Champion

Simon's solution shows a thorough grasp of Python's capabilities and is both simple and effective. He makes sure the solution is reliable and capable of handling a variety of numerical inputs by utilizing the decimal module.

Weekly collections

NICEPERL's lists

Great CPAN modules released last week;
MetaCPAN weekly report.

Events

Paris.pm monthly meeting

November 12, 2025

Toronto.pm - online - How SUSE is using Perl

December 6, 2025

Paris.pm monthly meeting

December 10, 2025

You joined the Perl Weekly to get weekly e-mails about the Perl programming language and related topics.

Want to see more? See the archives of all the issues.

Not yet subscribed to the newsletter? Join us free of charge!

(C) Copyright Gabor Szabo
The articles are copyright the respective authors.

use feature "switch";  
    # Construct operator priority data  
    %priority_of_operation=(  
    '+'=>1,  
    '-'=>1,  
    '*'=>2,  
    '/'=>2,  
    '('=>0,  
    ')'=>0  
    );  
    # Expression to be calculated  
    $prepare_exec="5.98+((1+2211.12)*4)-3";  
    $prepare_endexpres=$prepare_exec;  
    # Convert to Reverse Polish Notation  
    # Create operator stack for storing operators  
    @operationstack=qw();  
    $exeexpress=$prepare_endexpres;  
    $result="";  
    print "String to scan: $exeexpress\n";    
    while (length($exeexpress)>0)  
    {  
    # Scan expression sequentially, if current character is a number, output it directly  
    if ($exeexpress =~ /^(\d+)/ | $exeexpress =~/^((\d+)\.(\d*))/){  
       print "Number: $1\n";      
       $result.=($1." ");     
       print "Expression: $result\n";  
       $exeexpress=substr($exeexpress,length($1),length($exeexpress)-length($1));  
       print "String to scan: $exeexpress\n";     
    }  
    # If current operator is '(', push directly to stack     
    elsif($exeexpress =~ /^\(+?/){     
       print "Operator: (\n";      
       print "Operator ( pushed to stack\n";    
       push @operationstack,"(";    
       print "Current operator stack: @operationstack\n";  
       print "Expression: $result\n";     
       $exeexpress=substr($exeexpress,1,length($exeexpress)-1);     
       print "String to scan: $exeexpress\n";        
    }     
    # If it's ')', pop and output operators sequentially until encountering first '(', first '(' is popped but not output     
    elsif($exeexpress =~ /^\)+?/){     
        print "Operator: )\n";           
        $temp=pop @operationstack;  
        while ($temp ne "(") {     
           $result.=($temp." ");     
           print "Operator $temp popped, expression: $result\n";  
           $temp=pop @operationstack;    
           print "Current operator stack: @operationstack\n";   
        }           
        $exeexpress=substr($exeexpress,1,length($exeexpress)-1);         
        print "String to scan: $exeexpress\n";          
    }   
    # If it's arithmetic operator, compare priority of top stack element with current element. If priority of top stack element operator >= priority of current element, pop and output operators sequentially until priority of top stack element < priority of current element, then push current element to stack;   
    elsif($exeexpress =~/^(\+|\-|\*|\/)?(.*)$/)  
    {  
        print "Operator: $1\n";   
        print "Current operator stack: @operationstack\n";   
        $curoperation=$1    ;   
        $topoperation=pop @operationstack;  
        push @operationstack,$topoperation;       
        if ($topoperation){  
            if ($priority_of_operation{$curoperation}>$priority_of_operation{$topoperation})  
            {  
                # If this character's priority is higher than the operator at top of operator stack, push this operator to stack  
                push @operationstack,$curoperation;       
                print "Operator $curoperation pushed to stack\n";  
                $exeexpress=substr($exeexpress,1,length($exeexpress)-1);      
                print "String to scan: $exeexpress\n";               

            }  
            else{  
    # If priority of top stack element operator >= priority of current element, pop and output operators sequentially until priority of top stack element < priority of current element, then push current element to stack;   
                while ($priority_of_operation{$curoperation}<=$priority_of_operation{$topoperation})  
                {  
                    $topoperation=pop @operationstack;    
                    if (not $topoperation) {  
                        last;  
                    }  
                    $result.=($topoperation." ");  
                    print "Operator $topoperation popped, expression: $result\n";  
                }  
                push @operationstack,$curoperation;  
                $exeexpress=substr($exeexpress,1,length($exeexpress)-1);      
                print "String to scan: $exeexpress\n";               
            }  
        }  
        else{  
                push @operationstack,$curoperation;  
                print "Expression: $result\n";   
                $exeexpress=substr($exeexpress,1,length($exeexpress)-1);      
                print "String to scan: $exeexpress\n";               
        }  
        print "Current operator stack: @operationstack\n";  
    }  

    }  
    while ((scalar @operationstack)>0){  
        $result.=pop @operationstack;  
    }  
    print "Expression: $result\n";   
    $mycode=$result;  
    @waitingexe=split (" ",$mycode);  
    $mylength= scalar  @waitingexe;  
    print "Reverse Polish Notation to calculate: $mycode\n";  
    print "Starting Reverse Polish Notation calculation\n";  
    @exestack=qw();  
    # Output current stack contents  
    print "Current stack contents: @exestack\n";  
    for ($i=0;$i<$mylength;$i++){  
    # Start Reverse Polish Notation calculation  
     $myvar=$waitingexe[$i];  
     print "Element read: $myvar   =>";  
     given ($myvar){  
        when ("+") { $num2=pop @exestack;$num1=pop @exestack; $result=$num1+$num2;push @exestack,$result;print "$num1+$num2=$result, $num2 and $num1 popped, $result pushed\n";}  
        when ("-") { $num2=pop @exestack;$num1=pop @exestack; $result=$num1-$num2;push @exestack,$result;print "$num1-$num2=$result, $num2 and $num1 popped, $result pushed\n";}  
        when ("*") { $num2=pop @exestack;$num1=pop @exestack; $result=$num1*$num2;push @exestack,$result;print "$num1*$num2=$result, $num2 and $num1 popped, $result pushed\n";}  
        when ("/") { $num2=pop @exestack;$num1=pop @exestack; $result=$num1/$num2;push @exestack,$result;print "$num1/$num2=$result, $num2 and $num1 popped, $result pushed\n";}  
        # Numbers pushed directly to stack  
        default    {push @exestack,$myvar;print "$myvar pushed to stack\n";}  
    }  
        # Output current stack contents  
        print "Current stack contents: @exestack=>";  
    }  
    $endresult=pop @exestack;  
    print "Result: $endresult\n";  

    sub trim  
    {  
            my $string = shift;  
            $string =~ s/^\s+//;  
            $string =~ s/\s+$//;  
            return $string;  
    }

The above code evaluates a mathematical expression.
We will use the following example to illustrate the computation process.
The infix expression "5 + ((1 + 2) * 4) - 3" is written in Reverse Polish Notation as:

5 1 2 + 4 * + 3 -

The table below illustrates the step-by-step evaluation of this RPN expression from left to right.

When the calculation is complete, only one operand remains in the stack, which is the final result of the expression: 14.

Debugging POST request headers in under 40 screen rows. Doesn't actually use Postman

While developing a Perl client for the Harvard Astrophysics Data System API, I was getting errors from my POST requests. Not usually a problem to fix, but I connect to the host machine via a dodgy terminal session that hangs up when the screensaver kicks in or when the wind blows from the East. To keep from having to restart the 6+ windows that I have open in my dev env every time I go for a walk, I start a tmux session running on the host which ignores the SIGHUP and is just where I left it when I reconnect, no .swp files to clean up.

The problem is that I can't scroll up in tmux like I do in a regular terminal¹ which leaves me with 40 rows to read the error returned from the POST request. This is nowhere near enough. Hmmm...

💡 Remember that you're using LWP::UserAgent::Mockable (or its Mojo cousin) to record the tests to avoid using the network during the test pipeline. Realise that all the traffic from those network calls are stored as plain text files and you don't have to mess around with tcpdump just to inspect the HTTP headers anymore.

The raw file itself is a bit messy to look at (maybe I should write a quick tool that deserializes it for STDOUT), but it shows me that the Authorization header just isn't there. But it's in my code, I made sure. See right after the call to post ...

Ahh, after some reflection I realize that the post method makes the HTTP request as soon as it's invoked, which is why I was using build_tx in the GET request to add my Dev Key, like so

my $tx = $self->ua->build_tx( GET => $url );
$tx->req->headers->authorization( 'Bearer ' . $self->token );
...
try { $tx = $self->ua->start($tx) }
catch ($error) { ...
}

Now, the response has changed from UNAUTHORIZED to INTERNAL SERVER ERROR. I try the curl command suggested by the docs and that works fine. Look back in the mock file and see ... no payload.

Quietly add the json attribute to the transaction constructor

my $tx = $self->ua->build_tx( POST => $url, json => $hash );

because sending a JSON payload is so damn easy in Mojo.

All done - and Robert is your mother's brother.

1. why yes, you can scroll up and down in a tmux session when you remember to enter Copy mode with Prefix [ so you get the arrow keys and the Page Up/Down buttons to play with. Enter to exit. ↩

Rewriting a script for the Homebrew package manager taught me how Go’s design choices align with platform-ready tools.

The problem with brew upgrade

By default, the brew upgrade command updates every formula (terminal utility or library). It also updates every cask (GUI application) it manages. All are upgraded to the latest version — major, minor, and patch. That’s convenient when you want the newest features, but disruptive when you only want quiet patch-level fixes.

Last week I solved this in Perl with brew-patch-upgrade.pl, a script that parsed brew upgrade’s JSON output, compared semantic versions, and upgraded only when the patch number changed. It worked, but it also reminded me how much Perl leans on implicit structures and runtime flexibility.

This week I ported the script to Go, the lingua franca of DevOps. The goal wasn’t feature parity — it was to see how Go’s design choices map onto platform engineering concerns.

Why port to Go?

• Portfolio practice : I’m building a body of work that demonstrates platform engineering skills.
• Operational focus : Go is widely used for tooling in infrastructure and cloud environments.
• Learning by contrast : Rewriting a working Perl script in Go forces me to confront differences in error handling, type safety, and distribution.

The journey

Error handling philosophy

Perl gave me try/catch (experimental in the Perl v5.34.1 that ships with macOS, but since accepted into the language in v5.40). Go, famously, does not. Instead, every function returns an error explicitly.

use v5.34;
use warnings;
use experimental qw(try);
use Carp;
use autodie;

…

try {
  system ‘brew’, ‘upgrade’, $name;
  $result = ‘upgraded’;
}
catch ($e) {
  $result = ‘failed’;
  carp $e;
}

package main

import (
  “os/exec”
  “log”
)

…

cmd := exec.Command(“brew”, “upgrade”, name)
if output, err := cmd.CombinedOutput(); err != nil {
  log.Printf(“failed to upgrade %s: %v\n%s”,
    name,
    err,
    output)
}

The Go version is noisier, but it forces explicit decisions. That’s a feature in production tooling: no silent failures.

Dependency management

• Perl : cpanfile + CPAN modules. Distribution means “install Perl (if it’s not already), install modules, run script.” Tools like carton and the cpan or cpanm commands help automate this. Additionally, one can use further tooling like fatpack and pp to build more self-contained packages. But those are neither common nor (except for cpan) distributed with Perl.
• Go : go.mod + go build. Distribution is a single (platform-specific) binary.

For operational tools, that’s a massive simplification. No runtime interpreter, no dependency dance.

Type safety

Perl let me parse JSON into hashrefs and trust the keys exist. Go required a struct:

type Formula struct {
  Name string `json:"name"`
  CurrentVersion string `json:"current_version"`
  InstalledVersions []string `json:"installed_versions"`
}

The compiler enforces assumptions that Perl left implicit. That friction is valuable — it surfaces errors early.

Binary distribution

This is where Go shines. Instead of telling colleagues “install Perl v5.34 and CPAN modules,” I can hand them a binary. No need to worry about scripting runtime environments — just grab the right file for your system.

• homebrew-semver-guard-darwin (Universal Binary for macOS)
• homebrew-semver-guard-linux-amd64 (Intel/AMD 64-bit binary for Linux)
• homebrew-semver-guard-linux-arm64 (Arm 64-bit binary for Linux)

Available on the release page. Download, run, done.

Semantic versioning logic

In Perl, I manually compared arrays of version numbers. In Go, I imported golang.org/x/mod/semver:

import (
  golang.org/x/mod/semver
)

…

if semver.MajorMinor(toSemver(formula.InstalledVersions[0])) !=
  semver.MajorMinor(toSemver(formula.CurrentVersion)) {
  log.Printf(“%s is not a patch upgrade”, formula.Name)
  results.skipped++
  continue
}

Cleaner, more legible, and less error-prone. The library encodes the convention, so I don’t have to.

Deliberate simplification

I didn’t port every feature. Logging adapters, signal handlers, and edge-case diagnostics remained in Perl. The Go version focuses on the core logic: parse JSON, compare versions, run upgrades. That restraint was intentional — I wanted to learn Go’s idioms, not replicate every Perl flourish.

Platform engineering insights

Three lessons stood out:

1. Binary distribution matters. Operational tools should be installable with a single copy step. Go makes that trivial.
2. Semantic versioning is an operational practice. It’s not just a convention for library authors — it’s a contract that tooling can enforce.
3. Go’s design aligns with platform needs. Explicit errors, type safety, and static binaries all reduce surprises in production.

Bringing it home

This isn’t a “Perl vs. Go” story. It’s a story about deliberate simplification, taking a working Perl script and recasting it in Go. The aim is to see how the language’s choices shape a solution to the same problem.

The result is homebrew-semver-guard v0.1.0, a small but sturdy tool. It’s not feature-finished, but it’s production-ready in the ways that matter.

Next up: I’m considering more Go tools, maybe even Kubernetes for services on my home server. This port was a practice, an artifact demonstrating platform engineering in action.

Links

• Original Perl script: brew-patch-upgrade.pl
• Go release: homebrew-semver-guard v0.1.0
• Last week’s post: Patch-​Perfect: Smarter Homebrew Upgrades on macOS