Byla vydána nová verze 24.04.28 s kódovým názvem Time After Time svobodného multiplatformního video editoru Shotcut (Wikipedie) a nová verze 7.24.0 souvisejícího frameworku MLT Multimedia Framework. Nejnovější Shotcut je vedle zdrojových kódů k dispozici také ve formátech AppImage, Flatpak a Snap.
Byla vydána verze 5.30 dnes již open source operačního systému RISC OS (Wikipedie).
V aktuálním příspěvku na blogu počítačové hry Factorio (Wikipedie) se vývojář s přezývkou raiguard rozepsal o podpoře Linuxu. Rozebírá problémy a výzvy jako přechod linuxových distribucí z X11 na Wayland, dekorace oken na straně klienta a GNOME, změna velikosti okna ve správci oken Sway, …
Rakudo (Wikipedie), tj. překladač programovacího jazyka Raku (Wikipedie), byl vydán ve verzi #171 (2024.04). Programovací jazyk Raku byl dříve znám pod názvem Perl 6.
Společnost Epic Games vydala verzi 5.4 svého proprietárního multiplatformního herního enginu Unreal Engine (Wikipedie). Podrobný přehled novinek v poznámkách k vydání.
Byl vydán Nextcloud Hub 8. Představení novinek tohoto open source cloudového řešení také na YouTube. Vypíchnout lze Nextcloud AI Assistant 2.0.
Vyšlo Pharo 12.0, programovací jazyk a vývojové prostředí s řadou pokročilých vlastností. Krom tradiční nadílky oprav přináší nový systém správy ladících bodů, nový způsob definice tříd, prostor pro objekty, které nemusí procházet GC a mnoho dalšího.
Microsoft zveřejnil na GitHubu zdrojové kódy MS-DOSu 4.0 pod licencí MIT. Ve stejném repozitáři se nacházejí i před lety zveřejněné zdrojové k kódy MS-DOSu 1.25 a 2.0.
Canonical vydal (email, blog, YouTube) Ubuntu 24.04 LTS Noble Numbat. Přehled novinek v poznámkách k vydání a také příspěvcích na blogu: novinky v desktopu a novinky v bezpečnosti. Vydány byly také oficiální deriváty Edubuntu, Kubuntu, Lubuntu, Ubuntu Budgie, Ubuntu Cinnamon, Ubuntu Kylin, Ubuntu MATE, Ubuntu Studio, Ubuntu Unity a Xubuntu. Jedná se o 10. LTS verzi.
Na YouTube je k dispozici videozáznam z včerejšího Czech Open Source Policy Forum 2024.
(display "Hello World!")(newline)
public static int
… az do konca zivota.
C++ (a v mensej miere aj Java) je ale dobry jazyk, ked uz clovek programovat vie a rovnako vie, preco ho chce pouzit (typicky rychlost programu alebo sprava pamate). Skoda len, ze takych ludi je desiva mensina. Tolko moj dnesny povzdych
s vyse uvedenym clankem je potiz -- ze vlastne krome par vtipku a strucneho uvodu nic neresi... ani prefixovou notaci, natoz proces vyhodnocovani, na toz vubec podstatu lisp-like jazyku.... mozna by to chtelo cely serial malinko zhutnit...Přesně o to mi šlo – není problém napsat pár článků o syntaxi Scheme, o tom, jak se píšou podmínky atd. Ale zrovna u jazyků LISPovské rodiny je celkem vhodné se rozepsat i o jejich podstatě a filozofii. A to už není jen tak... No bezva, tak to už jsme dva, kdo budeme na Kyosukeho vyvíjet mírný nátlak v mezích zákona.
seznam[::-1]
zvykl na (reverse seznam)
protože to druhé je oproti tomu prvnímu šíleně nečitelné a nepraktické. </rejp>
<type 'reversed'>
". Netuším, co to má znamenat (představuju si, že typy pasují skutečně k typům hodnot, jako je float, int, list a podobně), ale moje představa je taková, že objektový jazyk by mohl mít něco jako univerzální API pro sekvence - jako že když nad objektem zavolám o.reversed()
, vrátí mi objekt stejného typu, jen pozadu. Když chci udělat vlastní typ s rozhraním sekvence, netuším, jak ho pro reversed(o)
přetížím (pokud Python nemá CLOSoidní objektový systém, jako má třeba Gauche), leda, že bych všude psal type(a)(reversed(a))
, což je ukrutné. A o.reverse()
je zase destruktivní.
Koukám teď, že sorted(o)
bude téhož zrna. Nemám námitky proti Pythonu jako jazyku (nebo jen víceméně malé), ale spíš proti takovýmhle věcem. Jak píšu jinde, ve Scheme leckdy název funkce a způsob jejího použití jednoduše uhádnu (a nemusím hledat), páč je to mírně konzistentnější, což mi je velmi milé. Ale to možná je jen věc vkusu, různí lidé si standardní knihovnu asi mohou představovat jinak.
;; Funkce přijímá matici A velikosti (m x n) [(sloupce x řádky)] ;; a matici B velikosti (o x m). Vrací matici ;; velikosti (o x n). (define (mmul A B) (let ((m (array-length A 1)) ;; Počet sloupců matice A (vlevo) (n (array-length A 0)) ;; Počet řádků matice A (vlevo) (o (array-length B 1))) ;; Počet sloupců matice B (nahoře) (tabulate-array (shape 0 o 0 n) ;; Generujeme prvky výsledku (lambda (i j) ;; (o x n) po řádcích. (sum-ec (: k 0 m) ;; Sečteme pro všechny (* (array-ref A i k) ;; sloupce A a řádky B (array-ref B k j)))))))Ale nejsem až taký dobrý schemař, třeba mě časem napadne i něco lepšího. S vícerozměrnými poli ve Scheme si teď hraju vůbec prvně a to API neznám. Tohle ale IMHO vypadá celkem rozumně.
Za prve, LispMe prostredi je hodne spartanske, a ja ho musel pouzit, protoze jsem nic jineho k ruce nemel (i kdyz je fakt, ze jsem se Scheme trochu naucit chtel).Já myslím, že od prostředí s pár sty kilobajty se toho zas až tolik čekat nedá...
Patrne proto jste pouzil funkce z urcite (ne)standardni knihovny, ktere tuto komplikaci odstinuji.Standardní. Ale upozorňuji, že to nejsou všechno funkce, comprehensions jsou syntaktické rozšíření (ostatně je máte i v Pythonu). Nicméně tahle rozšíření prošla peer-review, jsou již několik let v platnosti a většina dobrých implementací je přijala. (Stejně jako se časem přidávaly věci do Pythonu.) Pokud jde o použitelnost, s tím se dá souhlasit: Dost často je dobré mít nástroj bližší běžným potřebám. I proto (pokud jde o Scheme) používám Gauche, které mě nenutí dělat spoustu i z mého pohledu zbytečných věcí (ilustrativní jsou třeba regexpy a jejich přímá aplikace jako v Perlu nebo Ruby, namísto toho, abych s nimi musel proskakovat nějakými funkcemi). Ostatně i Python je taková praktičtější verze Lispu, tedy aspoň to tvrdí Peter Norvig. A vůbec, já netvrdím, že Python je špatný jazyk. Mně jen odradil určitý vnitřní bordel v implementaci, když jsem se pokoušel pochopit jazykový model, abych mohl kupříkladu dělat bindingy, nebo se vrtat v runtimu a tak. A příšerně rozházená standardní knihovna, prakticky bez jakýchkoli konvencí, což mě nutilo hledat v dokumentaci a nemohl jsem hádat (= používat intuici), kteýžto postup v Ruby a Gauche prakticky zaručeně funguje a frustruje mě podstatně méně. Jinak jako jazyk (gramatika, sémantika a podobně) je moc fajn, na tom se určitě shodneme.
Jde o to, ze funckionalne clovek (tj. v rekurzivnich smyckach misto iterativnich smycek) clovek dost casto neuvazuje. Patrne proto jste pouzil funkce z urcite (ne)standardni knihovny, ktere tuto komplikaci odstinuji.Ano, takto uvažuje mnohem častěji implementátor jazyka než jeho uživatel. Nicméně v lispovských jazycích může být uživatel jazyka sám sobě jeho implementátorem a tak mu je tail recurision poskytnuta jako základní prostředek k vlastním implementacím jazykových fíčur. Od toho, aby člověk používal konstrukce méně abstraktní a více názorné, jsou tu makra a funkce vyššího řádu (někdy je lepší to, někdy zase ono, a řeší to tak i Python a přiznává to i Guido). Tvrdit, že Scheme je špatné, protože řeší smyčky rekurzivní aplikaci procedur, je asi tak moudré, jako tvrdit, že Cčko je špatné, protože má goto a protože všechny ty whily a fory nakonec skončí jako
Jc <adresa>
. Nikdo nikoho v Cčku nenutí psát smyčky pomocí goto. (Když už jsme u těch analogií. )
gosh> (use gauche.array) #<undef> gosh> (define A #,(<array> (0 2 0 2) 10 2 0 -3)) A gosh> (define B #,(<array> (0 2 0 2) 2 1 -1 2)) B gosh> (array-mul A B) #,(<array> (0 2 0 2) 18 14 3 -6) gosh> (array-expt A 2) #,(<array> (0 2 0 2) 100 14 0 9)(Aneb "vždycky se podívej pořádně, co vlastně máš ve standardní knihovně svého jazyka..." )
(define A '((1 0 2) (-1 3 1))) (define B '((3 1) (2 1) (1 0))) ;; testovaci matice A, B (define multiply_matrix (lambda (A B) (let create_rows ((A A)) (if (null? A) '() (cons (let create_member ((B B)) (if (null? (car B)) '() (cons (apply + (map * (car A) (map car B))) (create_member (map cdr B))))) (create_rows (cdr A))))))) (multiply_matrix A B) :==> ((5 1) (4 2))
(define multiply_matrix (lambda (A B) (map (lambda (x) (let create_member ((B B)) (if (null? (car B)) '() (cons (apply + (map * x (map car B))) (create_member (map cdr B)))))) A)))
(define (matrix-multiply a b) (map (lambda (lx) (map (lambda (ly) (apply + (map * lx ly))) (matrix-transpose b))) a))
(define (matrix-multiply a b) (map (lambda (lx) (map (lambda (ly) (apply + (map * lx ly))) (apply map list b))) a))BTW, je to takhle o dva znaky kratší - jak že bylo to řešení v Pythonu na tři řádky? (Ale moje námitka ohledně efektivity zůstává, a to mlčím i o tom
array-mul
, co jsem nakonec v Gauche našel. )
(map <něco> A)
) byl celkem jasný a na konec (transpozici) jsem přišel kdysi před lety ještě v Pythonu (akorát tam jsem ho dělal přes b_transposed = zip(*b)
), jen ta věc mezi tím mi nějak ušla. Bídáku! A já mám jít spát střízlivý, jo? A ještě s map
a apply
kroužícími hlavou. (Hmmm, to ale taky není zrovna nejlepší naplnění slova "střízlivý"... )
(apply map list '((1 2 3) (4 5 6))) => (map list '(1 2 3) '(4 5 6)) => ;; (map f list1 list2 list3 ... listn) -> \ (cons (f (car list1) (car list2) (car list3) ... (car listn)) (map f (cdr list1) (cdr list2) (cdr list3) ... (cdr listn))) (cons (list 1 4) (cons (list 2 5) (cons (list 3 6) '()))) => '((1 4) (2 5) (3 6))
t([[]|_]) -> []; t(X) -> [ [ H || [H|_]<-X ] % cut heads | t([ T || [_|T]<-X ]) % transpose tails ].Ten scheme map je něco jako erlangový zipwith, ale zipwithN. Je to mnohem pružnější, protože erlangový map umí pracovat jen s jedním seznamem.
(map * lx ly)
o kousek vlevo byla "brnkačka", tak snad není problém pochopit ani tohle.
apply
definováno tak, že poslední argument (zde b) musí být seznam, který se připojí na seznam argumentů volané procedury. Všechny předchozí s výjimkou prvního se připojí před něj, a první poslouží jako operátor. Názorněji: (apply + 1 2 3 '(4 5 6))
je totéž, co (+ 1 2 3 4 5 6)
. (BTW, apply
přece taky patří do "brnkačky"... )
(apply map list '((1 2 3) (4 5 6))) => (map list '(1 2 3) '(4 5 6))me z toho leze:
(apply map list '((1 2 3) (4 5 6))) => (map (list '(1 2 3) '(4 5 6)))
(apply a b c)
vede na `(a (b ,@c))
? Jaký by to mělo smysl? U mně (apply a b c)
zásadně vede na `(a b ,@c)
, a je to tak i ve specifikaci.
Globální (dynamicky vázané) proměnné se (aspoň v CL) docela hodí pro defaultní parametry funkcí, pokud je jeden netouží psát. Jak tohle řešit bez nich?
clhs pro write:
Parameter Corresponding Dynamic Variable array *print-array* base *print-base* case *print-case* circle *print-circle* escape *print-escape* gensym *print-gensym* length *print-length* level *print-level* lines *print-lines* miser-width *print-miser-width* pprint-dispatch *print-pprint-dispatch* pretty *print-pretty* radix *print-radix* readably *print-readably* right-margin *print-right-margin*
A pořád mi není jasné, jak se principiálně liší globální proměnná od globální funkce - a ty snad ve Scheme jsou morálně bez problému, ne? Ostatně měl jsem za to, že globální proměnné tam taky máte.
Jinak místní schemeři (little, seasoned i reasoned) mě asi nebudou mít rádi, ale myslím, že pro praktické účely je CL často použitelnější (aspoň pokud mluvíme opravdu o holých standardech), byť nabízí více možností a tak je méně čisté - zmiňované do macro (v obou standardech) je IMHO opravdu pruda a méně čitelné než obdobná loop konstrukce. Kromě toho je k dispozici i funkcionálně čistší kombinace map/reduce (což je možná ve scheme taky, ne? Nebo si to lze aspoň napsat s rekurzí), a samozřejmě i ta proklatá rekurze :)
zmiňované do macro (v obou standardech) je IMHO opravdu pruda a méně čitelné než obdobná loop konstrukce.A právě proto máme základní odpověď na scoping, control flow a vůbec, totiž SRFI-42.
Olomouc, no jo ta stodola na kopci.
Stodola pod kopcem. A mám pocit, že ta stodola tady byla dřív než Praha.
Jinak v komerci jazyk na .... moc sem si zneho neodnesl a v realu jsem ho uz nevidel.
Každému co jeho jest. Je dobře, že v komerci moc není -- zmizela by část vhodnosti pro výuku.
LISP is worth learning for a different reason — the profound enlightenment experience you will have when you finally get it. That experience will make you a better programmer for the rest of your days, even if you never actually use LISP itself a lot.btw. osobne muzu rict, treba ze az diky uzaverum ve schemu se me podarilo poradne pochopit anonymni tridy v jave... a pak ze to s realnym svetem nema nic spolecneho.
delej
má obsahovať funkciu, ktorá sa má volať. V tom prípade to bude takto (s ešte malo úpravou, kedy tá funkcia bude brať ako argument počítadlo)
(define (pokud od do delej) (cond ((>= do od) (delej od) (pokud (+ 1 od) do delej))))A volať sa to bude takto
(pokud 1 5 (lambda (x) (display x) (newline)))Citácia tu nikde potrebná nebude. Dá sa síce napísať makro, ktoré by to volanie
pokud
expandovalo na (do - od + 1)
volaní zadaného kódu delej
, ale to Vy zjavne nepotrebujete.
(#f #f)
coby parametr if
-u mělo mít hodnotu?
Tiskni Sdílej: