2017 m. rugpjūčio 1 d.

EuroPython 2017 apžvalga

Asmeninė patirtis/Vieta


Iš pusšaltės Lietuviškos vasaros patekau į normalų Itališką kurortą, kurį praminiau 100x Basanavičiaus gatvės kurortu. Gal ir gerai, kad nestebuklinga vieta. Kitaip būčiau praleidęs visą laiką, kur nors kitur vietoje to, kad eiti į konferenciją šviestis, tobulėti, valgyti dietologų nerekomenduojamą maistą nerekomenduojamais kiekiais, viską užgerti daug kavos ir vyno vakare, ilgai kalbant po oficialios dalies (tam, kad nuolat nedamiegoti) apie kitų šalių politiką, kultūrą, tradicijas ir šiaip. "Šiaip" reiškia programavimą ir moteris/vyrus. Procentaliai tema "apie moteris" lenkė "apie vyrus" gana daug nuošimčių. Nes vis dėlto programavimas. Bent jau įsivaizduojate, kaip nykiais skamba programuotojų bandymas kažką protinga pasisakyti ta tema negimtąja kalba? Aš įsivaizduoju, nes "how to say".

Tai čia aš apžvelgsiu tos savaitinės (Nes konferencija trunka 5 dienas + 1 pradedančiųjų mokymai + 2 sprint'ai) mėsmalės, po kurios jautiesi taip, lyg tai rašytum į delfi skyrių "Bendraukime" tema "Kaip aš po Python konferencijos nusprendžiau viską savo gyvenime keisti ir pradėti sveikai gyventi". Tai va, pateiksiu tos savaitės savo įžvalgas ir perklausytų kalbų apžvalgas. Viską palydės mano konspektai, kur vėl piešiau gyvatėles (Linkėjimai Froidui).

Keturi aspektai


Grįžęs iš konferencijos visada mąstau, kokios esmines kryptis ir idėjas galima pajusti tvyrant konferencijos ore (atsiprašau už kvailai poetinį išsireiškimą). Pavyzdžiui, kažkada buvo galima pajusti, kad mikro karkasų (microframeworks) banga tuoj, tuoj nuneš visą industriją. Tai tą buvo galima pastebėti prieš du/tris metus. Šiais metais pastebėjau kitas 4-ias tendencijas.

Bitcoin ir blockchain


Pirmiau istorija. Aš visą laiką žiūrau į BitCoin'us (ir viską, kas su jais susiję) atsargiai. Nes man visada ten atrodo, kaip kelių rimtų sukčių ir tūkstančių melžiamų ožkučių (kurie vis dar, iki rimtesnio numelžimo, jaučiasi rimtais sukčiais) irštva. Ir aš nemanau, kad taip vėlai prisijungęs aš nebūčiau tas, kurį melžia.

Taigi, vieną vakarą Kiwi kompanija organizavo vakarėlį paplūdimyje. Viskas tvarkinga -- sumokėta barui, kad jeigu parodai ženkliuką, gauni nemokamai gėrimų.

Tada kitą vakarą BitCoin sindikatas (taip ir nesupratau, kas tiksliai: kažkiek pavienių žmonių ir kažkiek kažkaip tarpusavyje susijusių kompanijų) irgi suorganizavo vakarėlį paplūdimyje ir paskaitą apie BitCoin ir blockchain technologijas.

Kai nuėjome pasižmonėti ir paklausyti apie blockchain (nes nu man iš tikro įdomu ta technologija), tai visus radome ne paplūdimyje, o automobilių stovėjimo aikštelėje prie paplūdimio. Nes nebuvo jokio baro, o sindikatas tiesiog nupirko kelias dėžes alaus ir juos visus praspyrė iš paplūdimio, nes ten galima gerti tik iš skardinių, o ne iš stiklinių butelių.

Paskaita tai buvo kelių vaikinų rėkimas apie tai kaip BitCoin'ai labai gerai ir viską gali pirkti, ir paprasti pinigai negerai, nes illuminati, ir visos valstybės yra negerai. Ypač vakarų valstybės.

Tai taip ir nepagilinau savo BlockChain žinių, o ėjau į paplūdimį ir į jūrą maudytis.

O šiaip konferencijoje buvo keletas kalbų apie blockchain, kaip technologiją. Ir panašu, kad ateityje tai gali tapti rimta iš techninės pusės, o ne iš tų ožkutinių pinigų pusės.

Nu bet tada grįžęs skaičiau N tokių straipsnių:
https://medium.freecodecamp.org/a-hacker-stole-31m-of-ether-how-it-happened-and-what-it-means-for-ethereum-9e5dc29e33ce

EuroPython tampa lokalia konferencija


Kažkada EuroPython buvo antra pagal dydį (po PyCon) ir automatiškai pagal svarbą Python konferencija. Kažakada (berods 2010) aš pats dalyvavau CPython sprinte, kur mums durnutukams patarinėjo N (Kur N > 2) Python core programuotojų. Jau kelinti metai nevyksta net CPython sprintas. Po teisybei, nei Django sprintas nevyksta. Nes nors ir EuroPython vis dar yra antra pagal dydį Python konferencija, bet core ešalonas ją jau aplenkia.

O ir pranešimų core programuotojai beveik neskaitė. Aš šiaip nesu tikras dėl to žodžio "beveik" reikalingumo. Gali būti, kad nei vienas core Python programuotojas neskaitė jokio pranešimo EuroPython konferencijoje.

EuroPython po truputį tampa bėdžių europiečių konferencija bėdžiams europiečiams.

Klijų kalba


Iš visų kalbų labai pranešimų ir nuotaikų aplinkui panašu, kad Python'as po truputį tampa absoliučiai klijuojančia programavimo kalba (glue language). T.y. kalba, kuria Python visą laiką reklamavosi, kad yra.

Python visur naudojamas kažką su kažkuo surišti ir sujungti. Pvz.: TensorFlow (https://en.wikipedia.org/wiki/TensorFlow) Machine Learning įrankis, kur po apačia sukasi galingasis C++ ir CUDA, o paviršiuje yra patogus Python API, kad lengvai galėtum jį prikergti kur tau bereikia.

Hmmmmm... Šiaip kuo toliau, tuo labiau į Python Web karkasus (framework) galima žiūrėti kaip į klijuojamo (glue) principo panaudojimą. Nes šiais laikas Python darbas iš esmės yra suklijuoti/sujungti DB (Pvz.: PostgreSQL) su kažkokiu UI (SPA ar mobili aplikacija) per kažkokį API.

Async IO, Python 3


Anksčiau būdavo jaučiama tokia mintis "Įdomu, ar Python3 prigis?". Po kiek laiko buvo jaučiama tokia mintis "Įdomu, ar Async IO prigis?". Panašu, kad tiek Async IO, tiek Python 3 jau prigijo ir gyvuos.

Dėl Python 3 -- gerai, dėl Async IO -- aš asmeniškai nelabai patenkintas. Papildoma leksinė kompleksija, kai visą tai buvo galima atlikti esama sintakse (Žėti: Twisted, Greelet, Tornado)

O kas panašu, kad neįgauna pagreičio tai tipų anotacijos (http://mypy-lang.org/).

Perklausytos kalbos


A Python for Future Generations

https://ep2017.europython.eu/conference/talks/a-python-for-future-generations

Šiaip visai gera pabumbėjimo kalba. Maždaug, mažai kas gerai ir daug kas blogai. Ir ką reiktų keisti. Bet be jokio plano, kaip keisti, kada keisti. Tik kodėl reikia keisti.

Protocols and Practices enforcing in Python through bytecode and inspection

https://ep2017.europython.eu/conference/talks/protocols-and-practices-enforcing-in-python-through-bytecode-and-inspection

Turbogears 2 autoriui nepatinka, kad žmonės ima ir pridirba bilen kokių nesąmonių su jo sukurtu įrankiu. Tada ateina pas jį ir sako jam, kad jo įrankiai yra sugedę.

Tai ši kalba apie tai, kaip apsaugoti pačius vartotojus nuo kojos persišovimo. Galvojate, kad siūlo naudoti assert, if ir visokias metaclass magija. O ne -- čia kapsto dar giliau ir siūlo knaisiotis po patį kodo medį ir ten tikrinti, ar jo kodas "teisingai" iškviestas.

https://docs.python.org/3/library/inspect.html

2 + 2 = 5: Monkey-patching CPython with ctypes to conform to Party doctrine

https://ep2017.europython.eu/conference/talks/2-2-5-monkey-patching-cpython-with-ctypes-to-conform-to-party-doctrine

Įdomus pranešimas, kaip naudojant ctypes programos vykdymo eigoje keisti bitinį kodą į savo kodą. Rekomenduoju -- čia geras pranešimas.

Bringing Python to Godot game engine

https://ep2017.europython.eu/conference/talks/bringing-python-to-godot-game-engine

Apie tai, kaip bandė Python pritempti prie Godot žaidimų variklio. Įdomu gali būti nebent tiems, kas domisi žaidimų programavimu.

Debugging in Python 3.6: Better, Faster, Stronger

https://ep2017.europython.eu/conference/talks/debugging-in-python-36-better-faster-stronger

JetBrains programuotoja pasakojo, kaip galima pasirašyti greitą debuger'į

Panašiai, kaip 2 + 2 = 5 pranešime naudojo ctypes ir įterpinėjo į bitų kodą savo erezijas, kad gautų daugiau greičio. Tik šitam pranešime mažiau magijos, o daugiau aiškumo.

Rekomenduoju šį pranešimą.

https://docs.python.org/3/library/dis.html
https://www.python.org/dev/peps/pep-0523/

Bitcoin and Blockchain for Pythoneers

https://ep2017.europython.eu/conference/talks/bitcoin-and-blockchain-for-pythoneers

Buvo žiauriai nuobodu ir nieko neatsimenu.

AAA Games with Unreal Engine 4 and Python

https://ep2017.europython.eu/conference/talks/aaa-games-with-unreal-engine-4-and-python

Žmogus sugebėjo įkergti Python į Unreal 4 žaidimų varikliuką. Realiai pačiuose žaidimuose nerekomenduoja naudoti. Bet rekomenduoja naudoti kaip klijuojantį įrankį, kad būtų lengviau bendrauti su kitais žaidimų kūrimo paketais. Pavyzdžiui: Maya.

GPU Acceleration of a Global Atmospheric Model using Python based Multi-platform

https://ep2017.europython.eu/conference/talks/gpu-acceleration-of-a-global-atmospheric-model-using-python-based-multi-platform

Labiau priminė kažkokio mokslinio laipsnio gynimą kažkokia labai siaura tema.

Pirmos dienos "Lightning Talks"

Nieko įdomaus nebuvo

How to create inspiring data visualizations?

https://ep2017.europython.eu/conference/talks/how-to-create-inspiring-data-visualizations

Kažko svarbaus ir ypač įžvalgaus nepapasakojo. Bet rodė gražius paveiksliukus ir gražias vizualizacijas, tai man patiko, nes man patinka gražūs paveiksliukai.

Write more decorators (and fewer classes)

https://ep2017.europython.eu/conference/talks/write-more-decorators-and-fewer-classes

Bandė išplaukti ant šito pranešimo ("Stop Writing Classes") šlovės:
https://www.youtube.com/watch?v=o9pEzgHorH0

Bet labai dar toli iki ano gerumo.

Abstract Base Classes: a smart use of metaclasses

https://ep2017.europython.eu/conference/talks/abstract-base-classes-a-smart-use-of-metaclasses

Kažkokios keistenybės. Vienintelė idėja, kurią pasigavau, tai kad gali bet kokią klasę priregistruoti prie bet kurios collections abstrakcijos.

>>> import collections
>>> class Foo: pass
...
>>> collections.Awaitable.register(Foo)

>>> isinstance(Foo(), collections.Awaitable)
True



Why you don't need design patterns in Python?

https://ep2017.europython.eu/conference/talks/why-you-dont-need-design-patterns-in-python

Jaunimas burnoja and Design Pattern. Jaunimas nesupranta. Jaunimas turbūt net nedaskaitė knygos iki tokio šablono pavadinimu "Interpreter". Būtų išsitaškę smegenys jaunimui.

There should be one obvious way to bring python into production

https://ep2017.europython.eu/conference/talks/there-should-be-one-obvious-way-to-bring-python-into-production

Šiaip sau.

Feeding a real-time user interface

https://ep2017.europython.eu/conference/talks/feeding-a-real-time-user-interface

Kaip žmonės išrado, kad nereikia klientams siuntinėti visų pokyčių kaip atskirų elementų. O galima paimti visus keitimus, juos akumuliuoti ir siųsti klientui tik tą akumuliaciją.

Šiaip įdomi visai kalba. Tiesa, labai vidutiniškai įdomi.

https://docs.python.org/3/library/difflib.html

Nelabai susiję (tik biški), bet siūlau pasižiūrėti šitą pranešimą:
https://www.youtube.com/watch?v=V6DKjEbdYos

Making Games with Python: Mission Impossible?

https://ep2017.europython.eu/conference/talks/making-games-with-python-mission-impossible

Tokia klišinė diskusija. Atsakymas: jo -- įmanoma, bet neverta.

Antros dienos "Lightning Talks"

Nelabai įdomu. Patiko, tik šitas PEP'as:
https://www.python.org/dev/peps/pep-0394/

Call a C API from Python becomes more enjoyable with CFFI

https://ep2017.europython.eu/conference/talks/call-a-c-api-from-python-becomes-more-enjoyable-with-cffi

Naujas (nevisai, bet mažai dar žinomas), super paprastas ir rekomenduotinas būdas, kaip C kodą susieti su Python.

https://cffi.readthedocs.io/en/latest/

How CPython parser works, and how to make it work better

https://ep2017.europython.eu/conference/talks/how-cpython-parser-works-and-how-to-fix-it

Pats kažkada susidūriau su panašia problema. Python negali paleisti štai tokio kodo:

foo = (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + (2 + 2))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
print(foo)

Tiesiog miršta interpretatorius. Tai čia netiesiogiai paaiškina kodėl.

Writing code? Pfft... Evolve it instead!

https://ep2017.europython.eu/conference/talks/writing-code-pfft-evolve-it-instead

Pranešimas kaip automatiškai generuoti programinį kodą. Naudojo BrainFuck, nes
ano labai paprasta sintaksė.

Green threads in Python

https://ep2017.europython.eu/conference/talks/green-threads-in-python

Paėmė greenlet ir paėmė Async IO ir tik su dideliu kiekiu hack'ų tesugebėjo pritemti Async IO greitį prie greenlet rezultatų. Bet išvada vis tiek buvo, kad Async IO yra labai gerai. Hmmm...

https://greenlet.readthedocs.io/en/latest/

Rendering complex 3D-Geodata using pyRT

https://ep2017.europython.eu/conference/talks/rendering-complex-3d-geodata-using-pyrt

Šiaip sau.

Realtime Distributed Computing At Scale (in pure Python!): Storm And Streamparse

https://ep2017.europython.eu/conference/talks/realtime-distributed-computing-at-scale-in-pure-python-storm-and-streamparse

Labai gražus ir tvarkingas pranešimas apie tai kaip Parse.ly naudoja Apache Storm.

http://storm.apache.org/

How to make money with your Python Open-Source Project

https://ep2017.europython.eu/conference/talks/how-to-make-money-with-your-python-open-source-project

Vienas geriausių konferencijos pranešimų. Kaip uždirbti pinigų iš ne mega populiarių atviro kodo projektų. Pasirodo įmanoma.

Trečiadienio "Lightning Talks"

Vienintelė įdomi biblioteka apie kurią sužinojau tai objgraph. Ji parodo objektų tarpusavio ryšius (references) grafiniu pavidalu. Originaliai skirta gaudyti atminties nutekėjimą (memory leaks).

https://mg.pov.lt/objgraph/

The Different Roads We Take

https://ep2017.europython.eu/conference/talks/the-different-roads-we-take

Turėjusi būti įkvepianti kalba. Bet aš per didelis savo bezdaluose paskendęs/užsiuostęs cinikas, kad mane įkvėptų. Plius, pačioje pranešimo pradžioje padarė standartinę klaidą, kad sumaišė kompiuterių mokslą (eee... mokslą) su programavimu (amatu). Ir atseit, jeigu tau nesisekė kompiuterių mokslas, tai vis tiek gali būti programuotojas (Eeeee... Nu nes skirtingi dalykai).

Type Annotations in Python 3: Whats, whys & wows!

https://ep2017.europython.eu/conference/talks/type-annotations-in-python-3-whats-whys-wows

Vienintelis pranešimas visoje savaitės ilgio konferencijoje apie tipų anotacijas. Nepanašu, kad Python pasaulyje tipai stipriai įsigalėja. Toks labai įvadinis pranešimas.

Network visualization and automation

https://ep2017.europython.eu/conference/talks/network-visualization-and-automation-with-python

Šiaip tai turėjo būti gal ir įdomus pranešimas, bet sugedo projektorius ir kaip ir nebuvo niekas užbaigta.

Cloud Native Python in Kubernetes

https://ep2017.europython.eu/conference/talks/cloud-native-python-in-kubernetes

Iš pavadinimo turėtų būti įdomus ir savalaikis pranešimas. Bet nieko neatsimenu, tai gal ir neįdomus.

Bet pasižymėjau, kad pranešėjas atsiprašė už tai, kad naudoja "blogą" (anot jo) kodo rašymo stilių. O jį tokį naudoja, nes tas blogas stilius yra lengviau suprantamas ir lengviau skaitomas. O tai koks tada yra geras stilius? Sunkiau suprantamas ir nebeįskaitomas?

Tai čia toks mano nugrįbavimas į lankas.

Developing elegant workflows in Python code with Apache Airflow

https://ep2017.europython.eu/conference/talks/developing-elegant-workflows-in-python-code-with-apache-airflow

Įvadinis pranešimas į Apache Airflow. Čia biblioteka/sistema/karkasas prižiūrėti pagalbinėms užduotims (background tasks) vykdyti. Tos užduotys gali turėti sudėtingas hierarchijas ir dar daug ką skirtinga. Tai pats principas aiškus, bet iš pranešimo ne kaži ką atsimenu.

http://airflow.apache.org/

AI on a Pi

https://ep2017.europython.eu/conference/talks/ai-on-a-pi

Šiaip pavadinimas neišduoda, bet jis realiai buvo Amazon AI įrankių reklama. Pranešėjas geras ir tie įrankiai geri, tai visai patiko. Kad ir reklama.

https://aws.amazon.com/polly/
https://aws.amazon.com/rekognition/
http://mxnet.io/

Practical Debugging - Tips, Tricks and Ways to think

https://ep2017.europython.eu/conference/talks/practical-debugging-tips-tricks-and-ways-to-think

Pranešimas pradedantiesiems. Bet buvo įdomių dalykų. Pavyzdžiui nežinojau, kad yra toks reikalas:


from ipdb import launch_ipdb_on_exception
with launch_ipdb_on_exception():

Ir geriausias patarimas. Jeigu turi problemą su kodu, tai eik ir kam nors apie tai papasakok. Bepasakojant suprasi, kame bėda.

Best Practices for Code Reviews

https://ep2017.europython.eu/conference/talks/best-practices-for-code-reviews

Kažkaip nelabai atsimenu gerų patarimų. Standartinis: kritikuok kodą, o ne programuotoją.

Introduction to TensorFlow

https://ep2017.europython.eu/conference/talks/introduction-to-tensorflow

Kažkaip neįstrigo. Gal dėl to, kad neįspūdingas pranešimas. Gal dėl to, kad jau galvelė nebeveikė.

Large-scale data extraction, structuring and matching using Python and Spark

https://ep2017.europython.eu/conference/talks/large-scale-data-extraction-structuring-and-matching-using-python-and-spark

Kaip naudojo Apache Spark ir kaip dėl to jiems gerai sekėsi. Man tai neįdomu buvo.

Overcoming Cognitive Bias

https://ep2017.europython.eu/conference/talks/overcoming-cognitive-bias

Paskutinį laiką išdeginau vienam vieninteliam per visą konferenciją "diversity" pranešimui. Ir tas nei kažko naujo papasakojo, nei juokingas, nei pernelyg absurdiškas.

Penktos dienos "Lightning Talks"

Šiaip nieko įdomaus nebuvo. Bet verta pasižiūrėti, kurį nors iš pirmų trijų dienų blitz pranešimų sesiją ir pasižiūrėti šitą. Anas vedė profesionalus vedėjas. Šitą geros valios kupini mėgėjai. O vargeli, kaip visą salę buvo apėmęs svetimos gėdos jausmas.

2017 m. gegužės 15 d.

Pycon 2017 LT: Prototipinio OOP įgyvendinimas su Python

Šeštadienį Kaune vyko Pycon LT 2017 konferencija (http://pycon.lt/). Čia mano pranešimo ("Prototipinio OOP įgyvendinimas su Python"), kurį aš skaičiau, tekstas.

Skaidrės:
http://petraszd.com/pycon-2017/

Kodo pavyzdžiai:
https://bitbucket.org/petraszd/pyconlt-2017-demo
Pačios kalbos įrašas:
https://www.youtube.com/watch?v=Jcgp5-8_XkU



--------------------

Sveiki,

Aš esu Petras Zdanavičius. Šiandieną aš jums pristatysiu pranešimą apie prototipinį OOP ir parodysiu demonstracinį jo įgyvendinimą Python pagalba.

Pranešimas nebus naudingas praktiškai. Tai daugiau kompiuterių mokslo ar net kompiuterių filosofijos tema. Filosofijos, nes aš kaip ir kiekvienas programuotojas, mėgstu savintis visuomenėje gerbiamus irba mėgstamus titulus. Kaip menininkas, kūrėjas, filosofas [pauzė], ninzė. Ar roko žvaigždė (rockstar).

Nes jo -- kiekvienas programuotojas tamsioje kamūrkėje po 80-uom valandų per savaitę kalantis kodą, turi ekvivalentų gyvenimo būdą kaip roko žvaigždė.

Apie ką aš čia? A. Tai va, aš jums papasakosiu apie prototipais paremtą OOP.

OOP Apibrėžimas I

Jeigu, jūs programuojate (ypač jeigu jūs programuojate Python), jūs esate susidūręs su OOP.

OOP - programavimo paradigma, kompiuterinių programų architektūroje naudojanti objektus ir jų sąveikas [Wikipedia]

Čia Lietuvos Wikipedia taip sako. Aš nieko nesuprantu, kas čia bandoma pasakyti.

OOP Apibrėžimas II

Mano apibrėžimas. OOP:

- Yra objektai
- Objekto viduje saugoma jo būsena. Atributų pavidalu
- Objektas turi sąsają, bendravimui su išoria. Metodų pavidalu
- Objektai sąveikauja vieni su kitais ne tiesiogiai keisdami vienas kito būseną, bet siuntinėdami vienas kitam žinutes. Metodų kvietimo pavidalu

[Petras (c)]

"Klasikinis" OOP

Kai mes sakome OOP, tai galvoje paprastai turime klasėmis paremtą variantą. Nu tą klasikinį. Nu tą, kaip Java. Kur yra klasės. Jose apsirašai, kaip veiks objektai. Ta klasė, tai tarsi kažkoks Platono formų teorijos atitikmuo. Kur tobulos formos egzistuoja tik abstrakčiame idėjų pasaulyje. O empiriniame pasaulyje (Dar žinomame kaip realybė) egzistuoja tik netobulos jų kopijos. Panašiai kaip tobulos klasės ir netobuli objektai.

OOP Istorija

1970-iais Alan Kay vadovaujama Xerox PARC komanda sukuria Smalltalk programavimo kalbą. Kalba netinkamas žodis. Programavimo sistemą. Programavimo mašiną? Tai turėjo būti nauja paradigma. Kaip jie patys teigė "naujojo pasaulio" "Žmogaus ir mašinos simbiozė" paradigma. Ar nesakiau, kad programuotojai mėgsta savintis skambius žodžius.

Ir jų sistema labai skyrėsi nuo to, ką turime dabar. Ta programavimo kalba nebuvo atskiriama nuo IDE (Integruota kūrimo aplinkos). Ta prasme, viskas buvo vienoje aplikacijoje. Ir teksto redaktorius ir versijavimas, ir dokumentacija, ir atsarginės kopijos, ir programos būsena irgi buvo Smalltalk mašinoje.

Iš dabartinių aplinkų turbūt būtų galima palyginti su Racket. Arba žaidimų varikliukų aplinkomis. Tokių kaip Unreal ar Unity. Kurie lenkia visas šlubas sistemas irba konfigūracijas, kurias mes naudojame programuodami Web su Python. Ir lenkia keliais dešimtmečiais.

Bet grįžtant prie istorijos. Tada atėjo Bjarne Stroustrup. Jam patiko OOP idėjos. Ir jis jas paėmė ir dalį jų daugmaž pritempė prie C ir parašė transliatorių į C, kurį pavadino C++.

Tada atėjo Syn Microsystems, pasakė, kad C++ yra perdaug kosmosas. Paėmė C++ pseudo OOP ir apgludino aštrius kampus. Dabar mes todėl turime Java. Java bei C++ šiaip laikais yra laikomos kaip etaloninės, pavyzdinės OOP kalbos. O Alan Kay verkia kamputyje.

Prototipinio OOP Istorija

Toje pačioje Xerox PARC toks David Ungar ir toks Randall Smith dirbdami su Smalltalk'u nusprendžia, kad tas dualizmas tarp klasių ir objektų yra ne fengšui. Kad kodo bazės egzistavimo cikle vis tiek prisireikia keisti klasių struktūrą. Kartais vien dėl to, kad nu va reikia tokio vieno objekto. Nu vieno vienintelio mažučiuko. Nu bet labai reikia. Nu bet būtent tau reikia vieno objekto. Nu reeeiiikiaaa. Ir dėl to vieno objekto reikia griauti velniop visą klasių hierarchiją ir kažkaip įterpti tą naują klasę tam naujam objektui.

Nors realiai, tai paimi bet kurią esamą klasę, prirašai ten if'ų ir normaliai. Sukasi kaip bitė.

Tai jiems kilo klausimas: "o kas jeigu galėtum praplėsti ne klases, o objektus". Iš to automatiškai seka kitas klausimas: "o kas jeigu nėra klasių, o yra tik objektai?".

Self

Ir būtent taip gimė programavimo kalba "Self".

Kadangi tais laikais žmonės vis dar nebuvo praradę ūpo eksperimentuot su kodo redaktoriais (kitaip nei šiais, kai naujausi ir populiariausi kodo redaktoriai yra naršyklės... Kaip "Visual Studio Code" ar "Atom"), tai jie paėmė ir tuo pačiu sukūrė integruotą kūrimo aplinką, kuri atrodė taip.

[Self nuotrauka]

(Petro pastaba po visko: patingėjiau pasidaryti Self VM nuotrauką. Tai ir nebuvo nei nuotraukos, nei šito teksto)

JavaScript

Kalba buvo eksperimentitnė. Ji vis dar gyva. Bet šiaip visas prototipinis konceptas būtų miręs, jeigu ne 10 dienų Brendan Eich gyvenime. Brendan'as 1995 turėjo tokią užduotį sukurti programavimo kalbą. Jis tuo metu buvo susižavėjęs dviem kitoms kalbomis. "Schema" (kas yra Lisp-1) ir jau minėtoji "Self". Tai jis ir kūrė kalbą, kuri buvo keista tų dviejų sąjunga. Neekstremaliai humaniškai funkcinė (bet ne visai) prototipais paremta OOP kalba.

Aij, ir tuo metu buvo ant bangos Java, tai Brendan'ui buvo pasakyta, kad jo kalba turi atrodyti kaip Java.

Štai kaip mes dabar turime turbūt pačią populiariausią kaip nepagrindinę programavimo kalbą JavaScript. Nepagrindinę, nes paprastai žmonės programuoja kažkuo ir tada ant viršaus dar JavaScript.

Ir didokas procentas JavaScript programuotojų nė velnio nežino, kad ten yra kažkokie prototipai ir iš vis, kas jie ir kaip jie veikia.

Dėl to aš jums pabandysiu parodyti Python'o kodo pagalba, kas yra prototipais paremta objektinė sistema.

Kodas (Kas yra kanoninis objektas)

Pagal Java'inį OOP apibrėžimą yra trys OOP banginiai: enkapsulecija, paveldėjimas ir polimorfizmas. Pats Python'as realiai iš jų įgyvendina tik paveldėjimą. Tai čia mes irgi daugiausia dėmesio kreipsime į paveldėjimą.

Klasikiniame modelyje paveldėjimas vyksta klasių lygmenyje. O prototipiniame paveldėjimas vyksta objektų lygmenyje.

Pradėkime nuo to, kad tai yra prototipinis modelis. Turi būti bent vienas kanoninis objektas, kūrį galime praplėsti savo reikmėmis.

Mes kurdami naudojame Python programavimo kalbą. Viena pagrindinių ir galingiausių Python'o kalbos įrankių yra žodynas (dict). Tai ir mes savo implementacijoje kaip vidinę objekto struktūrą naudosime Objektą

Object = {
    '__proto__': {}
}


Kaip matote, tai yra tiesiog žodynas, savyje turintis vieną mums magišką raktą `__proto__`. Kas esate susidūrę su JavaScript, jau galite įtarti kaip viskas veiks.

Ir tuo pačiu susitarsime, kad niekad pačio žodyno tiesiogiai neliesime. Tam naudosime `proto` modulio funkcijas.

Taigi, pradžioja mums reikia būdų tą objektą praplėsti ir tuo pačiu būdo kaip sukurti naują objektą, jeigu mums nusispjauti, kas jo prototipas.

obj1 = p.create({'a': 'a-1', 'b': 'b-1'})
obj2 = p.extend(obj1)

assert obj1['a'] == 'a-1'
assert obj2['__proto__'] == obj1

print("It is fine!!!")


Tam bus dvi funkcijos. `create`, kuri pagal nutylėjimą praplės standartinį `Object` ir tuo pačiu priskirs jam kažkokius atributus.

Kita bus `extend`. Jos esmė bus praplėsti jau egzistuojantį objektą.

Pažiūrim, ar jos veikia. Veikia. Dabar pažiūrim, kaip jos parašytos.

def extend(other, keys=None):
    obj = {'__proto__': other}
    if keys is not None:
        obj.update(keys)
    return obj


def create(keys=None):
    if keys and '__proto__' in keys:
        prototype = keys.pop('__proto__')
    else:
        prototype = Object
    obj = extend(prototype, keys)
    return obj


Ganėtinai paprastai. Pirma sukuria naują žodyną. `__proto__` raktą nurodo į praplečiamą objektą ir jeigu reikia sukuria naujus reikšmių raktus.

`create` tuo tarpu tiesiog shortcut'as į `extend`.

Einam prie įdomesnio funkcionalumo. Galimybės keisti objektų būseną. Funkcinio programavimo fanai ir karvės to nesupras.

obj1 = p.create({'a': 'a-1'})

obj2 = p.extend(obj1)
p.set(obj2, 'b', 'b-2')

assert p.get(obj2, 'a') == 'a-1'
assert p.get(obj2, 'b') == 'b-2'

p.set(obj2, 'a', 'a-2')
assert p.get(obj2, 'a') == 'a-2'
assert p.get(obj2, 'b') == 'b-2'

assert p.get(obj1, 'a') == 'a-1'

assert p.get(obj2, 'c') is None
print("It is fine!!!")


Mes norime gauti ir keisti objektų atributus. Kadangi susitarėme, kad tiesiogiai pačių Python'o žodynų neliesime, tai tam turime dvi pagalbines funkcijas, išradingais pavadinimais `get` ir `set`.

Pažiūrim, ar veikia. Veikia. Pažiūrim, kaip ir kodėl veikia.

def set(obj, attribute_name, value):
    obj[attribute_name] = value
    return value


def get(obj, attribute_name):
    current_obj = obj
    while True:
        if attribute_name in current_obj:
            return current_obj[attribute_name]
        current_obj = current_obj.get('__proto__', None)
        if current_obj is None:
            break

    return None


`set` yra žymiai paprastesnė. Ji tiesiog pakeičia arba sukuria vidinio Python žodyno raktą. Viskas.

`get` yra įdomesnis. Jame ir yra visa esmė. Pradedame nuo esamo objekto ir ieškome norimo atributo jame. Jeigu neradome keliaujame giliau į jo prototipą.  Vėl ieškome atributo. Ir taip kol ką nors surandame arba baigiasi prototipai.

Pastaba: Norint sudirbti algoritmą tereikia paimti sukurti 2 objektus ir jų prototipus nurodyti vienas į kitą.

Ir čia yra visa esmė.

Bet OOP nebūtų OOP, jeigu nebūtų metodų ir jų kvietimo.

def get_two():
    return 2


obj3 = p.create({'get_two': get_two})
assert p.call(obj3, 'get_two') == 2

obj4 = p.extend(obj3)
assert p.call(obj4, 'get_two') == 2

print("It is fine!!!")


Čia turime `call` funkciją. Aš jums jos implementaticos dar nerodysiu, nes pereisime prie magijos.

def get_foo_plus_1():
    return p.get(this, 'foo') + 1


proto_obj = p.create({
    'get_foo_plus_1': get_foo_plus_1
})


obj5 = p.extend(proto_obj, {'foo': 1})
obj6 = p.extend(proto_obj, {'foo': 2})

assert p.call(obj5, 'get_foo_plus_1') == 2
assert p.call(obj6, 'get_foo_plus_1') == 3
print("It is fine!!!"
)

Kažkaip norisi įdomesnių metodų. Kurie pasiektų patį objektą. Tam mums reikia `this`.

Visas šitas marazmas, beje, veikia.

Implementacija. Gink die, nedarykite niekad taip.

def call(obj, attribute_name, *args):
    function = get(obj, attribute_name)

    this_backup = this
    _builtins.this = obj
    result = function(*args)
    _builtins.this = this_backup
    return result


try:
    import builtins as _builtins
except ImportError:
    import __builtin__ as _builtins
_this = create()
_builtins.this = _this


Jeigu paimsite JavaScript. Tai toje kalboje visada yra `this` kintamasis. Visada. Net ir globalioje vardų erdvėje (namespace). Tai ir mes tokį va sukuriame. Geras? Ne? Python 2 ir 3 skiriasi, bet abu leidžia nesudėtingai šaudyti sau į kojas.

Tada `call`. Paprasta. Pernaudojame `get`, kad gauti funkciją. Nes ji gali būti ir giliau. Išsisaugojame dabartinę `this` reikšmę. Nustatome ją į einamą objektą. Iškviečiam funkciją. Gražiname prieš tai buvusį this.

Pabaiga

Kaip ir viskas. Ačiū, kad klausėte. Jeigu turite klausimų (nelabai įsivaizduoju kokių), tai mielai į juos atsakysiu.