Zobrazit příspěvky

Tato sekce Vám umožňuje zobrazit všechny příspěvky tohoto uživatele. Prosím uvědomte si, že můžete vidět příspěvky pouze z oblastí Vám přístupných.


Příspěvky - Franta Kučera

Stran: [1] 2 3 ... 11
1
Desktop / Re:Směr práce se dvěma okny
« kdy: 13. 10. 2025, 23:24:29 »
Typicky zleva doprava tzn. jako píšeme a čteme. Alespoň pokud jde o kopírování/přesouvání souborů v ortodoxních správcích souborů (např. mc). Když je toho víc a mám tam složky obráceně, tak je prohodím pomocí Ctrl+U. Pokud ale chci zkopírovat třeba jen jeden soubor, tak klidně v „opačném“ směru. Pokud jde o práci v IDE, tak tam mám většinou otevřené dva zdrojáky vedle sebe + vlevo panel se stromem projektů, tříd atd. Hlavní práci pak dělám v tom zdrojáku vlevo (protože je uprostřed obrazovky) a ten soubor vpravo slouží spíš jako dokumentace (dá se tedy říct, že tady „opisuji“ zprava doleva tzn. opačně než v tom mc). A když by šlo o přetahování myší mezi okny, tak mi asi taky přijde intuitivnější směr zprava doleva, protože jsem pravák, chytnu tu myš a ikonu vpravo a táhnu ji před sebe a ne někam pryč do strany.

Nevím, jestli tahle informace nějak pomohla :-) Čeho to vlastně bude koncept – celého desktopového prostředí nebo nějaké jedné aplikace?

2
Server / Re:hledání zprávy v postfixu
« kdy: 07. 10. 2025, 10:14:02 »
Klient si ten soubor může pojmenovat, jak chce, takže na serveru bude název jiný (klient ho ani nezná, takže šance, že by byly stejné se blíží nule).

Ten antivir dal asi zprávu do karantény, ne? Tak bych se k němu dostal a hledal podle obsahu (typicky postačí předmět a přibližné datum).

Pokud se k té zprávě nedostaneš, tak bych hledal podle data a času – zpráva byla na serveru přijata a uložena nejspíš krátce před tím než ji zachytil antivir. Pro jednoho uživatele resp. schránku by to nemělo být moc zpráv, které bude potřeba projít a zkontrolovat.

Případně je možné, že antivir zprávu ze serveru smazal a najdeš ji už jen v té karanténě.

3
Vývoj / Re:Přechod z Javy na Rust. Ano či ne?
« kdy: 03. 10. 2025, 16:09:16 »
Nedávno jsem tady do nějaké diskuse napsal, že generování XML je někdy lepší si napsat sám, ručně, bez knihoven a hned se seběhli místní trollové, co že si to dovoluji si takovou věc psát sám… Přitom to generování XML je výrazně jednodušší než parsování (byť si nepíšeš vlastní parser asi zpracováváš SAX události nebo pracuješ nad DOMem nebo něco podobného). (jen dodávám, že cílem toho mého generátoru nebylo generování libovolného XML, ale určité podmnožiny, která je pro moje potřeby dostačující – důležité je, aby výstup bylo validní XML)

Kdysi jsem měl číst ceník v XML, který prodejce generoval tuším v Pohodě. V záhlaví sada Windows-1250, v obsahu francouzský parfém. Výsledkem nevalidní XML. Prodejce byl bohužel přesvědčen, že má vše správně. Lepení XML bohužel pokaždé nevyjde.

Obávám se, že když někdo neví, v jakém kódování má která data, tak ho nezachrání ani knihovna.

Viz např. v PHP:

Kód: [Vybrat]
<?php

$xw 
xmlwriter_open_memory();
xmlwriter_set_indent($xw1);
$res xmlwriter_set_indent_string($xw"\t");

xmlwriter_start_document($xw'1.0''UTF-8');

xmlwriter_start_element($xw'zkouška-kódování');

$text "čeština v UTF-8";
xmlwriter_start_element($xw'správně');
xmlwriter_text($xw$text);
xmlwriter_end_element($xw);

