Originally published at Perl Weekly 750

Hi there,

One of the most enjoyable yearly customs in the community, the Perl Advent Calendar 2025, is being introduced this week. A new article, tutorial, or in-depth analysis demonstrating the ingenuity and skill that continue to propel Perl forward is released every day.

The calendar has something for every skill level, whether you're interested in cutting-edge Perl techniques, witty one-liners, CPAN gems, or true engineering tales. It serves as a reminder that Perl's ecosystem is still active, creative, and developing-driven by a fervent community that enjoys exchanging knowledge.

If you still want more, be sure to check out, The Weekly Challenge Advent Calendar 2025. There you'll find not just Perl, but Raku as well.

Last but not least, I'd like to extend my heartfelt thanks to Gabor Szabo for kindly promoting my book: Design Patterns in Modern Perl - your support means a great deal. And to the Perl community: thank you for embracing my first book with such warmth and encouragement. Your enthusiasm continues to inspire me.

Enjoy rest of the newsletter, stay safe and healthy.

--
Your editor: Mohammad Sajid Anwar.

Articles

PAGI: ASGI For Perl, or the Spiritual Successor to Plack

PAGI (Perl Asynchronous Gateway Interface) is a new specification for async Perl web applications, inspired by Python's ASGI. It supports HTTP, WebSockets, and Server-Sent Events natively, and can wrap existing PSGI applications for backward compatibility.

plenv-where

A plenv plugin to show which Perl versions have a particular module.

LPW 2025 - Event Report

Here is my detailed report of LPW 2025 that includes the slides of my presentation.

Living Perl: Building a CNN Image Classifier with AI::MXNet

This article demonstrates Perl's continued relevance in cutting-edge fields by showcasing integration with MXNet, a major deep learning framework. The ability to build convolutional neural networks (CNNs) in Perl for image classification represents significant technical sophistication.

Perl Advent Calendar

The Ghost of Perl Developer Surveys Past, Present, and Future

The article demonstrates sophisticated understanding of developer tooling ecosystems and community trends. The comparison between 2009-2010 surveys and the 2025 results shows deep insight into how Perl development practices have evolved while maintaining continuity.

All I Want for Christmas Is the Right Aspect Ratio

The step-by-step progression from simple Perl script to full Docker deployment serves as an excellent tutorial on modern Perl module distribution. It shows how a well-designed module can serve diverse audiences from command-line power users to web developers to DevOps teams.

Santa's Secret Music Studio

The step-by-step approach from "need to identify devices" to "controlling a synth" serves as an excellent mini-tutorial. The mention of related modules (MIDI::RtController, MIDI::RtController::Filter::Tonal) provides helpful pointers for readers wanting to explore further.

Stopping the Evil Grinch: A Holiday Defense Guide

This article demonstrates enterprise-grade security automation using Perl as a robust orchestration layer. The solution elegantly combines multiple security tools (Lynis for auditing, ClamAV for malware scanning) with professional email reporting.

Santa needs to know about new toys...

This article successfully teaches professional API integration through storytelling, making technical concepts accessible while demonstrating production-ready Perl code patterns. The holiday theme enhances rather than distracts from the educational content.

ToyCo want to push new toy updates

This article beautifully demonstrates transitioning from a polling-based API client to a webhook-based service - a common and important architectural pattern in modern web development. The scenario of "crippling ToyCo's servers" with excessive polling is both realistic and educational.

Abstract storage of Christmas letters

This solution demonstrates sophisticated software design with the strategic use of Storage::Abstract to create a clean abstraction layer between business logic and data storage. The anticipation of changing storage requirements and preemptive abstraction is professional forward-thinking.

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

Welcome to a new week with a couple of fun tasks "Special Average" and "Arithmetic Progression". 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 - 350

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

TWC350

This implementation demonstrates elegant Perl craftsmanship. The good substrings solution is particularly clever, using a regex lookahead to capture all overlapping 3-character substrings in one pass, then filtering to ensure no repeated characters - a beautifully concise one-liner.

