Originally published at Perl Weekly 763

Hi there!

While we are still low on articles we had a good start in the WhatsApp group I mentioned 2 weeks ago. People introduced themselves and there were some light conversations. You are welcome to join us and write a few words about yourself.

There are also a number of Perl related events on the horizon in Paris and Berlin and the virtual event I organize.

Finally I published the Code Maven Academy site where there are already 140 hours of videos including 30 hours related to Perl. I'll keep recording these during live events and participants of my events will also get a discount coupon.

Enjoy your week!

--
Your editor: Gabor Szabo.

Announcements

Perl 5.42.1 is now available!

'We are pleased to announce version 42.1, the first maintenance release of version 42 of Perl 5.': Perldelta

Articles

ANNOUNCE: Perl.Wiki & JSTree V 1.41, etc

Beautiful Perl feature : fat commas, a device for structuring lists

Beautiful Perl feature: trailing commas

More dev.to articles on beautiful Perl features

A meta-article about the series.

Discussion

Protocol Buffers (Protobuf) with Perl

Perl

This week in PSC (216) | 2026-03-02

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 - 364

Welcome to a new week with a couple of fun tasks "Decrypt String" and "Goal Parser". 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 - 363

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

Sheriff Detector

The post offers a clear and elegant walkthrough of solving two interesting problems using Raku. It stands out for its well-explained code, practical examples, and thoughtful use of language features like subsets, parsing, and bitwise operations.

Lying Sheriffs

The article provides a clear and well-structured exploration of the challenge, combining thoughtful algorithmic reasoning with an elegant implementation. The use of Perl and PDL demonstrates both efficiency and creativity, making the solution not only correct but also technically insightful. Overall, it's an excellent example of concise problem analysis paired with expressive code.

Perl Weekly Challenge 363

The post presents a clean and well-reasoned solution to the Perl Weekly Challenge, with concise Perl code and a clear explanation of the underlying logic. The approach is methodical and easy to follow, demonstrating solid problem-solving and thoughtful handling of edge cases.

I Don't Lie, Sheriff!

The post demonstrates a clean and thoughtful Perl implementation, with clear logic and well-structured code. The approach effectively handles both the self-referential string validation and the subnet-membership check, showing careful attention to correctness and readability.

I Shot The Subnet…

The post presents a clear and engaging walkthrough of the challenge, combining solid problem decomposition with readable Perl implementations. The explanation of the approach is practical and easy to follow, while the multi-language comparisons add extra technical value for readers exploring different idioms. Overall, it's a well-structured and insightful solution write-up.

Lies and lies within

The write-up presents a clear and methodical approach to solving the Perl Weekly Challenge, with well-structured code and helpful explanations of the reasoning behind the solution. The implementation is clean and idiomatic Perl, making the logic easy to follow and reproduce. Overall, it's a thoughtful and technically solid exploration of the problem.

The Weekly Challenge - 363

The write-up provides a clear and well-structured solution to the challenge, with careful input validation and readable Perl code that emphasizes robustness. The step-by-step logic and defensive programming style make the implementation easy to understand and reliable.

The Weekly Challenge #363

The blog presents a thorough and thoughtfully structured solution to the Perl Weekly Challenge, combining clear reasoning with well-documented Perl code. The modular design and detailed explanations make the logic easy to follow while demonstrating solid engineering discipline.

Stringy Sheriff

The post offers a clear and thoughtful walkthrough of solving the challenge with practical reasoning and well-structured code. Roger nicely explains the approach step-by-step, making the solution easy to follow while highlighting useful string-processing techniques.

The subnet detector

The post provides a clear and practical walkthrough of both tasks from The Weekly Challenge, with well-structured solutions in Python and Perl. The explanations highlight useful techniques such as regex parsing, handling UTF-8 characters, and leveraging networking libraries like Python's ipaddress and Perl's Net::IP.

Weekly collections

NICEPERL's lists

Great CPAN modules released last week.

Events

Perl Maven online: Code-reading and Open Source contribution

March 10, 2026

Paris.pm monthly meeting

March 11, 2026

German Perl/Raku Workshop 2026 in Berlin

March 16-18, 2026

Perl Toolchain Summit 2026

April 23-26, 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.

Weekly Challenge 363

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: String Lie Detector

Task

You are given a string.

