Czysty kod. Podręcznik dobrego programisty + Mistrz czystego kodu. Kodeks postępowania profesjonalnych programistów

Czysty-kod-Podręcznik-dobrego-programisty.jpg,  Mistrz-czystego-kodu-Kodeks-postępowania-profesjonalnych-programistów.jpg, Robert-C-Martin.jpg, Arik-pl-Księgarnia-Akademicka.jpg
  • promocja
Dostępność: średnia ilość
Wysyłka w: 48 godzin
Dostawa: Cena nie zawiera ewentualnych kosztów płatności sprawdź formy dostawy
Cena: 110,00 zł
zawiera 5.00% VAT, bez kosztów dostawy

Cena regularna: 128,00 zł

110.00
Najniższa cena z 30 dni przed obniżką: 128,00 zł
ilość szt.
Zyskujesz 11 pkt [?]

towar niedostępny

dodaj do przechowalni
Pin It

Opis

Poznaj najlepsze metody tworzenia doskonałego kodu

  • 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

Niech stworzony przez Ciebie kod imponuje czystością!

O autorze

Robert C. Martin (Wujek Bob) jest programistą od 1970 roku. Jest uznanym mówcą na konferencjach całego świata. Napisał między innymi książki Czysty kod (Helion, 2009), Agile. Programowanie zwinne: zasady, wzorce i praktyki zwinnego wytwarzania oprogramowania w C# (Helion, 2008), Mistrz czystego kodu. Kodeks postępowania profesjonalnych programistów (Helion, 2013) oraz UML for Java Programmers (Prentice Hall, 2003). Oprócz tego Martin opublikował setki artykułów, rozpraw i wpisów na blogach. Działał jako redaktor naczelny magazynu „The C++ Report” i był pierwszym przewodniczącym organizacji Agile Alliance. Założył i prowadzi międzynarodową firmę Object Mentor Inc., skupiającą doświadczonych programistów i menedżerów specjalizujących się we wspomaganiu firm w realizacji trudnych projektów.

