By GoPerl — Architecture, Perl, Go & Node.js for companies that need reliable and scalable systems.

In today’s modern systems, especially in web development, new stacks and new developers grow up with the idea of async/await—in other words, asynchronous systems. Many adopt the concept without fully understanding what lies behind it. The simplest goal is clear: make your application feel fast and responsive, without leaving users waiting.

Let’s take this into the enterprise world, where speed, scalability and resilience define technological competitiveness. One concept that immediately enters the conversation is job queues. Behind every high‑performance system, there is always a subsystem responsible for processing heavy tasks without blocking the user experience.

Within the Perl ecosystem, that subsystem has a name: Minion.

Minion provides a modern job queue with SQL persistence, real asynchronous execution and a simple distributed model. This makes it a more robust and easier‑to‑operate alternative compared to Redis‑based solutions like Sidekiq or BullMQ.

The three of us discussed:

• There is overall agreement that @INC handling should be improved, but there are still outstanding questions and issues that overlap with build modules, installer tools, and so on. Plan is to publish a partial document so far as a draft PR and get others to comment further.
• The recent change to improve the accuracy of caller reported line numbers in expressions involving anonymous subroutines (Pull #24396) has caused more BBC fallout than might have been expected. So far it doesn’t need any immediate response from PSC but we continue to keep an eye on it.

[P5P posting of this summary]

Introduction

I have uploaded to CPAN some tooling modules which allow Perl documentation to be authored as Markdown files - or Docbook XML articles - then merged into source files as POD. They can also then be published as HTML to static sites such as Github pages or Cloudflare Workers.

TL;DR here is an example of the end result - documention for the Cloudflare::API module created from the doc/ directory in the GitHub repository and POD for the command-line tool created from a Markdown file in the same repository.

Perl Documentation

Documentation can be tedious - despite knowing how important good documentation is, and that it can make or break open-source software. Nothing is worse than trying to run "man Some::Module" (or "perldoc Some::Manual") and getting nothing back.

POD is the "linga franca" of the Perl world for a good reason - it has stood the test of time, is completely integrated into the Perl ecosystem and is an excellent format for creating manual pages for Perl modules and scripts.

A few days ago, an article by Flutter developer Hammad Tariq caught my eye: "Rendering 10,000 Machine State Changes on a Timeline Without Freezing Flutter".

It was a solid piece of profiling detective work. Hammad was building a high-density timeline view in Flutter representing 10,000 machine state transitions. But every time the dataset loaded, the mobile UI stuttered and dropped dozens of frames.

Under a section aptly titled "The Original Sin", the author identified the culprit:

sorted.sort((a, b) => DateTime.parse(a.start).compareTo(DateTime.parse(b.start)));

Because sorting makes O(N log N) comparisons, sorting 10,000 items was triggering over 215,000 redundant calls to DateTime.parse() right inside the comparison callback, blowing past the 16ms frame budget and freezing the screen.

To fix the frame freeze, Hammad introduced a clever optimization: map each item to a temporary helper object holding the pre-computed timestamp, sort the list using that cached value, and unwrap it:

This blog entry has no release attached to it. 0.6.21 is an internal version, not for release. In the four days since 0.6.20 a few things happened, but this post is not about new things. It is about old things the 0.6.20 post forgot, about how a project moving at this pace should announce anything at all, and about a question that deserves an answer in public: who pperl is for, at a time when you can ask an AI to port your Perl script to the language of your choice and be done.

(yes, that's a lot of twos!)

Dancer2 2.2.2 is now headed to CPAN. This is a small bug fix release.

Bug Fixes

• Fixed a crash when using class-method serializers (GH #1837)
• Fixed test failures in gen.t affecting CPAN Testers and Debian builds (GH #1843)

Documentation

• Updated a contributor's name in the documentation (PR #1844)

There are no security fixes, enhancements, or deprecations in this release.

Thanks to David Precious and Nova Patch for their contributions.

As always, bug reports and pull requests are welcome on GitHub.

Jason, on behalf of the Dancer Core Team

All three of us (plus Graham’s cat) met as usual.

• Discussions about some case-matching syntax ideas continue on the mailing list. PSC is following along but for now there does not seem to be a need to come to an official response.
• From this it sounds like finding a better solution to controlling Perl’s autovivification (especially in deep hash accesses) is a useful goal and can be pursued independently. Potentially addressed by optional chaining (PPC0021).
• Adding a builtin::rand_bytes function as per [PR24722](https://github.com/Perl/perl5/pull/24722 ) sounds worthwhile. There are portability concerns that still need to be addressed on the subject of platform-dependent entropy sources (such as on VMS).

[P5P posting of this summary]

From my Wiki Haven you can now download:

• Perl.Wiki V 1.55
• cpan.metacurator.tree.html V 1.32
• Mojo.Wiki V 1.26

The basic purpose of these is to deal with the upgrade of TiddlyWiki from V 4 to V5.
Up to V 4, CamelCase words were treated as links to be clicked.
From V 5. all links to be clicked must be in double brackets: [[...]].
I have updated Perl.Wiki & Mojo.Wiki to use [[...]] and will progressively upload updated versions of the other wikis to match.

New York

Last week I went to visit my teen nephew and niece in New York. A wonderful city of contrasts, where opulence blends with poverty, with shops selling a margherita for 2 bucks a slice next to a place offering margaritas at 20 bucks a sip, and streets full of people either with pots of cash, or those blowing cash on pot. Likewise my nephew, (let’s call him Nathan) and my niece (pseudonymised here to Norma), present equally contrasting mindsets and approaches to life, yet manage to live semi-harmoniously in this subtly harsh environment.

pperl 0.6.20 is released, and readers of the two previous posts - Shall we play a game? and Doing a REJIT - know what that means. This post carries the Benchmarks Game scoreboard. It also covers a native Memoize whose cache hit is compiled into the caller, a GPU binding on the wgpu crate for the other kind of games, and a few smaller items.

Dancer2 2.2.1 is now on CPAN. This is a security release; upgrading is recommended.

Dancer2::Serializer::YAML handed request bodies straight to YAML::Load. A body tagged !!perl/hash:Some::Class could therefore instantiate an arbitrary blessed object, and !!perl/code could ask for a string eval. Both are now refused explicitly rather than left to YAML.pm's defaults.

Note that you can be exposed without having configured YAML yourself: Serializer::Mutable maps both text/x-yaml and text/html to this serializer.

Two packaging notes for this release: the minimum YAML version is now 1.30, and Dancer2 now declares the minimum CLI::Osprey it needs (0.09).

Thanks to David Precious for the YAML work.

From my Wiki Haven you can now download:

• Perl.Wiki.html V 1.54
• cpan.metacurator.tree.html V 1.31
• Mojo Wiki V 1.25

Array Median

We are given two sorted arrays, our task is to merge them and return the median. Let’s start with the naive approach: just let Perl sort the list and select the median.

#!/usr/bin/perl
use warnings;
use strict;
use experimental qw( signatures );

sub array_median_naive($arr1, $arr2) {
    my @m = sort { $a <=> $b } @$arr1, @$arr2;
    return unless @m;

    return @m % 2 ? $m[ $#m / 2 ]
                  : ($m[ $#m / 2 ] + $m[ @m / 2 ]) / 2
}

Thanks to some crafty editing by Lee, the lightning talks are also online on Youtube.

Thanks again to all the past speakers!

Many conference speakers got their start with a lightning talk - maybe on your next conference you want to give a lightning talk too?

These presentations are up to 5 minutes long - the ideal way to introduce your favorite module, TV series, or really just about any topic.

If you do scientific and/or numerical computing, you probably use or at least know about BLAS, and LAPACK. If you've done much programming with them, you may have passed in data that it cannot handle, and then you'll probably know about xerbla_.

xerbla_ is the error-handler in those two libraries, and by default it terminates the whole process. To do otherwise you have to provide a replacement routine, and have the linker for your program insert that replacement, which the library will then use instead. This is increasingly hard or impossible to do, including on macOS, Windows, and static libraries. There is now an open pull-request in the reference versions of those libraries that will permanently solve this, by allowing client programs to just pass in a new handler, which will then be used. No linker stuff involved.

Implementing this involved figuring out how to achieve this in Fortran. As a test-bed, I made a directory with this simple, no-nonsense Makefile:

Background

I've been developing the WebDyne framework to make creation of Perl-based web applications easier (for me anyway). Most of the apps I write now use John Napiorkowski's excellent PAGI design, as it supports modern asynchronous web services such as SSE and WebSockets.

One of the challenges has always been: "where do I host them?"

They run fine in Docker containers, and the demo website currently runs on Sevalla in a relatively cheap container. I could also run them in an AWS Lambda environment, but with either option I have to pick a region, and — especially with full Docker containers — hosting multiple sites can be relatively expensive for "small" applications.

Cloudflare Workers and WASM

AmberDB is an embedded, schema-driven NoSQL database engine for Perl, designed for applications that need structured records, fast indexed queries, full-text search, transactions, and a simple deployment model.

It is built on top of Berkeley DB through DB_File, but AmberDB provides a much higher-level database API rather than exposing the underlying key-value store directly.

Why AmberDB?

AmberDB brings several capabilities together in a single Perl database engine:

• a simple Perl-native CRUD API
• schemaless and schema-driven data structures
• indexed matching and filtering
• full-text search
• sorting and faceted queries
• relational and repeated data blocks
• multi-table transactions
• concurrency control
• high-throughput batch operations
• portable database archives and restore tools

The result is a database where operations that often require additional layers, services, or complex query logic can be handled directly by the database itself.

For example, a Perl application can insert, read, modify, search, and delete records using a small and consistent API, while the schema controls validation and indexing behind the scenes.

AmberDB is built around a straightforward principle:

The videos are now online on Youtube.

Thanks again to all people presenting their projects and insights!

Much of the credit for the video production goes to Lee Johnson for recording
all of them during the event. The postproduction happened thanks to ffmpeg.

The London Perl & Raku Workshop is back again this year!

https://act.yapc.eu/lpw2026

WHEN: Saturday 21 November 2026
WHERE: The Café at Zoopla, The Cooperage, 5 Copper Row, London SE1 2LH

Registrations and talk submissions are now open. As on previous years, we welcome talks for anything and everything people think might interest the Perl and Raku communities, even if it's not specifically about those languages.

We have a large room for the main track, and a breakout room for ~15 people that is available for smaller sessions, BOFs, hackathons, etc. Submissions for use of that room is also open.

We would like to encourage people to register in advance, to make it easier to access the venue and to give us an idea of numbers.

Looking forward to seeing you all, and the crazy things you've come up with.