CZYSTY KOD PODRĘCZNIK DOBREGO PROGRAMISTY

* Jak pisać dobry kod, a zły przekształcić w dobry?
* Jak formatować kod, aby osiągnąć maksymalną czytelność?
* Jak implementować pełną obsługę błędów bez zaśmiecania logiki…

69.00

Na stanie

* Jak pisać dobry kod, a zły przekształcić w dobry?
* Jak formatować kod, aby osiągnąć maksymalną czytelność?
* Jak implementować pełną obsługę błędów bez zaśmiecania logiki kodu?

O tym, ile problemów sprawia niedbale napisany kod, wie każdy programista. Nie wszyscy jednak wiedzą, jak napisać ten świetny, "czysty" kod i czym właściwie powinien się on charakteryzować. Co więcej – jak odróżnić dobry kod od złego? Odpowiedź na te pytania oraz sposoby tworzenia czystego, czytelnego kodu znajdziesz właśnie w tej książce. Podręcznik jest obowiązkową pozycją dla każdego, kto chce poznać techniki rzetelnego i efektywnego programowania.

W książce "Czysty kod. Podręcznik dobrego programisty" szczegółowo omówione zostały zasady, wzorce i najlepsze praktyki pisania czystego kodu. Podręcznik zawiera także kilka analiz przypadków o coraz większej złożoności, z których każda jest doskonałym ćwiczeniem porządkowania zanieczyszczonego bądź nieudanego kodu. Z tego podręcznika dowiesz się m.in., jak tworzyć dobre nazwy, obiekty i funkcje, a także jak tworzyć testy jednostkowe i korzystać z programowania sterowanego testami. Nauczysz się przekształcać kod zawierający problemy w taki, który jest solidny i efektywny.

* 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

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)
o Rozpoczęcie wielkiej zmiany projektu (26)
o Postawa (27)
o Największa zagadka (28)
o Sztuka czystego kodu? (28)
o 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)
o Notacja węgierska (45)
o Przedrostki składników (46)
o 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)
o Bloki i wcięcia (57)
* Wykonuj jedną czynność (57)
o Sekcje wewnątrz funkcji (58)
* Jeden poziom abstrakcji w funkcji (58)
o Czytanie kodu od góry do dołu – zasada zstępująca (58)
* Instrukcje switch (59)
* Korzystanie z nazw opisowych (61)
* Argumenty funkcji (62)
o Często stosowane funkcje jednoargumentowe (62)
o Argumenty znacznikowe (63)
o Funkcje dwuargumentowe (63)
o Funkcje trzyargumentowe (64)
o Argumenty obiektowe (64)
o Listy argumentów (65)
o Czasowniki i słowa kluczowe (65)
* Unikanie efektów ubocznych (65)
o Argumenty wyjściowe (66)
* Rozdzielanie poleceń i zapytań (67)
* Stosowanie wyjątków zamiast zwracania kodów błędów (67)
o Wyodrębnienie bloków try-catch (68)
o Obsługa błędów jest jedną operacją (69)
o 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)
o Komentarze prawne (77)
o Komentarze informacyjne (78)
o Wyjaśnianie zamierzeń (78)
o Wyjaśnianie (79)
o Ostrzeżenia o konsekwencjach (80)
o Komentarze TODO (80)
o Wzmocnienie (81)
o Komentarze Javadoc w publicznym API (81)
* Złe komentarze (81)
o Bełkot (81)
o Powtarzające się komentarze (82)
o Mylące komentarze (84)
o Komentarze wymagane (85)
o Komentarze dziennika (85)
o Komentarze wprowadzające szum informacyjny (86)
o Przerażający szum (87)
o Nie używaj komentarzy, jeżeli można użyć funkcji lub zmiennej (88)
o Znaczniki pozycji (88)
o Komentarze w klamrach zamykających (88)
o Atrybuty i dopiski (89)
o Zakomentowany kod (89)
o Komentarze HTML (90)
o Informacje nielokalne (91)
o Nadmiar informacji (91)
o Nieoczywiste połączenia (91)
o Nagłówki funkcji (92)
o Komentarze Javadoc w niepublicznym kodzie (92)
o Przykład (92)
* Bibliografia (95)

5. Formatowanie (97)

* Przeznaczenie formatowania (98)
* Formatowanie pionowe (98)
o Metafora gazety (99)
o Pionowe odstępy pomiędzy segmentami kodu (99)
o Gęstość pionowa (101)
o Odległość pionowa (101)
o Uporządkowanie pionowe (105)
* Formatowanie poziome (106)
o Poziome odstępy i gęstość (106)
o Rozmieszczenie poziome (107)
o Wcięcia (109)
o 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)
o Wraki pociągów (118)
o Hybrydy (118)
o Ukrywanie struktury (119)
* Obiekty transferu danych (119)
o 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)
o Testy zwiększają możliwości (144)
* Czyste testy (144)
o Języki testowania specyficzne dla domeny (147)
o Podwójny standard (147)
* Jedna asercja na test (149)
o Jedna koncepcja na test (150)
* F.I.R.S.T. (151)
* Zakończenie (152)
* Bibliografia (152)

10. Klasy (153)

* Organizacja klas (153)
o Hermetyzacja (154)
* Klasy powinny być małe! (154)
o Zasada pojedynczej odpowiedzialności (156)
o Spójność (158)
o Utrzymywanie spójności powoduje powstanie wielu małych klas (158)
* Organizowanie zmian (164)
o 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)
o Wydzielenie modułu main (171)
o Fabryki (172)
o Wstrzykiwanie zależności (172)
* Skalowanie w górę (173)
o 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)
o 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)
o Mity i nieporozumienia (195)
* Wyzwania (196)
* Zasady obrony współbieżności (196)
o Zasada pojedynczej odpowiedzialności (197)
o Wniosek – ograniczenie zakresu danych (197)
o Wniosek – korzystanie z kopii danych (197)
o Wniosek – wątki powinny być na tyle niezależne, na ile to tylko możliwe (198)
* Poznaj używaną bibliotekę (198)
o Kolekcje bezpieczne dla wątków (198)
* Poznaj modele wykonania (199)
o Producent-konsument (199)
o Czytelnik-pisarz (200)
o 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)
o Traktujemy przypadkowe awarie jako potencjalne problemy z wielowątkowością (203)
o Na początku uruchamiamy kod niekorzystający z wątków (203)
o Nasz kod wątków powinien dać się włączać (203)
o Nasz kod wątków powinien dać się dostrajać (204)
o Uruchamiamy więcej wątków, niż mamy do dyspozycji procesorów (204)
o Uruchamiamy testy na różnych platformach (204)
o Uzbrajamy nasz kod w elementy próbujące wywołać awarie i wymuszające awarie (205)
o Instrumentacja ręczna (205)
o 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)
o C1. Niewłaściwe informacje (296)
o C2. Przestarzałe komentarze (296)
o C3. Nadmiarowe komentarze (296)
o C4. Źle napisane komentarze (297)
o C5. Zakomentowany kod (297)
* Środowisko (297)
o E1. Budowanie wymaga więcej niż jednego kroku (297)
o E2. Testy wymagają więcej niż jednego kroku (297)
* Funkcje (298)
o F1. Nadmiar argumentów (298)
o F2. Argumenty wyjściowe (298)
o F3. Argumenty znacznikowe (298)
o F4. Martwe funkcje (298)
* Ogólne (298)
o G1. Wiele języków w jednym pliku źródłowym (298)
o G2. Oczywiste działanie jest nieimplementowane (299)
o G3. Niewłaściwe działanie w warunkach granicznych (299)
o G4. Zdjęte zabezpieczenia (299)
o G5. Powtórzenia (300)
o G6. Kod na nieodpowiednim poziomie abstrakcji (300)
o G7. Klasy bazowe zależne od swoich klas pochodnych (301)
o G8. Za dużo informacji (302)
o G9. Martwy kod (302)
o G10. Separacja pionowa (303)
o G11. Niespójność (303)
o G12. Zaciemnianie (303)
o G13. Sztuczne sprzężenia (303)
o G14. Zazdrość o funkcje (304)
o G15. Argumenty wybierające (305)
o G16. Zaciemnianie intencji (305)
o G17. Źle rozmieszczona odpowiedzialność (306)
o G18. Niewłaściwe metody statyczne (306)
o G19. Użycie opisowych zmiennych (307)
o G20. Nazwy funkcji powinny informować o tym, co realizują (307)
o G21. Zrozumienie algorytmu (308)
o G22. Zamiana zależności logicznych na fizyczne (308)
o G23. Zastosowanie polimorfizmu zamiast instrukcji if-else lub switch-case (309)
o G24. Wykorzystanie standardowych konwencji (310)
o G25. Zamiana magicznych liczb na stałe nazwane (310)
o G26. Precyzja (311)
o G27. Struktura przed konwencją (312)
o G28. Hermetyzacja warunków (312)
o G29. Unikanie warunków negatywnych (312)
o G30. Funkcje powinny wykonywać jedną operację (312)
o G31. Ukryte sprzężenia czasowe (313)
o G32. Unikanie dowolnych działań (314)
o G33. Hermetyzacja warunków granicznych (314)
o G34. Funkcje powinny zagłębiać się na jeden poziom abstrakcji (315)
o G35. Przechowywanie danych konfigurowalnych na wysokim poziomie (316)
o G36. Unikanie nawigacji przechodnich (317)
* Java (317)
o J1. Unikanie długich list importu przez użycie znaków wieloznacznych (317)
o J2. Nie dziedziczymy stałych (318)
o J3. Stałe kontra typy wyliczeniowe (319)
* Nazwy (320)
o N1. Wybór opisowych nazw (320)
o N2. Wybór nazw na odpowiednich poziomach abstrakcji (321)
o N3. Korzystanie ze standardowej nomenklatury tam, gdzie jest to możliwe (322)
o N4. Jednoznaczne nazwy (322)
o N5. Użycie długich nazw dla długich zakresów (323)
o N6. Unikanie kodowania (323)
o N7. Nazwy powinny opisywać efekty uboczne (323)
* Testy (324)
o T1. Niewystarczające testy (324)
o T2. Użycie narzędzi kontroli pokrycia (324)
o T3. Nie pomijaj prostych testów (324)
o T4. Ignorowany test jest wskazaniem niejednoznaczności (324)
o T5. Warunki graniczne (324)
o T6. Dokładne testowanie pobliskich błędów (324)
o T7. Wzorce błędów wiele ujawniają (324)
o T8. Wzorce pokrycia testami wiele ujawniają (325)
o T9. Testy powinny być szybkie (325)
* Zakończenie (325)
* Bibliografia (325)

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

* Przykład klient-serwer (327)
o Serwer (327)
o Dodajemy wątki (329)
o Uwagi na temat serwera (329)
o Zakończenie (331)
* Możliwe ścieżki wykonania (331)
o Liczba ścieżek (332)
o Kopiemy głębiej (333)
o Zakończenie (336)
* Poznaj używaną bibliotekę (336)
o Biblioteka Executor (336)
o Rozwiązania nieblokujące (337)
o Bezpieczne klasy nieobsługujące wątków (338)
* Zależności między metodami mogą uszkodzić kod współbieżny (339)
o Tolerowanie awarii (340)
o Blokowanie na kliencie (340)
o Blokowanie na serwerze (342)
* Zwiększanie przepustowości (343)
o Obliczenie przepustowości jednowątkowej (344)
o Obliczenie przepustowości wielowątkowej (344)
* Zakleszczenie (345)
o Wzajemne wykluczanie (346)
o Blokowanie i oczekiwanie (346)
o Brak wywłaszczania (346)
o Cykliczne oczekiwanie (346)
o Zapobieganie wzajemnemu wykluczaniu (347)
o Zapobieganie blokowaniu i oczekiwaniu (347)
o Umożliwienie wywłaszczania (348)
o 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)
o Klient-serwer bez wątków (352)
o 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)

Autor

ISBN

978-83-283-0234-1

Liczba stron

Rok wydania

Wydawca

Opinie

Na razie nie ma opinii o produkcie.

Napisz pierwszą opinię o „CZYSTY KOD PODRĘCZNIK DOBREGO PROGRAMISTY”