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.
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.
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.
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.
Over twenty-five years ago, when PetaMem was still in its infancy but
the use of Perl for its NLP/NLU systems was already a given (Natural
Language Processing / Natural Language Understanding - we did not
dare to call it AI back then), slightly before the 5.8 era and in a
still-young SMP environment, I envisioned a perl that would
autoparallelize. That is: dispatch your code onto the available CPUs,
automatically. The idea was not mine. I had seen it sometime in the
nineties at the CeBIT computer fair, at the SGI booth, where their C
compiler was doing exactly that.
The vision evolved into a wish, and the wish, refined over the years,
into a resolution: should PetaMem ever have the resources to fund the
R&D team this would need - realistically at least twenty people, or
five Jonathan Worthingtons - we would do it. 2025 was a remarkable
year for us technology-wise, and when Christmas came, the decision
was made: requisition said twenty … or fifty
“people”,
and build an autoparallelizing perl with a JIT.
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.
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' };
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.
So I've created a programming language which blends a fairly JavaScript-like syntax with fairly Perl-like semantics, and a few other features that I haven't really seen in many programming languages.
This Perl:
use Path::Tiny;
my $str = uc(substr(Path::Tiny->new("myfile.txt")->slurp_utf8, 0, 80));
Becomes this in ZuzuScript:
from std/path import Path;
let str := new Path("myfile.txt")
▷ ^^.slurp_utf8
▷ ^^[0:80]
▷ uc ^^;
The ▷ operator means "evaluate the left side, then evaluate the right side with ^^ set to the result of the left side". It's conceptually similar to | in shells and seems to make a lot of expressions so much easier to understand.
Then here is a reminder that in light of current events you will want to update your account to use a different email address. (There are about 130 of you that get to jump through this hoop now.)
This post is the first in a series that will follow my re-development of the Devel::ptkdb debugger. This post explains the beginnings of my involvement with the Perl Tk debugger.
