Co si myslíte o OOP?

[Inkvizitor]

Python má historicky dva různé způsoby vytváření "recordu" - dictionary (pohodlnější) a class (těžkopádnější, ale systémovější). V poslední době přišly dvě novinky - named tuple a dataclass, protože prostě ani dictionary (nejdynamičtější řešení z dynamických) ani "normální" třída nejsou zase tak moc super.

To všechno je ale pod kapotou netypovaný dict. viz x.__dict__

A vo tom to je. Vytvořila se abstrakce, která má v některých ohledech výhodnější vlastnosti než vrstva pod ní. Dictionary je skvělá obecná struktura, protože do ní můžu vložit prakticky cokoli, ale mizerná struktura pro popis dat, která mají pevný formát. Normální třída v Pythonu je skvělý obecný nástroj, protože je velice flexibilní, ale z pohledu člověka, který chtěl record a nic víc, je to kanon na vrabce se vším všudy.

Dynamické jazyky jsou super, protože dovolují naprogramovat všechno a všelijak. Pokud po nich chceme přesnost, rychlost a spolehlivost, je ta flexibilita spíš na obtíž. Můj odhad je, že dynamické jazyky budou ustupovat, protože jejich základem je snadnost implementace a vyhýbání se složitostem návrhu, což jim historicky přinášelo nemalé výhody. Statické jazyky se ale vyvíjejí, jak z hlediska ergonomie, tak z pohledu podpory nástrojů a možností.

[Reklama]

[Honza]

mne by treba zajimalo proc se dynamicke jazyky zatim neprosadily u life saving real time mission criticial systems, ktere se nejspis vyvijeji jen v silne typovych jazycich, napr. v Ade resp. v jazycich ktere jsou jeji podmnozinou


https://en.wikipedia.org/wiki/Ada_(programming_language)


https://en.wikipedia.org/wiki/SPARK_(programming_language)


https://en.wikipedia.org/wiki/Ravenscar_profile


nebo je to jinak ?

Já tuším, že to bude tím, že implementace těch jazyků, které se pro to nepoužívají, mají nedeterministický GC. Pokud navíc běží VM pouze v jednom vlákně, tak to je problém. Ale není to proto, že jde o dynamické jazyky...

[operator]

Já mám takovou krásnou ukázku flexibility dynamického jazyka. Implementace funkce undo pro libovolné proměnné libovolného typu. Jak složité bude tohle implementovat ve statickém jazyce, který se používá v produkční sféře, tedy C, C++, Java, C#?

Kód: [Vybrat]

~ $ python2 history.py
var1: 4
var1 after undo: 2 <type 'int'>
var2: 4
var2 after undo: 2 <type 'str'>
~ $ cat history.py
import sys

def undo(name):
    undo.data[name].pop(-1)
    return undo.data[name][-1]
undo.data = {}

def history(frame, event, arg):
    for name,val in frame.f_locals.items():
        if name not in undo.data:
            undo.data[name] = []
        else:
            if undo.data[name][-1] is val:
                continue
        undo.data[name].append(val)
    return history

def main():
    for i in range(5):
        var1 = i
        var2 = str(i)


    print "var1:", var1
    var1 = undo('var1')
    var1 = undo('var1')
    print "var1 after undo:", var1, type(var1)

    print "var2:", var2
    var2 = undo('var2')
    var2 = undo('var2')
    print "var2 after undo:", var2, type(var2)

if  __name__ == '__main__':
    sys.settrace(history)
    main()
    sys.settrace(None)

[anonym]

Já mám takovou krásnou ukázku flexibility dynamického jazyka. Implementace funkce undo pro libovolné proměnné libovolného typu. Jak složité bude tohle implementovat ve statickém jazyce, který se používá v produkční sféře, tedy C, C++, Java, C#?

Kód: [Vybrat]

~ $ python2 history.py
var1: 4
var1 after undo: 2 <type 'int'>
var2: 4
var2 after undo: 2 <type 'str'>
~ $ cat history.py
import sys

def undo(name):
    undo.data[name].pop(-1)
    return undo.data[name][-1]
undo.data = {}

