Beefy Boxes and Bandwidth Generously Provided by pair Networks
We don't bite newbies here... much


( #480=superdoc: print w/replies, xml ) Need Help??

If you've discovered something amazing about Perl that you just need to share with everyone, this is the right place.

This section is also used for non-question discussions about Perl, and for any discussions that are not specifically programming related. For example, if you want to share or discuss opinions on hacker culture, the job market, or Perl 6 development, this is the place. (Note, however, that discussions about the PerlMonks web site belong in PerlMonks Discussion.)

Meditations is sometimes used as a sounding-board — a place to post initial drafts of perl tutorials, code modules, book reviews, articles, quizzes, etc. — so that the author can benefit from the collective insight of the monks before publishing the finished item to its proper place (be it Tutorials, Cool Uses for Perl, Reviews, or whatever). If you do this, it is generally considered appropriate to prefix your node title with "RFC:" (for "request for comments").

User Meditations
Holy Crap! Programming Well is Hard Work
3 direct replies — Read more / Contribute
by nysus
on Feb 24, 2017 at 12:50

    As a hobbyist programmer and someone fascinated with the world of programming and learning what I can about it, it strikes me more and more just how obsessive to detail good programmers are. That's never been a strong suit of mine, unfortunately. I'm impatient and I often make wrong and bad assumptions that make it tough for me to write solid code. And I think what I like about programming so much–even though it often humbles me by making me feel like a bit of a dunce–is that it forces me to think like an engineer. But I have to work pretty damn hard at it and the process is slow and frequently frustrating.

    In the programming field, there is an extraordinary amount of information to take in, process, and put into practice. It seems the more I learn, the less I feel like I know. I marvel at the programmers to be able to do that and who have a natural knack for it. I'd like nothing better than to spend 15 hours a day lost in code (which I've been doing lately) but it still sometimes feels like I'm pushing a rock up a mountain. I have a few projects I want to write and write well but I end up getting diverted by having to learn some new skill first. Every day there seems to be countless new idioms, tools, and concepts that I need to learn and put into practice.

    But I'm eager for the day when it all just clicks, when I can look at someone else's piece of code and read it like a newspaper and know everything that's going on with it (or at least have a pretty good idea). It's frustrating to go down three dead ends or spend an hour figuring out why your code won't do what you want because of a stupid mental error. I'm guessing most programmers like me have gone through a similar phase where they can write code that gets simple stuff accomplished but aren't good enough to take on a really large or complex project.

    Anyway, just needed to vent. I feel better now. And thanks to the Perlmonks who have helped me on my journey toward my goal of achieving programming excellence. I could not keep pushing on this rock without you.

    $PM = "Perl Monk's";
    $MCF = "Most Clueless Friar Abbot Bishop Pontiff Deacon Curate";
    $nysus = $PM . ' ' . $MCF;
    Click here if you love Perl Monks

Look at the next value of hash when sorting by values
2 direct replies — Read more / Contribute
by Cow1337killr
on Feb 13, 2017 at 12:15
    #!/usr/bin/perl # Program name: Run it, thusly: perl next-value Look at the next value of hash when sorting by values # From perlmonks Chatterbox 20170213 reply by [ambrus] # [stu96art] I am hoping to get some help with hashes. Working on l +ooking at the next value when sorting by values, but don't know how t +o reference it. # [stu96art] My code is on my scratchpad: /padstu96art # [ambrus] stu96art: perhaps try to first assign the sorted key lis +t to an array variable, then iterate through that array with indexes # [stu96art] Gotcha. That makes sense. Appreciate the help. # [ambrus] like my@s = sort keys %a; for my$i (keys@s) { print "cur +rent: $s[$i] => $a{$s[$i]}, next: ", ($i+1<@s ? "$s[$i+1] => $a{$s[$i ++1]}" : "none"); } # [stu96art] Thanks again. I will work on that. use strict; use warnings; # Example hash from my %color_of = ( "apple", "red", "orange", "orange", "grape", "purple", "tomato", "red", "lettuce", "green", "peanut", "tan", ); my @s = sort keys %color_of; for my $i ( keys @s ) { print "current: $s[$i] => $color_of{$s[$i]}, next: ", ( $i + 1 < @s ? "$s[$i+1] => $color_of{$s[$i+1]}" : "none" ); print "\n"; } __END__

    Close readers will note the following: stu96art specified "when sorting by values".

    It is debatable whether he meant Sort the values of the hash or Sort the hash in alphabetical order of its keys. is a good place to start to learn this particular subject.

