Hi, I'm kobaken.

I've released an adapter for using Inertia.js with Mojolicious, a Perl backend framework. Inertia.js is a bridging library that connects backend frameworks with components written in React, Vue, and other frameworks.

https://metacpan.org/pod/Mojolicious::Plugin::Inertia

What is Inertia.js?

Inertia.js is a framework that connects backend frameworks with React or Vue components. It allows you to use modern frontend components while maintaining a traditional backend approach.

I figure this is an approach that fits well when you have substantial assets on the backend side, but replacing everything would be too costly, and you want to start by improving the client-side experience.

When using components written in React, Vue, etc. with backend frameworks like Mojolicious, I believe there are two approaches. One is to mix JavaScript code into the backend framework's proprietary template engine. The other is to call backend APIs and handle rendering with CSR or SSR. Both approaches result in more complex architecture compared to the days when you could simply select a template on the backend and pass values to it.

With Inertia.js, you can use React and other components while maintaining the good old way of writing code. Specifically, it works as follows: by writing $c->inertia(COMPONENT, PROPS) on the backend side, Inertia.js will connect with the component.

Inertia.js is the simple protocol

Another point I found appealing is that the protocol for this connection is simple. It's remarkably simple.

For example, if you write it like this...

$c->inertia('Index', {
   user => { name => 'Mojolicious' }
})

It returns this JSON:

{
   "component": "Index",
   "props": { "user": { "name": "Mojolicious" } },
   "url": "/",
   "version": "c53bc3824540ea95b1e9b495c7a01a9d"
}

So straightforward!

In fact, looking at Inertia.js's protocol, it's content you can finish reading in about 10 minutes, and Mojo's plugin is less than 100 lines, so I think it would be easy to port to other Perl frameworks.

Recently, in another project, I made React Server Components usable with Hono, but understanding that in 10 minutes is difficult for me 😅 Since Inertia.js becomes CSR, I think React Server Components is better if you're looking for user experience and SEO, but I believe there are situations where Inertia.js is sufficient.

https://zenn.dev/kfly8/articles/hono-meets-vite-rsc (Japanese)

Please give it a try if you'd like!

Weekly Challenge 338

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: Highest Row

Task

You are given a m x n matrix.

Write a script to find the highest row sum in the given matrix.

My solution

For input from the command line, I take a JSON-formatted string and turn it into a list of list of integers (arrays in Perl).

This is a one liner in Python, using the sum function to calculate the sum of each row, and the max function to return the highest (maximum) sum.

def highest_row(matrix: list[list[int]]) -> int:
    return max(sum(row) for row in matrix)

While Perl does not have a built-in max and sum function, they are provided by the List::Util module. Therefore the solution is similar.

use List::Util qw(max sum);

sub main ($matrix) {
    my $max = max( map { sum @$_ } @$matrix );
    say $max;
}

Examples

$ ./ch-1.py "[[4, 4, 4, 4], [10, 0, 0, 0], [2, 2, 2, 9]]"
16

$ ./ch-1.py "[[1, 5], [7, 3], [3, 5]]"
10

$ ./ch-1.py "[[1, 2, 3], [3, 2, 1]]"
6

$ ./ch-1.py "[[2, 8, 7], [7, 1, 3], [1, 9, 5]]"
17

$ ./ch-1.py "[[10, 20, 30], [5, 5, 5], [0, 100, 0], [25, 25, 25]]"
100

Task 2: Max Distance

Task

You are given two integer arrays, @arr1 and @arr2.

Write a script to find the maximum difference between any pair of values from both arrays.

My solution

For input from the command line, I take two strings and separate them on non-digit characters to turn them into two lists (arrays in Perl).

There are at least two possible ways to solve this, each with pros and cons.

I could extract the minimum and maximum values of each array, and compare the minimum of one list with the maximum of the other. The advantage of this is we only scan each list once, and do three additional calculations. The con is that it is significantly more code than the other solution.

The solution that I did write is a one liner in Python, by using double list comprehension and the abs and max function.

def max_distance(arr1: list[int], arr2: list[int]) -> int:
    return max(abs(a - b) for a in arr1 for b in arr2)

Perl does not have list comprehension (it does have map, but double mapping is asking for a world of pain). Therefore I use two foreach loops to get the same result.

sub main (@arrays) {
    my @arr1 = split /\D+/, $arrays[0];
    my @arr2 = split /\D+/, $arrays[1];

    my $max = 0;
    for my $a1 (@arr1) {
        for my $a2 (@arr2) {
            my $dist = abs( $a1 - $a2 );
            $max = $dist if $dist > $max;
        }
    }
    say $max;
}

