Na YouTube a nově také na VHSky byly zveřejněny sestříhané videozáznamy přednášek z letošního OpenAltu.
Jednou za rok otevírá společnost SUSE dveře svých kanceláří široké veřejnosti. Vítáni jsou všichni, kdo se chtějí dozvědět více o naší práci, prostředí ve kterém pracujeme a o naší firemní kultuře. Letos se dveře otevřou 26. 11. 2025 v 16:00. Můžete se těšit na krátké prezentace, které vám přiblíží, na čem naši inženýři v Praze pracují, jak spolupracujeme se zákazníky, partnery i studenty, proč máme rádi open source a co pro nás skutečně
… více »Na čem pracují vývojáři webového prohlížeče Ladybird (GitHub)? Byl publikován přehled vývoje za říjen (YouTube).
Jeff Quast otestoval současné emulátory terminálu. Zaměřil se na podporu Unicode a výkon. Vítězným emulátorem terminálu je Ghostty.
Amazon bude poskytovat cloudové služby OpenAI. Cloudová divize Amazon Web Services (AWS) uzavřela s OpenAI víceletou smlouvu za 38 miliard USD (803,1 miliardy Kč), která poskytne majiteli chatovacího robota s umělou inteligencí (AI) ChatGPT přístup ke stovkám tisíc grafických procesů Nvidia. Ty bude moci využívat k trénování a provozování svých modelů AI. Firmy to oznámily v dnešní tiskové zprávě. Společnost OpenAI také nedávno
… více »Konference Prague PostgreSQL Developer Day 2026 (P2D2) se koná 27. a 28. ledna 2026. Konference je zaměřena na témata zajímavá pro uživatele a vývojáře. Příjem přednášek a workshopů je otevřen do 14. listopadu. Vítáme témata související s PostgreSQL či s databázemi obecně, a mohou být v češtině či angličtině.
Byl vydán Devuan 6 Excalibur. Přehled novinek v poznámkách k vydání. Kódové jméno Excalibur bylo vybráno podle planetky 9499 Excalibur. Devuan (Wikipedie) je fork Debianu bez systemd. Devuan 6 Excalibur vychází z Debianu 13 Trixie. Devuan 7 ponese kódové jméno Freia.
Společnost Valve aktualizovala přehled o hardwarovém a softwarovém vybavení uživatelů služby Steam. Podíl uživatelů Linuxu poprvé překročil 3 %, aktuálně 3,05 %. Nejčastěji používané linuxové distribuce jsou Arch Linux, Linux Mint a Ubuntu. Při výběru jenom Linuxu vede SteamOS Holo s 27,18 %. Procesor AMD používá 67,10 % hráčů na Linuxu.
Joel Severin v diskusním listu LKML představil svůj projekt linuxového jádra ve WebAssembly (Wasm). Linux tak "nativně" běží ve webovém prohlížeči. Potřebné skripty pro převod jsou k dispozici na GitHubu.
Byla vydána nová verze 25.10.31 svobodného multiplatformního video editoru Shotcut (Wikipedie) postaveného nad multimediálním frameworkem MLT. Shotcut je vedle zdrojových kódů k dispozici také ve formátech AppImage, Flatpak a Snap.
Když poprvé někoho napadlo vytvořit něco jako JXP Commander měl jsem radost, že mohu sledovat vznik nového open-source projektu a co víc - dokonce se do jeho vývoje zapojit. První měsíc vývoje byl překotný - vznikl název, wiki projektu a IRC kanál, ale nikdo se dlouho neměl k tomu, aby napsal jediný řádek kódu.
Velice kladně hodnotím iniciativu Jaroslava Šmída, který se jako první rozhodl něco vytvořit. K mému zklamání se ale rozhodl zkombinovat nezkombinovatelné - C++ a GTK. Knihovna GTK je implementována v C a pracovat s ní v C++ je zbytečně nepřehledné a na objektovosti to programu nepřidá.
Již někdy během tohoto vývoje jsem se rozhodl napsat si vlastní JXP Commander (jenom pro sebe, abych si trochu zopakoval GTK). Je implementován v GTK+ 2.0 a napsán v céčku. Vycházel jsem ze screenshotů Total Commanderu 6 a dal jsem si za cíl "aby to vypadalo stejně" (jen nevím na co je to tlačítko se šipkou dolů ve skupině čtyř tlačítek vpravo nahoře v každém panelu - nemám nainstalované wine a rebootovat se mi nechtělo, tak jsem ho tam nedával) - k tomu příkazovému řádku dole jsem se ještě nedostal. Abych nikoho nemátl, pojmenoval jsem svoje dílo JXP Commander II.
JXP Commander II toho moc neumí - je to jenom GUI. Pouze parsuje /proc/mounts a všechny aktivní přípojné body nahází do combo boxu, který ve Windows slouží k přepínání mezi "disky". Jako výhody spatřuji správné použití Makefile, lokalizovatelnost (stačí v CFLAGS v Makefile změnit -DLANGCZ na -DLANGEN a vše je anglicky).
V open-source je pro uživatele důležitá možnost volby a pro vývojáře konkurence a možnost inspirace. Proto jsem se rozhodl svůj výtvor publikovat. Možná tím někoho inspiruji a vyrojí se nepřeberné množství různých JXP Commanderů, z nichž pouze jeden nejsilnější jedinec přežije přirozený výběr a stane se nejlepším file-managerem.
        Tiskni
            
                Sdílej:
                
                
                
                
                
                
            
    
            Zaprvé neumím pořádně C++ (nekamenujte mě)Nebudu, já taky ne
A zadruhé jsem pro to, aby paralelně existovalo víc projektů.Jasně, ale šlo by to rychleji a výsledek by byl lepší. No ale když to každý chcete psát v jiném jazyce, to je pak těžký, to je fakt...
            Total PlesingerLOL!
            
            
Ale jsi už druhý, kdo začíná práci návrhem GUI, nejsem si jistý, jestli je to dobrý nápad (netvrdím, že je to špatně, jen si prostě nejsem jistý).
            
            
Nicméně je tu risk, že pokud pak naprogramuješ backend a zjistíš, že se k tomu to GUI nehodí, budeš ho muset předělávat. Jenže se obávám, že totéž platí i naopak, takže mě neber moc vážně.
            
Dejte mi opici, co umí náhodně ťukat do klávesnice, dost času a slibuji vám, že vytvořím JXP Commander III, který bude dokonalým přenesením Total Commanderu do prostředí linuxu 
            
            Naopak, nedokazem si predstavit, ako niekto dokaze napisat gui v c. To musi byt ultrahnus ( a verte, ze par pokusov s gtk som mal ). Takisto ma totalne dorazili prve pokusy s gstreamer, z toho mi bolo na zvracanie.v tom pripade dufam, ze nepouzivas GIMP ani ine Gtk+ programy :P
Konstrukcie ako
bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
gst_element_set_state (pipeline, GST_STATE_PLAYING);
gst_object_unref (GST_OBJECT (pipeline));
su totalne obskurdnosti. Odvtedy mam totalnu averziu voci vsetkym "g-style" knizniciam.
            X(1:N) = X1(1:N) + X2(1:N)vs
DO I = 1, N X(I) = X1(I) + X2(I) ENDDOv prvním případě překladač hned ví, že to může optimalizovat, zatímco ve druhém to musí zkoumat, aby došel k závěru, že výpočet v jednom cyklu neovlivňuje výpočet v cyklu jiném, takže to může vektorizovat
 můžou to být nějaký drsný třídy s přetíženym operátorem +
            Plus(a,a), takže pořád nevidím, v čem C++ brání optimalizaci. Naopak, mohlo by jí pomoci, pokud by jazyk umožňoval specifikovat hint typu "tenhle operátor je komutativní", ale to bychom asi chtěli moc…
            Plus(a, b) klidně může být realizováno jako a.add(b) a že pak to a + a + a + a na 4 * a redukovat nejde, protože v okamžiku překladu nevím, co dělá to add. Když je to POD tak tam samozřejmě žádná překážka není.
Chtěl jsem to v této diskuzi hlavně pochopit, protože C++ skoro neznám.
            
            To už bych to rovnou mohl napsat v QT. Problém je v tom, ž QT je zbytečně pomalá knihovna - právě kvůli C++.Prosím neFUDovat. QT je velmi rychlá knihovna, troufnul bych si dokonce říct, že rychlejší než GTK1. Jako člověk, co dělá s hudebními programy to vidím denně. Tyto programy mají narozdíl od různých gimpů, email klientů a www browserů obrazovku posetou mraky pohyblivých elementů, skákají tam různé VU metry a posouvají se slidery. Je na tom krásně vidět, jak který toolkit tyto věci (ne)stíhá. Třeba takový ardour 0.9x (GTK1) jede na mém stroji dost dobře. Připravovaný ardour2 (pouze přepsání pro GTK2) už je skoro nepoužitelný, jak mu GUI "plave". A to není zatížením CPU, které je velmi malé. Ostatní GTK aplikace jakbysmet. Když pak vedle toho pustím třeba hydrogen (QT apikace - počet i design pohyblivých elementů je srovnatelný s ardourem), tak ten vyloženě "frčí". To samé se dá říct o srovnání dalších obdobných aplikací. A opravdu se mi nezdá, že je to tím, že by autoři aplikací nad GTK neuměli programovat a ti od QT jo.
 Jestli jo, bude to super 
            
. C je skvělý jazyk, ale na prototypování ani omylem (možná snad ještě prototypování aplikací v assembleru).
            
.
Hint: nemluvil jsem o tom, v čem by se to psalo líp, ale v čem by se lépe psal prototyp, což je to, co teď děláš.
            class Process {
  uint pid;
  char *name;
  ...
};
class Filesystem {
  ...
LOL
            
            
            Aby som to zhrnul, nevidel som v živote nič tak nepodobné PHP ako D.
No, o tom bych si dovolil pochybovat. Sice D vůbec neznám, ale pokud je aspoň trochu podobné C, tak by se určitě něco našlo… :-)
            
Predsa len som nemyslel na to, že oveľa nepodobnejšie PHP ako D je napríklad steblo trávy, alebo mločie žalúdky. Nabudúce budem opatrnejší 
            Stači kus marketingu, silnú spoločnosť a z jazyku je hit raz dva.
