Originally published at Perl Weekly 773

Hi there!

Recently there were a number of days that the perl-tester Docker image did not build properly. It is always a bit of an issue with it, because there quite a few moving parts. Parts where the dependency isn't fixed. e.g. in most of the cases it installs the most recent version of the modules from CPAN. Which mean any release of any module might break the whole build process. This time, however, the source of the problem was the new release of App::cpm, the tool used to install the CPAN modules. As often the case the new release was intended to improve things: cpm v1: making installs stable, but it broke the build on some of the older versions of Perl just by increasing the minimum version of Perl required.

One solution would be to fix all the dependencies, both tooling and the modules we install, but then someone would need to keep track of changes (the way dependabot does) which is probably way too much work for the few people who contribute to this project. The other solution might be to create an easy way to see what changed between the last successful build and the current failing build. We have started to work on a tool that will help with that. It will also allow us to show exactly what is in every image. BTW If you have spare stars in your pocket, it would be nice if you gave one to the docker-perl-tester project.

A couple of days ago I started to play with FalkorDB, an Open Source Graph Database. I already gave a presentation in Hebrew on how to use in general and specifically in Python. In a couple of hours I am going to give another one - this time in English - an intro to GraphDB. I'll use Rust for the programatic examples. It seems there is no client for it in Perl so it might be an interesting project to build one. The one in Python uses the Redis module for connectivity so I looked at the options to use Redis in Perl. MetaCPAN showed the Redis module as the first hit. Unfortunately that module did not have a commit for 3 years and there are many outstanding Issues and even PRs. So I posted about it both in the Perl Maven WhatsApp group and in the Telegram channel. Within seconds I was pointed towards Mojo::Redis and Redis::XS as alternatives.

Online Events: If you are in an American time-zone then both the Boston Perl Mongers and the Toronto Perl Mongers have semi-regular online meetings in your evening hours with various interesting speakers. If you are in the European time-zones or you don't mind having a meeting in your morning hours in the Americas, then there is the Perl Maven group where it is mostly me giving a presentation or working on some code. For details check out the Perl Weekly events page.

Enjoy your week!

--
Your editor: Gabor Szabo.

Announcements

cpan.org email forwarding has been shut down

The Perl NOC team has shut down the forwarding of email to the cpan addresses. If you are a CPAN author, please make sure MetaCPAN displays ways to contact you. (link to the source git repository of your projects, a LinkedIn account, an email address, etc.)

Articles

cpm v1: making installs stable

I rarely include articles from Medium as most of them are spam, but this one is real. So here you are!

Is your account on blogs.perl.org registered with an @cpan.org email address?

Installing Bit::Vector on Debian 13 (Trixie)

It is good that this information can be found on a public blog post, but IMHO it would be event better if this was part of the README or the documentation of the project.

My Journey with Devel::ptkdb - Origins

Enabling AddressSanitizer (ASan) in Makefile.PL for Linux Environments

Introducing Time::Str

At first I was wondering why this new module when DateTime provides all the features, but then I read on and there are a few reasons. Interesting.

Discussion

Optional stricter normalization of raw ISBN input

An issue that gives an opportunity for you to share your thoughts.

Why does a call to ref on a reference to 'substr' produce 'LVALUE'?

Perl

This week in PSC (224) | 2026-05-11

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 Marc Perry.

The Weekly Challenge - 374

Welcome to a new week with a couple of fun tasks "Count Vowel" and "Largest Same-digits Number". 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 - 373

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

Perl Weekly Challenge 373: Equal List

The clean, logical structure of Abigail's detailed technical analysis provides a very clear and rational basis for how best to apply mathematical theory to practical use. With a focus on optimising the algorithmic complexity rather than executing a brute force approach, Abigail delivers an incredibly efficient solution to this problem that will be valuable to all developers who wish to create highly efficient solutions to their problems.

Perl Weekly Challenge 373: List Division