def history(frame, event, arg):
    for name,val in frame.f_locals.items():
        if name not in undo.data:
            undo.data[name] = []
        else:
            if undo.data[name][-1] is val:
                continue
        undo.data[name].append(val)
    return history

def main():
    for i in range(5):
        var1 = i
        var2 = str(i)


    print "var1:", var1
    var1 = undo('var1')
    var1 = undo('var1')
    print "var1 after undo:", var1, type(var1)

    print "var2:", var2
    var2 = undo('var2')
    var2 = undo('var2')
    print "var2 after undo:", var2, type(var2)

if  __name__ == '__main__':
    sys.settrace(history)
    main()
    sys.settrace(None)

Ty vole co to je za hack, to doufam ze Java ani takovouto cestou neumi, fuj

Ano, mas pravdu, uvedl jsi kraaasnyy pripad flexibilnosti dynamicky typovaneho jazyka.

[Kit]

Jenže ideální by bylo se obejít zcela bez testů a správnost programu dokázat. To z mnoha důvodů většinou nejde. Proto se snažíme dokázat (rozhodnout na základě statické analýzy zdrojových textů, pro všechny možné vstupy a bez nutnosti program spouštět) aspoň něco. Statická typová analýza je jedním z nástrojů, jak dokázat aspoň některé vlastnosti programu. Jestliže nějaké tvrzení o programu dokážeme (v matematickém slova smyslu), tak si můžeme být jistí, že platí.

Také by mohlo být ideální obejít se bez statických typů. Bude to znamenat pouze určitou ztrátu výkonu, což v dnešní době není považováno za podstatné. Statická analýza může být (a také bývá) součástí testů.

Na druhou stranu testy většinou žádné obecné tvrzení o programu nedokazují, protože je není možné napsat tak, aby pokryly úplně celý stavový prostor programu. Takže se spoléháme na to, že otestujeme některé speciální situace, v lepším případě zvolené "chytře", např. na základě znalosti kódu, v horším případě vybrané náhodně, v nejhorším případě vybrané systematicky špatně. Když testy neohlásí chybu, tak věříme, že je program dobře. Ale ve skutečnosti jsme jen ověřili, že nenastane chyba pro určitou (většinou malou) podmnožinu vstupů. A to ještě za předpokladu, že nějaká chyba v testu nezamaskuje přítomnost chyby v kódu.

Zpravidla testujeme pouze okrajové podmínky, kdy program má fungovat a kdy naopak musí vyhodit výjimku. Na znalost kódu se spoléhat nemůžeme, protože ho v době psaní testů ještě nemáme. Když testy neohlásí chybu, tak zpřesníme testy, to je základ. Nevěř testům, které projdou.

Když mám k dispozici dva kontrolní mechanismy, které jsou do značné míry komplementární, tak se mi nezdá vhodné jeden z nich zahodit (a ještě ten s principiálně silnější vypovídací schopností) a tvářit se, že jsem zachoval stejnou úroveň kontroly.

Proto se tyto kontrolní mechanismy kombinují. Smalltalk šel cestou testování a možná proto se tolik nerozšířil. Haskell se vydal cestou statického typování, ale bez testů se také neobejde. Nejlépe jsou dnes na tom jazyky, které oba přístupy volně kombinují. Proto byly do PHP či Pythonu přidány volitelné statické typy a proto se staticky typované programy nejen dokazují, ale i testují.

[Reklama]

[operator]

Já mám takovou krásnou ukázku flexibility dynamického jazyka. Implementace funkce undo pro libovolné proměnné libovolného typu. Jak složité bude tohle implementovat ve statickém jazyce, který se používá v produkční sféře, tedy C, C++, Java, C#?

Kód: [Vybrat]

~ $ python2 history.py
var1: 4
var1 after undo: 2 <type 'int'>
var2: 4
var2 after undo: 2 <type 'str'>
~ $ cat history.py
import sys

def undo(name):
    undo.data[name].pop(-1)
    return undo.data[name][-1]
undo.data = {}

def history(frame, event, arg):
    for name,val in frame.f_locals.items():
        if name not in undo.data:
            undo.data[name] = []
        else:
            if undo.data[name][-1] is val:
                continue
        undo.data[name].append(val)
    return history

