Praktická aplikácia využívajúca framework Rails
| 1. | Úvod do Ruby on Rails |
| 2. | Jazyk Ruby |
| 3. | Porovnanie Ruby a PHP |
| 4 | Framework Ruby on Rails |
| 5 | Praktická aplikácia využívajúca framework Rails |
Obsah
V predošlých kapitolách sme sa zaoberali sumarizovaním teoretických informácií, od základov jazyku Ruby, až po možnosti frameworku Rails. Cielene sme sa zamerali na časti súvisiace s prácou s databázami, aby sme mohli tieto informácie použiť pri nasledujúcej praktickej úlohe.
Rozvrh on Rails
Základnou úlohou bolo vytvoriť databázu školského rozvrhu v jazyku Ruby on Rails s prihliadaním na využitie zabudovaných modulov Rails (generátory, modely, kontroléry...). Aplikáciu sme nazvali „Rozvrh on Rails“. Databáza má vychádzať zo vzoru rozvrhnutia tabuliek a asociácií medzi nimi, ktoré sa momentálne používajú na Fakulte Mechatroniky TNUAD v jazyku PHP. Do výslednej databázy má byť možnosť pridávania záznamov a relácie databázových tabuliek majú umožniť vyhľadávanie záznamov rozvrhu obdobne, ako je to v jazyku PHP na stránke http://fm.tnuni.sk/rozvrh. Záverečnou časťou úlohy je vytvorenie benchmarku, ktorý bude sledovať dĺžku času vykonania určeneho množstva požiadaviek v Rails a PHP. Výsledky testovania budú následne zaznamenané a graficky spracované.
Návrh schémy
Východzím bodom práce bola predloha rozloženia databázových tabuliek a ich relácií, ktorá bola narhnutá pre naprogramovanie v jazyku PHP. Táto výsledná schéma sa nachádza v prílohe A – Obrázok 1. V nasledujúcej tabuľke sú vypísané všetky tabuľky schémy vrátane ich atribútov. Pri atribútoch, ktoré sú primárnym alebo cudzím kľúčom, sa nachádza aj príslušné značenie:
| Tabuľka | Atribúty | Poznámka |
| rozvrh_zamerania | id (int) zameranie (varchar) |
PK* |
| rozvrh_studijne_kombinacie | id (int) rocnik (int) stupen (int) id_zameranie (int) |
PK FK** (rozvrh_zamerania) |
| rozvrh_typ_predmetu | id (int) typ (varchar) farba (varchar) |
PK |
| rozvrh_kruzky | id (int) kruzok (varchar) id_sudijne_kombinacie (int) |
PK FK (rozvrh_studijne_kombinacie) |
| rozvrh_predmety | id (int) predmet (varchar) semester (enum(’Z’,’L’)) id_studijna_kombinacia (int) pocet_hodin (int) |
PK FK (rozvrh_studijne_kombinacie) |
| rozvrh_predmet_typ | id (int) id_predmet (int) id_predmet_typ (int) id_kruzok (int) |
PK FK (rozvrh_predmety) FK (rozvrh_typ_predmetu) FK (rozvrh_kruzky) |
| rozvrh_ucebne | id (int) ucebna (varchar) kapacita (integer) poznamka (varchar) |
PK |
| eval_users | id_user (int) login (varchar) meno (varchar) priezvisko (varchar) *** |
PK |
| rozvrh_ucitel_predmet | id (int) id_ucitel (int) id_predmet (int) |
PK FK (eval_users) FK (rozvrh_predmety) |
| rozvrh_rozvrh | id (int) id_vyucujuci (int) id_ucebna (int) id_predmet (int) **** |
PK FK (eval_users) FK (rozvrh_ucebne) FK (rozvrh_predmety) |
Vysvetlivky:
- - PK – primary key – primárny kľúč
- - FK – foreign key – cudzí kľúč
- - ostatné atribúty tabuľky eval_users a to: heslo, tituly, fakulta, katedra, funkcia, prava, email. Atribúty sme v tabuľke vynechali v dôsledku zanedbateľnosti ich relačnej funkcie.
- - ostatné atribúty tabuľky rozvrh_rozvrh a to: zabezpecuje, den, typ_studia, poradie_tyzdna, poznamka, cas. Atribúty sme v tabuľke vynechali v dôsledku zanedbateľnosti ich relačnej funkcie
Z uvedenej schémy sme následne vytvorili novú, pričom sme pri jej tvorbe prihliadali na špecifiká frameworku Rails. Výsledkom je schéma nachádzajúca sa v prílohe A – Obrázok 2. Z obrázku je viditeľné, že v databáze sme vykonali niekoľko podstatnejších zmien, konkétne:
- Pomenovanie názvov tabuliek: Zmenili sme názvy tabuliek aby boli čo najjednoduchšie, písané v anglickom jazyku množného čísla – v súlade s konvenciami Rails.
- Názvy cudzích kľúčov: Názvy cudzích kľúčov sme premenovali rovnako podľa konvencií Rails - charakteristickú predponu id_ sme nahradili príponou _id, ktorú sme pripojili za singulárny názov cieľovej tabuľky.
- Zmeny v tabuľke rozvrh_ucitel_predmet: Tabuľka bola premenovaná na subjects_users a charakterizovaná ako prepojovacia tabuľka. Z tohto dôvodu nová tabuľka neobsahuje primárny kľúč id, ktorý nemá v tomto prípade uplatnenie.
- Vymazanie tabuľky rozvrh_predmet_typ: Pri skúmaní všetkých relácií sme dospeli k rozhodnutiu odstrániť tabuľku rozvrh_predmet_typ, ktorej atribúty sa dajú nahradiť inými, pravdepodobne vhodnejšími úpravami v iných tabuľkách. Týmto sa súčasne skrátilo prepojenie medzi tabuľkami subjects a rozvrh_events.
- Zmeny v tabuľke rozvrh_predmety: V tabuľke premenovanej na subjects sme pridali nový atribút type_id, ktorý nahrádza pôvodný atribút id_predmet_typ odstránenej tabuľky rozvrh_predmet_typ. Relácia medzi týmto kľúčom a tabuľkou types ostáva zachovaná. Atribút length bol presunutý do tabuľky types.
- Vytvorenie prepojenia rozvrh_events – subclasses. Do tabuľky rozvrh_events bol pridaný nový cudzí kľúč subclass_id.
- Vymazenie tabuľky rozvrh_zamerania: Keďže táto tabuľka v praxi osahuje iba 2-3 záznamy s jediným atribútom, zlúčili sme ju s tabuľkou study_combinations
V nasledujúcej tabuľke sú uvedené všetky kľúče tabuliek a Rails asociácií, ktoré sa na ne viažu:
| Tabuľka | Kľúč | Asociácia |
| types | id | has_many :subjects |
| study_combinations | id | has_many :subjects has_many :subclasses |
| subclasses | id study_combination_id |
has_many :rozvrh_events belongs_to :study_combination |
| subjects | id study_combination_id type_id |
has_and_belongs_to_many :users has_many :rozvrh_events belongs_to :study_combination belongs_to :type |
| subjects_users | user_id subject_id |
belongs_to :user belongs_to :subject |
| classrooms | id | has_many :rozvrh_events |
| users | id | has_and_belongs_to_many :subjects has_many :events |
| rozvrh_events | id user_id classroom_id subject_id subclasses_id |
belongs_to :user belongs_to :classroom belongs_to :subject belongs_to :subclass |
Vytvorenie databázy Rozvrh on Rails
Po tom, čo sme presne definovali tabuľky a vzťahy medzi nimi sme mohli vytvoriť samotnú aplikáciu. V našom prípade sme sa rozhodli programovať na platforme Windows Vista Home Premium a ako vývojové prostredie sme zvolili open source projekt NetBeans (domovská stránka: http://www.netbeans.org). Všetky nasledujúce príkazy a obrázky budú z tohto vývojového prostredia. V prostredí NetBeans sme najprv vytvorili nový Rails projekt s názvom rozvrh_on_rails pomocou sprievodcu, kde sme okrem iného definovali názov databázy a prístupové práva k nej. Tieto potom ActiveRecord použije pri prístupe do databázy. V prípade potreby zmeny týchto údajov ich nájdeme v súbore configuration/database.yml. V ďalšom kroku sme postupne vytvorili jednotlivé tabuľky. Na ich vytvorenie sme použili už spomínanú funkciu scaffold, ktorá uľahčí vytváranie pohľadov a akcií, ktoré potrebujeme pre správu dát v tabuľkách. Táto funkcia teda zabezpečí vytvorenie všetkých akcií CRUD. Ako príklad uvedieme vytvorenie tabuľky subjects. Na vytvorenie scaffoldu je potrebné sputiť generátor, ako vidno na obrázku 5.1.:
Z voľby generátora vyberieme scaffold a zadáme potrebné údaje v tvare NazovModelu atribut1:typ1 atribut2:typ2 .... – kde atribúty sú stĺpce novovytvorenej tabuľky so zadaním ich typu (oddelené len medzerou). Názov modelu zadávame v jednotnom čísle, Rails automaticky vytvorí migráciu tabuľky aj kontrolér v množnom čísle. V prípade tabuľky subjects je meno modelu subject a atribúty name:string semester:string study_combination_id:integer length:integer type_id:integer. Po spustení generátora nám tento poskytne nasledovný výstup:
exists app/models/
exists app/controllers/
exists app/helpers/
create app/views/objects
exists app/views/layouts/
exists test/functional/
exists test/unit/
exists test/unit/helpers/
exists public/stylesheets/
create app/views/subjects/index.html.erb
create app/views/subjects/show.html.erb
create app/views/subjects/new.html.erb
create app/views/subjects/edit.html.erb
create app/views/layouts/subjects.html.erb
identical public/stylesheets/scaffold.css
create app/controllers/subjects_controller.rb
create test/functional/subjects_controller_test.rb
create app/helpers/subjects_helper.rb create
test/unit/helpers/subjects_helper_test.rb
route map.resources :subjects
dependency model
exists app/models/
exists test/unit/
exists test/fixtures/
create app/models/subject.rb
create test/unit/subject_test.rb
create test/fixtures/subjects.yml
exists db/migrate
create db/migrate/20090605132005_create_subjects.rb
Generátor vytvoril množstvo súborov, vrátane pohľadov (views) zobrazujúcich CRUD (sem patrí index, show, new, edit a základná šablóna layout/subjects.html.erb), kontroléra s akciami CRUD subject_controller.rb a modelu subject.rb. Tiež vytvoril migráciu 20090605132005_create_subjects.rb, ktorá vyzerá nasledovne:
class CreateSubjects < ActiveRecord::Migration
def self.up
create_table :subjects do |t|
t.string :name
t.string :semester
t.integer :study_combination_id
t.integer :length
t.integer :type_id
t.timestamps
end
end
def self.down
drop_table :subjects
end
end
Keby sme teraz vykonali migráciu, vytvorí sa nám tabuľka subjects so zvolenými parametrami. Migráciu ale môžeme aj ľubovoľne meniť, treba si ale uvedomiť, že vytvorený model a kontrolér sú už prednastavené na určité parametre, ktoré potom nemusia korelovať. My sme do metódy up tejto migrácie pridali aj vytvorenie prepojovacej tabuľky subjects_users. Vložený kód:
create_table :subjects_users, :id => false do |t|
t.column :subject_id, :integer
t.column :user_id, :integer
end
Pri tvorbe tabuliek Rails vždy automaticky vytvorí atribút id, preto sme tomu v tomto prípade zabránili príkazom :id => false. Následne spustíme migráciu:
Úspešnú migráciu nám následne ohlási výpis. Týmto sme vytvorili základnú štruktúru tabuľky subjects, ktorú si môžeme pozrieť v prehliadači na adrese http://localhost:3000/subjects. Obdobne postupujeme aj pri tvorbe ďalších tabuliek. Tabuľky nemusíme tvoriť len migráciami, môžeme ich vytvoriť akýmkoľvek iným spôsobom nezávisle od modelu a kontroléru. Keď sme vytvorili všetky tabuľky, začali sme vytvárať asociácie. Asociácie sa vždy nachádzajú v modeloch, ktoré sú po vztvorení prázdne:
class Subject < ActiveRecord::Base
end
Pri tvorení asociácií sme sa riadili schémou, ktorú sme vopred vytvorili. Výsledný model Subject potom vyzerá nasledovne:
class Subject < ActiveRecord::Base
has_and_belongs_to_many :users
has_and_belongs_to_many :subclasses
has_many :rozvrh_events
belongs_to :type
belongs_to :study_combination
end
Až po vytvorení všetkých asociácií pristupujeme k napĺňaniu tabuliek skúšobnými dátami. Pri tom sme sledovali prípadné chyby, ktoré sme priebežne dolaďovali. V procese testovania môžeme vidieť napríklad pohľad, zobrazený na obrázku 5.3.:
V prehliadači na adrese http://localhost:3000/users sa nám zobrazí aktuálny obsah tabuľky users, ktorý bol vygenerovaný ako views/users/index.html.erb. Z obrázku môžeme vidieť, že Rails vytvoril iba základnú funkčnú konštrukciu, ktorú následne môžeme nakonfigurovať podľa individuálnych požiadaviek (pohľad v obrázku už prešiel pár úpravami). Zdrojový kód všetkých vytvorených modelov a migrácií sa nachádza v prílohe B a celá Rails aplikácia je v prílohe na CD. Po tom, čo sme vytvorili funkčnú databázu, vypracovali sme aplikáciu na zobrazenie rozvrhu.
Zobrazenie rozvrhu
Rails poskytuje značnú flexiblitu v štýle písania kódu. Aj preto existuje veľké množstvov ariácií, ako napísať aplikáciu zobrazenia rozvrhu, čo závisí aj od znalostí príkazov ktoré Rails ponúka. Pri tvorbe zobrazenia rozvrhu sme začali vytvorením kontroléru, ktorý ju určený na základný skript a pohľadu, ktorý nasledne vygeneruje potrebné údaje. Model sme v tomto prípade netvorili, pretože kontrolér bude pracovať s už vytvorenými modelmi tabuliek. Kontrolér sme pomenovali RozvrhFiltersController a nachádza sa v priečinku controllers/rozvrh_filter_controller.rb, pohľad má základný názov index a je v priečinku views/rozvrh_filters/index.html.erb. Phľad sme vytvorili tak, aby obsahoval základný formulár, ktorý odoslaním zašle zvolené podmienky. Tieto sú v Rails zasielané v podobe hash-u s názvom params. Napríklad k premennej subject potom v kontroléri pristupujeme ako params[:subjects]. Výsledný základný pohľad sa nachádza v prílohe B – index.html.erb. Pokúšali sme sa vytvoriť zobrazenie rozvrhu viacerými spôsobmi, ale nie všetky vyhovovali podmienkam. Jedným z prvotných riešení bolo použiť na vyhľadávanie dynamické vyhľadávače, spomínané v predchádzajúcej kapitole. Kód kontroléru vyzeral nasledovne:
class RozvrhFiltersController < ApplicationController
def index
if request.get?
params[:subject]=='-' ? @subjects=“%“: @subjects=params[:subject]
params[:user]=='-' ? @users=“%“ @users=params[:user]
params[:subclass]=='-' ? @subclass=“%“ : @subclass=params[:subclass]
params[:branch]=='-' ? @branch=“%“ : @branch=params[:branch]
params[:year]=='-' ? @year=“%“ : @year=params[:year]
@study_combinations = StudyCombination.find_all_by_year_and_branch(@year,@branch)
@subjects = Subject.find_all_by_name_and_study_combination_id(@subject, @study_combinations)
@rozvrh_events = RozvrhEvent.find_all_by_subject_id(@subjects)
end
end
end
V tomto prípade sme pracovali len s 5 údajmi (subject,user,subclass,branch,year) a už bola aplikćia relatívne komplikovaná. Najprv sme zisťovali, či bola zadaná určitá hodnota, ktorá sa potom pridala do samostatnej premennej a následne sa v tabuľkách vyhľadávali vyhovujúce záznamy. Aj keď aplikácia prejavovala známky funkčnosti, bola veľmi neefektívna. Poslednou funkčnou a vhodnejšou verziou je vyhľadávanie cez jednu tabuľku pomocou :conditions , kde môžeme použiť syntax SQL alebo Rails. Vyhľadávanie v ostatných tabuľkách je zabezpečené pomocou prepojení, ktoré určíme pred podmienkami. Výsledný kontrolér vyzerá nasledovne:
class RozvrhFiltersController < ApplicationController
def index
if request.get?
@rozvrh_events = RozvrhEvent.find(:all,
:joins =>[{:subject =>[:type,:study_combination]},:user,:classroom],
:conditions => ['subjects.name like ?
and users.priezvisko like ?
and study_combinations.year like ?
and study_combinations.branch like ?
and study_combinations.degree like ?
and subclass_id like ?
and classrooms.meno like ?
and day like ?',
params[:subject], params[:user], params[:year],
params[:branch], params[:degree], params[:subclass_id],
params[:classroom], params[:day] ] )
end
end
end
V príklade sme k vzdialeným tabuľkám mohli pristupovať jednoduchšie vďaka prepojeniu :joins. Celá aplikácia vyzerá po spracovaní v ActiveRecord preložená do SQL nasledovne (v prípade, že odošleme formulár bez parametrov):
SELECT `rozvrh_events`.* FROM `rozvrh_events` INNER JOIN `subjects` ON `subjects`.id = `rozvrh_events`.subject_id
INNER JOIN `types` ON `types`.id = `subjects`.type_id INNER JOIN `study_combinations` ON `study_combinations`.id = `subjects`.study_combination_id
INNER JOIN `users` ON `users`.id = `rozvrh_events`.user_id
INNER JOIN `classrooms` ON `classrooms`.id = `rozvrh_events`.classroom_id
WHERE (subjects.name like '%'
and users.priezvisko like '%'
and study_combinations.year like '%'
and study_combinations.branch like '%'
and study_combinations.degree like '%'
and subclass_id like '%'
and classrooms.meno like '%'
and day like '%')
Vytvorené aplikácia je funkčná, ale má ešte oblasti, na ktoré by sa bolo treba ešte bližšie zamerať pri dolaďovaní, ako je následná grafická úprava a pod. Takisto by bolo treba opäť prehodnotiť schému databázových tabuliek a ich relácií, či nenájdeme vhodnejšiu alternatívu. V tabuľkách sme z dôvodu názornej ukážky použili atribúty v slovenskom aj anglickom jazyku, anglické názvy sú vhodné hlavne pri pomenovávaní kľúčov. Pri tvorbe tabuliek tiež treba skontrolovať, či náš názov atribútu už Rails nepoužíva ako zabudovanú metódu. Inak by mohlo dôjsť ku kolízii.
Benchmark
Posledným bodom práce bolo vytvoriť porovnávací benchmark, ktorý skúma spôsob spracovania požiadavky v Rails a v PHP. V našom prípade sme zasielali určitú požiadavku v Rails a PHP, ktorej výstup je v oboch prípadoch totožný, pričom benchmark má za úlohu porovnať časy vykonania tejto požiadavky. Výsledky sa graficky spracujú. Zvolili sme požiadavku, ktorá má za úlohu vybrať všetky predmety určeného prednášajúceho cez pepojovaciu tabuľku rozvrh_ucitel_predmet/subjects_users. Kód v PHP vyzerá nasledovne:
<?php
function microtime_float()
{ list($usec, $sec) = explode(" ", microtime());
return ((float)$usec + (float)$sec); }
$db=mysql_connect("localhost","user","password") or die("e1");
mysql_select_db("rozvrh") or die("e2");
$t1=microtime_float();
for($i=0;$i<$hodnota;$i++)
{ $sql="select * from eval_users,rozvrh_ucitel_predmet, rozvrh_predmety where id_user=id_ucitel and id_predmet=rozvrh_predmety.id and id_user=1";
$r=mysql_query($sql); }
$t2=microtime_float();
echo $t2-$t1;
mysql_close();
?>
Za premennú $hodnota sme postupne dosádzali hodnoty počtu cyklov. Výpisom je dĺžka času potrebná na vykonanie požiadavky. V Rails sme vytvorili kontrolér benchmark_controller.rb a pohľad akcie index index.html.erb. Ich kód vyzerá nasledovne:
controllers/benchmark_controller.rb
class BenchmarkController < ApplicationController
def index
t1=Time.now
hodnota.times do
@user = User.find(1).subjects
end
t2=Time.now
@t=t2-t1
end
end
views/benchmark/index.html.erb
<h1>Benchmark</h1>
<%= @t %> <br>
Predpokladom bolo, že čas na spracovanie požiadavky bude v Rails podstatne dlhší ako v jazyku PHP. Naše testovanie síce nemôže byť úplne presné, pretože sme zanedbali vplyv vonkajších faktorov a testovanie jazykov prebehlo za podobných, avšak nie identických podmienok, ale potrvdili sme počiatočnú domnienku. Z výslednej tabuľky 5.3 a grafického zobrazenia (obrázok 5.4), je viditeľné, že jazyk PHP vykonáva požiadavku asi 10-násobne kratšie, ako Rails. Toto zistenie nie je prekvapujúce, príčinou je, že sme porovnávali PHP, teda čistý jazyk a Ruby on Rails -framework, ktorého úlohou je skrátiť čas písania kódu na úkor času samotného spracovania požiadavky. V tomto prípade by bolo preto vhodné porovnávať Ruby a PHP alebo Rails a niektorý z PHP frameworkov, pretože kódy frameworkov sú pomalšie ako kódy čistých jazykov.
Benchmark
| počet cyklov | Rails – čas[s] | priemer[s] | |||||||||
| 1000 | 0,597 | 0,463 | 0,442 | 0,522 | 0,466 | 0,508 | 0,469 | 0,459 | 0,438 | 0,526 | 0,489 |
| 2000 | 0,932 | 0,960 | 0,975 | 0,910 | 0,957 | 0,917 | 0,957 | 0,965 | 0,978 | 0,899 | 0,945 |
| 5000 | 2,390 | 2,383 | 2,322 | 2,382 | 2,383 | 2,373 | 2,405 | 2,389 | 2,322 | 2,379 | 2,373 |
| 10000 | 4,777 | 4,707 | 4,755 | 4,794 | 4,708 | 4,759 | 4,722 | 4,712 | 4,758 | 4,769 | 4,746 |
| 15000 | 7,085 | 7,164 | 7,092 | 7,101 | 7,161 | 7,069 | 7,160 | 7,099 | 7,102 | 7,069 | 7,110 |
| 20000 | 9,501 | 9,461 | 9,465 | 9,492 | 9,479 | 9,458 | 9,495 | 9,537 | 9,479 | 9,468 | 9,484 |
| počet cyklov | PHP – čas[s] | priemer[s] | |||||||||
| 1000 | 0,053 | 0,056 | 0,060 | 0,060 | 0,062 | 0,053 | 0,060 | 0,054 | 0,053 | 0,065 | 0,058 |
| 2000 | 0,110 | 0,109 | 0,115 | 0,120 | 0,120 | 0,122 | 0,106 | 0,108 | 0,108 | 0,106 | 0,112 |
| 5000 | 0,265 | 0,270 | 0,287 | 0,304 | 0,298 | 0,286 | 0,279 | 0,280 | 0,285 | 0,271 | 0,283 |
| 10000 | 0,593 | 0,547 | 0,602 | 0,602 | 0,604 | 0,576 | 0,578 | 0,550 | 0,614 | 0,531 | 0,580 |
| 15000 | 0,894 | 0,855 | 0,827 | 0,929 | 0,898 | 0,876 | 0,903 | 0,807 | 0,870 | 0,846 | 0,870 |
| 20000 | 1,195 | 1,154 | 1,143 | 1,205 | 1,205 | 1,157 | 1,162 | 1,129 | 1,216 | 1,188 | 1,175 |
Parametre
Na testovanie Rails sme použili server free.railshosting.cz , na ktorom je možnosť free Rails hostingu, ktorý obsahuje:
- virtuálny server s podporou mod_rails (Phusion Passenger – modul do Apache)
- databázu MySQL
- SSH účet, SSH kľúč
Aplikácia používala adresu http://kszv.free.railshosting.cz/benchmark. Aplikácia PHP bola testovaná na adrese http://www.kszv.sk/ruby.php.
Z doposiaľ vykonaných testovaní, ktoré porovnávajú Ruby a PHP vyplýva, že Ruby pracuje rýchlejšie ako PHP. Konkrétnym príkladom je testovanie uverejnené na internetovej stránke http://npzrk8rz.wordpress.com/2008/01/17/ruby-vs-php-performance. Toto testovanie bolo zamerané výlučne na rýchlosť samotného kódu, preto sa na testovanie použil triediaci algoritmus v Ruby a PHP. Triediaci algoritmus v oboch jazykoch je k nahliadnutiu v prílohe na CD. Tento mal za úlohu utrediť pole 100 náhodne vygenerovaných čísiel v cykle tritisíckrát za sebou. Výsledný graf sa nachádza na obrázku 5.6.
Z testovania vyplynulo, že Ruby 1.8.6 je pri triedení len o málo rýchlejší ako PHP, ale Ruby 1.9.1 je schopný vykonať utriedenia už za menej ako polovicu času, ktorý potrebuje PHP. V grafe sú na porovnanie zobrazené aj časy zotriedenia, ktoré potrebovali iné populárne jazyky. Toto testovanie vyvracia mylné domnienky veľkej časti programátorov o tom, že jazyk Ruby je pomalý. Ruby pracuje rýchlo, takže príčinou spomalenia vykonania požiadavky je samotný framework. To ale neznamená že by bol Rails prĺiš pomalý. Dokazuje to aj testovanie viacerých PHP frameworkov a Rails uverejnené na stránke http://www.root.cz/clanky/velky-test-php-frameworku-zend-nette-php-a-ror. Testovanie bolo zamerané hlavne na frameworky PHP, bol ale testovaný aj framework Rails. Pracovalo sa s tabuľkou členov a užívateľov, pričom členovi môže byť priradených viac užívateľov. Predmetom testovania boli 4 požiadavky: zobrazenie členov, zobrazenie užívateľov, editácia užívateľa a úprava dát. Vo výslednom grafe – obrázok 5.6 sú porovnané výsledky všetkých frameworkov, ktoré boli testované. Z výsledkov môžeme povedať, že Rails patrí v rýchlosti medzi priemerné. Naproti tomu Zend, ktorý je jedným z populárnych frameworkov pre PHP, patrí medzi najpomalšie z testovaných, pokiaľ nie je použitý cAccelerator. Aj z tohoto grafu je vidieť, že čistý jazyk PHP pracuje najrýchlejšie.
Výsledky jasne ukazujú, že aplikácia napísaná v určitom jazyku pracuje rýchlejšie, ako aplikácia frameworku. Napriek tomu si treba uvedomiť, že rýchlosť aplikácie je podstatná, avšak nie jediná podmienka dobrého kódu, ktorý má byť stručný, prehľadný a efektívny, aby samotné programovanie zabralo najkratší čas.
Záver
Práca úvodom popisuje základné teoretické informácie o jazyku Ruby ako o objektovo orientovanom jazyku. Následne sme sa snažili poukázať na konkrétne rozdiely medzi syntaxou jazyka Ruby a jazyka PHP, ktoré je potrebné brať do úvahy, pokiaľ tvoríme aplikácie v oboch týchto jazykoch. Ďalšia časť je zameraná na popis frameworku Ruby on Rails, rozoberá podrobnejšie funkcie modelov, pohľadov a kontrolérov. Hlavným modulom, ktorý sme popisovali, bol najmä na modul Action View, ktorý zabezpečuje komunikáciu s databázou. Tiež sme bližšie popísali funkcie CRUD. Opísali sme relácie medzi tabuľkami, nazývané v Rails asociácie, a uvedli postupy pri ich tvorbe. Teoretická časť bola pomerne rozsiahla z toho dôvodu, že o jazyku Ruby a framworku Ruby on Rails je v Slovenskom jazyku vydané minimálne množstvo publikácií, ktoré by poskytli ucelené základné informácie. V praktickej časti sme najprv vytvorili základnú schému databázových tabuliek, podľa ktorej sme potom vytvorili konkrétnu aplikáciu Rozvrh on Rails. Táto aplikácia má za úlohu zobraziť výpisy z databázy podľa zvolených podmienok. Výsledná aplikácia sa ukázala byť plne funkčná, aj keď sa v nej nachádzajú niektoré reálne nedostatky, ako napríklad validácia vstupných údajov či admnistrátorské rozhranie, avšak tým by sa značne prekročil rozsah práce. Záverom sme vytvorili porovnavací test – benchmark, na určenie rýchlosti vykonania požiadavky v PHP a Rails. Výsledkom testu bolo, že PHP vie spracovať požiadavku omnoho rýchlejšie ako Rails, príčinou ale bolo, že sme porovnávali jazyk a framework. Preto sme na záver uviedli aj iné porovnávacie testy, z ktorých vyplynulo, že jazyk Ruby je minimálne rovnako rýchly ako jazyk PHP, a framework Rails patrí medzi priemerne rýchle frameworky v porovnaní s frameworkami PHP. Preto by programátor pri výbere jazyka alebo frameworku na tvorbu programov mal prihliadať skôr na to, ako efektívne dokáže vytvoriť aplikáciu, ktorú potrebuje.
Použitá literatúra
- Holzner, S.: Začínáme programovat v Ruby on Rails, Brno, Computer Press, a.s., 2007, ISBN 978-80-251-1630-2
- Ruby, S., Thomas, D., Heinemeier Hansson, D.,: Agile Web Development with Rails – Third edition, Raleigh, North Carolina, Dallas, Texas, The Pragmatic Bookshelf, 2008, ISBN-13: 978-1-9343561-6-6
- Lenz, P.,: Build Your Own Ruby On Rails Web Applications, United States of America, SitePoint Pty. Ltd., 2007, ISBN 978-0-9758419-5-2
- Naberezny, M., DeVries, D.,: Rails for PHP Developers, Raleigh, North Carolina, Dallas, Texas, The Pragmatic Bookshelf, 2008, ISBN-13: 978-1-9343560-4-3
- Rajshekhar, A.P.,: Building Dynamic Web 2.0 Websites with Ruby on Rails, Birmingham, Packt Publishing Ltd., 2008, ISBN 978-1-847193-41-4
- Fernandez, O.,: The Rails way, Boston, Pearson Education, Inc., 2008, ISBN 978-1-847193-41-4
- Lenz, P.,: Simply Rails 2, Collingwood, SitePoint Pty. Ltd., 2008, ISBN 978-0-9804552-0-5
