Inżynieria oprogramowania i projektowanie

1. Analiza wymagań — rozmowy z klientem, wywiady, obserwacja obecnego systemu. Produkt: specyfikacja wymagań i najczęściej diagram przypadków użycia. Tu decyduje się, co system ma robić.

2. Projektowanie — architektura, podział na moduły, model bazy danych, diagramy klas i sekwencji, projekt interfejsu. Produkt: dokumentacja projektowa. Tu decyduje się, jak system ma to robić.

3. Implementacja — pisanie kodu w wybranym języku, testy jednostkowe pisane przez programistów, praca w repozytorium git.

4. Testowanie — integracyjne, systemowe i akceptacyjne; raportowanie i poprawianie błędów.

5. Wdrożenie — instalacja u klienta, migracja danych ze starego systemu, konfiguracja środowiska produkcyjnego, szkolenie użytkowników.

6. Utrzymanie (konserwacja) — poprawki błędów zgłoszonych przez użytkowników, aktualizacje, dostosowanie do zmian prawa i sprzętu, rozwój o nowe funkcje. To najdłuższa i najdroższa faza całego cyklu.

Analiza wymagan  ------------------->  Testy akceptacyjne
 \                                        /
  Specyfikacja systemu  ----------->  Testy systemowe
     \                                  /
      Projekt architektury  ---->  Testy integracyjne
         \                          /
          Projekt szczegolowy  ->  Testy jednostkowe
             \                    /
                  IMPLEMENTACJA

• Ludzie i interakcje ponad procesy i narzędzia.
• Działające oprogramowanie ponad obszerną dokumentację.
• Współpraca z klientem ponad formalne ustalenia umowy.
• Reagowanie na zmiany ponad realizację ustalonego planu.

+-------------+---------------+--------------+-------------+
|   DO ZROBIENIA |  W TOKU (3)  |  TESTY (2)   |   GOTOWE    |
+-------------+---------------+--------------+-------------+
| [ Eksport   ] | [ Logowanie ] | [ Koszyk   ] | [ Rejestr. ]|
| [ Raporty   ] | [ Platnosci ] | [ Filtry   ] | [ Menu     ]|
| [ Powiadom. ] | [ Wyszukiw. ] |              | [ Stopka   ]|
| [ Ustawien. ] |               |              |             |
+-------------+---------------+--------------+-------------+
                limit = 3       limit = 2
                ^ pelno!        ^ mozna wciagnac 0 zadan

Liczba w naglowku kolumny to limit WIP.
Kolumna "W toku" jest pelna -> nikt nie zaczyna nowego zadania,
zespol pomaga dokonczyc to, co juz sie zaczelo.

         SYSTEM SPRZEDAZY BILETOW
 +--------------------------------------------+
 |                                            |
 |        (  Przegladaj repertuar  )          |
 |               ^                            |
 |               |                            |
 |        (  Rezerwuj miejsce  )              |
 |            |        |                      |
 |  <<include>>|        |<<extend>>           |
 |            v        v                      |
 |   ( Zaloguj sie ) ( Wybierz znizke )       |
 |                                            |
 |        (  Generuj raport sprzedazy )       |
 |               ^                            |
 +---------------|----------------------------+
      O          |                    O
     -|-  -------+                   -|-  ------> raport
     / \                             / \
   KLIENT                        PRACOWNIK KASY