// tato data se načetla např. ze souboru nebo z databáze:
$text "čeština v ISO-8859-2";
$text iconv("UTF-8""ISO-8859-2"$text);
xmlwriter_start_element($xw'špatně');
xmlwriter_text($xw$text);
xmlwriter_end_element($xw);

xmlwriter_end_element($xw);

echo 
xmlwriter_output_memory($xw);

?>

Nebo v Javě:

Kód: [Vybrat]
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

public class BadEncodingXml {

    public static void main(String[] args) throws Exception {
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        DocumentBuilder db = dbf.newDocumentBuilder();
        Document d = db.newDocument();

        Element root = d.createElement("zkouška-kódování");
        d.appendChild(root);

        {
            String text = "čeština v UTF-8";
            Element správně = d.createElement("správně");
            správně.appendChild(d.createTextNode(text));
            root.appendChild(správně);
        }

        {
            String text = "čeština v ISO-8859-2";
            text = new String(text.getBytes("ISO-8859-2"), "UTF-8");
            // Java tam aspoň dá: � takže XML je validní, byť data jsou chybná
            Element špatně = d.createElement("špatně");
            // případně: text = "\0";
            špatně.appendChild(d.createTextNode(text));
            root.appendChild(špatně);
        }
       
        TransformerFactory tf = TransformerFactory.newInstance();
        Transformer t = tf.newTransformer();
        t.transform(new DOMSource(d), new StreamResult(System.out));
    }
}


Chyba se dá udělat i při násobení dvou čísel, ale asi to neznamená, že přestaneme násobit, že?

Tady taky narážíme na to, že vývoj softwaru není jen o technologiích, ale i o lidském chování. Pro spolupráci je kolikrát důležitější než nedělat chyby, nebýt kretén a uznat, že v programu chyba je a opravit ji.

4
Vývoj / Re:Přechod z Javy na Rust. Ano či ne?
« kdy: 03. 10. 2025, 16:09:09 »
Nedávno jsem tady do nějaké diskuse napsal, že generování XML je někdy lepší si napsat sám, ručně, bez knihoven a hned se seběhli místní trollové, co že si to dovoluji si takovou věc psát sám… Přitom to generování XML je výrazně jednodušší než parsování (byť si nepíšeš vlastní parser asi zpracováváš SAX události nebo pracuješ nad DOMem nebo něco podobného). (jen dodávám, že cílem toho mého generátoru nebylo generování libovolného XML, ale určité podmnožiny, která je pro moje potřeby dostačující – důležité je, aby výstup bylo validní XML)

Muzu se zeptat v jakem jazyku/platforme je to nekdy lepsi? Protoze jediny duvod, co me napada, kdyby podpora xml byla resena v nejake knihovne, co je zabugovana nebo prilis velka, atd.... Tak by me zajimalo v jakem jazyku jste to resili, ze tam nebyla podpora pro xml...

Jednak v Javě - tam bylo cílem mít lepší kontrolu nad formátováním a odsazením + volitelné zvýrazňování syntaxe v terminálu. (jinak v Javě dobré knihovny jsou a podpora XML je ve standardní knihovně)

Jednak v C++ - tam to byla volba mezi a) napsáním cca 140 řádků kódu a b) přidáním závislosti na nějaké komplexní knihovně.

Ani jedno není „lepení stringů“ ale volají se tam metody jako writeStartElement(), writeCharacters(), writeComment() atd. (podobá se to StAX rozhraní).

To „lepení stringů“ se dá napsat třeba i v Bashi a je to jeden řádek s voláním příkazu sed s pár náhradami.

5
Vývoj / Re:Přechod z Javy na Rust. Ano či ne?
« kdy: 02. 10. 2025, 21:34:43 »
Navíc často ten dict může obsahovat jen omezenou množinu typů, takže třeba neomezeně dlouhé číslo do něj nejde uložit přímo jako číslo, ale jako řetězec a pak se bokem serializátoru do JSONu musí říct, ať to uloží jako číslo, ne jako řetězec (i když to tak je v tom slovníku).
No a? To je správně.

