= 5. Moderní softwarové systémy =
Interpretace požadavků od Mr. Tůmy:
http://d3s.mff.cuni.cz/~ceres/adm/moderni-softwarove-systemy.php
== a. Moderní architektury: ==
i. virtualizace paměti na paralelních architekturách (SMP, NUMA),
ii. hyperthreading,
iii. multicore,
iv. podpora v operačním systému,
v. programování v paralelních prostředích,
vi. neblokující algoritmy
Distribuovaný systém: nezávislé uzly, dojem jednotného systému, komunikace mezi uzly přes síť.
Distribuované osy mrtvé, mechanismy využity v aplikacích, lokální os, rozšiřující vrstva, distribuovaná mezivrstva (middleware)
Transparentnost - tváří se to jako jednotný systém
=== i. virtualizace paměti na paralelních architekturách (SMP, NUMA), ===
Paralelní architektury:
- Těsně spřažené (tightly coupled) - multiprocesory se sdílenou pamětí
- sběrnicová: sdílená sběrnice hází data do cache procesoru
- přepínačová: mřížka procesory x paměti, nebo omega network nlogn - používá perfect shuffle - každá krabice spojuje dvě z předchozí úrovně, např. 1.+3., 2.+4,...
- Volně spřažené (loosely coupled) - multicomputery, každý vlastní paměť
- sběrnicová: běžná počítačová síť, netřeba tolik komunikace jako u tightly protože má každý svou paměť, možnost processor pool (mám logické procesory, dávám jim fyzické z poolu)
- přepínačová:
- mřížka: na každé pozici mřížky jeden počítač, fajn pro 2D problémy, grafy,...
- hyperkrychle: obvykle 4 rozměrná, každý počítač přímo propojen se sousedy ve všech rozměrech. IBM Watson Blue Gene
==== SMP: ====
Symmetric multiprocessing: architektura, kde je víc procesorů připojeno na jednu paměť, používaná v dnešních multiprocesorech.
procesor může běžet na datech ať jsou kdekoliv v paměti. přesouvání tasků po procesorech - load balancing
aby se plně využily procesory, musí s tím program počítat. I když s tím nepočítá, je to rychlejší než single procesor, protože není tolik přerušení - místo přerušení se to hodí na volné procesory, když běží víc tasků, každý má svůj procesor - to musí umět os
sériový přístup do paměti, typicky přes sběrnici
==== Hybridní architektura NUMA: ====
Non Uniform Memory Access, v multiprocesorech
procesor má kus paměti kam může přistupovat rychleji než do zbytku, občas se musí přesouvat data. fajn pro servery, kde mají tasky přiřazená data plus mínus pevně.
procesory jsou rychlejší než paměti, proto mají cache
víc procesorů může lézt do paměti najednou, do svého kusu.
cacheově nekoherentní NUMA se blbě zaintegrovává do klasické architektury počítače, proto se používá ccNUMA - má special hardware na udržování koherence, pokud procesy sdílí data, musí se synchronizovat.
cache coherence:
- jednoduchá varianta - bus sniffing. cache má bity: valid, invalid, dirty , shared (má to ještě někdo). čtou a zapisují data, posílají si broadcast signály přes sběrnici. Nedá se to moc škálovat.
- Možno použít SCI Scalable Coherent Interface standard komunikace, založený na distributed directory based cache coherence model
Při práci s pamětí si procesor udělá lokální kopii dat ve své cachi, původní data zůstávají v paměti
S-COMA: Simple Cache-Only Memory Architecture
Používá hlavní paměť jako cache, čili když pracuje s daty, tak si je přesune do svého adresového prostoru
ASMP: Asymmetric Multiprocessing: specializované procesory pro specifické tasky
NUMA-faktor - rozdíl latence lokálních a vzdálených paměťových přístupů
=== ii. hyperthreading, ===
==== SMT - Simultaneous multithreading:====
narozdíl od Temporal Multithreading, kde může běžet jen jedno vlákno na procesoru v jednu dobu, tady může běžet víc. Zvyšuje Thread Level Paralelism. Procesor musí mít akorát větší registry, aby se tam vešel kontext víc vláken, a musí umět brát instrukce víc threadů najednou. Oproti superskalárním procesorům, které berou instrukce z jednoho vlákna a vykonávají je paralelně (když to jde) - tj. zvyšují Instruction Level Paralelism, berou instrukce z víc threadů.
Pipelining - zatímco se čeká, dělá se něco dalšího. nemusí paralelně.
Hyperthreading (HTT): technologie Intelu, která umí pouštět instrukce z víc threadů na jednom procesoru najednou (SMT). Os adresuje místo každého fyzického procesoru dva virtuální. Musí mít podporu minimálně pro SMP, ale měl by být na to optimalizovaný. Např. jeden thread může používat Integer a druhý floating point sčítačku. Některé části procesoru se duplikují, většina ne.
Very long instruction word or VLIW: kompilátor vytváří instrukce včetně informací co je na čem závislé. frčí v embedded systémech.
=== iii. multicore, ===
Více procesorů v jednom integrovaném obvodu
různé stupně couplingu: sdílejí cache/ne
homogenní nebo heterogenní
Amdahl's law: improvement = 1/((1-p)+ p/s) .. p je procentáž operací, kde se dá využít paralelizace, s .. zrychlení
častěji se může provádět cache coherency synchronizace - může být uvnitř, menší spotřeba než vysokofrekvenční, nebo víceprocesorové.
fajn na servery s více uživateli, např web servery
=== iv. podpora v operačním systému, ===
ASMP-L INUX, ASymmetric MultiProcessor Linux,
==== Sdílené caches, soupeření o kapacitu a udržování koherence ====
Intel Core Duo má sdílené cache.
Výhody sdílených cachí: když jedno jádro spí, druhé má cache pro sebe. Rychlé sdílení dat mezi vlákny běžícími na různých jádrech se sdílenou cachí. Míň problémů s cache coherence, nemusí se tak často přistupovat do paměti. Techniky optimalizování přístupů do sdílených cachí, další pojmy:
- cache blocking (data tiling): pro zpracování datasetů - nad každým kusem dat se dělají nějaké operace. rozdělit data na menší kusy, aby se vešly do cache, udělat nad nimi co se dá.
- delayed approach: čeká se až se změny dostanou do L2 cache a pak se teprv druhému jádru řekne, že má pokračovat, čímž se ušetří jedno čtení z paměti do cache.
- False sharing: sice každý píše někam jinam do sharované cache, ale stejně se to musí synchoronizovat přes další level paměti (L2/paměť). Řešení: dávat nesdílená data odděleně od sdílených.
- Procesor affinity: vlákna, která mají sdílená data, by měly jít na stejné jádro, nebo na jádra, která sdílí cache. když dávám na stejný procesor, nebo procesory se sdílenou cachí vlákna, které nemají nic společného, tak to nebude moc fajn, budou bojovat o cache.
Cache coherence: když jsou stejná data v cachích dvou procesorů a jeden je změní, tak se změna musí propagovat i do druhé cache. Musí být zachováno:
- pořadí instrukcí (když něco zapíšu, nikdo to nezmění a já to znovu přečtu, mělo by to být ono),
- čtení aktuálních dat,
- pořadí zápisu.
Udržování:
- Directory based: directory hlídá všechny čtení a zápisy do cachí z hlavní paměti, procesory před čtením/zápisem se ptají jestli můžou. Když se data změní, updatuje/invaliduje to všem cache.
- Snooping: každý procesor hlídá kus paměti, který má nacachovaný. Když se změní, updatuje si cache. = bus sniffing. cache má bity: valid, invalid, dirty , shared (má to ještě někdo). čtou a zapisují data, posílají si signály přes sběrnici.Nedá se to moc škálovat, ale na malých je to rychlé
- Snarfing: jako snooping, ale ještě navíc to sleduje obsah paměti.
==== Optimalizace alokace (omezení kolizí, lokální alokace) ====
http://siber.cankaya.edu.tr/ozdogan/OperatingSystems/ceng328/node202.html
Alokace framů na procesy, možnosti:
- rovnoměrně: každý proces dostane stejně framů
- proporčně: podle velikosti jejich virtuální paměti
Algoritmy výběru stránky na vyhození: LRU (least recently used), hodiny (second chance): každá stránka má bit, při přístupu se nastaví na 0 při průchodu ručičky se nastaví na 1, při průchodu ručičky se vyhodí ty, které mají 1.
řešení kolizí:
- globální alokace: proces může sebrat jinému procesu frame, častější
- lokální alokace: nemůže, nemění se počet framů na proces
==== Požadavky na plánování u hyperthreading a multicore systémů. ====
http://www.scribd.com/doc/4838281/Operating-System-Scheduling-on-multicore-architectures
- cache fairness: některé thready potřebují víc místa v cachi a tím pádem utlačují ostatní. Priority ztrácí smysl, protože thread může být na procesoru zároveň s threadem, který mu sežere skoro celou cache a tím pádem poběží déle. Řešení: rozdělit cache na best-effort a cache-fair - dostanou se na procesor na delší čas.
- balance core assignment: nebalancovaný - těžko se určuje kdy co doběhne. pomocí benefit function se rozhoduje jestli se vyplatí přesunout thread na jiné jádro.
- maximalizovat resource utlization
btw. semafory = init, up, down. čítač, fronta procesů. Když chci vstoupit, dám down, po výstupu up.
monitory (condition variable) - v jazycích - např třída, ve které může běžet max jedna funkce v každém okamžiku. wait(podmínka), čekej až bude splněná; signal(podmínka) - vlákno dává najevo, že podmínka je splněná.
Zprávy, např MPI: send, receive. blokující/neblokující. přímé/nepřímé adresování
==== v. programování v paralelních prostředích, ====
===== Synchronizace, časové závislé chyby. =====
počítán zrychlení při paralelním výpočtu:
- Amdahl's law: improvement = 1/((1-p)+ p/s) .. p je procentáž operací, kde se dá využít paralelizace, s .. zrychlení
- Gustafson's law: speedup S(P) = P - alfa*(P-1) .. P.. počet procesorů, alfa je procentáž operací kde se NEDÁ použít paralelizace, narozdíl od Amdahla počítá, že máme fixní čas a podle toho volíme velikost problému. narozdíl od Amdahla bere část, která se nedá zpracovat paralelně jako konstantní.
Datové závislosti: žádný program nemůže běžet rychleji než je doba zpracování instrukcí na jeho critical path (nejdelší cesta ze závislých instrukcí).
Bernsteinovy podmínky: vstupní proměnné - pro čtení R_i, R_j, výstupní proměnné - pro zápis W_i, W_j. Podmínky:
R_j \cap W_i = \varnothing: porušení - zápis a čtení v jedné proměnné - závislost toku
R_i \cap W_j = \varnothing: porušení - přepsání už přečtené proměnné
W_i \cap W_j = \varnothing: porušení - dva píší na stejné místo
.. sdílenou proměnnou je možné akorát číst... je to příliš přísné, pouze teoretický význam
race condition - výsledek záleží na pořadí provádění operací
distributed deadlock - deadlock v distribuovaném prostředí. možnost udělat globální wait-for-graph, dvoufázové zamykání, dvoufázový commit (první fáze hlasování o commitu, druhá commit když všichni pro, nebo abort)
úrovně Paralelismu:
- bit level: n-bitové procesory
- instruction-level paralelism: vykonávání instrukcí paralelně, tam kde je to možné, pipeliny, superskalární procesory, SMT
- data paralelism: rozdělit data na menší kusy, na každém z nich něco v cyklu počítat, místo jednoho velkého supercyklu
- task paralelism: na jedněch datech běží víc operací najednou
POSIX threads - standard API na thready, implementace na unixu, windows. mutexy, condition variables, barriers, ...
MPI - portabilita, de facto standard, jádro dostane jeden proces.
- výkonné, škálovatelné, portabilní, Java, Python, C#, ...
- point-to-point komunikace, broadcast mezi proces ve skupině, podpora standardních datových typů.
- MPI2 - sdílená paměť
- hezky to běží na NUMA architektuře, podporuje lokalitu paměti
- Language Independent Specifications
- topologie, synchronizace, komunikace mezi procesy nasazenými na různé uzly
- Concepty mpi2:
- komunikatory: objekty, dá procesům čísla, rozdělí je do topologie, podle toho jak komunikují
- point to point: všechny možné varianty posílání zpráv mezi dvěma procesy
- collective: broadcast, reduce
- vychytané datové typy- structy za sebe apod.
===== Koncepty paměťových modelů. =====
Paměťový model: popisuje jak vlákna interagují přes paměť. Jaké podmínky musí kompilátor udržovat při optimalizacích.
Když jazyk nemá memory model nemůžou se dělat základní optimalizace, jako třeba sloučení dvou stejných cyklů za sebou (loop fusion). Když přehodí co nemá může dojít k race condition. Model specifikuje Synchronizační bariéry - když se dostanu k bariéře (např lock), musím vidět všechny změny na sdílených proměnných, jinak ne. Tím pádem může kompilátor dělat optimalizace, musí jen zaručit, že na bariérách to bude stejné jako kdyby se kód prováděl sekvenčně.
Cache se nesynchronizjí pořád - bylo by to pomalé. Z pohledu vlákna se akce, které dělá jeví být v daném pořadí. Z pohledu jiného vlákna to může vypadat jinak.
standard C++0x už bude mít memory model.
- Data race: vlákno čte zatímco jiné vlákno zapisuje. Zapisuje a čte se vždycky kus najednou, takže se může přepsat něco co se mezitím změnilo.
Java memory model.
http://www.cs.umd.edu/~pugh/java/memoryModel/jsr-133-faq.html
- within-thread as-if-serial: v rámci jednoho vlákna sémantika stejná jako by to běželo tak jak je nadefinováno
- synchronizační akce, např uvolnění zámku: vše před akcí je vidět pro všechny po akci
- happens-before uspořádání: read může přečíst hodnotu která byla zapsána jako poslední v happens-before uspořádání, nebo může přečíst hodnotu, která byla zapsaná nějakým writem neuspořádaným vůči readu. Tj. akorát nemůže číst hodnoty z budoucnosti.
- záleží na procesoru, některé mohou mít strong (tj. vždy se to synchronizuje)
- hýbání writy dopředu a dozadu tak aby to neovlivnilo sémantiku, ale přesto se můžou dít podivuhodné věci (např. příklad se zapisováním a čtením, a=1, b=2 na sobě nezávisí).
- původní memory model se ukázal být rozbitý
- když v konstruktoru neunikne reference na nový objekt, tak všichni vidí final fieldy tak jak je konstruktor nastavil, bez nutnosti synchronizace. Např. nepřidávat nový objekt doWhy should you care? Concurrency bugs are very difficult to deb nějakého listu přímo v konstruktoru.
- data race: (když má data race, tak je nesprávně synchronizovaný)
1. there is a write of a variable by one thread,
2. there is a read of the same variable by another thread and
3. the write and read are not ordered by synchronization
- synchronizace: při acquire a release na zámku, synchronizace (cachí, registrů, ...)
- memory operations na které se váže happens-before uspořádání: čtení, psaní, lock, unlock, start thead, join (čekání až typicky child vlákno něco skončí),
- ordering rules:
* Each action in a thread happens before every action in that thread that comes later in the program's order. (v sémantickém smyslu)
* An unlock on a monitor happens before every subsequent lock on that same monitor.
* A write to a volatile field happens before every subsequent read of that same volatile.
* A call to start() on a thread happens before any actions in the started thread.
* All actions in a thread happen before any other thread successfully returns from a join() on that thread.
- synchronizační akce musí matchovat, tj musí probíhat na stejném monitoru/čekat na stejné vlákno/..
- volatile: read vždy vrátí výsledek posledního writu. kompilátor je nesmí dávat do registrů, cacheovat. po writu hned flush a invalidovat cache, před čtením taky invalidovat cache, zápis je to samé jako monitor release, čtení jako acquire. co se stalo předtím se propaguje. zase to musí matchovat.
- double checked locking - nefunguje, není zaručeno, že inicializace nového objektu se provede před vrácením z funkce
- statické inicializace jsou vidět všemi, vnitřní třídy jsou lazy
===== Consistency models ======
consistency models http://en.wikipedia.org/wiki/Consistency_model
http://www.cs.nmsu.edu/~pfeiffer/classes/573/notes/consistency.html
pravidla, co může dělat systém při paralelním vykonávání, který podporuje daný model, z pohledu sdílené paměti.
- striktní konzistence: read vrací to co zapsal poslední write, vykonávání instrukcí nad pamětí přesně v daném pořadí. intuitivně co by to dělalo bez cachí Nemožno zaručit v distribuovaném systému s cachemi.
- sekvenční konzistence: jestli je něco sekvenčně konzistentní je nerozhodnutelný problém. Výsledek bude stejný jako kdyby se to dělalo v nějakém existujícím pořadí, nepřehazuju operace nodu. Node vidí všechny write operace ve stejném pořadí jako si řekl.
- cache coherence: to samý jako sekvenční, ale bere se to jenom lokálně (za proměnnou). sekvenční to bere globálně.
- kauzální konzistence: slabší než sekvenční, silnější než PRAM. kauzální operace vidí všichni ve stejném pořadí. čtení a pak zápis jedním nodem jsou kauzální. zápis a pak čtení jedním nodem z té samé proměnné je kauzální. dva zápisy stejným nodem jsou kauzální (počítá, že první zapsaná se nezměnila a může se promítnout do druhé). Kauzalita je tranzitivní. Co není kauzální je concurrent. špatně se implementuje v hw.
- PRAM konzistence: pipelined random access memory, reflektuje sítě a latenci mezi uzly. Writy tvořené nodem vidí všichni ve správném pořadí. Od různých nodů vidí pořadí různé procesory různě (latence).
- Slow memory: zápisy jedním nodem do jednoho místa musí být vidět v tom správném pořadí
- slabá konzistence: ne všichni se potřebují synchronizovat se všemi. nechat proces ukončit kritickou sekci a poté rozeslat
změny ostatním. jsou synchronizační (slouží jen na synchronizaci) a nesynchronizační přístupy do paměti. Podmínky:
- přístup do synchronizačních je sekvenčně konzistentní
- přístup do synchronizačních musí počkat až se dodělají všechny writy
- přístup kamkoliv musí počkat až se dodělá synchronizace
- release consistency: paměť při přístupu k synchronizačním nerozezná vstup a výstup z kritické sekce- musí propagovat vždy vše. operace acquire a release. Podmínky:
- před přístupem do sdílené proměnné musím dodělat všechny acquires
- před releasem musím udělat všechny ready a writy
- acquire a release operace musí být sekvenčně konzistentní.
implementace: eager (všechno se propaguje po rel), lazy (propagace až při acqire)
- entry consistency: synchronizační proměnné vázány na sdílená data, vlastník - ten co naposled zapisoval. Zápis (exkluzivní) jen když nikdo nepřistupuje k synchronizačním proměnným, Po zápisu si musí další (neexkluzivní) vyžádat aktuální data od vlastníka.
==== vi. neblokující algoritmy ====
===== Klasifikace neblokujících algoritmů. =====
zajišťují, že se vlákno dostane k prostředku v konečném čase. Nepotřebují krické sekce. Alternativa k zámkům.
Motivace: zablokované vlákno nic nedělá, problémy s deadlocky, live locky (dávají si vzájemně přednost a nepostupujou) a priority inversion (neblokovaný s menší prioritou dostane resource před blokovaným s vyšší)
Implementace: atomické read-modify-write, compare-and-swap v hw. cas(*register, old_val, new_val). Když je v registru old_val, tak tam narve new_val a vrátí true, jinak neudělá nic a vrátí false. použití: přečtu hodnotu, udělám s tím něco. při pokusu zapsat, vyzkoušim jestli tam stará hodnota ještě pořád je, když jo, tak zapíšu novou. Když ne tak opakuju postup.
http://audidude.com/?p=363
ABA probém nastává když mezi mým čtením a voláním CAS někdo zapisuje a poslední jeho zapsaná hodnota je stejná jako moje, ale má jiný význam, něco se mezitím stalo. Řešení: používat counter ve skryté části proměnné, aby to nehodilo tento false positive.
- wait-free: nenastane starvation per thread, existuje horní hranice na dobu výpočtu. vzácné. Každý algoritmus může být naprogramován jako wait-free, ale je to pomalé.
- lock-free: nenastane starvation globálně, ale na threadu může. lock-free datové struktury - stack, fifo, ...
== b. Objektové koncepty moderních jazyků, třídy, mixiny, klony, vazba na typový systém ==
* Definice tříd, mixinů, klonů.
* Vysvětlení konceptů typové kompatibility.
=== Objektové koncepty, třídy ===
- dynamic dispatch
- encapsulation
- subtype polymorhism
- object inheritance
- open recursion (self, this)
=>
- reusability
- modularity
abstraction principles:
- classification/instantiation
- aggregation/decomposition
- generalization/specialization
- grouping/individualization: lists, tables
inheritance pokrývá aggregation a generalization
subclassing: vytváření subclassů. Můžu subclassovat aniž bych inheritoval (všechno předefinuju)
subtyping: instance subclass může být na místě class, ale members specifické pro subclass nejsou vidět - attribute hiding
specialization: is-a
multiple inheritance - diamond problem. C3 algorithm python
self a super
name collisions, implicit override
method lookup - delegation (dědičnost) nebo embedding (řeknu si u objektu metody)
viditelnost class members nebo access list (kdo to vidí)
dynamic dispatch (virtuální metody), vs. static dispatch
casting je impure
=== Advanced ===
Scala: cosi typově bohatšího, přeložitelného do Javy
- všechno je objekt, i funkce
- single/multiple inheritance
Python: take the head of the first list, i.e L[B1][0]; if this head is not in the tail of any of the other lists, then add it to the linearization of C and remove it from the lists in the merge, otherwise look at the head of the next list and take it, if it is a good head. Then repeat the operation until all the class are removed or it is impossible to find good heads. In this case, it is impossible to construct the merge, Python 2.3 will refuse to create the class C and will raise an exception.
- interfaces: seznam hlaviček metod, java umí implementovat víc interfaců
- mixin: fragment funkcionality třídy, z víc mixinů udělám třídu (násobnou dědičností). Samotný mixin se neinstanciuje. Jako interface, akorát implementovaný.
- traits: jako mixin, akorát je možné skládat traity různými způsoby, např. symetrický součet, rozdíl, aliasing.
- type parametrization:
- generics C#: generický typ jako first-class objekt. Nesmaže se informace o typu jako v Javě, rychlejší - nemusí se castovat.
- templates v C++: při kompilaci se vytvoří typy s daným parametrovým typem, zvlášť pro každé použití šablony.
bounding types jako constraints v c#
variance: list<string> je subtype list<object> .. v C# nefunguje.
typová konverze nebo pravidlo je covariant, když zachovává uspořádání <= na typech (typ <= subtyp)
je contravariant, když ho přehazuje
je invariant když ani jedno
To samé v parametrech metod
při subclassingu by se občas hodilo mít i subtyping, když přetěžuju metodu, tak bych měl mít jiný typ parametru - C++ private inheritance - zděděné je vidět jenom jako privátní
=== kompatibilní typy ===
http://publib.boulder.ibm.com/infocenter/comphelp/v7v91/index.jsp?topic=%2Fcom.ibm.vacpp7a.doc%2Flanguage%2Fref%2Fclrc03compatible_types.htm
kompatibilita
- používat dva typy beze změn, např při přiřazení, btw. signed int = int
- zaměnit jeden typ za druhý beze změny, do longu dáváš int,
- složit dva typy do composite type unsigned int - unsigned int = int
... řeší se ve strong-typed jazycích. Ve weak typed se udělají konverze, takže je to vždy kompatibilní (javascript, vb)
staticky typované jazyky (java, C): typ svázán s proměnnou, explicitní deklarace
dynamicky (python, php): typ svázán s hodnotou, implicitní deklarace
=== problémy s inheritance ===
fragile base class: když změním base class, musím překompilovat i potomky v C++. Java to řeší.
mezi class a subclass existuje implicitní interface
sémantická závislost - závislost subclass na implementaci base class
může se změnit množina možných stavů
se synchronizací jsou problémy
=== Prototypy, klony ===
jazyk bez tříd, klonování existujících objektů
návrh na úrovni objektů, vyhnutí se metatřídám
posílání zpráv
typ objektů = objekty od stejného prototypu
Omega, Self, JavaScript, Lua
odkaz na parent - prototyp
clone je shallow
Druhy objektů:
- prototype
- trait - chunk of attributes, typicky metody
- normal
sdílení metod a proměnných - jsou jen v parentovi
JavaScript nemá třídy, objekty se tvoří constructor function, každý objekt má pointer na prototyp
Dědičnost:
- získávání atributů od prototypu,
- implicitně - shallow copy
- explicitně - když si řeknu, tak deep na dané fieldy
- přidávání atributů
- embedding: kopírování z prototypu, každý pak má svojí kopii (deepcopy)
- delegation: sdílení s prototypem, možno víc prototypů
dědičnost je dynamická a dá se měnit za běhu
== c. Metaprogramování, reflexe, aspekty ==
* Popis a příklad rozhraní pro reflexi.
* Definice a příklad aspektu.
== Metatřídy ==
metaprogramování: vytvářet programy, které manipulují s jinými prgramy, nebo sami sebou. V podstatě tři možnosti: používat API runtimového prostředí, vytvářet stringy s kódem a ty pak pouštět, transformace programů
typ třídy je meta třída. V Javě je metaclass Class, ale nedá se použít žádná jiná pro vytváření tříd, v pythonu jo. ve smalltalku taky a je to úlet
=== Reflexe ===
program může číst a modifikovat svou vlastní strukturu a chování.
- compile time OpenC++, ovlivňuje chování kompilátoru: přidání loggování pomocí metaclass, registrování nového klíčového slova, přidání foreach apod.
- runtime Java, C#, Java třída Class má hafo metod na reflexi - změna memberů, zjišťování vlastností třídy, memberů
GetType, GetMethod, Invoke, getattr, setattr, .__class__
=== Aspekty: ===
Separation of concerns
Related functionality should be defined together
funkcionality bývají pohromadě. ale např. loggování dělají všechny části systému = cross-cutting concern, nemůže být snadno vyčleněno do modulu.
aspect: feature která je využívána mnoha jinými částmi programu, ale není to primární funkce programu.
AspectJ: implementace té srandy v Javě, rozšíření jazyka. Základní koncepty
- aspect: může přidávat metody už existujícím třídám.
- pointcut = set of join points: definice míst v programu, kde se něco zajímavého děje, např volání metody, instanciace objektu, ... call - caller side, execution - calee side
- advice: informace, jak se má kód vykonat kolem join points daného pointcutu, může být before, after, around, k zápisu se používají regulární výrazy.
Aspect Weaver: to co bere původní kód a vkládá do něj nesmysly produkované aspecty. Výsledkem je woven class nebo woven bytecode
aspect vidí to samé jako třída / privileged
dá se s tím měnit i hierarchie dědičnosti
Jako dekorátory v pythonu akorát se do dekorovaných metod nepíše ten dekorátor, ale definuje se to mimo.
== d. Softwarové komponenty ==
vyšší level abstrakce
A software component is a unit of composition with contractually specified interfaces and explicit context dependencies only. A software component can be deployed independently and is subject to composition by third parties.
možnost použít v různých kontextech (black box)
soa - nezávislý deploy
high level design
Component model: kolekce souvisejících abstrakcí a jejich významu, pravidla použití komponenty
koncepty:
- rozhraní: poskytuje, vyžaduje
- binding: vazby. volání funkcí, events, messages
- architektura komponenty
- container: co se má deployovat
- composition: flat (black box), hierarchical (grey, white box)
- development lifecycle: component lifecycle, application lifecycle (dávání komponent dohromady)
- design, development, deployment, execution, dynamic replacement
- koheze
- modularita
- zaměnitelnost
Component jako runtime koncept: má api, navíc např xml popis
Component framework: server, který hostí komponenty. threadpool, transakce, perzistence, ...
Data flow komponenty - modeluje se s nimi jak proudí data, možno nested. Dá se z toho generovat kód
Server, na kterém běží víc komponent: aplikační server
Akademické komponentové systémy:
- silný popis architektury, api, interakcí mezi komponenty. umožňují verifikaci kompozice a komunikace, spolehlivost, generování kódu. Výzkum co s komponentami.
SOFA 2
- component type = frame: definice funkcionality, rozhraní
- primitive components: neobsahují subkomponenty, něco dělají.
- composite components: mají subkomponenty, delegují
- java anotace - speciální význam metod
- subkomponenty možno specifikovat pomocí architektury nebo framu
- assembly: při deploymentu musí být v listech primitivní komponenty, architektury popsány pomocí assembly descriptoru
- je distribuovaná, komponenty deployovány po docích. Dock - kontejner na komponenty
- prostředí SOFAnode, kde to pak běží
- spojování komponent pomocí Connectorů - first class objekty. Connector definuje jak se bude komunikovat - volání metod, zprávy, ... nefunkční požadavky: bezpečnost, sledování výkonu, ... Jeden connector může spojovat víc komponent. při deploymentu se vytvoří automaticky
- funkcionalita používaná všude možně, např. db - dock s databází, subkomponenta sdílená více komponentami
- control logic - controllers - režie komponent - vázání na sebe, životní cyklus, ...
- tvorba component - factory
- mikrokomponenty pomocí aspektů
- má to nějaký behaviour protokol - co by se mělo volat když. Frame protocol a architekture protokol
- dá se checkovat vertikál compliance, jestli children dělají to co chce parent
- horizontál jestli nejsou konflikty mezi dětmi
- kontrola primitivních komponent - runtime checker, code analysis
- dvě úrovně vývoje:
- vývoj komponent - spojování už existujících, vytváření nových
- systému - integrace, vícenásobné používání
- lifecycle:
- development
- assembly
- deployment, execution
- kdy kde co má běžet,
- generování connectorů
- aplikace controllerů, běh
- repository hotových component
JavaBeans jsou komponenty
events: publisher-subscriber pattern. zdroj eventů, listener - zaregistruje se, po eventu se zavolá funkce.
property: jako get a set
introspekce - reflexe
Corba:
- funguje jen přes LAN
- industry standard by OMG
- flat
- platformová a jazyková nezávislost
- Object Request Broker:
- jádro corby
- stará se transparenci umístění objektů, komunikaci, aktivaci
- při zavolání najde implementaci objektu, aktivuje ho, pošle mu request
- všechny requesty jdou přes něj
- Interface Definition Language:
- typy objektů definovány interfacy.
- pouze definice interfacu, ne implementace, není programovací jazyk
- podle interfacu, který klient potřebuje se vybere implementace v libovolném jazyce, který má mapování
- Dynamic Invocation Interface:
- ne přes stuby (statický), bere se z databáze interfaců (Interface Repository)
- v klientovi můžu použít objekty aniž bych znal implementaci za compile timu
- Dynamic Skeleton Interface:
- To samý jako DII ale na serveru - implementuju interface, nevim kdo mě bude volat
COM, .NET (assembly), Spring: Don't call us we'll call you
Proč se to nepoužívá (jen flat model):
- změny za runtimu, v hierarchickém modelu se špatně pracuje s břibyvšími více instancemi jedné komponenty
- spojení s externími systémy a komponentami
výzvy
- spojování heterogenních komponent
- model check potřebuje main
co s rekonfigurací:
- zakázat
- zploštit architekturu za běhu - ztratí se korespondence k modelu
- omezit jen na dovolené předem definované změny
- povolit - eroze architektury
Dynamická architektura
- architektura musí být dynamická, např. když připojím tiskárnu. API na rekonfiguraci za runtimu
- špatně se dokumentuje a verifikuje
- dovolit jenom dané změny
SOA:
- Service registry, service provider, service consumer
- může poskytovat služby i navenek, narozdíl od komponentů, které jsou typicky local
- service je např přístup do databáze, tisk, ...
- špatně se zachycuje v architektuře, binding on demand
- component může využívat službu, nebo se může ukazovat jako služba (na to je special connector)
- jenom nabízená rozhraní
- deployment a implementace uvnitř se neřeší
- skládání pomocí zpráv bez fixně dané architektury
- rekonfigurace není problém, on demand
- SCA (service component architecture)
- service je běžící component.
- specifikace by IBM, Sun, ...
- volná vazba mezi komponentem a jeho implementací
- deklarativní popis infrastruktury v XML - Policies
- specifikace pro formát předávaných dat Service Data Objects
- hierarchická architektura (ne flat)
== e. Softwarové služby ==
http://www.soapatterns.org/
SOA:
- paradigma, sada principů pro vývoj a integraci systémů, systém - set služeb které mohou být využity různými systémy z různých business domén
- standardy, principy, metodologie návrhu, technologická infrastruktura
- standardized service contract: Co má služba dělat, (funkce, datový model, policy), bez vazby na implementaci (service abstraction)
- composition: služby mohou sestávat z mnoha jiných služeb
- jako api používá popis protokolů a funkcionality
- služba může automatizovat business process
- loose coupling
- orchestration: skládání více služeb do jedné, centrální řízení
- služby se mezi sebou nevolají, používají se protokoly
- metadata (popis služeb) - XML, WSDL. SOAP - popis protokolu
- nezávislost na programovacím jazyku
principy
- reuse, granularity, modularity, composability, componentization and interoperability.
- standards-compliance (both common and industry-specific).
- services identification and categorization, provisioning and delivery, and monitoring and tracking.
podle jiného zdroje:
- Standardizovaný service contract
- Loose coupling
- Abstraction
- Reusability
- Autonomy
- Statelessness
- Discoverability: metadata
- Composability
navíc:
- Optimization
- Relevance
- Encapsulation
- Location Transparency: nezávislost na skutečné poloze v síti
Role - web service:
- Service provider: do registru dá co dělá. brokers nabízejí služby
- Service consumer
- SOMF: notace na kreslení návrhu SOA systémů
- dobře se to testuje (jsou nezávislé malé kusy - služby), ale nikdo to nedělá
- security challenge
- SOA manifesto
Žemlička:
- inspirace službami ve skutečném světě
- radikální změna myšlení
- použití stávajících systémů
- deploy po menších kusech
- strukturované systémy: data z jednoho systému vstupem druhého, uchovávání dočasných dat, vyměňují si soubory
- proces: soubor aktivit, jejichž výsledkem je služba nebo produkt
- byznys procesy standardizované a nestandardizované
- agile bpm: změny v procesech dle aktuálních potřeb
- standardizované procesy lze zadrátovat do aplikace
- řídící systém: řídí procesy, musí být spolehlivý
- druhy
- dávkové systémy jsou prý taky SOA
- Měkké řídící systémy: spolupráce HW a SW; ?
- Aliance: dočasná spolupráce mezi jednotlivými částmi systému, vývojáři neví s čím vším to bude komunikovat. např. web services, silná standardizace
- Konfederace: těsnější vazba, vývojáři jednotlivých systémů se domlouvají.
- Enterprise Konfederace: silná centrální autorita, která může regulovat
- Unie: integrace stávajících systémů bez velkých změn v nich, e-Government, pro SME (small and medium enterprises asi)
- aplikační služby: vlastní výkonné složky, možno současné systémy s novým rozhraním:
- primární brána, jako primární brána může být použit upravený klient
- jemnozrnné na hrubozrnné rozhraní transformujeme předsazenou branou, možno xslt
- portál: vstupní bod pro uživatele
- datové úložiště: služba schraňující data
- hlava složené služby: služba která je předsazená před složenými službami
- služba - manažer procesů, spravuje vlastník procesu, mění dle potřeby.
- návrhové vzory:
- vybrat vhodný typ služby
- rozhraní orientované na problém, inspirované komunikací reálných lidí
- hrubozrnná rozhraní: nezabývat se drobnými detaily, ztratí se logika věci
- (2):
- předřazená brána: možno víc rozhraní k téže službě
- datové úložiště: oddělení dat podle kvality a oprávnění
- hlava kompozitní služby: složená služba se tváří jako jedna
- proces manažeři: řízení procesu službou
- antivzory:
- nevhodný typ soa
- jemnozrnná rozhraní
- žádné staré systémy
- stálé byznys procesy, vlastník by měl mít možnost měnit službu
- výhradně interaktivní: nedají se zakomponovat dávkové systémy. řešit datovými úložišti
- obecné antivzory
- velký třesk: nahrazení starého komplet novým systémem
- potížista: přiřadit na izolovaný úkol
== f. Moderní konstrukce programovacích jazyků ==
(anotace, iterátory, generics, lambda výrazy, integrované dotazy, integrované XML)
=== Anotace ===
http://en.wikipedia.org/wiki/Annotation#Software_programming,
http://publib.boulder.ibm.com/infocenter/iadthelp/v7r0/index.jsp?topic=/com.ibm.etools.wrd.annotation.doc/topics/coverview.html
poznámky v kódu, které obvykle neovlivňují přímo běh programu, ale slouží k dokumentaci apod. Narozdíl od komentářů přežijí kompilaci
ve frameworcích se používají anotace místo toho aby se to muselo dávat do externího xml filu. např mapování datových objektů na tabulky v databázi v ejb
redukce počtu konfiguráků a jiných artefaktů
Java annotations:
- metadata, zpracována kompilátorem, mohou být použita při runtimu, při překladu. Např. deprecated, override, supress warnings
- umožňuje anotovat anotace
- java kompilátor má annotation processors - může házet hlášky, vyřadit, ...
v C#: např. sdělit, že metoda má být thread-safe, dá se serializovat.
- uživatelsky definované anotace (atributy): může se něco nadeklarovat a pak to vytáhnout z objektu.
- anotace pro assembly
- používáno asp, linq, web services
Python - docstrings, přístupné potom v __doc__ jako nápověda k objektu, fajn v konzoli
=== Iterátory ===
http://en.wikipedia.org/wiki/Iterator
btw. design pattern
objekt který umožňuje procházet kontejner
dvě metody: získat prvek pod, posunout se na další. Vytvořit iterátor na první prvek, zjistit jestli už je konec
udělat něco s každým prvkem kontejneru, aniž bych věděl o interní struktuře kontejneru
generátor: iterátor bez kontejneru, pro komplikované výpočty, nemusím držet celé pole v paměti.
implicitní iterátory - foreach
srovnání s indexováním:
- někde rychlejší (listy, stromy)
- možnost vyměnit kontejner pod tím
- iterátor zvládá, když přidám prvek před aktuální
v C++ musíš dát foreachi funkci co má udělat na každém prvku
=== Generics ===
http://en.wikipedia.org/wiki/Generic_programming,
Program se píše s tím, že typy budou specifikovány později.
Ve staticky typovaných jazycích
Možno templatovat: třídy, funkce.
constrainty: co musí daný typ splňovat aby se dal použít
- generics C#, .NET: generický typ jako first-class objekt. reification, udělá se z něj proxy. Nesmaže se informace o typu jako v Javě, rychlejší - nemusí se castovat.
- Java: ve skutečnosti tam jsou všude objecty, compilator přidává casty
- templates v C++: při kompilaci se vytvoří typy s daným parametrovým typem, zvlášť pro každé použití šablony.
- specializace templatu: udělám special verzi pro nějaký typ, můžu i částečně, narozdíl od generic
Duck typing: metody přímo na aktuálním objektu určují co se s daným objektem dá dělat, ne jeho příslušnost k třídě, inheritance. V dynamických jazycích automaticky, v C# v 4 možno checkovat jestli je metoda přístupná až za runtimu
=== lambda výrazy ===
- pocházejí z lambda kalkulu.
zápis anonymních funkcí, zkrácená syntaxe.
v jazycích, kde jsou funkce first class objects, se takhle dají rovnou tvořit
lambda x: x + 1
má je tak i C#, dají se tak tvořit delegáty (pointery na funkce)
=== integrované dotazy ===
Object-relational mapping: technika konverze mezi nekompatibilními typovými systémy, virtuální objektová databáze
redukuje množství kódu, který se musí napsat pro přístup do databáze
Bývá pomalejší než když se přímo píše SQL - joiny, delete.
navázání na tabulky přímo v jazyku (django), anotacemi (EJB), nebo mapovacími fily (hibernate)
=== integrované XML ===
xml je široce používané a proto bývá jeho zpracování přímo v jazyce
knihovny na zpracování xml: python, .NET
parsování, udělá to nějakou fajnou strukturu, tam pak lze něco měnit, pak to zas někam zapsat.
dotazy nad xml fily: linq to XML, dom
serializace do xml, např. pro použití ve webových službách, python pickling
== g. Middleware architektury pro komunikaci: RPC, proxies, messaging, DSM ==
* Princip fungování RPC.
* Rozhraní pro messaging.
Middleware: software in the middle. mezi distribuovanou aplikaci a platformou pod ní
middleware is a distributed software layer, or platform, which abstracts over the complexity and heterogeneity of the underlying distributed environment with its multitude of network technologies, machine architectures, operating systems and programming languages.
Tiered architectures:
- client tiers: presentation logic, application logic (thick client - míň komunikace)
- server tiers: application logic (thin client), data
3-tiers navíc
- middleware: application logic
vstev může být plno - authentication, resources, ...
Service oriented:
- independent services
- independent integration
Unreliable unicasting: od odesílatele k příjemci, best effort, bez záruky
Routing: buď k příjemci rovnou nebo routeru
Exactly one delivery. Packet se může zničit, ztratit, nebo zduplikovat
Detekce - duplication, checksum, parity, cross parity (matice - řádky, sloupce), hamming code, cyclic redundancy check (polynomy mod 2)
potvrzení příjmu paketu, adaptivní timeout, ACK - correct, NAK damaged, missing, timeout před
unikátní číslo packetu - duplikace
Dlouhá zpráva - rozdělit na packety, potvrzovat po burstech. pevná nebo dynamická velikost
Idempotentní služby - nevadí vícenásobné provedení operace, exactly once, at least once, at most once
Když zhyne klient :
- extermizace: klient po restartu zruší službu
- nová epocha, stará se zahodí
- expirace: časové kvantum, po vypršení si server řekne o nové (když je komu)
TCP: spolehlivý, příjemce posílá kolikátý packet dostal.
flow control: posílat tak rychle aby to příjemce stíhal, congestion: aby to síť stíhala. domluva přes window
soft a hard real time: jitter: fluktuace v přenosové rychlosti
multicast: danému subsetu příjemců, broadcast: všem. Ve společných částech sítě to může jet jen jednou
spolehlivost - moc ACKů, radši posílat NAKy, multicastovat
topologie:
- strom: rozesílá všem pod sebou
- kruh: a token
řazení: podle odesílatele, kauzální, totální
http://en.wikipedia.org/wiki/Distributed_shared_memory
RMI: remote method invocation - jako RPC ale na objektech
- jenom mezi instancemi JVM, mimo javu corba
javaspaces:
- implementace sekvenčního konzistenčního modelu v Javě. (asi)
- tuplespace: repository tuplů jako asociativní sdílená paměť. Někdo tam zapisuje, někdo jiný si říká podmínky co chce a ono mu to vrací tuply
- object exchange
- komunikace sdílením stavu
- vysoký výkon, nízká latence, nepříliš spolehlivé
- Master-Worker pattern: jeden říká co se bude dělat, zapíše, ostatní si to přečtou, zapíšou výsledky
- hype, ale nikdo to moc nepoužívá
- objekt v repository: entry
=== Rozhraní pro messaging. ===
typicky:
- send(message, address - proces, nebo fronta)
- receive(buffer)
druhy (ve funkcích programovacího jazyka)
- blokující: čeká se, nemusíme se dočkat konce, záleží na ostatních. Když je plno/prázdno, zablokuje se. Jednodušší
- neblokující: místo čekání skončí, callback nebo polling
druhy 2: (komunikace, která používá víc funkcí)
- synchronní: skončený send == přijal to
- asynchronní: naopak
může být klidně neblokující synchronní, pro oznámení se použije polling (aktivně sleduju, jestli už to přišlo) nebo callback (zavolá mě, až)
strukturované (mpi) nebo nestruktorované (unix ipc)zprávy
=== RPC ===
server vykonává funkce jak mu řekne klient - zabalí funkci do zprávy, server jí rozbalí, vykoná, zabalí návratovou hodnotu, pošle, klient rozbalí. Balení a rozbalování zpráv dělá middleware. V interfacu middlewaru je method stub, ten dělá marshalling (balení do zprávy) a unmarshalling.
Stub se dělá v runtimu nebo compile timu.
Předávání parametrů - reference, aliasing (víc pointerů na jedna data)
Paralelní zpracování: thread per connection, thread per request, thread pool
Lifecycle
- kompilace - vytvoření stubu (klient) a skeletonu (server), rpc generátor
- spojení: server se exportuje registruje, klient se binduje se serverem
- vyvolání: marshalling, exception handling
SOAP, WSDL
problémy RPC:
- reprezentace dat: endiany, kódování
- globální proměnné (možno přes DSM)
- ukazatele, dynamické struktury
- pole - kopírování, restore
- variabilní parametry
- skupinová komunikace, problém s pořadím zpráv, synchronizace hodin - Cristianův algo (pasivní timeserver, synchronizace), Berkeley (aktivní time server - ptá se ostatních na čas, vrací rozdíl od průměru), distribuovaný (broadcastem). Jde o pořadí (kauzální závislosti) Lamport - hodiny se posílají zprávami, proces zvedne čítač před každou událostí, před přijetím se kouknout jestli je větší než poslední, nastavit si čítač.
- bezpečnost
Vzájemné vyloučení
- semaforem to nejde - není společná paměť
- centralizovaný algoritmus: centrální sekvencér, ostatní se ho ptají. ideově nevhodné
- Lamportův algoritmus: každý proces si drží frontu požadavků, když chce vstoupit do chráněné sekce, dá si požadavek do vlastní fronty, řekne si o fronty všem ostatním, když je první, vleze tam. Když vyleze, pošle všem zprávu, aby si ho vyhodily z front.
- Ricart-Agrawala: netřeba posílat release. odpovídám jen když nejsem v krické sekci a nechystám se do ní vstoupit
- volby, s volebním okrskem
všem vadí výpadek jednoho uzlu. Moudro: Obvykle nemá smysl řešit centralizovaný problém distribuovaným algoritmem - volba koordinátora
Vektorové hodiny - čítač pro každý proces. Některé vektory neporovnatelné. každý má svůj lokální vektor, vektory se posílají zprávami. když přijde zpráva s vektorem, beru max pro každý čítač
Algoritmů pro synchronizaci je ještě hafo, viz slajdy distribuované systémy.
=== DSM ===
koncept: množina uzlů sdílející adresový prostor, hafo různých implementací
- v osu - Extenze virtuální paměti, pro programátora transparentní. nebo v knihovně, pak s tím musí pracovat.
- možno hw cache coherent circuits
organizace:
- stránky stejné velikosti
- nebo po objektech, jak to vyjde
Výhody sdílené paměti: škálovatelné, messages netřeba, nebo schované, nemusí se replikovat data a posílat každému, extenze sekvenčního programování
Nevýhody: může být pomalejší, musí chránit proti dvoum přístupům v jeden čas, programátor nemůže ovlivnit co se posílá za zprávy
viz consistency
Distribuované stránkování
- jako virtuální paměť: když přistoupim k nenamapované, přerušení
- konzistence: mapované jsou jakoby read only, při zápisu buď invalidovat ostatní nebo aktualizovat
- nalezení stránky: broadcast, centralizovaný manager, distribuovaně, spodních n bitů
- správa kopií: broadcast, nebo stránka má vlastníka, ten udržuje informace kdo kde to má
- uvolňování: read only, vlastnictví stránky a přenos vlastnictví, lokální heuristika třeba LRU
problémy:
- falešné sdílení: nezávislá data na stejné stránce
- kauzálně konzistentní stránkování: graf závislostí stránek - kauzálních, vektorové hodiny, při výpadku přenášim, při zápisu zneplatnim. Velká prostorová režie, problém s konkurentními zápisy
Sdílené proměnné na úrovni jazyka
- typicky konzistenční model se synchronizačními proměnnými
- výkonné, eliminace falešného sdílení, ale podpora jen v jazyce, rekompilace
Distribuované objekty:
- corba, java. předek pro sdílené třídy, řeší se to samo
=== Proxy ===
btw design pattern
server/aplikace/objekt, který zpracovává požadavky klientů pomocí komunikace s jinými servery. Klient se připojí k proxy, proxy to zařídí.
Proxy může mít filtry. Použití:
- vše za tím je anonymní
- cacheování
- blokování nedovoleného příchozího i odchozího
- logování
gateway: proxy bez filtru
reverse proxy: okolnímu světu dává služby z privátní sítě. zabezpečení, load balancing, caching
open proxy: použití její ip adresy uživateli odjinud
=== Data Distribution Service ===
specifikace protokolu
publish subscribe pattern
zápis do published témat přes write queue - DataWriter
== h. Čitelnost kódu, metriky čitelnosti, refaktorizace, dokumentace ==
=== citelnost, metriky ===
http://d3s.mff.cuni.cz/teaching/programming_practices/lecture02.html
http://d3s.mff.cuni.cz/teaching/programming_practices/lecture03.html
princip lokality - věci, které souvisí mají být u sebe
inicializovat proměnné při deklaraci
deklarovat a inicializovat blízko prvnímu použití
oblast platnosti proměnné souvisí s jejím významem - platná jen tam kde ji potřebuju
metriky (minimalizovat):
- lokalita přístupu (variable span): průměrný počet řádků mezi přístupy k proměnné
- doba života (variable live time): počet řádků mezi prvním a posledním přístupem
- cyklomatická složitost
seskupovat příkazy, které spolu souvisí
Čím menší je stavový prostor programu menší, tím lépe.
Používat proměnné jen k jednomu účelu.
Používat konstanty - DRY, výjimky: 0 pro součty, 1 posuny o 1, 2 půlení, ...
Správně pojmenovávat proměnné Název proměnné by měl přesně a úplně popisovat, co proměnná reprezentuje.- kontext
nejdůležitější na začátek
pozitivní název pro bool
názvové konvence - podle jazyka, říkat stejným věcem stejně
Primitiva kódu:
- sekvence (příkazů)
- zjevné uspořádání
- selekce (if then else)
- if: kód nad rámec běžné činnosti
- if else: dominantní na začátek (rovnou za if)
- iterace
- známý počet - for, neznámý - while
- neměnit hodnotu řídící proměnné mimo
- foreach
opakující se věci do metod
složité výrazy do funkcí
logika do rozhodovacíh tabulek - data driven
funkce - čitelnost, skrývání detailů
- koheze, coupling
- 100-200 řádků
- parametry vstupní, výstupní, dobré dávat abstraktní typy
- nedávat do výrazu procedury
switch nahrazovat polymorfismem
používat immutable třídy
=== Formátování kódu ===
- zdůrazňovat logickou strukturu
- konzistence
- čitelnost
- robustnost vůči modifikaci
vizuální oddělovače
závorkovat
=== refaktoring ===
http://d3s.mff.cuni.cz/teaching/programming_practices/lecture12.html
změna v interní struktuře programu s cílem ji zesrozumitelnit a učinit lépe modifikovatelnou, aniž by se změnilo vnější chování
zajistit separation of concerns: zajistit, aby se fíčury, chování nepřekrývalo
musíme získat víc než vynaložíme. Je fajn mít testy, pro: bude se často měnit
když kód smrdí, je dobré ho refaktorizovat.
- refaktorizace dat
- refaktorizace příkazů
- refaktorizace funkcí
- refaktorizace implementace tříd
- refaktorizace rozhraní tříd
- globální refaktorizace
=== dokumentace ===
http://d3s.mff.cuni.cz/teaching/programming_practices/lecture11.html
- vnější: mimo kód
- požadavky, architektura, popis problému, tutoriál, rozhodnutí, konvence
- vnitřní
- komentáře k souborům, třídám, rozhraní, metodám
- v kódu: proč to dělám
- při/před psaním kódu
- nezakomentovávat - version system
== i. Testování a ladění kódu (technické principy nástrojů), preconditions, postconditions, invariants ==
osnova v http://d3s.mff.cuni.cz/~kalibera/teaching/sdmt
Defenzivní programování: předpokládám, že svět je zlý, minimalizuju škody.
Kontrolovat data z externích zdrojů, co nejdříve převést na vlastní reprezentaci
řetězcové parametry, sql injection
kontrakt metody:
- formální, precizní ověřitelný popis rozhraní
- datové typy
- preconditions: co musí být splněno před
- postconditions: co musí být splněno po
- invariants: co musí platit pořád
vztahuje se na:
- hodnoty vstupních proměnných
- výstup: hodnota, význam
- výjimky, za jakých podmínek
- side effecty
- případně, jak dlouho to bude trvat
Design by contract: psát nejdřív kontrakty
vynucovat dodržování, ověřovat preconditions
podporuje to eiffel, C# 4.0 v jazyce
Unit testing testuje modul jestli dodržuje kontrakty, integrační testování jestli to funguje pohromadě
bariéry:
- k vnějšku
- k vnitřnímu starému a neudržovanému
uvnitř důvěryhodného asserty - jen v debugu
=== Testování ===
Cíle:
- odhalit chyby
- dokumentace chování
- zlepšení kvality kódu
- změny v budoucnosti
Automaticky, spustitelné jedním příkazem, jednoznačný výsledek
- Unit testy: třídy, metody
- Testy komponent
- Integrační
- systémové: celý produkt ve finálním prostředí
- regresní testy
- výkonnostní
- zátěžové
- testy použitelnosti
- black box: možno před napsáním kódu
- white box: pokrytí kódu
testovat kontrakty, speciální případy.
verifikace chyb, opravy.
ladící výpisy, převést na test.
mock objekty
=== Test driven development ===
- napsat testy
- spustit testy - fail
- napsat minimální kód
- spustit testy
- refaktorovat kód
nutí přemýšlet nad návrhem, lepší rozhraní, ryhlá zpětná vazba X omezuje experimenty (zkusím víc variant)
=== Ladění ===
- odstranit příčinu chyby
- ideální se vyhnout
- snaha pochopit příčinu, odstranit
Postup:
- reprodukce chyby
- vytvoření testu, který padá na chybě
- nalezení příčiny - sběr dat, hypotéza o příčině, ověření hypotézy
- oprava chyby
- spuštění testu
- kontrola chyb podobného druhu
izolovat podezřelou část
=== Technická realizace krokování a breakpointů. ===
Debugger: na windows syscall DebugActiveProcess. nebo je na to api na virtuálním stroji
event loop, eventy dělá proces
debugger může číst a zapisovat do paměti procesu
api nad symbol files (ne součástí os), které dokáže přeložit adresu v paměti na jméno proměnné a její pozice ve zdrojácích
grafický front-end
http://www.alexonlinux.com/how-debugger-works
podpora v jádru os
ptrace syscall - request na debuggování
target proces může být potomkem debuggeru, a nebo ptrace_attach - attachnu se na target proces
os říká debuggeru o všech eventech v targetu, dělá se to přes signály
debugovaný musí zavolat ptrace trace me, pak dostane signal trap a debugger signal hold
breakpointy
- fungují na úrovni assembleru - instrukce INT3 - speciální interrupt handler, v handleru os pošle signál
- debugger vkládá instrukci INT3 do instrukcí targetu (je malá), přepíše nějakou instrukci, pamatuje si co přepsal. po tom co narazí na breakpoint, to zase přepíše zpátky a nastaví RIP registr procesoru, aby nepřeskočil tu zpátky zapsanou instrukci
- když dám breakpoint na řádek, logika ze symbol files zjistí kam má debugger dát INT3
krokování:
- nastavení instrukce INT3 na další řádek kódu
GDB je source level debugger
=== Vazba mezi zdrojovým kódem a binárním obrazem ===
na windows je pdb file, kerý mapuje zdrojáky na binár
symbol file, dá se předhodit gdb na vstupu
debug symbol
- informace jaké jazykové konstrukce se jak přeložily, včetně názvu souboru a čísla řádku
- vytváří kompilátor, linker
- můžou být přímo v bináru
- microsoft má server, pomocí kterého můžeš symboly rozluštit. Microsoft symbol server
- formáty:
- STABS: starší, původně pro pascal
- DWARF: speciální struktura pro každý symbol (název proměnné, typu, ...), vazba na to kde je to definované. Line number table. designován původně s ELFem, umí ho produkovat gcc