Katalog książek

Wydawnictwo Helion

Helion SA
ul. Kościuszki 1c
44-100 Gliwice
tel. (32) 230-98-63




© Helion 1991-2016

Lauret zaufanych opinii
Czysty kod. Podręcznik dobrego p...

Czysty kod. Podręcznik dobrego programisty

Autor: 

Ocena:
   5.5/6  Opinie  (46)
Stron: 424 Stron (w wersji papierowej): 424
Ksiazka drukowana Druk (oprawa: miękka) 3w1 w pakiecie: PdfPDF ePubePub MobiMobi
Wydawca: Helion
Wydawca: Helion
Cena:
69,00 zł
Cena promocyjna: Oszczędzasz: 13,80 zł
55,20 zł 69,00 zł
Dodaj do koszyka
Kup terazstrzalka

Druk
Książka drukowana
69,00 zł
eBook
Pdf ePub Mobi
55,20 zł
69,00 zł

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ą!

  • 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
Osoby, które kupowały książkę, często kupowały też:
Wzorce projektowe. Elementy oprogramowania obie...
Erich Gamma, Richard Helm, Ralph Johnson, John M. Vlissides
Cena: 49,00 zł
Cena: 149,00 zł
Cena: 89,00 zł
Cena: 59,00 zł
Cena: 41,30 zł
Osoby, które kupowały książkę, często kupowały też:
Cena: 29,50 zł
Cena: 71,20 zł
Cena: 119,20 zł
Cena: 47,20 zł
6
(29)
5
(10)
4
(3)
3
(1)
2
(2)
1
(1)

Liczba ocen: 46

Średnia ocena
czytelników

  


okladka
  Ocena : 6 

Świetna książka. Daje dużo do myślenia nad pisaniem czystego kodu. Nie umiejąc javy tylko znając C++ 3/4 książki zrozumiałem bez większych problemów. Ma wiele pożytecznych rad. Autor wie o czym pisze. Wiedzę popiera własnym doświadczeniem.
  Ocena : 6 

Podstawowa książka każdego programisty (każdego).
  Ocena : 6 

Bardzo dobra książka. Nieco żałuję, że trochę późno ją przeczytałem, ponieważ wtedy mógłbym uniknąć wielu błędów, które zdążyłem popełnić w przeszłości. Niemniej jednak, lektura książki daje do myślenia, zmienia podejście do programowania i świetnie rozwiewa wszelkie wątpliwości dotyczące tego, jak właściwie powinno się pisać dobry i czysty kod, co należy robić, a czego należy unikać. Książka jest podzielona na małe rozdziały, przez co łatwiej jest chłonąć informacje. Całość czyta się dość przyjemnie, choć autor na wstępie zaznaczył, że lektura lekka nie jest. Uważam, że każdy programista, który poważnie traktuje swoją pracę i chce być profesjonalistą powinien uważnie przeczytać tę książkę.
  Ocena : 6 

Bardzo, ale to bardzo dobra książka do ungruntowania sobie podstaw solidnego programowania w akcji.
  Ocena : 6 

Jest to pozycja obowiązkowa dla każdego programisty. Zwraca uwagę na pozornie nie znaczące kwestie takie jak formatowanie kodu czy też nazewnictwo zmiennych. Ale jak to zwykle bywa zła karma wraca i gdy programista nie przestrzega tych drobiazgów z czasem kod się zaciemnia i staje się coraz trudniejszy w utrzymaniu co z kolei odbija się na spadku szybkości wytwarzania oprogramowania. Polecam każdemu.
  Ocena : 6 

Książka bardzo dobra dla osób początkujących, próbujących napisać kilka pierwszych większych projektów. Zwięzły i uzasadniony zbiór reguł, których przestrzeganie znacznie podnosi czytelność kodu.
  Ocena : 6 

  Ocena : 6 

Co tu dużo pisać. Absolutny klasyk. MUST dla każdego programisty.
  Ocena : 6 

Pozycja obowiązkowa dla każdego, kto chce uważać siebie za osobę dążącą do bycia profesjonalnym programistą. Ciężko jest wprowadzić w życie wszystkie zawarte tam uwagi, (ba! nawet ciężko z niektórymi się zgodzić!) ale każda jedna której się nauczymy wpływa pozytywnie na jakość naszej pracy. Polecam!
  Ocena : 6 

TEST
  Ocena : 6 

