I released PerlOnJava 5.44.1 yesterday:

https://github.com/fglock/PerlOnJava/releases/tag/v5.44.1

This is a big milestone, with the regex implementation, ithreads, taint mode, and async/await now complete.

As usual, get them and cpan.metacurator.tree.html from my
Wiki Haven.

Every 8-12'ish months I get sentimental/nostalgic over the good 'old days. I'll head over to CPAN and look at the latest releases investigate a few projects, maybe even make a contribution. I'll then head over to Perlmonks to see what's going on.

Well yesterday, and still today all I see is a fastly "Opps, something went wrong" screen. Is Perlmonks dead? The title of the page is "Client Challenge" so I hope that it's some fastly issue and not that the plug has been pulled on PM.

I’ve released WebDyne 3.0, an update to the Perl-based dynamic HTML engine I have created.

The biggest addition in 3.0 is support for PAGI, alongside the existing PSGI and Apache/mod_perl backends.

PAGI support brings an asynchronous/event-oriented interface to WebDyne and allows WebDyne applications to handle more than conventional HTTP request/response traffic:

• Server-Sent Events (SSE) for streaming events from Perl applications to browsers
• WebSocket connections for bidirectional, long-lived connections
• Normal asynchronous HTTP requests
• PAGI application lifespan startup/shutdown events

WebDyne continues to support HTMX, JSON and API concepts in .psp pages.

There’s also a new webdyne.pagi runner, so getting a PAGI-backed WebDyne application running is straightforward:

Introduction

(crossposted from dev.to)

PAGI 0.002002 is a specification release. It does not change the runtime shape of a PAGI application. A running application is still one asynchronous code reference:

(English version below)

Hallo zusammen,

wir laden Euch herzlich ein
zum Deutschen Perl/Raku Workshop 2027.

Der Workshop findet nächstes Jahr vom Mittwoch 14. April bis
Freitag 16. April im Stadteilzentrum Nordstadt in Hannover statt.

Die Webseite und der Call for Papers sind bereits online unter
https://act.yapc.eu/gpw2027/cfp.html. Wir freuen uns auf viele interessante
Vorträge!

Über Unterstützung durch Sponsoren freuen wir uns immer. Wenn Ihr bzw. Eure
Firma den Workshop unterstützen möchtet, wendet Euch gerne an uns. Wir finden
gemeinsam sicher eine Möglichkeit!

Wenn Ihr Fragen an die Organisatoren habt, erreicht Ihr uns am besten
direkt unter orga2027@german-perl-workshop.de .

Wir freuen uns auf Eure Teilnahme,
Max Maischein für die Organisatoren und Frankfurt.pm

Wir arbeiten noch an
Hotelempfehlungen und veröffentlichen diese auf der Webseite.

Revisiting a Pac-Man Implementation in Perl/Tk

More or less by accident, I recently came across an old project of mine from around 2013/2014. In it, I had tried to approximate Pac-Man using Perl and Tk.

It was never intended to be an exact reimplementation of the original game. There are plenty of those in almost every programming language imaginable. What interested me more was a different question: how could the structure of a game like Pac-Man be represented as a relatively simple data structure, with the Perl/Tk user interface merely visualizing that structure on a Canvas?

Back then, of course, there was no generative AI sitting next to me explaining what I had built.

More than ten years later, there is.

So I fed the old implementation to an AI and asked it to describe the underlying concept. Maybe, the approach is interesting for you.

So here it is.

Have fun reading.

The current implementation

Here is a short video showing the current state of the implementation:

There is no release attached to this post - the second half will explain why. It is a post about measurement, twice over. Earlier posts claimed that pperl is under high-velocity development, and a claim like that should be quantified - so we do, with the same statistics perl's own release notes use, epigraph included. And we have started playing the Computer Language Benchmarks Game: one program is finished, the result is a 36x speedup on the game's terms, and the conclusions have reset our speed goals.

• Perl.Wiki V 1.52
• cpan.metacurator.tree.html V 1.29
• Mojo.Wiki V 1.23

If you work anywhere near vulnerability management, you've run into the CVSS problem: a single severity number that tells you almost nothing about what to actually do. CVSS was never designed to be a triage tool, and treating it like one is how organizations end up "patching everything" or, worse, patching nothing because everything looks equally urgent.