Legenda:
O/-|-/ \        aktor (rola uzytkownika lub system zewnetrzny)
( tekst )       przypadek uzycia (funkcja systemu)
------          asocjacja: aktor bierze udzial w przypadku uzycia
<<include>>     przypadek ZAWSZE wlacza inny (obowiazkowy)
<<extend>>      przypadek CZASEM rozszerza inny (opcjonalny)

         +---------------------------+
       |         Osoba             |   <- nazwa klasy
       +---------------------------+
       | # imie : string           |   <- atrybuty
       | # nazwisko : string       |
       | - pesel : string          |
       +---------------------------+
       | + getImie() : string      |   <- metody (operacje)
       | + setPesel(p:string):void |
       +---------------------------+
                   /_\                 dziedziczenie
                    |                  (pusty trojkat)
       +---------------------------+
       |         Klient            |
       +---------------------------+
       | - idKlienta : int         |
       | - rabat : float           |
       +---------------------------+
       | + zlozZamowienie() : void |
       +---------------------------+
            1 |
              |  posiada
            * |
       +---------------------------+          +------------------+
       |       Zamowienie          |<>-------*|   PozycjaKoszyka |
       +---------------------------+  1       +------------------+
       | - numer : string          | agregacja| - ilosc : int    |
       | - dataZlozenia : date     |          | - cena : float   |
       +---------------------------+          +------------------+
       | + policzWartosc() : float |
       +---------------------------+
            1 |
            <>| KOMPOZYCJA (romb wypelniony)
            1..1
       +---------------------------+
       |        Faktura            |
       +---------------------------+
       | - nrFaktury : string      |
       +---------------------------+

