Názory k článku Programovací jazyk TCL

checks = []
checks.append( gtk.CheckButton( label="První" ) )
checks.append( gtk.CheckButton( label="Druhý" ) )
checks.append( gtk.CheckButton( label="Třetí" ) )
checks.append( gtk.CheckButton( label="Čtvrtý" ) )
checks.append( gtk.CheckButton( label="Pátý" ) )

checks = ["První","Druhý","Třetí","Čtvrtý","Pátý"]
for popisek in checks:
    checks.append( gtk.CheckButton( label=popisek ) )

texty = ("První","Druhý","Třetí","Čtvrtý","Pátý")
checks = [gtk.CheckButton(label=i) for i in texty]

To není provokace, to je velmi rozumné.

(if <podmínka> <true-forma> <false-forma>)
(cond (<podmínka> <forma> <forma>*) (<podmínka> <forma> <forma>*)*)

A je to. Odděluje se na horizonální úrovni mezerami a na vertikální závorkami a je to. Víc člověk vědět nemusí. Indentace je povinnost pro čitelnost, ale ve slušném editoru je automatická. Co by mohl člověk chtít víc?

Další mnou kdesi výše jmenované jazyky jsou podobně jednoduché. Python jednoduchý není a spousta jiných jazyků je na tom ještě hůř.

resAB := vysledky select: [ :v | v first & v second ] thenCollect: [ :v | v third ].
resAb := vysledky select: [ :v | v first & v second not ] thenCollect: [ :v | v third ].
resaB := vysledky select: [ :v | v first not & v second ] thenCollect: [ :v | v third ].
resab := vysledky select: [ :v | v first not & v second not ] thenCollect: [ :v | v third ].

select := [:val | vysledky select: [ :v | (v first: 2) = val ] thenCollect: [ :v | v third ] ].
resAB := select value: #(true true).
resAb := select value: #(true false).
resaB := select value: #(false true).
resab := select value: #(false false).

resAB := OrderedCollection new.
resAb := OrderedCollection new.
resaB := OrderedCollection new.
resab := OrderedCollection new.

vysledky do: [ :v |
    (v first & v second) ifTrue: [ resAB add: v third ].
    (v first & v second not) ifTrue: [ resAb add: v third ].
    (v first not & v second) ifTrue: [ resaB add: v third ].
    (v first not & v second not) ifTrue: [ resab add: v third ] ].

V TCL například takto (osobně bych to napsal trošku jinak, ale nebylo by to tak čitelné):

set AB {}
set Ab {}
set aB {}
set ab {}
set vysledky { { 0 0 prvni} { 0 1 druhy} { 1 0 treti} {1 1 ctvrty}}

foreach i $vysledky {
    set podminka1 [lindex $i 0]
    set podminka2 [lindex $i 1]
    set vysledek [lindex $i 2]
    if       [expr $podminka1 & $podminka2] {
        lappend AB $vysledek
    } elseif [expr $podminka1 & ! $podminka2] {
        lappend Ab $vysledek
    } elseif [expr ! $podminka1 & $podminka2] {
        lappend aB $vysledek
    } else { lappend ab $vysledek}
}
puts $AB
puts $Ab
puts $aB
puts $ab

Podle mě trošičku lepší řešení, kde se pořád neopakuje stejná operace:

set AB {}
set Ab {}
set aB {}
set ab {}
set vysledky { { 0 0 prvni} { 0 1 druhy} { 1 0 treti} {1 1 ctvrty}}

foreach i $vysledky {
    set podminka1 [lindex $i 0]
    set podminka2 [lindex $i 1]
    set vysledek [lindex $i 2]
    if       [expr $podminka1 & $podminka2] {
        set seznam AB
    } elseif [expr $podminka1 & ! $podminka2] {
        set seznam Ab
    } elseif [expr ! $podminka1 & $podminka2] {
        set seznam aB
    } else {
        set seznam ab
    }
    lappend $seznam $vysledek
}

puts $AB
puts $Ab
puts $aB
puts $ab

Vážený pane, před uzavírací závorkou nejsou žádné hvězdičky. Najděte si v nějakém slovníku výpočetní techniky slovo „metaznak“.