Write a script that parses a self-referential string and determines whether its claims about itself are true. The string will make statements about its own composition, specifically the number of vowels and consonants it contains.

My solution

This was relatively straight forward in Python. I took the following steps:

1. Use a regular expression to extract the necessary parts of the input_string, and store this as the value match.
2. Count the number of vowels and consonants in the first value and store it as vowel_count and const_count.
3. Use the word2num module to convert the numbers in input_string to integers, stored as expected_vowel and expected_const.
4. Compare the count and expected values match, and return the result.

import re
from word2num import word2num

def string_lie_detector(input_string: str) -> bool:
    match = re.match(
        r"(\w+) . (\w+) vowels? and (\w+) consonants?", input_string)
    if not match:
        raise ValueError("Input string not in expected format")

    vowel_count = 0
    const_count = 0
    for c in match.group(1).lower():
        if c in "aeiou":
            vowel_count += 1
        else:
            const_count += 1

    expected_vowel = word2num(match.group(2))
    expected_const = word2num(match.group(3))

    return vowel_count == expected_vowel and const_count == expected_const

The Perl solution is a little more complex. Maybe my Google-foo isn't up to scratch (and I don't use Copilot when working on solutions) that there doesn't appear to be a CPAN module that will convert words into numbers. As this is a coding exercise only I have a hash called %word2num that maps words to number (from zero to twenty).

The next problem is four of the examples use a long dash as the separator. This is a UTF-8 character. The result of perl -E 'say length("—")' is 3. After numerous searches of the Internet, it turns out I need to include use utf8:all in the code. With this change, I get the expected result of 1.

The rest of the code follows the same logic as the Python solution.

use utf8::all;

sub main ($input_string) {
    my %word2num = (qw/
        zero 0 one 1 two 2 three 3 four 4 five 5 six 6 seven 7 eight 8
        nine 9 ten 10 eleven 11 twelve 12 thirteen 13 fourteen 14
        fifteen 15 sixteen 16 seventeen 17 eighteen 18 nineteen 19 twenty 20
    /);

    my ( $word, $v, $c ) =
      ( $input_string =~ /(\w+) . (\w+) vowels? and (\w+) consonants?/ );

    if ( !$word ) {
        die "Input string not in expected format\n";
    }

    my $vowel_count = 0;
    my $const_count = 0;
    foreach my $c ( split //, lc($word) ) {
        if ( index( "aeiou", $c ) == -1 ) {
            $const_count++;
        }
        else {
            $vowel_count++;
        }
    }

    my $expected_vowel = $word2num{ lc $v } // die "Don't know what $v is\n";
    my $expected_const = $word2num{ lc $c } // die "Don't know what $c is\n";

    my $truth =
      ( $vowel_count == $expected_vowel and $const_count == $expected_const );
    say $truth ? 'true' : 'false';
}

Examples

There was an issue with the examples, and I raised a pull request to fix it.

$ ./ch-1.py "aa — two vowels and zero consonants"
True

$ ./ch-1.py "iv — one vowel and one consonant"
True

$ ./ch-1.py "hello - three vowels and two consonants"
False

$ ./ch-1.py "aeiou — five vowels and zero consonants"
True

$ ./ch-1.py "aei — three vowels and zero consonants"
True

Task 2: Subnet Sheriff

Task

You are given an IPv4 address and an IPv4 network (in CIDR format).

Write a script to determine whether both are valid and the address falls within the network. For more information see the Wikipedia article.

My solution

This one was the easier of the two to complete. Maybe because I have worked at many IPSs in the past :-)

Python has the ipaddress module which makes it easy to confirm if an IPv4 address is in a particular IP address block.

I use a try/except block to handle situations (like the second example) where the IP address or net block is invalid. This follows the Python philosophy of Easier to Ask for Forgiveness than Permission.

import ipaddress

def subnet_sheriff(ip_addr: str, domain: str) -> bool:
    try:
        return ipaddress.IPv4Address(ip_addr) in ipaddress.IPv4Network(domain)
    except ipaddress.AddressValueError:
        return False

Perl has the Net::IP module in CPAN that performs similar functionality. If the IP address or net block is invalid, the variable will be undef, and the else block will be used.

use Net::IP;