Abigail's solution to the list partitioning problem is a beautifully crafted and idiomatic implementation that completely avoids the cumbersome index-tracking that traditional loop-based implementations require. The implementation is easy to read and is highly efficient because it leans heavily on the mechanics of the underlying language. This illustrates how an effective structural data transformation paradigm can result in simpler implementations.

List the List

Through a demonstration using gather and take in conjunction with native array splicing Arne demonstrates Raku's capabilities and gives a simple way to distribute remaining list offsets without having to rely on complex nested loops or overhead due to atypical index calculations. The result is a functional representation showing how Raku can eliminate complications associated with the partitioning of structural data, creating an intuitive self-documenting pattern.

Let's Dance to List Division

Bob has produced a superbly developer-oriented analysis addressing the pragmatic aspects of designing APIs using Perl's 'flat' argument list mechanism. Bob's approach to using array references in conjunction with a dual-while-loop, which uses 'destructive splice' calls to divide the input data into well-balanced partitions, enables this entire operation to occur without requiring any complex index-tracking cognitive load.

Divide and Concat

Jorg has provided a mathematically accurate and highly precise solution that demonstrates command of Perl's multidimensional array manipulation and list processing capabilities. The solution has been designed with a heavy emphasis on reducing iteration overhead, and uses a clean and logical approach to conditional checking. Overall, the implementation is an efficient way to manage data structures for all of the tasks required to complete this project.

Perl Weekly Challenge 373

W. Luis Mochan gives an interesting, very mathematical view of the difficulties and has elevated the difficulty of the tasks by discussing the different ways each of these tasks can be solved through their mathematical representations. The way the solution uses Perl Data Language is unique in its creativity and clearly shows how matrix operations and vector operations can be applied in a different manner to solve an algorithmic process much more efficiently and faster than typical procedural methods. This is a remarkable, challenging read, demonstrating the way that thinking in terms of vectors alone can change the way standard procedure of manipulating data can be made into a high level, abstract manner.

Because your list, your list I can’t resist

Packy offers a unique perspective on the challenge by framing the approach through an interesting musical context, followed by a really clean, multilingual show-off with a few different language options. As a polyglot expert, Packy's write-up shows a number of idiomatic and clean ways to solve problems in both Perl and Elixir. The solutions have been complimented for their clear structure, readable transformations of data, and the highly contrasting ways in which they use the procedural power of Perl with the functional, pipeline-based elegance of Elixir.

The week of lists

This paragraph describes the outstanding quality of Peter's work in executing his weekly assignments and projects using clear and detailed methods. He concentrates on providing clear and easy to understand explanations of all aspects of the problem using very pragmatic solutions with less complex algorithms than would be required to complete this task, and thus have produced solutions with low run times and high readability. Another benefit of using this strategy is that it will have produced many examples of good clean and maintainable code, as well as simple Perl code showing how to accomplish structural validation without additional runtime cost.

The Weekly Challenge - 373: Equal List

The analysis that Reinier provided on this challenge is truly impressive due to the systematic approach used to cover edges and validate input. The solution makes a great balance between how computer efficient it is to run while at the same time being easy to scan through for code due to well-named variables and clearly defined logical conditions. This is a great resource for developers looking to implement defensive programming and build highly maintainable systems.

The Weekly Challenge - 373: List Division

Reinier has presented a very clear and logical way to solve the list partitioning problem through clarity in procedural programming and appropriately managing data through effective use of algorithms. The implemented solution is easy to follow, with simple looping structures and clearly defined conditions used to divide the collection according to specification without introducing complexity into the underlying architecture. This solution is a perfect example of pragmatic programming, where simplicity, maintainability, and consistency take precedence over unnecessary abstraction.

The Weekly Challenge #373

The analysis provided by Robbie consists of an analysis of the weekly problems and an an idea of what you'd have to do. The breakdown of the problems will be thoroughly examined and will include thorough analysis of all the constraints on the solution as well as a commitment to validate input sufficiently to account for any and all edge cases and to deal with them accordingly. The combination of cleanly structured idiomatic programming style (including the use of loops) with clear and explicit comments that explain the logic behind the programming additions and modifications, make this a great reference source for new and experienced programmers to use.