A není jednodušší to číslo nechat třeba jako BigInteger a naučit ten generátor, jak mapovat BigInteger na datové typy daného formátu? K čemu je dobré to převádět na String a pak si někde bokem předávat informaci, že tohle vlastně není String ale číslo?

6
Vývoj / Re:Přechod z Javy na Rust. Ano či ne?
« kdy: 02. 10. 2025, 21:30:39 »
Já ti nerozumím. V čem, že je ten problém?

Problém je v tom, že to nemusí být stromová struktura, ale může to být obecný graf a na jeden objekt může vést reference z víc míst. Pokud to řešíš přes reflexi, tak tam tu informaci o tom, že jde o stejný objekt, akorát je na něj odkazováno z víc míst, máš zachovanou. Ale když to přesypeš do mapy map, tak se tam ta informace ztratí (nebo si minimálně přiděláš dost práce s tím, abys ji tam zachoval).

7
Vývoj / Re:Přechod z Javy na Rust. Ano či ne?
« kdy: 02. 10. 2025, 21:25:01 »
Ale vysvětli mi, proč bych měl tím dictem něco ztrácet? Nevidím proto jediný důvod...

Tohle už jsem komentoval někde výše. Když už se to tedy bude řešit takhle ručně (osobně bych spíš použil spíš tu reflexi a anotace nebo kód generovaný ze specifikace), tak bych tam nechal normální datové typy toho programovacího jazyka – a jejich mapování na datové typy formátu, ať si řeší ta serializační knihovna (specifika se dají upravit konfigurací, ale nevidím důvod, proč by někdo měl být nucen to ručně programovat).

Proč už nikdy nepoužiju reflexi na serializaci: To takhle jeden kolega v kódu, který jsem přebral použil reflexy nad Enum, což ve výsledku znamenalo, že pro každou hodnotu Enumu do dalo jeden int. Hezké, krásně se to namapovalo do databáze. Pak někdo přidal nový záznam do Enumu. A první odstranil, protože ten se už neměl nikdy použít. A najednou si klienti stěžovali, že se nám mrší data.

To ovšem není chyba reflexe ale logická chyba v návrhu. Neměl to mapovat na čísla ale na textové hodnoty a k tomu tu reflexi klidně mohl použít. Případně to mohl přemapovat na jednoznakové konstanty nebo i na ta čísla, aby to v DB zabíralo míň místa, ale musel by tam mít pevně dané mapování. Taky by pomohla zkušenost třeba s C++, protože to člověka naučí ty enumy neodstraňovat a nové přidávat jen na konec.

Připravit se kvůli tomu o reflexi mi přijde škoda. Jsou např. homoikonické jazyky, které jdou v tomhle mnohem dál. Ta reflexe je tak na půl cesty, ale i tak je to velmi užitečný nástroj (spíš tedy pro tvorbu knihoven a frameworků než aplikací, tam to moc nepatří).

Nedávno jsem tady do nějaké diskuse napsal, že generování XML je někdy lepší si napsat sám, ručně, bez knihoven a hned se seběhli místní trollové, co že si to dovoluji si takovou věc psát sám… Přitom to generování XML je výrazně jednodušší než parsování (byť si nepíšeš vlastní parser asi zpracováváš SAX události nebo pracuješ nad DOMem nebo něco podobného). (jen dodávám, že cílem toho mého generátoru nebylo generování libovolného XML, ale určité podmnožiny, která je pro moje potřeby dostačující – důležité je, aby výstup bylo validní XML)

Ty výhrady k tomu generovanému kódu částečně chápu. Sám jsem s tím bojoval u Swaggeru resp. OpenAPI, kde generátor nebyl dost zralý, některé věci to nepodporovalo vůbec nebo to generovalo nesmysly… to bylo dost peklo. Něco vyřešili autoři generátoru v novějších verzích, něco jsme vyřešili sami vlastními šablonami. Ale i tak si myslím, že je většinou lepší si jednou odladit šablony/generátor než to psát pokaždé ručně. A JAXB je oproti tomu mnohem zralejší a spolehlivější technologie (byť to zemětřesení, které přišlo po Javě 8, s tím nepěkně zamávalo).

