Originally published at Perl Weekly 772

Hi there,

The Perl Toolchain Summit 2026 held in Vienna from 23rd - 26th April. I almost forgotton about it, until I read the blog post by Philippe Bruhat. It was refreshing to see the group met and continued the great work. First post event report was shared by Thomas Klausner. The event report gave a detailed insights what happend during the 4-days event. I was hoping to see more such event report from other attendees. Luckily, we had few more to keep you busy by Timothy Legge, Leo Lapworth, Thibault Duponchelle, Shawn Sorichetti, and Paul Johnson. There was even a group photo shared by Paul. I am looking for an update on my personal favourite project MetaCPAN led by Olaf Alders.

Happy to see, Stats::LikeR, which provides R statistical functions. I wish it was available few years ago. I was approached by a research student of an Australian university few years ago asking for help with his Perl script doing R's equivalent function in Perl. Fortunately we did it and paper was accepted in the end. I was surprised by his choice of language for his research paper. He could have easily used R rather than creating equivalent function in Perl. He was well versed with R as well, still he choose Perl, whilst learning the language.

Please watch the recent page on MetaCPAN for such cool modules. Enjoy rest of the newsletter.

--
Your editor: Mohammad Sajid Anwar.

Articles

DBIx::Class::Async - Oracle Database

This post I shared about the proof of support for Oracle in DBIx::Class::Async. It is always assuring the async operations with Oracle database.

Signing CPAN Releases with SigStore

Timothy Legge describes a contemporary way of achieving security in the Perl ecosystem with the implementation of Sigstore to sign CPAN Releases. This post describes how we will transition from using traditional GPG signatures to shorter and easier to obtain certificates, while providing a clear roadmap to assist maintainers (and others) in adopting "keyless" signing and enhancing supply chain security.

DBIx::Class - Schema Class (Part 2)

This is part 2 of the series post about DBIx Schema Class. In this post, I shared how we can configure session on the fly and trap exception globally.

DBIx::Class - Schema Class (Part 3)

In the third part of the series, I discussed the use of DBIx::Class::Schema::Config and how we can securely manage database credentials.

Beautiful Perl feature: low-precedence boolean operators 'and', 'or'

The elegant usefulness of Perl's low-precedence boolean operators (and, or, not) compared to the more common high-precedence operators (&&, ||, !) is further explored by Laurent. The post shows how the low-precedence boolean operator can be used as a "control flow tool" creating readable, idiomatic code using the example of the classic "do or die" convention.

Explain act

In this post, I introduced the workflow automation tool, act. It gives hands-on tutorial on the subject.

Ideas for the CPAN Meta v3 Specification

Improvements to how developers will be able to manage their dependencies and the tools that they use for building them is the goal of several forward-thinking updates proposed by Robert Rothenberg to the CPAN Meta Spec v3. His blog post includes recommendations for enhancements to provide developers with standardised, enhanced requirements for their "develop" phase, as well as improved ways to specify what hardware or operating system a developer's distribution requires to successfully run.

Discussion

This week in PSC (223) | 2026-05-04

A brief report from the Perl Steering Council has provided us with an update about their most recent triage session. Among several small changes and the completion of various CPAN dual-life module updates, one of the major highlights of this update is that there are currently no release blockers.

CPAN

GTC 2.1 go pro

The GTC (Graphics::Toolkit::Color) project has been going well according to Herbert Breunung's progress report on it, including the Go-Pro initiative for professional grade stability. The update on the 2.1 release completed a more efficient API, reducing the amount of work involved in creating colors or generating palettes, and successfully built on a solid foundation for future integration into GUI's and plotting applications.

The Weekly Challenge

The Weekly Challenge by Mohammad Sajid Anwar will help you step out of your comfort-zone. You can even win prize money of $50 by participating in the weekly challenge. We pick one champion at the end of the month from among all of the contributors during the month, thanks to the sponsor Marc Perry.

The Weekly Challenge - 373

Welcome to a new week with a couple of fun tasks "Equal List" and "List Division". If you are new to the weekly challenge then why not join us and have fun every week. For more information, please read the FAQ.

RECAP - The Weekly Challenge - 372

Enjoy a quick recap of last week's contributions by Team PWC dealing with the "Rearrange Spaces" and "Largest Substring" tasks in Perl and Raku. You will find plenty of solutions to keep you busy.

Spaces at Large