Widocznosc:
  +   public     - dostepny wszedzie
  -   private    - dostepny tylko wewnatrz klasy
  #   protected  - dostepny w klasie i w klasach dziedziczacych
  ~   package    - dostepny w obrebie pakietu

  :Uzytkownik      :FormularzLogowania   :Autoryzacja      :BazaDanych
    |                    |                   |                |
    |  wpiszDane()       |                   |                |
    |------------------->|                   |                |
    |                   [#]                  |                |
    |                    | sprawdz(login,haslo)                |
    |                    |------------------>|                |
    |                    |                  [#] pobierzUzytkownika(login)
    |                    |                   |--------------->|
    |                    |                   |               [#]
    |                    |                   |<- - - - - - - -|
    |                    |                   |   rekord       |
    |                    |<- - - - - - - - - |                |
    |                    |   true / false    |                |
    |<- - - - - - - - - -|                   |                |
    |   komunikat        |                   |                |
    |                    |                   |                |

---->      komunikat synchroniczny (wywolanie metody)
- - >      komunikat zwrotny (odpowiedz, return)
[#]        prostokat aktywnosci - obiekt wykonuje operacje
|          linia zycia obiektu; czas plynie w dol

              (*)   <- wezel poczatkowy
             |
             v
    +--------------------+
    |  Dodaj towar do    |
    |     koszyka        |
    +--------------------+
             |
             v
           /     \
          <  suma  >   [suma > 200 zl]
           \     /--------------------+
             |                        |
    [suma <= 200 zl]                  v
             |             +--------------------+
             v             | Naliczen. rabatu   |
    +--------------------+ +--------------------+
    | Naliczen. wysylki  |          |
    +--------------------+          |
             |                      |
             +----------+-----------+
                        |
                        v
               +------------------+
               | Zlozenie zamow.  |
               +------------------+
                        |
                        v
                      (( ))  <- wezel koncowy

1. RED       napisz test dla nieistniejacej jeszcze funkcji
           -> test NIE przechodzi (na czerwono)

2. GREEN     napisz NAJPROSTSZY kod, ktory zalicza test
           -> test przechodzi (na zielono)

3. REFACTOR  popraw strukture kodu (nazwy, powtorzenia),
           nie zmieniajac zachowania
           -> testy nadal przechodza

 -> wroc do punktu 1 dla kolejnej funkcji


Przyklad testu jednostkowego (skladnia w stylu PHPUnit):

class KalkulatorTest extends TestCase
{
  public function testDodawanie()
  {
      $k = new Kalkulator();
      $this->assertEquals(7, $k->dodaj(3, 4));
  }

  public function testDzieleniePrzezZero()
  {
      $this->expectException(DivisionByZeroError::class);
      (new Kalkulator())->podziel(5, 0);
  }
}

• Pełna historia zmian — wiadomo, kto, kiedy i co zmienił w każdej linii kodu.
• Możliwość cofnięcia się do dowolnej wcześniejszej, działającej wersji.
• Praca równoległa wielu osób na tym samym projekcie bez nadpisywania cudzych plików.
• Rozwijanie nowych funkcji na gałęziach, bez psucia wersji produkcyjnej.
• Kopia repozytorium na serwerze (GitHub, GitLab) to jednocześnie zapasowa kopia projektu.

REPOZYTORIUM  katalog projektu wraz z pelna historia zmian (folder .git)
COMMIT        zatwierdzona migawka zmian; ma autora, date, opis i skrot SHA
BRANCH        galaz - rownolegla linia rozwoju, np. na jedna nowa funkcje
MERGE         scalenie galezi z powrotem do glownej linii (main / master)
KONFLIKT      dwie osoby zmienily te sama linie - git nie wie, ktora zostawic;
            czlowiek musi recznie wybrac i zatwierdzic wynik

git init                     utworzenie nowego repozytorium
git clone <adres>            pobranie repozytorium zdalnego
git status                   co zostalo zmienione
git add plik.php             dodanie pliku do poczekalni (staging)
git commit -m "opis zmiany"  zatwierdzenie zmian z opisem
git log --oneline            historia commitow
git branch nowa-funkcja      utworzenie galezi
git checkout nowa-funkcja    przelaczenie sie na galaz
git merge nowa-funkcja       scalenie galezi do biezacej
git push                     wyslanie commitow na serwer
git pull                     pobranie zmian z serwera

                       galaz "logowanie"
                        o---o---o
                       /         \   merge
main:  o---o---o---o--o-----------o---o--->
       A   B   C   D               scalenie

Kazde "o" to jeden commit. Praca nad nowa funkcja odbywa sie
na osobnej galezi, wiec main przez caly czas pozostaje sprawny.

class Baza
{
  private static $instancja = null;
  private $polaczenie;

  private function __construct()          // konstruktor PRYWATNY
  {
      $this->polaczenie = new PDO("mysql:host=localhost;dbname=sklep",
                                  "user", "haslo");
  }

  public static function getInstancja(): Baza
  {
      if (self::$instancja === null) {
          self::$instancja = new Baza();   // tworzone raz
      }
      return self::$instancja;             // potem zawsze to samo
  }
}

$a = Baza::getInstancja();
$b = Baza::getInstancja();     // $a i $b to DOKLADNIE ten sam obiekt

   UZYTKOWNIK
     |  1. zadanie: GET /produkty?kategoria=laptopy
     v
+--------------+   2. pobierz dane   +-----------------+
|  KONTROLER   |-------------------->|      MODEL      |
|              |<--------------------|  (baza, logika) |
+--------------+   3. lista obiektow +-----------------+
     |
     |  4. przekaz dane do szablonu
     v
+--------------+
|    WIDOK     |  5. gotowy HTML -> przegladarka
+--------------+

Zasada: WIDOK nie odpytuje bazy, MODEL nie generuje HTML-a.
Wymiana szablonu nie dotyka logiki, wymiana bazy nie dotyka szablonu.

interface Obserwator {
  public function aktualizuj($zamowienie);
}

class Zamowienie                      // obiekt obserwowany
{
  private $obserwatorzy = [];

  public function dodajObserwatora(Obserwator $o)
  {
      $this->obserwatorzy[] = $o;
  }

  public function zloz()
  {
      // ... zapis zamowienia ...
      foreach ($this->obserwatorzy as $o) {
          $o->aktualizuj($this);     // powiadomienie WSZYSTKICH
      }
  }
}

class WysylkaMaila implements Obserwator { /* wysyla potwierdzenie */ }
class Magazyn      implements Obserwator { /* zdejmuje towar ze stanu */ }
class Logger       implements Obserwator { /* zapisuje wpis do logu */ }

interface Platnosc {
  public function zaplac(float $kwota): bool;
}

class PlatnoscKarta   implements Platnosc { /* ... */ }
class PlatnoscPrzelew implements Platnosc { /* ... */ }
class PlatnoscBlik    implements Platnosc { /* ... */ }

class FabrykaPlatnosci
{
  public static function utworz(string $typ): Platnosc
  {
      switch ($typ) {
          case "karta":   return new PlatnoscKarta();
          case "przelew": return new PlatnoscPrzelew();
          case "blik":    return new PlatnoscBlik();
          default: throw new InvalidArgumentException("Nieznany typ");
      }
  }
}

// reszta programu nie wie, ktora klasa powstala:
$p = FabrykaPlatnosci::utworz($wyborUzytkownika);
$p->zaplac(199.00);