Curs 04 - Dezvoltarea programelor

Demo

Comanda dpkg

  • Utilitarul dpkg este un manager de pachete pentru sisteme bazate pe Debian (ex. Ubuntu), care poate realiza mai multe acțiuni.
  • Pentru simpla instalare a unui pachet, folosim opțiunea -i, alături de numele fișierului „.deb”, descărcat anterior (sau calea către acest fișier, dacă ne aflăm într-un folder diferit):
student@uso:~$ sudo dpkg -i google-chrome-stable_current_amd64.deb 
Selecting previously unselected package google-chrome-stable.
(Reading database ... 196951 files and directories currently installed.)
Preparing to unpack google-chrome-stable_current_amd64.deb ...
Unpacking google-chrome-stable (86.0.4240.111-1) ...
Setting up google-chrome-stable (86.0.4240.111-1) ...
update-alternatives: using /usr/bin/google-chrome-stable to provide /usr/bin/x-www-browser (x-www-browser) in auto mode
update-alternatives: using /usr/bin/google-chrome-stable to provide /usr/bin/gnome-www-browser (gnome-www-browser) in auto mode
update-alternatives: using /usr/bin/google-chrome-stable to provide /usr/bin/google-chrome (google-chrome) in auto mode
Processing triggers for gnome-menus (3.13.3-11ubuntu1.1) ...
Processing triggers for desktop-file-utils (0.23-1ubuntu3.18.04.1) ...
Processing triggers for mime-support (3.60ubuntu1) ...
Processing triggers for man-db (2.8.3-2) ...

În cazul în care pe sistemul nostru este deja instalată o versiune mai veche a pachetului, dpkg creează un back up al vechilor fișiere, astfel încât să poată păstra versiunea inițială dacă apar probleme la noua instalare.

  • Pentru a șterge un pachet instalat, folosim opțiunea -r:
 
sudo dpkg -r google-chrome-stable 
(Reading database ... 197063 files and directories currently installed.)
Removing google-chrome-stable (86.0.4240.111-1) ...

În cazul ștergerii, trebuie să folosim ca parametru al comenzii numele pachetului instalat, nu numele fișierului „.deb” folosit pentru instalare.

  • Anumite fișiere de configurare ar putea rămâne în sistem după simpla ștergere cu -r, deoarece au fost create separat de scripturi de configurare. Dacă vrem să fim siguri că și acestea sunt șterse, putem folosi opțiunea dpkg -P (purge)
student@uso:~$ sudo dpkg -P google-chrome-stable 
(Reading database ... 197063 files and directories currently installed.)
Removing google-chrome-stable (86.0.4240.111-1) ...
...
Purging configuration files for google-chrome-stable (86.0.4240.111-1) ...
  • Tot dpkg ne oferă posibilitatea de a lista toate pachetele din sistem, alături de versiune, tipul arhitecturii și o scurtă descriere, cu opțiunea -l:
student@uso:~$ dpkg -l
Name                                       Version                                         Architecture Description
+++-==========================================-===============================================-============-===============================================================================
ii  accountsservice                            0.6.45-1ubuntu1                                 amd64        query and manipulate user account information
ii  acl                                        2.2.52-3build1                                  amd64        Access control list utilities
ii  acpi-support                               0.142                                           amd64        scripts for handling many ACPI events
ii  acpid                                      1:2.0.28-1ubuntu1                               amd64        Advanced Configuration and Power Interface event daemon
ii  adduser                                    3.116ubuntu1                                    all          add and remove users and groups
...........

* Dacă ne interesează să verificăm dacă un anumit pachet este deja instalat, putem folosi opțiunea -s, care ne va afișa statusul pachetului (installed / uninstalled) și o serie mai largă de informații legate de acesta:

student@uso:~$ dpkg -s zsh
Package: zsh
Status: install ok installed
Priority: optional
Section: shells
Installed-Size: 2070
Maintainer: Ubuntu Developers ubuntu-devel-discuss@lists.ubuntu.com
.......

gcc (compilarea programelor)

  • GNU Compiler Collection este un compilator pentru C/C++, adică un program ce traduce codul nostru sursă în cod mașină, păstrat într-un fișier executabil și care va putea fi rulat pe procesor.
  • Pentru a compila un fișier de tip cod sursă, putem folosi comanda gcc însoțită de numele sursei:
student@uso:~/demos$ gcc hello_world.c 
student@uso:~/demos$ ls
a.out  hello_world.c
student@uso:~/demos$ file a.out
a.out: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/l, for GNU/Linux 3.2.0, BuildID[sha1]=ddbe5634d0b0da5b4eab5d27d6b77236d7a90f7b, not stripped

Observăm că după rularea comenzii este creat fișierul a.out de tip „ELF 64-bit shared object”, adică un fișier executabil ce va putea fi rulat.

  • Dacă dorim ca executabilul rezultat în urma compilării să aibă un anumit nume, folosim opțiunea -o:
student@uso:~/demos$ gcc hello_world.c -o hello
student@uso:~/demos$ ls
hello  hello_world.c
  • Prin utilizarea a diferitelor opțiuni, putem opri procesul de compilare după fiecare pas descris în curs și obținem astfel fișierul obținut la fiecare etapă a compilării.

Cu opțiunea -E, rezultatul este codul rezultat după etapa de preprocesare. Acest cod este afișat la ieșirea standard, însă poate fi redirectat într-un fișier cu extensia „.i” (această extensie indică faptul că fișierul nu mai trebuie să treacă prin preprocesare).

 
student@uso:~/demos$ gcc -E hello_world.c > hello_world.i
student@uso:~/demos$ file hello_world.i
hello_world.i: C source, ASCII text

Pentru a obține fișierul în limbaj de asamblare rezultat în urma compilării, folosim opțiunea -S (în aces caz, codul în limbaj de asamblare este salvat direct într-un fișier cu extensia „.s”):

student@uso:~/demos$ gcc -S hello_world.c
student@uso:~/demos$ file hello_world.s 
hello_world.s: assembler source, ASCII text

După ce codul a fost tradus din limbaj de asamblare în cod mașină, putem opri procesul înaintea etapei de link-editare, folosind opțiunea „-c”. Rezultatul va fi un fișier cu extensia „.o” ce conține cod mașină, fără a fi linkat încă cu bibliotecile necesare.

student@uso:~/demos$ gcc -c hello_world.c
student@uso:~/demos$ file hello_world.o
hello_world.o: ELF 64-bit LSB relocatable, x86-64, version 1 (SYSV), not stripped
  • În general, programele pe care le dezvoltăm sunt prea complexe pentru a fi scrise într-un singur fișier, motiv pentru care ne dorim să realizăm compilarea din mai multe surse. Pentru a ilustra modul de lucru, vom crea un program care să realizeze operațiile de adunare și scădere a 2 numere întregi. Vom folosi fișierul sursă „operations.c” pentru a implementa cele 2 funcții și fișierul „main.c” pentru a apela aceste funcții.
operations.c
int addition(int a, int b) {
       return a + b;
}
int substraction(int a, int b) {
      return a - b;
}

Pentru a putea apela funcțiile din „operations.c” în „main.c”, va trebui să creăm un fișier de tip header, în acest caz „operations.h”, pe care să-l includem la începutul fișierului main și care să conțină doar antetele funcțiilor respective.

Operations.h
int addition(int a, int b);
int substraction(int a, int b);
Main.c
#include <stdio.h>
#include "operations.h"
int main() {
     int a = 3, b = 2;
     printf("Suma este: %d\n", addition(a, b));
     printf("Diferenta este: %d\n", substraction(a, b));
     return 0;
}

Dacă am include „operations.c” ar apărea o eroare la compilare, din cauza faptului că ar apărea câte 2 definiții ale funcțiilor, atât în „operations.c”, cât și în „main.c”. Folosind un header, în „main.c” vom include doar antetele, compilatorul știind astfel că aceste funcții există, urmând să găsească definițiile lor în alt fișier.

La includerea antetelor definite de noi, numele antetului se pune între „”, nu între <>, ca în cazul „stdio.h”. gcc ne va permite să compilăm ambele surse și să obținem un singur executabil final.

student@uso:~/demos$ gcc -o operations operations.c main.c
student@uso:~/demos$ ./operations 
Suma este: 5
Diferenta este: 1