Arne Sommer takes a close look at the nuances of whitespace in Raku, especially in relation to how the context of either string or array can affect whitespace. This post provides a practical investigation into how to handle whitespace effectively. Examples of how Raku's syntactical flexibility will allow for clean, expressive code to be written around more complex data structures have been provided.

Perl Weekly Challenge: Week 372

Jaldhar demonstrates the unique strengths of each language, contrasting Perl’s efficient hash-based counting with Raku’s expressive built-ins to solve these algorithmic puzzles.

Regular Sub-Gaps

In this post, Jorg Sommrey provides an in-depth overview of his approaches to each of the two tasks for this week's challenge. He demonstrates that it is possible to write relatively short and very readable code by using List::Util and idiomatic hash slicing. He also shows how these techniques easily handle edge cases such as the case insensitivity of the frequency count of words.

Perl Weekly Challenge 372

Mochan takes a higher-level look at Rearrange Spaces by breaking down an input string into an array and then using the tr/// operator to determine how many elements are in the array before performing some arithmetic to calculate how many spaces need to be added. The x operator and join are both used to construct the output from the individual elements. For the solution to Largest Substring, Mochan uses a hash data structure to remember the first time each character appears in the input string so that he can keep track of the longest substring while going through the input string using an index. He also updates his maximum substring variable each time he sees a character he's previously encountered.

Very Stringish

Matthias Muth offers straightforward, modernly written Perl code using the new v5.40 features of Perl’s builtin::indexed to track the position of all characters in Finding Largest Substring so as to find the maximum length substring in the most efficient manner possible.

Empty Substrings and Empty Spaces

In his blog post, Packy Anderson focuses on the edge cases for each of the challenges and provides solid solutions in Perl, Raku, Python and Elixir. He also explains the logic of his "Rearrange Spaces" solution with exact math for distributing spaces between words, as well as a clever method for handling the -1 requirement for unique characters in his "Largest Substring" solution.

Strings of strings

Peter has given two stylish implementations of the weekly challenge using Perl's native string functions to produce very compact code. For Rearrange Spaces he worked out precisely what gaps were needed to recreate the string using join, and for the Largest Substring solution he had one loop with a hash to keep track of where each character was seen first so that the answer was determined with one cycle through the original string.

The Weekly Challenge - 372: Rearrange Spaces

Reinier presents a straightforward solution with his algorithmic method to achieve a successful outcome on this week's "Rearranging Spaces". This is done in Perl primarily because of its preciseness regarding how many spaces to be distributed across the gaps between the words and determining how many of the combined gaps will result in an even distribution. This post emphasizes on a well-structured plan, such as separating the words from one another using split, and then joining them back together with join and the x operator.

The Weekly Challenge - 372: Largest Substring

Reinier had a methodical solution written in Perl for Weekly Challenge task of finding the largest substring. He used a hash to track the first instance of each character encountered when traversing the string. When he finds two identical characters, he determines their distance by subtracting the first instance's index from the second instance's index, and keeping track of the maximum value found up to that point; if he doesn't find duplicates then he will return -1.

The Weekly Challenge #372

Robbie gives in-depth solutions to the problem, providing excellent input handling as well as clarity in logic. When working with Rearranging Spaces, he uses a regex to identify the count of spaces & words, ensuring the math for gap size calculations & remainders are correct. For example, with regards to one word, he handles it just like the rest (edge cases). In terms of solving the problems of Largest Substring, he uses an array to save the first and last seen indexes of each character as he iterates through the character set of the input string making a distance calculation between these saved locations to determine the largest distance. The solutions are both mathematically correct and easily understood.

Space is the Largest Place

For Rearrange Spaces, Roger considers how to find the gap sizes through integer division and then uses the modulus operator for trailing spaces. He ensures that his logic from each of his implementations remains consistent. In the case of Largest Substring, he uses a "first-seen" hash to improve performance by only traversing through the string one time. He shows us, in his post, an engineering-oriented coding style while also documenting that these algorithmic patterns are transferable to working with dynamic languages.

Distant spaces

In Finding the Largest Substring, Simon created a dictionary in Python and hash in Perl to store the first occurrence of each of the letters in the string. Once this was done, he proceeded through the entire string to compare the current index to the index where the letter was first stored; this enabled him to efficiently track the maximum distance between the first occurrence and the current occurrence. It clearly illustrate that string manipulation and data structures are accomplished using virtually the same logical steps in each of these two programming languages.

Rakudo

