A lot of people say that "TIMTOWTDI is the main reason for Perl's write-only reputation", but I'm going to humbly disagree here. Instead, I argue that Perl's TIMTOWTDI- and 0222-ness instead both follow from something else: a huge language with lots of syntax that both mixes programming paradigms and manages to be unique at the same time. Here're a few examples of what I mean (please feel free to correct me or my examples if I'm or they're wrong!):
- A quick script I wrote shows that perlfunc contains 217 entries or so, with 331 usages or so. See also szabgab's Perl index. That's a lot of functions!
- Many people find the default/implicit variables $_ and @_ confusing. It seems to me that this idea is largely unique to Perl and leads to such problems as "why does ord() mean ord $_ but srand() does not mean srand $_?" or "why can't I omit @_ from map?" The lack of formal parameters (yes, I know they exist now, but most people don't use them) leads to things like sub mult{$_[0]*$_[1]}.
- Context! New programmers often have difficulty adjusting to the fact that functions return different values depending on how you call them. To some people, this seems like a violation of the "you can't know why I'm calling you, just do your job" abstraction for functions.
- Two words: regular expressions. Although they are perhaps one of the most useful things in Perl, period, they do have a lot of syntax associated with them. Consider the number of modifiers m//cgimosx; for readability, notice that spaces are interpreted literally unless the /x modifier is added. However, other languages are trying to import Perl's regexps (see Java) or their own variant (see C++ (Boost)). See also the line noise comment later.
- There are some logical things in Perl that are a little foreign to, say, C programmers. These include unless( FOO ){ BAR } or the BAR if/unless FOO variants of the same. But these too are sometimes unusual: in the script I mentioned above, I wrote print $1 if /^\s{7}(\S+)/'; what is the $1 here? You have to look ahead to find out. More reasonable things that take some time to get used to include allowing trailing commas in (1,2,3,) or allowing lacking ending semicolons in sub f{my $x = shift; $x**$x}, the <FH> operator, or an alternation operator || that actually returns the value that was true (so $var ||= $default or $var //= $default works as it should)
- Perl is nice enough to let you avoid parentheses wherever possible. This is great, but sometimes it's a little confusing, in particular when the "if it looks like a
duck function, it's a function" rule gets in the way of an honest print (2+2), "\n".
- There are a lot of functional programming paradigms in Perl, an otherwise mostly procedural language, that are also foreign to C programmers. These include fun things like map, but also more complicated things like closures. Also, Perl manages to have both lexical and dynamic variables; compare Scheme, which has only lexical variables.
- Perl allows you to avoid a lot of spaces, allowing smushing of function and variables (func$var) and such.
- I think the most common Perl insult is that "it looks like noise". What contributes to this perception? I think it was the design philosophy of "Huffman coding" --- commonly occuring things are short. However, to make this practical, the "alphabet" was extended: the pattern m'[$@%#\\<>~]' fails on most lines of code in other languages. In addition, some things were overloaded (like {..} for hashes and functions). Regular expressions usually do not help, because they're pretty well Huffman-coded (although I think Perl 6's pattern matching is a step in the direction of both better coding and comprehension). Finally, things like $#$_ just baffle new programmers, I think (disclaimer: I think that Zaxo's response is good there and not confusing; I am just commenting abstractly). Note also the special variables, like $/ or $".
- I'm not even going into obfuscation. Notice that most obfuscated C code uses the preprocessor heavily.
This isn't a full analysis, but it's a start. What I'm saying is that TIMTOWTDI comes from some of the above (especially the function programming paradigms and regexes), but that the inherent nature of the above also causes write-only-ness. That is, they have a common cause, and not that TIMTOWTDI causes write-only-ness.
Disclaimer: By the way, don't get me wrong ... I love all of these things about Perl, particularly one liners and the interaction with the Unix pipe philosophy. I, however, have talked with many people who don't like Perl since I usually mention that it's my favorite language.
Update: Spelling, formatting, and such.
Posts are HTML formatted. Put <p> </p> tags around your paragraphs. Put <code> </code> tags around your code and data!
Titles consisting of a single word are discouraged, and in most cases are disallowed outright.
Read Where should I post X? if you're not absolutely sure you're posting in the right place.
Please read these before you post! —
Posts may use any of the Perl Monks Approved HTML tags:
- a, abbr, b, big, blockquote, br, caption, center, col, colgroup, dd, del, details, div, dl, dt, em, font, h1, h2, h3, h4, h5, h6, hr, i, ins, li, ol, p, pre, readmore, small, span, spoiler, strike, strong, sub, summary, sup, table, tbody, td, tfoot, th, thead, tr, tt, u, ul, wbr
You may need to use entities for some characters, as follows. (Exception: Within code tags, you can put the characters literally.)
| |
For: |
|
Use: |
| & | | & |
| < | | < |
| > | | > |
| [ | | [ |
| ] | | ] |
Link using PerlMonks shortcuts! What shortcuts can I use for linking?
See Writeup Formatting Tips and other pages linked from there for more info.