Spis treści

  • Słowo wstępne
  • Wstęp
    • Podziękowania
      • Rysunki
  • Rozdział 1. Czysty kod
    • Niech stanie się kod...
    • W poszukiwaniu doskonałego kodu...
    • Całkowity koszt bałaganu
      • Rozpoczęcie wielkiej zmiany projektu
      • Postawa
      • Największa zagadka
      • Sztuka czystego kodu?
      • Co to jest czysty kod?
    • Szkoły myślenia
    • Jesteśmy autorami
    • Zasada skautów
    • Poprzednik i zasady
    • Zakończenie
    • Bibliografia
  • Rozdział 2. Znaczące nazwy
    • Wstęp
    • Używaj nazw przedstawiających intencje
    • Unikanie dezinformacji
    • Tworzenie wyraźnych różnic
    • Tworzenie nazw, które można wymówić
    • Korzystanie z nazw łatwych do wyszukania
    • Unikanie kodowania
      • Notacja węgierska
      • Przedrostki składników
      • Interfejsy i implementacje
    • Unikanie odwzorowania mentalnego
    • Nazwy klas
    • Nazwy metod
    • Nie bądź dowcipny
    • Wybieraj jedno słowo na pojęcie
    • Nie twórz kalamburów!
    • Korzystanie z nazw dziedziny rozwiązania
    • Korzystanie z nazw dziedziny problemu
    • Dodanie znaczącego kontekstu
    • Nie należy dodawać nadmiarowego kontekstu
    • Słowo końcowe
  • Rozdział 3. Funkcje
    • Małe funkcje!
      • Bloki i wcięcia
    • Wykonuj jedną czynność
      • Sekcje wewnątrz funkcji
    • Jeden poziom abstrakcji w funkcji
      • Czytanie kodu od góry do dołu zasada zstępująca
    • Instrukcje switch
    • Korzystanie z nazw opisowych
    • Argumenty funkcji
      • Często stosowane funkcje jednoargumentowe
      • Argumenty znacznikowe
      • Funkcje dwuargumentowe
      • Funkcje trzyargumentowe
      • Argumenty obiektowe
      • Listy argumentów
      • Czasowniki i słowa kluczowe
    • Unikanie efektów ubocznych
      • Argumenty wyjściowe
    • Rozdzielanie poleceń i zapytań
    • Stosowanie wyjątków zamiast zwracania kodów błędów
      • Wyodrębnienie bloków try-catch
      • Obsługa błędów jest jedną operacją
      • Przyciąganie zależności w Error.java
    • Nie powtarzaj się[13]
    • Programowanie strukturalne
    • Jak pisać takie funkcje?
    • Zakończenie
    • SetupTeardownIncluder
    • Bibliografia
  • Rozdział 4. Komentarze
    • Komentarze nie są szminką dla złego kodu
    • Czytelny kod nie wymaga komentarzy
    • Dobre komentarze
      • Komentarze prawne
      • Komentarze informacyjne
      • Wyjaśnianie zamierzeń
      • Wyjaśnianie
      • Ostrzeżenia o konsekwencjach
      • Komentarze TODO
      • Wzmocnienie
      • Komentarze Javadoc w publicznym API
    • Złe komentarze
      • Bełkot
      • Powtarzające się komentarze
      • Mylące komentarze
      • Komentarze wymagane
      • Komentarze dziennika
      • Komentarze wprowadzające szum informacyjny
      • Przerażający szum
      • Nie używaj komentarzy, jeżeli można użyć funkcji lub zmiennej
      • Znaczniki pozycji
      • Komentarze w klamrach zamykających
      • Atrybuty i dopiski
      • Zakomentowany kod
      • Komentarze HTML
      • Informacje nielokalne
      • Nadmiar informacji
      • Nieoczywiste połączenia
      • Nagłówki funkcji
      • Komentarze Javadoc w niepublicznym kodzie
      • Przykład
    • Bibliografia
  • Rozdział 5. Formatowanie
    • Przeznaczenie formatowania
    • Formatowanie pionowe
      • Metafora gazety
      • Pionowe odstępy pomiędzy segmentami kodu
      • Gęstość pionowa
      • Odległość pionowa
      • Uporządkowanie pionowe
    • Formatowanie poziome
      • Poziome odstępy i gęstość
      • Rozmieszczenie poziome
      • Wcięcia
      • Puste zakresy
    • Zasady zespołowe
    • Zasady formatowania wujka Boba
  • Rozdział 6. Obiekty i struktury danych
    • Abstrakcja danych
    • Antysymetria danych i obiektów
    • Prawo Demeter
      • Wraki pociągów
      • Hybrydy
      • Ukrywanie struktury
    • Obiekty transferu danych
      • Active Record
    • Zakończenie
    • Bibliografia
  • Rozdział 7. Obsługa błędów
    • Użycie wyjątków zamiast kodów powrotu
    • Rozpoczynanie od pisania instrukcji try-catch-finally
    • Użycie niekontrolowanych wyjątków
    • Dostarczanie kontekstu za pomocą wyjątków
    • Definiowanie klas wyjątków w zależności od potrzeb wywołującego
    • Definiowanie normalnego przepływu
    • Nie zwracamy null
    • Nie przekazujemy null
    • Zakończenie
    • Bibliografia
  • Rozdział 8. Granice
    • Zastosowanie kodu innych firm
    • Przeglądanie i zapoznawanie się z granicami
    • Korzystanie z pakietu log4j
    • Zalety testów uczących
    • Korzystanie z nieistniejącego kodu
    • Czyste granice
    • Bibliografia
  • Rozdział 9. Testy jednostkowe
    • Trzy prawa TDD
    • Zachowanie czystości testów
      • Testy zwiększają możliwości
    • Czyste testy
      • Języki testowania specyficzne dla domeny
      • Podwójny standard
    • Jedna asercja na test
      • Jedna koncepcja na test
    • F.I.R.S.T.[8]
    • Zakończenie
    • Bibliografia
  • Rozdział 10. Klasy
    • Organizacja klas
      • Hermetyzacja
    • Klasy powinny być małe!
      • Zasada pojedynczej odpowiedzialności
      • Spójność
      • Utrzymywanie spójności powoduje powstanie wielu małych klas
    • Organizowanie zmian
      • Izolowanie modułów kodu przed zmianami
    • Bibliografia
  • Rozdział 11. Systemy
    • Jak budowałbyś miasto?
    • Oddzielenie konstruowania systemu od jego używania
      • Wydzielenie modułu main
      • Fabryki
      • Wstrzykiwanie zależności
    • Skalowanie w górę
      • Separowanie (rozcięcie) problemów
    • Pośredniki Java
    • Czyste biblioteki Java AOP
    • Aspekty w AspectJ
    • Testowanie architektury systemu
    • Optymalizacja podejmowania decyzji
      • Korzystaj ze standardów, gdy wnoszą realną wartość
    • Systemy wymagają języków dziedzinowych
    • Zakończenie
    • Bibliografia
  • Rozdział 12. Powstawanie projektu
    • Uzyskiwanie czystości projektu przez jego rozwijanie
    • Zasada numer 1 prostego projektu system przechodzi wszystkie testy
    • Zasady numer 2 4 prostego projektu przebudowa
    • Brak powtórzeń
    • Wyrazistość kodu
    • Minimalne klasy i metody
    • Zakończenie
    • Bibliografia
  • Rozdział 13. Współbieżność
    • W jakim celu stosować współbieżność?
      • Mity i nieporozumienia
    • Wyzwania
    • Zasady obrony współbieżności
      • Zasada pojedynczej odpowiedzialności
      • Wniosek ograniczenie zakresu danych
      • Wniosek korzystanie z kopii danych
      • Wniosek wątki powinny być na tyle niezależne, na ile to tylko możliwe
    • Poznaj używaną bibliotekę
      • Kolekcje bezpieczne dla wątków
    • Poznaj modele wykonania
      • Producent-konsument[9]
      • Czytelnik-pisarz[10]
      • Ucztujący filozofowie[11]
    • Uwaga na zależności pomiędzy synchronizowanymi metodami
    • Tworzenie małych sekcji synchronizowanych
    • Pisanie prawidłowego kodu wyłączającego jest trudne
    • Testowanie kodu wątków
      • Traktujemy przypadkowe awarie jako potencjalne problemy z wielowątkowością
      • Na początku uruchamiamy kod niekorzystający z wątków
      • Nasz kod wątków powinien dać się włączać
      • Nasz kod wątków powinien dać się dostrajać
      • Uruchamiamy więcej wątków, niż mamy do dyspozycji procesorów
      • Uruchamiamy testy na różnych platformach
      • Uzbrajamy nasz kod w elementy próbujące wywołać awarie i wymuszające awarie
      • Instrumentacja ręczna
      • Instrumentacja automatyczna
    • Zakończenie
    • Bibliografia
  • Rozdział 14. Udane oczyszczanie kodu
    • Implementacja klasy Args
      • Jak to napisałem?
    • Args zgrubny szkic
      • Zatrzymałem się
      • O przyrostowości
    • Argumenty typu String
    • Zakończenie
  • Rozdział 15. Struktura biblioteki JUnit
    • Biblioteka JUnit
    • Zakończenie
  • Rozdział 16. Przebudowa klasy SerialDate
    • Na początek uruchamiamy
    • Teraz poprawiamy
    • Zakończenie
    • Bibliografia
  • Rozdział 17. Zapachy kodu i heurystyki
    • Komentarze
      • C1. Niewłaściwe informacje
      • C2. Przestarzałe komentarze
      • C3. Nadmiarowe komentarze
      • C4. Źle napisane komentarze
      • C5. Zakomentowany kod
    • Środowisko
      • E1. Budowanie wymaga więcej niż jednego kroku
      • E2. Testy wymagają więcej niż jednego kroku
    • Funkcje
      • F1. Nadmiar argumentów
      • F2. Argumenty wyjściowe
      • F3. Argumenty znacznikowe
      • F4. Martwe funkcje
    • Ogólne
      • G1. Wiele języków w jednym pliku źródłowym
      • G2. Oczywiste działanie jest nieimplementowane
      • G3. Niewłaściwe działanie w warunkach granicznych
      • G4. Zdjęte zabezpieczenia
      • G5. Powtórzenia
      • G6. Kod na nieodpowiednim poziomie abstrakcji
      • G7. Klasy bazowe zależne od swoich klas pochodnych
      • G8. Za dużo informacji
      • G9. Martwy kod
      • G10. Separacja pionowa
      • G11. Niespójność
      • G12. Zaciemnianie
      • G13. Sztuczne sprzężenia
      • G14. Zazdrość o funkcje
      • G15. Argumenty wybierające
      • G16. Zaciemnianie intencji
      • G17. Źle rozmieszczona odpowiedzialność
      • G18. Niewłaściwe metody statyczne
      • G19. Użycie opisowych zmiennych
      • G20. Nazwy funkcji powinny informować o tym, co realizują
      • G21. Zrozumienie algorytmu
      • G22. Zamiana zależności logicznych na fizyczne
      • G23. Zastosowanie polimorfizmu zamiast instrukcji if-else lub switch-case
      • G24. Wykorzystanie standardowych konwencji
      • G25. Zamiana magicznych liczb na stałe nazwane
      • G26. Precyzja
      • G27. Struktura przed konwencją
      • G28. Hermetyzacja warunków
      • G29. Unikanie warunków negatywnych
      • G30. Funkcje powinny wykonywać jedną operację
      • G31. Ukryte sprzężenia czasowe
      • G32. Unikanie dowolnych działań
      • G33. Hermetyzacja warunków granicznych
      • G34. Funkcje powinny zagłębiać się na jeden poziom abstrakcji
      • G35. Przechowywanie danych konfigurowalnych na wysokim poziomie
      • G36. Unikanie nawigacji przechodnich
    • Java
      • J1. Unikanie długich list importu przez użycie znaków wieloznacznych
      • J2. Nie dziedziczymy stałych
      • J3. Stałe kontra typy wyliczeniowe
    • Nazwy
      • N1. Wybór opisowych nazw
      • N2. Wybór nazw na odpowiednich poziomach abstrakcji
      • N3. Korzystanie ze standardowej nomenklatury tam, gdzie jest to możliwe
      • N4. Jednoznaczne nazwy
      • N5. Użycie długich nazw dla długich zakresów
      • N6. Unikanie kodowania
      • N7. Nazwy powinny opisywać efekty uboczne
    • Testy
      • T1. Niewystarczające testy
      • T2. Użycie narzędzi kontroli pokrycia
      • T3. Nie pomijaj prostych testów
      • T4. Ignorowany test jest wskazaniem niejednoznaczności
      • T5. Warunki graniczne
      • T6. Dokładne testowanie pobliskich błędów
      • T7. Wzorce błędów wiele ujawniają
      • T8. Wzorce pokrycia testami wiele ujawniają
      • T9. Testy powinny być szybkie
    • Zakończenie
    • Bibliografia
  • Dodatek A: Współbieżność II
    • Przykład klient-serwer
      • Serwer
      • Dodajemy wątki
      • Uwagi na temat serwera
      • Zakończenie
    • Możliwe ścieżki wykonania
      • Liczba ścieżek
        • Wyliczanie możliwych uporządkowań
      • Kopiemy głębiej
      • Zakończenie
    • Poznaj używaną bibliotekę
      • Biblioteka Executor
      • Rozwiązania nieblokujące
      • Bezpieczne klasy nieobsługujące wątków
    • Zależności między metodami mogą uszkodzić kod współbieżny
      • Tolerowanie awarii
      • Blokowanie na kliencie
      • Blokowanie na serwerze
    • Zwiększanie przepustowości
      • Obliczenie przepustowości jednowątkowej
      • Obliczenie przepustowości wielowątkowej
    • Zakleszczenie
      • Wzajemne wykluczanie
      • Blokowanie i oczekiwanie
      • Brak wywłaszczania
      • Cykliczne oczekiwanie
      • Zapobieganie wzajemnemu wykluczaniu
      • Zapobieganie blokowaniu i oczekiwaniu
      • Umożliwienie wywłaszczania
      • Zapobieganie oczekiwaniu cyklicznemu
    • Testowanie kodu wielowątkowego
    • Narzędzia wspierające testowanie kodu korzystającego z wątków
    • Zakończenie
    • Samouczek. Pełny kod przykładów
      • Klient-serwer bez wątków
      • Klient-serwer z użyciem wątków
  • Dodatek B: org.jfree.date.SerialDate
  • Epilog