2026.18 Star Wars Day

Weekly collections

NICEPERL's lists

Great CPAN modules released last week.

Event reports

Perl Toolchain Summit 2026 - Vienna

According to Timothy Legge, there was an effective meeting; the purpose of this summit was to develop the CPAN Security Group (CPANSec) into a CVE Numbering Authority and improve the security disclosure process for maintainers of CPAN modules. An example of a technical outcome resulting from the summit was the inclusion of signature function support in the distribution of Crypt::OpenSSL::RSA as well as the decision to deprecate Module::Signature in favour of more modern integrity checks.

PTS 2026

Leo Lapworth highlights the 2026 Perl Toolchain Summit by describing some of the major sponsorships that made it possible. He also discusses his own efforts to modernize the MetaCPAN infrastructure and the value of in-person collaboration for solving problems with other core developers.

The Perl Toolchain Summit 2026

In this blog post, Paul Johnson provides his impressions of an intense and productive Perl Toolchain Summit 2026 held in Vienna, and highlights progress made in both Devel::Cover version 2.00 and on integrating with MetaCPAN.

My Perl Toolchain Summit 2026

Thibault’s PTS 2026 report features a heavy lift on Test::Smoke releases and CPAN security hardening. His post offers a deep dive into the technical vetting of YAML payloads and the successful launch of cpm v1.0.

PTS 2026: What Actually Happened

Shawn recaps the PTS 2026 focus on infrastructure, detailing the migration of MetaCPAN services to Kubernetes and enhanced secret management. It’s a grounded look at the high-stakes maintenance work that powers the Perl ecosystem.

Events

Boston Perl Mongers virtual monthly

May 12, 2026

Exploring Perl Modules

May 20, 2026

The Perl and Raku Conference 2026

June 26-29, 2026, Greenville, SC, USA

You joined the Perl Weekly to get weekly e-mails about the Perl programming language and related topics.

Want to see more? See the archives of all the issues.

Not yet subscribed to the newsletter? Join us free of charge!

(C) Copyright Gabor Szabo
The articles are copyright the respective authors.

Beautiful Perl series

This post is part of the beautiful Perl features series. See the introduction post for general explanations about the series.

Today's feature is quite unique in programming languages: the fact that Perl has two different syntaxes for expressing the same boolean operations. Read on to understand why this is clever and beautiful.

Boolean algebra and short-circuit evaluation

The basic operations of Boolean algebra are fundamental in programming; therefore they are present in all programming languages. In the C language, later followed by many other languages, icluding Perl, logical conjunction (the "AND" operator) is written &&, logical disjunction (the "OR" operator) is written ||, and logical negation (the "NOT" operator) is written !. Conjunction has higher precedence than disjunction, so a && b || c && d is parsed as (a && b) || (c && d) and not a && (b || c) && d. The unary negation operator has even higher precedence.

Mathematically speaking, both AND and OR operators are commutative : the left and right operands can be switched without affecting the result. But in programming languages the order of operands is not totally indifferent, because operands have an evaluation cost; therefore the system usually spares the cost of evaluating the right operand whenever it has enough information from the left operand to compute the result of the boolean operation: this is called short-circuit evaluation. For example in the conjunction $x < 9999 && is_prime($x), if $x is a large number, the left condition is false, so the whole expression is necessarily false and there is no need to do an expensive computation to decide if the number is prime. Similarly, when the left operand of a disjunction is true, then the whole expression is true and the right operand need not be evaluated.

Short-circuit evaluation is not only a question of performance: it also has important consequences when operand expressions have side-effects, like changing the value of a global variable or interacting with files, sockets or other elements of the operating system. Because of short-circuiting, the value of the left operand determines if the side-effects of the right operand will happen or not. In languages of C lineage, many common idioms take advantage of this feature for avoiding runtime exceptions: conditions checked in the left operand must be met before operations in the right operand are attempted. For example the left condition might be to check if a file is present before attempting to open it, or check if a number is different from zero before using it as denominator in a division. Here is a C example borrowed from Wikipedia:

bool isFirstCharValidAlpha(const char* p) {
    return p != NULL && isalpha(p[0]); // 1) no unneeded isalpha() execution
                                       //    with p == NULL,
                                       // 2) no SEGFAULT risk
}

Perl expressions are also statements

In languages other than Perl, examples of boolean expressions where operands have side-effects are not frequent, apart from the family of idioms just mentioned. Expressions with side-effects may even be considered inadvisable. Perl is different, because expressions are also statements, as explained in perlsyn:

The only kind of simple statement is an expression evaluated for its side-effects.

Therefore a boolean combination of expressions is also a statement. Likewise, instructions in real life may also be combinations of more atomic instructions:

Add four spoons of sugar and dissolve it into the preparation, or replace it by honey.

The above sentence indeed can be seen as a boolean expression with short-circuit: either you add sugar and then you must dissolve it and there is no need for honey, or you don't use sugar, so there is no need to dissolve anything, and you just have to incorporate the honey.

This way of expressing composite instructions is used everyday in natural language; therefore, expressing programming instructions in a similar way helps to make them easily understandable by humans, often better than sequences of if-then-else constructs, at least when the composite instruction only contains two or three individual clauses. Most programming languages would require the individual clauses to be enclosed in parentheses, which impedes readability.

Boolean expressions in Perl: two sets of operators, same semantics, different precedence

Perl's brilliant solution for improving the readability of composite instructions is to offer another set of boolean operators, written as the English words and, or, not, with exactly the same semantics as the usual &&, || and !, but with lower precedence. Actually, these word versions of boolean operators have the lowest precedence of all in Perl's table of operators, which means that statements between such keywords will be nicely parsed as an individual clauses. Let us look at a simple example:

say "tic", "tac" and say "toe";

The intended result is two lines of output

tictac
toe

and it indeed works that way. The first say is a list operator of very high precedence. Commas after such an operator build a list that will be fed as arguments to say ... but that list stops at the keyword and because of its very low precedence, so it is equivalent to the following parenthesized version:

say("tic", "tac") and say("toe");

Now since we are using parentheses, we might as well write

say("tic", "tac") && say("toe");

with exactly the same result. By contrast, the && version without parentheses

say "tic", "tac" && say "toe"

produces a different output:

toe
tic1

because everything after the first say was treated as an argument list to that say, so an equivalent parenthesized version would be:

say("tic", ("tac" && say("toe")));

The expression "tac" && say "toe" needs to be evaluated first, which is why the output has toe on the first line. The result of that expression is 1 because since the left operand is true, the boolean && returns the value of the right operand say("toe"), which is 1. Then the outer say can do its job, and since it received two arguments "tic" and 1, it prints tic1 on the second line.

This example with say was good for explanations, but is unlikely to be written like this in real programs. More realistic situations involve other list operators, like this very common idiom with open:

open my $fh, '<', $filename
  or die "failed to open '$filename': $!";

Here is another example with mkdir; this also shows that of course several successive boolean connectors can be combined:

-d $dir                                # does this directory exist ?
  or mkdir $dir                        # if not, try to create it
  or die "failed to mkdir '$dir': $!"; # if the creation failed, report the error

Assignment operations

Examples so far were mainly with the or operator. Usage of and is more often combined with assignment operations: a variable takes the value of an expression, and if that value is not empty, then a follow-up operation is performed.

$n_items = $aref && @$aref
  and say "this array contains $n_items items"
  or  say "this array is empty";

This example assumes a variable $aref to be a reference to an array. The first line checks if the reference is indeed defined, and if so, if it refers to a non-empty array. Depending on the result, the appropriate follow-up message is printed.

For this example to work, the $n_items variable must be already declared earlier in the code: unfortunately it wouldn't work here to write my $n_items = ... because the my declaration would only take effect at the end of the whole statement; therefore at the point where the interpreter parses the string "this array contains $n_items items", variable $n_items would not be declared yet and would throw an exception.

This excerpt shows a single expression containing both && and and. Perl's table of operator precedence has been carefully crafted so that the assignment operator = (and its derivatives +=, *=, etc.) has lower precedence than boolean operators in their symbolic syntax &&, || or !, but higher precedence than those operators in their english syntax and, or, not. Therefore the value assigned to $n_items is $aref && @$aref, including the && operator, but it does not include what comes after the and.

The result of a boolean operator is the last operand

The example of the previous section assigns a boolean expression to a variable $n_items whose name indicates that it is not meant to receive a constant true or false but an integer number! This may be surprising for readers accustomed to strongly typed languages like Java or C++, where the result of a boolean expression can only take one of two boolean values.

