The recent turmoil in Perl's organizational culture, discussed recently here at Perl Monks in:

• Pumpking resignation
• Perl Foundation Community Affairs Team Transparency Report
• Improving p5p: Perl is going to stay Perl
• TPF's Marketing Strategy for the Next Two Years
• Perl questionaire by Gobby
• Why Perl in 2020
• Another resignation, this time from CAT (update)
• Announcing Perl 7 (update)
• The Future of Perl 5 and Recap: The Future of Perl 5 (update)

• ABC podcast - Defence minister Stephen Smith has announced six inquiries into cultural problems within the Australian Defence Force
• Pathway to Change - Evolving Defence Culture - some background on ADF culture
• Blood Lust, Trust and Blame - new book by sociologist Samantha Crompvoets, reportedly paid more than six million dollars to bring about cultural change in the ADF

For therapy, I've decided to follow up my nine-part series on Agile processes in organizations with a new (ten-part :-) series of articles exploring the perplexing multi-disciplinary topic of Organizational Culture. There's certainly no shortage of material, with a mind-boggling number and variety of disciplines in play, such as:

• Sociology
• Sociology of culture
• Sociology of the Internet
• Psychology
• Evolutionary psychology
• Industrial and organizational psychology
• Cross-cultural Psychology
• Culture
• Cultural history
• Cultural evolution
• Anthropology
• Social anthropology
• Cultural anthropology
• Evolution
• Evolutionary game theory
• Biology
• Behavioral neuroscience
• Human resource management
• Leadership

A possible breakdown by topic is:

• Broad Overview of Organizational Culture
• Meta Process: that is, a process to build a process to effectively change Organizational Culture
• Culture variation in different countries
• Software Industry Culture
• Open Source Software Culture
• Perl Culture
• Perl Monks Culture! :)
• Space/Aircraft Industry Culture. As a space nut, I doubt I'll be able to restrain myself from scrutinizing the impact of organizational culture on the Space Shuttle Challenger and Columbia disasters.

Please note that I'm just an interested layman on all these topics, so please correct me when I veer off course. I also welcome your feedback and opinion, along with insights, anecdotes and any useful citations you may know of.

To kick off this series, given that I've just finished reading Sapiens, I thought it'd be fun to speculate on how our early evolutionary history helps explain some of the peculiar and counter-productive behaviour we witness today.

PreHistory

Around 2.5 million years ago, an unremarkable new species appeared in Africa. Now, I doubt these early humans, enduring their daily battle for survival along with many other species, had any inkling back then that they would one day walk on the moon, split the atom, map the genome, calculate the age of the universe ... and compose Perl programs, obfus and poetry.

How on earth did this unremarkable and physically weak new species win this brutal evolutionary war? Sapiens revealed the (surprising to me) secret:

A green monkey can yell to its comrades, "Careful! A lion!". But a modern human can tell her friends that this morning, near the bend in the river, she saw a lion tracking a herd of bison. She can then describe the exact location, including the different paths leading to the area. With this information, the members of her band can put their heads together and discuss whether they should approach the river, chase away the lion, and hunt the bison.

Homo sapiens is primarily a social animal. Social cooperation is our key for survival and reproduction. It is not enough for individual men and women to know the whereabouts of lion and bison. It's much more important for them to know who in their band hates whom, who is sleeping with whom, who is honest, and who is a cheat. ... The most important information that needed to be conveyed was about humans, not lions and bison. Our language evolved as a way of gossiping.

Do you think that history professors chat about the reasons for the First World War when they meet for lunch, or that nuclear physicists spend their coffee breaks at scientific conferences talking about quarks? Sometimes. But more often, they gossip about the professor who caught her husband cheating, or the quarrel between the head of the department and the dean, or the rumours that a colleague used his research funds to buy a Lexus.

Only Homo sapiens can speak about things that don't really exist. You could never convince a monkey to give you a banana by promising him limitless bananas after death in monkey heaven. But why is it so important? Fiction has enabled us not merely to imagine things, but to do so collectively. We can weave common myths. Such myths give Sapiens the unprecedented ability to cooperate flexibly in large numbers.