Examples

$ ./ch-2.py "4 5 7" "9 1 3 4"
6

$ ./ch-2.py "2 3 5 4" "3 2 5 5 8 7"
6

$ ./ch-2.py "2 1 11 3" "2 5 10 2"
9

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

$ ./ch-2.py "1 0 2 3" "5 0"
5

As I'm writing this, I'm watching a crew install a fence and once again thanking my high school guidance counselor, Mr. Bencini, for yelling at me to get my ass in gear and quit procrastinating on those college applications if you don't want to spend your life digging post holes and living in a van down by the river.

This week's challenges must have come from Cybertruck drivers in Texas, because they are overcompensating for something with an obsession about being the biggest.

Our musical accompaniment: Take it to the Limit by the Eagles, 1975 (coincidentally about the time that Mr. Bencini was yelling at me).

Task 1: Highest Row

You are given a m x n matrix. Write a script to 
find the highest row sum in the given matrix.
Example: Input: @matrix = ([4,  4, 4, 4],
                           [10, 0, 0, 0],
                           [2,  2, 2, 9])
Output: 16
    Row 1: 4  + 4 + 4 + 4 => 16
    Row 2: 10 + 0 + 0 + 0 => 10
    Row 3: 2  + 2 + 2 + 9 => 15

If every row can be reduced to its sum, then it's a one-liner. We'll lean on list utilities.

use List::Util qw/sum0 max/;
sub highestRow(@matrix)
{
    return max map { sum0 $_->@* } @matrix
}

Notes:

• map {...} @matrix -- Each element in @matrix is a reference to an array. Do something to every row.
• sum0 $_->@* -- De-reference a row ($_) to get its list of numbers. Use sum0 instead of sum to handle the possibility of an empty matrix.

Task 2: Max Distance

# You are given two integer arrays, @arr1 and @arr2.  Write a script to
# find the maximum difference between any pair of values from both arrays.
# Example 1 Input: @arr1 = (4, 5, 7)
#                  @arr2 = (9, 1, 3, 4)
#           Output: 6
#   With element $arr1[0] = 4   | 4 - 9 | = 5
#                               | 4 - 1 | = 3
#                               | 4 - 3 | = 1
#                               | 4 - 4 | = 0
#           max distance = 5
#   With element $arr1[1] = 5   | 5 - 9 | = 4
#                               | 5 - 1 | = 4
#                               | 5 - 3 | = 2
#                               | 5 - 4 | = 1
#           max distance = 4
#   With element $arr1[2] = 7   | 7 - 9 | = 2
#                               | 7 - 1 | = 6
#                               | 7 - 3 | = 4
#                               | 7 - 4 | = 4
#           max distance = 6
#   max (5, 4, 6) = 6

This example is trying to scare us by implying that we have to do some atrocious examination of every possible pair, an O(n²) algorithm. But let's cut through the fog: if we reduce each array to a range from its minimum to its maximum, it can be visualized like sliding @arr2 past @arr1, with five different possibilities for how they overlap.

                min1                   max1
                +-------------------------+
 +--------+  +--------+  +--------+  +--------+  +--------+
 min2  max2  min2  max2  min2  max2  min2  max2  min2  max2

The maximum distance will be from the extreme of one line to the extreme of the other. At the left side of the figure, that's the distance from min2 to max1; at the right side, it's from min1 to max2.

sub maxDist($arr1, $arr2)
{
    use List::MoreUtils qw/minmax/;
    use List::Util qw/max/;

    my ($min1, $max1) = minmax($arr1->@*);
    my ($min2, $max2) = minmax($arr2->@*);

    return max( $max1-$min2, $max2-$min1 );
}

Notes:

• List::MoreUtils::minmax -- this convenient function finds the minimum and maximum in an array with only one pass, exploiting Perl's ability to return more than one thing at a time.

Well, that was almost too easy. Let's apply Parkinson's Law ("Work expands to fill the time available"). We should do some error checking for the case that one of the arrays is empty. Because I can't think of a sensible result for that case, I'll throw an exception.

    die "ERROR empty array" if ( not ( @$arr1 and @$arr2) );

• @$arr1 and @arr2 -- the value of an array in a scalar context is its size; compact and useful, and easy to trip up beginners.
• I'm using not and and for readability, rather than ! and &&. It's a simple conditional expression, so there's no problem with the low precedence of not and and.

That's nice, but now we have a function that could possibly throw an exception. We should check for that. Classic Perl had the eval syntax, but there have been variations on a try/catch feature for decades. Perl finally acquired a native try/catch syntax as an experimental feature in release 5.34, and it became a stable language feature in 5.40, so let's embrace the future.