Jedna ze zkušeností, co mne v tomhle ovlivnila, byla, když  jsem  kdysi  pozoroval  lidi, kteří seděli asi dva metry od sebe, jeden psal server v Javě, druhý psal klienta v JavaScriptu a neustále řešili, že ten druhý posílá  atribut  s „jiným  názvem“ nebo  „starým  způsobem“…  v každé  verzi  byly  chyby tohoto typu a pořád se na to plýtval čas a vyvolávalo to hádky. Mezi sebou si sdíleli dokument ve  Wordu,  ve kterém  měli příklady, jak se má služba volat… Takže když mi dneska někdo tvrdí, jak nepotřebuje schéma, a že je to prý jednoduché a že stačí napsat pár příkladů a všem to bude jasné… tak se mi otevírá pomyslná kudla v kapse, protože vím, jak to dopadá. Přitom tohle se v oboru řeší od pradávna a obecně  se  to  jmenuje IDL  (interface  description language). Konkrétních implementací je spousta, ale podstatná je ta myšlenka, že máš nějakou strojově  čitelnou  specifikaci,  která definuje ten kontrakt, a ze které obě strany vycházejí.

Ale každopádně, pokud si píšeš parser ručně ale máš tu specifikaci a ne jen pár příkladů, tak je to ještě ten lepší případ.

Dělám to stejně, protože ono se to nakonec vyplatí vždycky mít to napsané ručně. Třeba když při integraci zjistíte, že protistrana posílá formát, který není v souladu se specifikací (třeba se mají posílat prázdné hodnoty jako element s nil, ale oni ten povinný element vůbec nepošlou). A když to reklamujete, dozvíte se, že jim to ale generovaný kód dělá takhle a nic s tím neudělají. Tak jsem to jednoduše vyřešil u sebe a upravil jsem parsování, a ten povinný element nebyl zas až tak povinný.

To se mi taky párkrát stalo, ale buď to šlo řešit domluvou a druhá strana uznala, že to je chyba a opravila to, aby to specifikaci odpovídalo, nebo jsme ustoupili my a upravili si to XSD nebo Swagger u sebe, a tudíž nám generátor vytvořil třídy, na které pasovala i ta původně neplatná data. Tohle se dá i případně automatizovat (tady je fajn, že XSD a WSDL jsou taky XML a dají se prohnat XSLT transformací).

8
Vývoj / Re:Přechod z Javy na Rust. Ano či ne?
« kdy: 02. 10. 2025, 19:34:27 »
Přijdete o zapouzdření, takže si zabetonujete vnitřnosti.
Jak jednou objekt serializujete, tak už takřka nemůžete překopat vnitřní reprezentaci. Nějaká aktualizace pak obvykle něco rozbije.

Ve výsledku pak občas máte vnitřnosti objektů dvakrát. Jednou pro sebe, jednou pro serializátor a přesypáváte je tam a zpět.

Smyslem té serializace je, že chci s někým komunikovat – typicky s nějakým externím systémem nebo třeba s jinou instancí svého programu. Proto si dohodneme nějaké rozhraní, kontrakt, který budou obě strany dodržovat, a který popisuje logickou strukturu předávaných dat případně i protokol jejich předávání. Ten koncept IDL nevznikl jen tak pro nic za nic…

