Słowo wstępne (13)

Wstęp (15)

1. Wyrażenia regularne (19)

• Programowanie w praktyce (20)
• Implementacja (21)
• Omówienie (22)
• Alternatywy (24)
• Rozszerzanie (25)
• Podsumowanie (27)

2. Edytor delty w Subversion - interfejs jako ontologia (29)

• Kontrola wersji i transformacja drzewa (30)
• Prezentacja różnic pomiędzy drzewami (34)
• Interfejs edytora delty (35)
• Ale czy to jest sztuka? (40)
• Abstrakcja jako sport widowiskowy (43)
• Wnioski (45)

3. Najpiękniejszy kod, którego nigdy nie napisałem (47)

• Najpiękniejszy kod, jaki kiedykolwiek napisałem (47)
• Coraz więcej za pomocą coraz mniejszych środków (49)
• Perspektywa (54)
• Co to jest pisanie (57)
• Zakończenie (57)
• Podziękowania (59)

4. Wyszukiwanie (61)

• Na czas (61)
• Problem - dane z pamiętnika sieciowego (62)
• Problem - kto zażądał, czego i kiedy (70)
• Wyszukiwanie na dużą skalę (75)
• Podsumowanie (77)

5. Poprawny, piękny, szybki (w takiej kolejności) - lekcje z projektowania weryfikatorów XML (79)

• Znaczenie walidacji XML (79)
• Problem (80)
• Wersja 1. Naiwna implementacja (82)
• Wersja 2. Imitacja gramatyki BNF O(N) (83)
• Wersja 3. Pierwsza optymalizacja O(log N) (84)
• Wersja 4. Druga optymalizacja - nie sprawdzaj dwa razy (85)
• Wersja 5. Trzecia optymalizacja O(1) (87)
• Wersja 6. Czwarta optymalizacja - buforowanie (91)
• Morał (93)

6. Framework for Integrated Test - piękno poprzez delikatność (95)

• Acceptance Testing Framework w trzech klasach (96)
• Wyzwanie zaprojektowania środowiska (98)
• Otwarte środowisko (99)
• Jak prosty może być parser HTML (100)
• Podsumowanie (103)

7. Piękne testy (105)

• To niesforne wyszukiwanie binarne (106)
• Wstęp do JUnit (109)
• Rozprawić się z wyszukiwaniem binarnym (111)
• Podsumowanie (122)

8. Generowanie w locie kodu do przetwarzania obrazów (125)

9. Kolejność wykonywania operatorów (147)

• JavaScript (148)
• Tablica symboli (149)
• Tokeny (150)
• Kolejność (151)
• Wyrażenia (152)
• Operatory wrostkowe (152)
• Operatory przedrostkowe (154)
• Operatory przypisania (155)
• Stałe (155)
• Zakres (156)
• Instrukcje (157)
• Funkcje (160)
• Literały tablicowe i obiektowe (161)
• Rzeczy do zrobienia i przemyślenia (162)

10. Poszukiwanie szybszych metod zliczania bitów w stanie wysokim (163)

• Podstawowe metody (164)
• Dziel i zwyciężaj (165)
• Inne metody (167)
• Suma i różnica liczb ustawionych bitów w dwóch słowach (169)
• Porównywanie liczby ustawionych bitów w dwóch słowach (169)
• Zliczanie jedynek w tablicy (170)
• Zastosowania (175)

11. Bezpieczna komunikacja - technologia wolności (177)

• Początki (178)
• Rozwikłać tajemnicę bezpiecznego przesyłania wiadomości (180)
• Klucz to użyteczność (181)
• Podstawa (184)
• Zestaw testów (188)
• Działający prototyp (189)
• Oczyść, podłącz i używaj (190)
• Hakowanie w Himalajach (194)
• Niewidoczne ruchy ręką (199)
• Prędkość ma znaczenie (201)
• Prywatność komunikacji dla praw jednostki (202)
• Hakowanie cywilizacji (203)

12. Hodowanie pięknego kodu w języku BioPerl (205)

• BioPerl i moduł Bio::Graphics (206)
• Proces projektowania modułu Bio::Design (210)
• Rozszerzanie modułu Bio::Graphics (228)
• Wnioski i lekcje (232)

13. Projekt programu Gene Sorter (235)

• Interfejs użytkownika programu Gene Sorter (236)
• Podtrzymywanie dialogu z użytkownikiem przez internet (237)
• Nieco polimorfizmu (239)
• Filtrowanie w celu znalezienia odpowiedniego genu (242)
• Ogólna teoria pięknego kodu (243)
• Podsumowanie (246)

14. Jak elegancki kod ewoluuje wraz ze sprzętem - przypadek eliminacji Gaussa (247)

• Wpływ architektury komputerów na algorytmy macierzowe (248)
• Metoda dekompozycyjna (250)
• Prosta wersja (251)
• Podprocedura DGEFA biblioteki LINPACK (252)
• Procedura LAPACK DGETRF (255)
• Rekursywna dekompozycja LU (257)
• Procedura ScaLAPACK PDGETRF (260)
• Wielowątkowość w systemach wielordzeniowych (265)
• Słowo na temat analizy błędów i liczby operacji (267)
• Przyszłe kierunki badań (268)
• Literatura zalecana (269)

15. Długoterminowe korzyści z pięknego projektu (271)

• Moje wyobrażenie o pięknym kodzie (271)
• Wprowadzenie do biblioteki CERN (272)
• Zewnętrzne piękno (273)
• Piękno wewnętrzne (278)
• Podsumowanie (284)

16. Model sterowników jądra systemu Linux - korzyści płynące ze współpracy (285)

• Skromne początki (286)
• Redukcja do jeszcze mniejszych rozmiarów (290)
• Skalowanie do tysięcy urządzeń (293)
• Małe, luźno połączone obiekty (294)

