Perlová magie

6.12.2006 16:14 | Přečteno: 1700× | Perl | poslední úprava: 7.12.2006 12:20

Myslíte si, že umíte perl?

Tak schválně, jaký bude výstup následujícího kódu?

perl -mData::Dumper -e '
map keys %$_, @$a{qw(a b c)};
print Data::Dumper->Dump([$a],["a"])'

Když se nad tím zamyslíte, tak to není až tak divné, ale i tak mě to zaskočilo.

Updated: Pokus o co nejméně magický zápis téhož:

perl -mstrict -mwarnings -mData::Dumper -e '
my ($a, @res);
for my $entry ($a->{a}, $a->{b}, $a->{c}) {
    push @res, keys %$entry;
}
print Data::Dumper->Dump([$a],["a"]);'

       

Komentáře

[petr]

zazipovaný to vypadá podobně

[happy barney]

zazipované:
- infozip: je to 129 znakov dlhšie.
- gzip: +12 bytes
- bzip2: +30 bytes

víťaz? perl

[Käyttäjä 11133]

Přepis do Perlu, nejlepší kompresní algoritmus :D

[Lukáš Rýdlo]

A já si pořád říkal, proč mi připadají zdrojáky v Perlu tak příšerně nesrozumitelné a nepřehledné. To jste měli říct rovnou, že se to prvně musí rozbalit

[Tomáš Honzák]

No, je to "hezký", ale k čemu je to dobrý?

Nepřestane mne fascinovat, jak lidi dokážou psát s odpuštěním prasácky nečitelné one-linery jenom proto, "že to jde".

PERL je fantasticky užitečný jazyk, který dokáže zásadním způsobem usnadnit práci s daty, to celé s nízkými náklady na "zaškolení", bez nutnosti chápat složitá paradigmata OOP či studovat tuny knihoven.

Z vlastní zkušenosti vím o lidech, kteří, ač vybaveni minimálními znalostmi o programování a UNIXu, zvládli PERL doslova během dní natolik, že jsou schopni psát komplikované filtry, programy, které vytváří programy a podobně.

A to celé tak, že ten kód je nejen srozumitelný a čitelný na první pohled, ale zároveň elegantní.

Ono stačí málo. use strict; use warnings;. Trocha štábní kultury při psaní komentářů. Dodržování nějakých coding standardů.

Jenomže ono je mnohem zábavnější napsat takovouhle nesmyslnou pakárnu a pak s tím machrovat, myslíte, že umíte PERL? Mimo to bych si dovolil polemizovat s názorem, že míra "umění" nějakého jazyka se dá vyjádřit tím, že člověk rychle zanalyzuje cizí kód.

Dovolím si myšlenkový experiment. Vezměte si nějaký složitější vlastní program (delší než 1 000 řádek), na jehož zdrojáky jste už pár měsíců nesáhli, a nahraďte všechny jména souborů, proměnných, funkcí, konstant a textových výstupů náhodnými řetězci. Odstraňte veškeré debuggovací výstupy. Přeházejte pořadí, v jakém jsou funkce nadeklarovány. Pak si najděte jednu funkci někde uprostřed, a zkuste vymyslet, co se uvnitř děje a k čemu je to dobré. Velmi pravděpodobně si budete muset zahrát na kompiler či interpreter, abyste se dobrali alespoň k něčemu. A máte pocit, že to vypovídá o tom, jak dobře ten konkrétní jazyk umíte? Přesně o tom je totiž tenhle zápisek.

To, že se v PERLu dá psát write-only "o něco jednoduššeji" než v jiných jazycích, přece neznamená, že to programátoři musejí dělat.

S takovým přístupem se jenom stále více šíří FUD, že PERL je nečitelný, write-only jazyk, kterému se každý rozumný programátor/unix administrátor vyhne.

A vůbec, myslíte si, že umíte C ? Dejte si do google obfuscated c contest a koukejte

[happy barney]

k čemu je to dobrý ?
v tomto prípade napr k ukážke toho, že keys inicializuje hashref.