Książka ta jest wpisana w kanon lektur obowiązkowych dla programistów. Polecam. Szkoda że na studiach tego nie wymagali.
  Ocena : 6 

Ostatnio zakupiłem tę książkę i już pierwszego dnia byłem w połowie. Książka jest na prawdę świetna. Łatwo się ją czyta nawet jeżeli nie jest się ekspertem od javy. W książce "Czysty kod" autor opisuje sposoby tworzenia idealnego kodu, który zrozumie zarówno przyjaciel, z którym programujesz od lat jak i nowy programista w Twojej firmie. Lektura obowiązkowa dla każdego programisty. Polecam!
  Ocena : 6 

Przeczytałem pół książki, drugie pół jest dla mnie nie przydatne bo nie znam jeszcze danych technologii, np TDD. Jednak dowiedziałem się bardzo dużo o czystości kodu, to naprawdę pomaga!
  Ocena : 6 

Dla nieprzekonanych - zastosowanie się (chociaż z grubsza) do wytycznych zawartych w tej książce zaoszczędzi wam sporo czasu gdy po kilku dniach będziecie przeglądali swój kod i zastanawiali się co mieliście na myśli go pisząc.
  Ocena : 6 

Bardzo dobra pozycja, którą niezwykle lekko się czyta. Nawet osoby nieznające języka Java są wstanie bez problemu przeanalizować (czytać) kod autora. Autor nie tylko przedstawia metody pisania czystego kodu, co dostarcza wielu wspaniałych rad, nawet organizacyjnych. Owszem książka jest skierowana do doświadczonych programistów, bo oni są w stanie zrozumieć pewne problemu w niej poruszane. Ale mam znajomych którzy mają niewielkie doświadczenie a mimo tego uważają ją za rewelacyjną. I naprawdę polecam każdemu (a zwłaszcza osobom niedoświadczonym, które mają szansę nauczyć się dobrych nawyków).
  Ocena : 6 

Książka dla osób, które już "coś tam programowały" obiektowo. Pisząc jakieś aplikacje, często zastanawiałem się co mam umieścić w każdej funkcji, nie wiedziałem kiedy i dlaczego używać mechanizmu wyjątków, dlaczego tworzone przeze mnie klasy są tak nieefektywne i ciągle muszę coś w nich zmieniać. Po przeczytaniu samych pierwszych kilku rozdziałów, większość problemów, nad którymi się zastanawiałem, zostało rozwiązanych! Polecam! :)
  Ocena : 6 

Ta książka bardzo pozytywnie wpłynęła na moje podejście do programowania. Na początku też nie mogłem przełknąć niemal obrazoburczych wersetów tej książki, lecz później schowałem dumę w kieszeń i przyjąłem, że nie jestem najmądrzejszy i postanowiłem się nauczyć z tej książki jak pisać czysty kod. Polecam każdemu programiście! P.S. Pan "programista wydajnościowy" najwyraźniej nie dorósł jeszcze do tego, żeby zrozumieć, że w dzisiejszych czasach wydajność jest na drugim planie. Liczy się utrzymanie programu w czasie. Najwydajniejszy kod źle napisany będzie musiał zostać wyrzucony po krótkim czasie. P.P.S. Pan "programista wydajnościowy" nie przeczytał książki a ją ocenia? To dyskredytuje jego opinię całkowicie.
  Ocena : 6 

Swietna ksiazka, dla kazdego programisty, odkrylem ja troche pozniej niz zaczelem kodowac cokolwiek I uczciwie musze powiedziec ze nie raz smialem sie z siebie "tak robie, o tak tez". Polecam, dobra lektura po ktorej wiesz jak nie kodowac, ale jak to robic lepiej. Uczy tez innego spojrzenia na zawod ktory sie wykonuje.
  Ocena : 6 

