Czysty kod. Podręcznik dobrego programisty - Robert C. Martin

Uwaga! Sprzedaż produktu została zakończona. Sprawdź inne w tej kategorii.Opis produktu: Czysty kod. Podręcznik dobrego programisty - Robert C. Martin

Chcesz dowiedzieć się czym charakteryzuje się "czysty" kod i jak napisać dobry program bez błędów? W tej książce przeczytasz o technikach solidnego i skutecznego programowania. Zapoznasz się z zasadami i wzorcami pisania składnego kodu. Nauczysz się jak tworzyć nazwy funkcji i obiektów oraz jak pisać testy jednostkowe. W lekturze opisanych jest kilka przykładów porządkowania kodu, dzięki którym nauczysz się jak sprawić by twój program spełniał przyjęte standardy.

W książce zostały zawarte takie zagadnienia jak:

* Nazwy klas i metod

* Funkcje i listy argumentów

* Rozdzielanie poleceń i zapytań

* Stosowanie wyjątków

* Komentarze

* Formatowanie

* Obiekty i struktury danych

* Obsługa błędów

* Testy jednostkowe

* Klasy i systemy

* Współbieżność

* Oczyszczanie kodu

Czysty kod. Podręcznik dobrego programisty - Robert C. Martin.Przykładowe projekty wykorzystane w książce dostępne do pobrania. Fragment ksiązki do przeczytania on-line.

Spis treści Słowo wstępne (13) Wstęp (19) 1. Czysty kod (23)

* Niech stanie się kod... (24)

* W poszukiwaniu doskonałego kodu... (24)

* Całkowity koszt bałaganu (25)

* Rozpoczęcie wielkiej zmiany projektu (26)

* Postawa (27)

* Największa zagadka (28)

* Sztuka czystego kodu? (28)

* Co to jest czysty kod? (28)

* Szkoły myślenia (34)

* Jesteśmy autorami (35)

* Zasada skautów (36)

* Poprzednik i zasady (36)

* Zakończenie (36)

* Bibliografia (37)

2. Znaczące nazwy (39)

* Wstęp (39)

* Używaj nazw przedstawiających intencje (40)

* Unikanie dezinformacji (41)

* Tworzenie wyraźnych różnic (42)

* Tworzenie nazw, które można wymówić (43)

* Korzystanie z nazw łatwych do wyszukania (44)

* Unikanie kodowania (45)

* Notacja węgierska (45)

* Przedrostki składników (46)

* Interfejsy i implementacje (46)

* Unikanie odwzorowania mentalnego (47)

* Nazwy klas (47)

* Nazwy metod (47)

* Nie bądź dowcipny (48)

* Wybieraj jedno słowo na pojęcie (48)

* Nie twórz kalamburów! (49)

* Korzystanie z nazw dziedziny rozwiązania (49)

* Korzystanie z nazw dziedziny problemu (49)

* Dodanie znaczącego kontekstu (50)

* Nie należy dodawać nadmiarowego kontekstu (51)

* Słowo końcowe (52)

3. Funkcje (53)

* Małe funkcje! (56)

* Bloki i wcięcia (57)

* Wykonuj jedną czynność (57)

* Sekcje wewnątrz funkcji (58)

* Jeden poziom abstrakcji w funkcji (58)

* Czytanie kodu od góry do dołu - zasada zstępująca (58)

* Instrukcje switch (59)

* Korzystanie z nazw opisowych (61)

* Argumenty funkcji (62)

* Często stosowane funkcje jednoargumentowe (62)

* Argumenty znacznikowe (63)

* Funkcje dwuargumentowe (63)

* Funkcje trzyargumentowe (64)

* Argumenty obiektowe (64)

* Listy argumentów (65)

* Czasowniki i słowa kluczowe (65)

* Unikanie efektów ubocznych (65)

* Argumenty wyjściowe (66)

* Rozdzielanie poleceń i zapytań (67)

* Stosowanie wyjątków zamiast zwracania kodów błędów (67)

* Wyodrębnienie bloków try-catch (68)

* Obsługa błędów jest jedną operacją (69)

* Przyciąganie zależności w Error.java (69)

* Nie powtarzaj się (69)

* Programowanie strukturalne (70)

* Jak pisać takie funkcje? (70)

* Zakończenie (71)

* SetupTeardownIncluder (71)

* Bibliografia (73)

4. Komentarze (75)

* Komentarze nie są szminką dla złego kodu (77)

* Czytelny kod nie wymaga komentarzy (77)

* Dobre komentarze (77)

* Komentarze prawne (77)

* Komentarze informacyjne (78)

* Wyjaśnianie zamierzeń (78)

* Wyjaśnianie (79)

* Ostrzeżenia o konsekwencjach (80)

* Komentarze TODO (80)

* Wzmocnienie (81)

* Komentarze Javadoc w publicznym API (81)

* Złe komentarze (81)

* Bełkot (81)

* Powtarzające się komentarze (82)

* Mylące komentarze (84)

* Komentarze wymagane (85)

* Komentarze dziennika (85)

* Komentarze wprowadzające szum informacyjny (86)

* Przerażający szum (87)

* Nie używaj komentarzy, jeżeli można użyć funkcji lub zmiennej (88)

* Znaczniki pozycji (88)

* Komentarze w klamrach zamykających (88)

* Atrybuty i dopiski (89)

* Zakomentowany kod (89)

* Komentarze HTML (90)

* Informacje nielokalne (91)

* Nadmiar informacji (91)

* Nieoczywiste połączenia (91)

* Nagłówki funkcji (92)

* Komentarze Javadoc w niepublicznym kodzie (92)

* Przykład (92)

* Bibliografia (95)

5. Formatowanie (97)

* Przeznaczenie formatowania (98)

* Formatowanie pionowe (98)

* Metafora gazety (99)

* Pionowe odstępy pomiędzy segmentami kodu (99)

* Gęstość pionowa (101)

* Odległość pionowa (101)

* Uporządkowanie pionowe (105)

* Formatowanie poziome (106)

* Poziome odstępy i gęstość (106)

* Rozmieszczenie poziome (107)

* Wcięcia (109)

* Puste zakresy (110)

* Zasady zespołowe (110)

* Zasady formatowania wujka Boba (111)

6. Obiekty i struktury danych (113)

* Abstrakcja danych (113)

* Antysymetria danych i obiektów (115)

* Prawo Demeter (117)

* Wraki pociągów (118)

* Hybrydy (118)

* Ukrywanie struktury (119)

* Obiekty transferu danych (119)

* Active Record (120)

* Zakończenie (121)

* Bibliografia (121)

7. Obsługa błędów (123)

* Użycie wyjątków zamiast kodów powrotu (124)

* Rozpoczynanie od pisania instrukcji try-catch-finally (125)

* Użycie niekontrolowanych wyjątków (126)

* Dostarczanie kontekstu za pomocą wyjątków (127)

* Definiowanie klas wyjątków w zależności od potrzeb wywołującego (127)

* Definiowanie normalnego przepływu (129)

* Nie zwracamy null (130)

* Nie przekazujemy null (131)

* Zakończenie (132)

* Bibliografia (132)

8. Granice (133)

* Zastosowanie kodu innych firm (134)

* Przeglądanie i zapoznawanie się z granicami (136)

* Korzystanie z pakietu log4j (136)

* Zalety testów uczących (138)

* Korzystanie z nieistniejącego kodu (138)

* Czyste granice (139)

* Bibliografia (140)

9. Testy jednostkowe (141)

* Trzy prawa TDD (142)

* Zachowanie czystości testów (143)

* Testy zwiększają możliwości (144)

* Czyste testy (144)

* Języki testowania specyficzne dla domeny (147)

* Podwójny standard (147)

* Jedna asercja na test (149)

* Jedna koncepcja na test (150)

* F.I.R.S.T. (151)

* Zakończenie (152)

* Bibliografia (152)

10. Klasy (153)

* Organizacja klas (153)

* Hermetyzacja (154)

* Klasy powinny być małe! (154)

* Zasada pojedynczej odpowiedzialności (156)

* Spójność (158)

* Utrzymywanie spójności powoduje powstanie wielu małych klas (158)

* Organizowanie zmian (164)

* Izolowanie modułów kodu przed zmianami (166)

* Bibliografia (167)

11. Systemy (169)

* Jak budowałbyś miasto? (170)

* Oddzielenie konstruowania systemu od jego używania (170)

* Wydzielenie modułu main (171)

* Fabryki (172)

* Wstrzykiwanie zależności (172)

* Skalowanie w górę (173)

* Separowanie (rozcięcie) problemów (176)

* Pośredniki Java (177)

* Czyste biblioteki Java AOP (178)

* Aspekty w AspectJ (181)

* Testowanie architektury systemu (182)

* Optymalizacja podejmowania decyzji (183)

* Korzystaj ze standardów, gdy wnoszą realną wartość (183)

* Systemy wymagają języków dziedzinowych (184)

* Zakończenie (184)

* Bibliografia (185)

12. Powstawanie projektu (187)

* Uzyskiwanie czystości projektu przez jego rozwijanie (187)

* Zasada numer 1 prostego projektu - system przechodzi wszystkie testy (188)

* Zasady numer 2 - 4 prostego projektu - przebudowa (188)

* Brak powtórzeń (189)

* Wyrazistość kodu (191)

* Minimalne klasy i metody (192)

* Zakończenie (192)

* Bibliografia (192)

13. Współbieżność (193)

* W jakim celu stosować współbieżność? (194)

* Mity i nieporozumienia (195)

* Wyzwania (196)

* Zasady obrony współbieżności (196)

* Zasada pojedynczej odpowiedzialności (197)

* Wniosek - ograniczenie zakresu danych (197)

* Wniosek - korzystanie z kopii danych (197)

* Wniosek - wątki powinny być na tyle niezależne, na ile to tylko możliwe (198)

* Poznaj używaną bibliotekę (198)

* Kolekcje bezpieczne dla wątków (198)

* Poznaj modele wykonania (199)

* Producent-konsument (199)

* Czytelnik-pisarz (200)

* Ucztujący filozofowie (200)

* Uwaga na zależności pomiędzy synchronizowanymi metodami (201)

* Tworzenie małych sekcji synchronizowanych (201)

* Pisanie prawidłowego kodu wyłączającego jest trudne (202)

* Testowanie kodu wątków (202)

* Traktujemy przypadkowe awarie jako potencjalne problemy z wielowątkowością (203)

* Na początku uruchamiamy kod niekorzystający z wątków (203)

* Nasz kod wątków powinien dać się włączać (203)

* Nasz kod wątków powinien dać się dostrajać (204)

* Uruchamiamy więcej wątków, niż mamy do dyspozycji procesorów (204)

* Uruchamiamy testy na różnych platformach (204)

* Uzbrajamy nasz kod w elementy próbujące wywołać awarie i wymuszające awarie (205)

* Instrumentacja ręczna (205)

* Instrumentacja automatyczna (206)

* Zakończenie (207)

* Bibliografia (208)

14. Udane oczyszczanie kodu (209)

* Implementacja klasy Args (210)

* Args - zgrubny szkic (216)

* Argumenty typu String (228)

* Zakończenie (261)

15. Struktura biblioteki JUnit (263)

* Biblioteka JUnit (264)

* Zakończenie (276)

16. Przebudowa klasy SerialDate (277)

* Na początek uruchamiamy (278)

* Teraz poprawiamy (280)

* Zakończenie (293)

* Bibliografia (294)

17. Zapachy kodu i heurystyki (295)

* Komentarze (296)

* C1. Niewłaściwe informacje (296)

* C2. Przestarzałe komentarze (296)

* C3. Nadmiarowe komentarze (296)

* C4. Źle napisane komentarze (297)

* C5. Zakomentowany kod (297)

* Środowisko (297)

* E1. Budowanie wymaga więcej niż jednego kroku (297)

* E2. Testy wymagają więcej niż jednego kroku (297)

* Funkcje (298)

* F1. Nadmiar argumentów (298)

* F2. Argumenty wyjściowe (298)

* F3. Argumenty znacznikowe (298)

* F4. Martwe funkcje (298)

* Ogólne (298)

* G1. Wiele języków w jednym pliku źródłowym (298)

* G2. Oczywiste działanie jest nieimplementowane (299)

* G3. Niewłaściwe działanie w warunkach granicznych (299)

* G4. Zdjęte zabezpieczenia (299)

* G5. Powtórzenia (300)

* G6. Kod na nieodpowiednim poziomie abstrakcji (300)

* G7. Klasy bazowe zależne od swoich klas pochodnych (301)

* G8. Za dużo informacji (302)

* G9. Martwy kod (302)

* G10. Separacja pionowa (303)

* G11. Niespójność (303)

* G12. Zaciemnianie (303)

* G13. Sztuczne sprzężenia (303)

* G14. Zazdrość o funkcje (304)

