Osoby które kupowały "In", wybierały także:

• F# 4.0 dla zaawansowanych. Wydanie IV 96,45 zł, (29,90 zł -69%)
• Systemy reaktywne. Wzorce projektowe i ich stosowanie 65,31 zł, (20,90 zł -68%)
• GameMaker. Kurs video. Kompleksowy przewodnik tworzenia gier platformowych 154,58 zł, (55,65 zł -64%)
• Poradnik design thinking - czyli jak wykorzystać myślenie projektowe w biznesie 39,21 zł, (14,90 zł -62%)
• Flutter. Kurs video. Przewodnik dla 149,00 zł, (59,60 zł -60%)

Spis treści

Inżynieria i testowanie oprogramowania dla studenta i technika programisty eBook -- spis treści

SPIS TREŚCI
1 WSTĘP ............................................................................................................. 11
2 PROGRAMIŚCI PRACUJĄ W ZESPOŁACH ............................................................ 14
2.1 SKŁAD ZESPOŁU IT ................................................................................................ 14
2.2 ZARZĄDZANIE ZADANIAMI I PROGRAMY JE UMOŻLIWIAJĄCE........................................... 17
2.2.1 Trello........................................................................................................ 17
2.2.2 Jira ........................................................................................................... 26
2.3 ŚRODOWISKA PROGRAMISTYCZNE (IDE) ................................................................... 28
2.3.1 PyCharm .................................................................................................. 28
2.3.2 Instalacja PyCharma ................................................................................ 28
2.3.2.1 System Windows 11 ........................................................................................ 28
2.3.2.2 System Linux .................................................................................................... 32
2.3.2.3 System MacOS ................................................................................................. 36
3 SYSTEMY KONTROLI WERSJI ............................................................................. 43
3.1 WPROWADZENIE DO GITA ..................................................................................... 43
3.2 HISTORIA GITA .................................................................................................... 43
3.3 INSTALACJA I KONFIGURACJA GITA ........................................................................... 44
3.3.1 System Windows 11 ................................................................................ 44
3.3.2 System MacOS ......................................................................................... 49
3.3.3 Linux: Skorzystaj z menedżera pakietów: sudo apt install git ................. 53
3.4 TROCHĘ TEORII .................................................................................................... 54
3.5 OTWORZENIE GITA W WERSJI KONSOLOWEJ .............................................................. 55
3.5.1 Co w przypadku gdy nie pokazują nam się skróty w menu podręcznym? 57
3.6 TWORZENIE PIERWSZEGO REPOZYTORIUM ................................................................. 58
3.6.1 Git init ...................................................................................................... 58
3.6.2 Ls ............................................................................................................. 58
3.6.3 Git status ................................................................................................. 58
3.7 TWORZENIE NOWYCH PLIKÓW ................................................................................ 59
3.7.1 Touch plik ................................................................................................ 59
3.7.2 Tworzenie pliku w Visual Studio Code ..................................................... 59
3.8 DODAWANIE PLIKÓW DO STAGING AREA – GIT ADD NAZWA, GIT ADD., GIT ADD -A ............ 61
3.8.1 Git add plik .............................................................................................. 61
3.8.2 Porównanie git add -A z git add. ............................................................. 61
3.9 COMMITY ........................................................................................................... 62
3.10 GIT LOG .......................................................................................................... 63
3.10.1 Git log ...................................................................................................... 63
3.10.2 Git log ––oneline ..................................................................................... 63
3.10.3 git log --graph .......................................................................................... 64
3.10.4 git log -n 3 ............................................................................................... 64
3.10.5 git log -n 4 --oneline ................................................................................ 65
3.10.6 git log --oneline --graph –all .................................................................... 65
3.10.7 git log --pretty=format:"%H %s" ............................................................. 66
3.10.8 git log nazwa_pliku ................................................................................. 66
3.10.9 git log -p -- plik ........................................................................................ 66
3.10.10 git log, czyli informacje o: .................................................................... 66
3.11 BRANCHE – GAŁĘZIE .......................................................................................... 70
3.11.1 Git checkout ............................................................................................ 70
3.11.2 Git switch ................................................................................................. 71
3.11.3 Git restore ............................................................................................... 71
3.11.4 Git branch ................................................................................................ 71
3.12 GIT MERGE ..................................................................................................... 74
3.13 ZEWNĘTRZNE REPOZYTORIUM (GITHUB) – WYPYCHANIE I POBIERANIE ZMIAN .............. 76
3.13.1 Git push ................................................................................................... 76
3.13.2 Pierwsze repozytorium na GitHub ........................................................... 76
3.13.3 Tokeny ..................................................................................................... 78
3.13.4 Zdalne repozytorium – podstawowe informacje o repozytorium, które
widzimy na głównej stronie ..................................................................................... 84
3.13.5 Git pull ..................................................................................................... 88
3.14 GIT MERGE I REBASE ......................................................................................... 89
3.14.1 Git merge ................................................................................................. 89
3.14.2 Git rebase ................................................................................................ 91
3.14.3 Porównanie obu komend ........................................................................ 92
3.15 KONFLIKTY I ICH ROZWIĄZYWANIE ........................................................................ 92
3.16 EDYTOR VIM I REBASE INTERAKTYWNY .................................................................. 99
3.16.1 Edytor Vim ............................................................................................... 99
3.16.2 Git rebase interaktywny ........................................................................ 100
3.17 FEATURE BRANCHE I PULL REQUEST ................................................................... 106
3.17.1 Feature branche .................................................................................... 106
3.17.2 Pull Request ........................................................................................... 107
3.18 GIT IGNORE ................................................................................................... 110
3.19 GIT GUI ...................................................................................................... 112
3.20 SŁOWNICZEK ................................................................................................. 113
3.21 SPRAWDŹ SIĘ! ............................................................................................... 115
4 METODYKI ZARZĄDZANIA PROJEKTAMI ......................................................... 122
4.1 WSTĘP DO METODYK ZARZĄDZANIA PROJEKTAMI ...................................................... 122
4.2 PODEJŚCIE KLASYCZNE ......................................................................................... 130
4.2.1 PRINCE2 ................................................................................................. 130
4.2.2 PMBoK ................................................................................................... 131
4.3 PODEJŚCIE ZWINNE ............................................................................................. 132
4.3.1 AgilePM ................................................................................................. 135
4.3.2 Kanban .................................................................................................. 135
4.3.3 Scrum ..................................................................................................... 137
4.4 PODEJŚCIE EKSTREMALNE ..................................................................................... 146
4.5 OCENA SUKCESU I RYZYKO PROJEKTU ...................................................................... 161
4.6 HARMONOGRAMOWANIE PROJEKTU ...................................................................... 166
4.6.1 Diagram typu Activity-on-Arc (AoA) ...................................................... 166
4.6.2 Diagram typu Activity-on-Node (AoN) .................................................. 167
4.6.3 Metoda ścieżki krytycznej (ang. Cricital Path Method, CPM) ................ 168
4.6.4 Wykres Gantta ...................................................................................... 169
4.6.5 Metoda CCPM (ang. Critical Chain Project Management) .................... 171
4.7 KONTROLA REALIZACJI PROJEKTU ........................................................................... 171
4.7.1 Metoda wartości wypracowanej ........................................................... 172
4.8 SPRAWDŹ SIĘ! ................................................................................................... 174
5 INŻYNIERIA OPROGRAMOWANIA ................................................................... 183
5.1 WPROWADZENIE DO INŻYNIERII OPROGRAMOWANIA ................................................ 183
5.2 ROZWÓJ, KRYZYS I EWOLUCJA OPROGRAMOWANIA ................................................... 183
5.2.1 Rozwój oprogramowania w latach 1946 – obecnie .............................. 183
5.2.2 Kryzys oprogramowania ........................................................................ 184
5.2.2.1 Objawy kryzysu oprogramowania ................................................................. 184
5.2.2.2 Przyczyny kryzysu oprogramowania .............................................................. 185
5.2.2.3 Kierunki rozwiązywania kryzysu oprogramowania ........................................ 186
5.2.3 Ewolucja oprogramowania ................................................................... 186
5.2.4 Co wpływa na sukces projektu?............................................................. 186
5.3 SZACOWANIE OPROGRAMOWANIA ........................................................................ 187
5.3.1 Szacowanie rozmiaru ............................................................................ 188
5.3.2 Szacowanie pracochłonności ................................................................. 191
5.3.3 Szacowanie harmonogramu .................................................................. 193
5.3.4 Wyniki szacowania ................................................................................ 195
5.3.4.1 Negatywne czynniki zawyżonego oszacowania ............................................. 195
5.3.4.2 Negatywne czynniki zaniżonego szacowania ................................................. 195
5.3.4.3 Błędy szacowania........................................................................................... 196
5.3.4.4 Wynik dobrego oszacowania projektu? ......................................................... 196
5.4 PROCES WYTWÓRCZY SYSTEMU ............................................................................. 197
5.4.1 Analiza wymagań .................................................................................. 197
5.4.1.1 Dokument wymagań ..................................................................................... 199
5.4.1.2 Z czego powinien się składać taki dokument? – Struktura ............................ 199
5.4.1.3 Specyfikowanie .............................................................................................. 206
5.4.1.3.1 Co definiuje dobrą specyfikację? ............................................................ 206
5.4.1.3.2 Kto jest odpowiedzialny za specyfikacje? ............................................... 209
5.4.1.3.3 Test Joela ................................................................................................ 210
5.4.1.3.4 Dlaczego specyfikacje są tak ważne? ...................................................... 211
5.4.1.3.5 Schemat specyfikacji .............................................................................. 212
5.4.2 Projektowanie ....................................................................................... 214
5.4.3 Implementacja ...................................................................................... 214
5.4.3.1 Refaktoryzacja ............................................................................................... 215
5.4.3.1.1 Typy refaktoryzacji ................................................................................. 216
5.4.3.1.2 Objawy konieczności zastosowania refaktoryzacji ................................. 217
5.4.4 Testowanie ............................................................................................ 222
5.4.5 Wdrożenie i pielęgnacja ........................................................................ 223
5.5 MODELE PROCESÓW WYTWÓRCZYCH ..................................................................... 223
5.5.1 Model kaskadowy ................................................................................. 223
5.5.2 Model V ................................................................................................. 224
5.5.3 Konstrukcja prototypów ........................................................................ 225
5.5.4 Model przyrostowy ................................................................................ 227
5.5.5 Model iteracyjny .................................................................................... 227
5.5.6 Model spiralny ....................................................................................... 229
5.6 UML ............................................................................................................... 230
5.6.1 Konstrukcja UML ................................................................................... 230
5.6.1.1 Diagram przypadków użycia .......................................................................... 231
5.6.1.2 Diagram klas .................................................................................................. 233
5.6.1.3 Diagram obiektów ......................................................................................... 241
5.6.1.4 Diagram struktur złożonych ........................................................................... 241
5.6.1.5 Diagram komponentów ................................................................................. 242
5.6.1.6 Diagram pakietów ......................................................................................... 244
5.6.1.7 Diagram wdrożenia ........................................................................................ 246
5.6.1.8 Diagram sekwencji ......................................................................................... 247
5.6.1.9 Diagram współdziałania ................................................................................. 249
5.6.1.10 Diagram przeglądu interakcji .................................................................... 250
5.6.1.11 Diagram uwarunkowań czasowych ........................................................... 251
5.6.1.12 Diagram stanu ........................................................................................... 254
5.6.2 Relacyjne bazy danych w UML .............................................................. 258
5.7 SPRAWDŹ SIĘ! ................................................................................................... 259
6 CZYM JEST TESTOWANIE OPROGRAMOWANIA? ............................................. 272
6.1 CZYM JEST TESTOWANIE OPROGRAMOWANIA?......................................................... 272
6.1.1 Cele testowania ..................................................................................... 272
6.1.2 Automatyzacja testów .......................................................................... 272
6.1.3 Etapy procesu testowania ..................................................................... 273
6.1.4 Rola testera oprogramowania .............................................................. 274
6.1.5 Znaczenie testowania w cyklu życia oprogramowania ......................... 274
6.2 METODY TESTOWANIA OPROGRAMOWANIA – TESTY MANUALNE A
AUTOMATYCZNE, TESTY FUNKCJONALNE I NIEFUNKCJONALNE, TESTY REGRESJI .... 274
6.2.1 Testy manualne ..................................................................................... 274
6.2.2 Testy automatyczne .............................................................................. 275
6.2.3 Testy funkcjonalne ................................................................................. 276
6.2.4 Testy niefunkcjonalne ............................................................................ 277
6.2.5 Testy regresji ......................................................................................... 279
6.3 TESTY BIAŁEJ SKRZYNKI, CZARNEJ SKRZYNKI I SZAREJ SKRZYNKI .................... 280
6.3.1 Testy białej skrzynki ............................................................................... 280
6.3.1.1 Przykład zastosowania: .................................................................................. 281
6.3.2 Testy czarnej skrzynki ............................................................................ 281
6.3.3 Testy szarej skrzynki .............................................................................. 282
6.3.4 Testowanie z użyciem instrukcji assert w Pythonie .......................... 284
SPRAWDŹ SIĘ! ............................................................................................................... 286
1. Czym jest główny cel testowania oprogramowania? ........................................ 286
2. Co jest jednym z głównych celów testowania? .................................................. 286
3. Co umożliwia automatyzacja testów? ............................................................... 286
4. W której fazie procesu testowania tworzy się środowisko testowe? .................. 286
5. Na czym polegają testy manualne? ................................................................... 287
6. Jaką wadę mają testy manualne? ...................................................................... 287
7. Co sprawdzają testy funkcjonalne? ................................................................... 287
8. Jakie pytanie zadają testy niefunkcjonalne? ..................................................... 287
9. Czym są testy regresji? ...................................................................................... 288
10. Na czym polegają testy białej skrzynki? .......................................................... 288
11. Czym charakteryzują się testy czarnej skrzynki? ............................................. 288
12. Co wyróżnia testy szarej skrzynki? .................................................................. 288
7 TWORZENIE DOKUMENTACJI PROJEKTU ......................................................... 292
7.1 CZYM JEST DOKUMENTACJA APLIKACJI? ................................................................. 292
7.2 DLACZEGO DOKUMENTACJA JEST WAŻNA? .............................................................. 292
7.3 RODZAJE ODBIORCÓW DOKUMENTACJI ................................................................... 293