Podobné príklady sú ako rébusy, ako krížovky, pre programátora tá istá kategória ako C programy vypisujúce samé seba.

[Tomáš Honzák]

Jistě. Nepokouším se zpochybňovat skutečnost, že se takovouto konstrukcí skutečně dá něco "užitečného" udělat. Ale při vší úctě k autorovi, žádný "programátorský zázrak" to tedy není, a ten samý výsledek se dá dosáhnout "bez magie" jednoduchou inicializací. Bonus navíc - bude to čitelnější. Žádní falešní sobi

Kdyby mi kdokoliv předhodil tenhle kus kódu na code review, nechal bych si velice podrobně vysvětlit, proč to potřebuje naprogramovat právě takhle, a nejspíš bych ho stejně poslal do háje.

Za těch X let, co programuju v PERLu, jsem se s podobně "chytrými" konstrukcemi setkal mnohokrát, a nepovažuju za náhodu, že v mnoha případech se v souvislosti s takovým "geniálním nápadem" o pár řádek výše nebo níže zjevila velice vážná logická chyba, kterou autor, omráčen a zaslepen svým "umem", v zápětí spáchal.

Aby nevznikla mýlka -- pěkný obfuscated kód si taky rád prohlídnu a příležitostně nosím klasické PERL triko s camel.pl skriptem na zádech a use strict na břiše

Ale v tomhle případě, stejně jako v desítkách dalších podobných, prostě nic zajímavého a elegantního nevidím. Yet another "obfuscated" one-liner.

[happy barney]

na ukážke je podstatná časť map keys %$_ všetko ostatné je len prezentácia výsledkov. Viem si kľudne predstaviť situáciu, kde nechcená / neuvedomená si inicializácia $_ dokáže vynechať nasledujúce podmienky.

Ja som to, priznávam, dohromady nedal, hoci potom, ako som videl výpis, mi došlo ktorá bije.

[Hynek (Pichi) Vychodil]

Uhádl, přesně o to šlo. Ta inicializace byla nechtěná. Že se založí ty klíče, to jsem čekal, ale že rovnou založí i ty hashe pod tím, to mě přece jen dostalo, i když je to celkem "předvídatelné"

[Hynek (Pichi) Vychodil]

<perex>Vyser si voko machříku!</perex> Podle stylu a obsahu, bych to skoro typnul, že to napsal uhrovitý puberťáček co si hraje na ultra hyper korporátního systémového analytika a pak kuk, on to jen o dva roky mladší celkem rozumnej človek.

No, je to "hezký", ale k čemu je to dobrý?

Jako varování a malé naťuknutí na co si dát pozor

Nepřestane mne fascinovat, jak lidi dokážou psát s odpuštěním prasácky nečitelné one-linery jenom proto, "že to jde".

<rejp>Nepřestane mě fascinovat, kde ti lidi ty křišťálové koule pořád berou.</rejp> Jako oneliner je to proto, aby si to mohl každý vyzkoušet aniž by zakládal nějaké soubory a podobně. I kolegům po Jabberu radši pošlu oneliner na kterém problém demonstruji, než abych jim posílal kusy kódu, na který by si museli strkat do souboru a ten pak spouštět.

PERL je fantasticky užitečný jazyk, který dokáže zásadním způsobem usnadnit práci s daty, to celé s nízkými náklady na "zaškolení", bez nutnosti chápat složitá paradigmata OOP či studovat tuny knihoven.

No to je fakt vtipné. Ten kód je součástí OOP kódu, tedy vnitřek jedné metody

#-------------------------------------------------------------------------------
# Method: involved
#	Method returns ids of involved objects requested types. If none type
#	used as parameter, returns all.
#
# Parameters:
#	type	- name of requested type
#
# Returns:
#	array	- list of ids
#-------------------------------------------------------------------------------
sub involved {
	my $self = shift;
	return () unless $self->{involved};
	return map $_ ? keys %$_ : (),
		   @_ ? @{$self->{involved}}{@_} : values %{$self->{involved}};
}