Podręcznik profesjonalnego programisty!

Robert C. Martin, znany jako Uncle Bob, to jeden z prawdziwych gwiazdorów branży IT, człowiek o niezwykłej charyzmie, rewelacyjnym podejściu do słuchaczy i poczuciu humoru. O jego czas wciąż biją się konferencje branżowe. Poza działalnością ekspercką Martin zajmuje się pisaniem książek — m.in. jest autorem znanego każdemu programiście tytułu „Czysty kod”. Książka, którą trzymasz w rękach, jest udaną kontynuacją tej pozycji.

W trakcie lektury dowiesz się, jakie cechy charakteryzują profesjonalnego programistę, a jest ich sporo! W pierwszej kolejności musisz nauczyć się mówić „nie”. Są też sytuacje, kiedy trzeba powiedzieć „tak” — dowiesz się, kiedy i jak to robić. Ponadto poznasz najlepsze techniki zarządzania czasem oraz przekonasz się, jak presja, zmęczenie i pośpiech wpływają na jakość Twojego kodu. W kolejnych rozdziałach Robert C. Martin zapozna Cię z różnymi sposobami podejścia do testowania kodu oraz współpracy między programistami a innymi ludźmi. Książka ta jest długo wyczekiwaną pozycją na rynku — nie pozwól, żeby ktoś miał ją przed Tobą!