Hvězdičky jsou na místech, kde se prvek před nimi může vyskytnout alespoň jednou nebo se nemusí vyskytnout vůbec. Alternativa by byla místo <forma> <forma>* napsat jen <forma>+, ale zjevně by to byla marná snaha, pokud Vám unikla konvence hvězdičky, asi byste těžko pochopil plus. A já myslel, že tenhle (pravda, mírně neformální, ale celkem běžný) zápis budou znát všichni. Narážím na něj dnes a denně a regulární výrazy se taky snad běžně používají.

Není co chápat na tom, proč jsou jen na druhém řádku. Jako kdybyste říkal, že při čtení syntaxe Cčka (aby se ji naučil) musí člověk předem vědět, proč se kde v Cčku píší jaké závorky a kam který prvek jazyka. Omyl! Zápis syntaxe je tu právě od toho, aby mu řekl, kam má co psát.

Pokud nedokážete pochopit (k této domněnce mne vede zjevná nesouvislost vaší odpovědi a mého příspěvku, nebo přinejmenším souvislost neviditelná pro mne) ani takhle triviální zápis dvou nezávislých syntaktických konstrukcí (příklad formy if a příklad formy cond), jsem zvědavý, jak byste se tvářil na BNF zápis, který do toho zamíchá třeba ještě rekurzi.

(let (|ab| |aB| |Ab| |AB|)
    (loop for (a b c) in results
        if a 
            if b
                collect c into |AB|
                else collect c into |Ab|
            else 
            if b
                collect c into |aB|
                else collect c into |ab|
        finally (return (values |ab| |aB| |Ab| |AB|))))

"Tok programu totiž odporuje přirozenému (či ve škole naučenému, viz matematika, fyzika) myšlení."

Přirozené? Odkdy je na středověkém algebraickém zápisu něco "přirozeného"? To, že se z nějakého důvodu ujal? (A podotýkám, že vznikl v prostředí mnohem jednodušších jím zapisovaných problémů. Dnes máme trošku jinou dobu.)

"To nespravíte ani odsazováním a navíc tak máte jak náročné odsazování tak miliony nepřehledných (protože do sebe x krát vnořených) závorek. Vím co to znamená hledat zapomenutou závorku v Céčku, fakt bych to nechtěl dělat v Lispu :-). "

Nevím jak Vy, ale za mě všechny tyhle věci dělá editor, a to nejen v Lispu.

BTW, jestli je to opravdu zavedený zápis, vždycky přeci můžu použít:

#I( x = (a+b) / (c-d) )
#I( attr(y) = z )

(SETQ X (/ (+ A B) (- C D)))
(SETQ (ATTR Y) Z)

Nevypadá to téměř stejně? :-) Uznávám, že by bylo dobré mírně CL-INFIX modifikovat, kvůli tomu structu, ale syntaktický převod je ekvivalentní. Zkusím si ho někdy dát za domácí úkol. (Jestli se někdy dostanu domů... :-D) Navíc s objekty by to tak jako tak nefungovalo, CLOS není tak omezený, aby podporoval jen single-dispatch. A když už jsme u té srozumitelnosti jazyků:

„No proper program contains an indication which as an operator-applied occurrence identifies an operator-defining occurrence which as an indication-applied occurrence identifies an indication-defining occurrence different from the one identified by the given indication as an indication-applied occurrence.“
-- ALGOL 68 Report

Ideální pro začátečníky, že? ;-)

Já už mu daroval mu ANSI Common Lisp od Grahama. (Je to opravdu velmi dobrý přítel... :-)) Nicméně ve Scheme již cosi udělal, ale nadává na PLT Scheme pro jeho pomalost. Překvapí vás, že v době, kdy už měl nějaký ten software ve Scheme napsaný, jsem mu musel vysvětlit, jak že to je se statickým scopingem a k čemu slouží LET? (To bylo v souvislosti s otázkou "jak udělám funkci, která si mezi dvěma voláními bude něco pamatovat, třeba jako static proměnné v Cčku" :-)) Možná za to může ten AutoLISP... :-)))

Stejně se domnívám, že nakonec zvládneme on i já (já jsem taky pořád v zácviku :-)) jak Scheme, tak i Common Lisp a pak si budeme moci vybírat podle potřeby. (I když, nevím, uvidíme, jestli já budu dřív umět hrát ha harfu nebo on pracovat s modernějším Lispem. Já věřím tomu druhému, on mě přesvědčuje o tom prvním... ;-))

"Bytekód je jen výsledek parsingu zdrojového kódu, je to pořád ten zdroják, jen ve formě, které rozumí interpret."