There Is No Equality Without Division

Roger performs a beautiful and tidy example of modern solutions to solving problems through example in different programming languages and paradigms. The two different types of tasks, structural validation and partitioning, have been broken down into separate clear logical blocks that allow for high readability of solutions and the use of commonly used data structures without the use of complex loops. The write-up contains an excellent comparison of the different language features that reduce index-tracking overhead while still providing optimal run-time efficiency and successfully illustrates how functional programming techniques can be used successfully with non-functional programming techniques.

Joining and splitting lists

Simon has presented an impressively logical and practical polyglot demonstration that compares the elegant way of handling the first task in Python to how it is done through direct translations into Perl. The first task's solution is particularly notable for its concise efficiency and consists of a great, simply written one-liner using native methods to join strings and performing a direct comparison to form the structure of the list being checked. In the second task, Simon has shown a brilliant method for diving an array into equal components by taking advantage of the mathematical operation called divmod or remainder and relying on destructive splice operations to divide the arrays evenly without creating any overhead from having to manage cumbersome index numbers.

Videos

Parsing Perl Without Perl - A Rust LSP for Perl 5

A presentation by Steven Zimmerman, CPA, at the online event of the Toronto Perl Monger

Acting Out With Claude: MCPs in Perl

A presentation by Steven Lembark, at the online event of the Toronto Perl Monger

Weekly collections

NICEPERL's lists

Great CPAN modules released last week.

Events

Exploring Perl Modules

May 20, 2026

Toronto.pm - online - JSON Schema: language-agnostic typing / May TPM meeting

May 29, 2026

Boston Perl Mongers virtual monthly

June 9, 2026

The Perl and Raku Conference 2026

June 26-29, 2026, Greenville, SC, USA

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.

Fuzzing Irssi with Perl Scripts

TL;DR: Breaking tech news from Unnamed Source.

What Happened

📰 Unnamed Source is reporting on this story. This is a tech development worth watching closely.

Why It Matters

This story could have significant implications for the global community following tech trends.

Key Takeaways

• 📌 Reported by Unnamed Source
• 📌 Category: tech
• 📌 Read full story →

Follow GlobalWFeed on Telegram →

🤖 Automatically posted by Global Feed Bot

The task title reminded me of the song Let's Dance to Joy Division. Oddly applicable lyrics for a blog about programming: "But I worked something out last night that changed this little boy's brain, a small piece of advice that took 22 years in the make, and I will break it for you now. Please learn from my mistakes." And who doesn't love a wombat?

Task Description

You are given a list and a non-negative integer, $n. Write a script to divide the given list into $n equal parts. Return -1 if $n is more than the size of the list.

Example 1

Input: @list = ( 1,2,3,4,5), $n = 2
Output: ((1,2,3), (4,5))

• 5 / 2 = 2 remainder 1. The extra element goes into the first chunk.

Example 2

Input: @list = (1,2,3,4,5,6), $n = 3
Output: ((1,2), (3,4), (5,6))

• 6 / 3 = 2 remainder 0.

Example 3

Input: @list = (1,2,3), $n = 2
Output: ((1,2), (3))

Example 4

Input: @list = (1,2,3,4,5,6,7,8,9,10), $n = 5
Output: ((1,2), (3,4), (5,6), (7,8), (9,10))

Example 5

Input: @list = (1,2,3), $n = 4
Output: -1

Example 6

Input: @list = (72,57,89,55,36,84,10,95,99,35), $n = 7;
Output: ((72,57), (89,55), (36,84), (10), (95), (99), (35))

Elaboration

There's some simple modulo division here, and then a decision about what to do if it doesn't divide evenly into $n chunks. We could put the remainder into a chunk of its own, ignore the remainder, or we could distribute the leftovers in some way that feels balanced -- here, the specification implies that the bigger divisions should go at the front of the list.