Zrovna u Javy bych tomu "raz dva" neříkal. Tam bylo potřeba několik let intenzivního plošného brainwashingu…
Ale o vzniku C++ som počul len v súvislosti s plánovaným vylepšením C ako takého, podobne ako D je vylepšenie C++. Ale neviem. Nič z toho som nezažil. A vlastne je mi to jedno. Ja už som sa vyprofiloval ako nealgolista, to mi stačí 
            
            
 Ten jazyk nemá prakticky šanci, protože není pro něj žádné IDE, není pro něj nativní grafický návrhář, nejsou dokonce nativní wrappery do nějaké slušné grafické knihovny. Kromě toho není to přenositelné, existuje jediný rozumný kompilátor a právě se zrovna založil projekt na front end do GCC.
Možnosti jazyka D hladce překoná třeba Python, nebo jiný interpretovaný jazyk. Určitě je D lepší, než C++, ale vývoj kompilovaných jazyků je už za zenitem. To by musel jazyk D udělat toto:
1) Vytvořit killer aplikaci(e), které by nastartovaly zájem o D
2) Vytvořit slušné IDE pro tento jazyk
3) Zvolit dobrou grafickou knihovnu a vytvořit kvalitní wrapper do D
4) Vytvořit grafického návrháře pro toto grafické rozhraní
5) Vytvořit nástroj, který by automaticky generoval wrappery pro D z C/C++
6) Automaticky připravit wrappery pro několik stovek základních knihoven
7) Vytvořit standard jazyka D, rozšířit jeho možnosti pro datové struktury
8) A prosazovat, prosazovat, prosazovat.
            To je asi zásadný rozdiel medzi nami, ja nehľadím na to, ako zarobiť
Jen počkejte, až si vezmete hypotéku… :-)
            
            
 kdyby nebyli, tak by ani kompilátory neměl kdo napsat 
 nedělejte ale z toho zase takovou složitost, a taky si uvědomte, že pravověrný a špičkový assemblerista je na pomezí geniality a bláznovství 
 takový člověk zvládne dokonale řadu procesorů 
            
            
            a29k alpha - ev5 - ev6 - ev67 arm clipper cray - cfp - ieee generic (Cčko) i960 ia64 m68k - mc68020 m88k - mc88110 mips32 mips64 ns32k pa32 - hppa1_0 - hppa2_0 pa64 power powerpc32 - 750 - vmx powerpc64 - mode32 - mode64 - vmx pyr s390 sh - sh2 sparc32 - v8 - v9 sparc64 thumb vax x86 - fat - i486 - k6 - k7 - p6 - pentium - pentium4 x86_64 z8000 z8000xTo je seznam adresářů s machine-dependent soubory, povětšinou asm, zčásti C.
            
 
Dokážu si ovšem živě představit i opravdové assemblerovské machry...napadá mě jeden zajímavý CAD software napsaný přímo do RAM hexeditorem paměti pomocí sedmitlačítkové klávesnice a později tímto způsobem naportovaný na několik platforem.  
            
 Samozřejmě, není to ideální způsob psaní čehokoli většího, to by bylo šílenství. 
AMD má ale moc pěknou optimalizační příručku, doporučuju aspoň nahlédnout. Je dobré vědět, že pokud je výkon prioritou (masivní numerické výpočty? 
), jsou k dispozici i takové prostředky.
            
 (Tahle 500MHz resp 500MIPSová věc byla jako prototyp vyrobená technologií, kterou se vyráběl Intel 80486 DX2 a Pentium 60/66 MHz. Do the math... 
)
V případě slušných (!) architektur CPU podle mě _je_ možné a reálné psát výkonný kód ručně. Samozřejmě můžeme polemizovat o tom, jak moc je x86 vhodná platforma pro ruční psaní v assembleru nebo třeba i pro psaní kompilátoru, to je ale podle mě trošku jiný problém. 
 (Steel Bank Common Lisp má z nutnosti (chabé registry) dvě verze prováděcího modelu: Jednu pro x86 a jednu pro slušné procesory.)
            
Takže sa vyjadrím už len k pár veciam, s ktorými celkom nesúhlasím.
S tým STLkom nejde o tú abstrakciu. To je vynikajúca vec a najvyššia kvalita ktorú programátor môže mať. A najlepšie sa uplatní v LISPe, kde vám makra dávajú možnosť oveľa väčšej abstrakcie, akú si vôbec viete predstaviť. Apropos, ak si nájdete čas: LISP v praktickom využití.
V STLku je problém, že každá kravina sa robí neúnosne zložito. A to IMO priamy dôsledok toho, že sa s tým nepočítalo a bolo to do pluspluska dorobené nasilu. Dá sa povedať, že je to elegantné riešenie v tom zmysle, že nič lepšie sa zrejme nedá v C++ na danú tému už spraviť. Podobne stringy s stringstreamy. Konvertovať s STL string do intu je síce elegantné a dá sa na to zvyknúť, ale predsa len je to oveľa viac kódu, ako by som chcel. Suma sumárum, STL nemá expresívnu silu. Nedá sa jednoducho povedať: chcem toto a toto krátkym a prehľadným kódom. Na druhej strane na obranu C++ sa dá povedať, že nie je veľa rovnako výkonných jazykov, ktorý zvládajú taký stupeň abstrakcie.
A k tomu pythonu. Tuším, som sa sám zamotal, takže sa opravím. Python nie je jazyk, ktorý má najčistejší design, tým je LISP. Myslím, že ako jediný je axiomatizovaný a formálne skúmaný (s výnimkou funkcionálnych jazykov). V praxi sú síce dialekty podstatne odlišné od tej čistoty, aby sa dali ľahšie používať, ale ten feeling tam je.
Python možno nemá čistý design, ale má jasnú KISS filozofiu a teda v podstate design. Preto som sa zamotal. Ale rozhodne je to jeden z mála jazykov, kde môžete byť efektívny behom pár dní a učiť sa za pochodu. To sa mi okrem pythonu stalo len pri D. Ale idem si ľahnúť a utriasť myšlienky, lebo tuším už plácam len dve na tri 
Ešte raz, bolo mi potešením. Dobrú noc.
            
