Hey folks, I have a couple NetBSD and Dragonfly BSD servers doing practically nothing at $dayJob, and I've been approved to "use them for charitable acts". The first thing that comes to mind for me is CPANTesters, is there a guide on how to set up a server to do so? Thanks!

I've just published version 0.44 of App::Test::Generator, the application software that scans source code and automatically generates tests for it.

Since the 0.39 release, App::Test::Generator has gained a substantial range of new capabilities while becoming more robust and reliable. Major additions include coverage-guided corpus minimization, automatic extraction and testing of POD examples, benchmark generation, GitHub Actions workflow deployment, CPAN Testers reproduction harnesses, and an end-to-end self-fuzzing framework that allows the tool to validate itself. Under the hood, schema extraction has become significantly more accurate, with improved support for formal POD input specifications, Params::Validate::Strict, Params::Validate, Type::Params, object parameters, constants, signatures, and relationship detection, resulting in higher-quality generated test suites. This release series also fixes a large number of edge cases affecting mutation testing, coverage analysis, generated test correctness, CI portability, security hardening, Windows compatibility, performance, and compatibility with older Perl environments, making App::Test::Generator both more capable and considerably more dependable for automatically generating high-quality test suites from existing Perl code.

https://metacpan.org/pod/App::Test::Generator

#Perl #softwaretesting

Hey guys! I’m a software engineer with ~5 YOE and all of it has been in Perl. The stack was essentially Perl (both for front end and back end) with SQL.

I like Perl and I’d be happy to work with it again for either existing code maintenance or migration to other languages like Python.

I also love learning new things and the “cool advanced tech,” but I would need an organization to take a chance on me and train me.

I think I’m running into two problems here: 1. getting filtered out by ATS for not checking every experience box and 2. companies don’t put Perl in their job descriptions (even when they use it).

So my questions are:

How do I let companies know that I’m willing to learn an entirely new stack?

How can I find jobs that use Perl? I’ve seen advice in this sub about tailoring your LinkedIn as a Perl dev to entice recruiters, but I don’t know what that looks like in practice.

Hello all,

I am pleased to announce the first public release of PersonName::Format v0.1.0, a new CPAN module implementing the Unicode CLDR Person Names specification.

The entire module is built from CLDR data provided by Locale::Unicode::Data and aims to follow the Unicode specification as closely as possible.

I hope it will provide value to your development projects!

Background