Shodou okolností právě při testování kódu unit testy jsem to zjistil. Jasně, že by to šlo napsat víc objektově, ale já taky trošku myslím na rychlost. Celý ten kód by šel krásně rozbít do dalšího objektu, který by dělal kolektor těch involved objektů a kolektor typů a pak by jsme místo toho jednoho mapu měli O(n) volání jedné metody ve které by se volala další metoda, fakt efektivní.

Ono stačí málo. use strict; use warnings;. Trocha štábní kultury při psaní komentářů. Dodržování nějakých coding standardů.

perl -mstrict -mwarnings \
-mData::Dumper -e '
my $a;    # declare variable
map keys %$_, @$a{qw(a b c)}; # try collect keys from hashes stored under some keys in other hash pointed by variable
print Data::Dumper->Dump([$a],["a"]) # dump original variable'

Spokojený, řekl bych, že se to moc nezlepšilo

Jenomže ono je mnohem zábavnější napsat takovouhle nesmyslnou pakárnu a pak s tím machrovat, myslíte, že umíte PERL?

Jedinej kdo tu machruje jseš ty, já jsem si jen blognul upozornění na jednu zákeřnůstku.

Mimo to bych si dovolil polemizovat s názorem, že míra "umění" nějakého jazyka se dá vyjádřit tím, že člověk rychle zanalyzuje cizí kód.

Dovolím si myšlenkový experiment. Vezměte si nějaký složitější vlastní program (delší než 1 000 řádek)

Hmm, je to součástí SW, který má momentálně 47330 řádek. Tak 1 000 si snad představit dokážu.

, na jehož zdrojáky jste už pár měsíců nesáhli, a nahraďte všechny jména souborů, proměnných, funkcí, konstant a textových výstupů náhodnými řetězci. Odstraňte veškeré debuggovací výstupy. Přeházejte pořadí, v jakém jsou funkce nadeklarovány. Pak si najděte jednu funkci někde uprostřed, a zkuste vymyslet, co se uvnitř děje a k čemu je to dobré. Velmi pravděpodobně si budete muset zahrát na kompiler či interpreter, abyste se dobrali alespoň k něčemu. A máte pocit, že to vypovídá o tom, jak dobře ten konkrétní jazyk umíte? Přesně o tom je totiž tenhle zápisek.

Hmm, a přesně proto z těch 47330 je víc než polovina komentářů a všechen novej kód má víc řádek testů než samotného kódu. He?

[Tomáš Honzák]

Hezký den,

obávám se, že jste vůbec nepochopil, co se snažím říct.

Jeden příklad za všechny -- psal jsem, že v PERLu se dají psát programy bez nutnosti chápat paradigmata OOP. Tedy že v PERLu se dá psát "neobjektově". A Vy kontrujete tím, že Váš kód je objektový. Proč?

Myslím, že jsem nijak nezpochybňoval Vaše programátorské schopnosti, a pokud z mé reakce máte ten dojem, je mi to líto. Psal jsem to jako svůj názor obecně a nikoliv "Vám na tělo", viz ostatně množné číslo. ( ...na jehož zdrojáky jste už pár měsíců nesáhli... apod. )

Reakce na osobní invektivy si s Vaším svolením odpustím. Nicméně osobní názor o Vás jsem si pochopitelně udělal.

Srdečně zdravím a přeju, aby Vás svět tolik neštval.

[happy barney]

imho ste vy nepochopil, o čo bol tento blog. A ani príspevok, na ktorý reagujete.

Autor sa podelil o chybu, ktorej vznik si neuvedomil. To tu mal pastnuť všetkých 43k riadkov a ukázať na jeden "aha tu je všeobecná chyba" ?

[Tomáš Honzák]

Já jsem především reagoval určitý kousek kódu a tři věty, které ho uvozovaly.

Autor se, řekl bych, ptal, jestli si myslíme, že umíme PERL, a pokud ano, ať se zkusíme zamyslet nad daným kódem.

Já jsem si dovolil zpochybnit vztah mezi "uměním PERLu" a obfuscated kódem a doplnit pár postřehu ze své zkušenosti. IMHO legitimní reakce v blogu. Kdybychom byli v diskusi, držel bych se tématu přísněji.