V STLku je problém, že každá kravina sa robí neúnosne zložito.
No to nesouhlasim ani za mak. Naopak template tridy dovolujou rozdelit problem na podproblemy (politiky, traity), aniz by tam byla rezie navic. A pak se soustredite jen na jednu cast - podproblem. V STL je sila v tom, ze oddelite algoritmy od dat a jako interface slouzi kontejnery. Staci to pochopit a pak se celej koncept(sablon) v stl opakuje. Ale co se tady budu vypisovat, prectete si Alexandreska a mozna zmenite nazor.
Konvertovať s STL string do intu je síce elegantné a dá sa na to zvyknúť
Konverze mezi cisly a stringy je narocnejsi, ale v pristim standardu je proposal na konverzni funkce. Viz boost::lexical_cast Pak muzete spachat neco jako tohle:
template<typename T>
inline T convertToFrom( const std::string& fromString ) {
  T toT;
  std::istringstream tmStream(fromString);
  char c;
  if( !(tmStream >> toT) || tmStream.get(c))
    throw std::out_of_range( "convertToFrom is std::out_of_range." );
  return toT;
}
Suma sumárum, STL nemá expresívnu silu.
Dalsi podle mne unahleny nazor. Jestli povazujete STL za kompozici rozsiritelnych nastroju postavenych na zaklade sablon(a tak to je!), pak se podivejte na parser boost::spirit. Pouzivam jej a je to po urcite dobe pouzivani velmi intuitivni nastroj vyuzivajici sablony do takove urovne, ze prekladac jde do kolen, jak pise autor. Ale funguje to, je to rychly, intuitivni a spolehlivy.
Porovnávať jazyky je celkom možné. Až na pár oblastí, kde treba veľký výkon je python použiteľný prakticky všade a teda v týchto ostatných oblastiach sú porovnateľné. A čo je dôležité (resp., malo by byť) zrejme pre každého programátora je prehľadnosť kódu a rýchlosť vývoja. A práve tu môžeme porovnať o koľko je jednoduchšie napísať v podstate hocičo v pythone, ako v C++. Ergo jazyky sú porovnateľné. Opak tvrdí len zaslepenec, ktorý nevidí za hranice svojho jazyka.
Teda ešte raz podstata, ak stratila. Nemám nič proti C++, v istých situáciách je to veľmi dobrá voľba. Ale nemusíte ho obhajovať len kvôli tomu, že ste naňho zvyknutý.
            uint32_t ani int64_t povinné nejsou ani podle C99…
            Podle mě v C++ právě chybí abstrakce na úrovni datových struktur, aby existoval literál typu pole, seznam, asiciativní pole.Co presne mate na mysli? Navrhuje se umoznit podobne veci:
std::vector<int> vec = { 1, 2, 10, 16 };
Dále mi chybí v C++ klíčové slovo finally pro výjimky.Mame RAII.
Pokud se pokusíte rozšířit třeba funkčnost streamů poděděním, zjistíte, že máte smůlu, protože neexistuje ani virtuální destruktor, ani virtuální metody, které by měly být logicky virtuální. Vše ve jménu ušetření několika taktů.Ze navrh i/o v c++ neni z nejstastnejsich, se vi uz davno. Ale kvuli zpetne kompatibilite zmeny v teto oblasti muzete cekat jen velmi tezko.
            
            
            je Gtk napsané v C, což je (podle mne) pro grafický toolkit naprosto nevhodný jazyk.Tobě se nelíbí
void*? 
            void* sám o sobě není špatná věc. Problém ale je, když ho někdo zneužívá jako berličku k čuňárnám. Hlavně když pak takový kód mám přeložit pomocí čtyřkového GCC, které si hned tak něco nenechá líbit…
BTW, nedávno jsem dokonce objevil v hlavičkových souborech jádra použití pointerové aritmetiky s void*. Potíž je, že zatímco gcc to spolkne, g++ pochopitelně prská…
            