The Unicode Consortium has been developing a specification for formatting personal names as part of CLDR (UTS #35 Part 8, Person Names), but there is no corresponding JavaScript API Intl.PersonNameFormat; JavaScript has not yet standardised person-name formatting (as of July 2026). PersonName::Format is a Perl implementation of that specification, built on top of the CLDR data already made accessible by Locale::Unicode::Data.

Why this matters

Formatting a personal name correctly turns out to be far more complicated than simply joining a given name, and a surname.

Different languages and cultures have different conventions regarding:

• given-name-first vs surname-first ordering;
• sorting order;
• formal vs informal forms;
• monograms and initials;
• surname prefixes, and surname cores;
• spacing, and punctuation;
• multilingual, and multiscript names.

The Unicode Consortium addresses all of these issues through the CLDR Person Names specification

PersonName::Format is the implementation of that specification for Perl.

What the formatter does

Given a formatting locale and a structured name, PersonName::Format follows the full LDML procedure:

• detects the name script by inspecting surname and then given name
• derives or adjusts the name locale using CLDR likely-subtag data
• selects the effective formatting locale when name and formatter scripts differ (for example, the rule that makes a Japanese formatter switch to Latin conventions for a Western name)
• looks up the matching CLDR pattern group across the locale inheritance tree
• selects the best pattern for the fields actually populated
• applies field modifiers: initial, initialCap, allCaps, monogram, retain, genitive, vocative
• applies locale-specific space replacement between name parts

```perl my $formatter = PersonName::Format->new( 'en', length => 'long', usage => 'referring', formality => 'formal', );

Dr. John Ronald Reuel Tolkien

my $result = $formatter->format( title => 'Dr.', given => 'John', given2 => 'Ronald Reuel', surname => 'Tolkien', nameLocale => 'en-GB', );

J.R.R. Tolkien

my $short = PersonName::Format->new( 'en', length => 'short', usage => 'referring', formality => 'formal' ); print $short->format( given => 'John', given2 => 'Ronald Reuel', surname => 'Tolkien' ), "\n";

Japanese native order: 宮崎駿

my $ja = PersonName::Format->new( 'ja-JP' ); print $ja->format( given => '駿', surname => '宮崎', nameLocale => 'ja-JP' ), "\n";

Japanese formatter, foreign name in Latin: Albert Einstein

print $ja->format( given => 'Albert', surname => 'Einstein', nameLocale => 'de-DE' ), "\n"; ```

Structured output via format_to_parts

For applications that need to apply per-field styling, format_to_parts() returns the structured token sequence:

```perl my $parts = $formatter->format_to_parts( given => 'John', surname => 'Tolkien', );

[

{ type => 'given', value => 'John', field => 'given' },

{ type => 'literal', value => ' ' },

{ type => 'surname', value => 'Tolkien', field => 'surname' },

]

```

Compiled formatters for high-throughput use

When formatting thousands of names sharing the same locale and script characteristics, compile() freezes all context-resolution steps and returns a reusable object. Pattern selection still occurs per name, since it depends on which fields are populated.

```perl my $compiled = $formatter->compile( nameLocale => 'ja-JP', nameScript => 'Jpan', );

foreach my $name ( @names ) { say $compiled->format( $name ); } ```

Custom name providers

Any object implementing get_field_value(), name_locale(), and preferred_order() satisfies the name contract and can be passed directly to format(). The PersonName::Format::Name base class provides a ready-made starting point.

Error handling

Following the Module::Generic philosophy, PersonName::Format never calls die() in normal error paths. Errors set a PersonName::Format::Exception object and return undef in scalar context, an empty list in list context, or a PersonName::Format::NullObject in method-chaining context (detected via Wanted). Fatal mode is available via the object instantiation option fatal => 1.

XS and pure-Perl backends

Script detection and grapheme extraction have an optional XS backend that is loaded automatically when available. Setting PERSONNAME_FORMAT_PUREPERL=1 forces the pure-Perl path, which is used as the fallback on platforms where the XS build fails.

Differential testing

Rather than inventing expected results by hand, the formatter is differentially tested against ICU4J's PersonNameFormatter, which served as the reference implementation throughout development.

A fixture set generated from the ICU4J reference implementation is included. Running AUTHOR_TESTING=1 prove t/16.icu4j.t compares PersonName::Format output against ICU4J for the same inputs.

A quick look across programming languages

One thing that surprised me while working on this project is that support for the CLDR Person Names specification is still fairly uncommon.

The following is based on information that I am aware of, as of today. If you think it is incomplete or incorrect, please let me know.

Links

• CPAN: https://metacpan.org/pod/PersonName::Format
• Source: https://gitlab.com/deguest/PersonName-Format
• Specification: UTS #35 Part 8 - Person Names
• TC39 repository: ECMAScript

Feedback, bug reports, and pull requests are welcome. I hope this will be useful in your projects.

*[CLDR]: Common Locale Data Repository

*[ICU4J]: International Components for Unicode for Java

*[LDML]: Locale Data Markup Language

This gift (250k) is possibly the largest donation ever made to the Perl communities. The only one I know of that is in the same ballpark is the grant from Ian Hague (200k) in 2008. https://news.perlfoundation.org/post/tpf_receives_large_donation_in

Edit: those comparisons do not allow for inflation. It has been pointed out to me that the 2008 number, when adjusted to today, would be in the 310k range.

This is an experiment. Perl School was originally intended to be all-in on eBooks. But I've discovered the market for real paper is still pretty big. So if this sells well, I'll be looking at paperback editions of other Perl School books in the future.

https://blogs.perl.org/users/veesh/2026/07/perl-lsp-version-060.html

I wrote a new blog post on making UTF-8 reads fast in Perl:

Reading UTF-8 at GB/s

Background: I maintain a UTF-8 library in C that Unicode::UTF8 uses, and I recently wired it into PerlIO::utf8_strict (a joint project with Leon Timmermans). We didn't get the throughput we hoped for, because of how Perl's read operator counts UTF-8 sequences — see Perl/perl5#24511. Karl Williamson has a WIP PR addressing it.

In the meantime I added read_utf8($fh, $buf, $length[, $offset]) to Unicode::UTF8: it reads and validates UTF-8 straight off a byte handle (no PerlIO encoding layer needed) and hits ~3.6–3.8 GB/s across scripts, versus ~0.4–1.0 GB/s for the :utf8 layer today.

Benchmark available in the Unicode::UTF8 repository.

What's next? I'm considering slurp_utf8($filename) and readline_utf8() as follow-ups — feedback on the API shape welcome.

Numbers and details are in the post.