A Vaše poznámka, jen tak mimochodem, docela koreluje s mým povzdechem, že používání takovýchto "elegantních konstrukcí" mnohdy vede k obtížně odhalitelným nebo nikoliv snadno viditelným chybám, podle mého názoru právě proto, že samotné pochopení konstrukce zabere zbytečně moc mentální kapacity.

Následná reakce autora blogu na můj komentář je kapitola sama pro sebe a s dovolením se k ní nebudu vyjadřovat.

[happy barney]

verzia 1:

map $_ ? keys %$_ : (), @pole;

verzia 2:

map keys %$_, grep defined, @pole;

verzia 3:

my @result;
for my $entry (@pole) {
  push @result, keys %$entry
    if defined $entry;
}

ktorá verzia je elegantná, a ktorá čitateľná ?

[Hynek (Pichi) Vychodil]

Verze 1: nejrychlejší, hůře čitelné, ale jak pro koho

Verze 2: ne moc efektivní/rychlé, relativně čitelné

Verze 3: hrubě neefektivní, vzhledem k přehnané snaze o čitelnost je to nakonec nečitelné

[happy barney]

ad 3: nevraviac o tom, že vynechanie podmienky if defined spôsobí tú istú chybu, na ktorú ste upozorňoval týmto blogom

[Hynek (Pichi) Vychodil]

Jeden příklad za všechny -- psal jsem, že v PERLu se dají psát programy bez nutnosti chápat paradigmata OOP. Tedy že v PERLu se dá psát "neobjektově". A Vy kontrujete tím, že Váš kód je objektový. Proč?

Ano, omlouvám se, četl jsem nepozorně. Nicméně se jedná o jedno přehlédnutí. To se vám to hodilo do krámu, co?

[Tomáš Honzák]

Vážený Pichi,

Vy pořád ještě nechápete, že se skutečně nepokouším o útok na Vaši osobu, ale na "pozoruhodné PERLové konstrukce", a že mne k reakci více méně vyprovokovaly první tři komentáře.

To Vaše přehlédnutí mne utvrdilo v tom, že jste můj příspěvek plně nepochopil, a skutečně se mi hodilo "do krámu" jako objektivní důkaz této skutečnosti.

Osobní invektivy, kterých je Vaše reakce plná, mi zase posloužily, abych si na Vás vytvořil názor. Možná Vám připadám jako machrující frajírek, ale ani to Vám nedává právo oslovit mne tak, jak jste to učinil Vy. Krávy jsme spolu, pokud si dobře pamatuji, nepásli.

Jinak si stojím za tím, že když se člověk trochu snaží, může psát v PERLu kód, který je nejen funkční a elegantní, ale také čitelný a srozumitelný. A že s odpuštěním prasit se dá v jakémkoliv jazyku.

Tímto se s Vámi a Vaším blogem loučím. Svoje stanovisko jsem, myslím, vysvětlil, a o další debatu s Vámi nestojím. Napříště si dám pozor, abych se komentářům ve Vašem blogu vyhnul.

[Hynek (Pichi) Vychodil]

Vážený pane Honzáku,

tak nevím jestli Váš první komentář lze považovat za útok na moji osobu nebo ne. Nicméně stále hovoříte o "pozoruhodných Perlových konstrukcích", ale konstrukce použitá v blogu není ničím pozoruhodná ani nijak obfuskovaná. Je to naprosto normální konstrukce jak vypsat seznam klíčů obsažených v hashích uložených pod definovanými klíči v anonymním hashi uloženém v jedné proměnné. One-liner je schválně rozložen na několik řádků, aby to bylo ještě lépe čitelné. Kód je po přídání deklarace proměnné strict a ani negeneruje žádný warning. One-liner jsem použil, aby si každý danou konstrukci mohl sám vyzkoušet co nejjednodužším způsobem. Nechápu proč regujete na komentáře naprostých laiků pokoušejících se vyvolat flame, na které jsem ani já nereagoval, protože to nemá smysl, jako nový thread a nereagujete přímo na tyto komentáře. Jak je to s elegancí a čitelností je nicméně názorně ukázáno zde, přičemž zdánlivě pro začátečníka nejčitelnější verze 3 trpí stejným neočekávaným chováním na které jsem se snažil upozornit. Ad absurdum