Polecam tą książkę wszystkim programującym w językach imperatywnych (C++, Java, C# itp.). Książka omawia jak pisać czytelny kod - jak poprawnie nazywać zmienne, klasy, ile linii powinna zawierać funkcja oraz klasa, omówiona została też niezwykle istotna zasada pojedynczej odpowiedzialności klasy. Książka zawiera również m. in. listę tzn. zapachów kodu, czyli praktyk programowania których należy unikać.
  Ocena : 6 

"Must read" dla każdego programisty. Książka rewelacyjna.
  Ocena : 6 

"Czysty kod" pozwala poznać sposób myślenia programisty z wieloletnim doświadczeniem, nie jest przeznaczona dla osób totalnie początkujących (co nie jest absolutnie wadą). Uważam, że rady tam zawarte można uznać w dużej mierze za uniwersalne. Składnia Javy nie jest przecież trudna i każdy, kto choć trochę programował w C++ albo w C# nie powinien mieć problemów ze zrozumieniem podanych tam przykładów. Wiadomo, że nie zawsze można zastosować się do podanych w książce rad. Jeżeli dany moduł programu ma bardzo ścisłe wymagania wydajnościowe, to wówczas ROZWAŻNIE odchodzimy od np. dzielenia funkcjonalności. Najlepiej, moim zdaniem, doprowadzić program do wersji takiej, jaką proponuje autor, a optymalizacją zająć się po spełnieniu wszystkich wymagań funkcjonalnych. Wtedy struktura kodu będzie przemyślana, w przeciwieństwie do spaghetti serwowanego przez programistów "zorientowanych na wydajność". Książka mnie zmotywowała do poprawy swojego kodu, a "programiści wydajnościowi" powinni pamiętać, że na wydajność wpływa również łatwość utrzymania systemu. Optymalizacja eleganckiego i czystego kodu to zadanie łatwe i przyjemne, zarządzanie "ultrawydajnym spaghetti" to mordęga (szczególnie jeśli chodzi o wprowadzanie zmian). Należy o tym pamiętać, zresztą chyba sam autor o tym wspomina. "Czysty kod" zajmuje u mnie miejsce wyróżnione - każdy programista powinien znać praktyki tam zawarte. Polecam, a niektórym dodatkowo życzę więcej pokory.
  Ocena : 6 

Książka już przeszła do legendy. Lektura konieczna dla kazdego programisty.
  Ocena : 6 

Bardzo dobra książka. Nie uczy składni a programowania. Może nie tyle nawet uczy, co pokazuje, jak to robi programista ze sporym doświadczeniem.
  Ocena : 6 

Książka bardzo istotna dla rozwoju programistów, zwłaszcza tych, który nie mieli nigdy do czynienia z dobrze napisanym kodem. Wyjaśnia dlaczego metody powinny być krótkie i dobrze nazwane, dlaczego należy zapewnić maksymalne pokrycie kodu testami jednostkowymi a także wiele innych aspektów tworzenia oprogramowania wysokiej jakości. Pozycja obowiązkowa dla tych, którzy chcą wyjść ponad programistyczną przeciętność.
  Ocena : 6 

Jedna z najlepszych książek informatycznych jakie czytałem. W szczególności przydatna średnio zaawansowanym programistom, którzy dobrze znają język w którym programują, ale czują się lekko zagubieni, gdy przyjdzie im zaprojektować i napisać większy program. Książka zwraca uwagę na błędy, które początkowo wydają się być bez znaczenia, ale z czasem dają o sobie znać. Pozwala uniknąć tego co pogrążyło nie jeden projekt. Przestrzegając zawartych w niej zasad i budując na ich podstawie nawyki, Twoje oprogramowanie będzie łatwiejsze w projektowaniu, tworzeniu i dalszym utrzymywaniu. W szczególności polecam ją studentom lub świeżym absolwentom informatyki - z pewnością skorzystacie na lekturze tej książki. Książka wykorzystuje przykłady z języka Java, ale programiści innych języków nie będą mieli problemów z jej zrozumieniem (w szczególności ci, którzy znają już jakiś C-podobny język).
  Ocena : 6 

Książkę należy polecić przede wszystkim zawodowym programistom. Pozycja pokazuje przykłady dobrych konstrukcji, które można zastosować nie tylko w Javie, ale w każdym innym współcześnie stosowanym języku programowania. Jest to jedna z niewielu pozycji, która pokazuje jak organizować kod źródłowy - tak aby można było go łatwiej pielęgnować. Autor podaje przy tym konkretne uzasadnienie dla proponowanych zmian w strukturze kodu. Niektóre rozdziały mogą być trudniejsze dla osób, które nie programują w Javie, ale książka nie skupia się na syntaktyce. Fenomenalne!
  Ocena : 6 

Książkę czyta się przyjemnie. Autor nie wdaje się w szczegóły zbędne z punktu widzenia tematyki książki (specyfikacja języka itp). Jest lekko kontrowersyjna, ale przez to, przynajmniej w moim odczuciu, została zabarwiona szczyptą humoru. Czytając tę książkę, poczułem się jak amator uczący się od nowa fundamentalnych aspektów programowania. Zdarzają się literówki i błędy w tłumaczeniu (wygląda to trochę jak tłumaczenie w pośpiechu). Jednak jestem daleki od obniżania o 2 czy 3 stopnie oceny z powodu uchybień tego kalibru.
  Ocena : 6 

Książka warta polecenia każdemu programiście - nie tylko javy. Świetne przykłady, opis szczegółowy z konkretnymi przykładami. POLECAM !
  Ocena : 6 

Polecam! Negatywne opinie które są na tej stronie wypisane są prawdopodobnie przez amatorów, którzy nie mają zbyt wiele wspólnego z profesjonalnym programowaniem i dlatego nie dostrzegają co książka oferuje.
  Ocena : 5 

Tak jak napisał jeden z wcześniej oceniających - książka jest obowiązkową pozycją dla każdego programisty. Z całą pewnością wymagająca i uświadamiająca jak daleko nam do ideału - przez to motywująca do zmiany utartych przyzwyczajeń, złych nawyków. Niestety miejscami tłumaczenie nie dostaje do oryginału, niektóre sformułowania są wręcz rażące. Na szczęście takich "kwiatków" jest niewiele i nie wpływają summa summarum na ogólną ocenę książki. Two thumbs up!
  Ocena : 5 

Polecam lekturę zwłaszcza na początku kariery zawodowej, żeby zawczasu nabrać dobrych nawyków i nie psuć krwi współpracownikom, którzy muszą naszą twórczość czytać. ;) Doświadczeni, rozgarnięci esteci raczej Ameryki w tej książce nie odkryją, ale i tak myślę, że warto choćby dla jednego "ojej, ja też tak brzydko robię...". Ponadto uważam za cenną podaną bibliografię (jeszcze niezgłębioną, ale książka zrobiła mi duży apetyt). Nie widzę tylko sensu dodania dobrych 50 stron biblioteki, która gdzieś pod koniec książki jest analizowana i refaktoryzowana. Cel może szczytny (w pracy przecież też będziemy czytać i pisać kobyły), ale kto będzie uważnie czytać rozdział i co chwilę kartkować tę bibliotekę w poszukiwaniu aktualnie komentowanej stałej?
  Ocena : 5 