Working Solo and in a Team
3 direct replies — Read more / Contribute
by eyepopslikeamosquito
on Feb 13, 2017 at 04:29

    I've worked solo, and in teams, for many years now, and in many different organisations. Yet I still feel dissatisified somehow.

    While I enjoy working alone -- especially when I'm in the zone -- I have to acknowledge that individuals working alone in my organisations have produced some pretty quirky and unmaintainable code over the years. At least, that's what I've seen.

    Moreover, I write better and more relevant code not when working solo, but when receiving regular feedback from others.

    Sadly, I've found that working closely with others can be difficult and stressful, especially when personality clashes arise. The tragic human condition -- as I'm reminded every day when reading the news -- is that there are so many factors that can cause conflict in teams: gender, politics, religion, baby boomers vs generation-y, introvert versus extrovert, perl vs java, the list goes on and on.

    Pair Programming

    One of the drawbacks of being chosen to lead humanity's push to become an interplanetary species is having to give up your privacy. "You could hear everything else that happened in the dome, and they could hear you," Ms Johnston recounted.

    -- What it's like to spend a year pretending to live on Mars (news article)

    I've tried pair programming eight hours a day and hated it. Like the budding Mars astronauts, I discovered how much I value my privacy.

    High Performing Teams

    Despite my unfortunate pair programming experiences, I acknowledge the crucial importance of teamwork and effective teams. Though I've rarely experienced it personally, I know that the elusive harmonious, high performing team is certainly possible. How best to achieve it?

    According to a recent study at Google the five keys to a successful team are:

    • Psychological safety: Can we take risks on this team without feeling insecure or embarrassed?
    • Dependability: Can we count on each other to do high quality work on time?
    • Structure & clarity: Are goals, roles, and execution plans on our team clear? Do we have an effective decision-making process?
    • Meaning of work: Are we working on something that is personally important for each of us?
    • Impact of work: Do we fundamentally believe that the work we're doing matters?

    Some ideas you might try from the Google study to improve teamwork:

    • Google's gTeams exercise: a 10-minute pulse-check on the five dynamics above, a report that summarizes how the team is doing, a live in-person conversation to discuss the results, and tailored developmental resources to help teams improve.
    • Google found that teams who adopted a "new group norm" improved more than other teams. An example of a new group norm is "Kick off every team meeting by sharing a risk you took in the previous week".


    I'd love to hear of your experiences. What's been your workplace experiences, both working solo, and in a team? Which do you prefer? I'm especially interested to learn what you feel is the key to working in an effective team.