By contrast, boolean expressions in Perl, like in several other dynamically typed languages (JavaScript, Python, Ruby, etc.), return the the last evaluated value. That value therefore can have a dual purpose: not only can it be tested for truthness (where any value different from undef, 0, "0" or "" means "true"), but it can also be used for its regular scalar value, as a number, string or reference. Many common idioms in Perl and other similar languages take advantage of this feature for writing compact expressions. A more verbose but more explicit version of the assignment above would be:

$n_items = defined $aref ? @$aref > 0 ? @$aref
                                      : 0
                         :              undef;

Real example

To conclude with a real example, here is an excerpt from my module Data::Domain with quite heavy use of idiomatic and / or constructs:

sub _inspect {
  my ($self, $data) = @_;

  looks_like_number($data)
    or return $self->msg(INVALID => $data);

  if (defined $self->{-min}) {
    $data >= $self->{-min}
      or return $self->msg(TOO_SMALL => $self->{-min});
  }
  if (defined $self->{-max}) {
    $data <= $self->{-max}
      or return $self->msg(TOO_BIG => $self->{-max});
  }
  if (defined $self->{-not_in}) {
    grep {$data == $_} @{$self->{-not_in}}
      and return $self->msg(EXCLUSION_SET => $data);
  }

  return;
}

Like always in Perl, there are several ways to do it. Here the stylistic choice was to use if statements for checking the main conditions, but and / or expressions for secondary checks. Another way to write the condition on -min could be:

  defined $self->{-min}
    and $data < $self->{-min}
    and return $self->msg(TOO_SMALL => $self->{-min});

or perhaps

  return $self->msg(TOO_SMALL => $self->{-min})
    if defined $self->{-min} and $data < $self->{-min};

Low precedence and/or in other programming languages

Apart from Perl, dual sets of boolean operators are only found in Ruby and PHP, two programming languages that were heavily influenced by Perl. Apparently their designers considered that this was a good idea! By contrast, a language like Python where the motto is there is only one way to do it did not adopt such a design.

Apart from stylistic preferences, the reason why low-precedence boolean operators in Perl are so effective is that they combine especially well with the other features of the language mentioned above, like the fact that expressions are also instructions, and the fact that boolean expressions return the last evaluated value.

Conclusion

Perl's invention of a double set of operators for a same purpose was a bold step, clearly on a different path than usual endeavors in programming language design that often seek to minimize the set of operators, with features as orthogonal as possible.

Yet Perl's choice integrates particularly well with other technical features of the language and with its general philosophy. Algorithmic steps can be written in a way that closely reflects natural language and natural thinking, without heavy syntactic if-then-else constructs and without verbose parentheses.

About the cover picture

Since the seminal Camel Book, Perl has been associated with the image of a camel (actually a dromedary). Here we have a camel carrying a performing organist ... nice illustration for a beautiful Perl feature. This woodcut print is part of a 16th-century Triumphal Procession series commissioned by the Holy Roman Emperor Maximilian I. The image is borrowed from the Deutsch Fotothek.

If you are developing a large-scale Perl module or a native extension (XS/SPVM), build and test times can become a bottleneck. While we often manually pass -jN to make, I wanted a way to bake parallel execution directly into the Makefile.PL.

Today, I want to share a rather "aggressive" hack to achieve parallel builds and tests by injecting logic into WriteMakefile.

The Snippet

WriteMakefile(
  macro => {
    # Force parallel builds
    MAKEFLAGS => "-j$jobs",
    
    # Inject parallel test execution by overriding TEST_VERBOSE
    # Constraints for Windows shell compatibility (pwsh/cmd.exe):
    # 1. The entire command is wrapped in double quotes.
    # 2. No backslashes (\) to avoid escape hell.
    # 3. No dollar signs ($) to prevent pwsh variable expansion.
    # 4. No nested parentheses to avoid pwsh tokenization errors.
    # 5. Only '();. are used for maximum safety.
    # 6. Minimal symbols to avoid edge cases in shell parsing.
    'override TEST_VERBOSE' => "scalar (eval chr(36) . q(ENV{HARNESS_OPTIONS}='j$jobs'), 0)",
  },
);

How it works

1. Parallel Build (MAKEFLAGS): This sets the -j flag for GNU Make. Please note that this only works with gmake.
2. Parallel Test Hack (override TEST_VERBOSE): This is the "dirty" part. I’m hijacking the TEST_VERBOSE macro, which is usually intended for toggling verbose output. By using eval and chr(36) (to avoid the $ symbol which causes pain in PowerShell), I’m forcing the HARNESS_OPTIONS environment variable to be set to j$jobs just as the test suite starts.

