There aren't any standards per se, but I think you can find some useful discussions of subroutines at the following links:

1. A question about the best way to use subroutines by scottstef
   To be less than modest, I think my reply to that node was fairly decent.


2. When do you function? by zdog
   The first reply to that link is by tilly and, as usual, is excellent.

Cheers,
Ovid

Join the Perlmonks Setiathome Group or just click on the the link and check out our stats.

• Keep it simple stupid
• Use strict (when writing them)
• Use explicit name (for the sub and the var)
• Document your code
• Make your code readable (it's even better than just documenting)
• Don't document your code TOO much (tilly convinced me on this one...)
• Be efficient (choose the best algo/structures)
• Test your code.
• Make your code upgradable (let you a chance to change any part of the design)
• Make your API clear (a lot of subtle error come from a misunderstood API)
• Subroutines should fit on a screen (old programming practice, but usually good. If it doesn't it should be possible to break into several smaller subs...)

This is what I've done: create a repository, although most of my items are one line fragments and not sub-routines, at present it's got a directory per idiom, but soon it'll be in postgres and fairly cook.

Best practices is a big can of worms, Ideally subroutines should be written like any other code, concisely, legibly etc. Are you asking for details on whether to prototype and such?

I kinda did functions at university in lisp, but in learning the Perl way, I did books, and lo they were good:

• A pretty good book with some generic coding standards is Kernigan and Pikes "Practice of Programming" chapter 2 seperates well-written from beautification.
• "Effective Perl Programming" also has some insights into the matter, highlightig issues with prototypes.
• "Debugging Perl is quite useful on functions, and since reading I've increased my use of return values to return status.
• Damian Conway's "OO Perl" has two blindingly good chapters on what you should already know & what you mightn't already know. There is loads of goodies in there on AUTOLOAD and gifts that can spice up your subroutines ;-)

Now I write functions to be called from a 'jump table' a hash of references to functions, my initial reason for doing this was deprecated when I discovered AUTOLOAD. Other than that I use subs to perfom one overall function and further more low-level functions under that, I like abstraction and subs to be no more than 60 lines ¹.

1. Which is a marked increase from my Lisp days when functions never grew longer than 4 lines.

--