Zobacz, jak Uncle Bob:

  • radzi sobie z presją
  • mówi „nie” i „tak”
  • zarządza czasem
  • tworzy kod wysokiej jakości

 

Obowiązkowa lektura każdego programisty!

O autorze

Robert C. Martin (Wujek Bob) jest programistą od 1970 roku. Jest uznanym mówcą na konferencjach całego świata. Napisał między innymi książki Czysty kod (Helion, 2009), Agile. Programowanie zwinne: zasady, wzorce i praktyki zwinnego wytwarzania oprogramowania w C# (Helion, 2008), Mistrz czystego kodu. Kodeks postępowania profesjonalnych programistów (Helion, 2013) oraz UML for Java Programmers (Prentice Hall, 2003). Oprócz tego Martin opublikował setki artykułów, rozpraw i wpisów na blogach. Działał jako redaktor naczelny magazynu „The C++ Report” i był pierwszym przewodniczącym organizacji Agile Alliance. Założył i prowadzi międzynarodową firmę Object Mentor Inc., skupiającą doświadczonych programistów i menedżerów specjalizujących się we wspomaganiu firm w realizacji trudnych projektów.

Spis treści

Słowo wstępne (11)

Wprowadzenie (17)

Podziękowania (21)

O autorze (25)

Na okładce (27)