The constraints in the comments ensure that this string remains "shell-safe" even on Windows (cmd.exe or PowerShell), avoiding backslashes and nested parentheses that usually break the build.

Is there a better way?

I’ll be honest: this works, but I’m not sure if it’s the "best" or "right" way to do it. It feels like a brilliant hack, but hacking TEST_VERBOSE to set environment variables is definitely not what the ExtUtils::MakeMaker authors intended.

I’d love to hear your thoughts:

• Is there a built-in WriteMakefile option that handles parallel tests natively?
• Have you found a cleaner way to pass HARNESS_OPTIONS through the generated Makefile without shell-escaping hell?

If you have a more "canonical" approach, please let me know in the comments!

Originally published at Perl Weekly 771

Hi there,

I put the 'Testing in Perl' course on hold for now. Instead of that we are going to explore the use of some of the mocking libraries we saw during the course. In the next session we'll pick one of the Perl modules used for mocking and we'll look for modules that use it. We'll try to understand how it is being used and we'll try to contribute something to at least one of the modules.

For background you can check the OSDC Perl page where we have a listing of modules for 'Code reading'.

You can also watch the recording of the Testing in Perl course. (Registration required but these videos are currently free of charge.)

Enjoy your week!

--
Your editor: Gabor Szabo.

Articles

ANNOUNCE: Perl.Wiki V 1.45 etc

TPRC Announces Post Conference Class

Steven Lembark is presenting: Teaching AI New Tricks: Perly MCP's for Claude.

Who tests the tester? Me !!!

I was just showing the participants of the 'Testing in Perl' course how to write and test a Test::* module. It is nice to see that about the same time Lichtkind wrote an article about the same topic.

Reading CPAN Testers Reports Using AI Agents

A very interesting and useful use of AI.

Discussion

sending matrix messages

Module naming vs CPAN conventions

Perl in Ubuntu 26-04 LTS (vs 24-04 LTS)

Some Perl modules need a dev package to be installed using 'apt'.

The Weekly Challenge

The Weekly Challenge by Mohammad Sajid Anwar will help you step out of your comfort-zone. You can even win prize money of $50 by participating in the weekly challenge. We pick one champion at the end of the month from among all of the contributors during the month, thanks to the sponsor Marc Perry.

The Weekly Challenge - 372

Welcome to a new week with a couple of fun tasks "Rearrange Spaces" and "Largest Substring". If you are new to the weekly challenge then why not join us and have fun every week. For more information, please read the FAQ.

RECAP - The Weekly Challenge - 371

Enjoy a quick recap of last week's contributions by Team PWC dealing with the "Missing Letter" and "Subset Equilibrium" tasks in Perl and Raku. You will find plenty of solutions to keep you busy.

Perl Weekly Challenge 371: Missing Letter

Abigail gives us an efficient solution, O(n), to the missing letter problem by determining the difference between the sum of all letters in a full range of letters and the sum of the letters in the given array. This eliminates unnecessary loops, which is a big advantage over an iterative search.

Perl Weekly Challenge 371: Subset Equilibrium

This solution is a well-organised that defines the NP-complete status of this problem and also implements an efficient bitmasking solution in numerous programming languages (e.g., Perl, Python, AWK, C, etc.) and serves as an excellent reference for other programmers to learn about and use for comparison purposes.

Missing Equilibrium

The Raku Solution implements this approach using combinations to easily create subsets in an idiomatic and very readable way. It also provides an elegant way of compensating for zero-based indices when calculating the sum of the positions in each subset by the calculated subsets.

Subset Equilibrium (Just nod if you can hear me)

Bob addressed the exponential number of complex solutions from the outset and provided a practical implementation based on Algorithm::Combinatorics. The use of a positional-based iterator with zero-index compensation allowed him to effectively handle the off-by-one requirement. In addition to that, Bob supplied practical testing strategies using the Test2::Tools::Compare package.

Perl Weekly Challenge: Week 371

This solution gives a clean, efficient implementation that fulfills both the requirement of a proper subset and utilising 1-based indexing by adding + @combo.elems to the index sum. By making use of combinations from Algorithm::Combinatorics in Perl (and using built-in combinations in Raku), only the necessary subset sizes are generated; the output formatting handles both the non-empty and empty result cases in a very clean manner via a clear ternary expression.

Missing Equilibria

