This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
FAQ sync.
[perl5.git] / pod / perlfaq3.pod
1 =head1 NAME
2
3 perlfaq3 - Programming Tools ($Revision: 1.13 $, $Date: 2002/02/08 22:32:47 $)
4
5 =head1 DESCRIPTION
6
7 This section of the FAQ answers questions related to programmer tools
8 and programming support.
9
10 =head2 How do I do (anything)?
11
12 Have you looked at CPAN (see L<perlfaq2>)?  The chances are that
13 someone has already written a module that can solve your problem.
14 Have you read the appropriate manpages?  Here's a brief index:
15
16         Basics          perldata, perlvar, perlsyn, perlop, perlsub
17         Execution       perlrun, perldebug
18         Functions       perlfunc
19         Objects         perlref, perlmod, perlobj, perltie
20         Data Structures perlref, perllol, perldsc
21         Modules         perlmod, perlmodlib, perlsub
22         Regexes         perlre, perlfunc, perlop, perllocale
23         Moving to perl5 perltrap, perl
24         Linking w/C     perlxstut, perlxs, perlcall, perlguts, perlembed
25         Various         http://www.cpan.org/misc/olddoc/FMTEYEWTK.tgz
26                         (not a man-page but still useful, a collection
27                          of various essays on Perl techniques)
28
29 A crude table of contents for the Perl manpage set is found in L<perltoc>.
30
31 =head2 How can I use Perl interactively?
32
33 The typical approach uses the Perl debugger, described in the
34 perldebug(1) manpage, on an ``empty'' program, like this:
35
36     perl -de 42
37
38 Now just type in any legal Perl code, and it will be immediately
39 evaluated.  You can also examine the symbol table, get stack
40 backtraces, check variable values, set breakpoints, and other
41 operations typically found in symbolic debuggers.
42
43 =head2 Is there a Perl shell?
44
45 In general, not yet.  There is psh available at
46
47     http://www.focusresearch.com/gregor/psh
48
49 Which includes the following description:
50
51     The Perl Shell is a shell that combines the interactive nature
52     of a Unix shell with the power of Perl. The goal is to eventually
53     have a full featured shell that behaves as expected for normal
54     shell activity. But, the Perl Shell will use Perl syntax and
55     functionality for control-flow statements and other things.
56
57 The Shell.pm module (distributed with Perl) makes Perl try commands
58 which aren't part of the Perl language as shell commands.  perlsh
59 from the source distribution is simplistic and uninteresting, but
60 may still be what you want.
61
62 =head2 How do I debug my Perl programs?
63
64 Have you tried C<use warnings> or used C<-w>?  They enable warnings 
65 to detect dubious practices.
66
67 Have you tried C<use strict>?  It prevents you from using symbolic
68 references, makes you predeclare any subroutines that you call as bare
69 words, and (probably most importantly) forces you to predeclare your
70 variables with C<my>, C<our>, or C<use vars>.
71
72 Did you check the return values of each and every system call?  The operating
73 system (and thus Perl) tells you whether they worked, and if not
74 why.
75
76   open(FH, "> /etc/cantwrite")
77     or die "Couldn't write to /etc/cantwrite: $!\n";
78
79 Did you read L<perltrap>?  It's full of gotchas for old and new Perl
80 programmers and even has sections for those of you who are upgrading
81 from languages like I<awk> and I<C>.
82
83 Have you tried the Perl debugger, described in L<perldebug>?  You can
84 step through your program and see what it's doing and thus work out
85 why what it's doing isn't what it should be doing.
86
87 =head2 How do I profile my Perl programs?
88
89 You should get the Devel::DProf module from the standard distribution
90 (or separately on CPAN) and also use Benchmark.pm from the standard 
91 distribution.  The Benchmark module lets you time specific portions of 
92 your code, while Devel::DProf gives detailed breakdowns of where your 
93 code spends its time.
94
95 Here's a sample use of Benchmark:
96
97   use Benchmark;
98
99   @junk = `cat /etc/motd`;
100   $count = 10_000;
101
102   timethese($count, {
103             'map' => sub { my @a = @junk;
104                            map { s/a/b/ } @a;
105                            return @a
106                          },
107             'for' => sub { my @a = @junk;
108                            local $_;
109                            for (@a) { s/a/b/ };
110                            return @a },
111            });
112
113 This is what it prints (on one machine--your results will be dependent
114 on your hardware, operating system, and the load on your machine):
115
116   Benchmark: timing 10000 iterations of for, map...
117          for:  4 secs ( 3.97 usr  0.01 sys =  3.98 cpu)
118          map:  6 secs ( 4.97 usr  0.00 sys =  4.97 cpu)
119
120 Be aware that a good benchmark is very hard to write.  It only tests the
121 data you give it and proves little about the differing complexities
122 of contrasting algorithms.
123
124 =head2 How do I cross-reference my Perl programs?
125
126 The B::Xref module can be used to generate cross-reference reports 
127 for Perl programs.
128
129     perl -MO=Xref[,OPTIONS] scriptname.plx
130
131 =head2 Is there a pretty-printer (formatter) for Perl?
132
133 Perltidy is a Perl script which indents and reformats Perl scripts
134 to make them easier to read by trying to follow the rules of the
135 L<perlstyle>. If you write Perl scripts, or spend much time reading
136 them, you will probably find it useful.  It is available at
137 http://perltidy.sourceforge.net
138
139 Of course, if you simply follow the guidelines in L<perlstyle>,
140 you shouldn't need to reformat.  The habit of formatting your code
141 as you write it will help prevent bugs.  Your editor can and should
142 help you with this.  The perl-mode or newer cperl-mode for emacs
143 can provide remarkable amounts of help with most (but not all)
144 code, and even less programmable editors can provide significant
145 assistance.  Tom Christiansen and many other VI users  swear by
146 the following settings in vi and its clones:
147
148     set ai sw=4
149     map! ^O {^M}^[O^T
150
151 Put that in your F<.exrc> file (replacing the caret characters
152 with control characters) and away you go.  In insert mode, ^T is
153 for indenting, ^D is for undenting, and ^O is for blockdenting--
154 as it were.  A more complete example, with comments, can be found at
155 http://www.cpan.org/authors/id/TOMC/scripts/toms.exrc.gz
156
157 The a2ps http://www-inf.enst.fr/%7Edemaille/a2ps/black+white.ps does
158 lots of things related to generating nicely printed output of
159 documents, as does enscript at http://people.ssh.fi/mtr/genscript/.
160
161 =head2 Is there a ctags for Perl?
162
163 Recent versions of ctags do much more than older versions did.
164 EXUBERANT CTAGS is available from http://ctags.sourceforge.net/
165 and does a good job of making tags files for perl code.
166
167 There is also a simple one at
168 http://www.cpan.org/authors/id/TOMC/scripts/ptags.gz which may do
169 the trick.  It can be easy to hack this into what you want.
170
171 =head2 Is there an IDE or Windows Perl Editor?
172
173 Perl programs are just plain text, so any editor will do.
174
175 If you're on Unix, you already have an IDE--Unix itself.  The UNIX
176 philosophy is the philosophy of several small tools that each do one
177 thing and do it well.  It's like a carpenter's toolbox.
178
179 If you want an IDE, check the following:
180
181 =over 4
182
183 =item Komodo
184
185 ActiveState's cross-platform (as of April 2001 Windows and Linux),
186 multi-language IDE has Perl support, including a regular expression
187 debugger and remote debugging
188 (http://www.ActiveState.com/Products/Komodo/index.html).  (Visual
189 Perl, a Visual Studio.NET plug-in is currently (early 2001) in beta
190 (http://www.ActiveState.com/Products/VisualPerl/index.html)).
191
192 =item The Object System
193
194 (http://www.castlelink.co.uk/object_system/) is a Perl web
195 applications development IDE, apparently for any platform
196 that runs Perl.
197
198 =item Open Perl IDE
199
200 ( http://open-perl-ide.sourceforge.net/ )
201 Open Perl IDE is an integrated development environment for writing
202 and debugging Perl scripts with ActiveState's ActivePerl distribution
203 under Windows 95/98/NT/2000.
204
205 =item PerlBuilder
206
207 (http://www.solutionsoft.com/perl.htm) is an integrated development
208 environment for Windows that supports Perl development.
209
210 =item visiPerl+
211
212 ( http://helpconsulting.net/visiperl/ )
213 From Help Consulting, for Windows.
214
215 =back
216
217 For Windows there's also the
218
219 =over 4
220
221 =item CodeMagicCD
222
223 ( http://www.codemagiccd.com/ ) Collection of various programming
224 tools for Windows: Perl (5.005_03), TclTk, Python, GNU programming
225 tools, REBOL, wxWindows toolkit, the MinGW GNU C/C++ compiler, DJGPP
226 GNU C/C++ compiler, Cint C interpreter, YaBasic.
227
228 =back
229
230 For editors: if you're on Unix you probably have vi or a vi clone already,
231 and possibly an emacs too, so you may not need to download anything.
232 In any emacs the cperl-mode (M-x cperl-mode) gives you perhaps the
233 best available Perl editing mode in any editor.
234
235 If you are using Windows, you can use any editor that lets
236 you work with plain text, such as NotePad or WordPad.  Word
237 processors, such as Microsoft Word or WordPerfect, typically
238 do not work since they insert all sorts of behind-the-scenes
239 information, although some allow you to save files as "Text
240 Only". You can also download text editors designed
241 specifically for programming, such as Textpad
242 (http://www.textpad.com/) and UltraEdit
243 (http://www.ultraedit.com), among others.
244
245 If you are using MacOS, the same concerns apply.  MacPerl
246 (for Classic environments) comes with a simple editor.
247 Popular external editors are BBEdit (http://www.bbedit.com)
248 or Alpha (http://alpha.olm.net/). MacOS X users can use Unix
249 editors as well.
250
251 =over 4
252
253 =item GNU Emacs
254
255 http://www.gnu.org/software/emacs/windows/ntemacs.html
256
257 =item MicroEMACS
258
259 http://members.nbci.com/uemacs/
260
261 =item XEmacs
262
263 http://www.xemacs.org/Download/index.html
264
265 =back
266
267 or a vi clone such as
268
269 =over 4
270
271 =item Elvis
272
273 ftp://ftp.cs.pdx.edu/pub/elvis/ http://www.fh-wedel.de/elvis/
274
275 =item Vile
276
277 http://vile.cx/
278
279 =item Vim
280
281 http://www.vim.org/
282
283 win32: http://www.cs.vu.nl/%7Etmgil/vi.html
284
285 =back
286
287 For vi lovers in general, Windows or elsewhere:
288 http://www.thomer.com/thomer/vi/vi.html.
289
290 nvi (http://www.bostic.com/vi/, available from CPAN in src/misc/) is
291 yet another vi clone, unfortunately not available for Windows, but in
292 UNIX platforms you might be interested in trying it out, firstly because
293 strictly speaking it is not a vi clone, it is the real vi, or the new
294 incarnation of it, and secondly because you can embed Perl inside it
295 to use Perl as the scripting language.  nvi is not alone in this,
296 though: at least also vim and vile offer an embedded Perl.
297
298 The following are Win32 multilanguage editor/IDESs that support Perl:
299
300 =over 4
301
302 =item Codewright
303
304 http://www.starbase.com/
305
306 =item MultiEdit
307
308 http://www.MultiEdit.com/
309
310 =item SlickEdit
311
312 http://www.slickedit.com/
313
314 =back
315
316 There is also a toyedit Text widget based editor written in Perl
317 that is distributed with the Tk module on CPAN.  The ptkdb
318 (http://world.std.com/~aep/ptkdb/) is a Perl/tk based debugger that
319 acts as a development environment of sorts.  Perl Composer
320 (http://perlcomposer.sourceforge.net/vperl.html) is an IDE for Perl/Tk
321 GUI creation.
322
323 In addition to an editor/IDE you might be interested in a more
324 powerful shell environment for Win32.  Your options include
325
326 =over 4
327
328 =item Bash
329
330 from the Cygwin package (http://sources.redhat.com/cygwin/)
331
332 =item Ksh
333
334 from the MKS Toolkit (http://www.mks.com/), or the Bourne shell of
335 the U/WIN environment (http://www.research.att.com/sw/tools/uwin/)
336
337 =item Tcsh
338
339 ftp://ftp.astron.com/pub/tcsh/, see also
340 http://www.primate.wisc.edu/software/csh-tcsh-book/
341
342 =item Zsh
343
344 ftp://ftp.blarg.net/users/amol/zsh/, see also http://www.zsh.org/
345
346 =back
347
348 MKS and U/WIN are commercial (U/WIN is free for educational and
349 research purposes), Cygwin is covered by the GNU Public License (but
350 that shouldn't matter for Perl use).  The Cygwin, MKS, and U/WIN all
351 contain (in addition to the shells) a comprehensive set of standard
352 UNIX toolkit utilities.
353
354 If you're transferring text files between Unix and Windows using FTP
355 be sure to transfer them in ASCII mode so the ends of lines are
356 appropriately converted.
357
358 On Mac OS the MacPerl Application comes with a simple 32k text editor
359 that behaves like a rudimentary IDE.  In contrast to the MacPerl Application
360 the MPW Perl tool can make use of the MPW Shell itself as an editor (with
361 no 32k limit).
362
363 =over 4
364
365 =item BBEdit and BBEdit Lite
366
367 are text editors for Mac OS that have a Perl sensitivity mode
368 (http://web.barebones.com/).
369
370 =item Alpha
371
372 is an editor, written and extensible in Tcl, that nonetheless has
373 built in support for several popular markup and programming languages
374 including Perl and HTML (http://alpha.olm.net/).
375
376 =back
377
378 Pepper and Pe are programming language sensitive text editors for Mac
379 OS X and BeOS respectively (http://www.hekkelman.com/).
380
381 =head2 Where can I get Perl macros for vi?
382
383 For a complete version of Tom Christiansen's vi configuration file,
384 see http://www.cpan.org/authors/Tom_Christiansen/scripts/toms.exrc.gz ,
385 the standard benchmark file for vi emulators.  The file runs best with nvi,
386 the current version of vi out of Berkeley, which incidentally can be built
387 with an embedded Perl interpreter--see http://www.cpan.org/src/misc.
388
389 =head2 Where can I get perl-mode for emacs?
390
391 Since Emacs version 19 patchlevel 22 or so, there have been both a
392 perl-mode.el and support for the Perl debugger built in.  These should
393 come with the standard Emacs 19 distribution.
394
395 In the Perl source directory, you'll find a directory called "emacs",
396 which contains a cperl-mode that color-codes keywords, provides
397 context-sensitive help, and other nifty things.
398
399 Note that the perl-mode of emacs will have fits with C<"main'foo">
400 (single quote), and mess up the indentation and highlighting.  You
401 are probably using C<"main::foo"> in new Perl code anyway, so this
402 shouldn't be an issue.
403
404 =head2 How can I use curses with Perl?
405
406 The Curses module from CPAN provides a dynamically loadable object
407 module interface to a curses library.  A small demo can be found at the
408 directory http://www.cpan.org/authors/Tom_Christiansen/scripts/rep;
409 this program repeats a command and updates the screen as needed, rendering
410 B<rep ps axu> similar to B<top>.
411
412 =head2 How can I use X or Tk with Perl?
413
414 Tk is a completely Perl-based, object-oriented interface to the Tk toolkit
415 that doesn't force you to use Tcl just to get at Tk.  Sx is an interface
416 to the Athena Widget set.  Both are available from CPAN.  See the
417 directory http://www.cpan.org/modules/by-category/08_User_Interfaces/
418
419 Invaluable for Perl/Tk programming are the Perl/Tk FAQ at
420 http://w4.lns.cornell.edu/%7Epvhp/ptk/ptkTOC.html , the Perl/Tk Reference
421 Guide available at
422 http://www.cpan.org/authors/Stephen_O_Lidie/ , and the
423 online manpages at
424 http://www-users.cs.umn.edu/%7Eamundson/perl/perltk/toc.html .
425
426 =head2 How can I generate simple menus without using CGI or Tk?
427
428 The http://www.cpan.org/authors/id/SKUNZ/perlmenu.v4.0.tar.gz
429 module, which is curses-based, can help with this.
430
431 =head2 How can I make my Perl program run faster?
432
433 The best way to do this is to come up with a better algorithm.  This
434 can often make a dramatic difference.  Jon Bentley's book
435 ``Programming Pearls'' (that's not a misspelling!)  has some good tips
436 on optimization, too.  Advice on benchmarking boils down to: benchmark
437 and profile to make sure you're optimizing the right part, look for
438 better algorithms instead of microtuning your code, and when all else
439 fails consider just buying faster hardware.  You will probably want to
440 read the answer to the earlier question ``How do I profile my Perl programs?''
441 if you haven't done so already.
442
443 A different approach is to autoload seldom-used Perl code.  See the
444 AutoSplit and AutoLoader modules in the standard distribution for
445 that.  Or you could locate the bottleneck and think about writing just
446 that part in C, the way we used to take bottlenecks in C code and
447 write them in assembler.  Similar to rewriting in C,
448 modules that have critical sections can be written in C (for instance, the
449 PDL module from CPAN).
450
451 In some cases, it may be worth it to use the backend compiler to
452 produce byte code (saving compilation time) or compile into C, which
453 will certainly save compilation time and sometimes a small amount (but
454 not much) execution time.  See the question about compiling your Perl
455 programs for more on the compiler--the wins aren't as obvious as you'd
456 hope.
457
458 If you're currently linking your perl executable to a shared I<libc.so>,
459 you can often gain a 10-25% performance benefit by rebuilding it to
460 link with a static libc.a instead.  This will make a bigger perl
461 executable, but your Perl programs (and programmers) may thank you for
462 it.  See the F<INSTALL> file in the source distribution for more
463 information.
464
465 Unsubstantiated reports allege that Perl interpreters that use sfio
466 outperform those that don't (for I/O intensive applications).  To try
467 this, see the F<INSTALL> file in the source distribution, especially
468 the ``Selecting File I/O mechanisms'' section.
469
470 The undump program was an old attempt to speed up your Perl program
471 by storing the already-compiled form to disk.  This is no longer
472 a viable option, as it only worked on a few architectures, and
473 wasn't a good solution anyway.
474
475 =head2 How can I make my Perl program take less memory?
476
477 When it comes to time-space tradeoffs, Perl nearly always prefers to
478 throw memory at a problem.  Scalars in Perl use more memory than
479 strings in C, arrays take more than that, and hashes use even more.  While
480 there's still a lot to be done, recent releases have been addressing
481 these issues.  For example, as of 5.004, duplicate hash keys are
482 shared amongst all hashes using them, so require no reallocation.
483
484 In some cases, using substr() or vec() to simulate arrays can be
485 highly beneficial.  For example, an array of a thousand booleans will
486 take at least 20,000 bytes of space, but it can be turned into one
487 125-byte bit vector--a considerable memory savings.  The standard
488 Tie::SubstrHash module can also help for certain types of data
489 structure.  If you're working with specialist data structures
490 (matrices, for instance) modules that implement these in C may use
491 less memory than equivalent Perl modules.
492
493 Another thing to try is learning whether your Perl was compiled with
494 the system malloc or with Perl's builtin malloc.  Whichever one it
495 is, try using the other one and see whether this makes a difference.
496 Information about malloc is in the F<INSTALL> file in the source
497 distribution.  You can find out whether you are using perl's malloc by
498 typing C<perl -V:usemymalloc>.
499
500 Of course, the best way to save memory is to not do anything to waste
501 it in the first place. Good programming practices can go a long way
502 toward this:
503
504 =over 4
505
506 =item * Don't slurp!
507
508 Don't read an entire file into memory if you can process it line
509 by line. Or more concretely, use a loop like this:
510
511         #
512         # Good Idea
513         #
514         while (<FILE>) {
515            # ...
516         }
517
518 instead of this:
519
520         #
521         # Bad Idea
522         #
523         @data = <FILE>;
524         foreach (@data) {
525             # ...
526         }
527
528 When the files you're processing are small, it doesn't much matter which
529 way you do it, but it makes a huge difference when they start getting
530 larger. 
531
532 =item * Use map and grep selectively
533
534 Remember that both map and grep expect a LIST argument, so doing this:
535
536         @wanted = grep {/pattern/} <FILE>;
537
538 will cause the entire file to be slurped. For large files, it's better
539 to loop:
540
541         while (<FILE>) {
542                 push(@wanted, $_) if /pattern/;
543         }
544
545 =item * Avoid unnecessary quotes and stringification
546
547 Don't quote large strings unless absolutely necessary:
548
549         my $copy = "$large_string";
550
551 makes 2 copies of $large_string (one for $copy and another for the
552 quotes), whereas
553
554         my $copy = $large_string;
555
556 only makes one copy.
557
558 Ditto for stringifying large arrays:
559
560         {
561                 local $, = "\n";
562                 print @big_array;
563         }
564
565 is much more memory-efficient than either
566
567         print join "\n", @big_array;
568
569 or
570
571         {
572                 local $" = "\n";
573                 print "@big_array";
574         }
575
576
577 =item * Pass by reference
578
579 Pass arrays and hashes by reference, not by value. For one thing, it's
580 the only way to pass multiple lists or hashes (or both) in a single
581 call/return. It also avoids creating a copy of all the contents. This
582 requires some judgment, however, because any changes will be propagated
583 back to the original data. If you really want to mangle (er, modify) a
584 copy, you'll have to sacrifice the memory needed to make one.
585
586 =item * Tie large variables to disk.
587
588 For "big" data stores (i.e. ones that exceed available memory) consider
589 using one of the DB modules to store it on disk instead of in RAM. This
590 will incur a penalty in access time, but that's probably better that
591 causing your hard disk to thrash due to massive swapping.
592
593 =back
594
595 =head2 Is it unsafe to return a pointer to local data?
596
597 No, Perl's garbage collection system takes care of this.
598
599     sub makeone {
600         my @a = ( 1 .. 10 );
601         return \@a;
602     }
603
604     for $i ( 1 .. 10 ) {
605         push @many, makeone();
606     }
607
608     print $many[4][5], "\n";
609
610     print "@many\n";
611
612 =head2 How can I free an array or hash so my program shrinks?
613
614 You can't.  On most operating systems, memory allocated to a program
615 can never be returned to the system.  That's why long-running programs
616 sometimes re-exec themselves.  Some operating systems (notably,
617 FreeBSD and Linux) allegedly reclaim large chunks of memory that is no
618 longer used, but it doesn't appear to happen with Perl (yet).  The Mac
619 appears to be the only platform that will reliably (albeit, slowly)
620 return memory to the OS.
621
622 We've had reports that on Linux (Redhat 5.1) on Intel, C<undef
623 $scalar> will return memory to the system, while on Solaris 2.6 it
624 won't.  In general, try it yourself and see.
625
626 However, judicious use of my() on your variables will help make sure
627 that they go out of scope so that Perl can free up that space for
628 use in other parts of your program.  A global variable, of course, never
629 goes out of scope, so you can't get its space automatically reclaimed,
630 although undef()ing and/or delete()ing it will achieve the same effect.
631 In general, memory allocation and de-allocation isn't something you can
632 or should be worrying about much in Perl, but even this capability
633 (preallocation of data types) is in the works.
634
635 =head2 How can I make my CGI script more efficient?
636
637 Beyond the normal measures described to make general Perl programs
638 faster or smaller, a CGI program has additional issues.  It may be run
639 several times per second.  Given that each time it runs it will need
640 to be re-compiled and will often allocate a megabyte or more of system
641 memory, this can be a killer.  Compiling into C B<isn't going to help
642 you> because the process start-up overhead is where the bottleneck is.
643
644 There are two popular ways to avoid this overhead.  One solution
645 involves running the Apache HTTP server (available from
646 http://www.apache.org/) with either of the mod_perl or mod_fastcgi
647 plugin modules.
648
649 With mod_perl and the Apache::Registry module (distributed with
650 mod_perl), httpd will run with an embedded Perl interpreter which
651 pre-compiles your script and then executes it within the same address
652 space without forking.  The Apache extension also gives Perl access to
653 the internal server API, so modules written in Perl can do just about
654 anything a module written in C can.  For more on mod_perl, see
655 http://perl.apache.org/
656
657 With the FCGI module (from CPAN) and the mod_fastcgi
658 module (available from http://www.fastcgi.com/) each of your Perl
659 programs becomes a permanent CGI daemon process.
660
661 Both of these solutions can have far-reaching effects on your system
662 and on the way you write your CGI programs, so investigate them with
663 care.
664
665 See http://www.cpan.org/modules/by-category/15_World_Wide_Web_HTML_HTTP_CGI/ .
666
667 A non-free, commercial product, ``The Velocity Engine for Perl'',
668 (http://www.binevolve.com/ or http://www.binevolve.com/velocigen/ )
669 might also be worth looking at.  It will allow you to increase the
670 performance of your Perl programs, running programs up to 25 times
671 faster than normal CGI Perl when running in persistent Perl mode or 4
672 to 5 times faster without any modification to your existing CGI
673 programs. Fully functional evaluation copies are available from the
674 web site.
675
676 =head2 How can I hide the source for my Perl program?
677
678 Delete it. :-) Seriously, there are a number of (mostly
679 unsatisfactory) solutions with varying levels of ``security''.
680
681 First of all, however, you I<can't> take away read permission, because
682 the source code has to be readable in order to be compiled and
683 interpreted.  (That doesn't mean that a CGI script's source is
684 readable by people on the web, though--only by people with access to
685 the filesystem.)  So you have to leave the permissions at the socially
686 friendly 0755 level.
687
688 Some people regard this as a security problem.  If your program does
689 insecure things and relies on people not knowing how to exploit those
690 insecurities, it is not secure.  It is often possible for someone to
691 determine the insecure things and exploit them without viewing the
692 source.  Security through obscurity, the name for hiding your bugs
693 instead of fixing them, is little security indeed.
694
695 You can try using encryption via source filters (Starting from Perl
696 5.8 the Filter::Simple and Filter::Util::Call modules are included in
697 the standard distribution), but any decent programmer will be able to
698 decrypt it.  You can try using the byte code compiler and interpreter
699 described below, but the curious might still be able to de-compile it.
700 You can try using the native-code compiler described below, but
701 crackers might be able to disassemble it.  These pose varying degrees
702 of difficulty to people wanting to get at your code, but none can
703 definitively conceal it (true of every language, not just Perl).
704
705 If you're concerned about people profiting from your code, then the
706 bottom line is that nothing but a restrictive license will give you
707 legal security.  License your software and pepper it with threatening
708 statements like ``This is unpublished proprietary software of XYZ Corp.
709 Your access to it does not give you permission to use it blah blah
710 blah.''  We are not lawyers, of course, so you should see a lawyer if
711 you want to be sure your license's wording will stand up in court.
712
713 =head2 How can I compile my Perl program into byte code or C?
714
715 Malcolm Beattie has written a multifunction backend compiler,
716 available from CPAN, that can do both these things.  It is included
717 in the perl5.005 release, but is still considered experimental.
718 This means it's fun to play with if you're a programmer but not
719 really for people looking for turn-key solutions.
720
721 Merely compiling into C does not in and of itself guarantee that your
722 code will run very much faster.  That's because except for lucky cases
723 where a lot of native type inferencing is possible, the normal Perl
724 run-time system is still present and so your program will take just as
725 long to run and be just as big.  Most programs save little more than
726 compilation time, leaving execution no more than 10-30% faster.  A few
727 rare programs actually benefit significantly (even running several times
728 faster), but this takes some tweaking of your code.
729
730 You'll probably be astonished to learn that the current version of the
731 compiler generates a compiled form of your script whose executable is
732 just as big as the original perl executable, and then some.  That's
733 because as currently written, all programs are prepared for a full
734 eval() statement.  You can tremendously reduce this cost by building a
735 shared I<libperl.so> library and linking against that.  See the
736 F<INSTALL> podfile in the Perl source distribution for details.  If
737 you link your main perl binary with this, it will make it minuscule.
738 For example, on one author's system, F</usr/bin/perl> is only 11k in
739 size!
740
741 In general, the compiler will do nothing to make a Perl program smaller,
742 faster, more portable, or more secure.  In fact, it can make your
743 situation worse.  The executable will be bigger, your VM system may take
744 longer to load the whole thing, the binary is fragile and hard to fix,
745 and compilation never stopped software piracy in the form of crackers,
746 viruses, or bootleggers.  The real advantage of the compiler is merely
747 packaging, and once you see the size of what it makes (well, unless
748 you use a shared I<libperl.so>), you'll probably want a complete
749 Perl install anyway.
750
751 =head2 How can I compile Perl into Java?
752
753 You can also integrate Java and Perl with the
754 Perl Resource Kit from O'Reilly and Associates.  See
755 http://www.oreilly.com/catalog/prkunix/ .
756
757 Perl 5.6 comes with Java Perl Lingo, or JPL.  JPL, still in
758 development, allows Perl code to be called from Java.  See jpl/README
759 in the Perl source tree.
760
761 =head2 How can I get C<#!perl> to work on [MS-DOS,NT,...]?
762
763 For OS/2 just use
764
765     extproc perl -S -your_switches
766
767 as the first line in C<*.cmd> file (C<-S> due to a bug in cmd.exe's
768 `extproc' handling).  For DOS one should first invent a corresponding
769 batch file and codify it in C<ALTERNATIVE_SHEBANG> (see the
770 F<INSTALL> file in the source distribution for more information).
771
772 The Win95/NT installation, when using the ActiveState port of Perl,
773 will modify the Registry to associate the C<.pl> extension with the
774 perl interpreter.  If you install another port, perhaps even building
775 your own Win95/NT Perl from the standard sources by using a Windows port
776 of gcc (e.g., with cygwin or mingw32), then you'll have to modify
777 the Registry yourself.  In addition to associating C<.pl> with the
778 interpreter, NT people can use: C<SET PATHEXT=%PATHEXT%;.PL> to let them
779 run the program C<install-linux.pl> merely by typing C<install-linux>.
780
781 Macintosh Perl programs will have the appropriate Creator and
782 Type, so that double-clicking them will invoke the Perl application.
783
784 I<IMPORTANT!>: Whatever you do, PLEASE don't get frustrated, and just
785 throw the perl interpreter into your cgi-bin directory, in order to
786 get your programs working for a web server.  This is an EXTREMELY big
787 security risk.  Take the time to figure out how to do it correctly.
788
789 =head2 Can I write useful Perl programs on the command line?
790
791 Yes.  Read L<perlrun> for more information.  Some examples follow.
792 (These assume standard Unix shell quoting rules.)
793
794     # sum first and last fields
795     perl -lane 'print $F[0] + $F[-1]' *
796
797     # identify text files
798     perl -le 'for(@ARGV) {print if -f && -T _}' *
799
800     # remove (most) comments from C program
801     perl -0777 -pe 's{/\*.*?\*/}{}gs' foo.c
802
803     # make file a month younger than today, defeating reaper daemons
804     perl -e '$X=24*60*60; utime(time(),time() + 30 * $X,@ARGV)' *
805
806     # find first unused uid
807     perl -le '$i++ while getpwuid($i); print $i'
808
809     # display reasonable manpath
810     echo $PATH | perl -nl -072 -e '
811         s![^/+]*$!man!&&-d&&!$s{$_}++&&push@m,$_;END{print"@m"}'
812
813 OK, the last one was actually an Obfuscated Perl Contest entry. :-)
814
815 =head2 Why don't Perl one-liners work on my DOS/Mac/VMS system?
816
817 The problem is usually that the command interpreters on those systems
818 have rather different ideas about quoting than the Unix shells under
819 which the one-liners were created.  On some systems, you may have to
820 change single-quotes to double ones, which you must I<NOT> do on Unix
821 or Plan9 systems.  You might also have to change a single % to a %%.
822
823 For example:
824
825     # Unix
826     perl -e 'print "Hello world\n"'
827
828     # DOS, etc.
829     perl -e "print \"Hello world\n\""
830
831     # Mac
832     print "Hello world\n"
833      (then Run "Myscript" or Shift-Command-R)
834
835     # VMS
836     perl -e "print ""Hello world\n"""
837
838 The problem is that none of these examples are reliable: they depend on the
839 command interpreter.  Under Unix, the first two often work. Under DOS,
840 it's entirely possible that neither works.  If 4DOS was the command shell,
841 you'd probably have better luck like this:
842
843   perl -e "print <Ctrl-x>"Hello world\n<Ctrl-x>""
844
845 Under the Mac, it depends which environment you are using.  The MacPerl
846 shell, or MPW, is much like Unix shells in its support for several
847 quoting variants, except that it makes free use of the Mac's non-ASCII
848 characters as control characters.
849
850 Using qq(), q(), and qx(), instead of "double quotes", 'single
851 quotes', and `backticks`, may make one-liners easier to write.
852
853 There is no general solution to all of this.  It is a mess, pure and
854 simple.  Sucks to be away from Unix, huh? :-)
855
856 [Some of this answer was contributed by Kenneth Albanowski.]
857
858 =head2 Where can I learn about CGI or Web programming in Perl?
859
860 For modules, get the CGI or LWP modules from CPAN.  For textbooks,
861 see the two especially dedicated to web stuff in the question on
862 books.  For problems and questions related to the web, like ``Why
863 do I get 500 Errors'' or ``Why doesn't it run from the browser right
864 when it runs fine on the command line'', see the troubleshooting
865 guides and references in L<perlfaq9> or in the CGI MetaFAQ:
866
867         http://www.perl.org/CGI_MetaFAQ.html
868
869 =head2 Where can I learn about object-oriented Perl programming?
870
871 A good place to start is L<perltoot>, and you can use L<perlobj>,
872 L<perlboot>, L<perltoot>, L<perltooc>, and L<perlbot> for reference.
873 (If you are using really old Perl, you may not have all of these,
874 try http://www.perldoc.com/ , but consider upgrading your perl.)
875
876 A good book on OO on Perl is the "Object-Oriented Perl"
877 by Damian Conway from Manning Publications, 
878 http://www.manning.com/Conway/index.html
879
880 =head2 Where can I learn about linking C with Perl? [h2xs, xsubpp]
881
882 If you want to call C from Perl, start with L<perlxstut>,
883 moving on to L<perlxs>, L<xsubpp>, and L<perlguts>.  If you want to
884 call Perl from C, then read L<perlembed>, L<perlcall>, and
885 L<perlguts>.  Don't forget that you can learn a lot from looking at
886 how the authors of existing extension modules wrote their code and
887 solved their problems.
888
889 =head2 I've read perlembed, perlguts, etc., but I can't embed perl in
890 my C program; what am I doing wrong?
891
892 Download the ExtUtils::Embed kit from CPAN and run `make test'.  If
893 the tests pass, read the pods again and again and again.  If they
894 fail, see L<perlbug> and send a bug report with the output of
895 C<make test TEST_VERBOSE=1> along with C<perl -V>.
896
897 =head2 When I tried to run my script, I got this message. What does it mean?
898
899 A complete list of Perl's error messages and warnings with explanatory
900 text can be found in L<perldiag>. You can also use the splain program
901 (distributed with Perl) to explain the error messages:
902
903     perl program 2>diag.out
904     splain [-v] [-p] diag.out
905
906 or change your program to explain the messages for you:
907
908     use diagnostics;
909
910 or
911
912     use diagnostics -verbose;
913
914 =head2 What's MakeMaker?
915
916 This module (part of the standard Perl distribution) is designed to
917 write a Makefile for an extension module from a Makefile.PL.  For more
918 information, see L<ExtUtils::MakeMaker>.
919
920 =head1 AUTHOR AND COPYRIGHT
921
922 Copyright (c) 1997-2002 Tom Christiansen and Nathan Torkington.
923 All rights reserved.
924
925 This documentation is free; you can redistribute it and/or modify it
926 under the same terms as Perl itself.
927
928 Irrespective of its distribution, all code examples here are in the public
929 domain.  You are permitted and encouraged to use this code and any
930 derivatives thereof in your own programs for fun or for profit as you
931 see fit.  A simple comment in the code giving credit to the FAQ would
932 be courteous but is not required.