sub main ( $ip_addr, $domain ) {
    my $addr = Net::IP->new($ip_addr);
    my $block = Net::IP->new($domain);
    if ( $addr and $block ) {
        my $overlaps = ( $addr->overlaps($block) != $IP_NO_OVERLAP );
        say $overlaps  ? 'true' : 'false';
    }
    else {
        say 'false';
    }
}

Examples

$ ./ch-2.py 192.168.1.45 192.168.1.0/24
True

$ ./ch-2.py 10.0.0.256 10.0.0.0/24
False

$ ./ch-2.py 172.16.8.9 172.16.8.9/32
True

$ ./ch-2.py 172.16.4.5 172.16.0.0/14
True

$ ./ch-2.py 192.0.2.0 192.0.2.0/25
True

$ ./ch-2.py 1.1.1.1 10.0.0.0/8
False

Beautiful Perl series

This post is part of the beautiful Perl features series.
See the introduction post for general explanations about the series.

Today's topic is a Perl construct called fat comma, which is quite different from the trailing commas discussed in the last post.

Fat comma: an introduction

A fat comma in Perl is a construct that doesn't involve a typographic comma! Visually it consists of an expression followed by an arrow sign => and another expression. This is used in many contexts, the most common being for initializing hashes or for passing named parameters to subroutines:

my %rect = (x      => 12,
            y      => 34,
            width  => 20,
            height => 10);
draw_shape(kind   => 'rect', 
           coords => \%rect,
           color  => 'green');

A fat comma is semantically equivalent to a comma; the only difference with a regular comma is purely syntactic: if the left-hand side is a string that begins with a letter or underscore and is composed only of letters, digits and underscores, then that string doesn't need to be enclosed in quotes. The example above took advantage of this feature, but it could as well have been written:

my %rect = ('x'      => 12,
            'y'      => 34,
            'width'  => 20,
            'height' => 10);
draw_shape('kind'   => 'rect', 
           'coords' => \%rect,
           'color'  => 'green');

or even:

my %rect = ('x', 12, 'y', 34, 'width', 20, 'height', 10);
draw_shape('kind', 'rect', 'coords', \%rect, 'color', 'green');

This last variant has exactly the same technical meaning, but clearly it does not convey the same impression to the reader; so the fat comma is mainly a device for improving code readability.

More general usage

Since Perl does not impose many constraints, fat commas can be used in many other ways than just initializing hashes or passing named parameters to subroutine calls:

1. they can appear at any place where a list is expected;
2. they need not be only in pairs: triplets, quadruplets, etc. are allowed;
3. mixtures of fat commas and regular commas are allowed (and even frequent);
4. the expression on the left-hand side of a fat comma need not be a string - it can be any value.

Most of these points are excellently illustrated in a collection of examples designed in 2017 by Sinan Ünür. Here is an excerpt from his answer to a StackOverflow question asking when to use fat comma if not for hashes:

Any time you want to automatically quote a bareword to the left of a fat comma:

system ls => '-lh';

or

my $x = [ a => [ 1, 2 ], b => [ 3, 4 ] ];

Any time you think it makes the code easier to see

join ', ' => @data;

Any time you want to say "into":

bless { value => 5 } => $class;

In short, => is a comma, plain and simple. You can use it anywhere you can use a comma. E.g.:

my $z = f($x) => g($y); # invoke f($x) (for its side effects) and g($y)
                        # assign the result of g($y) to $z

Fat commas for domain-specific languages

A number of CPAN modules took advantage of fat commas for designing domain-specific languages (DSLs), exploiting the fact that fat commas can be used liberally for other purposes than just expressing pairs.

Moose

Attribute declarations

Moose is the most well-known object-oriented framework for Perl; it also influenced several competing frameworks¹. Here is a short excerpt from the synopsis, showing a class declaration:

package Point;
use Moose;

has 'x' => (isa => 'Int', is => 'rw', required => 1);
has 'y' => (isa => 'Int', is => 'rw', required => 1);

This is an example where the fat comma does not introduce a pair of values, but rather a longer list in which the first element (the attribute name) is deliberately emphasized. Technically this x attribute could have been declared as:

  has('x', 'isa', 'Int', 'is', 'rw', 'required', 1);

with exactly the same result, but much less readability. Observe that in addition to the fat comma, the recommended Moose syntax also takes advantage here of two other Perl features, namely:

1. the fact that a subroutine can be treated like a list operator², without parenthesis around the arguments: so the call has 'x' => ... is technically equivalent to has('x' => ...).
2. the fact that a list within another list is flattened, so the parenthesis in 'x' => (isa => 'Int', ...) are technically not necessary; they are present just for stylistic preference.

You may have noticed that the single quotes around the attribute name are technically unnecessary: the x attribute name could go unquoted in

  has x => (isa => 'Int', is => 'rw', required => 1);

Here again it's a matter of stylistic preference; in this context I suppose that the Moose authors wanted to emphasize the difference between the subroutine name has and the string x passed as first argument.

Subtype declarations

Another domain-specific language in Moose is for declaring types. The cookbook has this example:

use Moose::Util::TypeConstraints;
use Locale::US;

my $STATES = Locale::US->new;

subtype 'USState'
    => as Str
    => where {
           (    exists $STATES->{code2state}{ uc($_) }
             || exists $STATES->{state2code}{ uc($_) } );
       };

Here again, fat commas and subroutine calls expressed as list operators were cleverly combined to form an expressive DSL for declaring Moose types.

Mojo

Mojolicious is one of the major Web frameworks for Perl. It uses a domain-specific language for declaring the routes supported by the Web application; here are some excerpts from the documentation:

my $route = $r->get('/:foo');
my $route = $r->get('/:foo' => sub ($c) {...});
my $route = $r->get('/:foo' => sub ($c) {...} => 'name');
my $route = $r->get('/:foo' => {foo => 'bar'} => sub ($c) {...});
my $route = $r->get('/:foo' => [foo => qr/\w+/] => sub ($c) {...});
my $route = $r->get('/:foo' => (agent => qr/Firefox/) => sub ($c) {...});
...
my $route = $r->any(['GET', 'POST'] => '/:foo' => sub ($c) {...});

Through these many variants we see a flexible language for declaring routes, where fat commas are used to visually convey some idea of structure within the lists of arguments. Observe that lines 3 and following are not pairs, but triplets, and that the last line has an arrayref (not a string!) to the left of the fat comma.

A word of caution about the quoting mechanism

Let's repeat the syntactic rule: if the left-hand side of the fat comma is a string that begins with a letter or underscore and is composed only of letters, digits and underscores, then that string doesn't need to be enclosed in quotes. We have seen numerous examples above that relied on this rule for more elegance and readability. One has to be careful, however, that builtin functions or user-defined subroutines could inadvertently be interpreted as strings instead of the intended subroutine calls. For example consider this snippet:

use constant foo => "tac";

sub build_hash {
 return {shift => 123, foo => 456, toe => 789};
}

my $h = build_hash('tic');

One could easily expect that the value of $h is {tic => 123, tac => 456, toe => 789} ... but actually the result is {foo => 456, shift => 123, toe => 789}, because both shift and foo were interpreted here as mere strings instead of subroutine calls. The ambiguity can be resolved easily, either by putting an empty argument list after the subroutine calls, or by enclosing them in parenthesis:

sub build_hash {
 return {shift() => 123, foo() => 456, toe => 789};
 # or: return {(shift) => 123, (foo) => 456, toe => 789};
}

Some people would perhaps argue that the Perl interpreter should automatically detect that shift or foo are subroutine names ... but that would introduce too much fragility. The interpreter would then be dependent on the list of builtin Perl functions, and also be dependent on the list of symbols declared at that point in the code; future evolutions on either side could easily break the behaviour. So Perl's design, that blindly applies the syntactic rule formulated above, is much wiser.

Similar constructs in other languages

To my knowledge, no other programming language has a general-purpose comma operator comparable to Perl's fat comma. What is quite common, however, is to have specific syntax for hashes (or "objects" or "dictionaries" or "records", as they are called in other languages), and sometimes specific syntax for named parameters in subroutine calls or method calls. This chapter explores some aspects on these directions.

JavaScript

JavaScript Objects

The equivalent of a Perl hash is called "object" in JavaScript; it is initialized as follows (example copied from the MDN documentation):

const obj = {
  property1:    value1, // property name may be an identifier
  2:            value2, // or a number
  "property n": value3, // or a string
};

Here the syntax is : instead of =>³. Like in Perl, any quoted string can be used as a property name, or a number, or an unquoted string if that string can be parsed as an identifier. What is not allowed, however, is to use an expression on the left-hand side: {(2+2): value} or {compute_name(): value} are syntax errors. The workaround for using expressions as property names is to first create the object, and then assign properties to it:

const obj           = {};
obj[2+2]            = value1;
obj[compute_name()] = value2;

Named parameters

JavaScript has no direct support for passing named parameters to subroutines; however there is of course an indirect way, which is to pass an object to the function:

function show_user(u) {
  return `${u.firstname} ${u.lastname} has id ${u.id}`;
}
console.log(show_user({id: 123, firstname:"John", lastname:"Doe"})); 

Recent versions of JavaScript have a more sophistictated way of exploiting the object received as parameter: rather than grabbing successive properties into the object, the receiving function could instead use object destructuring to extract the values into local lexical variables:

function show_user_v2({firstname, lastname, id}) {
  return `${firstname} ${lastname} has id ${id}`;
}
console.log(show_user_v2({id: 123, firstname:"John", lastname:"Doe"})); 

This technique can go even further by supplying default values to the lexical variables - an advanced technique described in the MDN documentation.

Python

Dictionaries

In Python the closest equivalent of a Perl hash is called a "dictionary". Like in JavaScript, dictionaries are initialized with list of keys and values separated by :, enclosed in curly braces :

point = {'x': 34, 'y': -1}

But unlike in JavaScript or Perl, keys on the left of the : separator are not quoted automatically: they are just ordinary expressions. This requires more typing from the programmer, but makes it possible to use operators or function calls, like in this example:

def double (x):
    return x * 2

obj = {
    'hello' + 'world': 11,
    234:               'foobar',
    double(3):         'doubled',
    }

print(obj) # prints : {'helloworld': 11, 234: 'foobar', 6: 'doubled'}

Keyword arguments

In Python, named parameters are called keyword arguments. The syntax is different from dictionary initializers: the symbol = is used to connect keywords to their values:

draw_line(x1=12, y1=-3, x2=55, y2=66)

Here the left-hand side does not need to be quoted; but it must obey the syntax rules for identifiers, which means for example that strings containing spaces are not eligible.

The construct of functions with keyword arguments is clearly different from the construct of dictionaries. They can be combined, however: a dictionary can be unpacked as a list of key-value pairs to be passed as arguments to a function.

points = {'x1':1, 'y1':2, 'x2':3, 'y2':4}
draw_line(**points)

but unlike in Perl or JavaScript, if the dictionary contains other keys than those expected by the function, an exception is raised ("got an unexpected keyword argument"). This is beneficial for defensive programming, where the interpreter exerts more control, but at the detriment of flexibility, because a dictionary received from an external source (for example a config file or an HTTP request) must be filtered before it can be flattened and passed to the called function.

PHP

PHP uses the => notation for key-value pairs in associative arrays, like in Perl, but without the automatic quoting feature. Therefore keys must be enclosed in double quotes or single quotes, like in Python.

In addition, PHP also uses the same notation => for anonymous functions, like in JavaScript, except that the fn keyword must also be present.

Here is an example where the two features are combined:

$array1 = ["foo" => "bar", 
           "fun" => fn($x) => fn($y) => $x+$y,
          ];

This is an associative array (like a Perl hash) where the key foo is associated to value "bar", and the key fun is associated with a function that returns another function. So beware when visually parsing a => in a PHP program!

Wrapping up

The Perl construct of fat commas is very simple, with coherent syntax and semantics, and applicable in a wide range of situations. It helps to write readable code by allowing the programmer to structure lists and emphasize some relations between values in the list. This capability is often used to design domain-specific sublanguages within Perl. A beautiful construct indeed!

About the cover picture

The picture shows the coupling mechanism on an old pipe organ. The french word for this is "accouplement", which in other contexts also means "mating"!

When the mechanism is activated, notes played on the lower keyword also trigger the notes on the upper keyboard ... which bears some resemblance to the bindings in programming that were discussed in this article.

1. since v5.38 some object-oriented features are also implemented in Perl core; but CPAN object-oriented frameworks like Moose are still heavily used. ↩

2. See perlsyn: "Declaring a subroutine allows a subroutine name to be used as if it were a list operator from that point forward in the program". ↩

3. the notation => is also present in JavaScript, but with a meaning totally different from Perl: it is used for arrow function expressions, a compact alternative to traditional function expression. ↩