This new solution offers an evaluation of the subset equilibrium problem that is a new and interesting technical perspective and acknowledges the shared views of the two demonstrated examples, while not overlooking those cases where the two may have disagreement along the edges of each set of criteria. The Perl code produced using Math::Prime::Util::forcomb and List::Gather is exceptionally simple but has an artistic style as well.

Perl Weekly Challenge 371

The post describes a simple yet effective way to generate all proper subsets of a set. It uses the subset function of the Algorithm::Combinatorics module to create all proper subsets, and then filters them based on a very concise expression written as a single line. The script contains both a command-line version for easy use and a complete version that includes error handling and has been thoroughly tested.

The Missing Equilibrium

By mathematically restructuring the main condition in the problem, i.e. equality of the total values for elements and their corresponding indices. Additionally, utilising the combination iterators from Algorithm::Combinatorics with subset sizes of 2 through n-1 provides a memory efficient approach to solving this exponential complexity problem while utilizing an optimally prepared array of pre-computed offsets, or at least the offsets for an individual index, gives evidence of thoughtful programming.

My subset is-a missing a letter…

The solution has a nice, clean, multi-language implementation (Raku, Perl, Python, Elixir) and uses indexed pairs of values to keep track of the relationship between the two elements and the index position of the two elements, thus having no off-by-one errors. The solution meets the "proper subset" constraints by filtering out empty sets, singletons, and the full set as well as providing lots of detail in verbose output to help educate the user by giving exact values and sums of values for each match.

Solve the question and balance the subset

By using established neighboring letter pairs, the algorithm determines the steps $a and $b in an efficient manner by deducing which are the next alternately patterned letter combinations in relation to each of the five positions for question marks. The entire algorithm utilises a single conditional expression to account for all five possible question mark positions. Additionally, the use of the modulus operator and the mapping of the patterning logic from the analysis to the assignment of steps makes this implementation both very efficient and very easy to read.

The Weekly Challenge - 371: Missing Value