Na druhou stranu je samozřejmě stejně nešťastné, pokud někdo sice formálně píše v C++, ale hlava mu stejně dál myslí v C.
“If you know what you're doing, three layers is enough; if you don't, even seventeen levels won't help”je to skor upozornenie, ze pokial nevie programator co robi, tak mu C++ nepomoze. ostatne o tom tam pisal, tento citat to len anekdoticky zhrnuje. a autor je celkovo proti velkym monolitickym projektom (ved je to kniha o UNIX programming), takze kritika v tejto oblasti nie je prekvapujuca. ale ja som si zapamatal skor, ze treba vediet zvolit spravny jazyk, nez ze OOP je vsade zle okrem tych troch oblasti... aj to, ze thready viac-menej zavrhuje sa dalo ocakavat - zase UNIX programming. ale ak by niekto potreboval nasadit thready, tak by sa urcite nespoliehal len na nazor z jednej knihy. ja som z knihou tiez nesuhlasil uplne vo vsetkom, ale vacsina je IMO spravna a vedel som si to utriedit a urcite bola pre mna prinosom. a rad odkazujem tu cast o OOP, pretoze niektori zaciatocnici (dufam, ze len zaciatocnici) si aj dnes myslia, ze C++ je pupok sveta.
))
jinak C++ je spíš otloukánek, do kterého si každý kopne, než pupek světa
pokud se týká OOP a začátečníci, kteří mají pocit, že jsou pupek světa, obrátil bych se rozhodně na Javisty
kniha není správná, kniha je prostě jedním pohledem na problematiku, která v jiných případech a v jiných situacích nemusí platit. zejména si myslím, že platí pro malé a rychle programované věci.
OOP určitě není samospasitelné, ale stylem jakým je podáno v této knize každého znalého člověka jenom přesvědčíte, že je to trochu zaujaté. řekl bych, že právě ta pasáž o OOP patří k těm nejslabším v té knize (ovšem tvrdě vede pasáž o threadech a hned následuje OOP a pak C++, kde na názoru hackerů postavil celé hodnocení)
Jinak ale musím ocenit, že se hodně zamyslel a třeba pasáž, co je špatně v unixové koncepci a co se mělo udělat jinak je moc dobrá.
            