Ants and bees can also work together in huge numbers, but they do so in a very rigid manner and only with close relatives. Sapiens can cooperate in extremely flexible ways with countless numbers of strangers. That's why Sapiens rule the world, whereas ants eat our leftovers and chimps are locked up in zoos. (Update: so far researchers have failed to locate lawyer bees; bees don't need lawyers because there is no danger that they might forget or violate the hive constitution).

Myths and fictions accustomed people, nearly from the moment of birth, to think in certain ways, to behave in accordance with certain standards, to want certain things, and to observe certain rules. They thereby created artificial instincts that enabled millions of strangers to cooperate effectively. This network of artificial instincts is called culture.

The theory of evolution tells us that instincts, drives and emotions evolve in the sole interest of survival and reproduction ... yet when some of these evolutionary pressures abruptly disappear (due to sudden changes in human culture), these hard-won instincts do not instantly disappear with them ... which explains why today young men drive recklessly and fight in pubs. They are simply following ancient genetic impulses that, though counter productive today, made perfect sense 70,000 years ago, where a young hunter who risked his life chasing a mammoth outshone all his competitors to win the affections of the local beauty. Sadly, those same successful macho genes today give us a mouthful on Perl mailing lists, IRC and Twitter.

With their brain growing (to keep track of the thousands of connections, deceits and subterfuge required for superior gossiping) and their hips narrowing (to facilitate walking upright), evolution favoured early births ... leading to helpless babies ... requiring a tribe to raise them ... favouring those with strong social abilities. Being born immature and with a big brain further allowed humans to be taught more flexibly than any other species -- which explains why we witness today the appalling spectacle of impressionable youngsters being effortlessly led to love Python and hate Perl.

Other Articles in This Series

• Organizational Culture (Part II): Meta Process
• Organizational Culture (Part III): Spaceflight and Aviation
• Organizational Culture (Part IV): Perl Culture
• Organizational Culture (Part V): Behavior
• Organizational Culture (Part VI): Sociology
• Organizational Culture (Part VII): Science

PM References

• Nobody Expects the Agile Imposition (Part I): Meta Process (nine part series on introducing Agile processes into an organization)
• Five Whys
• Working Solo and in a Team
• Conflict in Teams

References Added Later

• Collective behavior (wikipedia)
• Computational social science (wikipedia)
• Social media (wikipedia)
• Complex system (wikipedia)
• Complex adaptive system (wikipedia)

• Cor—An object system for the Perl core by Ovid
• The Corinna RFC for getting modern OO into the Perl core is taking shape by Ovid

Updated: Make Homo sapiens stand out from surrounding text, and with the species name (sapiens) in all lower case, a convention used by biologists, such as erix. 13-June: added bee lawyer joke to quoted Sapiens passage.

I'm old-school, object-oriented programming didn't start to get mainstream until I'd been in the industry 20 years (the roots go back to before my start, of course). And then Perl has a not completely generic approach to objects.

Today I learned, less painfully than I might have, that when I instantiate an object in one program, use Dumper to make it a string, send that to another program, and eval the string, I get an object exactly matching what Dumper saw (I know there are cases where it can't do that, but my situation is simple and that part works). But...the blessed object and the class/package it's associated with don't interlock. So, having forgotten to include that package in the second program, evaling the Dumper string gave me a blessed object (hash, in this case) with all the right members -- but didn't notice that the package was missing, and that therefore all the methods, including accessors, were missing.

Oops!

I didn't take that long to realize what was wrong, even. It's a cleavage line I don't think exists in most other object environments.

No particular point beyond this; I'm not saying this is bad and must be fixed or anything. It's an extra way to screw up (which I exploited :-) ) made possible by the flexibility of Perl's rather ad-hoc approach to objects. "Meditation" is about right; I'm just thinking about this out loud.

I suppose you could make this a slightly harder mistake, but only by making some low-level changes. If a blessed object kept track of whether it was associated with a package of that name, and the information went into the Dumper output, then when the string was evaled, if there was no package of the right name loaded, it could point that out (optional extra parameter to bless, or something?). Huh; my first thought was that it was going to be hopeless, but maybe there are holes in that idea I haven't noticed yet. I wonder if there is code out there that deliberately uses this somehow?

I often have to update Perl and the CPAN dists i use for my projects on many machines at once. Over time i have to come more and more to realize how much of a drag badly written test suits are. In this post, i'll try to formulate this into a somewhat readable list of things that can be improved.

Make your tests as short and fast as possible