perl -mstrict -mwarnings -mData::Dumper -e '
my ($a, @res);
for my $entry (@$a{qw(a b c)}) {
    push @res, keys %$entry;
}
print Data::Dumper->Dump([$a],["a"]);'

Nebo jestli se vám to zdá stále příliš magické

perl -mstrict -mwarnings -mData::Dumper -e '
my ($a, @res);
for my $entry ($a->{a}, $a->{b}, $a->{c}) {
    push @res, keys %$entry;
}
print Data::Dumper->Dump([$a],["a"]);'

Omlovám se za one-linery.

[happy barney]

predpokladám, že vložený kód je už po oprave
osobne v podobných metódach používam

return unless defined wantarray;
die "wantarray" unless wantarray;

[Hynek (Pichi) Vychodil]

die "wantarray" unless wantarray;

Mi přijde přílišné vodění za ručičku a co když to dotyčný chce? Třeba aby zjistil jestli to vrátí aspoň něco. Naproti tomu

return () unless cosi

se chová celkem předvídatelně. Ve skalárním kontextu je to undef a v array to udělá prázdné pole. Je fak, že to () je tam zbytečně, ale čtenáře to trkne

[happy barney]

ok, uznávam, užívateľ môže chcieť počet prvkov, ktoré mu je metóda schopná vrátiť. Osobne volanie funkcie/metódy vracajúcej zoznam v skalárnom kontexte považujem za chybu. To už radšej nejaký ten iterátor.

[Hynek (Pichi) Vychodil]

Iterátor? To mě zajímá. Myslíte něco jako

#-------------------------------------------------------------------------------
# Method: forEachMetric
#	Do something for each metric. The method automatically sets up <$Report>
#	variable.
#
# Parameters:
#	subref	- pointer to procedure, current metric is in $_
#
# Returns:
#	array	- same as map aplied subref on metrics
#-------------------------------------------------------------------------------
sub forEachMetric #(subref)
{
	(local $Report, my $subref) = @_;
	DieLogFatal {__ "Parameter must be subref"} unless ref $subref eq 'CODE';
	map &$subref, @{$Report->{metrics}};
}

[happy barney]

hmm, ovládam perl zhruba na úrovni 6-ročného Larryho, vy ste za métou 7
mal som skôr na mysli niečo ako:

sub involve {
  return
    unless defined wantarray;
  return bless [ goto &involve ], __PACKAGE__ . '::Iterator'
    unless wantarray;
  return map ...
}

resp viac čitateľné, často efektívnejšie (v mojich problémoch):

sub involve {
  return
    unless defined wantarray;
  return new __PACKAGE__ . '::Iterator' (@_)
    unless wantarray;
  return map ...
}

plus obvyklé metódy

map $iter->$_, qw( count next previous begin end finish );

[Hynek (Pichi) Vychodil]

hmm, ovládam perl zhruba na úrovni 6-ročného Larryho, vy ste za métou 7

Myslím, že jste příliš skromný, na tohle totiž koukám jako puk a nebo nechápu kontext. Můžete uvést příklad použití? Nejvíc mě děsí konstrukce [ goto &sub ] a ani z té čitelnější metody nejsem moc moudrý.

[Hynek (Pichi) Vychodil]

Aha, už mi to pomalu začíná docházet. Žádná magie. Já čekal něco na způsob iterátorů v pythonu. Ten package __PACKAGE__ . '::Iterator'; musí být definovaný a musí mít ty potřebné metody a ty ještě ke všemu musím explicitně volat. Tedy žádná magie.

[happy barney]

zlý zápis, správne

(__PACKAGE__ . '::Iterator')->new

Je možné definovať jeden package Iterátor.

vcelku silná mágia je treba, aby fungovalo to goto Ono si totiž ponecháva kontext. Čiastočne funkčné riešenie by bolo asi takéto niečo