Mining and war as a metaphor for programming
2 direct replies — Read more / Contribute
by nysus
on Feb 11, 2017 at 08:58

    Heads up, this doesn’t have much to do with Perl but, in my highly unqualified opinion, PerlMonks are the smartest programmers around (at least maybe the only smart ones who will give me the time of day (barely)) so I thought I’d post this here.

    So anyway, I had a few beers last night and a couple of cocktails to boot and I started getting a little philosophical about programming. What is it programming, exactly? I decided the best definition I could come up with is that it is “the automation of the creation and extraction of meaning from the world.” It’s basically a mining exercise where the “natural resource” is meaning.

    Once the meaning is extracted, it can be used to help guide decisions, help increase efficiency of processes (including the mining of more meaning even faster and more automatically), or help us uncover how the universe works as in the case of scientific research.

    Then I got to wondering where programmers fit into this cosmic extraction of meaning. It struck me that programmers are like foot soldiers. Those who employ soldiers and direct them are like generals. The generals would be equivalent to the business leaders and bureaucrats who make big picture decisions. And then somewhere in the middle are computer scientists, who study the extraction and processing of meaning with computers. The generals rely on the knowledge of computer scientists to determine which strategies to employ to help extract meaning. The computer scientists would be like war strategists, determining the best tools and methods for automating the extraction of meaning.

    Outside of these three major roles are people like IT folks who would be like Seabees; those who set up the infrastructure and equipment needed to process the meaning. The companies that write software workhorses are like defense contractors who manufacture equipment (the tanks, jets, and ships) that do a lot of heavy lifting (IBM, Google, Microsoft, Facebook, Apple, etc.).

    Of course, the lines between these roles are much blurrier than in war. For example, a programmer running a small business writing consumer software is often the general, the foot solider, and the Seabee (probably not so much a war strategist). A consultant who helps businesses develop complex custom software is probably much less of a foot soldier and more of a war strategist.

    My thought is the most valuable programmers are those who have a good idea about what would be of value to leaders, are very familiar with computer science and are highly expert on wielding the most powerful tools used to automate the extraction meaning.

    $PM = "Perl Monk's";
    $MCF = "Most Clueless Friar Abbot Bishop Pontiff Deacon Curate";
    $nysus = $PM . ' ' . $MCF;
    Click here if you love Perl Monks

How to remove the overlaps (MIRA - Bioinformatics)
No replies — Read more | Post response
by Cow1337killr
on Feb 07, 2017 at 12:27
What killed Perl?
4 direct replies — Read more / Contribute
by Anonymous Monk
on Feb 06, 2017 at 17:07
    Easy. If, instead of focusing on Perl 6, the community had made things like installing Perl web server as easy as installing PHP, Perl5 would still be in top 10 like PHP is. Maybe it is not too late ...
Improve readability of Perl code. Naming reference variables.
7 direct replies — Read more / Contribute
by hakonhagland
on Jan 19, 2017 at 15:05
    Hello Monks!

    I've been learning Perl for some years now. At the same time, moving from writing awk scripts to writing Perl scripts, I have found Perl to be an amazing resource for getting things done.

    Still, I have some minor issues with the language design that I have not yet been able to understand/resolve. This is what I want to discuss here.


    It sometimes bugs me that it is so difficult to write Perl code that is readable (easy to follow) when working with references. For example, if I see a variable $var in the middle of some code, it can be a scalar variable, a scalar reference, an array reference, a hash reference, and so on. Hence, I often end up guessing or having to scan source code nearby in order to determine the type of the variable. I find this workflow less than optimal. Would it not be better if the variable could (optionally) be made self-documenting with respect to reference type?

    In the book Perl Best Practices, the problem is mentioned in another setting, and the solution suggested is to add the suffix _ref to the variable name. So one could write,

    $var_href = { a => 1 };
    to create a hash ref, and
    $var_aref = [ 1, 2, 3];
    to create an array reference.

    However, a problem with this convention could be that the suffix is not optional. You should not be forced to used the more verbose form of the variable name. I think, the programmer should have a choice to decide whether he finds it advantageous to include the suffix at given place or not. For example, when declaring the variable as

    $var = [ 1, 2, 3 ];
    it is rather obvious that it is an array reference, and there is no need to write:
    $var_aref = [ 1, 2, 3 ];
    The latter is in my opinion too verbose. However, if the reference is just defined as
    my $var;
    it would often be better to include the suffix. If there is no indication on the next lines or so whether $var will be used as an array reference or not, it would be more readable to define it as
    my $var_aref;

    A new idea for reference variable naming syntax

    So this lead me to an idea: Could the postfix dereferencing syntax be extended for this use case?

    The Postfix Dereferening Syntax (PDS) was introduced as experimental in 5.20. And starting from 5.24 it is included in the Perl language by default.

    Currently PDS is used for dereferencing:

    my @array = $var->@*;
    Notice that the PDS includes a star after the sigil. It is a syntax error not to include the star. But let's say for the moment that if the star was omitted, the dereferencing was to be simply ignored instead. So
    my $var->@;
    would mean the same as
    my $var;
    and produce no syntax error.

    Let's denote this new syntax by Optional Postfix Reference Declaration Syntax (OPRDS). So when using OPRDS, should it be entirely up to the user to ensure that he used the correct sigil. For example, if I write

    $var->@ = 12;
    when I really meant
    $var->@ = [ 12 ];
    should it produce a compile time error? I think it would be very helpful if the compiler could use OPRDS to check for consistency. But it might be difficult to implement? I do not know. If it is difficult to implement, some alternatives might be used instead? I don't know much of Perl internals, so this is a point where I need help.

    When I started out with this idea, compile time type-checking was not on my mind at all. But I see now that OPRDS would offer the opportunity for stricter type checking.

    But type checking was not the main issue I wanted to discuss. What I would like to discuss is how to deal with reference variable names. Reading and understanding written Perl code can be difficult since the $ sigil can be used for many data types. How could this situation be improved?