Make

  • Atunci când lucrăm la aplicații complexe, care implică un număr mare de fișiere sursă, headere etc., procesul de build devine greoi dacă este făcut „manual” (de ex. prin comanda gcc la fiecare re-compilare a codului sursă, când apar modificări). Pentru a automatiza acest proces, putem folosi utilitarul make.
  • Comanda make caută în directorul curent fișiere numite Makefile. Un fișier Makefile conține una sau mai multe reguli, adică nume atribuite unor comenzi. Comanda make fără argumente execută prima regulă din Makefile, iar dacă dorim să rulăm o anumită regulă, folosim „make <nume regulă>”.
  • Pentru programul cu operațiile aritmetice, putem scrie următorul Makefile, conținând regula build care se va ocupa de compilare:
Makefile
build :
	gcc -o operations operations.c main.c
student@uso:~/demos$ make
gcc -o operations operations.c main.c
student@uso:~/demos$ ./operations 
Suma este: 5
Diferenta este: 1
  • Tot în Makefile putem defini mai multe reguli, între care putem stabili anumite dependențe. Pe scurt, rularea unei reguli va depinde de existența unuia sau mai multor fișiere. Dacă fișierele respective există în directorul curent, regula este rulată, dacă nu, se caută în Makefile o altă regulă cu numele respectivului fișier și se rulează mai întâi aceasta (sau se continuă lanțul dependețelor).
Makefile
build : operations.o
	gcc -o operations operations.o main.c
operations.o:
	gcc -c operations.c
clean:
	rm operations
student@uso:~/demos$ make
gcc -c operations.c
gcc -o operations operations.o main.c
student@uso:~/demos$ ./operations 
Suma este: 5
Diferenta este: 1
student@uso:~/demos$ make clean
rm operations
student@uso:~/demos$ ls
Makefile  main.c  operations.c  operations.h  operations.o

Mai sus, regula build depinde de un fișier de tip obiect numit „operations.o”. Deoarece acesta nu există încă în director, se rulează regula cu numele lui, care generează fișierul prin compilarea sursei „operations.c”, iar apoi se revine la regula build. De asemenea, am adăugat regula clean, folosită pentru a șterge executabilul când am încheiat o sesiune de testare.

Git

  • Aproape toate aplicațiile complexe sunt dezvoltate în echipe, fapt care poate face organizarea și structurarea proiectului destul de complicată. Ne vom dori adesea ca anumite feature-uri să fie dezvoltate și testate separat și doar apoi integrate în proiectul final. De asemenea, apar situații când ne dorim să ne putem întoarce la un stadiu anterior al proiectului. Git este un sistem de versionare a codului ce rezolvă astfel de probleme, iar în continuare vom prezenta câteva comenzi de bază.
  • Un proiect este păstrat într-un repository (repo), în cazul lucrului în echipă fiind vorba despre un repository remote. Pentru a crea o clonă locală a unui repo, folosim comanda git clone, însoțită de numele repository-ului. Această comandă creează pe sistemul local un folder cu numele repository-ului, care va conține atât fișierele propriu zise, cât și fișierele utilizate de git în realizarea versionării.
student@uso:~/demos$ git clone https://github.com/systems-cs-pub-ro/uso
Cloning into 'uso'...
remote: Enumerating objects: 150, done.
remote: Counting objects: 100% (150/150), done.
remote: Compressing objects: 100% (115/115), done.
remote: Total 2198 (delta 31), reused 138 (delta 19), pack-reused 2048
Receiving objects: 100% (2198/2198), 118.28 MiB | 5.20 MiB/s, done.
Resolving deltas: 100% (1016/1016), done.
student@uso:~/demos$ cd uso
student@uso:~/demos/uso$ ls -a
 .    .git       'TW Warhammer'   lab03   lab05   lab10   tema1   tema3
 ..   README.md   lab02           lab04   lab09   lab12   tema2   tema4
  • La creare, un repository are doar branch-ul master, care conține în general versiunea stabilă a proiectului. Atunci când vrem să ne aducem contribuția, ne creăm un branch distinct pornind de la master sau de la un alt branch deja existent. Astfel, putem să facem orice modificare, fără a afecta branch-ul de la care am pornit. Comanda git checkout -b <nume branch> va crea un branch nou și ne va muta automat pe acesta (git status afișează numele branch-ului curent și situația modificărilor aduse). Imediat după creare, stadiul proiectului din noul branch va fi identic cu cel înregistrat în branch-ul de la care am pornit.