Some dists really seems to drag their feet when it comes to running tests. Do you really need to run a gazillion slow tests on every single computer your dist is installed? This wastes the users time.

For example, do you really need to test if 1+1=2? You can assume that Perl did some extensive tests on the basics during its installation, so you don't have to.

Don't run extensive "timeout" tests unless you absolutely have to.

Make more of your tests Author-only tests

Decide which tests only makes sense for you, the author. Prime examples would be tests that check the documentation or running Perl::Critic. Others might be check if your network protocol handler conforms to the specification. Unless part of your code is specific to the system architecture, these tests only need to be run whenever you change the code.

Don't make assumptions about the users network architecture.

Quite a few dists in CPAN make assumption on how the network setup of a users should behave. Don't assume that the user is even allowed or able to access the internet. For the same reason, don't assume DNS resolution is going to get you the expected results, these days many users and companies run filters on Nameservers.

Don't try to access servers you don't personally own or have explicit permission to use

I've seen tests that run against other peoples (or companies) servers. This is generally frowned up on, you are wasting resources of the server owner and quite possibly their money.

Also, your tests might suddenly start to fail. You don't have control over those servers. If their configuration suddenly changes or they go offline, your users might have problems installing your dist.

Accessing certain sites may also be against company policy or even against the law in the country the user resides. Think "news sites" for example. Accessing news sites during work hours might get the user into trouble. Trying to access these sites might even get the user into legal trouble because they are "banned" in the users country.

Don't ask stupid questions while installing

Quite a few dists hold up the installation process to ask stupid questions. This is very annoying, especially if you run the installation on multiple hosts and once and you have to constantly switch through all tabs of your terminal. Just to check if some installation script has put its lazy feet on the table and won't do anything until you press enter.

Like "should i run the network tests over the internet". Answer: "No, you shouldn't" (see above). Provide some Author-tests instead that the user can run if they run into trouble - and document this in the dists "Troubleshooting" section.

Another good example is Template Toolkit. You get the questions "Do you want to build the XS Stash module?" and "Do you want to use the XS Stash by default?". How the f should i know? You are the author and you should know the answer to that better than me. If the author answer is "i don't know", then try to build the module while catching errors as non-fatal. If the module build, run its tests, if those tests work, use it as default.

Don't keep outdated tests and workarounds for external modules

If your dist uses external modules, and you encounter bugs, you will probably check for those bugs and write a workaround. Say the author of that module has since fixed the bug. Instead of keeping slow workarounds and extensive tests for that outdated module around, just require the current version of that external module as your minimum version.

Don't install if your requirements are not fulfilled.

If your dist needs either ACME::Foo or ACME::Foo::PurePerl installed to function properly, don't just print a message and continue. Either fail the installation (not good) or pick one at development time. In this case, picking the PurePerl version might be more reliable. Just printing a message during installation is pretty useless, especially if your dist is getting installed at the same time as a number of other dists. Your message might be on screen for only a fraction of a second.

Don't make the computer unusable during building and testing (unless you have to).

A good example where this is unavoidable is install Tk. It has to pop up many different windows to test this GUI library, which makes working on the computer while the installation is running impossible due to focus stealing. But if at all possible, avoid this.

Be careful when testing floating point numbers

Different systems might handle floating point numbers in slightly different way. Just because 1.0 + 0.05 = 1.05, this might not be true on the users system. It might only be "1.04999999". That is how floating point numbers work on on computers, because they use binary representations of varying length (precision) to work on those internally.

Today is six months since I created an account here in the Monastery...

Seldom have more than a few days passed without me kicking myself that I didn't do so much, much earlier. I have been writing Perl code since the mid-1990's but have learnt more in the last six months than in most of the time before. I managed to get quite a bit of 'stuff' working, mostly web based but also quite a few client tools. Even a handful of GUI tools using Tk. Over the years I has to do some C++ coding as part of my physics degree which I did not get on with and knew I never wanted to revisit... I've had a couple of brushes with Java including recently to create a couple of simple Android apps. But it has always been Perl that has been the language of choice.

When I needed to do something, I found out just enough to make it work. Then didn't go any further. Why would I? I didn't know there was a better way to do things!

A great example was when I posted some code and suddenly found out about placeholders in database queries...I had vaguely heard about the things but thought they were just for reusing one query multiple times. I soon found out they were a lot more useful than that. So useful in fact that all my code is slowly being converted.
Re^5: Splitting the records into multiple worksheets

