DEV Community: 🌌 Sébastien Feugère ☔

Preload Data::Printer and avoid polluting your code with debug symbols

🌌 Sébastien Feugère ☔ — Thu, 08 Feb 2024 19:00:00 +0000

When I work, I tend to have a lot of boilerplate. I am a great user of Data::Printer for debugging. There is no way I wouldn't use it, even on the smallest project. Usually, I have this on all my projects:

use strict;
use warnings;
use Data::Printer;

p $object;

Fellow Peter coworker saw me doing that once and said I liked typing too much: only use DDP was enough.

Later I learned another solution was provided in the DDP documentation.

It's possible to call ::pinstead of p(): ::p doesn't require to use the module first.

use strict;
use warnings;

::p $object;

For getting this to work, it's necessary to preload the module through command line:

perl -MDDP script.pl

The good thing is that if we forget debug symbols in a module that is going to reach deployment pipelines or the CPAN (assuming we don't have other tools configured complaining about that), it will trigger a compile-time failure without the -M option, making it easier to catch.

Note that it also works well for tests with Test2::Harness:

yath -MDDP 01_test.t

Demand Data::Printer to dump politely if it doesn't want to

🌌 Sébastien Feugère ☔ — Wed, 07 Feb 2024 11:00:58 +0000

If your project got objects that use the following methods names:

to_string(),
as_string(),
stringify(),

... Data::Printer might not behave as expected... It will dump the "stringified" object (as defined in your own code, possibly $self->name or something slightly more complicated).

It's possible to disable that feature on p() call:

p $fancy_object, class => { stringify => 0 };

But honestly, that's too much typing verbosity. I prefer, to have a ~/.dataprinter file containing the following:

class.stringify = 0

It's very convenient, for example, to automate the creation of this file in development environment (e.g. Docker containers). I usually add the following to my Dockerfiles :

RUN echo 'class.stringify = 0' > ~/.dataprinter

References

From Data::Printer perldoc:

Finally, if your object implements string overload or provides a method called "to_string", "as_string" or "stringify", Data::Printer will use it. To disable this behaviour, set class.stringify = 0 on your .dataprinter file, or call p() with class => { stringify => 0 }.

The spooky CSS in Perl toolkit

🌌 Sébastien Feugère ☔ — Thu, 28 Dec 2023 15:17:10 +0000

Some people are really going to love that: a spooky inline CSS helper for composing Outlook messages in a Perl application!

Most websites those days are SPA applications that render on the front-side, or a mixture of backend and frontend rendering. There is also this trend of CSS in JavaScript also knowns as JSS that is debatable for the simplest projects (makes everything overcomplicated), but in for more complex applications, can be justified and very useful.

Anyway, I use a lot of server side rendering. I mean, the old-school way you know, I serve HTML, CSS, and JavaScript separately.

A couple of years ago, I encountered one of those specific cases where it was useful to generate the CSS from some Perl code. We developed a crawler that helped us to interact with our in house project management API, so that we could send alerts to our colleagues when requirements had not been delivered and deadlines approached. Day minus 7, minus 3 and minus 1. And those colleagues used old versions of Outlook, so it was obligatory tables based emails, you know, those who have all kind of style and non-standard attributes all over the tags. It's actually not even standard CSS, it is Outlook specific style attributes in HTML:

  <table
    align="center"
    bgcolor="#FFFFFF"
    cellpadding="0"
    cellspacing="0"
    class="w600"
    width="600"
  >

In such a situation, the tags and style are totally mixed. There is no separation of concerns any more.

There are tools (e.g. Foundation Emails) for managing these kinds of beautiful things, but the integration with the crawler was more complicated than developing our own.

I thought of the CSS in JS thing and decided to implement a quick helper to inject the styled tags in appropriate places. Note that it starts to be interesting because when you compose such things, you have the same values repeated from dozens to hundreds of tags. And believe me, I had colleagues who really needed this automated, they would be asked to do it by hand otherwise. That's how things worked, in this company, e.g. there were no SCM tools and each “programmer” worked on their own repository, that were “merged” every few years. Also, production had hundreds of duplicates of the same app, but not the way you think of. Anyway, I'm digressing.

What I wanted was a nicely structured application, with separation of concerns, templates, no duplicated code and easy to maintain, although in the end it was for producing spooky inline CSS. This is how we would generate the previous HTML:

%= t table => ( class => 'w600', inline 'header-table' ) => begin
    ...
 % end

The basis of our toolkit is the Mojolicious::Plugin::Email::Style::CSS module that is strictly the same as the principle of CSS in
JS except it is CSS in Perl (I can hear some people crying, but this thing got designed with Outlook 2016 in mind, sorry).

It contains a list of constants that can be extended and nested.

package Mojolicious::Plugin::Email::Style::CSS;
use Mojo::Base -base, -signatures;

use constant PALETTE => {
  INFO    => '#4ECA47',
  WARNING => '#F0964B',
  DANGER  => '#F52930',
  WHITE   => '#FFFFFF',
};

use constant {

  ALIGNCENTER => {
    style => 'text-align: center'
  },
  CELLZERO     => {
    cellpadding => '0',
    cellspacing => '0',
  },

  HEADER_COLOR => [
    { bgcolor => PALETTE->{ INFO }},
    { bgcolor => PALETTE->{ WARNING }},
    { bgcolor => PALETTE->{ DANGER }},
   ],
  MAIN_WIDTH   => 600,
};

This is only a couple of constant hashes that are structured as a Sass file would be. I means: CSS with variables.

We also have a css subroutine that will take care of the “preprocessing”. It now looks even more like CSS.

sub css( $self ) {

  return {

    'align-center' => { ALIGNCENTER->%* },

    body => {
      leftmargin => '0',
      topmargin => '0',
      marginwidth => '0',
      marginheight => '0',
    },

    'top-table' => {
      bgcolor => PALETTE->{ WHITE },
      width => '100%',
      border => '0',
      CELLZERO->%*,
    },

    'content-table' => {
      align => 'center',
      bgcolor => PALETTE->{ WHITE },
      width => MAIN_WIDTH,
      CELLZERO->%*,
    },

    'header-table' => {
      border => '0',
      align => 'center',
      HEADER_COLOR->[ $self->alert_occurence - 1 ]->%*,
      width => MAIN_WIDTH,
      CELLZERO->%*,
      color => PALETTE->{ WHITE },
    },

    hello => {
      style => "color: #FFFFFF; " .
      "font-family: Arial, Gotham, 'Helvetica Neue', Helvetica,'sans-serif'; " .
      "font-size: 250%;"
    },

    'nbsp-top-margin' => {
      height => 17,
      style => "font-size: 17px; line-height: 17px"
    },
  }
}

The CSS.pm module also has an alert_occurence attribute so that we can send appropriate content and dynamically style the email depending on the emergency of the situation (day minus 7, 3, or 1):

use Mojo::Base -base, -signatures;

has 'alert_occurence';

The CSS.pm module is registered as a inline helper in our Mojolicious::Plugin::Email::Style plugin, so that it can be consumed in Mojo templates:

use Mojo::Base 'Mojolicious::Plugin', -signatures;
use Mojolicious::Plugin::Email::Style::CSS;

sub register ( $self, $app, $conf ) {
  my $style = Mojolicious::Plugin::Email::Style::CSS->new;
    $app->helper(
      inline => sub ( $self, $key ) {
        return $style->css->{ $key }->%*;
    });
}

The plugin is then loaded in a larger application:

package Email::Api;
use Mojo::Base 'Mojolicious', -signatures;

sub startup ( $app ) {
  # ...
  $app->plugin( 'Alerts::Api::Plugin::Style' );
  # ...
}

1;

Templates

Here are the main templates used for the Outlook messages. This is the global layout:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns:v="urn:schemas-microsoft-com:vml">
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <meta name="viewport" content="width=device-width; initial-scale=1.0; maximum-scale=1.0;" />
    <title>Alert</title>
    %= include 'layouts/style'
  </head>
  %= t body => ( inline 'body' ) => begin
    <%= content %>
  % end
</html>

And here is how we use our inline helper:

% layout 'outlook';
% title 'Alert';
%= t table => ( inline 'top-table' ) => begin
  %= t tbody => begin
    %= t tr => begin
      %= t td => begin
        <!-- content ~~~~~~~~~~~~~~~~~~~~~~~~~ -->
        %= t table => ( class => 'w600', inline 'content-table' ) => begin
          %= t tbody => begin
            <!-- header ~~~~~~~~~~~~~~~~~~~~~~~~~ -->
            %= t table => ( class => 'w600', inline 'header-table' ) => begin
              %= t tbody => begin
                %= t tr => begin
                  %= t td => ( align => 'center') => begin
                    <tbody>
                      <!-- top margin ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
                      <tr>
                        %= t td => ( inline 'nbsp-top-margin' ) => begin
                          &nbsp;
                        % end
                      </tr>
                      <!-- logo ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
                      %= include 'fragment/logo'
                      <tr>
                        %= t td => ( align => 'center', inline 'hello' ) => begin
                          %# include 'fragment/hi'
                        % end
                      </tr>
                    </tbody>
                  % end
                % end
              % end
            % end
          % end
        % end
      % end
    % end
  % end
% end
%#= include 'fragment/alert/first'

Conclusion

The examples for this blog post are very simple. Such old-style Outlook emails can use very-very verbose attributes and be duplicated all over the place, especially if you generate content. You obviously don't want that to be edited by hand. My idea with this project was to avoid that someone had to edit the emails by hand, because this is how things were managed usually in this company.

I thought about releasing that on the CPAN in the Mojolicious::Pugin::* namespace, but I had difficulties evaluating if it was a useful thing, really.

Hope you liked that and that it was not too spooky.

References

Initial thoughts
Foundation Emails, a toolkit for generating emails from templates

Notes about the ongoing Perl logo discussion

🌌 Sébastien Feugère ☔ — Sun, 09 Jul 2023 12:25:01 +0000

More talks popped up recently about the Perl logo topic. I feel involved into this subject because even if my activities today are mostly about Perl programming and systems maintenance, I am from an artistic background, including graphic design. I was also interested about Camelia design talks in the past and the initial mascot “specifications”.

A professional graphic designer should be involved in the core discussion around the Perl logo.

They could be given the complex logo history, articles like those written by Thibault Duponchelle or Neil Bowers, plus existing logo material. Involving a graphic designer, outside the Perl community, would allow getting a fresh and neutral eye on the situation and possibly solve some Camel / Raptor disputes (or understand better the meaning of getting a Raptor after a Camel, etc.).

It could also avoid all kind of basic design mistakes. The "shadow" O'Reilly derived logo is very detailed. Logos usually don't use such detail levels, because they need to be identified even on smaller sizes (e.g. a browser tab). Let's take a look at a couple of examples:

the Raptor used on perldoc.perl.org works well as a logo;
the cropped O'Reilly book camel head on Perl Monks doesn't work too well: it's impossible to identify an animal head;
on https://www.nntp.perl.org/ a full sized camel attempt is quite conclusive, what is surprising at this size.

A realistic camel is super difficult to use as a logo basis because it is a long animal, has too many legs and fluffy details. It won't work well except if it is “stylized” and simplified. The O'Reilly camel was a book cover, not a logo: there is no way it can work just by resizing it.

An amazing example is Ocaml lang logo / mascot. It might be useful to talk with them to know what was the process behind this work. The About page camel head on Perl dot org header is also a pretty good example of simplification, but it's not a logo, just a friendly illustration, as the O'Reilly camel is. Another notable logo for this animal is the well known tobacco industry company, but don't get me started on that (“good” logo, though, if we look at the effectiveness of their marketing).

Only shadowing the O'Reilly camel (or other base pictures) won't work: we don't want to have such detailed legs, also the tail is weird, etc. An important part of the original O'Reilly drawing spirit is the animal face, and gaze, something that would totally be lost in a shadowed version. Also, the way the camel walks, its body posture, is very significant. How can we keep all that in a simple, tiny drawing?

I don't have an opinion about which animal should better be used. There are even Perl material with butterflies, they are nice, although they are even more confusing since Raku (hello Camelia, best programming language mascot ever!). Camel is better known. Raptor is more modern and surely works better as a logo. But if the-same-artist-who-made-the-raptor would draw a camel, wouldn't it also work? For what reason a Raptor was chosen then: what is the history, the meaning under the choice?

Looks like both a very hard work, and a relativelly straightforward process for a professional graphic designer, especially considering the complex history and heritage. And keep in mind that when we speak of graphic design, everybody got an opinion, coming with their own taste, culture.

Maximize Data::Printer strings length

🌌 Sébastien Feugère ☔ — Tue, 27 Jun 2023 08:22:47 +0000

The Perl data structures and objects pretty printer Data::Printer would trim strings longer than 4096 characters (this is the default value).

This is something that can be parameterized in the ~/.dataprinter file:

# No limit!
string_max        = 0

This default is sensible, though, because you usually don't want the program output to fill with too much text.

It might be necessary to change this value, only in a specific place. You can pass a false value to string_max to display the whole string fields:

p $object_with_long_string_values, string_max => 0;

More information can be found in the module Customization section, along with all the available configuration parameters.

Why am I giving up on Perl? (edit: I didn't)

🌌 Sébastien Feugère ☔ — Mon, 02 Aug 2021 20:46:42 +0000

I started using Perl in 2010. After years of a passionate use, I start to plan something else. Disclaimer: this is not because of "the language".

Note: at the end of August, after the publication of this post, some very ~~helpful~~ lovely persons came to me and the situation changed quite a bit. More on this later...

It is a real career issue

In my country of living, getting a Perl job is a real problem. I worked the last four years in a small team where all the projects were done using Perl and Mojolicious. As far as I know, even if I got fired for economic reasons linked to pandemic situation, all the applications I deployed there are still working well despite they are not maintained anymore (ouch).

Then, what I saw since March on the jobs market is: there is a niche of companies or organizations that still do an active use of Perl. What I notice is that they are all thinking of switching to other platform (maybe they are right, after all this is something that seem to go on since 15 years), and that there is no way new projects are developed with Perl. What I felt by talking with a CTO is that she hadn't any more trust with Perl: she was not able to recruit people. Therefore, they are hiding the Perl aspect in the jobs offers and then have even more difficulties finding people. Then, when they find some persons, they would even decide that, maybe, they should hire someone more versatile. And that person will be sad, maintaining some Perl, can you imagine this hell?

I mean, this is a kind of very sad waste.

say 'help';

I missed two opportunities based on the fact that I was not a polyglot enough. I know Java, JavaScript, Perl, quite enough of various web technologies like HTML and CSS, but still, I don't know something like Go, Python, you know this stuff is real trendy! I don't value the idea of polyglotism a lot, because I prefer to focus on something, and also, I am not really able to learn a lot of programming languages. I know this is not a very popular opinion, and now I feel like in trouble. So I'll try to improve myself.

It would still be possible to switch to Raku. This is a fantastic language, and I would really like to involve myself into it, but seriously, I need to pay my bills. I mean, the probability to find a Raku job in my country is... Small?

Lack of gender equality and diversity in the communities

The Perl communities are dominated by mostly men. There are rare persons who advocate for diversity and inclusivity, but honestly, if it exists at some conferences, it is not what is spread by the communities: just check the stats of Perl Weekly contributors or other popular Perl cultural items, this is the same-old men-leaded-content everywhere with very little exceptions.

If I decide to go away from this community, I will at least contribute to reduce the gender gap. Plus, it will be one grumpy person less.

Recent communities issues are awfully worrying

Perl has a number of toxic community members, this is not new. They are armful to other, and I got very shocked of some events that happened recently. I'll focus here exclusively on the victims.

Sawyer X, pumpkin of Perl since 2016 resigned of their responsibilities after being victim of harassment. It is unacceptable that a person enduring such responsibilities are bullied by communities members.

Wendy totally vanished of the Perl communities after years of active quality work for the advocacy of Perl. I am totally sure I would have never been interested in Perl that much without Wendy. She encouraged me, her talks and the way she was engaged marked me forever. She gave me a Learning Perl book copy, and sent me to Curtis Ovid Poe to ask for a signature. Meeting her was a major event in my Perl career, and I made a very good use of this gift. From what I understood, it was partly the Raku renaming that took her away, but I suppose it is more the talks and difficult interactions that happened at this time. I don't know where you are now, Wendy, and how you are doing, but I wanted to thank you.

The Mojolicious community recently denounced a racist issue in a CPAN distribution to TPF, and after it didn't get answered accurately, pointed a conflict of interest inside TPF itself. Result: nothing.

All those, and the lack of reactions from the communities members, continuing to do their release and challenges and blog posts as if everything was going fine, all of this made me sick. And you know what? I don't even want to participate in this a lot, even if I will always love the language in itself and have a good memory of my time around Perl, and it's communities. I guess I have been marked by a very small amount of personalities, that inspired me a lot of love and motivation, but what I am seeing right now, this is not where I want to be.

Modern Perl, Perl7, Corinna

All this is very exciting, seriously, I mean it. When the Perl7 announcement came, I felt really, something will be going to happen. Then I saw all the discourse and the doubt it created, and I got afraid.

In 2021, I feel like that there are a lot of codebases that still didn't incorporate the Modern Perl ideas. It's rare to see usages of subroutines signatures, even if the feature is (experimentally) around since 2015.

Corinna, and its possible implementation, Object::Pad looks to progress real well, and I am almost sure it will be usable soon.

Conclusion

But still, I am not patient enough, and I need to get a job: unfortunately, it looks like managers and CTOs lost the confidence in Perl, and that Perl codebases should be only fixed: new code should be written in other languages. Again, this is only what I saw in France, maybe it is different in other countries, and this is not what I wish, since I have been a Perl enthusiast since 2010, and wrote new web applications 100% with Perl in the 4 last years. I wish I could find more context for this incomprehensible Perl love, but for the above reasons, I'll have to go search somewhere else. It must be a good decision, I guess...

import antigravity

Note: I received lots of support and advices after posting this. I am grateful to the people who helped me.

I started studying Python3

🌌 Sébastien Feugère ☔ — Mon, 02 Aug 2021 20:05:08 +0000

I am encountering employment difficulties with Perl lately, so I decided to cross the gap. A "reasons why" post is also available.

I started less than one week ago, so coding is still a bit hard: I am mostly evaluating expressions in the repl, I use bpython and feel extremely satisfied with it.

For now, the feeling is smooth and I am quite happy: everything I am used to in Perl can be found in Python. I see no major differences between the two languages. I am a bit surprised how sometimes the Python core have batteries included, you don't necessarily need to install modules. The only thing I miss is Mojolicious, I mean, I know there are similar tools, but I have habits, and they should simply evolve.

Reading

So far I am reading:

Planning to read:

The Quick Python Book

Language

Relatively to the language itself here are few things I noticed:

absence of sigils (@those %things $you *know): I really dislike it, it makes code less readable in my opinion. I would be tempted to systematically use two_words syntax for variables. With sigils, you target easier what is a variable or what is a keyword. Maybe I am too much used to Perl and that on the long term, this is really a minor issue, especially that functions require parenthesis with Python3, you can’t write print 'perl is cute'.
functions require parenthesis. It’s a lot of parenthesis typing, I guess my text editor is not configured the right way

Modules

I miss Data::Printer, one of my favorite Perl debugging tools ever. I install it everywhere, even for the simplest project. I searched for equivalents, but none of the one that I found, like data_printer (directly inspired from the Perl implementation) or objprint are as simple to use out-of-the-box than Data::Printer, that also have a better display

I’ll attend the Perl and Raku Conference In the Cloud

🌌 Sébastien Feugère ☔ — Wed, 09 Jun 2021 13:53:27 +0000

This year, I am unemployed so let’s try to attend and follow the Perl and Raku Conference In the Cloud. Feeling quite bored since those days, I am not too much into computer stuff but more like gardening, fixing my house, take care of my cat, cooking and do wood work, but let’s try.

I bought a ticket.

True private attributes and methods for modern Perl OOP

🌌 Sébastien Feugère ☔ — Sat, 20 Mar 2021 14:58:59 +0000

Today we will continue our exploration of modern Perl OOP. Those are very experimental features, but I feel like it could be a bit similar to what Corinna could look like so I find it fun to try new things. This is also an opportunity to learn more about OOP.

This is an example of how to implement private attributes and methods with the Zydeco toolkit. We will also see how polymorphism and named parameters works for the needs of this example.

There are other OO modules plugins that allow to add privacy features, but in Perl, it is interesting to see that, privacy is often mostly by convention: subroutines are prefixed with an underscore (e.g. sub _super_private { ... }) and everybody will consider it as private. See a short explanation about this on perlmaven.com in the Public and private methods section.

use v5.20;
use strict;
use warnings;

package DevTo {
  use Zydeco;
  class Privacy {

    # Predeclaration of the accessor coderef
    my $hidden_attr;

    has wonder ( isa => Str );
    has hidden (
      isa => Str,
      is => private,
      accessor => \$hidden_attr );

    method $innaccessible_method {
      say "No problem acessing " . $self->wonder .
      ' through a private method';
    }

    method $innaccessible_method_attr {
      $self->$hidden_attr('a hidden place');
      say "No problem accessing a private attribute in " .
      $self->$hidden_attr;
    };

    multi method no_problem {
      $self->$innaccessible_method;
    }

    multi method no_problem( Bool *with_attr ) {
      $self->$innaccessible_method_attr;
    }
  }

  my $access = DevTo
    ->new_privacy( wonder => "a public attribute" );

  $access->no_problem;
  # ==> "No problem acessing a public attribute through a private method"
  $access->no_problem({ with_attr => true });
  # ==> "No problem accessing a private attribute in a hidden place"

  # This would fail
  # $access->$innaccessible_method;

  # No things are not possible
  # $access->hidden_attr;
  # $access->$hidden_attr;
}

So, what are we doing here?

The privacy with Zydeco can target two different entities:

attributes, by using the is => private during the attribute declaration
methods, by prefixing the method name with a $

We have two private methods, that we will call from the public multi no_problem() method. This one is declared two times, with different signatures and prefixed with the multi keyword: it makes possible to setup the polymorphism, dispatching the desired behavior depending on the passing of a boolean or not:

# Would call $inaccessible_method
$access->no_problem; 

# Would call $inaccessible_method_attr
$access->no_problem({ with_attr => true });

Note how named attributes are declared and easily used:

multi method no_problem( Bool *with_attr ) { ... }

By prefixing the parameter name with a * and not a $ in the method signature, you get automatic parameter names ready for later

Then, we create a new Privacy object that we call $access. Privacy got a public attribute, wonder and one that is private, called hidden. With Zydeco, declaring an attribute as "private" make it assessor-less. Under the hood, if you check on of the underlying technologies that power Zydeco, it doesn't mean that the attribute is totally inaccessible: we can request an accessor as a coderef.

my $hidden_attr;
has hidden (
  isa => Str,
  is => private,
  accessor => \$hidden_attr );

And then access the attribute in the scope of the variable as follows:

$access->$hidden_attr;

Outside the variable scope, the attribute will be totally invisible. This is possible thanks to a handy technic that allows to call methods dynamically.

References

Random integer generation in an interval with Modern OOP Perl

🌌 Sébastien Feugère ☔ — Tue, 23 Feb 2021 11:45:18 +0000

I always have to search how to generate a random integer number between a range because this is a common task that I use a lot in tests, but really, I can't memorize it.

Though, this is how I would do it in 2021.

use v5.16;
use strict;
use warnings;

# Class definition
package Random::Range {
  use Zydeco;
  class Integer {
    method pick ( Int $min, Int $max ) {
      return $min + int ( rand ( $max - $min ));
    }
  }
}

# Script
say Random::Range->new_integer->pick(1, 100);
#==> 42

So what did we do here? We used the rand function where we applied the int function, so we would get an integer, not a fractional number. The small calculation makes possible to restrict the result to the desired interval.

All of this is glued into a minimal Zydeco class that adds a very nice object-oriented interface. You maybe don't need Zydeco, this simple one-liner would work:

perl -le 'my @interval = (1, 100); print $interval[0] + int ( rand ( $interval[1] - $interval[0] ))'

Note this is not cryptographically secure and should only be used in simple cases: if you need a secure implementation, please check some appropriate solutions on CPAN.

Art: digital painting by myself.

Load a list of lines into an array (easily)

🌌 Sébastien Feugère ☔ — Tue, 13 Oct 2020 14:42:35 +0000

This blog post describes a common task my colleagues ask often about repeating a dynamic string in a defined token and adding some or, and, = in between, plus finishing smartly.

I like to use the Perl's __DATA__ token at the end of my scripts for this. The __DATA__ token strength is to make possible to « "embed” a file inside a Perl program then read it from the DATA filehandle ». It saves you the creation and opening of a real file and is very handy for quick prototypes and tests.

#!/usr/bin/env perl
use strict;
use warnings;

# Your script here

# Everything under is considered as 
# the end of the code
__DATA__
a
lot
lot
of
stuff
here
...

A common practice is to load those data to an array by treating them as a file handle:

my @lines = <DATA>;

But the values would include carriage returns, what you obviously don't want. I used two solutions for this:

my @lines;
push @lines, 
 split while <DATA>;

This is quite readable and self-explanatory (remember Perl a natural language, it was created by a linguist). Feel free to comment if something is unclear so I could improve the post.

Ok, I have to admit a little secret:

push my @lines, 
  split while <DATA>;

... without the pre-declaration of @lines does the same. I had to counter check it worked, but as often with Perl, when you spontaneously think of something silly, it actually works naturally (I have to admit it sometimes looks like a miracle).

If you want uniq values (you surely do), one way is to use the core module List ::Util:

use List::Util qw(uniq);

push my @lines, 
  uniq split while <DATA>;

Another way to do it is always possible:

chomp( my @lines = uniq <DATA> );

I actually prefer this list context solution, for it's shortness, dunno which one is the more readable, and it is good to choose the readable way.

Let's say you want to generate a series of or for your colleagues or customers. We are actually doing a super advanced language generation thing here:

#!/usr/bin/env perl
use strict;
use warnings;
use List::Util qw(uniq);

chomp( my @lines = uniq <DATA> );

for ( @lines ) {
  # $_ is the current loop element
  print generate_string( $_ );
  # $lines[-1] is the last array element
  if ( not $_ eq $lines[-1] ) {
    print ' or ';
  } else {
    print "\n";
  }
}    

sub generate_string {
  return 'line == "' . shift . '"';
}

__DATA__
a
lot
lot
of
stuff
here
...

$ perl lines.pl
line == "a' or line == "lot' or line == "of' or line == "stuff' or line == "here' or line == "...'

Lots of other solutions exist, check the Perl one-liners thing that allow to learn a lot more about those kind of practices.

The quantities of cools things you can do inside this loop is infinite, from log parsing to generating code or data munging, thanks to the kindness of Perl.

References

Note

I wrote this because my memory is awful and I was tired of always searching for the exact syntax of the __data__ token to array process. Hope it will help all kinds of people including me when I type it in a search engine.

A concise mtime sorted directory listing application

🌌 Sébastien Feugère ☔ — Tue, 18 Feb 2020 19:10:16 +0000

Today we will focus on a simple task: listing the files contained in a directory, sort them by modification time (mtime) and display the result in a JSON array.

We are gonna use Mojo::File for the file system part and Mojolicious::Lite to expose those data on a simple but effective JSON API.

Prerequisites

apt install libmojolicious-perl

touch mtime.pl && chmod +x mtime.pl

The code

Our lite application is separated in two main parts:

a helper, the get_paths_by_ctime() method
an unique route that returns an array reference containing our file list

#!/usr/bin/env perl

# Automagically import Mojo::Base -base
use Mojolicious::Lite -signatures;
use Mojo::File 'path';

helper get_paths_by_mtime => sub {
  my $files_list = path( '/tmp' )->list;

  # Returns an array of Mojo::File
  my @files = sort { $a->stat->mtime <=> $b->stat->mtime }
    map { $_ } $files_list->each;

  # Returns an array of paths sorted by modification date
  return map { $_->realpath->to_string } @files;
};

get '/' => sub( $c ) {
  $c->render( json => \$c->app->get_paths_by_mtime );
};

app->start;

Starting the app

Mojolicious comes with the morbo HTTP and WebSocket development server

morbo mtime.pl
Server available at http://127.0.0.1:3000

If you visit this adress in your browser, it should display the list of files contained in the /tmp directory of your computer. On mine it returns:

[
  "/tmp/sddm-:0-RweLaZ",
  "/tmp/xauth-1000-_0",
  "/tmp/cpan_install_3QQI.txt",
  "/tmp/!home!sfeu!.emacs.d!savefile!ido.hist~",
  "/tmp/!home!sfeu!.emacs.d!savefile!recentf~",
  "/tmp/!home!sfeu!dev!processing-perl!etc!crontab~",
  "/tmp/!home!sfeu!.emacs.d!personal!custom.el~",
  "/tmp/!home!sfeu!dev!processing!.env~",
  "/tmp/liste_desabonnement_20200218.csv",
  "/tmp/!home!sfeu!dev!processing!.git!COMMIT_EDITMSG~",
  "/tmp/!home!sfeu!scripts!mtime.pl~"
]

It is just a bunch of temporary files, mostly those I edit in my text editor. Note that the directories and special files (., ..) are not listed.

Releasing the power of `Mojo::File`

Retrieving a list of files

Mojolicious provide a lot of utilities that makes your Perl programmer life almost bearable. Note that Mojolicious needs zero dependencies, this is the reason it comes with a great toolkit for doing simple tasks. Mojo::File is one of those. Let's see how to use it.

use Mojo::File 'path';

By using Mojo::File and loading it's path function, you will be able to construct a Mojo::File object by passing it any kind of path:

my $files_list = path( '/tmp' )->list;

The list method called on a Mojo::File directory will return all files contained in this directory. The returned object is a Mojo::Collection object, an array-based container for collections.

Sorting the objects by modification date

To read the following code, start by the end.

my @files = sort { 
  $a->stat->mtime <=> $b->stat->mtime 
} $files_list->each;

first, you return all the elements of the collection by using each
it will return an array, that can be passed to sort

sort is being passed a comparison function. In our case we will compare by mtime (modification time). The reason we can access to mtime from the array of Mojo::Files is that this module got it's own stat method that returns itself a File::stat object for the path. This is where the magic happend!

Retrieving the files paths

By using a simple map function and the Mojo::File chainedrealpath->to_string methods we will transform our array of objects to a simple array of strings:

return map { $_->realpath->to_string } @files;

The route

The result of our helper is then rendered as JSON (must be passed to the front as an arrayref).

Making it even more concise

Marcus Ramberg explained me how to make this even more concise by using Mojo::Collection->sort

The helper can be rewritten:

helper get_paths_by_mtime => sub {
  return path( '/tmp' )->list
    ->sort( sub { $a->stat->mtime <=> $b->stat->mtime })
    ->map('realpath');
};

Conclusion

The conciseness and readability of this program is quite surprising thanks to the effective tools used.

I hope you enjoyed reading this presentation and that it gave you the wish to use the formidable Mojolicious framework and it's utilities.

Acknowledgments

Thanks to Marcus Ramberg who read this, improved and simplified the code.

DEV Community: 🌌 Sébastien Feugère ☔

Preload Data::Printer and avoid polluting your code with debug symbols

Demand Data::Printer to dump politely if it doesn't want to

References

The spooky CSS in Perl toolkit

Templates

Conclusion

References

Notes about the ongoing Perl logo discussion

Maximize Data::Printer strings length

Why am I giving up on Perl? (edit: I didn't)

It is a real career issue

Lack of gender equality and diversity in the communities

Recent communities issues are awfully worrying

Modern Perl, Perl7, Corinna

Conclusion

I started studying Python3

Reading

Language

Modules

I’ll attend the Perl and Raku Conference In the Cloud

True private attributes and methods for modern Perl OOP

References

Random integer generation in an interval with Modern OOP Perl

Load a list of lines into an array (easily)

References

Note

A concise mtime sorted directory listing application

Prerequisites

The code

Starting the app

Releasing the power of Mojo::File

Retrieving a list of files

Sorting the objects by modification date

Retrieving the files paths

The route

Making it even more concise

Conclusion

Acknowledgments

Releasing the power of `Mojo::File`