http://cvs.sourceforge.net/viewcvs.py/*checkout*/python/python/dist/src/Include/opcode.h?rev=2.39.2.2

No, opravdu to musí po kompilaci připomínat zdroják... :-D

Příprava dat trvala 15.422000 s
První test trval    3.875000 s
Druhý test trval    2.000000 s

==================

[4]> (load "test.fas")
;; Loading file test.fas ...
Real time: 11.421875 sec.
Run time: 10.140625 sec.
Space: 136005080 Bytes
GC: 24, GC time: 3.578125 sec.
Bytes permanently allocated:       66792
Bytes currently in use:         33629196
Bytes available until next GC:   8407299
Alokovanych bajtu: 33629196

Real time: 0.703125 sec.
Run time: 0.671875 sec.
Space: 8000032 Bytes
Real time: 0.78125 sec.
Run time: 0.734375 sec.
Space: 8000032 Bytes
AB: 250788
aB: 249885
Ab: 249285
ab: 250042
;; Loaded file test.fas
T

(macroexpand '(cond ((= a 1) 12)
                    ((= a 2) 35) 
                    ((= a 3) 551) 
                    (t 3214)))

(IF (= A 1) 
    12 
    (IF (= A 2) 
        35 
        (IF (= A 3) 
            551 
            3214)))

Mimochodem, za takovéhle příspěvky by se asi v newsgroupě objevilo "RTFM". Snad si umíte přečíst dokumentaci, ne? Implementace GC je překvapivě záležitost implementace, ne jazyka, který od toho odstiňuje a dost možná je v jeho specifikaci výslovně zmínka, že tyhle věci se v normě jazyka _neřeší_. Schválně se podívám. Kód, který jsem poslal, je spustitelný v CLISPu a CMUCL, jak jsem psal. Až mi váš kód nebude fungovat v IronPythonu nebo v Jythonu, mám taky začít nadávat?

A pokud se chcete naučit Common LISP nenásilnou formou, zkuste třeba http://www.gigamonkeys.com - ta knížka je výborná. Je to Common LISP, tak, jak je popsaný v HyperSpecu, ne konkrétní implementace - radši to předesílám předem.

„Není tu ale deset různých nekompatibilních implementací Pythonu pro to samé prostředí. Tohle skutečně hodnotu Lispu snižuje.“

Tak tohle jsem nepochopil. Jednak ta nekompatibilita je pouze v nestandardizovaných věcech, což je typicky malá část programu (a už jsem to v mnohla LISPovských kódech viděl, třeba 200-300 kB kódu společného a 5-15 kB kódu pro každou implementaci - de facto hnída), jednak - proč je možnost výběru nevýhodou? Prostě si vyberte jednu implementaci, tu používejte, na ostatní zapomeňte...lo and behold! Máte jednu implementaci. ;-)

BTW, ty tři implementace Pythonu jsou na tom asi stejně jako ty LISPy - každý je dobrý v něčem jiném, pokud jde o interakci se zbytkem světa.

Ale to si pletete implementaci a jazyk. :-)

Použil jsem CLISP a CMUCL, což jsou dvě implementace, které se mi dost líbí (CMUCL je výkonnostně možná nejlepší LISP vůbec), a ten benchmark jsem pustil interaktivně:

(compile-file "neco.lisp")
(load "neco.fas")

(compile-file "neco.lisp")
(load "neco.x86f")

případně to nějak narvat do parametrů příkazového řádku, ale to jsem zatím nepotřeboval. Ostatně v obou implenentacích se dá aplikace zabalit do image tak, že se po spuštění image ve VM spustí rovnou zadaná funkce, u CMUCL se to snad dá udělat i přímo spustitelné.

Vybrat si GCL, to je odvaha, tam jsou věci trošku složitější a zatím s ním nemám zkušenosti.

Jo a samozřejmě je dobré použít správnou cestu k souboru s daty.

Python v žádném případě není jednoduchý. Jediné jednoduché jazyky, které znám jsou Lisp, Scheme, FORTH, Smalltalk, Self a případně i TCL, i když ty na začítku seznamu vedou.

Čitelný bloatware je pořád bloatware. Nic proti tomu, že je to snadno naučitelný bloatware (mám Python rád, stejně tak i Ruby), aspoň má výhody oproti megabloatwaru s názvem „C++“, který má z mého pohledu nejhorščí poměr bloat/užitečnost v celé historii programování, ale pořád jím zůstává.