Obowiązkowy wstęp (29)

Rozdział 1. Profesjonalizm (35)

  • Uważaj, czego sobie życzysz (36)
  • Przejmowanie odpowiedzialności (36)
  • Po pierwsze nie szkodzić (38)
  • Etyka pracy (43)
  • Bibliografia (48)

Rozdział 2. Kiedy mówić "nie" (49)

  • Przeciwstawne role (51)
  • Wysokie stawki (54)
  • Gracz zespołowy (55)
  • Koszta przytakiwania (60)
  • Kod niemożliwy (65)

Rozdział 3. Kiedy mówić "tak" (69)

  • Język zobowiązań (71)
  • Naucz się, jak mówić "tak" (75)
  • Wnioski (78)

Rozdział 4. Kodowanie (79)

  • Przygotowanie (80)
  • Strefa (83)
  • Blokada twórcza (85)
  • Debugowanie (87)
  • Wyznaczanie sobie rytmu (90)
  • Spóźnienia (91)
  • Pomoc (93)
  • Bibliografia (95)

Rozdział 5. TDD (97)

  • Sąd na sali (98)
  • Trzy prawa TDD (99)
  • Czym TDD nie jest (103)
  • Bibliografia (103)

Rozdział 6. Ćwiczenia (105)

  • Kilka ćwiczeń w tle (106)
  • Dojo kodowania (109)
  • Zwiększanie doświadczenia (112)
  • Wnioski (113)
  • Bibliografia (113)