For command-line usage, I'm going to pass the script a pair of comma-separated lists.

perl ch-2.pl  1,2,3,4  3,6,9

The Perl code to handle the arguments and call maxDist will look like:

my @ARR1 = split(",", shift // "");
my @ARR2 = split(",", shift // "");
try          { say maxDist(\@ARR1, \@ARR2); }
catch ( $e ) { say STDERR "Problem: $e" }

Notes:

• shift -- the implicit argument for shift is @ARGV, so this takes the next available command-line argument.
• shift // "" -- If there isn't an argument, avoid a warning message by defaulting to an empty string.
• say STDERR "..." -- Not trying very hard to inform or recover, but at least use conventional streams.

The final piece is to add a unit test for catching an exception. Using the Test2::V0 testing module, check for throwing an appropriate exception like this:

    like( dies { maxDist([], []) }, qr/empty/i, "Empty arrays");

• like(...) -- test that the result of some code matches a regular expression
• dies {...} -- evaluate some code that is expected to throw an exception (note braces instead of parentheses).

Originally published at Perl Weekly 737

Hi there!

There is a new episode of Underbar, the Perlish podcast, part 3 of the Vibe-coding with Perl series came out, and there is an article whether one should learn Perl in 2025.

Regarding that. My son became a programmer a while ago mostly writing in Python and some fron-end stuff when necessary. He also knows how to use vim and he is definitely not lost on the Linux command-line. I don't think there is a lot of value for him to learn Perl in general, but being able to write one-liner to help with various small tasks could be really usefule. So I started to put together a bunch of oneliners in Perl and converted it into a book. It is still only in its infancy, but to go with the tradition I decided to release early.

Thus you can already read it for free or if you'd like to also support my efforts then you can buy an epub/pdf version of it via Leanpub. You can even pick the price.

Enjoy the book and enjoy your week!

--
Your editor: Gabor Szabo.

Podcast

The Underbar, episode 4: The Cyber Resilience Act

BooK wrote: I've just published the latest episode of The Underbar. This time we're having a long conversation with Salve Nilsen about the Cyber Resilience Act and it consequences for Perl and CPAN.

Articles

Installing DarkPAN Perl modules via GitLab

Thomas wrote: This week Farhad and me finally found some time to improve a part of our build pipeline that was nagging me for years. We can now release our DarkPAN modules via CI/CD into a GitLab generic packages repository and install them from there into our app containers, also via CI/CD pipelines.

Vibe coding a Perl interface to a foreign library - Part 3

CVE-2025-40927

Re-creating the vulnerability CVE-2025-40927 in an isolated docker container.

Taking VelociPerl for a ride.

VelociPerl is a closed source fork of Perl that claims performance gains of 45% over the stock.

A Quiz about Operator Priorities

Should You Learn Perl in 2025?

Annual Russian Perl Conference 2025

Discussion

question about class design with Object::Pad

object inheritance in xs

order of SvXXOK in xs

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

Welcome to a new week with a couple of fun tasks "Highest Row" and "Max Distance". 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 - 337

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

TWC337

This is a solid, practical and highly efficient blog post that showcases a competitive programming mindset. The approach is characterized by a focus on performance, concise code and leveraging the powerful built-in functions of Perl.

Oddly Current

This is a high-quality, technically sound blog post that perfectly exemplifies the spirit of Raku programming. It successfully demonstrates how to tackle a classic algorithmic problem (Eulerian Circuits) by leveraging Raku's unique and powerful features, such as its sophisticated grammar (regex) engine and functional programming constructs.

I Never Go Far Without A Little Big Star

This post is a well-written, technically sound and engaging exploration of two weekly code challenges in Perl. Overall, it's a solid contribution that balances clarity, correctness and style.

Smaller Oddities

Both tasks move beyond naive solutions to offer significantly more scalable alternatives. The use of sorting, indexing, and run-length encoding reflects expert-level proficiency in PDL. Despite the technical depth, the code remains compact and well-organized.

Perl Weekly Challenge 337

Solutions are elegant, efficient (thanks to PDL), and provide precise results. They shine when used in a context where PDL is acceptable.

Small Numbers, and No Matrix at All

Both tasks avoid brute-force solutions in favor of counting, sorting, and parity logic. Code is concise, modern, and idiomatic Perl. Commentary is pedagogical, explains not only the "how" but also the "why".

Small, but Oddly Current

This is an exceptionally well-written and insightful post. It successfully transcends a simple "how I solved these coding puzzles" write-up and instead delivers a compelling narrative about the enduring relevance of Perl, the value of community-driven challenges and the universal benefits of sharpening one's problem-solving skills with constrained tools.

One and two dimensions

Solutions are clear, idiomatic Perl, well explained and great for educational/demo purposes. They emphasize readability and correctness over raw efficiency, which is often the right trade-off in The Weekly Challenge.

The Weekly Challenge #337

The solutions are excellent. They are correct, efficient, readable and well-structured. The post has a clear, pragmatic coding style that focuses on simplicity and directly solving the problem at hand. The code is thoroughly documented and follows good practices. This is production-quality code for this type of algorithmic problem.

The Odd Current

The post is a masterclass in technical writing and scientific computing. It successfully transforms a seemingly simple programming challenge into a deep, insightful exploration of numerical methods and performance optimization.

Oddly small

This is a well-written, engaging and technically sound solution to a coding challenge. It stands out by focusing on clarity, educational value and algorithmic elegance rather than just brute-forcing an answer.

Weekly collections

NICEPERL's lists

Great CPAN modules released last week.

Events

Boston.pm - online - monthly meetings resume (2d Tuesday)

September 9, 2025

Paris.pm - Michelangelo - monthly meeting

September 10, 2025

Toronto.pm - online - Lightning Talks 2025

September 25, 2025

Annual Russian Perl Conference 2025

September 27, 2025

Toronto.pm - online - How SUSE is using Perl

December 6, 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.

Perl in 2025 🐪

In 2025, I unexpectedly find myself enjoying Perl again — after years of Ruby and Go.

It sounds strange, but Perl hasn’t aged the way many people think. It’s not trendy, elegant, or fashionable — and yet, for certain kinds of work, it feels perfect.

Don’t Learn Perl. Learn UNIX.

Should you learn Perl in 2025?

Honestly — no. At least, not directly.

Start with UNIX system programming:

• Work in the shell.
• Understand file descriptors and streams.
• Learn how processes are born, end, and communicate.
• Get comfortable with Bash and other UNIX tools.

Once you understand these things, Perl becomes automatic.

You don’t “study” Perl — you realize you already understand it.

Perl Looks Messy — Until You See the Process

Here’s the key insight:

If you look at Perl from a syntax perspective, it looks messy.

But if you look at it through the lens of UNIX processes and streams, it suddenly becomes crystal clear and intuitive.

Perl isn’t designed like Python or Go, where you build large structures full of imports, frameworks, and abstractions.

A Perl script is simply a process:

• born by the OS,
• with three streams (STDIN, STDOUT, STDERR),
• communicating with other processes,
• manipulating files, signals, and descriptors.

When you see programs this way, Perl’s “cryptic” operators and shortcuts stop looking weird — they become beautifully compressed UNIX primitives.

Perl Is a Tool, Not a System

Modern languages — Python, Ruby, Go — often push you toward designing systems.

Perl isn’t like that.

Perl is a sharp tool for solving tasks quickly:

• Renaming hundreds of files? One-liner.
• Parsing gigabytes of logs? Two-liner.
• Automating a messy workflow? Done before lunch.

You don’t worry about architecture, imports, or frameworks.

You just write the code, run the process, and move on.

Perl feels less like a language and more like an extension of your UNIX shell.

Why Perl Lost Popularity

Perl didn’t die — it simply stepped aside. The web changed.

In the early days, the web was simple: HTML pages, images, and tables.

Perl thrived because it could glue things together effortlessly.

But today’s web apps are massive, layered systems with complex UIs, APIs, and distributed backends.

Perl was never designed for this — so it faded from the spotlight.

Why Perl Will Never Fade Away

Perl still matters because it’s tied to UNIX itself.

• Its syntax mirrors UNIX primitives directly.
• It doesn’t hide processes and streams behind abstractions.
• It becomes intuitive only after you understand the OS.

For sysadmins, DevOps engineers, and anyone who works close to the system, Perl remains reliable, concise, and insanely useful.

Perl doesn’t chase trends.

It doesn’t ship breaking changes every six months.

It’s like a ballpoint pen and a squared notebook: simple, stable, always ready when you need it.

Final Thought

Perl developers don’t see programs as abstract algorithms or piles of imports.

They see them as processes — living entities with streams, signals, and descriptors, talking to other processes in a UNIX world.

When you shift to this perspective, Perl syntax suddenly becomes obvious.

It’s not cryptic anymore — it’s just UNIX in shorthand.

Perl isn’t a language you learn.

It’s a language you grow into.

And once you do, it feels like home. 🐪