This solution requires formalization of the detection of repeating patterns through a comprehensive and well-documented approach by treating them as a repeating two-stage model (i.e., d1 = d3 and d2 = d4). Special consideration is given to both constant and alternating sequences. The use of defined-or (i.e., //=) to unify step values, along with the straightforward relationship between each possible question mark position and its simple arithmetic reconstruction, contributes to creating a code that is highly reliable and easy to follow. Additionally, the thorough input validation provided demonstrates significant consideration for actually implementing in a real world scenario.

The Weekly Challenge - 371: Subset Equilibrium

This document includes an excellent comparison of two CPAN modules (Algorithm::Combinatorics and Data::PowerSet) that correctly identifies the combinatorically generated subsets by size (2 to n) are more efficient than generating the power set and filtering out the subsets to produce the same result for this specific task. The code base is very clean and well-structured; it also does a great job of utilising list slicing (@nums[@$subset]) and map to convert from 0-based to 1-based position, while making use of the helper function print_result to ensure that all output for all test cases is consistent and easy to read.

The Weekly Challenge #371

This document offers an innovative and realistic perspective on the subset equilibrium issue by acknowledging there is no "smart" optimisation to the subset equilibrium solution and then using a simple combination-based search on the two to n-1 sizes. The solution was implemented correctly with a summation on 1-indexed values for each of those combinations.

Missing Equilibrium

Roger demonstrates a very clever way of optimizing the solution through the precomputation of one list of differences so that only the check for the sum of the selected differences equals zero must occur, which substantially reduces the amount of computing needed within the combinatorial loops. Roger does a great job of providing a perspective of how to write this in many programming languages (Raku, Kotlin, Crystal, etc.) and provides many practical examples (like sorting the list to create a consistent order for output), thereby making this solution efficient and easily transferable across many different programming languages.

Question the bits

Using bit manipulation, this solution works well to create all combinations of subsets by iterating through all integers from 1 to 2^n-2, thus avoiding the empty and full subsets. The inner loop adds pos+1 because the indices in a array have a base index of 1, while the implementation does not require any third-party modules, making it portable and easy to use for individuals who are already comfortable using bit mask manipulation.

Weekly collections

NICEPERL's lists

Great CPAN modules released last week.

Event reports

Welcome to the Perl Toolchain Summit 2026!

That's how it started

Perl Toolchain Summit in Vienna

A little review by the local orga.

Events

Exploring Perl Modules

May 7, 2026

Boston Perl Mongers virtual monthly

May 12, 2026

The Perl and Raku Conference 2026

June 26-29, 2026, Greenville, SC, USA

You joined the Perl Weekly to get weekly e-mails about the Perl programming language and related topics.

Want to see more? See the archives of all the issues.

Not yet subscribed to the newsletter? Join us free of charge!

(C) Copyright Gabor Szabo
The articles are copyright the respective authors.

Weekly Challenge 372

Each week Mohammad S. Anwar sends out The Weekly Challenge, a chance for all of us to come up with solutions to two weekly tasks. My solutions are written in Python first, and then converted to Perl. Unless otherwise stated, Copilot (and other AI tools) have NOT been used to generate the solution. It's a great way for us all to practice some coding.

Challenge, My solutions

Task 1: Rearrange Spaces

Task

You are given a string text of words that are placed among number of spaces.

Write a script to rearrange the spaces so that there is an equal number of spaces between every pair of adjacent words and that number is maximized. If you can’t distribute, place the extra spaces at the end. Finally return the string.

My solution

This is a little more straight forward than last weeks challenge one task. For this task, I take start by separating the words on whitespace, and count the number of spaces. This is stored in the words list (array in Perl) and spaces variable.

def rearrange_space(input_string: str) -> str:
    words = input_string.split()
    spaces = input_string.count(" ")

To avoid a division by zero error, I handle the case where there is a single word. For this I return the word followed by the required number of spaces. In Python, a string multiple by an integer will repeat the string the specified number of times.

    if len(words) == 1:
        return words[0] + " " * spaces

If there is more than one word, I calculate the spaces_between_words and spaces_at_end using the divmod function. I return the string with the spaces in the appropriate places.

    spaces_between_words, spaces_at_end = divmod(spaces, len(words)-1)
    return (" " * spaces_between_words).join(words) + " " * spaces_at_end

The Perl solution uses the same logic. As it does not have a divmod function, I calculate the two values separately. The x operator in Perl is used for repetition. The expression $#words returns one less than the length of the words array.

sub main ($input_string) {
    my @words  = grep { $_ ne "" } split /\s+/, $input_string;
    my $spaces = ( $input_string =~ tr/ / / );

    if ( $#words == 0 ) {
        say '"' . $words[0] . " " x $spaces . '"';
    }
    else {
        my $spaces_between_words = int( $spaces / $#words );
        my $spaces_at_end        = $spaces % $#words;
        say '"'
          . join( " " x $spaces_between_words, @words )
          . " " x $spaces_at_end . '"';
    }
}

Examples

$ ./ch-1.py "  challenge  "
"challenge    "

$ ./ch-1.py "coding  is  fun"
"coding  is  fun"

$ ./ch-1.py "a b c  d"
"a b c d "

$ ./ch-1.py "  team      pwc  "
"team          pwc"

$ ./ch-1.py "   the  weekly  challenge  "
"the    weekly    challenge "

Task 2: Largest Substring

Task

You are given a string.

Write a script to return the length of the largest substring between two equal characters excluding the two characters. Return -1 if there is no such substring.

My solution

For this task, I start by creating a dict (hash in Perl) called freq with the frequency of each letter. In Python, this is achieved with the Counters function from the collections module.

I then iterate through the dict. If the letter occurs more than once, I calculate the difference between position of the first and last occurrence, minus one. Both Python and Perl have the index and rindex methods to do this. I update the largest value if this is greater than previously found values.

from collections import Counter

def largest_substring(input_string: str) -> int:
    freq = Counter(input_string)
    largest = -1

    for letter, count in freq.items():
        if count > 1:
            substr = input_string.rindex(letter) - input_string.index(letter) - 1
            if substr > largest:
                largest = substr

    return largest

The Perl solution follows the same logic.

sub main ($input_string) {
    my %freq = ();
    $freq{$_}++ foreach ( split //, $input_string );
    my $largest = -1;

    while ( my ( $letter, $count ) = each %freq ) {
        if ( $count > 1 ) {
            my $substr = rindex( $input_string, $letter ) -
              index( $input_string, $letter ) - 1;
            $largest = $substr if ( $substr > $largest );
        }
    }

    say $largest;
}

Examples

$ ./ch-2.py aaaaa
3

$ ./ch-2.py abcdeba
5

$ ./ch-2.py abbc
0

$ ./ch-2.py abcaacbc
4

$ ./ch-2.py laptop
2

$ ./ch-2.py abc
-1