[31989] in Perl-Users-Digest
Perl-Users Digest, Issue: 3253 Volume: 11
daemon@ATHENA.MIT.EDU (Perl-Users Digest)
Tue Jan 4 16:09:24 2011
Date: Tue, 4 Jan 2011 13:09:09 -0800 (PST)
From: Perl-Users Digest <Perl-Users-Request@ruby.OCE.ORST.EDU>
To: Perl-Users@ruby.OCE.ORST.EDU (Perl-Users Digest)
Perl-Users Digest Tue, 4 Jan 2011 Volume: 11 Number: 3253
Today's topics:
Re: FAQ 1.16 How can I convince others to use Perl? <marc.girod@gmail.com>
How can I migrate a Linux Perl installation <no-one_you-know@not-at-this-address.com>
Re: How can I migrate a Linux Perl installation <tadmc@seesig.invalid>
Re: How can I migrate a Linux Perl installation <apeiron@isuckatdomains.net.invalid>
opinion: comp lang docs style <xahlee@gmail.com>
Re: opinion: comp lang docs style <jearl@notengoamigos.org>
Re: opinion: comp lang docs style <goposter@jonjay.com>
Re: seven languages <bugbear@trim_papermule.co.uk_trim>
Re: seven languages <cartercc@gmail.com>
Split attachment from email <jqmicro@gmail.com>
Re: Split attachment from email <apeiron@isuckatdomains.net.invalid>
Digest Administrivia (Last modified: 6 Apr 01) (Perl-Users-Digest Admin)
----------------------------------------------------------------------
Date: Tue, 4 Jan 2011 03:19:48 -0800 (PST)
From: Marc Girod <marc.girod@gmail.com>
Subject: Re: FAQ 1.16 How can I convince others to use Perl?
Message-Id: <fb3652c2-e6a6-4b71-812c-da83be5a6d59@n10g2000yqd.googlegroups.com>
On Jan 4, 11:00=A0am, PerlFAQ Server <br...@theperlreview.com> wrote:
> =A0 =A0 the people using that language. If you or your team can be more f=
aster,
^^^^
faster is enough, isn't it?
Marc
------------------------------
Date: Tue, 04 Jan 2011 13:22:36 GMT
From: pete <no-one_you-know@not-at-this-address.com>
Subject: How can I migrate a Linux Perl installation
Message-Id: <slrnii67os.25c.no-one_you-know@corv.local>
I have an AMD64 machine running Ubuntu 8.04 with a _lot_ of
perl modules installed. I have a need to replicate the same
set of libraries on a different box running a later version
of Ubuntu - probably 10.04 but possibly 10.10. However the
new box will be a 32-bit version, not the 64 bit system I am
running here.
Now I could settle in for a long session in front of a
perl -MCPAN -e shell prompt and pull stuff across manually.
However, this would take a long time and I would probably
miss a few modules.
I also expect that some will break, some will need hacking
and some will have been obsoleted - the original install
is a few years old.
Is there a more reliable way I could audit the modules I
have on the original box and have the same modules installed
on the new system? If it took care of dependencies, that
would be even better.
with thanks
--
http://thisreallyismyhost.99k.org/032011011140144275.php
------------------------------
Date: Tue, 04 Jan 2011 07:43:32 -0600
From: Tad McClellan <tadmc@seesig.invalid>
Subject: Re: How can I migrate a Linux Perl installation
Message-Id: <slrnii69m9.p15.tadmc@tadbox.sbcglobal.net>
pete <no-one_you-know@not-at-this-address.com> wrote:
> reliable way I could audit the modules I
> have on the original box
perldoc perllocal
--
Tad McClellan
email: perl -le "print scalar reverse qq/moc.liamg\100cm.j.dat/"
The above message is a Usenet post.
I don't recall having given anyone permission to use it on a Web site.
------------------------------
Date: Tue, 4 Jan 2011 20:14:57 +0000 (UTC)
From: Chris Nehren <apeiron@isuckatdomains.net.invalid>
Subject: Re: How can I migrate a Linux Perl installation
Message-Id: <ifvv41$dpu$2@news.eternal-september.org>
On 2011-01-04, Tad McClellan scribbled these curious markings:
> pete <no-one_you-know@not-at-this-address.com> wrote:
>
>> reliable way I could audit the modules I
>> have on the original box
>
>
> perldoc perllocal
Except that old versions of Module::Build don't update that file, so
it's incomplete. But more-or-less yes. Try complementing it with it with
the .packlist (assuming you're not using vendor packages here, which
like to strip that file for some silly reason) files and use cpanm. The
webservice it uses is smart enough to pick out the dist a given package
belongs to, even if said package is not the same as the dist name. What
this means is that you can give it e.g. Class::MOP::Class and it'll know
you really mean Class::MOP.
... beyond the facts that cpanm is a lot smarter than CPAN.pm and much
better at the STFU and JFDI parts.
--
Thanks and best regards,
Chris Nehren
------------------------------
Date: Tue, 4 Jan 2011 10:24:24 -0800 (PST)
From: Xah Lee <xahlee@gmail.com>
Subject: opinion: comp lang docs style
Message-Id: <98e82f1b-cf59-4e64-8fd4-63671f96b04f@r19g2000prm.googlegroups.com>
a opinion piece.
=E3=80=88The Idiocy of Computer Language Docs=E3=80=89
http://xahlee.org/comp/idiocy_of_comp_lang.html
--------------------------------------------------
The Idiocy of Computer Language Docs
Xah Lee, 2011-01-03
Worked with Mathematica for a whole day yesterday, after about 10
years hiatus. Very nice. Mathematica lang and doc, is quite unique.
Most other langs drivel with jargons, pettiness, comp-sci
pretentiousness, while their content is mathematically garbage.
(unixism mumble jumple (perl, unix), or =E2=80=9Cproper=E2=80=9D-engineerin=
g OOP
fantasy (java), or impractical and ivory-tower adacemician idiocy as
in Scheme & Haskell ( currying, tail recursion, closure, call-cc,
lisp1 lisp2, and monad monad monad!)) (See: What are OOP's Jargons and
Complexities =E2=97=87 Language, Purity, Cult, and Deception.)
Mathematica, in its doc, is plain and simple. None of the jargon and
pretention shit. Very easy to understand. Yet, some of its function's
technical aspects are far more scholarly abstruse than any other lang
(dealing with advanced math special functions that typically only a
few thousand people in the world understand.).
------------------------------
A Gander into the Idiocies
Here's a gander into the doc drivel in common langs.
------------------------------
unix
In unix man pages, it starts with this type of garbage:
SYNOPSIS
gzip [ -acdfhlLnNrtvV19 ] [-S suffix] [ name ... ]
gunzip [ -acfhlLnNrtvV ] [-S suffix] [ name ... ]
zcat [ -fhLV ] [ name ... ]
SYNOPSIS
zip [-aABcdDeEfFghjklLmoqrRSTuvVwXyz!@$] [--
longoption ...] [-b path] [-n suf
fixes] [-t date] [-tt date] [zipfile [file ...]] [-xi
list]
Here, the mindset of unix idiots, is that somehow this =E2=80=9Csynopsis=E2=
=80=9D form
is technically precise and superior. They are thinking that it
captures the full range of syntax in the most concise way. In
practice, it's seldomly read. It's actually not accurate as one'd
thought; no program can parse it and agree with the actual behavior.
It's filled with errors, incomprehensible to human. Worse of all, the
semantic of unix software's options are the worst rape to any possible
science in computer science. See: The Nature of the Unix Philosophy =E2=97=
=87
Unix Pipe As Functional Language =E2=97=87 Unix zip Utility Path Problem.
------------------------------
Python
In Python, you see this kinda garbage:
7.1. The if statement
The if statement is used for conditional execution:
if_stmt ::=3D "if" expression ":" suite
( "elif" expression ":" suite )*
["else" ":" suite]
(Source docs.python.org)
Here, the mindset of the python idiots is similar to the unix tech
geekers. They think that using the BNF notation makes their doc more
clear and precise. The fact is, there are so many variations of BNF
each trying to fix other's problem. BNF is actually not used as a
computer language for syntax description. It's mostly used to
communicate syntax to humans. Like regex, there are so many
variations. But worse than regex in the sense that there are actually
not many actual implementations of BNF. Real word syntax description
language are usually nothing close to BNF. See: Pattern Matching vs
Lexical Grammar Specification.
This incomprehensible BNF notation is the only thing you get if you
want to know the basic syntax of =E2=80=9Cif=E2=80=9D, =E2=80=9Cfor=E2=80=
=9D, =E2=80=9Cwhile=E2=80=9D, =E2=80=9Clambda=E2=80=9D, or
other basic constructs of python.
------------------------------
Perl
In perl, you see this type of drivel:
A Perl program consists of a sequence of declarations and
statements which run from the top to the bottom. Loops, subroutines
and other control structures allow you to jump around within the code.
Perl is a free-form language, you can format and indent it however
you like. Whitespace mostly serves to separate tokens, unlike
languages like Python where it is an important part of the syntax.
Many of Perl's syntactic elements are optional. Rather than
requiring you to put parentheses around every function call and
declare every variable, you can often leave such explicit elements off
and Perl will figure out what you meant. This is known as Do What I
Mean, abbreviated DWIM. It allows programmers to be lazy and to code
in a style with which they are comfortable.
Perl borrows syntax and concepts from many languages: awk, sed, C,
Bourne Shell, Smalltalk, Lisp and even English. Other languages have
borrowed syntax from Perl, particularly its regular expression
extensions. So if you have programmed in another language you will see
familiar pieces in Perl. They often work the same, but see perltrap
for information about how they differ.
(Source perldoc.perl.org)
Notice they introduced you to their lingo =E2=80=9CDWIM=E2=80=9D. Juvenile =
humor is a
characteristics of perl's docs. It's a whole cult. They have =E2=80=9Cperl
republic=E2=80=9D, =E2=80=9Cstate of the onion=E2=80=9D, =E2=80=9Capocalyps=
e=E2=80=9D, =E2=80=9Cperl monger=E2=80=9D, =E2=80=9Cperl
golf=E2=80=9D, etc.(See: Larry Wall and Cults.) Another trait is irrelevant
rambling. For example, in the above you see: =E2=80=9CPerl borrows syntax a=
nd
concepts from many languages: awk, sed, C, Bourne Shell, Smalltalk,
Lisp and even English.=E2=80=9D.
However, perl doc overall is more practically usable than Python's.
------------------------------
Haskell
Here's a example of ivory-tower idiocy, from Haskellers:
Haskell uses a traditional Hindley-Milner polymorphic type system
to provide a static type semantics [4, 6], but the type system has
been extended with type classes (or just classes) that provide a
structured way to introduce overloaded functions.
A class declaration (Section 4.3.1) introduces a new type class
and the overloaded operations that must be supported by any type that
is an instance of that class. An instance declaration (Section 4.3.2)
declares that a type is an instance of a class and includes the
definitions of the overloaded operations=E2=80=94called class methods=E2=80=
=94
instantiated on the named type.
For example, suppose we wish to overload the operations (+) and
negate on types Int and Float. We introduce a new type class called
Num:
class Num a where -- simplified class declaration for
Num
(+) :: a -> a -> a -- (Num is defined in the Prelude)
negate :: a -> a
This declaration may be read =E2=80=9Ca type a is an instance of the cl=
ass
Num if there are class methods (+) and negate, of the given types,
defined on it.=E2=80=9D
(Source www.haskell.org)
Note the words =E2=80=9CHindley-Milner=E2=80=9D, =E2=80=9Cpolymorphic=E2=80=
=9D, =E2=80=9Cstatic type
semantics=E2=80=9D, =E2=80=9Coverloaded operations=E2=80=9D.
The reason they wrote their doc like that is because they are
academicians. You might think that their writing is really scholarly,
mathematically meaningful, almost provably correct, full of dense
mathematical rigor, and necessarily hard to understand because of the
advanced math ideas. By the look of it it is really daunting. The
irony is that the writing is often imprecise, most use of tech jargons
and terms are absolutely uncessarily to the point of being irrelevant.
And, the writing quality is pretty bad, far below the quality of
standard math journal's articles.
--------------------------------------------------
uhmm, happy 2011.
Xah =E2=88=91 http://xahlee.org/ =E2=98=84
------------------------------
Date: Tue, 04 Jan 2011 13:24:35 -0700
From: Jason Earl <jearl@notengoamigos.org>
Subject: Re: opinion: comp lang docs style
Message-Id: <87vd24benw.fsf@notengoamigos.org>
On Tue, Jan 04 2011, Xah Lee wrote:
> a opinion piece.
>
> 〈The Idiocy of Computer Language Docs〉
> http://xahlee.org/comp/idiocy_of_comp_lang.html
>
> --------------------------------------------------
> The Idiocy of Computer Language Docs
>
> Xah Lee, 2011-01-03
>
> Worked with Mathematica for a whole day yesterday, after about 10
> years hiatus. Very nice. Mathematica lang and doc, is quite unique.
> Most other langs drivel with jargons, pettiness, comp-sci
> pretentiousness, while their content is mathematically garbage.
> (unixism mumble jumple (perl, unix), or “proper”-engineering OOP
> fantasy (java), or impractical and ivory-tower adacemician idiocy as
> in Scheme & Haskell ( currying, tail recursion, closure, call-cc,
> lisp1 lisp2, and monad monad monad!)) (See: What are OOP's Jargons and
> Complexities ◇ Language, Purity, Cult, and Deception.)
>
> Mathematica, in its doc, is plain and simple. None of the jargon and
> pretention shit. Very easy to understand. Yet, some of its function's
> technical aspects are far more scholarly abstruse than any other lang
> (dealing with advanced math special functions that typically only a
> few thousand people in the world understand.).
>
> ------------------------------
> A Gander into the Idiocies
>
> Here's a gander into the doc drivel in common langs.
>
> ------------------------------
> unix
>
> In unix man pages, it starts with this type of garbage:
>
> SYNOPSIS
> gzip [ -acdfhlLnNrtvV19 ] [-S suffix] [ name ... ]
> gunzip [ -acfhlLnNrtvV ] [-S suffix] [ name ... ]
> zcat [ -fhLV ] [ name ... ]
>
> SYNOPSIS
> zip [-aABcdDeEfFghjklLmoqrRSTuvVwXyz!@$] [--
> longoption ...] [-b path] [-n suf
> fixes] [-t date] [-tt date] [zipfile [file ...]] [-xi
> list]
>
> Here, the mindset of unix idiots, is that somehow this “synopsis” form
> is technically precise and superior. They are thinking that it
> captures the full range of syntax in the most concise way.
Actually, it *does* capture the full range of syntax in a concise way.
If you know of man pages where the Synopsis does not match the syntax
then you have found a documentation bug, which should be reported so
that it can be fixed.
In fact, if anything the real problem with the Synopsis is that it is
too concise. Fortunately gzip is a bit of an extreme example. Most man
pages look more like this:
--8<---------------cut here---------------start------------->8---
NAME
tar — The GNU version of the tar archiving utility
SYNOPSIS
tar [-] A --catenate --concatenate | c --create | d --diff --compare |
--delete | r --append | t --list | --test-label | u --update | x
--extract --get [options] [pathname ...]
--8<---------------cut here---------------end--------------->8---
That synopsis is pretty useful. If you have used tar before and just
need a refresher chances are very good that the synopsis will do the
trick.
If you look at the man pages from the Linux Programmer's Manual the
Synopsis makes even more sense.
--8<---------------cut here---------------start------------->8---
NAME
open, creat - open and possibly create a file or device
SYNOPSIS
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);
int creat(const char *pathname, mode_t mode);
--8<---------------cut here---------------end--------------->8---
Heck, that's basically precisely what I want to know.
> In practice, it's seldomly read. It's actually not accurate as one'd
> thought; no program can parse it and agree with the actual behavior.
> It's filled with errors, incomprehensible to human.
I've been using UNIX man pages for quite some time, and I don't think
that I have ever come across an error. I am sure that there are errors,
but I am also sure that Mathematica's documentation has its share of
errors as well.
> Worse of all, the semantic of unix software's options are the worst
> rape to any possible science in computer science. See: The Nature of
> the Unix Philosophy ◇ Unix Pipe As Functional Language ◇ Unix zip
> Utility Path Problem.
It seems to me that the problem is not UNIX software in general, but
rather that the zip function does not have an analogue of tar's -C
option (which sets the current directory for the command).
> ------------------------------
> Python
>
> In Python, you see this kinda garbage:
>
> 7.1. The if statement
>
> The if statement is used for conditional execution:
> if_stmt ::= "if" expression ":" suite
> ( "elif" expression ":" suite )*
> ["else" ":" suite]
>
> (Source docs.python.org)
>
> Here, the mindset of the python idiots is similar to the unix tech
> geekers. They think that using the BNF notation makes their doc more
> clear and precise. The fact is, there are so many variations of BNF
> each trying to fix other's problem. BNF is actually not used as a
> computer language for syntax description. It's mostly used to
> communicate syntax to humans. Like regex, there are so many
> variations. But worse than regex in the sense that there are actually
> not many actual implementations of BNF. Real word syntax description
> language are usually nothing close to BNF. See: Pattern Matching vs
> Lexical Grammar Specification.
This example is taken from the Python Language Reference, which is
really only useful if you are looking to re-implement Python (or create
something that parses Python, I suppose). The particular flavor of BNF
is explained in the Introduction.
I am not sure what you expect from a Language Reference, but in the case
of Python the Language Reference seems to have worked quite well. Very
few languages have as many successful implementations as Python. The
Language Reference is clearly a large part of that.
> This incomprehensible BNF notation is the only thing you get if you
> want to know the basic syntax of “if”, “for”, “while”, “lambda”, or
> other basic constructs of python.
If you want to *use* the language the Tutorial is probably what you
want.
Perhaps the most well-known statement type is the if statement. Here's
what the Tutorial has to say about the if statement.
--8<---------------cut here---------------start------------->8---
Perhaps the most well-known statement type is the if statement. For example:
>>> x = int(raw_input("Please enter an integer: "))
Please enter an integer: 42
>>> if x < 0:
... x = 0
... print 'Negative changed to zero'
... elif x == 0:
... print 'Zero'
... elif x == 1:
... print 'Single'
... else:
... print 'More'
...
More
There can be zero or more elif parts, and the else part is optional. The
keyword ‘elif‘ is short for ‘else if’, and is useful to avoid excessive
indentation. An if ... elif ... elif ... sequence is a substitute for the
switch or case statements found in other languages.
--8<---------------cut here---------------end--------------->8---
Once again, that looks pretty good to me.
> ------------------------------
> Perl
>
> In perl, you see this type of drivel:
>
> A Perl program consists of a sequence of declarations and
> statements which run from the top to the bottom. Loops, subroutines
> and other control structures allow you to jump around within the code.
>
> Perl is a free-form language, you can format and indent it however
> you like. Whitespace mostly serves to separate tokens, unlike
> languages like Python where it is an important part of the syntax.
>
> Many of Perl's syntactic elements are optional. Rather than
> requiring you to put parentheses around every function call and
> declare every variable, you can often leave such explicit elements off
> and Perl will figure out what you meant. This is known as Do What I
> Mean, abbreviated DWIM. It allows programmers to be lazy and to code
> in a style with which they are comfortable.
>
> Perl borrows syntax and concepts from many languages: awk, sed, C,
> Bourne Shell, Smalltalk, Lisp and even English. Other languages have
> borrowed syntax from Perl, particularly its regular expression
> extensions. So if you have programmed in another language you will see
> familiar pieces in Perl. They often work the same, but see perltrap
> for information about how they differ.
>
> (Source perldoc.perl.org)
>
> Notice they introduced you to their lingo “DWIM”. Juvenile humor is a
> characteristics of perl's docs. It's a whole cult. They have “perl
> republic”, “state of the onion”, “apocalypse”, “perl monger”, “perl
> golf”, etc.(See: Larry Wall and Cults.) Another trait is irrelevant
> rambling. For example, in the above you see: “Perl borrows syntax and
> concepts from many languages: awk, sed, C, Bourne Shell, Smalltalk,
> Lisp and even English.”.
>
> However, perl doc overall is more practically usable than Python's.
You might not like Larry Wall's documentation style, but if that is the
case then you are in the minority. IMHO Perl is an example of a
language that prospered almost entirely on the strength of its
documentation. The Camel book is one of the best selling computer
language books of all time.
Much of Perl's "culture" is just plain old marketing, but it is hard to
argue that it has not been successful.
> ------------------------------
> Haskell
>
> Here's a example of ivory-tower idiocy, from Haskellers:
>
> Haskell uses a traditional Hindley-Milner polymorphic type system
> to provide a static type semantics [4, 6], but the type system has
> been extended with type classes (or just classes) that provide a
> structured way to introduce overloaded functions.
>
> A class declaration (Section 4.3.1) introduces a new type class
> and the overloaded operations that must be supported by any type that
> is an instance of that class. An instance declaration (Section 4.3.2)
> declares that a type is an instance of a class and includes the
> definitions of the overloaded operations—called class methods—
> instantiated on the named type.
>
> For example, suppose we wish to overload the operations (+) and
> negate on types Int and Float. We introduce a new type class called
> Num:
>
> class Num a where -- simplified class declaration for
> Num
> (+) :: a -> a -> a -- (Num is defined in the Prelude)
> negate :: a -> a
>
> This declaration may be read “a type a is an instance of the class
> Num if there are class methods (+) and negate, of the given types,
> defined on it.”
>
> (Source www.haskell.org)
>
> Note the words “Hindley-Milner”, “polymorphic”, “static type
> semantics”, “overloaded operations”.
>
> The reason they wrote their doc like that is because they are
> academicians. You might think that their writing is really scholarly,
> mathematically meaningful, almost provably correct, full of dense
> mathematical rigor, and necessarily hard to understand because of the
> advanced math ideas. By the look of it it is really daunting. The
> irony is that the writing is often imprecise, most use of tech jargons
> and terms are absolutely uncessarily to the point of being irrelevant.
> And, the writing quality is pretty bad, far below the quality of
> standard math journal's articles.
I actually agree with you on this example.
> uhmm, happy 2011.
You too.
Jason
------------------------------
Date: Tue, 4 Jan 2011 12:29:20 -0800 (PST)
From: Google Poster <goposter@jonjay.com>
Subject: Re: opinion: comp lang docs style
Message-Id: <0edd77ae-2b3b-494b-8651-94b3f56a59e4@j32g2000prh.googlegroups.com>
On Jan 4, 12:24=C2=A0pm, Xah Lee <xah...@gmail.com> wrote:
> a opinion piece.
>
> =E3=80=88The Idiocy of Computer Language Docs=E3=80=89http://xahlee.org/c=
omp/idiocy_of_comp_lang.html
>
> --------------------------------------------------
> The Idiocy of Computer Language Docs
>
> Xah Lee, 2011-01-03
>
> Worked with Mathematica for a whole day yesterday, after about 10
> years hiatus. Very nice. Mathematica lang and doc, is quite unique.
> Most other langs drivel with jargons, pettiness, comp-sci
> pretentiousness, while their content is mathematically garbage.
> (unixism mumble jumple (perl, unix), or =E2=80=9Cproper=E2=80=9D-engineer=
ing OOP
> fantasy (java), or impractical and ivory-tower adacemician idiocy as
> in Scheme & Haskell ( currying, tail recursion, closure, call-cc,
> lisp1 lisp2, and monad monad monad!)) (See: What are OOP's Jargons and
> Complexities =E2=97=87 Language, Purity, Cult, and Deception.)
>
> Mathematica, in its doc, is plain and simple. None of the jargon and
> pretention shit. Very easy to understand. Yet, some of its function's
> technical aspects are far more scholarly abstruse than any other lang
> (dealing with advanced math special functions that typically only a
> few thousand people in the world understand.).
>
> ------------------------------
> A Gander into the Idiocies
>
> Here's a gander into the doc drivel in common langs.
>
> ------------------------------
> unix
>
> In unix man pages, it starts with this type of garbage:
>
> =C2=A0 =C2=A0 SYNOPSIS
> =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0gzip [ -acdfhlLnNrtvV19 ] [-S su=
ffix] [ name ... =C2=A0]
> =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0gunzip [ -acfhlLnNrtvV ] [-S suf=
fix] [ name ... =C2=A0]
> =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0zcat [ -fhLV ] [ name ... =C2=A0=
]
>
> =C2=A0 =C2=A0 SYNOPSIS
> =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0zip =C2=A0[-aABcdDeEfFghjklLmoqr=
RSTuvVwXyz!@$] =C2=A0[--
> longoption =C2=A0...] =C2=A0 [-b path] [-n suf
> =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0fixes] [-t date] [-tt date] [zip=
file [file ...]] =C2=A0[-xi
> list]
>
> Here, the mindset of unix idiots, is that somehow this =E2=80=9Csynopsis=
=E2=80=9D form
> is technically precise and superior. They are thinking that it
> captures the full range of syntax in the most concise way. In
> practice, it's seldomly read. It's actually not accurate as one'd
> thought; no program can parse it and agree with the actual behavior.
> It's filled with errors, incomprehensible to human. Worse of all, the
> semantic of unix software's options are the worst rape to any possible
> science in computer science. See: The Nature of the Unix Philosophy =E2=
=97=87
> Unix Pipe As Functional Language =E2=97=87 Unix zip Utility Path Problem.
>
> ------------------------------
> Python
>
> In Python, you see this kinda garbage:
>
> =C2=A0 =C2=A0 7.1. The if statement
>
> =C2=A0 =C2=A0 The if statement is used for conditional execution:
> =C2=A0 =C2=A0 if_stmt ::=3D =C2=A0"if" expression ":" suite
> =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0( "elif" ex=
pression ":" suite )*
> =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0["else" ":"=
suite]
>
> (Source docs.python.org)
>
> Here, the mindset of the python idiots is similar to the unix tech
> geekers. They think that using the BNF notation makes their doc more
> clear and precise. The fact is, there are so many variations of BNF
> each trying to fix other's problem. BNF is actually not used as a
> computer language for syntax description. It's mostly used to
> communicate syntax to humans. Like regex, there are so many
> variations. But worse than regex in the sense that there are actually
> not many actual implementations of BNF. Real word syntax description
> language are usually nothing close to BNF. See: Pattern Matching vs
> Lexical Grammar Specification.
>
> This incomprehensible BNF notation is the only thing you get if you
> want to know the basic syntax of =E2=80=9Cif=E2=80=9D, =E2=80=9Cfor=E2=80=
=9D, =E2=80=9Cwhile=E2=80=9D, =E2=80=9Clambda=E2=80=9D, or
> other basic constructs of python.
>
> ------------------------------
> Perl
>
> In perl, you see this type of drivel:
>
> =C2=A0 =C2=A0 A Perl program consists of a sequence of declarations and
> statements which run from the top to the bottom. Loops, subroutines
> and other control structures allow you to jump around within the code.
>
> =C2=A0 =C2=A0 Perl is a free-form language, you can format and indent it =
however
> you like. Whitespace mostly serves to separate tokens, unlike
> languages like Python where it is an important part of the syntax.
>
> =C2=A0 =C2=A0 Many of Perl's syntactic elements are optional. Rather than
> requiring you to put parentheses around every function call and
> declare every variable, you can often leave such explicit elements off
> and Perl will figure out what you meant. This is known as Do What I
> Mean, abbreviated DWIM. It allows programmers to be lazy and to code
> in a style with which they are comfortable.
>
> =C2=A0 =C2=A0 Perl borrows syntax and concepts from many languages: awk, =
sed, C,
> Bourne Shell, Smalltalk, Lisp and even English. Other languages have
> borrowed syntax from Perl, particularly its regular expression
> extensions. So if you have programmed in another language you will see
> familiar pieces in Perl. They often work the same, but see perltrap
> for information about how they differ.
>
> (Source perldoc.perl.org)
>
> Notice they introduced you to their lingo =E2=80=9CDWIM=E2=80=9D. Juvenil=
e humor is a
> characteristics of perl's docs. It's a whole cult. They have =E2=80=9Cper=
l
> republic=E2=80=9D, =E2=80=9Cstate of the onion=E2=80=9D, =E2=80=9Capocaly=
pse=E2=80=9D, =E2=80=9Cperl monger=E2=80=9D, =E2=80=9Cperl
> golf=E2=80=9D, etc.(See: Larry Wall and Cults.) Another trait is irreleva=
nt
> rambling. For example, in the above you see: =E2=80=9CPerl borrows syntax=
and
> concepts from many languages: awk, sed, C, Bourne Shell, Smalltalk,
> Lisp and even English.=E2=80=9D.
>
> However, perl doc overall is more practically usable than Python's.
>
> ------------------------------
> Haskell
>
> Here's a example of ivory-tower idiocy, from Haskellers:
>
> =C2=A0 =C2=A0 Haskell uses a traditional Hindley-Milner polymorphic type =
system
> to provide a static type semantics [4, 6], but the type system has
> been extended with type classes (or just classes) that provide a
> structured way to introduce overloaded functions.
>
> =C2=A0 =C2=A0 A class declaration (Section 4.3.1) introduces a new type c=
lass
> and the overloaded operations that must be supported by any type that
> is an instance of that class. An instance declaration (Section 4.3.2)
> declares that a type is an instance of a class and includes the
> definitions of the overloaded operations=E2=80=94called class methods=E2=
=80=94
> instantiated on the named type.
>
> =C2=A0 =C2=A0 For example, suppose we wish to overload the operations (+)=
and
> negate on types Int and Float. We introduce a new type class called
> Num:
>
> =C2=A0 =C2=A0 =C2=A0 class Num a =C2=A0where =C2=A0 =C2=A0 =C2=A0 =C2=A0 =
=C2=A0-- simplified class declaration for
> Num
> =C2=A0 =C2=A0 =C2=A0 =C2=A0 (+) =C2=A0 =C2=A0:: a -> a -> a =C2=A0 =C2=A0=
-- (Num is defined in the Prelude)
> =C2=A0 =C2=A0 =C2=A0 =C2=A0 negate :: a -> a
>
> =C2=A0 =C2=A0 This declaration may be read =E2=80=9Ca type a is an instan=
ce of the class
> Num if there are class methods (+) and negate, of the given types,
> defined on it.=E2=80=9D
>
> (Sourcewww.haskell.org)
>
> Note the words =E2=80=9CHindley-Milner=E2=80=9D, =E2=80=9Cpolymorphic=E2=
=80=9D, =E2=80=9Cstatic type
> semantics=E2=80=9D, =E2=80=9Coverloaded operations=E2=80=9D.
>
> The reason they wrote their doc like that is because they are
> academicians. You might think that their writing is really scholarly,
> mathematically meaningful, almost provably correct, full of dense
> mathematical rigor, and necessarily hard to understand because of the
> advanced math ideas. By the look of it it is really daunting. The
> irony is that the writing is often imprecise, most use of tech jargons
> and terms are absolutely uncessarily to the point of being irrelevant.
> And, the writing quality is pretty bad, far below the quality of
> standard math journal's articles.
>
> --------------------------------------------------
>
> uhmm, happy 2011.
>
> =C2=A0Xah =E2=88=91http://xahlee.org/=E2=98=84
Fell free to rewrite the docs of those programming languages in iambic
pentameter, adding harp octaves in the background.
-Ramon
------------------------------
Date: Tue, 04 Jan 2011 10:26:02 +0000
From: bugbear <bugbear@trim_papermule.co.uk_trim>
Subject: Re: seven languages
Message-Id: <6v2dnfYWncYnaL_QnZ2dnUVZ8t6dnZ2d@brightview.co.uk>
ccc31807 wrote:
> Got 'Seven Languages in Seven Weeks' by Bruce Tate for Christmas and
> have just finished my first quick read through. It's a pretty easy
> read if you don't pay attention to understanding the code
!!
BugBear
------------------------------
Date: Tue, 4 Jan 2011 06:56:23 -0800 (PST)
From: ccc31807 <cartercc@gmail.com>
Subject: Re: seven languages
Message-Id: <9ec3f5eb-a2b8-49bf-9096-7813161d21b1@m35g2000vbn.googlegroups.com>
On Jan 4, 5:26=A0am, bugbear <bugbear@trim_papermule.co.uk_trim> wrote:
> ccc31807 wrote:
> > Got 'Seven Languages in Seven Weeks' by Bruce Tate for Christmas and
> > have just finished my first quick read through. It's a pretty easy
> > read if you don't pay attention to understanding the code
>
> !!
Hey, if I tried to understand the code, it probably /would/ take seven
weeks to read!
;-)
------------------------------
Date: Tue, 4 Jan 2011 06:23:30 -0800 (PST)
From: macaruchi <jqmicro@gmail.com>
Subject: Split attachment from email
Message-Id: <220b1b35-c8b0-421c-8c0e-ded5fbdc511b@y31g2000vbt.googlegroups.com>
Hi!
I am using getmail to download my emails from account service mail.
These emails have an attachment and I wanna know if it is posible with
Perl split the attachment to send to another directory.
I need to split because this attachment will be procesed to send the
information to database.
Any idea or any cluess will be so appreciated
TIA
Edwin Quijada
------------------------------
Date: Tue, 4 Jan 2011 20:17:22 +0000 (UTC)
From: Chris Nehren <apeiron@isuckatdomains.net.invalid>
Subject: Re: Split attachment from email
Message-Id: <ifvv8i$dpu$3@news.eternal-september.org>
On 2011-01-04, macaruchi scribbled these curious markings:
> Hi!
> I am using getmail to download my emails from account service mail.
> These emails have an attachment and I wanna know if it is posible with
> Perl split the attachment to send to another directory.
> I need to split because this attachment will be procesed to send the
> information to database.
> Any idea or any cluess will be so appreciated
Pass the raw RFC 822^W2822^W5322 message to the Email::MIME constructor
and then look at its ->parts method to get access to the attachments.
The rest should follow simply.
--
Thanks and best regards,
Chris Nehren
------------------------------
Date: 6 Apr 2001 21:33:47 GMT (Last modified)
From: Perl-Users-Request@ruby.oce.orst.edu (Perl-Users-Digest Admin)
Subject: Digest Administrivia (Last modified: 6 Apr 01)
Message-Id: <null>
Administrivia:
To submit articles to comp.lang.perl.announce, send your article to
clpa@perl.com.
Back issues are available via anonymous ftp from
ftp://cil-www.oce.orst.edu/pub/perl/old-digests.
#For other requests pertaining to the digest, send mail to
#perl-users-request@ruby.oce.orst.edu. Do not waste your time or mine
#sending perl questions to the -request address, I don't have time to
#answer them even if I did know the answer.
------------------------------
End of Perl-Users Digest V11 Issue 3253
***************************************
