blogs.perl.org

Available from the Wiki Haven.
I have still not had time to update CPAN::MetaCustodian, so it does not yet work correctly with the latest version of Perl.Wiki.html.

Class::Mite is getting better relatively as numbers shown in the post below: https://theweeklychallenge.org/blog/bless-vs-class-mite

The Experiment

At the beginning of the year, we ran a small experiment at work. We hired four annotators and let them rate 900 sentences (the details are not important). To decide whether the inter-annotator agreement was significant, we calculated (among others) Krippendorff’s alpha coefficient.

I’d used Perl for everything else in the project, so I reached for Perl to calculate the alpha, as well. I hadn’t found any module for it on CPAN, so I wrote one: I read the Wikipedia page and implemented the formulas.

The Real Data

The experiment was promising, so we got additional funding. We hired 3 more annotators, and a few months later, another nine. This increased the number of raters to 16. So far, they’ve rated about 200K sentences. Each sentence has been annotated by at least two annotators (usually three).

One day, I decided to calculate the inter-annotator agreement for the new data. To my surprise, the calculation took more than 6 hours.

We finally managed to arrange our first regular meeting between the three of us.

• Largely we discussed strategy for the named parameters branch. We agreed to merge soon (so people start playing with it), just staying ready to back it out well before release, in case it proves not to be ready.
• In that context, we considered the situation with experiment warnings. We agreed that named parameters should be an additional experiment of its own, though it is an adjunct of another experiment – and we do not yet have established ways of dealing with such a situation. We want to think about how our experiment mechanism should be extended to cover such cases.

[P5P posting of this summary]

Without weighing in to the pros and cons of using a Monorepo approach to your organizations codebase, I am interested in hearing about tools and approaches that have been used with Perl.

For example, I have found that Bazel has Perl support which seem fairly actively. I wonder if there is anything that can integrate with Dist::Zilla? Or any way of managing pulling third party code?

Experiences with CI/CD in the normal Git hosting platforms are also of interest - although it does seem like Github and Gitlab are designed around death-by-repo - and I have seen some features to vary the "actions" behavior based on whats changed. I am however just as interested in if you have had experiences with other platforms please chime in!

Fwiw I realize that perhaps Git isn't the best for Monorepos (although you could argue that the Linux Kernel is in a monorepo) and I have no issue with current alternatives and upcoming ones.

Any plugins that can help? For anything mentioned or not.

Totally open ended question. Please comment!

At long last - Dancer2 2.0.0!

I apologize it took longer than expected - open source doesn't always move as fast as we'd like it to - but there's a lot of great things in this release that make it worth the wait.

Head on over to Perl.com to check out the details. Here's a quick summary of what's new:

• New documentation, courtesy of a grant from the Perl and Raku Foundation
• Extendable config system, thanks to Mikko Koivunalho
• Removed Dancer2::Template::Simple from core Dancer2
• Retired our fork of Template::Tiny, and integrated our changes into the core distribution (thanks, @ether!)
• Configurable data/secrets censoring with Data::Censor
• Logging of hooks as they are executed
• New hook: on_hook_exception
• CLI improvements:
  • Changes that allow for scaffolding of other things (plugins, etc.) in future Dancer2 releases
  • Scaffolding of tutorial app

We're really excited for this release, and we hope you are too!

Keep Dancing!

Jason/CromeDome

Design Pattern Factory: Moo vs experimental class feature.
Please check out the link for more information:
https://theweeklychallenge.org/blog/design-pattern-factory

Ongoing scheduling issues have meant we haven’t met all three together for a while, but today Paul and Leon found a time to discuss a few issues.

Dev point releases

5.43.3 just went out. .4 to .7 are accounted for, so we’ve a few months yet on that. Nothing for PSC to do for now.

OpenSSL progress

Leon has been building a replacement for Net::SSLeay - an XS wrapper of libssl. Eventual plan is that IO::Socket::SSL should be able to use that instead. Eventual intention is that it can be bundled with the actual core perl dist and get us ability to use https URLs from the in-core CPAN client directly.

We should have a technical meeting at some point to round up some of the interested parties. PSC’s involvement can just be keeping an eye on it, and seeing if it is on track to be included in (5.)44.

TODO: Plan a time and audience for said meeting.

Better categorization of core vs dual-life modules

We often rely on our tools and just deploy new DB versions and move on.

Lets see these simple examples.
Example 1
You have Schema v1 where table's column has the name `X`. At the next Schema v2 instead of it you created column named `Y`.

v1 -> v2
X -> -
- -> Y

So the tool correctly drops the `X` and creates `Y`.
Example 2:
For downgrades it looks the similar:

v2 -> v1
Y -> -
- -> X

Simple! Right??

Example 3
Let's do it in more advanced way. Now instead of create/drop we will rename field:

v1 -> v2
X -> Y{renamed X}

In this scenario SQL:T will detect `renamed` option and will generate `ALTER ...` statements correctly instead of CREATE/DROP one.