The Good Shuffle

The solutions demonstrate strong understanding of both algorithmic thinking and Raku language features. The shuffle pairs solution is particularly clever in its use of canonical forms and early termination conditions.

Good Substring / Shuffle Pairs

The Perl implementation demonstrates clean, readable code with thoughtful organization. The good substrings solution uses efficient array slicing and clear manual comparison logic that's easily understandable.

Shuffled Strings

This is an exceptionally elegant Perl implementation showcasing expert-level Perl idioms. Both solutions exemplify Perl's philosophy of "making easy things easy and hard things possible" with concise, expressive code that solves the problems elegantly without unnecessary complexity.

only Perl!

This is a comprehensive and impressively diverse implementation across multiple languages and environments. The Raku solutions showcase excellent use of the language's functional features. The PL/Perl implementations are particularly noteworthy for their adaptability to database environments.

Perl Weekly Challenge 350

This solution stands out for its deep mathematical analysis and optimization. The Task 2 solution demonstrates remarkable theoretical insight by using modular arithmetic with modulo 9 to significantly reduce the search space - achieving a 5.2x speedup is an impressive feat of algorithmic optimization.

Shuffling the Good

This solution demonstrates exceptional cross-language programming skills with clean, idiomatic implementations across four different languages (Raku, Perl, Python, Elixir). The consistent algorithmic approach while respecting each language's unique idioms shows deep understanding of multiple programming paradigms.

Good pairs

Both solutions showcase excellent Perl craftsmanship with thoughtful comments, clear variable naming, and robust handling of edge cases. Peter demonstrates both theoretical understanding (mathematical bounds, algorithmic complexity) and practical implementation skills.

The Weekly Challenge #350

This is a masterclass in professional Perl documentation and code structure. The solutions feature comprehensive POD documentation with clear attribution, problem descriptions, notes, and IO specifications - demonstrating exceptional software engineering practices.

A Good Shuffle

This solution demonstrates elegant Perl craftsmanship with a particularly clever approach. Using a regex with a lookahead assertion /(?=(...))/g to capture overlapping substrings is an expert-level Perl idiom that showcases deep understanding of the language's regex capabilities.

Good shuffling

This solution demonstrates excellent cross-language programming skills with clear parallel implementations in both Python and Perl. The Task 1 solution is elegantly simple - the Python version using set(substr) for uniqueness checking and the Perl version using a hash with early returns showcase appropriate idioms for each language while maintaining the same algorithmic approach.

Rakudo

2025.48 Advent is Here

Weekly collections

NICEPERL's lists

Great CPAN modules released last week;
MetaCPAN weekly report.

Events

Paris.pm monthly meeting

December 10, 2025

German Perl/Raku Workshop 2026 in Berlin

March 16-18, 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.

Weekly Challenge 350

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. It's a great way for us all to practice some coding.

Challenge, My solutions

Task 1: Good Substrings

Task

You are given a string.

Write a script to return the number of good substrings of length three in the given string. A string is good if there are no repeated characters.

My solution

This is relatively straight forward, so doesn't require much explanation. I have a variable called i that starts at zero and ends with three less than the length of the string. For each iteration, I extract the the three letters starting at the specified position. If the three letters are unique, I add one to the count variable.

def good_substr(input_string: str) -> int:
    count = 0

    for i in range(len(input_string) - 2):
        substr = input_string[i:i + 3]

        if len(set(substr)) == 3:
            count += 1

    return count

In Python, I convert the three characters to a set. If the length of the set is 3, I know all characters are unique (sets can only store unique values). In Perl, I use a %chars hash. If a letter is already seen, it will return 0.

sub is_unique ($substr) {
    my %chars;
    foreach my $char (split //, $substr) {
        return 0 if exists $chars{$char};
        $chars{$char} = 1;
    }
    return 1;
}

Examples

$ ./ch-1.py abcaefg
5

$ ./ch-1.py xyzzabc
3

$ ./ch-1.py aababc
1