Bardzo dobra książka dla fanów wujka Boba i Jego podejścia do tworzenia oprogramowania.
  Ocena : 5 

Obowiązkowa lektura każdego programisty, niezależnie od doświadczenia czy technologii, w jakiej pracuje.
  Ocena : 5 

Książka porusza problemy które głównie ujawniają się przy projektach programistycznych które są rozwijane modyfikowane itp. Początkujący programista nie do końca będzie czuł problemy poruszane w książce. Jeśli piszecie program i w którymś momencie stwierdzacie ze coraz trudniej połapać wam się w swoim projekcie zaczynacie zmieniać funkcje przebudowywać wszystko aby było czytelniejsze łatwiejsze do modyfikacji to znaczy ze jest to etap w którym powinniście przeczytać tego rodzaju publikacje. Pracuje samodzielnie nad projektem w c++ rozwijam go od roku dostosowując do wymagań klienta i po takim czasie natknąłem się niemal na wszystkie problemy które opisuje książka. Myślę że pomoże mi ona stać się bardziej efektywnym programista. Jestem w trakcie lektury i stwierdzam ze w programowaniu nie jest najtrudniejsze kodowanie funkcji itp ale samo projektowanie oprogramowania tak by było łatwe do utrzymania i czytelne.
  Ocena : 5 

Na chwilę obecną uważam, że jest to pozycja obowiązkowa dla każdego programisty (obiektowego).
  Ocena : 5 

Warto przeczytać, zwłaszcza jeśli programujesz od lat. Trzeba napisać trochę złego kodu, żeby w pełni docenić klasę tej książki :)
  Ocena : 5 

Bardzo dobra, bo przydatna i dobrze napisana książka. Mam nadzieję, że jak najwięcej osób z mojego otoczenia ją przeczyta, a to zrobi moją prace trochę łatwiejszą.
  Ocena : 5 

Książka znośna ;) Zdecydowanie przeznaczona dla nieco bardziej zaawansowanych programistów, którzy już troszkę kodu w życiu napisali. Z uwagi na, to że zaliczam się do tej grupy śmiało mogę ocenić książkę wysoko. Kilka cech "dobrego programisty" sam w sobie wykształciłem, ale autor wytknął mi wszystkie popełniane błędy ;] Uwaga! Książka nie nauczy nikogo pisać poprawnego kodu, nie nadaje się dla początkujących! (nie nadaje się, dla osób raczkujących w programowaniu).
  Ocena : 5 