RFC: Module for testing asynchronous event series
No replies — Read more | Post response
by Dallaylaen
on Jan 18, 2017 at 16:57

    Let's say we are going to test a module that is supposed to be run asynchronously - using threads, AnyEvent, or Coro, or some other means. And we need to check that certain events happen in certain sequence, because some of them depend on the others.

    Probably the best way to achieve this would be of course to minimize interdependencies and use mathematically correct synchronization for whatever is left. Of course, that is not always achievable, due to limited time.

    So I'm going to propose a primitive that I think should deal with a huge subclass of such tasks.

    The code goes as follows:

    use Test::AsyncSeq; my $id = Test::AsyncSeq->get_sequence_id; my $id2 = Test::AsyncSeq->get_sequence_id( "frobnicate" ); # would be "frobnicate1" or smth # somewhere in threads/callbacks is_after( $id, "start" ); # elsewhere is_after( $id, "event2", "start" ); # more elsewhere is_after( $id, "event3", "start" ); # finally is_after( $id, "finish", "event2", "event3" );

    The is_after( $id, $event, @dependencies ); passes if and only if:

    • sequence named $id was created;
    • $event was not seen in the sequence yet;
    • all of the @dependencies have been seen at the moment of the call.

    The id is just a string, and is required since Perl is not very good at passing blessed references across threads. And multiple tests MAY be needed in the same script, say to catch a race condition.

    Does such interface make sense? Would it be of use to anyone?