SSVC (Stakeholder-Specific Vulnerability Categorization), developed by Carnegie Mellon's SEI (CERT/CC) and later adapted by CISA into its own decision tree, takes a different approach: instead of a score, it's a decision tree. You feed in a handful of factors specific to your role - exploitation status and technical impact for some methodologies, safety and market-share considerations for others - and it hands you back an actual decision: track it, act on it, attend to it now. Which factors matter, and what decision comes out, depends on who you are in the vulnerability management chain - a vendor, a deployer, a coordinator, a finder - because a coordinator publishing an advisory and a deployer patching a fleet of servers are answering completely different questions with completely different inputs.

All of us turned up. There wasn’t much other than administrivia to discuss. We will be initiating the process for the new PSC election in the coming days.

[P5P posting of this summary]

Two weeks ago we announced PetaPerl 0.6.0. Today, 0.6.8 goes live at https://perl.petamem.com. Again, the version has no hidden meaning, but if you insist, you can call this the "дурак Go Home" edition. The headlines: pperl has now perl 5.44 as compatibility target because it follows the current stable perl5. The benchmark suite that produces our numbers is released, so you can see what the numbers are on your machine. DBI works, with native database drivers - connect to your PostgreSQL or MySQL database with an unmodified use DBI; script and no driver installation. And there is now a daemon that lets repeated runs of a script skip compilation entirely: each run forks an already-compiled image and goes straight to execution.

I'm pleased to announce the release of perl-lsp version 0.6.0; you can install it from Github releases, from crates.io via cargo install perl-lsp, or as a vscode or vscodium extension. If you are a zed user, you can opt in using the zed-perl extension following these instructions.

All of us were present.

• We merged one more small fix during triage. Everything else in RC2 looks good.
• The majority of our time went into discussing and editing a draft LLM policy based on the feedback so far from the core team. We will create a PR for it in the next days.
• Leon will be releasing 5.44.0 this week.
• Paul volunteers to be release manager for the subsequent 5.45.1 which may be much sooner than the usual “one per month”, because there are a lot of changes already queued up and we have two months of slipped time to catch up with.

[P5P posting of this summary]

The tech world is experiencing an identity crisis. Pundits are shouting from the digital rooftops that traditional coding is over, replaced by natural human language interfaces. They're calling it a radical new paradigm.
But if you've been paying attention to Perl since 1987, you know this isn't a revolution--it's a homecoming.
When Larry Wall created Perl, he didn't just build a language to sit closer to the metal; he built it to sit closer to speech. While computer science worshiped at the altar of rigid mathematical purism, Perl introduced a context-aware structure built on nouns, verbs, singulars, and plurals.
Today, Large Language Models operate entirely on probability, semantics, and context. We've spent decades forcing humans to think like transistors; now, we've successfully forced silicon to learn human.
Perl programmers are uniquely wired for this future. We've spent forty years treating programming as an exercise in linguistics and context.
The community isn't fading into the past; it's providing the blueprint for what's next. Case in point: The Public Enrichment and Robotics Laboratories (RoboPerl) are currently engineering PerlGPT--a model trained specifically to understand best practices, architectures, and the nuanced wisdom of "Perl poets."
The future of engineering belongs to those who can speak fluent intent.
👉 Watch Randal's full talk on how structural context is dominating the modern landscape: https://youtu.be/hAd6MHXrdh4

Last month saw the official announcement of The Raku Foundation, including an invitation to every member of the global Raku community to register their interest in the organization and become members, with the right to vote on its leadership, policies, and activities. Once again, I would encourage everyone who loves Raku to do exactly that.

I've been working on a CPAN module called JSON::JSONFold, and I wrote an article describing the motivation and design. I'd really appreciate feedback from other Perl developers.

JSON serializers tend to give us two choices: compact JSON, which is efficient but a dense wall of text that's painful to read, or pretty-printed JSON, which is readable but often wastes a lot of vertical space (a small array of numbers can turn into ten lines).

I wanted something in between. JSONFold keeps the shape of pretty-printed JSON, but folds small, simple structures back onto a single line whenever that improves readability. It works on top of your existing serializer (JSON, JSON::PP, JSON::XS, etc.) - you keep using whatever you already have, and JSONFold just reformats the output.

Example 1 - Coding

If you're like me, you use a constant a lot (I may overuse it). I often use it to turn typos in words and fields into compile-time errors, and for that I usually create constants that either are the named the same as the word, or the word uppercased, like this

use constant +{ SERVICE => 'Service', INSTANCE => 'Instance' };

or

use constant +{ map +( $_ => $_ ), @constants }

and doing that too many times inspired the creation of constant::string and constant::string::uc.

GTC 2.20 brings a huge amount of new features again (described in this post) and is starting an additional, more trimmed down, high level API, geared more toward what designers expect. But it also comes with new documentation and error handling, the two most important things that were missing for a professional distribution.