output_parsewords.txt

Practical 
Extraction 
and 
Reporting 
Language.[5] 
Perl 
was 
originally 
developed 
by 
Larry 
Wall 
in 
1987 
as 
a 
general-purpose 
Unix 
scripting 
language 
to 
make 
report 
processing 
easier.[6] 
Since 
then, 
it 
has 
undergone 
many 
changes 
and 
revisions 
and 
became 
popular 
amongst 
programmers. 
Larry 
Wall 
continues 
to 
oversee 
development 
of 
the 
core 
language, 
and 
its 
upcoming 
version, 
Perl 
6. 
Perl 
borrows 
features 
from 
other 
programming 
languages 
including 
C, 
shell 
scripting 
(sh), 
AWK, 
and 
sed.[7] 
The 
language 
provides 
powerful 
text 
processing 
facilities 
without 
the 
arbitrary 
data 
length 
limits 
of 
many 
contemporary 
Unix 
tools,[8] 
facilitating 
easy 
manipulation 
of 
text 
files. 
Perl 
gained 
widespread 
popularity 
in 
the 
late 
1990s 
as 
a 
CGI 
scripting 
language, 
in 
part 
due 
to 
its 
parsing 
abilities. 
Its 
place 
was 
later 
taken 
by 
PHP 
and 
Perl 
has 
remained 
unpopular 
since 
then.[9] 
On 
May 
14, 
2011, 
Perl 
5.14 
was 
released, 
the 
- 
latest 
version 
of 
that 
branch, 
5.14.2, 
being 
released 
on 
September 
26, 
2011. 
On 
May 
20, 
2012, 
Perl 
5.16 
was 
released. 
Notable 
new 
features 
include 
the 
ability 
to 
specify 
a 
given 
version 
of 
perl 
that 
one 
wishes 
to 
emulate, 
allowing 
users 
to 
upgrade 
their 
version 
of 
perl, 
but 
still 
run 
old 
scripts 
that 
wold 
normally 
be 
incompatible. 
[12]. 
Perl 
5.16 
also 
updates 
the 
core 
to 
Name 
OReilly owns the image as a trademark but licenses it for non-commercial use, requiring only an acknowledgement and a link to www.perl.com. Licensing for commercial use is decided on a case by case basis.[20] OReilly 
also 
provides 
Programming Republic of Perl 
logos 
for 
non-commercial 
sites 
and 
Powered by Perl 
buttons 
for 
any 
site 
that 
uses 
Perl.[20] 
The 
Perl 
Foundation 
owns 
an 
alternative 
symbol, 
an 
onion, 
which 
it 
licenses 
to 
its 
subsidiaries, 
Perl 
Mongers, 
PerlMonks, 
Perl.org, 
and 
others.[21] 
The 
symbol 
is 
a 
visual 
pun 
on 
pearl 
onion.[22] 
Perl 
is 
a 
general-purpose 
programming 
language 
originally 
developed 
for 
text 
manipulation, 
but 
as 
of 
2010 
is 
used 
for 
a 
wide 
range 
of 
tasks 
including 
system 
administration, 
web 
development, 
network 
programming, 
games, 
bioinformatics, 
and 
GUI 
development. 
The 
language 
is 
intended 
to 
be 
practical 
(easy 
to 
use, 
efficient, 
complete) 
rather 
than 
beautiful 
(tiny, 
elegant, 
minimal).[23] 
Its 
major 
features 
include 
support 
for 
multiple 
programming 
paradigms 
(procedural, 
object-oriented, 
and 
functional 
styles), 
reference 
counting 
memory 
management 
(without 
a 
cycle-detecting 
garbage 
collector), 
built-in 
support 
for 
text 
processing, 
and 
a 
large 
collection 
of 
third-party 
modules. 
According 
to 
Larry 
Wall, 
Perl 
has 
two 
slogans. 
The 
first 
is 
There's more than one way to do it, 
commonly 
known 
as 
TMTOWTDI. 
The 
second 
slogan 
is 
Easy things should be easy and hard things should be possible.[8] 
Features 
The 
overall 
structure 
of 
Perl 
derives 
broadly 
from 
C. 
Perl 
is 
procedural 
in 
nature, 
with 
variables, 
expressions, 
assignment 
statements, 
brace-delimited 
blocks, 
control 
structures, 
and 
subroutines. 
Perl 
also 
takes 
features 
from 
shell 
programming. 
All 
variables 
are 
marked 
with 
leading 
sigils, 
which 
unambiguously 
identify 
the 
data 
type 
(for 
example, 
scalar, 
array, 
hash) 
of 
the 
variable 
in 
context. 
Importantly, 
sigils 
allow 
variables 
to 
be 
interpolated 
directly 
into 
strings. 
Perl 
has 
many 
built-in 
functions 
that 
provide 
tools 
often 
used 
in 
shell 
programming 
(although 
many 
of 
these 
tools 
are 
implemented 
by 
programs 
external 
to 
the 
shell) 
such 
as 
sorting, 
and 
calling 
on 
system 
facilities. 
Perl 
takes 
lists 
from 
Lisp, 
hashes 
(associative arrays) 
from 
AWK, 
and 
regular 
expressions 
from 
sed. 
These 
simplify 
and 
facilitate 
many 
parsing, 
text-handling, 
and 
data-management 
tasks. 
Perl 
5 
added 
features 
that 
support 
complex 
data 
structures, 
first-class 
functions 
(that 
is, 
closures 
as 
values), 
and 
an 
object-oriented 
programming 
model. 
These 
include 
references, 
packages, 
class-based 
method 
dispatch, 
and 
lexically 
scoped 
variables, 
along 
with 
compiler 
directives 
(for 
example, 
the 
strict 
pragma). 
A 
major 
additional 
feature 
introduced 
with 
Perl 
5 
was 
the 
ability 
to 
package 
code 
as 
reusable 
modules. 
Larry 
Wall 
later 
stated 
that 
The whole intent of Perl 5's module system was to encourage the growth of Perl culture rather than the Perl core.[24] 
All 
versions 
of 
Perl 
do 
automatic 
data-typing 
and 
automatic 
memory-management. 
The 
interpreter 
knows 
the 
type 
and 
storage 
requirements 
of 
every 
data 
object 
in 
the 
program; 
it 
allocates 
and 
frees 
storage 
for 
them 
as 
necessary 
using 
reference 
counting 
(so 
it 
cannot 
deallocate 
circular 
data 
structures 
without 
manual 
intervention). 
Legal 
type-conversions 
— 
for 
example, 
conversions 
from 
number 
to 
string 
— 
are 
done 
automatically 
at 
run 
time; 
illegal 
type 
conversions 
are 
fatal 
errors. 
Design 
The 
design 
of 
Perl 
can 
be 
understood 
as 
a 
response 
to 
three 
broad 
trends 
in 
the 
computer 
industry: 
falling 
hardware 
costs, 
rising 
labor 
costs, 
and 
improvements 
in 
compiler 
technology. 
Many 
earlier 
computer 
languages, 
such 
as 
Fortran 
and 
C, 
aimed 
to 
make 
efficient 
use 
of 
expensive 
computer 
hardware. 
In 
contrast, 
Perl 
is 
designed 
to 
make 
efficient 
use 
of 
expensive 
computer-programmers. 
Perl 
has 
many 
features 
that 
ease 
the 
task 
of 
the 
programmer 
at 
the 
expense 
of 
greater 
CPU 
and 
memory 
requirements. 
These 
include 
automatic 
memory 
management; 
dynamic 
typing; 
strings, 
lists, 
and 
hashes; 
regular 
expressions; 
introspection; 
and 
an 
eval() 
function. 
Perl 
follows 
the 
theory 
of 
no built-in limits,[19] 
an 
idea 
similar 
to 
the 
Zero 
One 
Infinity 
rule. 
Wall 
was 
trained 
as 
a 
linguist, 
and 
the 
design 
of 
Perl 
is 
very 
much 
informed 
by 
linguistic 
principles. 
Examples 
include 
Huffman 
coding 
(common 
constructions 
should 
be 
short), 
good 
end-weighting 
(the 
important 
information 
should 
come 
first), 
and 
a 
large 
collection 
of 
language 
primitives. 
Perl 
favors 
language 
constructs 
that 
are 
concise 
and 
natural 
for 
humans 
to 
write, 
even 
where 
they 
complicate 
the 
Perl 
interpreter. 
Perl 
syntax 
reflects 
the 
idea 
that 
things that are different should look different.[25] 
For 
example, 
scalars, 
arrays, 
and 
hashes 
have 
different 
leading 
sigils. 
Array 
indices 
and 
hash 
keys 
use 
different 
kinds 
of 
braces. 
Strings 
and 
regular 
expressions 
have 
different 
standard 
delimiters. 
This 
approach 
can 
be 
contrasted 
with 
languages 
such 
as 
Lisp, 
where 
the 
same 
S-expression 
construct 
and 
basic 
syntax 
are 
used 
for 
many 
different 
purposes. 
Perl 
does 
not 
enforce 
any 
particular 
programming 
paradigm 
(procedural, 
object-oriented, 
functional, 
or 
others) 
or 
even 
require 
the 
programmer 
to 
choose 
among 
them. 
No 
written 
specification 
or 
standard 
for 
the 
Perl 
language 
exists 
for 
Perl 
versions 
through 
Perl 
5, 
and 
there 
are 
no 
plans 
to 
create 
one 
for 
the 
current 
version 
of 
Perl. 
There 
has 
been 
only 
one 
implementation 
of 
the 
interpreter, 
and 
the 
language 
has 
evolved 
along 
with 
it. 
That 
interpreter, 
together 
with 
its 
functional 
tests, 
stands 
as 
a 
de 
facto 
specification 
of 
the 
language. 
Perl 
6, 
however, 
started 
with 
a 
specification,[27] 
and 
several 
projects[28] 
aim 
to 
implement 
some 
or 
all 
of 
the 
specification. 
Applications 
Perl 
has 
many 
and 
varied 
applications, 
compounded 
by 
the 
availability 
of 
many 
standard 
and 
third-party 
modules. 
Ever 
since 
the 
early 
days 
of 
the 
Web, 
programmers 
have 
used 
Perl 
to 
write 
CGI 
scripts. 
Perl 
is 
known 
as 
one 
of 
the three Ps 
(along 
with 
Python 
and 
PHP), 
the 
most 
popular 
dynamic 
languages 
for 
writing 
Web 
applications. 
It 
is 
also 
an 
integral 
component 
of 
the 
popular 
LAMP 
solution 
stack 
for 
web 
development. 
Large 
projects 
written 
in 
Perl 
include 
cPanel, 
Slash, 
Bugzilla, 
RT, 
TWiki, 
and 
Movable 
Type. 
Many 
high-traffic 
websites 
use 
Perl 
extensively. 
Examples 
include 
Amazon.com, 
bbc.co.uk, 
Priceline.com, 
Craigslist,[29] 
IMDb,[30] 
LiveJournal, 
Slashdot 
and 
Ticketmaster. 
Perl 
is 
often 
used 
as 
a 
glue 
language, 
tying 
together 
systems 
and 
interfaces 
that 
were 
not 
specifically 
designed 
to 
interoperate, 
and 
for 
data munging,[31] 
that 
is, 
converting 
or 
processing 
large 
amounts 
of 
data 
for 
tasks 
such 
as 
creating 
reports. 
In 
fact, 
these 
strengths 
are 
intimately 
linked. 
The 
combination 
makes 
Perl 
a 
popular 
all-purpose 
language 
for 
system 
administrators, 
particularly 
because 
short 
programs 
can 
be 
entered 
and 
run 
on 
a 
single 
command 
line. 
With 
a 
degree 
of 
care, 
Perl 
code 
can 
be 
made 
portable 
across 
Windows 
and 
Unix. 
Portable 
Perl 
code 
is 
often 
used 
by 
suppliers 
of 
software 
(both 
COTS 
and 
bespoke) 
to 
simplify 
packaging 
and 
maintenance 
of 
software 
build- 
and 
deployment-scripts. 
Graphical 
user 
interfaces 
(GUIs) 
may 
be 
developed 
using 
Perl. 
For 
example, 
Perl/Tk 
is 
commonly 
used 
to 
enable 
user 
interaction 
with 
Perl 
scripts. 
Such 
interaction 
may 
be 
synchronous 
or 
asynchronous, 
using 
callbacks 
to 
update 
the 
GUI. 
For 
more 
information 
about 
the 
technologies 
involved, 
see 
Tk, 
Tcl 
and 
WxPerl. 
Perl 
is 
also 
widely 
used 
in 
finance 
and 
in 
bioinformatics, 
where 
it 
is 
valued 
for 
rapid 
application 
development 
and 
deployment 
and 
for 
its 
capability 
to 
handle 
large 
data-sets. 
Implementation 
Perl 
is 
implemented 
as 
a 
core 
interpreter, 
written 
in 
C, 
together 
with 
a 
large 
collection 
of 
modules, 
written 
in 
Perl 
and 
C. 
As 
of 
2010, 
the 
stable 
version 
(5.12.3) 
is 
14.2 
MB 
when 
packaged 
in 
a 
tar 
file 
and 
gzip 
compressed.[32] 
The 
interpreter 
is 
150,000 
lines 
of 
C 
code 
and 
compiles 
to 
a 
1 
MB 
executable 
on 
typical 
machine 
architectures. 
Alternatively, 
the 
interpreter 
can 
be 
compiled 
to 
a 
link 
library 
and 
embedded 
in 
other 
programs. 
There 
are 
nearly 
500 
modules 
in 
the 
distribution, 
comprising 
200,000 
lines 
of 
Perl 
and 
an 
additional 
350,000 
lines 
of 
C 
code. 
(Much 
of 
the 
C 
code 
in 
the 
modules 
consists 
of 
character-encoding 
tables.) 
The 
interpreter 
has 
an 
object-oriented 
architecture. 
All 
of 
the 
elements 
of 
the 
Perl 
language—scalars, 
arrays, 
hashes, 
coderefs, 
filehandles—are 
represented 
in 
the 
interpreter 
by 
C 
structs. 
Operations 
on 
these 
structs 
are 
defined 
by 
a 
large 
collection 
of 
macros, 
typedefs, 
and 
functions; 
these 
constitute 
the 
Perl 
C 
API. 
The 
Perl 
API 
can 
be 
bewildering 
to 
the 
uninitiated, 
but 
its 
entry 
points 
follow 
a 
consistent 
naming-scheme, 
which 
provides 
guidance 
to 
those 
who 
use 
it. 
Most 
of 
what 
happens 
in 
Perls compile phase is compilation, and most of what happens in Perls 
run 
phase 
is 
execution, 
but 
there 
are 
significant 
exceptions. 
Perl 
makes 
important 
use 
of 
its 
capability 
to 
execute 
Perl 
code 
during 
the 
compile 
phase. 
Perl 
will 
also 
delay 
compilation 
into 
the 
run 
phase. 
The 
terms 
that 
indicate 
the 
kind 
of 
processing 
that 
is 
actually 
occurring 
at 
any 
moment 
are 
compile 
time 
and 
run 
time. 
Perl 
is 
in 
compile 
time 
at 
most 
points 
during 
the 
compile 
phase, 
but 
compile 
time 
may 
also 
be 
entered 
during 
the 
run 
phase. 
The 
compile 
time 
for 
code 
in 
a 
string 
argument 
passed 
to 
the 
eval 
built-in 
occurs 
during 
the 
run 
phase. 
Perl 
is 
often 
in 
run 
time 
during 
the 
compile 
phase 
and 
spends 
most 
of 
the 
run 
phase 
in 
run 
time. 
Code 
in 
BEGIN 
blocks 
executes 
at 
run 
time 
but 
in 
the 
compile 
phase. 
At 
compile 
time, 
the 
interpreter 
parses 
Perl 
code 
into 
a 
syntax 
tree. 
At 
run 
time, 
it 
executes 
the 
program 
by 
walking 
the 
tree. 
Text 
is 
parsed 
only 
once, 
and 
the 
syntax 
tree 
is 
subject 
to 
optimization 
before 
it 
is 
executed, 
so 
that 
execution 
is 
relatively 
efficient. 
Compile-time 
optimizations 
on 
the 
syntax 
tree 
include 
constant 
folding 
and 
context 
propagation, 
but 
peephole 
optimization 
is 
also 
performed. 
Perl 
has 
a 
Turing-complete 
grammar 
because 
parsing 
can 
be 
affected 
by 
run-time 
code 
executed 
during 
the 
compile 
phase.[34] 
Therefore, 
Perl 
cannot 
be 
parsed 
by 
a 
straight 
Lex/Yacc 
lexer/parser 
combination. 
Instead, 
the 
interpreter 
implements 
its 
own 
lexer, 
which 
coordinates 
with 
a 
modified 
GNU 
bison 
parser 
to 
resolve 
ambiguities 
in 
the 
language. 
Perl 
is 
distributed 
with 
some 
120,000 
functional 
tests. 
These 
run 
as 
part 
of 
the 
normal 
build 
process 
and 
extensively 
exercise 
the 
interpreter 
and 
its 
core 
modules. 
Perl 
developers 
rely 
on 
the 
functional 
tests 
to 
ensure 
that 
changes 
to 
the 
interpreter 
do 
not 
introduce 
bugs; 
additionally, 
Perl 
users 
who 
see 
that 
the 
interpreter 
passes 
its 
functional 
tests 
on 
their 
system 
can 
have 
a 
high 
degree 
of 
confidence 
that 
it 
is 
working 
properly. 
Maintenance 
of 
the 
Perl 
interpreter 
has 
become 
increasingly 
difficult 
over 
the 
years. 
The 
code 
base 
has 
undergone 
continuous 
development 
since 
1994. 
The 
code 
has 
been 
optimized 
for 
performance 
at 
the 
expense 
of 
simplicity, 
clarity, 
and 
strong 
internal 
interfaces. 
New 
features 
have 
been 
added, 
yet 
virtually 
complete 
backward 
compatibility 
with 
earlier 
versions 
is 
maintained. 
Major 
releases 
of 
Perl 
were 
coordinated 
by 
Perl 
pumpkings,[38] 
which 
handled 
integrating 
patch 
submissions 
and 
bug 
fixes, 
but 
the 
language 
has 
since 
changed 
to 
a 
rotating, 
monthly 
release 
cycle. 
Development 
discussion 
takes 
place 
via 
the 
perl5_porters 
mailing 
list. 
As 
of 
Perl 
5.11, 
development 
efforts 
have 
included 
refactoring 
certain 
core 
modules 
known 
as 
dual lifed 
modules 
out 
of 
the 
Perl 
core[39] 
to 
help 
alleviate 
some 
of 
these 
problems. 
[edit]Availability 
Perl 
is 
dual 
licensed 
under 
both 
the 
Artistic 
License 
and 
the 
GNU 
General 
Public 
License. 
Distributions 
are 
available 
for 
most 
operating 
systems. 
It 
is 
particularly 
prevalent 
on 
Unix 
and 
Unix-like 
systems, 
but 
it 
has 
been 
ported 
to 
most 
modern 
(and 
many 
obsolete) 
platforms. 
With 
only 
six 
reported 
exceptions, 
Perl 
can 
be 
compiled 
from 
source 
code 
on 
all 
POSIX-compliant, 
or 
otherwise-Unix-compatible 
platforms.[40] 
Because 
of 
unusual 
changes 
required 
for 
the 
Mac 
OS 
Classic 
environment, 
a 
special 
port 
called 
MacPerl 
was 
shipped 
independently.[41] 
The 
Comprehensive 
Perl 
Archive 
Network 
carries 
a 
complete 
list 
of 
supported 
platforms 
with 
links 
to 
the 
distributions 
available 
on 
each.[42] 
CPAN 
is 
also 
the 
source 
for 
publicly 
available 
Perl 
modules 
that 
are 
not 
part 
of 
the 
core 
Perl 
distribution. 
[edit]Windows 
Users 
of 
Microsoft 
Windows 
typically 
install 
one 
of 
the 
native 
binary 
distributions 
of 
Perl 
for 
Win32, 
most 
commonly 
Strawberry 
Perl 
or 
ActivePerl. 
Compiling 
Perl 
from 
source 
code 
under 
Windows 
is 
possible, 
but 
most 
installations 
lack 
the 
requisite 
C 
compiler 
and 
build 
tools. 
This 
also 
makes 
it 
difficult 
to 
install 
modules 
from 
the 
CPAN, 
particularly 
those 
that 
are 
partially 
written 
in 
C. 
ActivePerl 
is 
a 
closed 
source 
distribution 
from 
ActiveState 
that 
has 
regular 
releases 
that 
track 
the 
core 
Perl 
releases.[43] 
The 
distribution 
also 
includes 
the 
Perl 
package 
manager 
(PPM),[44] 
a 
popular 
tool 
for 
installing, 
removing, 
upgrading, 
and 
managing 
the 
use 
of 
common 
Perl 
modules. 
Strawberry 
Perl 
is 
an 
open 
source 
distribution 
for 
Windows. 
It 
has 
had 
regular, 
quarterly 
releases 
since 
January 
2008, 
including 
new 
modules 
as 
feedback 
and 
requests 
come 
in. 
Strawberry 
Perl 
aims 
to 
be 
able 
to 
install 
modules 
like 
standard 
Perl 
distributions 
on 
other 
platforms, 
including 
compiling 
XS 
modules. 
The 
Cygwin 
emulation 
layer 
is 
another 
way 
of 
running 
Perl 
under 
Windows. 
Cygwin 
provides 
a 
Unix-like 
environment 
on 
Windows, 
and 
both 
Perl 
and 
CPAN 
are 
available 
as 
standard 
pre-compiled 
packages 
in 
the 
Cygwin 
setup 
program. 
Because 
Cygwin 
also 
includes 
the 
gcc, 
compiling 
Perl 
from 
source 
is 
also 
possible. 
[edit]Database 
interfaces 
Perl 
is 
widely 
favored 
for 
database 
applications. 
Its 
text-handling 
facilities 
are 
useful 
for 
generating 
SQL 
queries; 
arrays, 
hashes, 
and 
automatic 
memory 
management 
make 
it 
easy 
to 
collect 
and 
process 
the 
returned 
data. 
In 
early 
versions 
of 
Perl, 
database 
interfaces 
were 
created 
by 
relinking 
the 
interpreter 
with 
a 
client-side 
database 
library. 
This 
was 
sufficiently 
difficult 
that 
it 
was 
done 
for 
only 
a 
few 
of 
the 
most-important 
and 
most 
widely 
used 
databases, 
and 
it 
restricted 
the 
resulting 
perl 
executable 
to 
using 
just 
one 
database 
interface 
at 
a 
time. 
In 
Perl 
5, 
database 
interfaces 
are 
implemented 
by 
Perl 
DBI 
modules. 
The 
DBI 
(Database 
Interface) 
module 
presents 
a 
single, 
database-independent 
interface 
to 
Perl 
applications, 
while 
the 
DBD 
(Database 
Driver) 
modules 
handle 
the 
details 
of 
accessing 
some 
50 
different 
databases; 
there 
are 
DBD 
drivers 
for 
most 
ANSI 
SQL 
databases. 
DBI 
provides 
caching 
for 
database 
handles 
and 
queries, 
which 
can 
greatly 
improve 
performance 
in 
long-lived 
execution 
environments 
such 
as 
mod_perl,[45] 
helping 
high-volume 
systems 
avert 
load 
spikes 
as 
in 
the 
Slashdot 
effect. 
In 
modern 
Perl 
applications, 
especially 
those 
written 
using 
Web 
application 
frameworks 
such 
as 
Catalyst, 
the 
DBI 
module 
is 
often 
used 
indirectly 
via 
object-relational 
mappers 
such 
as 
DBIx::Class, 
Class::DBI 
or 
Rose::DB::Object 
which 
generate 
SQL 
queries 
and 
handle 
data 
transparently 
to 
the 
application 
author. 
[edit]Comparative 
performance 
Large 
Perl 
programs 
start 
more 
slowly 
than 
similar 
programs 
in 
compiled 
languages 
because 
perl 
has 
to 
compile 
the 
source 
every 
time 
it 
runs. 
In 
a 
talk 
at 
the 
YAPC::Europe 
2005 
conference 
and 
subsequent 
article 
A Timely Start, 
Jean-Louis 
Leroy 
found 
that 
his 
Perl 
programs 
took 
much 
longer 
to 
run 
than 
he 
expected 
because 
the 
perl 
interpreter 
spent 
much 
of 
the 
time 
finding 
modules 
because 
of 
his 
over-large 
include 
path.[48] 
Unlike 
Java, 
Python, 
and 
Ruby, 
Perl 
has 
only 
experimental 
support 
for 
pre-compiling.[49] 
Therefore 
Perl 
programs 
pay 
this 
overhead 
penalty 
on 
every 
execution. 
The 
run 
phase 
of 
typical 
programs 
is 
long 
enough 
that 
amortized 
startup 
time 
is 
not 
substantial, 
but 
benchmarks 
that 
measure 
very 
short 
execution 
times 
are 
likely 
to 
be 
skewed 
due 
to 
this 
overhead. 
[edit]Optimizing 
Like 
any 
code, 
Perl 
programs 
can 
be 
tuned 
for 
performance 
using 
benchmarks 
and 
profiles 
after 
a 
readable 
and 
correct 
implementation 
is 
finished. 
In 
part 
because 
of 
Perls interpreted nature, writing more-efficient Perl will not always be enough to meet ones 
performance 
goals 
for 
a 
program. 
In 
such 
situations, 
the 
most-critical 
routines 
of 
a 
Perl 
program 
can 
be 
written 
in 
other 
languages 
such 
as 
C 
or 
Assembler, 
which 
can 
be 
connected 
to 
Perl 
via 
simple 
Inline 
modules 
or 
the 
more-complex-but-flexible 
XS 
mechanism.[50] 
Nicholas 
Clark, 
a 
Perl 
core 
developer, 
discusses 
some 
Perl 
design 
trade-offs 
and 
solutions 
in 
a 
2002 
document 
called 
When perl is not quite fast enough.[51] 
At 
the 
2000 
Perl 
Conference, 
Jon 
Orwant 
made 
a 
case 
for 
a 
major 
new 
language 
initiative.[53] 
This 
led 
to 
a 
decision 
to 
begin 
work 
on 
a 
redesign 
of 
the 
language, 
to 
be 
called 
Perl 
6. 
Proposals 
for 
new 
language 
features 
were 
solicited 
from 
the 
Perl 
community 
at 
large, 
and 
more 
than 
300 
RFCs 
were 
submitted. 
Larry 
Wall 
spent 
the 
next 
few 
years 
digesting 
the 
RFCs 
and 
synthesizing 
them 
into 
a 
coherent 
framework 
for 
Perl 
6. 
He 
has 
presented 
his 
design 
for 
Perl 
6 
in 
a 
series 
of 
documents 
called 
apocalypses, 
which 
are 
numbered 
to 
correspond 
to 
chapters 
in 
Programming 
Perl. 
As 
of 
January 
2011, 
the 
developing 
specification 
of 
Perl 
6 
is 
encapsulated 
in 
design 
documents 
called 
Synopses, 
which 
are 
numbered 
to 
correspond 
to 
Apocalypses.[54] 
Perl 
6 
is 
not 
intended 
to 
be 
backward 
compatible, 
although 
there 
will 
be 
a 
compatibility 
mode. 
Perl 
6 
and 
Perl 
5 
are 
distinct 
languages 
with 
a 
common 
ancestry.[55] 
In 
2005, 
Audrey 
Tang 
created 
the 
pugs 
project, 
an 
implementation 
of 
Perl 
6 
in 
Haskell. 
This 
was, 
and 
continues 
to 
act 
as, 
a 
test 
platform 
for 
the 
Perl 
6 
language 
(separate 
from 
the 
development 
of 
the 
actual 
implementation) 
allowing 
the 
language 
designers 
to 
explore. 
The 
pugs 
project 
spawned 
an 
active 
Perl/Haskell 
cross-language 
community 
centered 
around 
the 
freenode 
#perl6 
IRC 
channel. 
A 
number 
of 
features 
in 
the 
Perl 
6 
language 
now 
show 
similarities 
to 
Haskell.[citation 
needed] 
As 
of 
2012, 
Perl 
6 
development 
is 
primarily 
centered 
around 
two 
compilers[57], 
Rakudo 
Perl 
6, 
an 
implementation 
running 
on 
top 
of 
the 
Parrot 
virtual 
machine, 
and 
Niecza, 
which 
targets 
the 
Common 
Language 
Runtime. 
[edit]Future 
of 
Perl 
5 
Development 
of 
Perl 
5 
is 
also 
continuing. 
Perl 
5.12.0 
was 
released 
in 
April 
2010 
with 
some 
new 
features 
influenced 
by 
the 
design 
of 
Perl 
6.[10][58] 
Perl 
5.14.1 
was 
released 
on 
June 
17, 
2011. 
Perl 
5 
development 
versions 
are 
released 
on 
a 
monthly 
basis, 
with 
major 
releases 
coming 
out 
once 
per 
year.[59] 
Future 
plans 
for 
Perl 
5 
include 
making 
the 
core 
language 
easier 
to 
extend 
from 
modules, 
and 
providing 
a 
small, 
extensible 
Meta-object 
protocol 
in 
core.[60] 
The 
relative 
proportion 
of 
searches 
for 
Perl programming, 
as 
compared 
with 
similar 
searches 
for 
other 
programming 
languages, 
declined 
from 
2005 
to 
early 
2011 
(with 
a 
subsequent 
increase 
since 
then).[61] 
However, 
according 
to 
this 
same 
source, 
Perl 
has 
been 
one 
of 
the 
top 
ten 
most 
popular 
programming 
languages 
since 
records 
began 
in 
2001.[62] 
[edit]Perl 
community 
[edit]State 
of 
the 
Onion 
State 
of 
the 
Onion 
is 
the 
name 
for 
Larry 
Wall’s 
yearly 
keynote-style 
summaries 
on 
the 
progress 
of 
Perl 
and 
its 
community. 
They 
are 
characterized 
by 
his 
hallmark 
humor, 
employing 
references 
to 
Perl’s 
culture, 
the 
wider 
hacker 
culture, 
Wall’s 
linguistic 
background, 
sometimes 
his 
family 
life, 
and 
occasionally 
even 
his 
Christian 
background. 
Each 
talk 
is 
first 
given 
at 
various 
Perl 
conferences 
and 
is 
eventually 
also 
published 
online. 
[edit]Perl 
pastimes 
JAPHs 
In 
email, 
Usenet, 
and 
message 
board 
postings, 
Just another Perl hacker 
(JAPH) 
programs 
are 
a 
common 
trend, 
originated 
by 
Randal 
L. 
Schwartz, 
one 
of 
the 
earliest 
professional 
Perl 
trainers.[64] 
In 
the 
parlance 
of 
Perl 
culture, 
Perl 
programmers 
are 
known 
as 
Perl 
hackers, 
and 
from 
this 
derives 
the 
practice 
of 
writing 
short 
programs 
to 
print 
out 
the 
phrase 
Just another Perl hacker,. 
In 
the 
spirit 
of 
the 
original 
concept, 
these 
programs 
are 
moderately 
obfuscated 
and 
short 
enough 
to 
fit 
into 
the 
signature 
of 
an 
email 
or 
Usenet 
message. 
The 
canonical 
JAPH 
as 
developed 
by 
Schwartz 
includes 
the 
comma 
at 
the 
end, 
although 
this 
is 
often 
omitted.[65] 
Perl 
golf 
Obfuscation 
Poetry 
Perl 
poetry 
is 
the 
practice 
of 
writing 
poems 
that 
can 
be 
compiled 
as 
legal 
Perl 
code, 
for 
example 
the 
piece 
known 
as 
Black 
Perl. 
This 
hobby 
is 
made 
possible 
by 
the 
large 
number 
of 
English 
words 
that 
are 
used 
in 
the 
Perl. 
New 
poems 
are 
regularly 
submitted 
to 
the 
community 
at 
PerlMonks.[70] 
CPAN 
Acme 
There 
are 
also 
many 
examples 
of 
code 
written 
purely 
for 
entertainment 
on 
the 
CPAN. 
Lingua::Romana::Perligata, 
for 
example, 
allows 
writing 
programs 
in 
Latin.[71] 
Upon 
execution 
of 
such 
a 
program, 
the 
module 
translates 
its 
source 
code 
into 
regular 
Perl 
and 
runs 
it.