PES pes ( "rexo" ) {
 signals:
  brese_ako_hovado();
};
SUSED honza ( "pekny curak" ) {
 slots:
  rozsviet_svetlo_a_pozri_co_sa_deje();
};
ZLODEJ klepto ( "ma uz cosi za sebou" );
DOM dom ( "moje kralovstvo" );
connect ( pes, signal ( brese_ako_hovado ), honza, slot ( rozsviet_svetlo_a_pozri_co_sa_deje ) );
pes.straz ( dom );
Toto je sice exemplarny priklad zneuzivania slotoveho mechanizmu v qt, ale ako priklad postaci ( tymto prikladom som ale nechcel poukazat na system signal/slot v qt, ale skor na objektovost jazyka ). Psovi kazem strazit dom. Ak pride zlodej k domu, pes zacne stekat a sused rozsvieti svetlo aby sa pozrel, co sa deje.
V semi-objektovom C by to vyzeralo asi nejak takto:
main () {
 PES* pes = vytvor_novy_objekt_typu ( "PES" );
 nastav_popisok ( pes, "rexo" );
 SUSED* sused = vytvor_novy_objekt_typu ( "SUSED" );
 nastav_popisok ( sused, "pekny curak" );
 DOM* dom = vytvor_novy_objekt_typu ( "DOM" );
 nastav_popisok ( dom, "moje kralovstvo" );
 ZLODEJ* klepto= vytvor_novy_objekt_typu ( "ZLODEJ" );
 nastav_popisok ( klepto, "ma uz cosi za sebou" );
 // tymto cyklom nahradzam signal/slot mechanizmus
 // on sice v reale asi aj tak nejak funguje, ale ja sa o to v QT nemusim starat
 bool flag = true;
 while ( flag == true ) {
  if ( pes_brese ( pes ) == 1 ) {
   pes_brese_akcia ( pes, sused );
   flag = false;
  }
 }
 zrus_objekt_co_si_vytvoril ( pes );
 zrus_objekt_co_si_vytvoril ( sused );
 zrus_objekt_co_si_vytvoril ( dom );
 zrus_objekt_co_si_vytvoril ( klepto );
}
void pes_brese_akcia (PES* pes, SUSED* sused) {
 SVETLO* svetlo = daj_mi_pointer_na_svetlo_niekde_na_susedovom_dome ( cislo_svetla );
 rozsviet_svetlo ( sused, svetlo );
}
Na prvy pohlad to mozno pride ako zmatocne, ale ked sa k tomu prida polymorf, dedicnost, ine vlastnosti oo jazyka, zlozitejsi projekt, zo standardnym C by sa clovek posral nieco poriadne napisat, nehovoriac o nachylnosti k chybam a tak podobne. Objektovy jazyk totiz svojim navrhom viac pripomina realny zivot a tak sa v nom aj programuje.
PS. Snad som nepopisal nejake kraviny.
            inputStream.open(const char*);. Ovšem s řetězci je také sranda, mimo C polí a std::string v C++ má navíc snad každá C++ knihovna starší sedmi let stringy vlastní.
            const char* moc nelíbí, viz C++0x wishlist (hned třetí požadavek). Ale to samozřejmě bude ještě nějaký ten rok trvat. Co se týká vlastních stringů v každé knihovně, to bohužel není problém jen C++ knihoven, to dělají i céčkové. Obzvlášť příjemné je to ve chvíli, kdy je potřeba v projektu takových knihoven použít víc, to člověk pomalu nedělá nic jiného, než že castuje jedotlivé xchary a xstringy mezi sebou, což ohromně zvyšuje čitelnost zdrojáku… :-(
            std::stringy, spíš se prostě přidá sada metod, kde bude místo const char* jako argument const std::string&.
            
. Navíc, pokud mi std::string vrací nějaká jiná metoda jako výstup, tak se zbytečnou konverzí na const char* paměťové nároky naopak zvyšují.
            tak se zbytečnou konverzí na const char* paměťové nároky naopak zvyšujíMinimálně v GNU implementaci ne. Protože zavolání
c_str() pouze poskytuje ukazatel na vnitřní reprezentaci, nikde se nic nealokuje.
            
            
            gcc: -lgtk-x11-2.0: linker input file unused because linking not done gcc: -lgdk-x11-2.0: linker input file unused because linking not done gcc: -latk-1.0: linker input file unused because linking not done gcc: -lgdk_pixbuf-2.0: linker input file unused because linking not done gcc: -lm: linker input file unused because linking not done gcc: -lpangocairo-1.0: linker input file unused because linking not done gcc: -lpango-1.0: linker input file unused because linking not done gcc: -lcairo: linker input file unused because linking not done gcc: -lgobject-2.0: linker input file unused because linking not done gcc: -lgmodule-2.0: linker input file unused because linking not done gcc: -ldl: linker input file unused because linking not done gcc: -lglib-2.0: linker input file unused because linking not done gcc -c -Wall -g `pkg-config --cflags gtk+-2.0` `pkg-config --libs gtk+-2.0` -DLANG_CZ -I. gui/about.c gcc: -lgtk-x11-2.0: linker input file unused because linking not done gcc: -lgdk-x11-2.0: linker input file unused because linking not done gcc: -latk-1.0: linker input file unused because linking not done gcc: -lgdk_pixbuf-2.0: linker input file unused because linking not done gcc: -lm: linker input file unused because linking not done gcc: -lpangocairo-1.0: linker input file unused because linking not done gcc: -lpango-1.0: linker input file unused because linking not done gcc: -lcairo: linker input file unused because linking not done gcc: -lgobject-2.0: linker input file unused because linking not done gcc: -lgmodule-2.0: linker input file unused because linking not done gcc: -ldl: linker input file unused because linking not done gcc: -lglib-2.0: linker input file unused because linking not done gcc -c -Wall -g `pkg-config --cflags gtk+-2.0` `pkg-config --libs gtk+-2.0` -DLANG_CZ -I. gui/panel.c gcc: -lgtk-x11-2.0: linker input file unused because linking not done gcc: -lgdk-x11-2.0: linker input file unused because linking not done gcc: -latk-1.0: linker input file unused because linking not done gcc: -lgdk_pixbuf-2.0: linker input file unused because linking not done gcc: -lm: linker input file unused because linking not done gcc: -lpangocairo-1.0: linker input file unused because linking not done gcc: -lpango-1.0: linker input file unused because linking not done gcc: -lcairo: linker input file unused because linking not done gcc: -lgobject-2.0: linker input file unused because linking not done gcc: -lgmodule-2.0: linker input file unused because linking not done gcc: -ldl: linker input file unused because linking not done gcc: -lglib-2.0: linker input file unused because linking not done gcc -c -Wall -g `pkg-config --cflags gtk+-2.0` `pkg-config --libs gtk+-2.0` -DLANG_CZ -I. lib/mounts.c gcc: -lgtk-x11-2.0: linker input file unused because linking not done gcc: -lgdk-x11-2.0: linker input file unused because linking not done gcc: -latk-1.0: linker input file unused because linking not done gcc: -lgdk_pixbuf-2.0: linker input file unused because linking not done gcc: -lm: linker input file unused because linking not done gcc: -lpangocairo-1.0: linker input file unused because linking not done gcc: -lpango-1.0: linker input file unused because linking not done gcc: -lcairo: linker input file unused because linking not done gcc: -lgobject-2.0: linker input file unused because linking not done gcc: -lgmodule-2.0: linker input file unused because linking not done gcc: -ldl: linker input file unused because linking not doneNa co předávat knihovny při obyčejné kompilaci? Si nech až na linkování.
 Můžeš se těšit na další verzi.
            
            
            
.
            
            /proc/mounts v libs/mounts.c. Připádá mi to dost prasácký. Jde to vyřešit nějak elegantněji? Neexistuje náhodou nějakej hotovej parser pro podobný věci? Jak byste to řešili?
            rootfs / rootfs rw 0 0 none /dev ramfs rw 0 0 /dev/root / ext3 rw,data=ordered 0 0 none /dev ramfs rw 0 0 none /proc proc rw 0 0 none /sys sysfs rw 0 0 none /proc/bus/usb usbfs rw 0 0 none /dev/pts devpts rw 0 0 none /dev/shm tmpfs rw 0 0 /dev/hda1 /boot ext2 rw 0 0 /dev/hdb2 /home ext3 rw,data=ordered 0 0Můžeš tam alespoň vynechat, aby se nevipisovali ty s "none"? Dvakrát / a /dev se mi tam také nelíbí, nechápu proč to je v /proc/mounts 2x
            df? Nejjednodušším způsobem, jak zjistit, jak se to doopravdy dělá, bude náhled do zdrojáků df (výhoda OpenSource), nebo třeba busyboxu (jednodušší a tím pádem i přehlednější). Jenom, ten, kdo chce mít výsledek pod BSD licencí, ať se raději podívá na neGPL utilitky 
.
            
 ... getmntent(3)
            exec()?)
            df? 