$ ./ch-1.py qwerty
4

$ ./ch-1.py zzzaaa
0

Task 2: Shuffle Pairs

Task

If two integers A <= B have the same digits but in different orders, we say that they belong to the same shuffle pair if and only if there is an integer k such that B = A × k where k is called the witness of the pair.

For example, 1359 and 9513 belong to the same shuffle pair, because 1359 * 7 = 9513.

Interestingly, some integers belong to several different shuffle pairs. For example, 123876 forms one shuffle pair with 371628, and another with 867132, as 123876 × 3 = 371628, and 123876 × 7 = 867132.

Write a function that for a given $from, $to, and $count returns the number of integers $i in the range $from <= $i <= $to that belong to at least $count different shuffle pairs.

My solution

This is an interesting challenge as the solution requires some thinking. Additionally there was an error with the original page, so I raised a pull request to fix it.

I start by setting the shuffle_pairs variable to zero. I have a loop with the variable value that starts at from and ends with to (inclusive). As from is a reserved word in Python, I use the variables start and end.

For each iteration of value, I do the following.

1. Set the variable this_count to zero. This will store the number of shuffle pairs for this value.
2. Set the variable multiplier to 2.
3. Set a variable called candidate to the product of value and multiplier.
4. If this is a shuffle_pair, increment the this_count value.
5. If the candidate is equal to or greater then 10^{length of value}, end the loop. As this number has more digits than the original, no shuffle pair can be found for this candidate.
6. Once the previous step is reached, increment the shuffle_pair value if this_count >= count.

def shuffle_pairs(start: int, stop: int, count: int) -> int:
    shuffle_pairs = 0

    for value in range(start, stop + 1):
        this_count = 0

        multiplier = 2
        while True:
            candidate = value * multiplier
            if candidate >= 10 ** len(str(value)):
                break
            if is_shuffle_pair(value, candidate):
                this_count += 1

            multiplier += 1

        if this_count >= count:
            shuffle_pairs += 1

    return shuffle_pairs

The Perl solution follows the same logic.

Examples

$ ./ch-2.py 1 1000 1
0

$ ./ch-2.py 1500 2500 1
3

$ ./ch-2.py 1000000 1500000 5
2

$ ./ch-2.py 13427000 14100000 2
11

$ ./ch-2.py 1030 1130 1
2

Musical Interlude

The movie version of Wicked is in theaters right now, so I am reminded of the song For Good -- but I'm gonna link to the Broadway version, because I'm classy like that. It's relevant to programming in Perl because "I don't know if I've been changed for the better, but I have been changed for good." For part two, Lido Shuffle by Boz Scaggs.

Task 1: Good Substrings

The Task

You are given a string. Write a script to return the number of good substrings of length three in the given string. A string is good if there are no repeated characters.

• Example 1: Input $str = "abcaefg", Output: 5
  • Good substrings of length 3: abc, bca, cae, aef and efg
• Example 2: Input: $str = "xyzzabc", Output: 3
• Example 3: Input: $str = "aababc", Output: 1
• Example 4: Input: $str = "qwerty", Output: 4
• Example 5: Input: $str = "zzzaaa", Output: 0

The Think-y Part

There's probably a regular expression for this, but I'm not going to find it. Do the simplest thing that works: take three characters at a time and see if they're different.

The Code-y Part