def main():
    for i in range(5):
        var1 = i
        var2 = str(i)


    print "var1:", var1
    var1 = undo('var1')
    var1 = undo('var1')
    print "var1 after undo:", var1, type(var1)

    print "var2:", var2
    var2 = undo('var2')
    var2 = undo('var2')
    print "var2 after undo:", var2, type(var2)

if  __name__ == '__main__':
    sys.settrace(history)
    main()
    sys.settrace(None)

Ty vole co to je za hack, to doufam ze Java ani takovouto cestou neumi, fuj

Ano, mas pravdu, uvedl jsi kraaasnyy pripad flexibilnosti dynamicky typovaneho jazyka.

To neni zadny hack, ale priklad vyuziti velmi uzitecna veci, introspekce. Mohu skrz ni kontrolovat chod programu, aniz bych zasahoval do jeho kodu a reagovat libovolne na ruzne specificke podminky. Introspekce neni nutne vlastnost jen dynamickeho jazyka, ale v dynamickem jazyku se lehce vyrovnam s tim, ze prichazum do styku s hodnotami libovolnych datovych typu.

[anonym]

Já mám takovou krásnou ukázku flexibility dynamického jazyka. Implementace funkce undo pro libovolné proměnné libovolného typu. Jak složité bude tohle implementovat ve statickém jazyce, který se používá v produkční sféře, tedy C, C++, Java, C#?

Kód: [Vybrat]

~ $ python2 history.py
var1: 4
var1 after undo: 2 <type 'int'>
var2: 4
var2 after undo: 2 <type 'str'>
~ $ cat history.py
import sys

def undo(name):
    undo.data[name].pop(-1)
    return undo.data[name][-1]
undo.data = {}

def history(frame, event, arg):
    for name,val in frame.f_locals.items():
        if name not in undo.data:
            undo.data[name] = []
        else:
            if undo.data[name][-1] is val:
                continue
        undo.data[name].append(val)
    return history

def main():
    for i in range(5):
        var1 = i
        var2 = str(i)


    print "var1:", var1
    var1 = undo('var1')
    var1 = undo('var1')
    print "var1 after undo:", var1, type(var1)

    print "var2:", var2
    var2 = undo('var2')
    var2 = undo('var2')
    print "var2 after undo:", var2, type(var2)

if  __name__ == '__main__':
    sys.settrace(history)
    main()
    sys.settrace(None)

Ty vole co to je za hack, to doufam ze Java ani takovouto cestou neumi, fuj

Ano, mas pravdu, uvedl jsi kraaasnyy pripad flexibilnosti dynamicky typovaneho jazyka.

To neni zadny hack, ale priklad vyuziti velmi uzitecna veci, introspekce. Mohu skrz ni kontrolovat chod programu, aniz bych zasahoval do jeho kodu a reagovat libovolne na ruzne specificke podminky. Introspekce neni nutne vlastnost jen dynamickeho jazyka, ale v dynamickem jazyku se lehce vyrovnam s tim, ze prichazum do styku s hodnotami libovolnych datovych typu.

A jaky je zrovna usecase pro to historii setovani tech parametru? To se da prece logovat - pokud pises spravne objektove a ne jako prase, mas tam getry a setry. Nenapada me k cemu by to bylo dobre.

[operator]

Já mám takovou krásnou ukázku flexibility dynamického jazyka. Implementace funkce undo pro libovolné proměnné libovolného typu. Jak složité bude tohle implementovat ve statickém jazyce, který se používá v produkční sféře, tedy C, C++, Java, C#?

Kód: [Vybrat]

~ $ python2 history.py
var1: 4
var1 after undo: 2 <type 'int'>
var2: 4
var2 after undo: 2 <type 'str'>
~ $ cat history.py
import sys

def undo(name):
    undo.data[name].pop(-1)
    return undo.data[name][-1]
undo.data = {}

def history(frame, event, arg):
    for name,val in frame.f_locals.items():
        if name not in undo.data:
            undo.data[name] = []
        else:
            if undo.data[name][-1] is val:
                continue
        undo.data[name].append(val)
    return history

def main():
    for i in range(5):
        var1 = i
        var2 = str(i)


    print "var1:", var1
    var1 = undo('var1')
    var1 = undo('var1')
    print "var1 after undo:", var1, type(var1)

    print "var2:", var2
    var2 = undo('var2')
    var2 = undo('var2')
    print "var2 after undo:", var2, type(var2)