Originally published at Perl Weekly 762

Hi there,

If there's one thing that keeps impressing me in our community, it's the dedication of people like Olaf Alders. Week after week, Olaf keeps refining MetaCPAN, polishing small details and improving the user experience. It's not always flashy work, but when you use MetaCPAN, you can feel it - everything feels smoother, faster, and more reliable. That kind of steady, thoughtful dedication really inspires me.

Speaking of inspiration, Dave Cross recently shared a neat little trick that I think many of us can use. He showed how your README file can be turned into a static website - yes, the README you already have for your module! The article on Dev.to is called "Your README is already a website" and it's a fun, practical reminder that sometimes the tools we already have, can do more than we think. I love seeing simple ideas like that applied in clever ways.

On my side of things, I've been quietly wrestling with some longstanding issues in DBIx::Class. Not only that, but DBIx::Class::Async shares the same quirks, so it's been double the fun. I managed to fix a few problems already, but some issues are tied to PostgreSQL-specific behavior. That turned out to be tricky because most of the existing tests run on SQLite - easy to spin up, but not the same as PostgreSQL. I stumbled upon Test::PostgreSQL, which looked perfect, and then found Test::DBIx::Class, which integrates smoothly with it. I thought, "Great! Just write a use case and done." Ha! Not quite. My Ubuntu 24.04 setup didn't want to play nicely with Test::PostgreSQL - some socket permission issues blocked me entirely. I decided to tinker and ended up creating Test::PostgreSQL::v2, which worked like a charm. Then came integrating it with Test::DBIx::Class, which needed a trait for my new module. After a little more work, I added Test::DBIx::Class::SchemaManager::Trait::Testpostgresqlv2, and voila - now anyone using Test::DBIx::Class with PostgreSQL can benefit. For me, that meant I finally had a reliable way to reproduce the issue and verify the fix, like in this unit test for DBIx::Class::Async v0.64: t/156-resultset-inflate-datetime.t. Feels good to see it all working.

While I was in tinkering mode, I also revisited Test::Spelling. I always get tripped up on British vs. American English in POD, and I wanted a unit test that could work across all my modules. Initially, I had to manually add stopwords per module - tedious! So I upgraded Test::Spelling and created Test::Spelling::Stopwords. Now I can generate stopwords automatically, and the same script works for every module. It's been a real time-saver, and I'm even using it in DBIx::Class::Async here: t/spell-pod.t

It's funny how small tools and little tweaks can make such a difference. Between Olaf's continuous improvements, Dave's clever README trick, and the testing adventures I've had, I feel reminded of what makes our Perl community special - curiosity, persistence, and a little bit of playful tinkering.

Enjoy rest of the newsletter and stay safe & healthy.

--
Your editor: Mohammad Sajid Anwar.

Announcements

TPRC call for presentations is open!

The Perl & Raku Foundation has opened its call for presentations for TPRC 2026, inviting submissions of 20 or 50 minute talks on topics of interest to the Perl and Raku communities. Accepted speakers will receive complimentary conference tickets, with sessions scheduled for June 26–28 in Greenville, SC—an excellent opportunity to share insights and help shape this year's technical programme.

Board Proposes Chris Prather (perigrin) for Membership

The Perl Foundation's board has put forward Chris Prather (perigrin) as a candidate for board membership, highlighting his decades of professional Perl experience and long‑standing community contributions. His vision emphasises strengthening the Foundation's role in uniting Perl and Raku projects, supporting maintainers, and fostering sustainable ecosystem growth.

Articles

Cloud VM Performance / Price comparison 2026

This post offers a timely, data‑driven benchmark of CPU performance versus cost across 7 major cloud providers and 44 VM families, using Perl‑based tooling for reproducible results. The concise summary and practical Docker‑ready benchmark suite make it a valuable reference for developers and architects seeking real‑world insights into cloud compute value.

Automatic cross-platform testing: part 7: 32 bit, again

David Cantrell's latest on automatic cross‑platform testing tackles the perennial challenge of running CI on 32‑bit environments using modern GitHub Actions, showing how to assemble a unified workflow across Unix‑like systems while handling 32‑bit builds. He walks through clever tricks for downloading artifacts and even building a 32‑bit Perl with 32‑bit integers for more thorough testing. It’s a practical, hands‑on guide for anyone keen to broaden test coverage beyond the usual 64‑bit platforms.