Rozdział 7. Testy akceptacyjne (115)

  • Komunikowanie wymagań (115)
  • Testy akceptacyjne (120)
  • Wnioski (129)

Rozdział 8. Strategie testowania (131)

  • Kontrola jakości nie powinna nic znaleźć (132)
  • Piramida automatyzacji testów (133)
  • Wnioski (136)
  • Bibliografia (136)

Rozdział 9. Zarządzanie czasem (137)

  • Spotkania (138)
  • Manna skupienia (142)
  • Paczkowanie czasu i pomidory (144)
  • Uniki (145)
  • Ślepe uliczki (146)
  • Marsze, bagna i bałagan (146)
  • Wnioski (147)

Rozdział 10. Szacowanie (149)

  • Czym jest szacowanie? (151)
  • PERT (154)
  • Szacowanie zadań (157)
  • Prawo wielkich liczb (159)
  • Wnioski (160)
  • Bibliografia (160)

Rozdział 11. Presja (161)

  • Unikanie presji (163)
  • Jak radzić sobie z presją (165)
  • Wnioski (166)

Rozdział 12. Współpraca (167)

  • Programiści kontra ludzie (169)
  • Móżdżki (173)
  • Wnioski (174)

Rozdział 13. Zespoły i projekty (175)

  • Można to zmiksować? (176)
  • Wnioski (178)
  • Bibliografia (179)

Rozdział 14. Nauczanie, terminowanie i mistrzostwo (181)

  • Stopnie niepowodzenia (181)
  • Nauczanie (182)
  • Terminowanie (187)
  • Rzemiosło (190)
  • Wnioski (191)

Dodatek A. Narzędzia (193)

  • Narzędzia (195)
  • Kontrola kodu źródłowego (195)
  • IDE i edytor (199)
  • Śledzenie problemów (201)
  • Ciągła kompilacja (202)
  • Narzędzia do testów jednostkowych (202)
  • Narzędzia do testów komponentów (203)
  • Narzędzia do testów integracyjnych (204)
  • UML/MDA (205)
  • Wnioski (207)

Skorowidz (209)

Koszty dostawy Cena nie zawiera ewentualnych kosztów płatności

Kraj wysyłki:

Opinie o produkcie (0)

do góry
Sklep jest w trybie podglądu
Pokaż pełną wersję strony
Sklep internetowy Shoper.pl