Automatizare în dezvoltarea aplicațiilor

Slide-urile prezentării

Exerciții practice

Folosiți arhiva cu resurse de aici.

Descărcați și dezarhivați fișierul:

wget http://open-source.cs.pub.ro/summer-school/res/tasks/tasks-auto-dev.zip
unzip tasks-auto-dev.zip

Instalați Dia, Ant, Sun Java SDK, Flex și Bison și LaTeX:

apt-get install dia
apt-get install ant
apt-get install sun-java6-jdk
apt-get install flex bison
apt-get install texlive-latex-base texlive-latex-extra texlive-bibtex-extra texlive-publishers highlight

Creați un repository Git în cadrul directorului obținut din dezarhivare:

git init .
git add .
git commit -m 'Add OSSS tasks'
git config --global user.name "Prenume Nume"
git config --global user.email "prenume.nume@nomail.me"
git config --global color.ui auto

Prenume și Nume reprezintă prenumele și numele vostru. La fel în cazul adresei de e-mail.

Intrați în subdirectorul 01-update-make/.
- Folosiți comanda make pentru a compila sursele. Ignorați warning-urile.
- Urmăriți conținutul fișierului Makefile.
- În fișierul loop_main.cpp, la linia 211, este comentată funcția dead_code_elimination().
  - Decomentați funcția.