[RFC] Building Regex Alternations Dynamically
5 direct replies — Read more / Contribute
by haukex
on Jan 18, 2017 at 07:57

    Dear Monks, this is a suggestion for a tutorial, any comments or suggestions are welcome. Update 1: Fixed up explanation of metacharacters a bit. Update 2: Implemented some things from kcott's comments. Update 3: Added TL;DR, inspired by LanX.

    TL;DR: The two code samples below are working pieces of code that can be copied into your Perl script and adapted for your purposes.

    I thought it might be useful to explain the technique of building regular expressions dynamically from a set of strings. Let's say you have a list of strings, like ("abc", "def", "ghi"), and you want to build a regex that matches any of them, like /(?:abc|def|ghi)/. This also works well with s/search/replacement/ if you have a hash where the keys are the search strings and the values are the replacements, as I'll show below. If you're uncertain on some of the regex concepts used here, like alternations a|b and non-capturing groups (?:...), I recommend perlretut.

    First, the basic code, which I explain below - note the numbering on the lines of code.

    my @values = qw/ a ab. d ef def g|h /; my $regex_str = join '|', # 4. map {quotemeta} # 3. sort { length $b <=> length $a } # 2. @values; # 1. my $regex = qr/$regex_str/; # 5. print "$regex\n"; # 6.
    1. We begin with the list of strings stored in the array @values. This could be any list, such as a literal qw/.../, or return values from functions, including keys or values.
    2. We sort the list so that the longer strings appear first. This is necessary because if our regular expression was /foo|foobar/, then applied to the string "foobarfoofoobar", it would only match "foo" three times, and never "foobar". But if the regex is /foobar|foo/, then it would correctly match "foobar", "foo", and again "foobar".
    3. Next, we apply the quotemeta function to each string, which escapes any metacharacters that might have special meaning in a regex, such as . (dot, matches anything) or | (alternation operator). In our example, we want the string "g|h" to be matched literally, and not to mean "match g or h". Unescaped metacharacters can also break the syntax of the regex, like stray opening parentheses or similar. Note that quotemeta is the same as using \Q...\E in a regex. As discussed here, you should only drop \Q...\E or quotemeta in the case that you explicitly want metacharacters in your input strings to be special, they come from a trusted source, and you are certain that your strings don't contain any characters that would break your regular expression or expose security holes!
    4. Then, we join the strings into one long string using the regex alternation operator |. If you want to use this string without the qr// of step 5, note this potential pitfall: For example, if your input is qw/a b c/, then at this point your string will look like $regex_str="a|b|c". Then, saying /^$regex_str$/ will be interpolated to /^a|b|c$/, which means "match a only at the beginning of the string, or b anywhere in the string, or c only at the end of the string", which is probably not what you meant, you probably meant /^(?:a|b|c)$/, that is /^(?:$regex_str)$/!
    5. Finally, we compile the regular expression using qr//. This is not strictly necessary, you could just interpolate the string you've just created into a regex, but I prefer to turn them into regex objects explicitly. It also has the advantages that you can apply modifiers such as /i to the regex in a (IMO) more natural way, and that qr// implicitly adds a non-capturing group (?:...) around the regex, which takes care of the problem described in step 4 above.
    6. When we print the regular expression, we see that it has become this:
      You can now use this precompiled regular expression anywhere, as explained in Compiling and saving regular expressions and perlop, such as if ($input=~$regex) { ... } or while ($input=~/$regex/g) { ... }.

    Search and Replace Using a Hash

    my %map = ( a=>1, ab=>23, cd=>45 ); # 1. my $regex_str = join '|', # 2. map {quotemeta} sort { length $b <=> length $a or $a cmp $b } # 3. keys %map; my $regex = qr/$regex_str/; print "$regex\n"; # 4. # Now, use the regex my @strings = qw/ abcd aacd abaab /; # 5. for (@strings) { my $before = $_; s/($regex)/$map{$1}/g; # 6. print "$before -> $_\n"; # 7. }
    1. This is the hash in which the keys are the search strings, and the values are the replacements. As above, this can come from any source.
    2. This code to build the regex is mostly the same as the above, with differences noted here.
    3. Instead of only sorting by length, this sort first sorts by length, and sorts values with the same length with a stringwise sort. While not strictly necessary, I would recommend this because hashes are unordered by default, meaning that your regex would be in a different order across different runs of the program. Sorting the hash keys like this causes the regex to be in the same order in every run of the program.
    4. We print the regex for debugging, and see that it looks like this: (?^:ab|cd|a)
    5. These are the test strings we will apply the regular expression against.
    6. This is the search and replace operation that matches the keys of the hash, and as a replacement value gets the corresponding value from the hash. Note that the /g modifier is not strictly required (s///g will replace all matches in the string, not just the first), and you can adapt this regex any way you like. So for example, to only make one replacement anchored at the beginning of the string, you can say s/^($regex)/$map{$1}/;.
    7. The output of the code is:
      abcd -> 2345 aacd -> 1145 abaab -> 23123

    Hope this helps,
    -- Hauke D

URL encoding and decoding
No replies — Read more | Post response
by $h4X4_&#124;=73}{
on Jan 12, 2017 at 06:33

    While testing a module I found a bug in the way it encodes a URL. So I hit the web to find out why.
    The subroutines it uses for encoding and decoding where very old and had many more bugs then the one I found, so I installed URL::Encode and because the module complained I then installed URL::Encode::XS also.

    I used URL::Encode to test the two output and fix the broken code, because most of the time using a cpan module just slows the main project down a lot when the included modules are providing a very small chunk of code.

    So my fix for the broken URL encode and decode is below and outputs the same as URL::Encode.
    It looks like it would be a lot faster then including a module (URL::Encode) to do the same actions.

    sub url_encode { my $rv = shift; $rv =~ s/([^a-z\d\Q.-_~ \E])/sprintf("%%%2.2X", ord($1))/geix; $rv =~ tr/ /+/; return $rv; } sub url_decode { my $rv = shift; $rv =~ tr/+/ /; $rv =~ s/\%([a-f\d]{2})/ pack 'C', hex $1 /geix; return $rv; }
    But with URL::Encode::XS module installed the code above is very, very slow.
    This bench script can show the speed difference.
    #!/usr/bin/perl #################### # LOAD CORE MODULES #################### use strict; use warnings FATAL => 'all'; # Autoflush ON local $| = 1; use URL::Encode; use Benchmark qw(cmpthese); my $thing = '%&copy; © <> []"\'=?.-_^&*(){}@#!|,;:`~$/\\ 1 + 2 = 3 1 +s sd sds'; my $thing22 = '%25%26copy%3B+%A9+%3C%3E+%5B%5D%22%27%3D%3F.-_%5E%26%2A +%28%29%7B%7D%40%23%21%7C%2C%3B%3A%60~%24%2F%5C+1+%2B+2+%3D+3+++1s+sd+ +sds'; my $num_of_iters = '1000000'; #################### # RUN BENCH #################### print "\n\nBenchmarking $num_of_iters iterations on Perl $] ($^O)\n\n" +; cmpthese( $num_of_iters, { 'MY::Decoder' => sub { url_decode( $thing22 ); }, 'URL::Decode' => sub { URL::Encode::url_decode( $thing22 ); }, 'MY::Encoder' => sub { url_encode( $thing ); }, 'URL::Encode' => sub { URL::Encode::url_encode($thing); }, } ); print "\n"; my $thing2 = URL::Encode::url_encode($thing); print $thing2."\n"; $thing2 = URL::Encode::url_decode($thing2); print $thing2."\n"; print "\n\n"; my $thing3 = url_encode($thing); print $thing3."\n"; $thing3 = url_decode($thing3); print $thing3."\n"; sub url_encode { my $rv = shift; $rv =~ s/([^a-z\d\Q.-_~ \E])/sprintf("%%%2.2X", ord($1))/geix; $rv =~ tr/ /+/; return $rv; } sub url_decode { my $rv = shift; $rv =~ tr/+/ /; $rv =~ s/\%([a-f\d]{2})/ pack 'C', hex $1 /geix; return $rv; }

Win32::SerialPort finally fixed for 64 bit Perl
No replies — Read more | Post response
by kschwab
on Jan 07, 2017 at 19:01

    Some kind soul finally posted a patch that fixes Win32::SerialPort for 64 bit installations of Perl on Windows.

    The patch is here.

    Thought it might be worth noting here...I can't be the only person that's suffered 32 bit perl on Windows for this reason. This has been broken for quite some time.

Perl vs Python revisited
5 direct replies — Read more / Contribute
by QuillMeantTen
on Jan 06, 2017 at 04:08

    edit: I don't know enough to write a web server with the full stack, but a web application. corrected that typo
    Now that I'm through the first semester and have three days to gather my bearings and prepare for the next one I decided to jot down some of my conclusions here.

    When I heard that we would do networking and security related programming in python I was kinda miffed. As some here might now perl was my first scripting language and the fondness that I have for it is in no small part due to the number of libraries and the ease of building new things from them. And of course its wonderful way of handling text analysis.

    After a day of two of brooding I decided to give it a go (really I didn't have any choice, still the teachers quips about me already being old for using perl bothered me quite a bit).
    He did not say perl was useless mind you, he admitted to not having followed it's recent development and being mostly interested in the use of the scapy python library.

    So here I went, full of expectations. I had heard much about python, how it was gentle on the beginner, object oriented and made you write nice code... How wrong I was.

    Yes, you HAVE to indent. After I got to working on a project with someone else who (even after we discussed coding conventions) kept using tabs instead of a set number of spaces, I understood why so many people complained about the rigidity of obligatory indentation. I mean if I wanted to code in whitespace I'd have chosen whitespace. This is not a python problem but rather a programmer's own issues there, it didn't really bother me at any time, thanks to an airtight vimrc.

    Now onto the next issue. Python will make you write nice code. I call bull on this one. Sure you'll have to indent your loops so they work but that won't make you write nice code. I have a hefty slab of absolutely unreadable UI code sitting in a repository on a university server to prove it.

    Interface with other languages: I found doing C code unit testing in python very easy and I hear that calling java or c++ from python isn't that hard either, so that's a very good thing for me.

    To sum it up I'm glad I've learned a bit of python this semester (enough to be able to code web applications, udp/tcp custom servers or simple AI algorithms) because it gave me another point of view on the topic of interpreted languages. I recommend anyone using perl to give python a try just to have that alternative point of view (the same way I'd recommend that any programmer use a functional language at least once just to see how it feels). but in the end? I think that for me perl's TIMTOWTDI approach is best, because it allows me to really express myself. I don't think it's the language's job to make me respect other programmer's work by sticking to discussed APIs and using coding standards. I do so by my own free will and what this semester has proven to me is that another neophyte can be using the exact same constraining language without giving a proverbial flying one about coding standards and end up with a steaming pile of unreadable code. Could have happened with perl too, albeit with a lot more $, @ and other #.

RFC: Test::Refute - extensible unified assertion & testing tool
1 direct reply — Read more / Contribute
by Dallaylaen
on Jan 05, 2017 at 03:28

    I would like to present a new assertion/testing tool project. Now there's excellent Test::More with a whole ecosystem built around it and a dozen assertion tools (typically optimizing themselves out in prod environment) available on CPAN. So WHY?


    1. It's more or less compatible with Test::More. Actually it aims to be 100% compatible condition-wise and somewhat compatible regarding the test flow, sans black magic like TODO: and SKIP:. (Saner substitutes planned).

    2. It has both functional AND object-oriented ("contract") interface. Contracts can be used in production code, say to check user input or plugin module meet requirements. Nesting contracts is possible (that's how subtest is implemented).

    3. It's very easy to extend (see below). A Builder is still required, but all it does is wrapping a given condition around for export AND OO-based usage. The internal check logic does NOT depend on it. Writing a custom Contract backend (e.g. outputting XML, or dying after a certain error count) is also possible.

    4. Built with testability in mind. Custom tests' failure modes can be easily checked.

    5. It's faster. Up to 5x-7x in a synthetic test (see t/speed.t) and up to 30-50% in real life test suite.

    I'd rather continue dreaming about the contract feature, if this rant wasn't the last drop.


    The test script usage is quite simple (read: ripped off Test::More):

    use Test::Refute; is 42, 42, "this holds"; like "foo", qr/bar/, "this fails"; done_testing; # this is mandatory, even if plan declared

    Or the object-oriented interface, runs just happily inside production code (on "oks" on STDOUT, no influence on return code etc):

    use Test::Refute::Contract; my $c = Test::Refute::Contract->new; $c->is($user_input, 42); $c->like($another_input, qr/f?o?r?m?a?t/); if ($c->is_valid) ...

    Or combining best of both worlds:

    use Test::Refute qw(no_init); my $c = contract { is $user_input, 42; like $another_input, qr/f?o?r?m?a?t/; }; # analyze $c here ...

    The project is in deep alpha stage right now, but I hope it evolves into something usable. Looking forward to your support, critique, suggestions, and prior art links.
Leap second coming up. Check your date handling code
5 direct replies — Read more / Contribute
by 1nickt
on Dec 25, 2016 at 16:18

    Hi all,

    A friendly reminder that a leap second will be added to the clock at the end of 2016. If you do date math at all, you may want to check that your date handling code is ready for it.

    For example, versions of DateTime below 1.34 won't handle it correctly:

    $ perl -MDateTime -E 'say $DateTime::VERSION' 1.33 $ perl -MDateTime -E ' my $dt = DateTime->new( time_zone => "UTC", year => 2016, month => 12, day => 31, hour => 23, minute => 59, second => 60 ); say $dt->datetime; $dt->add( months => 1 ); say $dt->datetime; ' Invalid second value (60) at -e line 2.
    $ perl -MDateTime -E 'say $DateTime::VERSION' 1.39 $ perl -MDateTime -E ' my $dt = DateTime->new( time_zone => "UTC", year => 2016, month => 12, day => 31, hour => 23, minute => 59, second => 60 ); say $dt->datetime; $dt->add( months => 1 ); say $dt->datetime; ' 2016-12-31T23:59:60 2017-02-01T00:00:00

    Hope this helps somebody :-)

    The way forward always starts with a minimal test.
RFC: - a perl -e use/new shortener
7 direct replies — Read more / Contribute
by Dallaylaen
on Dec 24, 2016 at 06:20

    I tend to use perl one-liners extensively, mostly for testing purposes. In particular, I often load a module with a loooooooooong name only to instantiate it once. And it's boooooooring to type the whole name twice.

    So I came up with an idea of a one-liner shortener along the lines of:

    perl -we 'use new qw(My::Very::Long::Module x foo 42); print $x->get_f +oo;'
    Which is a rough equivalent of
    perl -we 'use My::Very::Long::Module; our $x = My::Very::Long::Module- +>new( foo => 42 ); print $x->get_foo;'

    And I have a proof-of-concept implementation that works as follows:

    • require module being called;
    • create a new instance;
    • create a package variable in the calling package (so that strict doesn't complain);
    • set that variable to instance from above.

    Here it is.

    package new; use strict; use warnings; =head1 NAME new - shorted require Foo; Foo->new(...) to just one call =head1 SYNOPSYS use new qw(My::Very::Long::Module x foo 42); is an exact equivalent of our $x; BEGIN { require My::Very::Long::Module; $x = My::Very::Long::Module->new( foo => 42 ); }; or a rough equivalent of use My::Very::Long::Module; our $x = My::Very::Long::Module->new( foo => 42 ); Not a big deal in a real program, but may save some typing in a one-liner test script. Works well under C<use strict;>. =cut $Carp::Internal{ (__PACKAGE__) }++; sub import { my ($self, $target, $name, @args) = @_; my $filename = $target; $filename =~ s#::#/#g; $filename .= ".pm"; require $filename; my $obj = $target->new( @args ); my $caller = caller; $name ||= 'new'; my $sym = join "::", $caller, $name; no strict qw(refs vars); *$sym = \$$sym; $$sym = $obj; }; 1;

    Made purely for fun, but maybe there's some point in it after all.

    UPDATE Available as gist.

Add your Meditation
Use:  <p> text here (a paragraph) </p>
and:  <code> code here </code>
to format your post; it's "PerlMonks-approved HTML":

  • Posts are HTML formatted. Put <p> </p> tags around your paragraphs. Put <code> </code> tags around your code and data!
  • Titles consisting of a single word are discouraged, and in most cases are disallowed outright.
  • Read Where should I post X? if you're not absolutely sure you're posting in the right place.
  • Please read these before you post! —
  • Posts may use any of the Perl Monks Approved HTML tags:
    a, abbr, b, big, blockquote, br, caption, center, col, colgroup, dd, del, div, dl, dt, em, font, h1, h2, h3, h4, h5, h6, hr, i, ins, li, ol, p, pre, readmore, small, span, spoiler, strike, strong, sub, sup, table, tbody, td, tfoot, th, thead, tr, tt, u, ul, wbr
  • You may need to use entities for some characters, as follows. (Exception: Within code tags, you can put the characters literally.)
            For:     Use:
    & &amp;
    < &lt;
    > &gt;
    [ &#91;
    ] &#93;
  • Link using PerlMonks shortcuts! What shortcuts can I use for linking?
  • See Writeup Formatting Tips and other pages linked from there for more info.
  • Log In?

    What's my password?
    Create A New User
    and all is quiet...

    How do I use this? | Other CB clients
    Other Users?
    Others lurking in the Monastery: (13)
    As of 2017-02-27 18:50 GMT
    Find Nodes?
      Voting Booth?
      Before electricity was invented, what was the Electric Eel called?

      Results (392 votes). Check out past polls.