The Monastery changed all that from almost immediately entering. Straight away I was implored to use strict. Something I knew of but didn't understand. I thought it was a pain and made coding much slower. But I tried using it and, yes, I have to be more careful with my coding but that's no bad thing. Now all my code has use strict at the start. Just today I've refactored a script to include it and had to change 638 lines, mostly adding my to the start!

All my code now uses Template's where appropriate. All thanks to the Monastery. Yes, it was quite a learning curve but has enabled me to refactor an entire website and incorporate AB Testing right into the core. We just create test templates rather than having to duplicate all the code. So much easier to create, test and maintain. Certainly worth the learning curve.

My blind uncle now has automated curtains thanks to Controlling USB on Raspberry Pi which quite possibly would never have been successfully completed without the help of fellow Monks.

Plus, I have published a module on CPAN - Business::Stripe::WebCheckout
Something else that almost certainly would not have happened without the help and encouragement of so many Monks

Thanks for making the last 6 months sch a great period of learning....
Here's to plenty more time. Hopefully, over time I will be able to pass something on to new Monks.

I needed to save the cookies in HTTP::Cookies into Netscape format (aka 'cookies.txt'). Unfortunately I discovered that this functionality is offered by HTTP::Cookies::Netscape alone, which is a subclass of HTTP::Cookies overriding parent-class's load() and save() methods.

However, if one has no control over the creation of the cookie jar (that is, someone has created it and passed it on to us) then it's a bit of a puzzle on how to do that, easily. Actually I did not find a way apart from doing it manually myself by copy-pasting the contents of HTTP::Cookies::Netscape::save() into my own "static" sub which takes in a HTTP::Cookies and saves it in "Netscape" format. But that's a round-about way which also suffers from missing on any patches on the original code.

What I eventually did was to bless the original HTTP::Cookies object into a HTTP::Cookies::Netscape. Call the save() method, which is now different. And when that's done, bless-back to HTTP::Cookies. I just hope this method is as clean as it looks like without side-effects, provided that nobody touches the object in-between its many blessings.

Here is code demostrating the bless/re-bless:

use HTTP::Cookies;
use HTTP::Cookies::Netscape;
use LWP::UserAgent;
my $cookie_jar = HTTP::Cookies->new();
my $browser = LWP::UserAgent->new( );
$browser->cookie_jar( $cookie_jar );
# hit some pages
# now re-bless the cookie jar to obtain ::Netscape functionality
bless $cookie_jar => 'HTTP::Cookies::Netscape';
$cookie_jar->save("mycookies.txt");
# and now re-bless back to original
bless $cookie_jar => 'HTTP::Cookies';
[download]

bw, bliako

It may be interesting to you for reasons other than the one that it's interesting to me; but here's what struck me:

Nothing can rip apart an Open Source project faster than competing
commercial interests playing dirty, and since Varnish has started
to cause serious amounts of money to shift around, it is time to
take this issue a bit more seriously.
[download]

Further on is this, which I really liked:

Fairness pledge:
- ----------------

As the de-facto leader of the Varnish community, I believe that
the success or failure of open source rises and falls with the
community which backs it up.

In general, there is a tacit assumption, that you take something
from the pot and you try put something back in the pot, each to his
own means and abilities.

And the pot has plenty that needs filling:  From answers to newbies
questions, bug-reports, patches, documentation, advocacy, VML funding,
hosting VUG meetings, writing articles for magazines, HOW-TO's for
blogs and so on, so this is no onerous demand for anybody.

But the BSD license allows you to not participate in or contribute
to the community, and there are special times and circumstances
where that is the right thing, or even the only thing you can do,
and I recognize that.

Therefore:

 I will treat everybody, who do not contribute negatively to
 the Varnish community, equally and fairly, and try to foster
 cooperation and justly resolve conflicts to the best of my
 abilities.
[download]