student@uso:~/demos/uso$ git checkout -b cool_feature
Switched to a new branch 'cool_feature'
student@uso:~/demos/uso$ git status
On branch cool_feature
nothing to commit, working tree clean
  • Conceptul de salvare al unui anumit stadiu al proiectului poate fi asociat cu crearea unui commit.

După simpla adăugare a unui nou fișier (sau după modificarea unui fișier existent), git ne va semnala că statusul acestuia este untracked. Folosind comanda git add, adăugăm fișierul respectiv pe lista fișierelor ce conțin update-uri pe care vrem să le includem în următorul commit.

student@uso:~/demos/uso$ echo "cool_feature" > cool_feature.txt
student@uso:~/demos/uso$ git status
On branch cool_feature
Untracked files:
  (use "git add <file>..." to include in what will be committed)
	cool_feature.txt
nothing added to commit but untracked files present (use "git add" to track)
student@uso:~/demos/uso$ git add cool_feature.txt 
student@uso:~/demos/uso$ git status
On branch cool_feature
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)
	new file:   cool_feature.txt

După ce am adăugat toate fișierele pe care dorim să le folosim, comanda git commit -m va salva un snapshot al fazei curente a proiectului nostru, alături de un mesaj sugestiv transmis ca argument. Commit-ul va fi înregistrat alături de metadatele sale (data și ora, branch-ul, mesajul) în istoricul repo-ului. Pentru a vizualiza ulterior acest istoric, putem folosi comanda git log.

student@uso:~/demos/uso$ git commit -m "Create cool feature"
[cool_feature 0bfd61e] Add cool feature
 1 file changed, 1 insertion(+)
 create mode 100644 cool_feature.txt
student@uso:~/demos/uso$ git log
commit 0bfd61efa5778e62d090da43a1def9f96f5e1930 (HEAD -> cool_feature)
Author: Student USO VM User <student@stud.acs.upb.ro>
Date:   Sun Oct 25 15:46:53 2020 +0200
    Add cool feature
......

Unul dintre motivele pentru care folosim mai întâi git add și apoi git commit este că uneori vom avea mai multe fișiere modificate și vom dori să le grupăm în commit-uri într-un mod relevant (1 commit – o funcționalitate adăugată/un bug rezolvat), astfel încât să păstrăm un istoric relevant al proiectului.

  • Atunci când considerăm că modificările pot fi integrate în versiunea finală a proiectului, realizăm operația de merge, prin care integrăm modificările aflate momentan doar pe branch-ul nostru în branch-ul master.
student@uso:~/demos/uso$ git checkout master 
Switched to branch 'master'
Your branch is up to date with 'origin/master'.
student@uso:~/demos/uso$ ls
 README.md       lab02   lab04   lab09   lab12   tema2   tema4
'TW Warhammer'   lab03   lab05   lab10   tema1   tema3
student@uso:~/demos/uso$ git merge master cool_feature 
Updating 0b8c9aa..0bfd61e
Fast-forward
 cool_feature.txt | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 cool_feature.txt
student@uso:~/demos/uso$ ls
 README.md       cool_feature.txt   lab03   lab05   lab10   tema1   tema3
'TW Warhammer'   lab02              lab04   lab09   lab12   tema2   tema4
  • În cazul în care lucrăm cu un repository remote, comanda git pull rulată dintr-un branch al repository-ului local va crea în repository-ul „părinte” o copie a acestui branch, care va conține istoricul commit-urilor de pe branch-ul local. În acest caz, procesul de merge cu branch-ul master va fi probabil gestionat prin platforma online care găzduiește proiectul (ex. Github).

Pentru a înțelege mai bine modul de lucru cu git, puteți parcurge următorul tutorial: https://gitimmersion.com/

uso/cursuri/curs-04.txt · Last modified: 2020/11/05 18:03 by ebru.resul
CC Attribution-Share Alike 3.0 Unported
www.chimeric.de Valid CSS Driven by DokuWiki do yourself a favour and use a real browser - get firefox!! Recent changes RSS feed Valid XHTML 1.0