Example 4
Let's move to Schema v3 where we create `X` and drop `Y` (like we did in the example 1):

v2 -> v3
Y{renamed X} -> X

The annual Perl-Conf.Ru/25 will take place in Moscow on September 27, 2025 — a special date marking the birthday of Perl's creator, Larry Wall!

The conference will bring together the Perl community to share experiences and discuss current trends in development. The program includes reports on modern tools and practical approaches to solving complex problems.

The talks will cover:

1. Test2: life after Test::More
2. Turbo Perl: batteries debugger included
3. Writing typemap for passing structures to XS
4. Perl & Postgres: the hard way, because it's easier

Registration and Details: https://perl-conf.ru/25

Roles in Perl, implemented in native form with zero dependencies. Check out where the discussion ends up in the post below:
https://theweeklychallenge.org/blog/roles-in-perl

#!/usr/bin/perl

use 5.36.0;

# ------------------------------------------------

say 'Does priority say we print 2b or ! 2b?';

my($action_types) = qr/PAYMENT|SETTLEMENT|TRANSFER/o;

say "Action types: $action_types";

for my $action (qw/PAYMENT REFUND/)
{
say "Action: $action";
say "Case: 1. $action (1a): ", $action =~ $action_types ? 'Present' : 'Absent';
say "Case: 2. $action (2a): ", "$action (2b): " . $action =~ $action_types ? 'Present' : 'Absent';
say "Case: 3. $action (3a): ", "$action (3b): " . ($action =~ $action_types) ? 'Present' : 'Absent';
say "Case: 4. $action (4a): ", "$action (4b): " . ( ($action =~ $action_types) ? 'Present' : 'Absent');
say "Case: 5. $action (5a): " . ($action =~ /$action_types/ ? 'Present' : 'Absent');
say '';
}

After a very long hiatus due to the triplet of work-vacation-work, we return to Part 3 of my AI assisted coding of a Perl interface to a foreign library.
I will not repeat the post on my Github pages Github pages, or the documentation of my MetaCPAN package Bit::Set which features a "vibecoding" section.
However, I would like to share the take home points from my exercise:

• I found the agentic bots to not be very helpful, as they entered these long repetitive and useless reflections without being able to fix the problems they identified when the build of `Bit::Set` failed.
• The "Ask" mode chatbots could generate lots of code, but with subtle mistakes.
• Success with porting test suites from one language to the other was highly variable, ranging from near perfect to outright refusal to execute a difficult task.
• On the other hand, the chatbot was excellent as an auto-complete, often helping me finish the structure of the POD and putting together the scaffold to fill things in.

All three of us attended, but with Aristotle and Paul short on time. So this was a short meeting. We discussed some administrivia and reviewed the left-over todo list from the previous PSC.

[P5P posting of this summary]

The unary + operator is one of the most commonly used operators in Perl. Below is a post detailing a recent situation where I encountered it:
https://theweeklychallenge.org/blog/unary-operator

We are moving full steam ahead. The Journals are not so easy to put out 2x a year we are finding, but the editing process for Issue #2 is moving ahead nonetheless. We are now collecting papers for inclusion for Issue #3. But our hybrid conferences are proving to be very successful endeavors. We hope you will consider submitting a Science Track paper or regular Perl talk to this 2 day hybrid conference in sunny ole Austin, TX, USA.

See more:

https://science.perlcommunity.org/spj/announcement/view/9

Get them at the usual place...

Twenty years is a long time in the world of software. That's how long it's been since I last updated my Perl module, File::Finder. But today, thanks to a bug report from a dedicated user, I'm excited to announce the release of version 1.0.0!

For those who don't know, File::Finder is a handy little module that gives you the power of the find command right in your Perl code. It turns out that it wasn't playing nicely with Windows, and it was high time to fix that.

It's a surreal and wonderful feeling to revisit code you wrote two decades ago and find that it's still useful to people. It's a testament to the power and longevity of Perl and the open-source community.

A big thank you to the user who took the time to report the bug and help me bring this module into the modern era. It's moments like these that make you appreciate the collaborative spirit of software development.

You can find the new, Windows-friendly version of File::Finder on CPAN.

#Perl #CPAN #SoftwareDevelopment #LegacyCode #OpenSource #ThrowbackThursday

[this message written with the assistance of Gemini CLI inside VSCode]

Caching using CHI.
Please check out the link for more information:
https://theweeklychallenge.org/blog/caching-using-chi

The transition meeting to the new PSC proved a bit tricky to schedule to get everyone from both the old and new PSC in attendance, but eventually we succeeded: Aristotle, Graham, Leon, Paul, and Philippe all participated.

• We discussed our structure for PSC meetings and our learnings about it from last cycle. We briefly introduced Leon to it and went over the onboarding checklist.
• We discussed roadmap items from the last cycle that did not get done, such as getting TLS in core. No decisions were taken as they will be for the new PSC to make.

[P5P posting of this summary]