sub goodSubstring($str)
{
    my $good = 0;
    my @s = split(//, $str);
    for ( 0 .. $#s - 2 )
    {
        my ($first, $second, $third) = @s[$_, $_+1, $_+2];
        $good++ if ( $first ne $second && $first ne $third && $second ne $third );
    }
    return $good;
}

Notes:

• Start by turning the string into a list of characters. It could be done with substr, but that would be untidy.
• @s[$_, $_+1, $_+2] -- With a nod to readability, I'll extract three consecutive characters with an array slice. It occurs to me that I'll always have two of the next three characters in hand at the bottom of the loop, so doing a complete splice every time could probably be optimized, but I declare it "good" enough.
• Since there's exactly three characters in play, check for uniqueness in the most obvious way.

Task 2:Shuffle Pairs

The Task

If two integers A <= B have the same digits but in different orders, we say that they belong to the same shuffle pair if and only if there is an integer k such that A = B * k. k is called the witness of the pair. For example, 1359 and 9513 belong to the same shuffle pair, because 1359 * 7 = 9513.

Interestingly, some integers belong to several different shuffle pairs. For example, 123876 forms one shuffle pair with 371628, and another with 867132, as 123876 * 3 = 371628, and 123876 * 7 = 867132.

Write a function that for a given $from, $to, and $count returns the number of integers $i in the range $from <= $i <= $to that belong to at least $count different shuffle pairs.

• Example 1:
  • Input: $from = 1, $to = 1000, $count = 1
  • Output: 0
  • There are no shuffle pairs with elements less than 1000.

• Example 2:

  • Input: $from = 1500, $to = 2500, $count = 1
  • Output: 3
  • There are 3 integers between 1500 and 2500 that belong to shuffle pairs.
    • 1782, the other element is 7128 (witness 4)
    • 2178, the other element is 8712 (witness 4)
    • 2475, the other element is 7425 (witness 3)

• Example 3:

  • Input: $from = 1_000_000, $to = 1_500_000, $count = 5
  • Output: 2
  • There are 2 integers in the given range that belong to 5 different shuffle pairs.
    • 1428570 pairs with 2857140, 4285710, 5714280, 7142850, and 8571420
    • 1429857 pairs with 2859714, 4289571, 5719428, 7149285, and 8579142

• Example 4:

  • Input: $from = 13_427_000, $to = 14_100_000, $count = 2
  • Output: 11
  • 6 integers in the given range belong to 3 different shuffle pairs,
  • 5 integers belong to 2 different ones.

• Example 5:

  • Input: $from = 1030, $to = 1130, $count = 1
  • Output: 2
  • There are 2 integers between 1020 and 1120 that belong to at least one shuffle pair:
    • 1035, the other element is 3105 (witness k = 3)
    • 1089, the other element is 9801 (witness k = 9)

Deliberations

It takes a minute to digest this one.

I first wondered if there's some algebraic number theory trick that would cut the search space way down, but that made my head hurt, so I moved to doing what computers do best: grinding through a lot of possibilities.

A bad first thought was to try all combinations of the digits, but that's going to die an excruciating slow death on the crucifix of combinatorics, not to mention that we'd be completely wasting our time on all but a few combinations.

A better thought is to look only at the multiples of a given number. There are at most 8 multiples of a number in play: the 10th would add a digit, and therefore can't possibly be a reordering. Examples 3 and 4 have a lot of numbers to grind through, but how long can it take, really? It's one banana, Michael; how much could it cost, ten dollars?

How will I decide that a number is a re-ordering? I think I'll reduce each number to a canonical form where the digits are sorted, then use string compare to see if a multiple has the same canonical form.

To the bat-editor, Robin!

First, a little function to turn a number into a canonical form with its digits in sorted order. Turn the number into a list of digits, sort, and then join the digits back into a string.

sub canonical($n)
{
    join("", sort split(//, $n));
}

Now the main course. I'll want to examine every number in the range $from to $to, inclusive. For each number, I'll want to examine its multiples to see if they have the same digits. I need to count the ones that work so that I can check that there are at least $count of them.

sub shufflePair($from, $to, $count)
{
    my $answer = 0;

    for my $n ( $from .. $to )
    {
        my $base = canonical($n);
        my $max = (9 x length($n))+0;
        my $pair = 0;
        for ( 2 .. 9 )
        {
            my $multiple = $n * $_;

            next if $multiple > $max
                 || index($base, substr($multiple,  0, 1)) < 0
                 || index($base, substr($multiple, -1, 1)) < 0;

            if ( canonical($multiple) eq $base )
            {
                $pair++;
            }
        }
        $answer++ if $pair >= $count;
    }
    return $answer;
}

Notes:

• my $base = canonical($n) -- hang on to this for comparison.
• my $max = (9 x length($n))+0; -- An optimization. The maximum number we need to be concerned with is one that has the same number of digits, but is all 9s. For example, if $n is 480, then we are dealing with 3-digit numbers, so the largest possible is 999. That's less than 480*3=1440, so we don't have to examine any of the multiples beyond 480*2.
• for ( 2..9 ) -- These are the only multiples of $n that could possibly have the same number of digits.
• next if ... -- Besides the check on $max, we can make cheap checks on a single digit. If the first or last digit isn't one of the possible digits, we can avoid the overhead of canonical(), which isn't horrendous, but it does involve allocating lists and a sort.
• canonical($multiple) eq $base -- This string compare is where we decide if we have a shuffle pair.
• $answer++ if $pair >= $count -- We increment the answer if this number has at least $count shuffle pairs.

This solution takes a few seconds to run the examples. My optimizations to bail early in many cases cut the run time approximately in half (from about 8 seconds to about 4.5).

Introducing PAGI: Async Web Development for Perl

TL;DR: PAGI (Perl Asynchronous Gateway Interface) is a new specification for async Perl web applications, inspired by Python's ASGI. It supports HTTP, WebSockets, and Server-Sent Events natively, and can wrap existing PSGI applications for backward compatibility.

The Problem

Modern web applications need more than traditional request-response cycles. Real-time features like live notifications, collaborative editing, and streaming data require persistent connections. This means:

• WebSockets for bidirectional communication
• Server-Sent Events for efficient server push
• Streaming responses for large payloads
• Connection lifecycle management for resource pooling

PSGI, Perl's venerable web server interface, assumes a synchronous world. While frameworks like Mojolicious have built async capabilities on top, there's no shared standard that allows different async frameworks and servers to interoperate.

PAGI aims to fill that gap.

What is PAGI?

PAGI defines a standard interface between async-capable Perl web servers and applications. If you're familiar with Python's ecosystem, think of it as Perl's answer to ASGI.

A PAGI application is an async coderef with three parameters:

use Future::AsyncAwait;
use experimental 'signatures';

async sub app ($scope, $receive, $send) {
    # $scope   - connection metadata (type, headers, path, etc.)
    # $receive - async coderef to get events from the client
    # $send    - async coderef to send events to the client
}

The $scope->{type} tells you what kind of connection you're handling:

A Simple HTTP Example

Here's "Hello World" in raw PAGI:

use Future::AsyncAwait;

async sub app ($scope, $receive, $send) {
    die "Unsupported: $scope->{type}" if $scope->{type} ne 'http';

    await $send->({
        type    => 'http.response.start',
        status  => 200,
        headers => [['content-type', 'text/plain']],
    });

    await $send->({
        type => 'http.response.body',
        body => 'Hello from PAGI!',
        more => 0,
    });
}

Run it:

pagi-server --app app.pl --port 5000
curl http://localhost:5000/
# => Hello from PAGI!

The response is split into http.response.start (headers) and http.response.body (content). This separation enables streaming—send multiple body chunks with more => 1 before the final more => 0.

WebSocket Support

WebSockets are first-class citizens in PAGI:

async sub app ($scope, $receive, $send) {
    if ($scope->{type} eq 'websocket') {
        await $send->({ type => 'websocket.accept' });

        while (1) {
            my $event = await $receive->();

            if ($event->{type} eq 'websocket.receive') {
                my $msg = $event->{text} // $event->{bytes};
                await $send->({
                    type => 'websocket.send',
                    text => "Echo: $msg",
                });
            }
            elsif ($event->{type} eq 'websocket.disconnect') {
                last;
            }
        }
    }
    else {
        die "Unsupported: $scope->{type}";
    }
}

The event loop pattern is consistent across all connection types: await events from $receive, send responses via $send.

PSGI Compatibility

One of PAGI's key features is backward compatibility with PSGI. The PAGI::App::WrapPSGI adapter lets you run existing PSGI applications on a PAGI server:

use PAGI::App::WrapPSGI;

# Your existing Catalyst/Dancer/Plack app
my $psgi_app = MyApp->psgi_app;

my $wrapper = PAGI::App::WrapPSGI->new(psgi_app => $psgi_app);
$wrapper->to_app;

The wrapper handles all the translation: building %env from PAGI scope, collecting request bodies, and converting responses back to PAGI events.

This means you can:

• Run legacy applications on a PAGI server
• Add WebSocket endpoints alongside existing routes
• Migrate incrementally from PSGI to PAGI
• Share connection pools between old and new code

PAGI::Simple Micro-Framework

For rapid development, PAGI ships with a micro-framework inspired by Express.js:

use PAGI::Simple;

my $app = PAGI::Simple->new(name => 'My API');

$app->get('/' => sub ($c) {
    $c->text('Hello, World!');
});

$app->get('/users/:id' => sub ($c) {
    my $id = $c->path_params->{id};
    $c->json({ user_id => $id });
});

$app->post('/api/data' => sub ($c) {
    my $data = $c->json_body;
    $c->json({ received => $data, status => 'ok' });
});

$app->to_app;

WebSockets are equally clean:

$app->websocket('/chat' => sub ($ws) {
    $ws->on(message => sub ($data) {
        $ws->broadcast("Someone said: $data");
    });
});

PAGI::Simple includes:

• Express-style routing with path parameters
• JSON request/response helpers
• Session management
• Middleware support (CORS, logging, rate limiting, etc.)
• Static file serving
• WebSocket rooms and broadcasting
• SSE channels with pub/sub

Current Status

PAGI is currently in early beta. The test suite passes, the examples work, but it hasn't been battle-tested in production.

What exists today:

• Complete PAGI specification
• Reference server implementation (PAGI::Server)
• PAGI::Simple micro-framework
• 13 example applications
• PSGI compatibility layer
• 483 passing tests

What it needs:

• Developers willing to experiment and provide feedback
• Real-world testing
• Framework authors interested in building on PAGI
• Performance profiling and optimization

Getting Started

git clone https://github.com/jjn1056/pagi.git
cd pagi
cpanm --installdeps .
prove -l t/

# Try the examples
pagi-server --app examples/01-hello-http/app.pl --port 5000
pagi-server --app examples/simple-01-hello/app.pl --port 5000

Why This Matters

Perl has excellent async primitives (IO::Async, Future::AsyncAwait), but no shared specification for async web applications. Each framework implements its own approach, which limits interoperability.

PAGI provides that shared foundation. By standardizing on a common interface:

• Servers can focus on performance and protocol handling
• Frameworks can focus on developer experience
• Middleware becomes portable across implementations
• The ecosystem can grow together rather than in isolation

If you're interested in the future of async Perl web development, I'd love your feedback. Check out the repository, try the examples, and let me know what you think.

Repository: github.com/jjn1056/pagi

PAGI is not yet on CPAN. It's experimental software—please don't use it in production unless you really know what you're doing.

Originally published at Perl Weekly 749

Hi there!

The big announcement is that Mohammad Sajid Anwar who runs The Weekly Challenge and who is the other editor of the Perl Weekly newsletter, has published his first book called Design Patterns in Modern Perl. You can buy it both on Amazon and on Leanpub. Leanpub gives you the option to change the price so you can also use this opportunity to give a one-time donation to him. As far as I know, Leanpub also gives a much bigger part of the price to the author than Amazon does. You can also ask them to send the book to your Kindle or you can upload it yourself. I already bought it and started to read it. Now you go, buy the book!

In just a few hours we are going to have the online meeting Perl Code-reading and testing. You can still register here.

Perl on WhatsApp: I am part of a lot of WhatsApp groups about Python and Rust and other non-tech stuff. I figured I could create one for Perl as well. If you are interested join here. There are also two groups on Telegram. One is called Perl 5 that has 141 members and the other one is called Perl Maven community that I created, because I did not know about the other one. The latter has 59 members. You are invited to join any or all of these channels.

I started a poll in the Perl Community Facebook group. There are already 63 votes. It would be nice if you answered too.

Enjoy your week!

--
Your editor: Gabor Szabo.

Announcements

Design Patterns in Modern Perl

Manwar, congratulations! Everyone else, go buy the book! (comments)

Articles

ANNOUNCE: Various updated wikis, including Perl.Wiki

Dotcom Survivor Syndrome – How Perl’s Early Success Created the Seeds of Its Downfall

I like the sentiment, but as one of the commenters pointed out there was PHP as well.

GitHub and the Perl License

In a nutshell, if you'd like to use 'the Perl license' you probably should include two separate license files. (comments)

Showcase: Localised JSON Schema validation in Perl + JavaScript (CodePen demo included!)

A small project that might interest anyone in dealing with form validation, localisation, and JSON Schema in their Perl web applications / REST API.

Web

Catalyst::Request body issues with the file position pointer

For those using the Perl Catalyst web framework in ways involving structured request bodies (e.g. API POSTs)...

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

Welcome to a new week with a couple of fun tasks "Good Substrings" and "Shuffle Pairs". 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 - 349

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

TWC349

Both solutions use a straightforward, single-pass approach that is perfectly suited for the problem. They process the input string only once, making them very efficient (O(n)) and demonstrating a solid grasp of fundamental algorithmic thinking.

Power Pointing

The post is an excellent, practical demonstration of Raku's expressiveness and built-in functionality. It successfully showcases how Raku allows a programmer to transition from a straightforward, imperative approach to a concise, idiomatic, and highly readable functional solution.

More complex than it has to be

The post presents a fascinating and honest case study of over-engineering. Bob deliberately explores a complex, "enterprise-grade" solution to a simple problem, contrasting it with the obvious simple solution.

Meeting Strings

This is an exceptionally well-crafted post. It demonstrates a deep understanding of Raku's idioms and standard library, transforming simple problems into masterclasses in concise, expressive, and functional programming.

moving and grepping

This is an exemplary post that demonstrates exceptional technical breadth, deep practical knowledge, and a clear, effective pedagogical style. It transcends being a mere solution set and serves as a masterclass in polyglot programming and database extensibility.

Perl Weekly Challenge 349

The post demonstrates both deep Perl knowledge and strong pedagogical skills, making complex solutions accessible while showcasing advanced language features.

Power Meets Points

This post demonstrates expert-level Perl programming with deep language knowledge and thoughtful engineering considerations. Matthias combines elegant solutions with practical performance analysis.

The Power of String

This is a high-quality technical post that successfully demonstrates how to solve the same problems in multiple programming languages while maintaining algorithmic consistency.

Powering to the origin

This post demonstrates creative problem-solving with elegant regex decrementing for Task 1 and a clever eval-based dispatch system for Task 2. Peter shows strong analytical thinking by carefully distinguishing between final-position and intermediate-position checks, and makes practical engineering trade-offs between cleverness and performance.

The Weekly Challenge #349

This is a well-structured, professional-grade solution with excellent documentation and robust code organization. Robbie demonstrates strong analytical thinking by carefully addressing potential ambiguities in the problem statement and explicitly warning against common algorithmic pitfalls.

Power Meeting

Roger demonstrates strong analytical skills by questioning the problem statement itself and providing robust solutions for different interpretations, showing both practical implementation skills and deeper algorithmic thinking.

Power Meeting

This is a clean, practical, and well-explained approach to the weekly challenges. Simon demonstrates strong fundamentals with a clear, step-by-step problem-solving methodology.

Weekly collections

NICEPERL's lists

Great CPAN modules released last week.

Events

Perl Maven online: Code-reading and testing

December 1, 2025

Toronto.pm - online - How SUSE is using Perl

December 6, 2025

Paris.pm monthly meeting

December 10, 2025

German Perl/Raku Workshop 2026 in Berlin

March 16-18, 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.