if  __name__ == '__main__':
    sys.settrace(history)
    main()
    sys.settrace(None)

Ty vole co to je za hack, to doufam ze Java ani takovouto cestou neumi, fuj

Ano, mas pravdu, uvedl jsi kraaasnyy pripad flexibilnosti dynamicky typovaneho jazyka.

To neni zadny hack, ale priklad vyuziti velmi uzitecna veci, introspekce. Mohu skrz ni kontrolovat chod programu, aniz bych zasahoval do jeho kodu a reagovat libovolne na ruzne specificke podminky. Introspekce neni nutne vlastnost jen dynamickeho jazyka, ale v dynamickem jazyku se lehce vyrovnam s tim, ze prichazum do styku s hodnotami libovolnych datovych typu.

A jaky je zrovna usecase pro to historii setovani tech parametru? To se da prece logovat - pokud pises spravne objektove a ne jako prase, mas tam getry a setry. Nenapada me k cemu by to bylo dobre.

Pamatovat si historii muze byt dobre treba k implementaci transakci a bud rollbacku nebo provest navrat do nejakeho casu. Nebo potrebujes mit triger ne na hodnotu, ale rychlost zmeny. Fantazii se meze nekladou. Logovat muzes svuj kod ale to znamenak ze ho musis upravit a bude ho to zpomalovat. Predstav si, ze chces docasne logovat nejaky kus kodu, treba nejakou funkci nebo metodu nejake tridy z nejake knihovny, do ktere ale nechces nebo nemuzes zasahovat.

[Inkvizitor]

Já mám takovou krásnou ukázku flexibility dynamického jazyka. Implementace funkce undo pro libovolné proměnné libovolného typu. Jak složité bude tohle implementovat ve statickém jazyce, který se používá v produkční sféře, tedy C, C++, Java, C#?

Kód: [Vybrat]

~ $ python2 history.py
var1: 4
var1 after undo: 2 <type 'int'>
var2: 4
var2 after undo: 2 <type 'str'>
~ $ cat history.py
import sys

def undo(name):
    undo.data[name].pop(-1)
    return undo.data[name][-1]
undo.data = {}

def history(frame, event, arg):
    for name,val in frame.f_locals.items():
        if name not in undo.data:
            undo.data[name] = []
        else:
            if undo.data[name][-1] is val:
                continue
        undo.data[name].append(val)
    return history

def main():
    for i in range(5):
        var1 = i
        var2 = str(i)


    print "var1:", var1
    var1 = undo('var1')
    var1 = undo('var1')
    print "var1 after undo:", var1, type(var1)

    print "var2:", var2
    var2 = undo('var2')
    var2 = undo('var2')
    print "var2 after undo:", var2, type(var2)

if  __name__ == '__main__':
    sys.settrace(history)
    main()
    sys.settrace(None)

Až na to, že jelikož objekty v Pythonu obecně nejsou immutabilní, je Ti zcela obecně ta Tvoje LIFO kolekce hodnot úplně nanic.

[operator]

Já mám takovou krásnou ukázku flexibility dynamického jazyka. Implementace funkce undo pro libovolné proměnné libovolného typu. Jak složité bude tohle implementovat ve statickém jazyce, který se používá v produkční sféře, tedy C, C++, Java, C#?

Kód: [Vybrat]

~ $ python2 history.py
var1: 4
var1 after undo: 2 <type 'int'>
var2: 4
var2 after undo: 2 <type 'str'>
~ $ cat history.py
import sys

def undo(name):
    undo.data[name].pop(-1)
    return undo.data[name][-1]
undo.data = {}

def history(frame, event, arg):
    for name,val in frame.f_locals.items():
        if name not in undo.data:
            undo.data[name] = []
        else:
            if undo.data[name][-1] is val:
                continue
        undo.data[name].append(val)
    return history

def main():
    for i in range(5):
        var1 = i
        var2 = str(i)


    print "var1:", var1
    var1 = undo('var1')
    var1 = undo('var1')
    print "var1 after undo:", var1, type(var1)

    print "var2:", var2
    var2 = undo('var2')
    var2 = undo('var2')
    print "var2 after undo:", var2, type(var2)