17. Inny poziom pośredniości (297)

• Od kodu do wskaźników (297)
• Od argumentów funkcji do wskaźników argumentów (300)
• Od systemów plików do warstw systemów plików (303)
• Od kodu do języka konkretnej domeny (305)
• Multipleksacja i demultipleksacja (307)
• Na zawsze warstwy? (308)

18. Implementacja słownika w Pythonie - być wszystkim dla wszystkich (311)

• Wewnątrz słownika (313)
• Warunki specjalne (314)
• Kolizje (316)
• Zmiana rozmiaru (317)
• Iteracje i zmiany dynamiczne (318)
• Podsumowanie (319)
• Podziękowania (319)

19. Wielowymiarowe iteratory w NumPy (321)

• Kluczowe wyzwania w operacjach na N-wymiarowych tablicach (322)
• Modele pamięci dla tablicy N-wymiarowej (323)
• Początki iteratora NumPy (324)
• Interfejs iteratora (331)
• Wykorzystanie iteratora (332)
• Podsumowanie (336)

20. System korporacyjny o wysokim stopniu niezawodności dla misji Mars Rover NASA (337)

• Misja i Collaborative Information Portal (338)
• Wymagania misji (339)
• Architektura systemu (340)
• Studium przypadku - usługa strumieniowa (343)
• Niezawodność (346)
• Solidność (353)
• Podsumowanie (355)

21. ERP5 - projektowanie maksymalnej giętkości (357)

• Ogólne cele ERP (358)
• ERP5 (358)
• Podstawowa platforma Zope (360)
• Założenia ERP5 Project (364)
• Pisanie kodu dla ERP5 Project (365)
• Podsumowanie (368)

22. Łyżka dziegciu (371)

23. Programowanie rozproszone z zastosowaniem MapReduce (389)

• Motywujący przykład (389)
• Model programistyczny MapReduce (392)
• Inne przykłady MapReduce (393)
• Implementacja rozproszonego MapReduce (394)
• Rozszerzenia modelu (398)
• Wnioski (399)
• Literatura zalecana (400)
• Podziękowania (400)
• Dodatek: przykład algorytmu zliczającego słowa (400)

24. Piękna współbieżność (403)

• Prosty przykład: konta bankowe (404)
• Pamięć transakcyjna STM (406)
• Problem Świętego Mikołaja (414)
• Refleksje na temat Haskella (422)
• Wnioski (423)
• Podziękowania (424)

25. Abstrakcja składniowa - rozszerzenie syntax-case (425)

• Krótkie wprowadzenie do syntax-case (429)
• Algorytm rozwijania (431)
• Przykład (443)
• Wnioski (445)

26. Architektura oszczędzająca nakłady - obiektowy framework dla oprogramowania sieciowego (447)

• Przykładowa aplikacja - usługa rejestrowania (449)
• Zorientowany obiektowo projekt frameworku serwera rejestrowania (451)
• Implementacja sekwencyjnych serwerów rejestrowania (457)
• Implementacja współbieżnych serwerów rejestrowania (461)
• Wnioski (467)

27. Integracja partnerów biznesowych z wykorzystaniem architektury REST (469)

• Tło projektu (470)
• Udostępnianie usług klientom zewnętrznym (470)
• Przekazywanie usługi za pomocą wzorca fabryki (473)
• Wymiana danych z użyciem protokołów e-biznesowych (475)
• Wnioski (480)

28. Piękne debugowanie (481)

• Debugowanie debugera (482)
• Systematyczny proces (483)
• Szukany problem (485)
• Automatyczne wyszukiwanie przyczyny awarii (486)
• Debugowanie delta (488)
• Minimalizacja wejścia (490)
• Polowanie na usterkę (490)
• Problem prototypu (493)
• Wnioski (493)
• Podziękowania (494)
• Literatura zalecana (494)

29. Traktując kod jako esej (495)

30. Gdy ze światem łączy cię tylko przycisk (501)

• Podstawowy model projektu (502)
• Interfejs wejściowy (505)
• Wydajność interfejsu użytkownika (518)
• Pobieranie (518)
• Przyszłe kierunki rozwoju (519)

31. Emacspeak - kompletne dźwiękowe środowisko pracy (521)

• Tworzenie wyjścia mówionego (522)
• Włączanie mowy w Emacsie (523)
• Bezbolesny dostęp do informacji online (534)
• Podsumowanie (541)
• Podziękowania (544)

32. Kod w ruchu (545)

• O byciu "podręcznikowym" (546)
• Podobne wygląda podobnie (547)
• Niebezpieczeństwa wcięć (548)
• Poruszanie się po kodzie (549)
• Wykorzystywane przez nas narzędzia (550)
• Burzliwa przeszłość DiffMerge (552)
• Wnioski (554)
• Podziękowania (554)
• Literatura zalecana (554)

33. Pisanie programów dla Księgi (557)

• Niekrólewska droga (558)
• Ostrzeżenie dla nawiasofobów (558)
• Trzy w rzędzie (559)
• Śliskie nachylenie (561)
• Nierówność trójkąta (563)
• Meandrowanie (565)
• "No przecież!", znaczy się "Aha!" (566)
• Wnioski (567)
• Zalecana literatura (568)

Posłowie (571)

Autorzy (573)

Skorowidz (583)

• Tytuł: Piękny kod. Tajemnice mistrzów programowania
• Autor: Andy Oram, Greg Wilson
• Tytuł oryginału: Beautiful Code: Leading Programmers Explain How They Think
• ISBN: 978-83-283-3478-6, 9788328334786
• Data wydania: 2008-06-24
• Format: Ebook
• Identyfikator pozycji: szpppv
• Wydawca: Helion