Austrálie - první zařizování

Do Austrálie jsem se chtěl dycky podívat. Teď se mi nabízí šance to uskutečnit. Na příští rok jsem nominován na výměnný pobyt do University of Queensbridge (Queensland). Povedlo se mi to tedy až na druhý pokus a jen díky tomu, že v OZS zvýšili body za průměr pro studenty FIS. Každopádně jsem nominován na rok 2013 na letní semestr.

Prvně, co jsem udělal, bylo kontaktovat další 2 lidi (např. Petra a Eva), kteří jedou se mnou. Pak jsem zašel s nimi na studijní oddělení (asi někdy v květnu) a tam nám paní sdělila nějaké info, ale hlavně to, že je času dost na zařizování. Po prostudování letáku, která nám paní posléze poslala emailem, jsem zjistil, že deadline pro přihlášky do 1.semestru (tj. letní semestr) je do 30.9. předchozího roku. Takže chill.

A dnes je konec sprna a holki spolucestovatelky mi napsaly, že příští týden pošleme všichni přihlášku do Austrálie. Přihláška se totiž musí posílat poštou spolu s 2 dalšími dokumenty, a to transkript známek v angličtině a potvzení o úrovni angličtiny (v angličtině). Úroveň angličtiny může být potvrzen platnými certifikáty nebo v případě VŠE stačí dopis ze školy o úrovni angličtiny.

V pondělí (dnes je pátek) to jdu všechno zařídit do školy. Prvně pro transkript na studijní oddělení a pak na katedru angličtiny pro potvrzení o úrovni angličtiny.

Začínám s Haskell - 2. kapitola

Datový typy v Haskell

- datové typy se odvozují
:t    příkaz pro vrácení datového typu
:t 'a'    vrací: 'a' :: Char

Typ fce - typ fce je tvořen z parametrů a návratové hodnoty
definice fce se 3 parametry typu int a výsledek int:


addThree :: Int -> Int -> Int -> Int
addThree x y z = x + y + z

Datové typy:
Int celá čísla
Integer taky celá čísla, akorát s větším rozsahem (např. na počítání faktoriál 9999)
Float , Double , Bool , Char 
Tuples (n-tice) - jejich datový typ závisí na velikosti a typ vnitřních prvků

Type Variable (typová proměnná)
- u fcí - typ může být jakýkoliv (jak Generics v Javě)

Typ fce fst (vrací 1.prvek ve 2-prvkovém tuple):
snd :: (a, b) -> b    znamená: jako parametr bere 2 prvky různého typu, a vrátí prvek stejného typu jako druhá proměnná

Type class (typová třída)
- definuje vlastnost, kterou všechny instance této třídy musí mít

(==) :: (Eq a) => a -> a -> Bool    znamená: funkce rovná se bere jako parametr 2 prvky stejného typové třídy Eq (tzn. tyto prvky musí být instancí této typové třídy) a vrací typ Bool

Typové třídy
Eq    == a /=, všechny předchozí zmíněné typy (kromě fcí ) jsou instancí Eq

Ord    porovnání (např. >=), všechny předchozí zmíněné typy (kromě fcí ) jsou instancí Eq

Show    převede do řetězce - fce show

Read    načte řetězec a vrátí typ - fce read: je potřeba ji buď použít v kontextu nebo specifikovat typ (type annotation)
read "[1,2,3,4]" ++ [3]      použitý v kontextu
read "5" :: Int                   type annotation

Enum    sekvenčně seřazené typy (použití v ranges). Má definované předchůdce (fce pred) a následníky (fce succ).