- Pentru a putea compila codul, trebuie ca procesul de compilare automată (prin intermediul comenzii make) să includă fișierul dead_code.cpp.
  - Realizați actualizările necesare astfel încât să compileze (prin rularea comenzii make.
  - Cât de multe acțiuni au fost necesare în cadrul noul proces de compilare?
- Comiteți schimbările efectuate:
```
git add Makefile loop_main.cpp
git commit -m 'Use dead code elimination'
```
Intrați în subdirectorul 02-make-from-scratch/.
- Cele trei subdirectoare (cap-01/, cap-02/, cap-03/) conțin surse LaTeX. Ne propunem să creăm fișiere Makefile pentru compilarea surselor.
1. Intrați în subdirectorul cap-01/.
  - Rulați comanda pdflatex cap-01.tex.
  - Creați un fișier Makefile care să automatizeze procesul de mai sus.
    - Aveți în vedere să folosiți țintele all, cap-01.pdf și clean.
    - Actualizați fișierul Makefile pentru a defini următoarele variabile:
      - PDFLATEX, comanda folosită pentru compilarea surselor.
      - BASENAME, numele de bază al fișierului (cap-01).
      - Folosiți o construcție de forma $(addsuffix extension, $(BASENAME)) pentru a defini noi variabile:
        
        TEX, numele fișierului sursă (cap-01.tex) (concanenați extensia .tex la BASENAME).
        
        PDF, numele de bază al fișierului (cap-01.pdf) (concanenați extensia .tex la BASENAME).
    - Actualizați fișierul Makefile pentru a defini variabila OUT_DIR cu valoarea texfiles.
      - Comanda pdflatex primește ca argument opțiunea -output-directory (vezi manual) pentru a genera fișierele de ieșire acolo.
      - Actualizați fișierul Makefile pentru a stoca ieșirea în cadrul subdirectorului texfiles/ și pentru a copia, la finele compilării, fișierul PDF din cadrul subdirectorului în directorul primar.
  - Comiteți schimbările realizate:
```
git add Makefile
git commit -m 'Add Makefile for cap-01'
```
2. Intrați în subdirectorul cap-02/.
  - Copiați fișierul Makefile din subdirectorul cap-01/ și actualizați BASENAME.
  - Pentru compilarea corespunzătoare, trebuie să folosiți și fișierul Makefile din subdirectorul code/.
    - Includeți, în fișierul Makefile, în locul potrivit comenzile:
      -test -d $(CODE_DIR) && make -C $(CODE_DIR) -test -d $(CODE_DIR) && make -C $(CODE_DIR) clean
  - Folosiți fișierul Makefile obținut pentru a genera fișierul PDF.
  - Comiteți schimbările realizate:
```
git add Makefile code/Makefile
git commit -m 'Add Makefiles for cap-02'
```
3. Intrați în subdirectorul cap-03/.
  - Dacă nu este instalat utilitarul dia instalați-l.
  - Copiați fișierul Makefile din subdirectorul cap-01/ și actualizați BASENAME.
  - Rulați comanda make. Ce observați?
  - Intrați în subdirectorul img/.
    - Folosiți comenzile de mai jos pentru a obține un fișier PDF al imaginii:
      dia -t eps ierarhia-de-procese.dia epstopdf ierarhia-de-procese.eps
    - Generați un fișier Makefile cât mai elegant care să obțină fișierul de PDF de mai sus din fișierul Dia.
  - Reveniți în subdirectorul cap-03/ și actualizați fișierul Makefile pentru a compila automat fișierul PDF de mai sus.
    - Folosiți o comandă de forma make -C ... la fel ca la exercițiul anterior.
  - Comiteți schimbările realizate:
```
git add Makefile img/Makefile
git commit -m 'Add Makefiles for cap-03'
```
Intrați, folosind SSH, pe contul vostru de pe swarm.cs.pub.ro:
```
ssh -l username swarm.cs.pub.ro
```
- username este numele vostru de utilizator de pe swarm.cs.pub.ro.
- Creați directorul git-repos/ și, în cadrul acestuia repository-ul osss.git:
```
mkdir git-repos
cd git-repos
git init --bare osss.git
```
- Creați directorul ~/public_html/projects/osss/:
```
mkdir -p ~/public_html/projects/osss/
```
- Lăsați terminalul deschis pentru debugging.
Intrați în subdirectorul 03-git-hook/.
- Inițializați remote-ul origin la valoarea username@swarm.cs.pub.ro:git-repos/osss.git, unde username este numele vostru de utilizator de pe swarm.cs.pub.ro.
- Copiați, prin SSH (scp), conținutul directorului la username@swarm.cs.pub.ro:git-repos/osss.git/hooks/:
```
scp -r * username@swarm.cs.pub.ro:git-repos/osss.git/hooks/
```
- Faceți push la repository:
```
git push origin master
```
- În urma operației de push slide-urile generate anterior vor fi publicate la URL-ul http://swarm.cs.pub.ro/~username/projects/osss/.
Intrați în subdirectorul 04-ant-demo/.
- Urmăriți fișierul build.xml și sursele din directorul src/.
- Compilați sursele:
```
JAVA_HOME=/usr/lib/jvm/java-6-sun/ ant
```
  - Ca să câștigați timp, puteți exporta variabila JAVA_HOME în shell:
```
export JAVA_HOME=/usr/lib/jvm/java-6-sun/
```
- Urmăriți fișierele .class compilate în directorul classes/.
- Folosiți comanda Ant de rulare a aplicației (nu va rula din cauza absenței serverului).
- Folosiți comanda Ant de generare a documentației Javadoc în directorul doc/api/.
  - Fișierul buil.xml dispune de regulă pentru generarea documentației. Folosiți acea regulă.
  - Parcurgeți documentația generată.
Intrați în subdirectorul 05-ant-from-scratch/.
- Construiți setupul necesar astfel încât să fie compilabil cu Ant.
  - Porniți de la fișierul build.xml de la exercițiul anterior.
- Folosiți pachetul ro.pub.cs.sprc.chord.
  - Adică trebuie adăugată, la începutul fiecărui fișier .java, următoarea linie:
```
package ro.pub.cs.sprc.chord;
```
- Nu folosiți regulă de run. Sunt mai multe clase de tip main și nu are rost să complicăm fișierul build.xml.
- Folosiți, respectiv, regulile build (implicit), clean și doc.
- Înainte de a comite actualizările, folosiți fișiere .gitignore pentru a ignora fișierele obținute (fișierele .class și fișierele de ieșire de tip Javadoc).
  - Hint: Puteți ignora directoarele care conțin aceste fișiere.