Chyba pierwsza książka na polskim rynku podejmująca zagadnienia Code Quality. Każdy programista znajdzie w niej coś, co pomoże jemu a raczej kolegom pracującym na jego kodzie. Najlepiej opisany jest rozdział 17 "Zapachy kodu i heurystyki" gdzie zasady wypisane są punkt po punkcie. W pozostałych rozdziałach zasady schowane są w tekście pełnym rozważań i filozofii, oraz kodu źródłowego (za dużo tego jest). Wnikliwi mogą postudiować np. teorię komentowania kodu na 20 stronach. Chociaż nie rozumiem tytułu 17 rozdziału ani organizacji tej książki, to bardzo ją polecam.
  Ocena : 4 

Pół na pół. Ciekawe techniki, aczkolwiek niektóre zbyt przesadne. Autor też wbija nam swoje myśli - jest trochę apodyktyczny.
  Ocena : 4 

Książka dobra ale przeznaczona dla osób które programują od dłuższego czasu i znających Javę. Początkujący programiści nie wiele z niej wyniosą poza podstawowymi poradami o zwięzłości kodu i dobrych nazwach funkcji.
  Ocena : 4 

Niezła książka dla programistów OOP z małym/średnim doświadczeniem. Tylko 4 dlatego, że niektóre zagadnienia opisane w książce głęboko opierają się na Javie i jej frameworkach, więc są mało zrozumiałe dla programistów innych języków. Także ok. połowa książki jest dla wszystkich, druga dla Javowców z doświadczeniem :)
  Ocena : 3 

Książka nie jest warta swojej ceny. Nie ma w niej zbyt wiele treści, a tym bardziej "twardej" technicznej wiedzy, raczej są to luźne rozważania i przemyślenia, do których średnio zdolny programista dochodzi po roku intensywnej pracy. Książka zawiera kilka wartościowych rozdziałów, ale reszta to zapychacze. Ach jak proste byłoby życie programisty, gdyby wystarczyło pisać krótkie funkcje oraz nadawać odpowiednie nazwy zmiennym, aby otrzymać w efekcie dobrze zaprojektowany rozszerzalny system. Nawiasem mówiąc rozdział n/t systemów informatycznych to zaledwie kilkanaście stron, z czego znacząca część to pogadanka o budowie miast. W kilkunastu przypadkach autor odsyła w przypisach do wikipedii, zamiast porządnie wyjaśnić termin...Nie rozumiem potrzeby umieszczenia w załączniku B około 50 stron jakiegoś kodu java, jest to zwykłe marnotrawstwo papieru. Szczerze mówiąc więcej skorzystałem czytając darmowe materiały ze strony autora na temat technik OOP (z 2006 roku) niż z omawianej książki. Na domiar złego tekst jest ilustrowany kiepskimi rysunkami. Odradzam zakup.
  Ocena : 2 

Książka zawiera wiele poważnych błędów. Jest zrozumiała dla kogoś kto dobrze zna dane zagadnienie, ale zupełnie bezużyteczna dla kogoś kto chce się dopiero tego zagadnienia nauczyć. Próbuje się w niej tłumaczyć złożone mechanizmy takie jak AOP odnosząc się do konkretnych implementacji, ale w sposób który jest zupełnie niezrozumiały. Bariera znajomości technologii nie umożliwiłaby komuś kto nie zna takich technologii jak AspectJ, tudzież CGLIB na jakiekolwiek zrozumienie tematu. Ogólnie rzecz biorąc nie polecam!
  Ocena : 2 

Nie polecam książki osobom które mają styczność z programowaniem ponieważ nie nauczą się niczego nowego. Szkoda, że w większości przykładów jest pokazywany kod JAVA.
  Ocena : 1 

autor ma własne przekonania i na siłę próbuje je wepchnąć innym, komentarze są potrzebne, pakowanie wszystkiego w funkcje rozpycha kod a to także jest niekorzystne, komentarze w czasie kompilowania są pomijane natomiast funkcja stworzona w celu nie pisania komentarza zostaje i zajmuje miejsce w pamięci książka powinna się nazywać "Jak pisać niewydajny kod i nie wyjaśniać nikomu swoich intencji" oceniam tylko na podstawie rozdziału dostępnego online, reszta już mnie nie interesuje