Jenom proboha žádné parsování standardního výstupu příkazů. K tomu, co chceš udělat slouží příslušné knihovní funkce.
            statfs(2) … a zkuste se už oprostit od parsování výstupu.
            
#include <gtk/gtk.h>
#include <stdio.h>
#include <mntent.h>
#include <include/locale.h>
#include <include/version.h>
#include <include/panel.h>
extERN VOID Set_mounts(struct myPanel panel)
{
        GList *glist = NULL;
        gchar **name;
        struct mntent mnt;
        gint i;
        FILE *fd = setmntent("/etc/mtab", "r");
        i = 0;
        while (getmntent(fd)){
                name[i] = mnt.mnt_dir;
                glist = g_list_append(glist, name[i]);
                i++;
        };
        endmntent(fd);
        gtk_combo_set_popdown_strings(GTK_COMBO(panel.mounts), glist);
        return;
}
Zkompiluje se to bez problému, ale při spuštění to hází Segmantation fault. Nevíte někdo kde je chyba? Asi nějaký zapomenutý ukazatel. Nejspíš jsem lama, ale já tam fakt nic nevidim.
            
            
BTW: pokud tohle bereš jako nadávání, pak se nad sebou zamysli. Uznej sám, že programovat cokoliv netriviálního tímto stylem (nevím, tak se zeptám ve fóru) je zhola nemožné. Zvlášť nechápu, proč to musí být v C, které moc neovládáš. Proč nenapíšeš pár prototypů třeba v Ruby, nebo Pythonu, abys to trochu dostal do ruky? Na přepis do C bude potom času dost 
.
BTW2: já mám raději debugovací výpisy, než gdb.
            
            
#include <gtk/gtk.h>
#include <stdio.h>
#include <mntent.h>
#include <string.h>
#include <stdlib.h>
#include <include/locale.h>
#include <include/version.h>
#include <include/panel.h>
extern void set_mounts(struct myPanel panel)
{
        GList *glist = NULL;
        gchar *name[255];
        struct mntent *mnt;
        gint i;
        FILE *fd = setmntent("/etc/mtab", "r");
        i = 0;
        while ((mnt = getmntent(fd)) && i < 256){
                name[i] = (char*) malloc(strlen(mnt->mnt_dir)+1);
                strcpy(name[i], mnt->mnt_dir);
                glist = g_list_append(glist, name[i]);
                i++;
        };
        endmntent(fd);
        gtk_combo_set_popdown_strings(GTK_COMBO(panel.mounts), glist);
        return;
}
            
. Proč místo té magie s polem nepřidávat rovnout do seznamu?
                glist = g_list_append(glist, mnt->mnt_dir);
            g_list funguje, ale takhle to jde a bez toho kopírování mi to nešlo (všecny položky byly stejné jako ta poslední).
            g_list ten string někam zkopíruje nebo jestli si jen zkopíruje pointer, jestli to po sobě ve druhém případě uklidí atd.?
            
            while zrušit pomocí free() v cyklu? Ty proměnné už stejně nejsou potřeba, když hned o 3 řádky dál (return) zaniknou...
            gtk_combo_set_popdown_strings(GTK_COMBO(panel.mounts), glist);
            mnt->mnt_dir_ent + 1 (ukončovací znak řetězce), takže mě nemůže překvapit žádný výstup z getmntent()
            
            
gchar **name; int names=256;
...
        name = (gchar **) malloc (sizeof(gchar*)*names);
        i = 0;
        while ((mnt = getmntent(fd))){
                if (i == names) {
                   names+=256;
                   name = (gchar **) realloc (name, sizeof(gchar*)*names);
                }
                name[i] = (char*) malloc(strlen(mnt->mnt_dir)+1);
                strcpy(name[i], mnt->mnt_dir);
                glist = g_list_append(glist, name[i]);
                i++;
        };
...
free (name); /*uvolní seznam, ale nikoliv řetězce, které obsahuje */
return; 
(Teď ještě prosím kohokoliv, aby našel a opravil nějakou strašně pitomou chybu, kterou jsem v tom určitě udělal 
)
            p = malloc(); if (!p) abort();Nic moc, ale už testuju, jestli to nevrátilo NULL. Spokojenost?
            