A proto má smysl, aby ty objekty vygenerované z téhle specifikace jí odpovídaly 1:1 – abych mohl ve své aplikaci mohl vytvářet nebo číst libovolné struktury, které jsou dle té specifikace validní. Tady není moc prostor pro kreativitu a nemá smysl si to dělat po svém a jinak. Ty objekty/třídy nemám pro nějaký serializátor, ale pro podporu toho formátu a jeho logického modelu. Slouží to jako most mezi mým programovacím jazykem (abych používal normální třídy, struktury, konstanty, volal metody, funkce…) a tím formátem nebo protokolem. A tady je žádoucí dodržovat správnou úroveň abstrakce a nedovolit těm strukturám specifickým pro daný formát, aby prosakovaly do zbytku programu, který už je obecný. Takže ano, budu tam ty třídy mít dvakrát, nebo třeba jedenáctkrát, pokud budu pracovat s deseti formáty. Ale pokaždé to jsou trochu jiné struktury a data (pokud by tomu tak nebylo, tak by to znamenalo, že ten program je nejspíš vcelku zbytečný a nic moc nedělá). Tzn. mám nějaké jádro programu a v něm používám nějaké entity-třídy – to je můj datový model, který odpovídá mému záměru logice toho programu. A pak tam mám moduly pro napojení na různé externí systémy a v nich se používají třídy specifické pro dané protokoly nebo formáty. V těchto modulech je pak nějaká obchodní logika, která na jedné straně pracuje s mými entitami a na druhé straně se strukturami specifickými pro ten formát nebo protokol.

Pokud by ta aplikace měla nějaké extrémní nároky na výkon nebo požadavek, že se data nemají v paměti kopírovat, tak bych se na nějaké objekty a konstruování jejich stromu úplně vykašlal a z parseru bych emitoval události, které by se průběžně zpracovávaly… případně bych vyrobil ukazatele na části dat v té původní paměti, aby se to nikam nekopírovalo a zpracovalo rovnou na místě.

9
Vývoj / Re:Přechod z Javy na Rust. Ano či ne?
« kdy: 02. 10. 2025, 19:06:41 »
Ale vysvětli mi, proč bych měl tím dictem něco ztrácet? Nevidím proto jediný důvod...

Tohle už jsem komentoval někde výše. Když už se to tedy bude řešit takhle ručně (osobně bych spíš použil spíš tu reflexi a anotace nebo kód generovaný ze specifikace), tak bych tam nechal normální datové typy toho programovacího jazyka – a jejich mapování na datové typy formátu, ať si řeší ta serializační knihovna (specifika se dají upravit konfigurací, ale nevidím důvod, proč by někdo měl být nucen to ručně programovat).

10
Vývoj / Re:Přechod z Javy na Rust. Ano či ne?
« kdy: 02. 10. 2025, 18:55:22 »
Pokud to jazyk podporuje, tak se k tomuto účelu použije spíš reflexe + případně anotace, kterými se dá upravit specifické chování a mapování.
Serializace reflexí má své mouchy. A jak je ten serializátor psaný někým jiným, jsou z toho pěkně vypasené masařky.

1) Navrhujete vnitřnosti podle toho, co umí serializátor.
Když máte štěstí dostanete třeba nekonečno a nan. Na denormály ani nemyslete. A na inty větší než 48b bych taky raději slepě nespoléhal.
Pokud serializátor není součást jazyka, tak určitě nedostanete všechny standardní knihovny.

2) Přijdete o zapouzdření, takže si zabetonujete vnitřnosti.
Jak jednou objekt serializujete, tak už takřka nemůžete překopat vnitřní reprezentaci. Nějaká aktualizace pak obvykle něco rozbije.

Ve výsledku pak občas máte vnitřnosti objektů dvakrát. Jednou pro sebe, jednou pro serializátor a přesypáváte je tam a zpět.

Tak přesně tohle je ten případ, kdy by mne zajímalo, na základě jakých zkušeností a projektů se takový komentář a názor vznikl. Nikdo z mých zákazníků bohužel (bohudík?) nechce platit za ruční implementaci de/serializátoru a za to, že se o ten nadbytečný kód budou další generace programátorů starat. Ale možná je to někde běžná praxe - právě proto bych rád věděl kde a jaké k tomu vedou důvody.