Podcast

The Underbar, episode 9: Olaf Kolkman (part 1)

Olaf Kolkman has had a long career in networking and Open Source that led him to be working on Internet Technology, Policy and Advocacy at the Internet Society. In September 2025, we had a long conversation with him. In this first part, we discussed his involvement with Perl, DNSSEC and NLnet Labs.

CPAN

DBD::Mock::Session::GenerateFixtures v1.03

The latest release includes automatic mock data generation for transactional database interactions. That means it's much easier to capture and replay sequences that involve BEGIN WORK, COMMIT, ROLLBACK, and even nested try/catch logic.

App::Test::Generator v0.29

The latest release introduces mutation testing alongside a sleek HTML mutation dashboard, making it easier to see which lines of code survived mutations and where your tests could miss mistakes. Instead of just coverage numbers, you can now ask, "Would a mistake here be caught?" The dashboard highlights affected lines, provides helpful tooltips, and allows detailed per-line inspection.

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 - 363

Welcome to a new week with a couple of fun tasks "String Lie Detector" and "Subnet Sheriff". 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 - 362

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

TWC362

This blog post delivers clean, idiomatic Perl solutions to both parts of TWC 362, with clear logic in the echo_chamber looping and a well-structured number-to-words sorting implementation. The use of Perl's core functions keeps the code readable and efficient, making it a helpful reference for Perl Weekly Challenge enthusiasts.

Spellbound Echo

This post offers a clear and idiomatic Raku solution to the 'Echo Chamber' challenge, showcasing concise use of core language features like map, substr, and the repetition operator. The explanation is practical and easy to follow, making it a great example of writing expressive, efficient Raku code.

Echo Chamber

This write-up for PWC 362 gives a thoughtful and practical exploration of multiple Perl approaches to the 'Echo Chamber' string transformation problem. Bob clearly explains regex, list-mapping, and string-building techniques, offering insights into Perl's expressive power and performance trade-offs. It's a solid, engaging read with useful benchmarks for comparison.

Perl Weekly Challenge: Week 362

This Week 362 post on Braincells.com presents clear, idiomatic Perl solutions to the 'Echo Chamber' and spell-sorting tasks, with concise logic leveraging Perl's core functions for string repetition and custom sorting. The explanations walk through the problem and implementation cleanly, making it accessible even for those new to the weekly challenges. It's a solid technical write-up that showcases effective Perl problem-solving.

Lingua to the rescue!

This write-up on Perl Weekly Challenge 362: Lingua to the rescue! gives a clear and practical set of Perl and Raku solutions, especially for the 'Echo Chamber' string task using Raku's expressive constructs and Perl's repetition operator. The post balances readability with technical depth, making it engaging and informative for developers exploring language features.

Perl Weekly Challenge 362

This post delivers clear, idiomatic Perl solutions to both tasks of Perl Weekly Challenge 362, using expressive constructs like map‑based repetition for Echo Chamber and a well‑structured Schwartzian sort with language‑specific converters for Spellbound Sorting. The explanations make the logic easy to follow and showcase Perl's strengths in string and list processing.

What Sort of Echo?

This post gives a straightforward and well-structured Perl implementation for both parts of Perl Weekly Challenge 362, cleanly illustrating string expansion and English-word sorting logic. The code leverages familiar Perl idioms like map and split for clarity and effectiveness, making it easy to follow for readers interested in Perl string and list processing.

You Have No Choice

This write-up offers clear, practical multi-language solutions to the Perl Weekly Challenge 362 tasks, with nicely explained approaches in Raku, Perl, Python, and Elixir that make the logic easy to follow. Packy balances straightforward implementations with thoughtful commentary, making it a technically solid and engaging post for challenge enthusiasts.

Echo and wordy numbers

This challenge page from Peter presents the Perl Weekly Challenge 362 tasks with clear problem statements for both 'Echo Chamber' and 'Spellbound Sorting'. It provides a solid foundation for exploring string manipulation and sorting by word form, making it a useful resource for practicing concise algorithm design in Perl.

Echo Chamber

This Weekly Challenge 362 post offers a clean, beginner-friendly Perl implementation of the 'Echo Chamber' task, contrasting a straightforward loop approach with a more declarative map-and-join variant. The explanations highlight readable coding practices and clarify the benefits of each style, making it both instructive and approachable for Perl programmers.