while ((mnt = getmntent(fd))){
    glist = g_list_append(glist, strdup(mnt->mnt_dir););
};
return;
            strdup() mě vůbec nenapadlo. Tím se vyřeší spousta problémů (třeba s tou dynamickou alokací). Jen doufám, že v tom nebude žádnej háček, jdu to vyzkoušet.
            malloc() náhodou nevrátil NULL. To je mimochodem zrovna věc, která by byla v C++ podstatně jednodušší. Jinak doufám, že ten panel.mounts se postará o řádné dealokování všech stringů, které jste mu předal.
            Ten wrapper může třeba zobrazit zprávu, že program padnul na hubu, nebo vypsat nějakou smysluplnou hlášku a korektně ukončit program.Kde je něco o nějaké knihovně? Kde je něco o tom, že ten wrapper bude pro všechny programy?
void *my_malloc(...) {
  void *ret;
  if (!(ret = malloc(...))) {
     perror("Malloc se porouchal");
     exit(1);
  }
  return ret;
}
A teď kousek v GTK+:void *my_malloc(...) {
  void *ret;
  if (!(ret = malloc(...))) {
     show_error("Malloc se porouchal"); // zobrazi chybu
     gtk_main_quit(1);
  }
  return ret;
}A ted mi rekni, co je na tom spatne.
            prostě jen vím, že všechno co je v C je i v C++ a ještě mnohé navíc
já prostě nevidím ani jeden důvod, proč kdykoli nedat přednost C++ před C
ale tam, kde se používá C, tam bych to na 100% nahradil C++.ako sa hovori: afekt ako hovado. vas nazor nemam sancu zmenit ani trosku. praktickych ukazok je dost, uviedol som. to ze vy by ste to robili v C++ nic nemeni na ich kvalite. bodka. ked niekto vie robit v C, tak robi ked je mu to vyhodne - ale vy by ste pouzili C++. bodka. nema zmysel pokracovat.
já opravdu ještě neviděl projekt, kde by se víc hodilo C oproti C++to ale neznamena, ze to je objektivny nazor. a zjavne s nim vela ludi nesuhlasi, takze tak.
zatím jsem prostě nenašel praktický argument v čem je C lepšíano, vy by ste preferoval C++ aj na kernel. uz sa to opakuje. stacilo.
 Možná pan Stroustrup ho zná do detailů, ale v tomhle má Raymond pravdu – ten jazyk je šíleně překomplikovaný. 
 Proto se o to ani nesnažím.
            „Kdo z Vás do detailů umí celý bash?“Jeden můj kamarád.
 Akorát že bash je o dost jednodušší a skripty v něm povětšinou taky. Kdybych měl číst a chápat nějaký kód od někoho jiného, kdo by používal zrovna ty části, co já ne, asi bych spíš upřednostnil kulku do hlavy. 
            
            
            
.
            
            
 Já se obávám, že vyčerpání paměti aplikací může způsobit problémy i v ne-GUI handleru. Nejsem si teď úplně jistý, ale mám pocit, že Java ve Windows trpěla tím, že se občas při handlingu výjimky OutOfMemory pokoušela alokovat další paměť, za což ji systém s radostí odstřelil, čímž ta výjimka byla napůl k ničemu. Tedy doufám, že to byla Java. Teď to nemůžu nikde najít.
            
).
            
            
            /etc/mtab
            /mnt/hda1 a tento adresář mám ve všech možných bookmarcích a v KDE na ploše.
            Výměnná média se dají spolehlivě rozeznat podle typu filesystému
Jak?
            /sys/block/*/removable (proboha, hlavně neparsovat). Ale nevím, zda existuje nějaké univerzální API, nebo se to musí pro každý unix řešit jinak.
Kio to také nějak rozpoznají, takže jde jenom o to, zjistit jak 
            sysfs je Linux only, ne? Nebo bude i na BSD?
            
            /media (doufám, že se teď nestanu terčem útoků FHS-haters :-) ). Nebo že by se ze seznamu mounting pointů vyřadily ty, které jsou v /etc/fstab a nemají tam noauto?
            Naopak na fstab bych moc nespoléhal (možná spíš mtab), protože ve spoustě moderních distribucí se tahle část systému o připojování hotplug výměnnejch médií nestará
To nijak neodporuje tomu, co jsem napsal: za pevná by se považovalo to, co je v /etc/fstab a nemá to v parametrech noauto. Ostatní - tedy i to, co v fstab není vůbec - by bylo považováno za výměnné. Zdůrazňuji ale, že za vůbec nejlepší řešení považuji to, že by si uživatel sám vybral adresáře, které tam chce mít.
            
hal-find-by-capability --capability blockTo vypadá docela zajímavě. Jenom to moc nekamarádí s věcma, co hardware nejsou. Například NFS oddíly.
cp). A nemusím přemýšlet, jestli je to zrovna /dev/sda1, /dev/sdb1, /dev/sdc1 nebo kýho výra. Prostě to chce odložit předsudky a zabývat se praktickou stránkou věci. Aneb "Image je nanic, poslouchej žízeň."
            /dev/sda je on), ve druhém ne. Kromě flashdisku mám ještě foťák a čtečku paměťových karet (která se chová jako tři samostatné diskové jednotky). Takže ono to není vždycky tak jednoduché.
            /proc/bus/usb moc často nelezu. Spíš jsem od toho čekal něco jako drives:/ v KDE.