Stats::LikeR: R’s statistics toolkit, native in Perl

I got tired of writing CSV files just so I could run a t-test in R.

My data was nearly always in Perl already. I’d parse a log or a lab export, clean it up, dump it to disk, open R, run t.test, and paste the p-value back into the Perl script that built the report. Every one of those hops is a chance for a column to get reordered or an NA to turn into a zero without anyone noticing.

Before: Perl, CSV, R, copy by hand, Perl. After: one Perl script.

Stats::LikeR is what I wrote so I could stop doing that. Version 0.34 is on CPAN now.

In short:

Dancer2 2.3.0 is on its way to CPAN. It adds support for the HTTP QUERY method, fixes a pair of JSON serializer bugs, and closes a small information leak in error responses.

If your app speaks JSON, you want this one.

Why 2.3.0 and not 2.2.3? QUERY support adds a new keyword, and a new keyword can collide with code you already have. Details below.

New: HTTP QUERY support

QUERY is a newer HTTP method that's safe and idempotent like GET, but carries a request body like POST. It's meant for searches and lookups that are too big or too complicated to cram into a query string. (Yes, it's the thing a lot of us have been faking with POST for years.)

Two Approaches

This blog post was inspired by the Task 1 of Weekly Challenge 396. Let’s start with the actual wording of the task:

You are given two arrays of integers, @order and @friends.
The @order (size n) contains every integer from 1 to n exactly once. The @friends contains IDs sorted in strictly increasing order.
Write a script to return the array containing IDs in finishing order.

Not clear? Let’s look at an example:

This week we invited Stig to discuss some general policy matters around security announcements and related development work.

We also talked about improvements to the way we handle maintenance releases and backporting bugfixes (in general, not just security-related ones) with the aim to make the process smoother and hope to do it a little more often.

[P5P posting of this summary]

The Perl Community is busily preparing for the Winter 2026 PCC, December 17 & 18 in Austin, TX, and remote—including Perl’s birthday! We’re planning on yet another great lineup of in-person and remote presentations.

Join our announcements-only email list for conference news and video releases.

In the meantime, thanks to a few generous souls, we’ve hired a video editor to help us release the conference recordings. The first two videos from Winter 2025 PCC are up:

• A Perl File System Based on FUSE — Mohammed Zia
• Gary McKinnon & the Biggest Perl Hack — Mickey Macten

More recordings are coming over the next couple of weeks, including:

• sealed.pm: Compile-Time Method Lookups — Dr. Joe Schaefer
• Bits & Pieces: Perl Library for CPU & GPU Architectures — Dr. Christos Argyropoulos
• Matplotlib::Simple: Plotting Quickly in Perl and SimpleFlow: Automating & Reliabilizing Computational Workflows — Dr. David Condon
• PAGI: The Perl Asynchronous Gateway Interface AKA PSGI 2.0 and AI Perl Committee: Introduction to Perl MCP — John Napiorkowski

• Perl.Wiki V 1.57
• cpan.metacurator.tree.html
• cpan.metacurator.help.html (New!)
• Mojo.WIki V 1.27

• CPAN::MetaCurator V 1.34
• CPAN::MetaPackager V 1.05

Since 2012 I have been saying in public that Perl needs applications, and that CPAN by itself is not the killer application. These apps never arrived, and the usual answer was "use the right tool for the job". In a time when AI reimplements whole software suites, the question is worth asking again. Our answer is PetaApps: a NAS, a hypervisor, a software-defined network, a mail server and a backup server, on one platform, built on Rust and Perl. None of it is finished. All of it is under way.

URI::PackageURL 2.26 is on CPAN.

URI-PackageURL implements two specifications that are becoming central to software supply-chain security:

• PURL (Package URL, standardized as ECMA-427): a uniform way to identify a software package across ecosystems (pkg:cpan/URI-PackageURL@2.26)
• VERS (Version Range): a universal notation for version ranges (vers:cpan/>=2.00|<2.26)

It ships with two CLI tools, purl-tool and vers-tool, and depends only on core modules.

What's new

The new cpan PURL type

The main change is support for the updated cpan type definition in purl-spec.

NetAddr::IP 4.079 was released in 2016 and has sat there since. I have started working on it recently, and 4.080_05 is the fifth trial release since. It is on CPAN now, and the tarball is ready for you to install!

Most of what changed is a matter of course: about a hundred fixes to bugs and to documentation that had drifted from the code, and a set of three breaking changes that fix behaviour the documentation said should not happen. NetAddr::IP is now MIT licensed, was dual licensed under GPL v2 or the Artistic License, and deprecations collected under one heading are going in version 5.

The XS build

Get them at my Home Page's Wiki Haven.

This is the first version where ChangeLog[12] are included in the JSTree, so there are still some tiny cleanups to do...

pperl 0.6.25 is released; the changelog has the complete record: https://perl.petamem.com/docs/eng/changelog/index.html. Until now pperl showed what it could do: a feature here, a module there, a benchmark won. This release is measured against what others need. The internal libraries and software suites of PetaMem and PetaJoule run on pperl in full, and of the 500 distributions the rest of CPAN stands on, all but three pass - 99.9% of the CPAN River by weight.

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:

(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

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.

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
}