Bounded    mají spodní a horní hranici (např. Int nebo Bool nebo Tuples složené z Bounded prvků). Pro zjištění hranic jsou fce minBound a maxBound (např. minBound :: Int = -2147483648 

Num     instance se chovají jako čísla. Instance této třídy musí být zároveň instancí Show a Eq.

Integral     jen celá čísla (Int a Integer)

Floating     čísla s des. čárkou (Float a Double)

fromIntegral    změní celé číslo na obecné číslo
fromIntegral :: (Num b, Integral a) => a -> b
fromIntegral (length [1,2,3,4]) + 3.2   
znamená: length vrací celé číslo a sečtením s 3.2 by házelo chybu (4 + 3.2 jde, protože Haskell bere 4 jako typ floating), proto musíme přetypovat na obecné číslo pomocí fromIntegral

Začínám s Haskell - 1.kapitola

Někde jsem četl, že je dobrý každý rok se naučit 1 nový programovací jazyk. Proto jsem se rozhodl, že tento rok se naučím Haskell. Budu si sem zapisovat poznámky z knížky Learn You a Haskell for Great Good!

Kapitola 2. Starting out

/=      nerovná se
succ   vrátí následující prvek (succ 8 == 9; succ 'a' == 'b')
min     vrací ze 2 prvků menší prvek (min 'a' 'b' == 'a', min 8 10 == 8)
max    vrací ze 2 prvků větší prvek
div      celočíselné dělení dvou prvků (div 92 10 == 9; 92 'div' 10 == 9)

Vytvoření funkce

doubleUs x y = x*2 + y*2  
název fce - doubleUs
x y - parametry fce
= začátek těla fce, za tímto je samotné provedení fce

List
ukládá více prvků stejného typu
let lostNumbers = [4,8,15,16,23,42]        (let definuje jméno proměnné)

String je list znaků
++     spojování

['w','o'] ++ ['o','t'] == "woot"
[5]++[1,2,3,4,5] == [5,1,2,3,4,5]
"ha" == ['h', 'a']

:    přidání prvku na začátek listu

'A':" SMALL CAT" == "A SMALL CAT"
 5:[1,2,3,4,5] == [5,1,2,3,4,5]

!!    získání prvku podle indexu (od 0)
"Steve Buscemi" !! 6  == 'B'

Porovnávání listů - porovnání prvků postupně (porovnává se 1. prvek, pak 2.prvek atd.)
[2, 10] < [1,100,1000] == false

head    vrací head (první prvek) z listu
tail       vrací tail = list - head
last      vrací poslední element
init       vrací vše

Texas ranges
- rozsahy čísel nebo znaků pro zkrácený zápis
[1..20], [2,4..20] (sudá čísla do 20), ['A'..'z'] (písmena A až Z + nějaké znaky + malé a až z), ['a'..'Z'] (prádzné pole), [20,19..1] (čísla od 20 do 1)

cycle    bere parametr list a vytvoří opakováním nekonečný list
repeat    bere prvek a vytvoří nekonečný list opakováním toho 1 prvku
replicate    první parametr určí počet opakování druhého parametru

Generátor listu
- má 3 části: první je výstupní funkce; druhá je list, ze kterého se bude brát x; třetí jsou podmínky pro x.
- výstupem je nový list

boomBangs xs = [ if x < 10 then "BOOM!" else "BANG!" | x <- xs, odd x]   - první část (před pipou) je if podmínka, druhá část: pro x se bere z parametru pole xs pro funkce boomBangs, třetí část x musí být liché.

[ x | x <- [10..20], x /= 13, x /= 15, x /= 19] - tady jsou 3 podmínky ve 3.částí

[ x*y | x <- [2,5,10], y <- [8,10,11], x*y > 50] - tady se ve 2.části bere ze 2 listů zároveň

length' xs = sum [1 | _ <- xs]   -  v této fci nás nezajímá, co se bere z listu za hodnoty, vždy se vrací 1. Nakonec dostaneme list jedniček o stejné délce jako je parametr xs a ten sečteme - dostaneme délku xs.

Tuples (N-tice)
Typy tuplu jsou závislé na tom, kolik obsahují prvků a jakého typu jsou tyto prvky.
- tuply nemusejí být homogenní jako list - můžou obsahovat prvky různého typu

[(1,2),(8,11),(4,5)] - ok, vnější list musí obsahovat jen prvky stejného typu, což ty vnitřní tuply jsou
[(1,2),(8,11,5),(4,5)] - chyba, vnitřní tuply nejsou stejného typu - tuply obsahují prvky stejného typu, ale tuply nemají stejný počet prvků.

fst    bere parametr tuple o 2 prvcích a vrací 1. prvek
snd   bere parametr tuple o 2 prvcích a vrací 2. prvek 

zip    bere jako parametr 2 listy a kombinuje tyto 2 listy na list obsahující tuply o 2 prvcích

zip [5,3,2,6,2,7,2,5,4,6,6] ["im","a","turtle"]  výsledek: [(5,"im"),(3,"a"),(2,"turtle")]  

Příklad:

jaký pravoúhlý trojúhelník s celočíselnými stranami má všechny strany rovné nebo menší než 10 a jeho obvod je 24?

JS soubory podle prostředí v Grails Resources

Při vývoji web aplikace je užitečné mít jiné Javascript (JS) soubory než při produkci. Příkladem jsou minifikované vs plné verze JS nebo JS soubory ze CDN vs uložené JS soubory. Grails pro práci s JS má plugin Resources (i když teď už se stal součástí Grailsu). V dokumentaci jsem ale nevyčetl, jak rozlišit různé prostředí v definici resources. Ve skutečnosti je to docela jednoduché:

environments {
    development {    // pro vývoj beru uložený plugin
        modules = {   // closure
            jquery {
                resource url: '/js/libs/jquery.js', disposition: 'head'
            }
            application {   // duplikace
                resource url: 'js/application.js'
            } 
        }
    }
    production {   // pro produkci beru ze CDN
        modules = {
            jquery {
                resource url: 'https://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js',
                        disposition: 'head'
            }
            application {   // duplikace
                resource url: 'js/application.js'
            }  
        }
    }
}

To už je skoro super. Pak jsem ale zjistil, že takhle definované má v sobě duplicity, když jsou soubory stejné pro oba prosředí (viz část application), a snadněji se dělají chyby (musí se přidávat ten samý řádek tolikrát, kolik je prostředí). Je potřeba ještě další trik - kompozice 2 closures v 1 closure:

commonModules = {
    application {
        resource url: 'js/application.js'
    }
}
environments {
    development {    // pro vývoj beru uložený plugin
        modules = {   // closure
            jquery {
                resource url: '/js/libs/jquery.js', disposition: 'head'
            }
        }
    } << commonModules
    production {   // pro produkci beru ze CDN
        modules = {
            jquery {
                resource url: 'https://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js',
                        disposition: 'head'
            } 
        }
    }  << commonModules
}

That's that s**t!

Backbone.js callback u metody save()

Backbone.js ve své dokumentaci píše o možnosti volitelného callbacku při úspěšném a neúspěšném uložení modelu. A tak jsem taky zkoušel vytvoři callback:

transientModel.save({
    success:function (model, response) {
        log.info("Uloženo!");
    }
});

A na serveru vracím jen kód 200 jako OK. Samozřejmě že callback nefungoval. Na serveru se poslaly všechny atributy modelu a vše se uložilo v pořádku. I kód 200 se vrátil.

Po chvíli googlení jsem zjistil, že na StackOverflow se někdo už ptal na tuto otázku. Pokud chci volat callback, musí tento callback být až jako druhý parametr. První parametr jsou atributy, které chci uložit. Bohužel v dokumentaci to není popsáno dostatečně (spíš vůbec). Tak jsem upravil:

transientModel.save({}, // {} znamená, že chci poslat všechny atributy na server
{
    success:function (model, response) {
        log.info("Uloženo!");
    }
});

A už to funguje.