Moje zkušenost vychází hlavně z bankovních projektů. Tam serializujeme objekty do XML, JSONu případně do Avro nebo nějakých specialit typu ISO 8583. Nebo jsem dělal projekty v oboru telekomunikací a tam to bylo trochu pestřejší, formáty byly často binární, bylo tam hodně ASN.1, Radius, Diameter, SMPP atd. A prakticky vždy je snaha tuhle práci automatizovat a minimalizovat množství kódu, který se musí napsat. Takže buď se do tříd dopíší anotace nebo, lépe, se vychází ze specifikace (XSD, WSDL, Swagger/OpenAPI, Avro schéma, definice ASN.1 modulů, slovníky atd.) a z ní se generují třídy nebo něco jiného. V obou případech ale tu práci za nás dělá nějaká knihovna. Ručně jsem to řešil jen párkrát u hodně malých projektů, kde toho ručně psaného kódu bylo tak málo, že převládl užitek ze snížení komplexity závislostí.

Napadají mne ještě takové věci jako multimediální kodeky nebo implementace síťových protokolů v operačním systému nebo nějaké firmwary… ale tam se spíš než vyrábění stromů objektů ta data namapují přímo, aby se nemusela vůbec kopírovat, maximálně se narovná endianita číselných typů, ale jinak data leží pořád na stejném místě v paměti, a buď se na ně 1:1 napasuje nějaká céčkovská struktura, nebo se vyrobí ukazatele, které ukazují na části dat na tom původním místě nebo se to zpracovává proudově a parser generuje události / volá funkce a ty se průběžně odbavují.

11
Vývoj / Re:Přechod z Javy na Rust. Ano či ne?
« kdy: 02. 10. 2025, 12:58:47 »
Když vývojář dostane zadání, musí ho napřed analyzovat a vybrat pro něj vhodný jazyk, ve kterém ho je nejlépe zakódovat. Každý programovací jazyk má svá specifika (výhody i nevýhody), která se musí při oné volbě brát v úvahu.

Pokud se bavíme o komerčním vývoji, o firmách, tak tam je většinou rozhodnuto předem. Je tam obecně snaha omezovat tyhle „zoo“ programovacích jazyků a technologií a mít to jednotné, aby mohla fungovat zastupitelnost, aby jeden programátor mohl přecházet mezi různými projekty té firmy a nestávalo se ti, že máš několik volných programátorů v jazyce X, ale práci máš pro programátora v jazyce Y.

Vybírat si můžeš, pokud je to tvůj projekt nebo jsi šéf vývoje a máš za úkol stavět něco na zelené louce. I tam je ale dobré myslet na to, kde najdeš potřebné programátory a jaké budou mít požadavky ostatní projekty té firmy, abys to měl do budoucna pokud možno jednotné. Větší firmy si můžou dovolit větší pestrost (byť to není moc záměr, spíš důsledek jakési volnosti a experimentů), u menších je spíš snaha mít jeden hlavní jazyk. A i když je někde víc jazyků současně, tak typicky spíš z historických důvodů a postupně se přechází, nové projekty se začínají jen v tom aktuálním.

Co vývojář, to originální osobnost. Co zadání + vývojář, to originální výsledek zpracování toho zadání. Nikdy jsem nepracoval ve vývojářském týmu. A dotaz zní: Máte také podobnou zkušenost s originalitou každého vývojáře? Mohu veřejně říci, že zpracování zadání (vývoj, programování atd.) je velice osobní záležitost?

Každý má nějaký styl, co je mu nejbližší a přirozené, k čemu se na základě svých zkušeností dopracoval. Spíš než hodnotit, co je správně a odsuzovat, co je špatně, je užitečnější se zajímat, co k tomu dotyčného vedlo, na základě jakých zkušeností k tomu došel. Na druhou stranu, pokud spolu ti lidé mají pracovat v jednom týmu na jednom projektu, tak je dobré, aby si domluvili nějaký kompromis a společné konvence, které budou dodržovat – rozumný člověk si může zachovat svůj názor, ale zároveň si je vědom toho, že dělat to „o trochu horším“ způsobem, ale jednotně, je užitečnější, než když to budou dělat všichni „lépe“ ale každý jinak.

12
Vývoj / Re:Přechod z Javy na Rust. Ano či ne?
« kdy: 02. 10. 2025, 12:03:02 »
P.S. Šlo by sice zavést konvenci, že o přemapování nativních typů programovacího jazyka na nějakou omezenou množinu typů používaných v abstraktním modelu se stará objekt, ale to spíš jen přidělá práci a bude se duplikovat kód v každém objektu resp. třídě. Lepší je, když to přemapování typů je odpovědnost toho de/serializátoru resp. un/marshalleru a je definovaná na jednom místě (případně ovlivnitelná konfigurací – ale naprogramované je to jen jednou).