if  __name__ == '__main__':
    sys.settrace(history)
    main()
    sys.settrace(None)

Až na to, že jelikož objekty v Pythonu obecně nejsou immutabilní, je Ti zcela obecně ta Tvoje LIFO kolekce hodnot úplně nanic.

O tom co se mi hodi a co ne vis uplne prdlajs a jinak jsi na urovni trumbery, ktery na demonstracni hello world reaguje poznamkou, ze vypisovani slov hello world je uplne na nic. :-)

[Inkvizitor]

O tom co se mi hodi a co ne vis uplne prdlajs a jinak jsi na urovni trumbery, ktery na demonstracni hello world reaguje poznamkou, ze vypisovani slov hello world je uplne na nic. :-)

Aha, takže Ty se prsíš kódem, který je ubohý a nepoužitelný a je to moje chyba? Sám jsi psal, že to funguje s hodnotami libovolného typu, tak se nevykrucuj, když jsem Tě nachytal.

[operator]

O tom co se mi hodi a co ne vis uplne prdlajs a jinak jsi na urovni trumbery, ktery na demonstracni hello world reaguje poznamkou, ze vypisovani slov hello world je uplne na nic. :-)

Aha, takže Ty se prsíš kódem, který je ubohý a nepoužitelný a je to moje chyba? Sám jsi psal, že to funguje s hodnotami libovolného typu, tak se nevykrucuj, když jsem Tě nachytal.

Neprsim se kodem, prsim se moznostmi, ktere demonstruuji na jednoduche ukazce. Tvoje chyba je, ze na to reagujes s nepochopenim jako osel. Psal jsem, ze to funguje pro vsechny promenne libovolneho typu, coz plati.

[Kit]

To neni zadny hack, ale priklad vyuziti velmi uzitecna veci, introspekce. Mohu skrz ni kontrolovat chod programu, aniz bych zasahoval do jeho kodu a reagovat libovolne na ruzne specificke podminky. Introspekce neni nutne vlastnost jen dynamickeho jazyka, ale v dynamickem jazyku se lehce vyrovnam s tim, ze prichazum do styku s hodnotami libovolnych datovych typu.

Vidím tam jednu vadu na kráse: Funkce history() a undo() jsou zbytečně součástí aplikace. Uvítal bych, kdyby byly spíš součástí toho testu dole. Nebo je to celé samostatným testem?

[Inkvizitor]

Neprsim se kodem, prsim se moznostmi, ktere demonstruuji na jednoduche ukazce. Tvoje chyba je, ze na to reagujes s nepochopenim jako osel. Psal jsem, ze to funguje pro vsechny promenne libovolneho typu, coz plati.

Hele, chybu udělá každý, ale takhle zatloukat, to je trapné. Vymyslel sis featuru, která je nanic, udělal implementaci, která nefunguje, abys demonstroval, co tu nikdo nepopírá. Tím s Tebou fakt končím, už se budu akorát tiše uchechtávat.

[MartinBeran]

Při statickém typování se neobejdeš bez testů, používáš tedy dva kontrolní mechanismy. Cílem tvůrců Smalltalku bylo tyto dva mechanismy sloučit do jednoho, tedy do testů. U dynamicky typovaných jazyků jsou tedy v testech i kontroly typů.

Jenže ideální by bylo se obejít zcela bez testů a správnost programu dokázat.

To je samozřejmě hloupost a realita je přesně opačná, bez testů se neobejdeme, bez _statických_ typů ano. Statické typy mají jediné opodstatnění, výkon. Ve všem ostatním jsou nahraditelné.

Když v takovéto diskusi věta začíná: "To je samozřejmě", je to silná indikace, že následuje nepravda. Aspoň jeden věcný argument by nebyl?

Ano, bez testů se neobejdeme, protože neumíme správnost programu dokázat. Ano, bez statických typů se obejdeme, když se smířime se ztrátou výhod, které poskytují. Ne, jejich význam nespočívá jen ve zlepšení výkonu. Také nás zbavují nutnosti psát některé druhy testů a zároveň poskytují lepší záruku správnosti programu.