Coppwr, tj. GUI nástroj pro nízkoúrovňové ovládání PipeWire, byl vydán v nové verzi 1.6.0. Zdrojové kódy jsou k dispozici na GitHubu. Instalovat lze také z Flathubu.
Byla vydána dubnová aktualizace aneb nová verze 1.89 editoru zdrojových kódů Visual Studio Code (Wikipedie). Přehled novinek i s náhledy a animovanými gify v poznámkách k vydání. Vypíchnout lze, že v terminálu lze nově povolit vkládání kopírovaného textu stisknutím středního tlačítka myši. Ve verzi 1.89 vyjde také VSCodium, tj. komunitní sestavení Visual Studia Code bez telemetrie a licenčních podmínek Microsoftu.
Proton, tj. fork Wine integrovaný v Steam Play a umožňující v Linuxu přímo ze Steamu hrát hry určené pouze pro Windows, byl vydán ve verzi 9.0-1 (𝕏). Přehled novinek se seznamem nově podporovaných her na GitHubu. Aktuální přehled her pro Windows běžících díky Protonu také na Linuxu na stránkách ProtonDB.
Byla vydána verze 1.78.0 programovacího jazyka Rust (Wikipedie). Podrobnosti v poznámkách k vydání na GitHubu. Vyzkoušet Rust lze například na stránce Rust by Example.
Služba Dropbox Sign (původně HelloSign) pro elektronické podepisování smluv byla hacknuta.
Byla vydána nová major verze 8.0 textového editoru GNU nano (Wikipedie). Podrobný přehled novinek a oprav v oznámení v diskusním listu info-nano nebo v souboru ChangeLog na Savannah. Volbou --modernbindings (-/) lze povolit "moderní" klávesové zkratky: ^C kopírování, ^V vložení, ^Z vrácení zpět, … Tato volba je aktivována také pokud binárka s nano nebo link na ni začíná písmenem "e".
Před 60 lety, 1. května 1964, byl představen programovací jazyk BASIC (Beginners' All-purpose Symbolic Instruction Code).
Byla vydána nová verze 12.0 minimalistické linuxové distribuce (JeOS, Just enough Operating System) pro Kodi (dříve XBMC) a multimediálního centra LibreELEC (Libre Embedded Linux Entertainment Center). Jedná se o fork linuxové distribuce OpenELEC (Open Embedded Linux Entertainment Center). LibreELEC 12.0 přichází s Kodi 21.0 "Omega".
Microsoft vydal novou velkou aktualizaci 2404.23 v září 2019 pod licencí SIL Open Font License (OFL) zveřejněné rodiny písma Cascadia Code pro zobrazování textu v emulátorech terminálu a vývojových prostředích.
OpenTofu, tj. svobodný a otevřený fork Terraformu vzniknuvší jako reakce na přelicencování Terraformu z MPL na BSL (Business Source License) společností HashiCorp, bylo vydáno ve verzi 1.7.0. Přehled novinek v aktualizované dokumentaci. Vypíchnout lze State encryption.
víťaz? perl 
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. 
AbcLinuxu.cz
ITBiz.cz
HDmag.cz
AbcPráce.czuse 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
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.
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.
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.
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?
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.
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" ?
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á ?
Verze 2: ne moc efektivní/rychlé, relativně čitelné
Verze 3: hrubě neefektivní, vzhledem k přehnané snaze o čitelnost je to nakonec nečitelné
if defined spôsobí tú istú chybu, na ktorú ste upozorňoval týmto blogom
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?
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.
return unless defined wantarray; die "wantarray" unless wantarray;
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 cosise 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
#-------------------------------------------------------------------------------
# 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}};
}
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 );
hmm, ovládam perl zhruba na úrovni 6-ročného Larryho, vy ste za métou 7Myslí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ý.
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.
(__PACKAGE__ . '::Iterator')->newJe 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;
goto znám. Ale v uvedeném kódu by šlo použít isub 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.
(Tady mi zřejmě nepomůže ani Gardinerova Egyptská gramatika, přestože jsem do ní nakoukl, neb jsem tam viděl jistou podobnost. )
perl -le 'sub {print reverse @_}->(split"", "?en ,edohop v ot eJ")'
perl -le 'print scalar reverse for "?en ,edohop v ot eJ"'
perl -le 'print scalar reverse for join " ", @ARGV' ?en ,edohop v ot eJ
(niektoré shell-y tomu otázniku nechcú porozumieť rovnako ako správne nastavený bash)
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 ...
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é.
Tiskni
Sdílej:
7.12.2006 00:11