I have no idea if perl can benefit from such a license or pledge (certainly doesn't apply to the scourge of "cancel culture"). And it doesn't find immediate application to the bazaar (and non-BSD) style development, but it's a good read, nonetheless.

Ultimately, what this means to me - and I think to anyone reading this - is that Perl is in desperate need of strong, fair, and righteous leadership. Until this exists, it will continue to be an absolute shitshow and continue to degenerate from within. Those who have been stepping up, thank you. Be fair, just, good, and kind. But most of all, be courageous. You will get the support you need if you decide to exhibit the courageous leadership Perl/perl needs.

The following was also interesting to me:

Today (20190517) Arturs Fastly, company went public on the New York Stock Exchange, and went up from $16 to $24 in a matter of hours. So-called “financial analysts” write that as a consequence Fastly is now worth 2+ Billion Dollars. I can say with 100% certainty and honesty that there is no way I could ever have done that, that is entirely Arturs doing and I know and admire how hard he worked to make it happen. Congratulations to Artur and the Fastly Crew! But I will steal some of Arturs thunder, and point to Fastlys IPO as proof that at least once in my career, I had a unique idea worth a billion dollars :-)

I found my old status reports from work, many moons ago, and I found some gems there, but by far this is the most significant one.

From the 1994 Week 24 status report:

Last week's achievements
========================

- MCPS
  - attended Tiger meeting.
  - attended M.Carlock's Ofc Parm meeting.
  - did LTCINV Table Tiger Team Timings.
  - began learning PERL.
    ^^^^^^^^^^^^^^^^^^^

This week's goals
=================

- MCPS
  - think about the MFA pre-development meeting issues & questions...
  - rewrite my old tools in PERL (for practice).
    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  - harass M.Gyger re Vacation Request.
[download]

The attitude around work is strongly "don't use Perl", in an informal way. It's not an official position, and there's been no talk that I know of about not allowing Perl in the workplace. There are a couple of key scripts that can't be replaced until we move completely into a container-based deployment model. So Perl is officially supported, for now.

That doesn't stop people from putting up style guides for various tools and toolsets in the company, and having a page for Perl that simply says:

Don't use it.
If you have to use it, use strict and use warnings.
But seriously, don't use it.
Use Python.
[download]

It's hard for me to rise above this attitude problem. They've gotten it stuck in their heads that Perl is just a spaghetti has-been language and that Python is "all that".

I do what I can... but we all know that story. I write good Perl, I instruct and inform people of good Perl that I've written that does useful things.

But I have a problem: I identify with Perl. I care about it, because it not only was part of my career identity for 20 years; I LIKE Perl and think it does many things better than other languages.

I'm biased. And it offends me that others are so openly contemptuous.

I need thicker skin. What's the best way to get thicker skin about Perl's unpopularity?

I was having an okay day until I saw this blatant display of contempt and smugness.

The rookie drama

At some point in time, everyone's been a beginner. There's no shame in being one. By contrast, I'd say there's shame in pretending not to be one. These days I was thinking about a matter related not just to learning Perl, but actually related to learning many things.

And just to be clear, I still consider myself a Perl beginner, as even though I started my learning path about 2 years ago, I've only used perl for trivial tasks and for many months didn't touch a single line of Perl code, until last month.

Actually, I'd say I'm proud of being one. The beginning is one of the most enjoyable stages of the learning path (as it should be), if you really take your time to appreciate it. It lessens the burden of having to know some complex details, though it's not to say you don't have the obligation to read docs and do some researching before you ask for help.