* G15. Argumenty wybierające (305)

* G16. Zaciemnianie intencji (305)

* G17. Źle rozmieszczona odpowiedzialność (306)

* G18. Niewłaściwe metody statyczne (306)

* G19. Użycie opisowych zmiennych (307)

* G20. Nazwy funkcji powinny informować o tym, co realizują (307)

* G21. Zrozumienie algorytmu (308)

* G22. Zamiana zależności logicznych na fizyczne (308)

* G23. Zastosowanie polimorfizmu zamiast instrukcji if-else lub switch-case (309)

* G24. Wykorzystanie standardowych konwencji (310)

* G25. Zamiana magicznych liczb na stałe nazwane (310)

* G26. Precyzja (311)

* G27. Struktura przed konwencją (312)

* G28. Hermetyzacja warunków (312)

* G29. Unikanie warunków negatywnych (312)

* G30. Funkcje powinny wykonywać jedną operację (312)

* G31. Ukryte sprzężenia czasowe (313)

* G32. Unikanie dowolnych działań (314)

* G33. Hermetyzacja warunków granicznych (314)

* G34. Funkcje powinny zagłębiać się na jeden poziom abstrakcji (315)

* G35. Przechowywanie danych konfigurowalnych na wysokim poziomie (316)

* G36. Unikanie nawigacji przechodnich (317)

* Java (317)

* J1. Unikanie długich list importu przez użycie znaków wieloznacznych (317)

* J2. Nie dziedziczymy stałych (318)

* J3. Stałe kontra typy wyliczeniowe (319)

* Nazwy (320)

* N1. Wybór opisowych nazw (320)

* N2. Wybór nazw na odpowiednich poziomach abstrakcji (321)

* N3. Korzystanie ze standardowej nomenklatury tam, gdzie jest to możliwe (322)

* N4. Jednoznaczne nazwy (322)

* N5. Użycie długich nazw dla długich zakresów (323)

* N6. Unikanie kodowania (323)

* N7. Nazwy powinny opisywać efekty uboczne (323)

* Testy (324)

* T1. Niewystarczające testy (324)

* T2. Użycie narzędzi kontroli pokrycia (324)

* T3. Nie pomijaj prostych testów (324)

* T4. Ignorowany test jest wskazaniem niejednoznaczności (324)

* T5. Warunki graniczne (324)

* T6. Dokładne testowanie pobliskich błędów (324)

* T7. Wzorce błędów wiele ujawniają (324)

* T8. Wzorce pokrycia testami wiele ujawniają (325)

* T9. Testy powinny być szybkie (325)

* Zakończenie (325)

* Bibliografia (325)

A: Współbieżność II (327)

* Przykład klient-serwer (327)

* Serwer (327)

* Dodajemy wątki (329)

* Uwagi na temat serwera (329)

* Zakończenie (331)

* Możliwe ścieżki wykonania (331)

* Liczba ścieżek (332)

* Kopiemy głębiej (333)

* Zakończenie (336)

* Poznaj używaną bibliotekę (336)

* Biblioteka Executor (336)

* Rozwiązania nieblokujące (337)

* Bezpieczne klasy nieobsługujące wątków (338)

* Zależności między metodami mogą uszkodzić kod współbieżny (339)

* Tolerowanie awarii (340)

* Blokowanie na kliencie (340)

* Blokowanie na serwerze (342)

* Zwiększanie przepustowości (343)

* Obliczenie przepustowości jednowątkowej (344)

* Obliczenie przepustowości wielowątkowej (344)

* Zakleszczenie (345)

* Wzajemne wykluczanie (346)

* Blokowanie i oczekiwanie (346)

* Brak wywłaszczania (346)

* Cykliczne oczekiwanie (346)

* Zapobieganie wzajemnemu wykluczaniu (347)

* Zapobieganie blokowaniu i oczekiwaniu (347)

* Umożliwienie wywłaszczania (348)

* Zapobieganie oczekiwaniu cyklicznemu (348)

* Testowanie kodu wielowątkowego (349)

* Narzędzia wspierające testowanie kodu korzystającego z wątków (351)

* Zakończenie (352)

* Samouczek. Pełny kod przykładów (352)

* Klient-serwer bez wątków (352)

* Klient-serwer z użyciem wątków (355)

B: org.jfree.date.SerialDate (357) C: Odwołania do heurystyk (411) Epilog (413) Skorowidz (415)