Spellbound Sorting

This PWC 362 Part 2 post presents a clear and efficient Perl solution for sorting numbers by their spelled-out word forms using a classic Schwartzian Transform. The explanation shows thoughtful use of Lingua::Any::Numbers for multilingual support and highlights how to avoid repeated conversions for better performance. It's a technically solid and instructive example of Perl's data-processing strengths.

The Weekly Challenge #362

This post presents well‑thought‑out Perl solutions to the Perl Weekly Challenge 362 problems with clear logic and use of idiomatic Perl constructs. The code is structured for readability and correctness, making it a valuable example for anyone exploring challenge‑style problem solving in Perl.

Spellbound Echo

This post delivers a clear and well‑explained exploration of The Weekly Challenge 362 tasks, walking through character‑duplication and spelled‑number sorting logic with readable examples. The author balances practical code with thoughtful commentary, offering valuable insights into expressive string and list manipulation techniques.

The one liners

This post delivers clean, one‑liner solutions in both Python and Perl for the Weekly Challenge 362 tasks, showing concise use of enumeration and string repetition for Echo Chamber and leveraging language‑specific libraries for Spellbound Sorting. Simon's examples and side‑by‑side language comparison make the logic easy to grasp and technically satisfying.

Rakudo

2026.08 Positional Adverbs

Weekly collections

NICEPERL's lists

Great CPAN modules released last week.

Events

Perl Maven online: Code-reading and Open Source contribution

March 10, 2026

Paris.pm monthly meeting

March 11, 2026

German Perl/Raku Workshop 2026 in Berlin

March 16-18, 2026

Perl Toolchain Summit 2026

April 23-26, 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.

Weekly Challenge 362

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: Echo Chamber

Task

You are given a string containing lowercase letters.

Write a script to transform the string based on the index position of each character (starting from 0). For each character at position i, repeat it i + 1 times.

My solution

Both of this weeks solutions are a one-liner in Python. For this task, the function is

def echo_chamber(input_string: str) -> str:
    return ''.join(
        letter * pos
        for pos, letter in enumerate(input_string, start=1)
    )

Multiplying a string (letter) by an integer (pos) will repeat the string the specified number of times.

The enumerate function in Python returns the index and the value from a iterator (in this case characters in a string). A little-used feature of this function is the start parameter which will start counting at a value other than the default of zero.

The Perl solution is a little more verbose, as I build the string a letter at a time. By using ++$cnt, the value is incremented before it is evaluated (as opposed to $cnt++). The x operator will repeat the string the required number of times.

sub main ($input_string) {
    my $output_string = '';

    my $cnt = 0;
    foreach my $letter ( split //, $input_string ) {
        $output_string .= $letter x ++$cnt;
    }

    say $output_string;
}

Examples

$ ./ch-1.py abca
abbcccaaaa

$ ./ch-1.py xyz
xyyzzz

$ ./ch-1.py code
coodddeeee

$ ./ch-1.py hello
heelllllllooooo

$ ./ch-1.py a
a

Task 2: Spellbound Sorting

Task

You are given an array of integers.

Write a script to return them in alphabetical order, in any language of your choosing. Default language is English.

My solution

Thankfully the perfectly round wheels have already been invented for converting integers into strings. To make this task a little easier on myself, I'm only using English.

Python has the num2words module. The sorted function has the key parameter to determine how the integers should be sorted.

from num2words import num2words

def spellbound_sorting(ints: list[int]) -> list[int]:
    return sorted(ints, key=num2words)

Perl has the Lingua::EN::Numbers module. The sort function in Perl also has built in features to determine the sort order.

use Lingua::EN::Numbers 'num2en';

sub main (@ints) {
    my @sorted_ints = sort { num2en($a) cmp num2en($b) } @ints;
    say join( ", ", @sorted_ints );
}

Examples

$ ./ch-2.py 6 7 8 9 10
[8, 9, 7, 6, 10]

$ ./ch-2.py -3 0 1000 99
[-3, 99, 1000, 0]

$ ./ch-2.py 1 2 3 4 5
[5, 4, 1, 3, 2]

$ ./ch-2.py 0 -1 -2 -3 -4
[-4, -1, -3, -2, 0]

$ ./ch-2.py 100 101 102
[100, 101, 102]