I believe the newness of a subject to be motivating (note that I'm referring to newness as "something new to someone", not as "new on itself"). Exploring on something new, that might be helpful (and in the case of Perl, it certainly will) should be enough to get you into learning something.

Why do people hurry?

I must confess that many times I found myself in a hurry to leave this awesome (beginning) stage behind, as I've seen many people doing the same thing. I now believe that to be a mistake. If you don't take your time to enjoy each step in a learning path, then it's like getting to the top of a cards pyramid. Just a wind blow and everything falls apart.

But then I thought to myself: "Why do people do that? Why do people hurry?" Well, I believe I can figure out some of these motivations, as they have crossed my mind many times. I'll be a bit Perl-specific here, but much of these considerations apply to other subjects too.

Fear of being discredited

When you're learning a complex subject such as a programming language, you might feel like much of what you're doing is wrong, simply because you've never had the time to learn how to do proper. That could lead you into thinking: "if someone experienced sees this, I'll become a joke".

You may also feel discouraged to contribute and say things about Perl because then something might be wrong or imprecise and someone could say something like "just stay quiet, you're nothing but a stupid newbie". Though not with these words (and not Perl-related), I've seen people act like that.

Being subject to this is not cool, and that certainly makes you wanna hurry to learn. And that's a bad motivation, because then your primary goal is not to learn, but not being bullied. When learning is secondary, you skip important stuff.

Just a hunch: bullies are probably newbies too. They're just so afraid to admit it, that they act like this. But even when they know what they're talking about, if they're using knowledge to embarass you, then it's shame on them, not you. They're driven by vanity alone and not the desire to help.

You, on the other hand, can always avoid vanity and not let that be an obstacle. If you know upfront that people might mock you (even when you're right) and yet you put your learning or contributing before that, then you'll be fine.

Let's just not confuse bullying with pointing the right direction, as some bad practices should be carefully and helpfully described, so they're not repeated.

Job related considerations

Perl-related jobs still exist, of course, but they've had more popularity in the past. For those who enjoy Perl programming, it may seem like a good idea to convince your boss that you know a lot about it, so that it's incorporated in your workflow.

And that is probably going to fail (miserably). If you want Perl to get some credit where you work, I believe your best chances are showing that it can help getting things done, and yet you don't depend on it.

And please, don't take that last part as an afterthought. The idea of depending on something like Perl is probably terrifying to your boss. Like nightmares-grade terrifying. Saying you're an expert doesn't help, as it may seem like you need to be an expert to get things done.

Now, if your company already uses perl, you might feel tempted to pretend you know more than you do. That's also a mistake, as you might be convincing, in which case you'll be put to face tasks you're not prepared for, or you might not, in which case you could face some (deserved) discredit, or even be fired, so don't do that.

So many nice docs and tutorials

One of the great virtues of Perl is the amount of high-quality documentation available, as well as books, tutorials and specialized blogs. There's so much to read, you may feel like you'll never finish your reading.

And in fact you probably won't. But that souldn't make you hurry. Reading just for the sake of reading is a complete waste of time. You won't learn anything by doing that, so either take your time to read properly, or don't read at all. In other words, hurrying just doesn't work.

Of course, you'll need to be selective. As time is a scarce resource, you need to prioritize what's best and most needed. This is where a community shines. A community (such as PerlMonks) may help curate material that's more appropriate for a beginner. As your learning goes, you'll be more proficient in choosing what's worth your time.

It may seem like shorter tutorials or explanations should be taken first. That's not necessarily so. Often times, taking your time to read a more comprehensive document or book might pay off and help you absorb with more ease the further documentation you come across.

Shorter articles/books might be good if they are concise, but not if they are simplistic, in which case you should just ignore them. Again, with the help of a community it might be easier to choose what's worth your time.

In that regard, I can say the tutorials here in PerlMonks greatly helped me. For instance, I've been doing some review on context and scoping rules, and found great articles on that. These are foundational concepts in Perl and having a good explanation on them has been very helpful. The same goes for many other concepts.

Now, even avoiding useless stuff, you'll most likely miss a lot of good reading too. It's just too much for not so much time. Not being able to read today something you really want to is frustrating, but there's always tomorrow. Here's where you exercise your patience.

The power of a community

As I've mentioned, a community helps a lot in curating your studying materials, but not only that. A community also may encourage you to keep improving yourself, giving feedback, proposing new challenges, and actually merely talking about a subject helps you keep motivated.

So, this is what brought me to PerlMonks. Much is said about CPAN being one of the greatest features of Perl, and certainly I agree, but I also believe PerlMonks is a feature many other languages lack.

In fact, CPAN itself is a community effort, and I believe that's one of the reasons it's so much appreciated by perl users. Of course, it wouldn't do much good if it didn't help us get things done, but the community thing is core to CPAN's existence.

Getting help from a community may be rewarding, but, at least for me, giving back is even more rewarding. Even when it's a very small contribution. We have limitations after all, but we can always do something.

Some things just take time

No matter how hard you try, some things take time. Accepting this fact may be liberating. Again, each step in a learning path should be properly appreciated. The beginning should be the most exciting part of the process, and here's good news: each step is a new beginning.

There's too much hype on being an expert on anything. Becoming an expert should be considered a good thing, of course. But what happens when it's so much desired and beginning is so underappreciated? You try to hurry (and gets frustrated, as it doesn't work).

Aside from that, there are too many "fake experts" out there. People who, as I said, are driven by vanity (and lazyness too). When you act like that you may fool some unwary people sometimes, but don't fall for it, you'll be unmasked sooner or later.

You shouldn't hurry, but if you do, make sure that learning is your primary goal, and not something else. In fact, I believe some other languages are far more popular than Perl just because they have much more immediate pressing concerns involved, that have nothing to do with learning.

And remember, this piece of advice comes from a beginner. As such, I know there's people out there who could say a lot more on this subject. Yet, that didn't prevent me from trying to contribute. For me, that's the spirit in a community. And you don't have to take my word for it, but if you came to the end of this post, then I believe you're at least willing to try.

I needed to use flock and found the docs confusing and the demo code slightly dangerous ( lock is another builtin for threading)

So I hacked a demo script, where only one instance will count from 1 to 10 when simultaneously running.

On windows you can start 4 simultanous instances from CMD with

> start perl demo_lock.pl & start perl demo_lock.pl & start perl demo_
+lock.pl & perl demo_lock.pl
[download]

The first three scripts will pop up in separate windows which you could/should arrange to be visible.

Have fun! :)

Having needed to implement a simple workflow for taking card payments by Stripe and knowing that I need to do the same again soon for a different product set, I have created a module that I think will be useful to other people. Existing modules to connect with Stripe either do not cater for the latest security measures of 3D card payments in Europe or are a wrapper for the Stripe API. Both of which are, of course useful. But I wanted to create something easy to use that can be used for the typical simple workflow required by many small businesses.

This gives a simple workflow of adding products to a 'Trolley' and then sending the user directly to the Stripe hosted checkout. From there, Stripe returns to either a success URL if payment was taken successfully or a cancel URL if, for any reason, the transaction failed.

Could you please provide me with some feedback regarding both the code and the POD ahead of uploading it to CPAN?

I was thinking Business::Stripe::Simple as the module name - is that sensible?

Note - at the moment, the examples in the documentation have not been tested. They will be before uploading!

Thank you to the Monks who have helped me develop the skills to get the module this far and to the ones who will give useful feedback.
It is very much appreciated.

UPDATE:
I have run the code through Perl::Critic and it passes at 'stern' but generates warnings at 'harsh'. One thing it has found are tab characters instead of spaces despite changing my editor to use spaces after this discussion. I will take out the tabs that have crept in from copying and pasting a few bits of code.

On the suggestion of Critic, I have moved the declaration of $VERSION to after use strict;. Although I thought that had to be first for the CPAN toolchain?

Recently, P5P is arguing about the future development of Perl. As a long-term user of Perl (but not a core developer), I also have some ideas of my own.

The first and most important question is, what are Perl's real capabilities / advantages? sigil？ Regexp? On some degree, yes, but not exactly. Perl's real power lies in its expressive power and self-evolvement. Language is language, and computer language is also a kind of language (although many people don't realize it now). The purpose of language is to communicate and express what they want to express. At the beginning of Perl language, Larry learned from many excellent functions of the language, so it can let people express what they want quickly accurately, which is the real reason why Perl stands on the river. So I conclude below by learning history of other languages(including human languages):

1. When the language can't deliver what it wants to deliver quickly, there will be fewer and fewer users stay there, such as COBOL, lisp, Latin (human language), even if they have many bright spots.
2. Without users, the language will die. In history, many languages have died out, they may have many advantages and characteristics, but now these characteristics may exist in other languages, but they themselves have died out.
3. The language needs to quickly implement the features it needs, not whether it is elegant or not. Think about Japanese, Chinese, and even English. In the long history, they constantly learn from other languages to implement some new concepts. These implementation may conflict with their own, but it doesn't matter. As long as they can quickly accurately deliver these new concepts to achieve the purpose of communication, the language will not die. Languages that have been slow to implement new functions for the sake of elegant implementation (or because of lack of manpower) have all died out.

Let's go back and see how Perl should do? In recent years, Perl supporters have said that the advantage of Perl is CPAN (stand on the shoulder of cpan). what does it really mean? It means that Perl also has all the functions and libraries which other languages have(though there is maybe not in Perl itself)

1. More and more modules on cpan are not available, and even many authors give up their own modules because they want to adapt to new changes
2. Because XS and its toolchain are too specific to C language and Perl, it is difficult for people who are not familiar with Perl to develop interface libraries. Think about UV, such a popular library needs people like PEVANS to maintain.
3. Due to the lack of new functions or new libraries, Perl has fewer new users, such as GUI and parallel programming. This is a vicious cycle. Due to the lack of language functions and the complexity of language level, fewer and fewer people use Perl. Therefore, there are fewer and fewer heavyweight modules in cpan, resulting in fewer and fewer people using Perl. It should be understood that the difficulty of learning the language itself is never the first thing for users, but the function is. As long as you have the features users want, no matter how difficult, they will learn.

To sum up, I suggest that the core developers of Perl should be able to focus on (of course, this is only my personal wish) redesigning and implementing a language layer for communication with other languages. The current XS and its toolchain are too limited to C and obscure which makes it difficult for the user to develop such an interface.

In addition, the layer between languages should not be limited to compiled languages, but also include virtual machine languages and other specifications(consider how many ppl on windows use Win32::OLE). Because we are short of developers, when a new popular application or library appears in other languages, it may be difficult for us to have the corresponding Perl version very quickly. If there is a convenient way to establish a conversion layer at this time, so that Perl users can stay in the Perl world happily, I think it is great incentive for the use of Perl! FFI:: Platypus does very well. I hope it can enter the official package when it's mature. but I also want it could be more ambitious. to introduce more virtual machine languages, including C sharp, node.js , GO, etc. Inline:: XX may also be a direction, but it seems too duplicated to need to write its parsers for each language.

Of course, in the long run, of course, P5P can slowly polish the Perl language itself, maybe including type system, object system, better regexp, concurrency programming, etc. but it should be noted that language and its new features need to be learned by users. First of all, users should stay in Perl, without users, language and its features can not prove whether they are useful or not.

UPDATE:

Thanks for Discipulus, GrandFather pointing out my various English mistakes. ;)

Hi, folks.

Recently I've found (here in PerlMonks) a link to one of Donald Knuth's great talks: Computer Programming as an Art. Knowing it was Knuth's sutff, I knew it would be worth my time.

One of the (often overlooked) benefits of computer programming is that it can be fun. But Knuth goes beyond that stating that it should be fun and that a program should be beautiful. Fun and beauty add a lot of value to the program and to programming.

Now, at the same time, observing the IT industry as whole, we can see how much the fun and beauty of programming are being overlooked. More and more "magic tools" are making way to sysadmin jobs, and they're focused on people who don't want to program. IT managers often see them as a means "not to depend too much on programmers". It's laughable, but I've seen it a lot.

One example of such tools are the configuration management tools, such as Ansible, Puppet, Chef and similar tools, which take a more declarative approach to systems management. I'm not saying these tools aren't useful (or even that they are necessarily bad), but I feel like they've taken a lot of the fun away from systems management.

This is not to mention GUI-only tools, which are mostly closed-source. Fortunately I've been far from them. But currently at my job, I help maintain some Ansible routines, and sometimes it's a daunting task. I can't remember how many times I had to grep a repository to find out when some variable was being set. If a declarative approach should be friendly, then I must say it has failed in my case, because the repository I work with has grown into a messy beast (I'm sure my co-workers agree).

Yet, I remember once I've put a perl one-line command in a playbook and was critized precisely for this action. I was told it would bring complexity and that other people would have difficulty maintaining perl code. Can you believe it? A one-line! I'd say it's a joke if someone else told me.

Of course, I wouldn't give up on Perl because of that. But it makes me wonder why must we always prove something that exists for decades is worthy a try, while something created a few years ago is promptly accepted. Of course, it's just my point of view, which not necessarily happens everywhere. Other points of view would be much appreciated.

Over on Re: How Xerces validation access http schemas ?, hippo wrote "It's worth noting that the most recent versions of XML::Validate and XML::Xerces are from 15 years ago and may not play so well with modern systems". This immediately reminded me of a recent search for modules to connect with PayPal where I found Business::PayPal::IPN but didn't look any further than the date which is AUG 19, 2003.

Clearly for things that connect to frequently evolving APIs, being quite up to date is pretty important unless the API allows use of a particular past version. But for things that don't change much, like XML, the need for recent updates is less apparent. As hippo puts it, they need to "play well with modern systems".

So, when deciding whether to use a module, or anything else for that matter, how old is too old?