return [ shift->xxx (@_) ] unless wantarray;

[Hynek (Pichi) Vychodil]

Jo, tuhle vlastnost goto znám. Ale v uvedeném kódu by šlo použít i

sub involve {
  return
    unless defined wantarray;
  return bless [ &involve ], __PACKAGE__ . '::Iterator'
    unless wantarray;
  return map ...
}

viz perlsub

       Subroutines may be called recursively.  If a subroutine is called using
       the "&" form, the argument list is optional, and if omitted, no @_
       array is set up for the subroutine: the @_ array at the time of the
       call is visible to subroutine instead.  This is an efficiency mechanism
       that new users may wish to avoid.

           &foo(1,2,3);        # pass three arguments
           foo(1,2,3);         # the same

           foo();              # pass a null list
           &foo();             # the same

           &foo;               # foo() get current args, like foo(@_) !!
           foo;                # like foo() IFF sub foo predeclared, else "foo"

a nebo jsem to vážně nepochopil.

[happy barney]

jj, to by šlo, toto ma nenapadlo

[Kyosuke]

To all: Rozumíte jim někdo? Přeložíte mi to? (Tady mi zřejmě nepomůže ani Gardinerova Egyptská gramatika, přestože jsem do ní nakoukl, neb jsem tam viděl jistou podobnost. )

[Hynek (Pichi) Vychodil]

perl -le 'sub {print reverse @_}->(split"", "?en ,edohop v ot eJ")'

[Hynek (Pichi) Vychodil]

perl -le 'print scalar reverse for "?en ,edohop v ot eJ"'

[happy barney]

Perl is like sex

* It's easy enough to get started, but takes years to get really good
* Doing it fast doesn't mean doing it well
* It's the little details that continue to amaze you
* You don't learn it from a book

[Hynek (Pichi) Vychodil]

To je dobré.

P.S.: Miluju bezzávorkové příkazy s implicitnímy parametry

perl -le 'print scalar reverse for join " ", @ARGV' ?en ,edohop v ot eJ

[happy barney]

^?^\?

(niektoré shell-y tomu otázniku nechcú porozumieť rovnako ako správne nastavený bash)

[Hynek (Pichi) Vychodil]

Some of shells aren't smart enough for me. Co je správné je vždy na diskusi, ale eskejpnout jsem to asi měl.

[Kyosuke]

Hele, totéž se dá říct i o Smalltalku!

[Hynek (Pichi) Vychodil]

Tomu věřím, jestli to umí aspoň polovinu toho co PERL

[Kyosuke]

Jak jsem tak koukal na Smalltalk/X (VM, VM+JIT, statická kompilace do Cčka, sjednocený VM pro Smalltalk a Javu, kompilátor JavaScriptu, interpret Lispu a Prologu a mnoho tisíc knihovních tříd), tak ten snad musí umět i uvařit kafe.

[happy barney]

Uff, tak som nakoniec našiel som ten správny zdroják

use Sub::Uplevel;

sub fun {
    return [ uplevel (1, \&fun, @_) ] unless wantarray;

    return @list;
}

Samozrejme je to výcuc. Sú tam ďaľšie bláznovstvá typu dynamické generovanie dedičnosti, zmena triedy, dekorátory ...

[Hynek (Pichi) Vychodil]

Nojo, jenže tohle mená s iterátory moc společného. Když se na to pozorně podíváš, tak to prostě vrátí v array kontextu pole a v scalar kontextu to vrátí ukazatel na pole, které akorát vyrobí jako volání téže funkce v array kontextu. Hlavní výhodou iterátorů je právě to, že se žádné pole v paměti nevytvoří a to se o tomhle kusu kódu říct nedá. Přesně stejného efektu dosáhneš pomocí

sub fun {
    my @list;
    ... bla bla plníme @list ...
    return wantarray ? @list : \@list;
}

Bez magie a co do rychlosti lepší a co do spotřeby paměti lautr to samé.

[xvasek]

Hm, tak toto není ani pěkné, ani nijak extra fikané. Mazanější konstrukce jsou k vidění i v man perlfunc.