Handling an invalid input (where $n is too big) by returning -1 instead of an array is a code smell. Having a function that returns different types of things is awkward to handle and error-prone. It would be more consistent to either throw an exception, or return an out-of-range value of the same type, such as an empty array or a null reference. But that wanker Kevin with his six months of Javascript experience got promoted to project manager for some reason <cough/>nepotism<cough> and that's the requirement we have.

This task has six examples, and usually we're given five. Is there some significance to this? Example 6 doesn't seem to add any new information beyond what we've already been given. But then we notice that the numbers could be ASCII characters, spelling "H9Y7$T?_c#". I'm pretty sure this is Kevin's password. Watch your back, Kevin.

To the CodeMobile, Robin!

sub listDivision($list, $n)
{
    my $size = @$list;
    return -1 if $n > $size;

    my $chunk = floor($size / $n);
    my $extra = $size % $n;
    my @answer;

    while ( $extra-- ) { push @answer, [ splice(@$list, 0, $chunk + 1) ]; }
    while ( @$list   ) { push @answer, [ splice(@$list, 0, $chunk    ) ]; }
    return \@answer;
}

The input parameters are an array and a number, which forces us to confront the way that Perl passes arguments as a flat list. Here, I've chosen to pass an array reference for $list instead of an array, which accomplishes two things: it removes the flat list problem to make it obvious which parameter is $n, and it's more efficient than passing a copy of the array. I could have also passed the parameters in the other order, but "project manager" Kevin said according to ChatGPT and Claude it had to be in this order, so yeah, that's that then.

Time to be serious. We dispense with the special case of returning -1 (more on that later). Then we calculate the quantities involved, and set up an array for producing the answer, initially empty.

The answer has two segments: a head part where there might be one extra element, and the tail part where the segments are of the calculated chunk size. One while loop ticks off the extra-sized chunks, and the second while loop completes the division.

To grab a group of contiguous elements from a list, the splice function seems like the obvious thing to do. Each splice is surrounded with [] so that the chunks are treated as array references. An alternative would have been to take an array slice, but that would introduce index variables for the range being sliced, which looks and feels more complicated and error-prone.

splice reduces the size of the list every time it's called, so the second while loop can use the size of $list as its condition. However, we are destroying $list as we go, so the calling function needs to be aware that the array it passed in is no longer valid. If it were important to keep the original list, a copy would need to be made either from the caller, or near the beginning of listDivision().

Let's think a moment about how to use this function. When it's called it could return either an array of arrays (references actually), or it could return a scalar -1. Here's how I wanted to write the script to use this function, using -n as a command-line option to get that parameter:

use GetOpt::Long;
my $N = 1;
GetOptions("n:i" => \$N);
my $div = listDivision([@ARGV], $N);
say showAofA($div);

where showAofA() is a function that formats the array of arrays into a parenthesized list of comma-separated lists, as in the examples.

However, $div isn't always a reference; sometimes it's a scalar -1. That throws up an ugly error about trying to use a scalar value as a reference. The way to check what's behind a variable in Perl is to use the ref function. It will give a string identifying the variable type, or, for a scalar, it will give an empty string. In perl, an empty string counts as false. So, to satisfy the requirement, the script needs to test whether ref($div) is empty:

say ( ref($div) ? showAofA($div) : $div );

What I probably should have done is change listDivision so that it consistently returns an array reference, but for the invalid case, throws an error. Variations on try/catch have been available as modules in Perl for decades, but it finally (see what I did there?) became official in version 5.38. That simplifies the usage of the function (if you consider try/catch simpler, which some consider a debatable topic).

try          { say showAofA( listDivision([@ARGV], $N) ); }
catch ( $e ) { say "-1" }

To make the function throw an exception, we only need to change the early return from the function into a die:

sub listDivision($list, $n)
{
    my $size = @$list;
    die "N out of range (must be <= $size)" if $n > $size;
    # [ ... ]

That's cleaner, but it slightly complicates the unit testing, because now we have to test for exceptions. The incantation is:

sub runTest
{
    use Test2::V0;
    use Test2::Tools::Exception;
    # [Test cases that should work
    is( listDivision([1,2,3], 1), [[1,2,3]], "One chunk");
    # [ ... ]
    # Test things that throw exceptions
    like ( dies { listDivision( [1,2,3], 4) }, qr/out of range/);

The dies function returns the exception string that results from trying to execute a code block, and like does a pattern match against the expected exception.

And finally, to tidy up a loose end, here's the showAofA() function.

sub showAofA($ref)
{
    return '('. join(',', map { '('.join(',', $_->@*).')' } $ref->@*) .')';
}

Let's take a bunch of punctuation out of that so that we can see the structure:

return ( join( map { join } ) ref )

$ref is a reference to an array of references; hence, $ref->@* is de-referencing it to yield a list of array references.

Each of those array references is then transformed by map. Inside the map {} block, $_ refers to one of the inner arrays, so we de-reference that ($_->@*) to get a list of numbers, which we will join into a comma-separated string. Wrap that with a pair of parentheses, and out of the map comes the inner lists formatted as needed.

Now each of the inner lists is a string. The outer join inserts commas to make it a list of lists, and finally we wrap the whole thing in parentheses to complete the string.

Note: This method is designed for Linux systems where LD_PRELOAD is available.
AddressSanitizer (ASan) is a powerful tool for detecting memory corruption in C/C++ code. When developing Perl XS modules, you can integrate ASan support directly into your Makefile.PL to make debugging seamless.

Add the 'asan-on-linux' Option

First, use GetOptions to provide a dedicated flag for ASan. This allows users to enable memory sanitization explicitly. We also set up a temporary directory to store ASan's detailed log files.

use Getopt::Long;
use File::Path 'mkpath';

GetOptions('asan-on-linux' => \my $asan_on_linux);

my @ccflags;
my @ldflags;
my $asan_logs_dir = ".tmp/asan_logs";

if ($asan_on_linux) {
    push @ccflags, "-fsanitize=address", "-fno-omit-frame-pointer";
    push @ldflags, "-fsanitize=address";
    
    mkpath $asan_logs_dir unless -d $asan_logs_dir;
}

Automate Library Preloading via Makefile Macros

Since the standard perl binary isn't typically compiled with ASan, we must ensure libasan.so is correctly preloaded before the interpreter starts. By using the macro parameter in WriteMakefile, we can automate this process for make test.

use Config;

WriteMakefile(
    NAME              => 'My::Module',
    CCFLAGS           => "$Config{ccflags} " . join(' ', @ccflags),
    LDDLFLAGS         => "$Config{lddlflags} " . join(' ', @ldflags),
    # ...
    macro => {
        $asan_on_linux ? (
            'override FULLPERL' => qq|LD_PRELOAD=\$\$($Config{cc} -print-file-name=libasan.so) ASAN_OPTIONS="log_path=$asan_logs_dir/asan.log:exitcode=0" $^X|
        ) : (),
    },
);

How to Handle Memory Issues

When ASan is enabled, the behavior depends on the type of memory issue:

• Memory Corruption: Issues like buffer overflows or use-after-free will cause a Segmentation Fault (Segfault) immediately. When this happens, you must fix the code until all tests pass without crashing.
• Memory Leaks: Unlike corruption, memory leaks do not cause a crash. To find them, you must check the logs after running your tests.

ASan generates a separate log file for each process. To efficiently find both corruption reports and leaks related to your specific module, use the following Perl one-liner (Replace My::Module with your module's name):

perl -00 -ne 'print "--- File: $ARGV ---\n$_\n" if /My::Module/' .tmp/asan_logs/* > .tmp/asan_summary.log

This command uses Perl's "paragraph mode" (-00) to extract the entire stack trace, allowing you to see exactly where the issue (crash or leak) was triggered in your native code.

Appendix: Platform Compatibility

macOS (Untested Hint)

On macOS, you might try DYLD_INSERT_LIBRARIES instead of LD_PRELOAD. However, System Integrity Protection (SIP) often prevents preloading into system binaries like /usr/bin/perl. You would likely need to use a perl installed via perlbrew or plenv.

Windows (Not Supported)

This mechanism is not applicable to Windows. Windows lacks LD_PRELOAD, and memory sanitization requires a fundamentally different configuration, typically involving a specially compiled perl interpreter.

Author: Yuki Kimoto

Weekly Challenge 373

Each week Mohammad S. Anwar sends out The Weekly Challenge, a chance for all of us to come up with solutions to two weekly tasks. My solutions are written in Python first, and then converted to Perl. Unless otherwise stated, Copilot (and other AI tools) have NOT been used to generate the solution. It's a great way for us all to practice some coding.

Challenge, My solutions

Task 1: Equal List

Task

You are given two arrays of strings.

Write a script to return true if the two given array represent the same strings otherwise false.

My solution

For input from the command line, I take a string with items concatenated by commas to generate the two lists. This seems to the easiest way to handle this, allowing for empty items as per the fourth example.

def main():
    result = equal_list(sys.argv[1].split(","), sys.argv[2].split(","))
    print("true" if result else "false")

This function is a one liner. I join the items in each list and then compare them to see if they are the same.

def equal_list(arr1: list[str], arr2: list[str]) -> bool:
    return ''.join(arr1) == ''.join(arr2)

The Perl solution has the same functionality.

sub main ( $str1, $str2 ) {
    my @arr1 = split /,/, $str1;
    my @arr2 = split /,/, $str2;

    say join( "", @arr1 ) eq join( "", @arr2 ) ? "true" : "false";
}

Examples

$ ./ch-1.py "a,bc" "ab,c"
false

$ ./ch-1.py "a,bc" "ab,c"
true

$ ./ch-1.py "a,b,c" "a,bc"
true

$ ./ch-1.py "a,bc" "a,c,b"
false

$ ./ch-1.py "ab,c," ",a,bc"
true

$ ./ch-1.py "p,e,r,l" "perl"
true

Task 2: List Division

Task

You are given a list and a non-negative integer.

Write a script to divide the given list into given non-negative integer equal parts. Return -1 if the integer is more than the size of the list.

My solution

For this task, I use the divmod function to calculate the number of items from the list each part needs, and the number of parts that require an extra item. These are stored as the variables item_length and extra_first.

I also have a variable called pos to store the position of the first letter. I have a loop i that runs n times. If i is less than extra_first, I take item_length + 1 items, otherwise item_length times, adding to pos as I go.

def list_division(input_list: list[int], n: int) -> list[list[int]] | None:
    result = []
    pos = 0

    if len(input_list) < n:
        return None

    item_length, extra_first = divmod(len(input_list), n)

    for i in range(n):
        this_length = item_length + 1 if i < extra_first else item_length
        result.append(input_list[pos:pos+this_length])
        pos += this_length

    return result

The Perl solution is similar. It doesn't have the pos variable, as it uses the splice function to remove the necessary number of items from the array. This function returns the items removed.

sub main (@list) {
    # The last value is the 'n' value
    my $n = pop(@list);
    my $length = scalar(@list);

    my @result = ();

    if ( $length < $n ) {
        say -1;
        return;
    }

    my $item_length = int( $length / $n );
    my $extra_first = $length % $n;

    foreach my $i ( 1 .. $n ) {
        my $this_length = $i <= $extra_first ? $item_length + 1 : $item_length;
        push @result, "(" . join( ",", splice( @list, 0, $this_length ) ) . ")";
    }

    say "(" . join( ", ", @result ) . ")";
}

Examples

$ ./ch-2.py 1 2 3 4 5 2
((1,2,3), (4,5))

$ ./ch-2.py 1 2 3 4 5 6 3
((1,2), (3,4), (5,6))

$ ./ch-2.py 1 2 3 2
((1,2), (3))

$ ./ch-2.py 1 2 3 4 5 6 7 8 9 10 5
((1,2), (3,4), (5,6), (7,8), (9,10))

$ ./ch-2.py 1 2 3 4
-1

$ ./ch-2.py 72 57 89 55 36 84 10 95 99 35 7 
((72,57), (89,55), (36,84), (10), (95), (99), (35))