13
Vývoj / Re:Přechod z Javy na Rust. Ano či ne?
« kdy: 02. 10. 2025, 11:45:32 »
Nebudu ho učit serializovat se do Jsonu, nebo do Databáze, ale obecný serializování musí umět on.

Ale i obecných serializačních formátů existuje mnoho. Jeden například povolí 64-bitová celá čísla a druhý povolí celá čísla bez omezení velikosti. Jiný povolí čas na mikrosekundy, další na pikosekundy. Některé mohou řešit, jak jsou data uložena v paměti, jiné se od toho snaží abstrahovat.
Tak tenhle přístup má samozřejmě nějaké předpoklady. Objekt vysype obecný slovník obsahující nějaké základní typy a pak to chce zpátky v původní podobě beze změn. Prakticky to znamená, že ten dict bude podporovat akorát tak osekané doubly a obecné stringy.
Ve chvíli, kdy je třeba řešit nějaké ztrátové ukládání, tak to takhle obecně nejde. A je otázka, jestli se tomu ještě dá říkat serializace.

Pokud to jazyk podporuje, tak se k tomuto účelu použije spíš reflexe + případně anotace, kterými se dá upravit specifické chování a mapování.

Pokud reflexe není nebo ji nechceme použít a chceme to dělat ručně, tak to sice „vysype hashmapu“ nebo poskytne metody pro procházení toho abstraktního stromu/grafu, ale v něm se budou používat normální datové typy daného programovacího jazyka. Knihovna nebo modul, který pak dělá mapování tohoto abstraktního modelu na konkrétní serializační formát, je zodpovědný za mapování datových typů jazyka na datové typy formátu. Takže když tam třeba nebude číselný typ s příslušnou přesností, tak to namapuje na textový řetězec nebo pole bajtů a případně připojí potřebná metadata (pokud nejsou ve schématu), aby šlo následně provést bezztrátovou deserializaci zpět na objekty a typy v daném programovacím jazyce.

14
Desktop / Re:Virtuální plocha jako nezávislé prostředí
« kdy: 01. 10. 2025, 20:20:38 »
Koukni na X2Go, tam by to mělo jít.

15
Vývoj / Re:Přechod z Javy na Rust. Ano či ne?
« kdy: 01. 10. 2025, 15:11:11 »
Tohle ale záleží na konkrétním programu. Kevlin Henney (https://en.wikipedia.org/wiki/Kevlin_Henney) doporučuje každý program dělat maximálně konkrétní, tedy pro tiskárnu je normální mít datové typy jako ink, paper, book apod. Je nevhodné vytvářet abstraktní metody, které umí vážit slona, když potřebuju jen znát hmotnost inkoustu. Tiskárna ví, kolik ho potřebuje a datový objekt typu ink může mít metodu GetVolume(). Nebo ještě lépe, mít kontejner pro inkousty a o každém ví, kolik jaké barvy tam je.

Jak kde. Postupem času jsem došel k tomu, že 1) implementaci, která je skrytá uvnitř, je většinou dobré dělat co nejjednodušší, nedělat overengineering, nevyrábět tam za každou cenu X objetků nebo abstraktních rozhraní, když stačí pár obyčejných metod, pár bloků kódu. Protože tyhle implementační detaily můžeš kdykoli přepsat a udělat je složitější nebo „pořádně objektově“. Ale u 2) veřejného rozhraní bys měl ten návrh udělat robustní už na začátku a myslet (v nějakém rozumném horizontu) i na budoucí vývoj a obecnost, univerzálnost. Protože veřejné API bys měl měnit co nejméně a hlavně zpětně kompatibilně (pokud nechceš naštvat všechny kolem sebe).

Více jsem to rozepsal v Rozlišování veřejného API a interních rozhraní.

Stran: [1] 2 3 ... 11