• úvod
  • témata
  • události
  • tržiště
  • diskuze
  • nástěnka
  • přihlásit
    registrace
    ztracené heslo?
    XCHAOSANSI C/C99 (specifikace), GNU C (gcc, glibc), Tiny C (tcc) a POSIX - ne nutně C++,g++,libstdc++ nebo Win32 API
    /* Toto je klub především pro lidi, pro které je programování jednou z mnoha massive multiplayer online počítačových her, které lze hrát.
        V tomto klubu hrozí sémantická hereze a nezdravě vysoký obsah syntaktického cukru. Nevhodné pro algoritmické diabetiky.
        Od účastníků debaty se předpokládá automaticky přístup k instalovanému GNU C: sudo apt-get install build-essential
    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    C (programovací jazyk)#C99 Heslo na české Wikipedii
    Jazyk C - Základy praktického programování V Praze 2oo7 pro SSPŠ Tomáš Harvie Mudruňka a kolektiv - jak si programování v C představuje většina lidí
    http://stevenkobes.com/ctest.html C Programming Puzzlers - nepouštějte se do flamewars v tomhle klubu, pokud neuhodnete aspoň polovinu správně!
    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    http://en.wikipedia.org/wiki/C99 C99 is a modern dialect of the C programming language.
    http://cprogramminglanguage.net/ C programming language
    http://cprogramminglanguage.net/c-programming-language-tutorial.aspx C programming language - úvod
    http://en.wikipedia.org/wiki/Criticism_of_the_C_programming_language C makes it easy to shoot yourself in the foot. (ještě že ne do hlavy...)
    http://en.wikipedia.org/wiki/C_preprocessor
    http://gcc.gnu.org/onlinedocs/gcc/Variadic-Macros.html C99 makra s proměnným počtem argumentů - __VA_ARGS__
    http://gcc.gnu.org/onlinedocs/gcc/ GNU C Compiler
    http://gcc.gnu.org/onlinedocs/gcc-4.2.2/gcc/Optimize-Options.html
    http://bellard.org/tcc/ Tiny C Compiler - prý C99 compliant (min. umí __VA_ARGS__) - vhodný pro skriptování v C - umí #!/usr/bin/tcc -run
    http://en.wikipedia.org/wiki/International_Obfuscated_C_Code_Contest - pokud jste neviděli tohle, tak jste ještě neviděli opravdu nečitelný C zdroják
    http://bellard.org/otcc/ Obfuscated Tiny C Compiler - z tohohle vtípku vznikl Tiny C compiler
    http://en.wikipedia.org/wiki/ANSI_C Jak se střelit do nohy standardizovaným způsobem.
    http://eli-project.sourceforge.net/c_html/c.html ANSI C Specification
    http://www.lysator.liu.se/c/ Různý ANSI C bordel
    http://www.cs.rit.edu/~ats/books/ooc.pdf Object Oriented Programming with ANSI-C - a pak že to nejde
    http://en.wikipedia.org/wiki/Longjmp co jsou to setjmp()/longjmp() knihovní funkce (pro všechny, podle kterých to bez C++ try { } catch() ... nejde)
    http://groups.google.com/group/comp.lang.c++.moderated/browse_thread/thread/dcdc710c27f47c72 C neumí správně počítat (?)
    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    http://www.fastcgi.com/ FastCGI is simple because it is actually CGI with only a few extensions.
    http://www.metalshell.com/source_code/18/Mysql_Select.html How to do a simple connection and select with mysql
    http://xmlsoft.org/ The XML C parser and toolkit of Gnome
    http://curl.haxx.se/libcurl/ libcurl - the multiprotocol file transfer library
    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    https://dev.arachne.cz/svn/cll1h SVN/Trac jazyka C<<1 (user-friendly nadstavba nad ANSI C99 - ve stylu JQuery vs. JavaScript)
    Benchmark iterace a serializace stringů v různých jazycích vs. v C
    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        moderátor se velice zhruba řídí zvyklostmi moderace, která kdysi platila v řadě konferencí sítě FidoNet ... C != 0xdead */
    rozbalit záhlaví
    XCHAOS
    XCHAOS --- ---
    REDGUY: no... v takovém případě jsi na tom úplně stejně, jako kdybys ty moje makra neměl :-)

    ale je to pochopitelně dobrý příklad: máš v podstatě dvě možnosti: buď na konci explicitně zahodíš všechny dílčí kusy paměti, co potřebuješ zahodit (tedy: zavoláš free() na všechno kromě toho, co si chceš zapamatovat - tím pádem si ale musíš pamatovat nějaký "seznam všeho, co chceš zapomenout" a nakonci ještě i zahodit tento seznam!) - a nebo můžeš vysloveně okopírovat konkrétní výsledek do jiného memory poolu, který nezahodíš.

    myslím, že se shodneme, že v případě, že zapamatovaný objekt má třeba řádově 10 bajtů a ty ho vybíráš z nějaké dočasné datové struktury o deseti tisíc položkách, tak je "moje strategie" v podstatě výhodná. A naopak - pokud jde o objekt velikosti řádu kilobajtů, a vybíráš ho třeba z deseti položek: tak je ovšem zavolání dealokace deseti položek zřejmě efektivnější, než kopírování kilobajtového objektu do jiného kontextu.

    vymyslet opravdu univerzální řešení podle mě fakt nejde: vždy najdeš nějaký protipříklad, v rámci kterého ta která strategie bude pomalá/neefektivní.

    já jsem uvažoval k tomu svému get(...) udělat ještě alternativu the(...), což by byl v podstatě malloc ("v podstatě" říkám proto, že tam mám nějaké syntaktické vychytávky okolo, které samotný malloc() nemá... ale v podstatě by se na pointery vzniklé pomocí the(....) volalo normálně free(...) - to už ani nemá smysl přejmenovávat :-) a pouze pointery vzniklé pomocí get(...) by se uvolňovaly tím remember/forget mechanismem.

    jako jo - je to asi krkolomné - ale všechno ostatní mě přijde taky krkolomné...
    REDGUY
    REDGUY --- ---
    XCHAOS: Prima. A ted mi prosim vysvetli, jak budes resit nasledujici situaci:

    - funkce postupne buduje nejakou velkou strukturu (pocita, cte z disku, neco takoveho)
    - v okamziku kdy je struktura hotova se vyhodnoti nejaka podminka X, kterou lze spocitat az v okamziku, kdy je hotova cela struktura, ne drive.
    - pokud plati X, vratim vytvorenou strukturu, pokud X neplati, vratim neco jineho (null, jinou strukturu, tak neco)
    XCHAOS
    XCHAOS --- ---
    REDGUY: no vidíš, že se dokážeme konstruktivně bavit a nemusíme si jen nadávat...

    je to prosté, milý Watsone: samotné volání té funkce bylo přece uvnitř nějaké jiné struktury remember { } nebo forget { } - remember prostě jen vloží data "o úroveň výše", forget naopak založí nový, "zahoditelný" kontext. resp. nejvyšší úroveň programu (funkce main(), resp. v terminologii mých syntakticky přeslazených maker makro program { }) je pak logicky ekvivalentní jednom velkému forget{ } (tedy na začátku programu máš k dispozici základní kontext paměti, která se na konci zahodí)

    doufám teď už tušíš, o čem jsem mluvil, když jsem říkal, že "pojmenované paměťové kontexty" by byly něco jako "goto" :-) nic proti ním - ať si někdo používá pojmenované memory pooly, pokud chce - ale mě se to líbí takhle anonymně.

    ve většině případů dočasné pomocné proměnné, do kterých budeš cpát ta "zapomenutelná" data, budeš deklarovat až uvnitř daného jednoprůchodového scope - tedy bude to slušně bezpečné. ale samozřejmě - budeš to moci udělat tak, že budeš mít pořád deklarovaný pointer, který bude ukazovat na v tu chvíli uvolněnou paměť. bude ti to dávat prostor k tomu udělat chybu - bude to pořád Céčko, ne nějaký hypotetický super-hyper-bezpečný jazyk, ve kterém by vůbec neměla existovat reference na již (nebo ještě) nealokovaný kus paměti...
    XCHAOS
    XCHAOS --- ---
    DAVIDOWITCH: já sice chápu, že se o tom dá mluvit obecně, a nikdy jsem neříkal, že ne: ale prohlásit o něčem, že "to v daném jazyce lze použít, ale musí se to dělat ručně" je pro mě naprosto ekvivalentní výroku "v tomto jazyce nelze docílit toho, aby se taková věc prováděla automaticky".

    a fakt trvám na tom, že "syntaktický cukr" je název pro případ, kdy napíšeš "něco navíc" - ne pro případ, kdy ti jazyk umožní něco vůbec nenapsat, protože to dělá za tebe.

    např. moje navržená (a jistě diskutabilní) makra remember { } a forget { } (vymezující nějaké hranice toho, jakým způsobem se bude s alokovanou pamětí dále zacházet, navzájem vnořovatelné, apod.) jsou typickým případem "syntaktického cukru" - je to snaha zapsat srozumitelněji a přehledněji něco, co by se jinak muselo zapisovat dost možná nepřehledně a složitě (minimálně tedy v čistém Céčku, při použití malloc() a free()).

    Ovšem za syntaktický cukr prostě nemůžeš označit, když za tebe runtime udělá sám něco, co ty ani v daném jazyce nemůžeš zapsat jinak :-)
    REDGUY
    REDGUY --- ---
    XCHAOS: Aha. Takze v podstate forget prepne do veskere alokace do kontextu ktery se na konci bloku komplete zahodi a remember je prehodi do bloku kterej se nezahodi. je to tak? Takze prvni otazka: zavolal jsem funkci nejakafunkce, dostal jsem vracena data, zpracoval jsem je, nepotrebuju je. Jak uvolnim jimi zabranou pamet?
    REDGUY
    REDGUY --- ---
    XCHAOS:
    NějakýTyp nějakáfunkce(parametry)
    {
        NějakýTyp returnValue;
        forget
        {
            NěcoDočasného tmp=get(...něco...);
            if(neošetřenNějakýZvláštníPřípad(NěcoDočasného))
            {
                return NULL;
            }
    
        remember
        {
            returnValue=get(...něco...);
            returnValue->NějakáPodstruktura=get(...něco...); 
            atd.
        }
        NěcoJinéhoDočasného tmp2=get(...něco...); 
        atd.
        }
        return returnValue;
    }
    
    XCHAOS
    XCHAOS --- ---
    JACHYMKO: hezká anketa, ale případem "syntax sugar" je podle mě myšlený případ, kdy třeba máš víc možností jak něco vyjádřit - ale jedna z nich to má udělat čitelnější: viz http://en.wikipedia.org/wiki/Syntactic_sugar

    (víceméně - z tohoto hlediska se moje snaha vymyslet nějaká předpřipravená makra, typedefy a knihovní funkce, které učiní C srozumitelnější, dá popsat jako snaha vytvořit "přeslazený dialekt" Céčka, který bude tvořený čistě jen syntaktickým cukrem :-)

    jenže pokud jsou reference countery zabudované přímo uvnitř nějakého jazyka, tak o tom nemůžeš mluvit jako o syntaktickém cukru, protože syntaktický cukr není případ,kdy něco vůbec NENAPÍŠEŠ a přesto dosáhneš požadované funkce :-) v nějakém vyšším jazyce bude reference counter zvýšen přímo v případě vzniku nové reference na jakýkoliv objekt, vzniklý v rámci vyhodnocení jakéhokoliv výrazu - a bude snížen vždy na konci scope. A troufám si říct, že alternativa "ručního volání" tam ve vyšším jazyce vůbec nebude (tedy, ve smyslu, alternativa takového ručního volání, které by dávalo smysl a zachovalo funkčnost programu - můžeš si tu metodu zavolat samozřejmě ručně, ale výsledkem bude pravděpodobně nesmysl - protože tam především nebudeš mít možnost, aby si vytvořil referenci bez záznamu o ní...)
    XCHAOS
    XCHAOS --- ---
    (kurňa, mi to spolklo odsazení bloků...)
    XCHAOS
    XCHAOS --- ---
    REDGUY: implementace bude trochu na dýl... v C to bude asi makro, ve kterém bude skrytý jednoprůchodový for() cyklus, který něco udělá před vstupem do scope, něco na jeho konci, že ano. to je k té implementaci asi všechno, kdyby to "něco" bylo úplně triviální, tak už to mám hotové :-)

    popis pro uživatele: dejme tomu, že chceš napsat funkci, která až skončí, tak zahodí veškerou paměť alokovanou na heapu - dejme tomu - kromě datové struktury, na kterou má vrátit odkaz (a tedy i všech dílčích bufferů, na které tato struktura odkazuje - např. dílčí alokované stringy, apod.). pak bych to napsal třeba takhle (NějakýTyp je typu pointer - kdybys tam hledal hvězdičku a get(..) je základní podoba mého alokátoru paměti, který k tomu forget a remember patří):

    NějakýTyp nějakáfunkce(parametry)
    {
    NějakýTyp returnValue;
    forget
    {
    NěcoDočasného tmp=get(...něco...);
    if(neošetřenNějakýZvláštníPřípad(NěcoDočasného))
    {
    return NULL;
    }

    remember
    {
    returnValue=get(...něco...);
    returnValue->NějakáPodstruktura=get(...něco...);
    atd.
    }
    NěcoJinéhoDočasného tmp2=get(...něco...);
    atd.
    }
    return returnValue;
    }

    Popravdě - tenhle případ je hodně obecný a bude popisovat hodně častý případ: v "dřevním C" bys tu paměť vyhradil na úrovni toho scope, který danou funkci volá a předal by si pointer: ovšem pokud by ta funkce ani nedokázala splnit to, co má za úkol, tak by ta funkce třeba byla alokovaná zbytečně - tedy určitě má smysl alokovat paměť pro výsledek toho, co má funkce dělat, až když víme, že to opravdu lze provést. Celkově jsou podobné funkce dnes HODNĚ zavrhované - typicky je příkladem té "dřevní" alokační strategie funkce scanf() - která je dnes už taky mezi C programátory naprosto "deprecated", zavrhovaná.

    moje alokační strategie je prostě jen paralelou situace, kdy na všechny pointery, které nevracíš jako návratovou hodnotu, zavoláš na konci free(): moje makra nebudou řešit nic jiného, než aby se na všechny použité memory pooly to free zavolalo samo (a popravdě - možná dokonce bude pro každý ten "kontext" memory pool jenom jeden a v případě potřeby bude zvětšovaný tím realloc() ... tedy i free() se zavolá pro libovolný počet pointerů jen jednou).

    Dobře - možná je to celé pitomost, ale pojďte se bavit o jiných důvodech, proč je to pitomost, než je ten, že jsem s tím přišel já :-)
    DAVIDOWITCH
    DAVIDOWITCH --- ---
    XCHAOS: No, nemluvi. O pocitani referenci se mluvi jako o mechanismu kterej pocita reference. Ne s ohledem na jazyk, ne s ohledem na pretezovani cehokoliv, dokonce ani ne s ohledem treba na garbage collection a jeho implementaci. Reference counting does exactly what it says on the tin, nekdo nejak pocita kolik existuje na danou vec referenci (a kdyz uz zadna tak ji zahodi). "Pochopitelne" je bohuzel tvoje pochopitelne, ktere neni pochopitelne ani mym, ani zadneho jineho programatora ktereho znam. Vzhledem k tomu ze se nas pohled na takhle zakladni vec takhle zasadne lisi, tak na ten zbytek asi nema smysl reagovat, protoze proste nesouhlasim se zakladni premisou.
    XCHAOS
    XCHAOS --- ---
    DAVIDOWITCH: tak jako sorry, ale tohle je zase flejm pro flejm... úplně zbytečný.

    pochopitelně se o počítadle referencí (reference counter) mluví vždy v souvislosti se syntaktickými konstukcemi jazyka, ve kterém jsou ony reference na cosi vytvářeny a v souvislosti s okolnostma, kdy se tím počítadlo hejbá nahoru nebo dolů - vykládat o tom, že se v tom nemusí mluvit v souvislosti s takovými konstrukcemi, je bohapustý flejm - potom samozřejmě v každém jazyce můžeš použít jakoukoliv konstrukci, a samozřejmě je vymalováno, že jo.

    Pokud jsou počítadla odkazů v C++ v zásadě špatně, pokud nepoužiješ nějaký speciální typ pointerů, u kterého se při opuštění aktuální scope zavolá destruktor, který by stav počítadla snížil - pak sorry, tohle je problém, který si musí C++ programátoři nějak vyřešit sami a mě do toho netahat. v žádném jiném vyšším jazyce se takový pojem pokud vím nepoužívá (protože je to tam jaksi automatické, to snížení toho reference counteru, když reference opustí scope, že ...). (Příkladem jazyků, kde očekávám, že je tohle řešené automaticky, je Python nebo Java - pokud se mýlím, tak mě TEĎ opravte, teď to nebude chytání za slovíčko...)

    O tom je to "ne nutně C++" které je uvedené v názvu - o některých programátorských konstrukcích lze diskutovat, aniž by člověk nutně věděl, jak je to udělané v C++ a jak se tomu tam říká.

    ... a u té složitosti BINÁRNÍHO B+ stromu (diskutovaná datová struktura byla BINÁRNÍ B+ strom, ne obyčejný) šlo o složitost přidávání prvku - ne procházení. procházení musí být pochopitelně logaritmické. A přidávání je jediné, co na té datové struktuře nebylo jasné, a proč jsem se v první řadě chtěl s někým radit (a opět - složité na tom vlastně bylo jen to, že pro to přidávání nechci použít rekurzi...).
    DAVIDOWITCH
    DAVIDOWITCH --- ---
    XCHAOS: A je to tu zase, nemuzu si pomoc. Vsichni na svete rikaj refcounty jen mechanismu ze se pocitaj reference (nejak jakkoliv) a kdyz se dojde na 0, tak se objekt automaticky smaze. A ty, tapajici v terminech a hledajici upresneni, se tu aktivne hadas ze to je blbost a ze se tim mysli vlastne neco jinyho. Nema cenu se s tebou bavit, jakkoliv o cemkoliv, sorry.


    XCHAOS: Ne, tim se (ted sem koukal) maskuje to, ze ty rikas B+ strom necemu, co neni B+ strom a vesmes to tak ani nevypada. Ale usmyslel sis ze to je B+ strom. Redguy zareagoval podobne jako ja na refcounty, at probuh nepouzivas zavedeny terminy pro neco JINYHO nez sou zavedeny a rikas tomu klidne Maruska a ne B+ strom, protoze to B+ strom neni. Refcounty jsou jen veci alokatoru, a B+ strom nema "primerenou slozitost O(N)" protoze by to nebyl B+ strom. Howg.
    REDGUY
    REDGUY --- ---
    A neco trochu konstruktivniho - mas nejaky navrh jak budou fungovat tvuj novy alokator, ten s "remember" a "forget"? Fakt by me zajimalo jak si to predstavujes. Nemusis ukazovat implementaci, staci popis funkce pro uzivatele?
    REDGUY
    REDGUY --- ---
    XCHAOS: v podstatě to tady všichni zahráli do autu, že je to nepodstatné a nudné téma, a že by taková datová struktura stejně byla skoro nanic - ale prdlajs. Prosim, neprepisuj historii. Jestli doslo k nejake shode, tak ze Maruska, v te podobe jak jsi ji prezentoval, by byla nanic. Mimochodem, jak to s ni vypada? Uz jsi ji dopsal, abys nam, nevericim tomasum, ukazal jak svele funguje a jak hluboce jsme se mylili kdyz jsme tvuj uzasny design kritizovali?

    a nevím, kdo tu prezentoval, že refcounty jsou zdaleka nejlepší strategie správy paměti, a že C++ je nejlepší prakticky na všechno - ja to taky nevim. Kdo to tady prezentoval? Konkretne, kdo a kdy? Nebo se jen oponentum snazis podsunout neco co nikdy nerekli?
    REDGUY
    REDGUY --- ---
    XCHAOS: hloupý kdo neví, blbější, kdo se nezeptá - bezpochyby. Ale kdyby situace byla "XChaos nevi co jsou refcounty, mysli si ze to je neco jineho, napise svuj nazor, ostatni mu reknou ze to chape spatne a XChaos rekne aha, tak takhle to je!" nereknu ani slovo a fandim ti. To co se ale deje je neco uplne jineho: placnes nejaky nesmysl (at uz skutecny, nebo plynouci ze zmatene terminologie), nekdo ti rekne ze to tak neni, ti reknes ze je, nekdo ti rekne ze ne a ukaze ti na dokumentaci ukazujici ze nemas pravu, ty znova vykrikujes ze nenene, ze pravdu mas ty a cele tohle kolecko se nekolikrat zopakuje az konecne, mozna, po x-te iteraci uznas ze jsi placal nesmysly. Mozna. To neni "Zvidavy clovek, ktery se chce naucit veci co nezna", to je "Trouba, co nedokaze uznat ze neco spatne chapal a trva minimalne tejden nez se mu vtluce do hlavy ze mele nesmysl a stejne za pul roku prijde znovu s tim samym nesmyslem". Tohle je pattern kterej se znovu a znovu a znovu opakuje ve vetsine diskusi, kterych se vidim te ucastnit. Chapu ze mas emocialni blok akceptovat cokoliv co ti pisu (i kdyz pravda, odmitnout radu "podivej se jak to funguje v OSX" slovy "to nepotrebuju, protoze vim jak to fungovalo v neexistujicim 16-bitovem pra-MacOS" je extrem s jehoz chapanim mam docela problem), ale to neni jen o me, presne to same predvadis ohlede rad od lidi, kteri na rozdil ode me maji silu ty to znovu a znovu vysvetlovat aniz by si z tebe zaroven delali srandu, jako treba Davidowitch.
    XCHAOS
    XCHAOS --- ---
    DAVIDOWITCH: no tedy POUŽITÍ refcountů V RÁMCI MECHANISMů nějakého jazyka skutečně vyžaduje, aby o počítadle referencí věděl operátor přiřazení - ano, na tom trvám. Nestačí, aby to řešil např. alokátor.

    Samozřejmě, pokud mluvíš o RUČNÍM, explicitním použití nějakých abstrakcí, tak potom samozřejmě v každém jazyce můžeš použít cokoliv, to samozřejmě :-) tady se ale bavíme o tom, které mechanismy jsou přímo zabudované do kterého jazyka (resp. jeho kompileru/interpreteru) nebo alespoň já se o tom domníval.

    (To bys potom mohl mluvit o tom, že nějaký ten pra-fortran vlastně uměl pracovat se stringy, protože uměl pracovat s poli integerů, takže tam samozřejmě šlo vytisknout string, apod. :-)
    XCHAOS
    XCHAOS --- ---
    DAVIDOWITCH: nic jako Maruška neexistuje, především :-) je to nějaký vás výsměšný pojem, kterým maskujete, že jste v podstatě ani vy nedostali nápad, jak sestavovat binární B+ strom s přiměřenou složitostí - třeba O(n), ale ideálně daleko lepší. v podstatě to tady všichni zahráli do autu, že je to nepodstatné a nudné téma, a že by taková datová struktura stejně byla skoro nanic (což rozhodně není pravda - i když je fakt, že jsem o ní přemýšlel hlavně předtím, než jsem se dozvěděl, že na současných PC architekturách je realloc() zřejmě implementovaný bez nutnosti zdlouhavě kopírovat rozsáhlé bloky paměti - což rozhodně mění situaci, když se bavíme o dynamických datových strukturách)

    a nevím, kdo tu prezentoval, že refcounty jsou zdaleka nejlepší strategie správy paměti, a že C++ je nejlepší prakticky na všechno.... takže jsem bral jako hotovou věc, že je to součástí většiny implementací... ale teď se dovídám, že je na to potřeba použít nějaký rozšiřující toolkit, jinak tam k dispozici nejsou... takže ono to je celé složitější.

    skutečně mi to připomíná situaci v řadě jiných klubů, kde třeba 2-3 roky mluvím o něčem, o čem se v té době běžně nemluví, a ani přesně nevím, jakým buzzwordem to média označí, když o tom mluvit začnou - viz např. "smart grid" v energetice, apod.

    chápu, že ustálené odborné pojmy a "buzzwordy" provařované v médiích jsou něco trochu jiného - ale zrovna "smart pointer" mě přijde spíš jako buzzword, než nějaký ustálený odborný termín - všechny reference na objekt např. v Pythonu jsou tím pádem (nejspíš) "smart pointery" - ale určitě tomu tak nikdo nebude říkat - jsou to prostě reference na objekt a tečka, že jo.
    DAVIDOWITCH
    DAVIDOWITCH --- ---
    XCHAOS: No, hmm.. ja bych ti to s tim upresnenim terminu a tak veril, ale to bys nesmel po dvojim upozorneni ze nemas pravdu a pletes dve veci dohromady potreti trvat na tom, ze refcounty potrebujou operator =, vis.
    XCHAOS
    XCHAOS --- ---
    REDGUY: ve skutečnosti - chápat nějaký koncept a netušit přesně, jakým pojmem je označován, to podle mě není žádná ostuda.

    a to, že bych nějaký pojem přiřadil chybně, to se zas tak často nestává. (Rozhodně se to nemůže stát někomu, kdo jen trolluje a sám se prezentuje tak, že je především chytřejší než všichni nebo většina ostatních, a tak ani nic přispívat nemusí).

    (nenapadlo tě někdy, že net obecně (a NYX zvláště) používám jako prostředí k ověření svých různých koncepcí a nápadů, či právě k ověření a upřesnění používané terminologie ? hloupý kdo neví, blbější, kdo se nezeptá... a já tedy nikdy nepracoval s internetem tak, jako že publikované příspěvky jsou nějaké zjevené pravdy, ke kterým se už nikdo nesmí vyjadřovat a opravovat ostatní, když se mýlí, nebo tak... právě naopak... pro mě je většina debat otevřených...)
    XCHAOS
    XCHAOS --- ---
    REDGUY: dobrá, byl to 32bitový procesor - ono to je fakt dlouho a já si negooglím všechny detaily předtím, než něco napíšu - jenže zřejmě neměl mechanismy ochrany paměti při multitaskingu, či co - prostě měl kooperativní multitasking, a aplikace musely ze všech smyček volat nějakou službu systému - a hlavně: při práci s většími bloky paměti se snad prý musely volat nějaké funkce pro aktualizaci obsahu bloku v paměti (podobně jako v DOSu).

    prostě navzdory honosnému GUI byly první Macintoshe programátorský prý dost hrozné. Já o tom bližší informace nemám - nikdy jsem pro tu platformu neprogramoval - ale min. ten kooperativní multitasking bývá často zmiňován
    REDGUY
    REDGUY --- ---
    XCHAOS: alokační strategii v původním 16ti bitovém Mac OS (tedy před Mac OS X), sám jsem tady na to odvolával - mimochodem, ted mi to doslo - na preOSX Macy nejsem ani zdaleka expert, ale pokud mluvis o " 16ti bitovém Mac OS", neni to jen dalsi dukaz ze opet placas o necem cemu nerozumis, protoze uz prvni Macintosh bezel na 68000, tudiz je pitomost mluvit o nem jako o 16bitovem? LOL. Tohle je cim dal tim lepsi 8)
    Kliknutím sem můžete změnit nastavení reklam