Darmowy fragment publikacji:
Tytuł oryginału: Sams Teach Yourself Beginning Programming in 24 Hours, Third Edition
Tłumaczenie: Tomasz Walczak
Projekt okładki: Studio Gravite / Olsztyn
Obarek, Pokoński, Pazdrijowski, Zaprucki
ISBN: 978-83-283-2939-3
Authorized translation from the English language edition: SAMS TEACH YOURSELF
BEGINNING PROGRAMMING IN 24 HOURS, Third Edition, ISBN 0672337002; by Greg Perry;
and Dean Miller; published by Pearson Education, Inc, publishing as SAMS Publishing. Copyright
© 2014 by Pearson Education
All rights reserved. No part of this book may be reproduced or transmitted in any form or by any
means, electronic or mechanical, including photocopying, recording or by any information storage
retrieval system, without permission from Pearson Education Inc.
Polish language edition published by HELION S.A. Copyright © 2017.
All rights reserved. No part of this book may be reproduced or transmitted in any form or by any
means, electronic or mechanical, including photocopying, recording or by any information storage
retrieval system, without permission from the Publisher.
Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej
publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną,
fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym
powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście
są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli.
Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje
były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie,
ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz
Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności za ewentualne szkody
wynikłe z wykorzystania informacji zawartych w książce.
Materiały graficzne na okładce zostały wykorzystane za zgodą Shutterstock Images LLC.
Wydawnictwo HELION
ul. Kościuszki 1c, 44-100 GLIWICE
tel. 32 231 22 19, 32 230 98 63
e-mail: helion@helion.pl
WWW: http://helion.pl (księgarnia internetowa, katalog książek)
Pliki z przykładami omawianymi w książce można znaleźć pod adresem:
ftp://ftp.helion.pl/przyklady/prpo24.zip
Drogi Czytelniku!
Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres
http://helion.pl/user/opinie/prpo24
Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję.
Printed in Poland.
• Kup książkę
• Poleć książkę
• Oceń książkę
• Księgarnia internetowa
• Lubię to! » Nasza społeczność
Spis treści
O autorach ................................................................................ 11
Podziękowania .......................................................................... 12
Wprowadzenie .......................................................................... 13
CZĘŚĆ I
Godzina 1. Praktyczne ćwiczenia z programowania .................................... 19
ZACZNIJ PROGRAMOWAĆ JUŻ DZIŚ
Przygotuj się do programowania ...............................................................................19
Co robi program komputerowy? ...............................................................................20
Często powtarzane mity na temat programowania ..........................................21
Istnieje już wiele programów ......................................................................................23
Programiści są poszukiwani na rynku pracy .......................................................23
Prawdziwa wartość programów ................................................................................23
Użytkownicy zwykle nie są właścicielami programów ...................................24
Udostępnianie programów komputerowych .......................................................24
Twój pierwszy program .................................................................................................26
Komentarze objaśniające kod .....................................................................................27
Wpisywanie własnego programu ..............................................................................29
Podsumowanie ...................................................................................................................31
Pytania i odpowiedzi .......................................................................................................32
Warsztaty ..............................................................................................................................32
Do czego potrzebne są programy? ............................................................................35
Programy, programy, wszędzie programy ............................................................38
Programy jako wskazówki ............................................................................................38
Podsumowanie ...................................................................................................................49
Pytania i odpowiedzi .......................................................................................................49
Warsztaty .............................................................................................................................. 49
Godzina 2. Proces i techniki ........................................................................ 35
Poleć książkęKup książkę4
Spis treści
Godzina 4. Pobieranie danych wejściowych
Godzina 6. Sterowanie programami ......................................................... 103
Godzina 3. Projektowanie programu .......................................................... 51
i wyświetlanie danych wyjściowych .......................................... 69
Dlaczego potrzebny jest projekt? ..............................................................................51
Umowa między użytkownikiem a programistą ..................................................52
Etapy projektowania .......................................................................................................53
Podsumowanie ...................................................................................................................65
Pytania i odpowiedzi .......................................................................................................65
Warsztaty ..............................................................................................................................66
Wyświetlanie danych na ekranie za pomocą JavaScriptu ..............................69
Przechowywanie danych ...............................................................................................71
Przypisywanie wartości .................................................................................................73
Pobieranie danych z klawiatury za pomocą metody prompt .......................75
Podsumowanie ...................................................................................................................82
Pytania i odpowiedzi .......................................................................................................83
Warsztaty ..............................................................................................................................83
Jeszcze o łańcuchach znaków ......................................................................................85
Wykonywanie obliczeń matematycznych w JavaScripcie ..............................89
W jaki sposób komputery wykonują obliczenia? ...............................................92
Używanie tabeli kodów ASCII .....................................................................................95
Przegląd metod ..................................................................................................................96
Podsumowanie .................................................................................................................100
Pytania i odpowiedzi .....................................................................................................100
Warsztaty ............................................................................................................................101
Porównywanie danych za pomocą instrukcji if ................................................103
Pisanie warunków ..........................................................................................................106
Pętle .......................................................................................................................................108
Podsumowanie .................................................................................................................116
Pytania i odpowiedzi .....................................................................................................116
Warsztaty ............................................................................................................................116
Godzina 5. Przetwarzanie danych z wykorzystaniem liczb i słów ................ 85
Poleć książkęKup książkę
Godzina 7. Narzędzia do debugowania .................................................... 119
Godzina 9. Pisanie algorytmów ................................................................. 149
CZĘŚĆ II
Godzina 8. Techniki programowania strukturalnego ................................ 135
Spis treści
5
PODSTAWY PROGRAMOWANIA
Pierwszy błąd ..................................................................................................................119
Wszystko zależy od precyzji .....................................................................................120
Pisz przejrzyste programy .........................................................................................124
Przećwicz debugowanie w JavaScripcie ..............................................................125
Dziennik konsoli JavaScriptu ....................................................................................129
Dodatkowe techniki debugowania ........................................................................130
Podsumowanie ................................................................................................................131
Pytania i odpowiedzi ....................................................................................................131
Warsztaty ...........................................................................................................................132
Programowanie strukturalne ...................................................................................135
Umieszczanie kodu w JavaScripcie w funkcjach ..............................................141
Testowanie programu .................................................................................................144
Profilowanie kodu .........................................................................................................145
Wróćmy do programowania .....................................................................................146
Podsumowanie ................................................................................................................146
Pytania i odpowiedzi ....................................................................................................146
Liczniki i akumulatory .................................................................................................150
Zmienne tablicowe ........................................................................................................152
Obliczanie łącznych wartości za pomocą akumulatorów ...........................155
Przestawianie wartości ...............................................................................................156
Sortowanie ........................................................................................................................157
Przeszukiwanie tablic ..................................................................................................161
Więcej o funkcjach .........................................................................................................166
Pętle zagnieżdżone ........................................................................................................170
Podsumowanie ................................................................................................................170
Pytania i odpowiedzi ....................................................................................................170
Warsztaty ...........................................................................................................................170
Poleć książkęKup książkę6
Spis treści
Godzina 10. Radość z programowania ....................................................... 173
Godzina 11. Zaawansowane techniki programowania ............................... 187
Zmienianie zdjęć na stronie .......................................................................................173
Rejestrowanie pozycji kursora myszy ..................................................................178
Dodawanie do witryny paska z powtarzanymi informacjami ...................180
Podsumowanie .................................................................................................................183
Pytania i odpowiedzi .....................................................................................................183
Warsztaty ............................................................................................................................184
Słaby punkt JavaScriptu ...............................................................................................187
Zapisywanie plików cookie ........................................................................................190
Wczytywanie plików cookie ......................................................................................192
Usuwanie utworzonych plików cookie .................................................................193
Podsumowanie .................................................................................................................197
Pytania i odpowiedzi .....................................................................................................197
Warsztaty ............................................................................................................................198
Wprowadzenie do Javy .................................................................................................204
Java udostępnia zawartość wykonywalną ..........................................................206
Automatyczne wykonywanie ....................................................................................208
Zawartość wykonywalna dostosowana do wielu systemów ......................208
Podsumowanie użytkowania Javy ..........................................................................210
Zacznij od niezależnego programu w Javie .........................................................211
Interfejs Javy .....................................................................................................................211
Kwestie bezpieczeństwa ..............................................................................................212
Wypróbuj Javę ..................................................................................................................213
Mechanizmy języka Java ..............................................................................................214
Przygotowania do rozpoczęcia .................................................................................218
Podsumowanie .................................................................................................................219
Pytania i odpowiedzi .....................................................................................................219
Warsztaty ............................................................................................................................220
CZĘŚĆ III PROGRAMOWANIE OBIEKTOWE Z UŻYCIEM JAVY
Godzina 12. Programowanie w Javie .......................................................... 203
Poleć książkęKup książkę
Godzina 13. Szczegółowe omówienie Javy ................................................. 221
Godzina 14. Java ma klasę .......................................................................... 237
Spis treści
7
Definiowanie danych w Javie ....................................................................................221
Operatory ...........................................................................................................................226
Sterowanie programem ..............................................................................................230
Od szczegółów do ogólnego poziomu ...................................................................234
Podsumowanie ................................................................................................................235
Pytania i odpowiedzi ....................................................................................................235
Warsztaty ...........................................................................................................................235
Używanie środowiska NetBeans do uruchamiania programów Javy ....237
Przejście do graficznego interfejsu użytkownika ............................................241
Java i programowanie obiektowe ...........................................................................243
Omówienie klas ...............................................................................................................244
Czy rozumiesz programowanie obiektowe? .....................................................246
Za wykonywanie zadań w klasach odpowiadają metody ............................246
Podsumowanie ................................................................................................................249
Pytania i odpowiedzi ....................................................................................................249
Warsztaty ...........................................................................................................................249
O pisaniu apletów Javy ................................................................................................251
Tworzenie apletu Javy .................................................................................................252
Umieszczanie apletu na stronie internetowej ..................................................258
Wyświetlanie apletu na stronie internetowej ..................................................259
Podsumowanie ................................................................................................................260
Pytania i odpowiedzi ....................................................................................................261
Warsztaty ...........................................................................................................................261
Programowanie w HTML-u .......................................................................................265
Prostszy przykład ..........................................................................................................269
Szybkie wprowadzenie do HTML-a .......................................................................271
Używanie stylów CSS do określania wyglądu tekstu .....................................274
Dodawanie grafiki do witryn za pomocą HTML-a ..........................................276
Podsumowanie ................................................................................................................277
Pytania i odpowiedzi ....................................................................................................278
Warsztaty ...........................................................................................................................278
INNE JĘZYKI PROGRAMOWANIA
CZĘŚĆ IV
Godzina 16. HTML5 i CSS3 ......................................................................... 265
Godzina 15. Aplety i strony internetowe .................................................... 251
Poleć książkęKup książkę8
Spis treści
Godzina 17. JavaScript i AJAX ..................................................................... 281
Godzina 18. Skrypty w PHP ......................................................................... 295
Wprowadzenie do AJAX-a ...........................................................................................281
Używanie obiektów typu XMLHttpRequest ........................................................285
Tworzenie prostej biblioteki AJAX-owej ..............................................................287
Tworzenie quizu z wykorzystaniem AJAX-a i opisanej biblioteki ............289
Podsumowanie .................................................................................................................293
Pytania i odpowiedzi .....................................................................................................293
Warsztaty ............................................................................................................................293
Czego potrzebujesz do programowania w PHP? ..............................................295
Podstawowe struktury ze skryptów PHP ............................................................297
Pętle .......................................................................................................................................301
Cegiełki języka PHP: zmienne, typy danych i operatory ...............................303
Używanie i tworzenie funkcji w PHP .....................................................................312
Praca z obiektami w języku PHP ..............................................................................316
Typowe zastosowania języka PHP ..........................................................................320
Podsumowanie .................................................................................................................321
Pytania i odpowiedzi .....................................................................................................321
Warsztaty ............................................................................................................................322
Wprowadzenie do języka C ........................................................................................325
Czego potrzebujesz do programowania w językach C i C++? .....................326
Spojrzenie na kod w C ...................................................................................................327
Dane w języku C ...............................................................................................................329
Funkcje w C ........................................................................................................................330
Operatory w C ...................................................................................................................336
Instrukcje sterujące w C są takie jak w JavaScripcie ......................................337
Nauka języka C++ ............................................................................................................337
Terminologia obiektowa .............................................................................................338
Podstawowe różnice między językami C i C++ .................................................338
Wprowadzenie do obiektów w języku C++ .........................................................340
Co dalej? ..............................................................................................................................345
Podsumowanie .................................................................................................................346
Pytania i odpowiedzi .....................................................................................................346
Warsztaty ............................................................................................................................347
Godzina 19. Programowanie w językach C i C++ ...................................... 325
Poleć książkęKup książkę
Godzina 20. Programowanie w języku Visual Basic 2012 ............................ 349
Godzina 21. C# i platforma .NET ................................................................ 363
Spis treści
9
Zawartość ekranu w środowisku Visual Basica ...............................................349
Tworzenie od podstaw prostej aplikacji .............................................................351
Inne uwagi związane z programowaniem w Visual Basicu ........................358
Następny krok .................................................................................................................360
Podsumowanie ................................................................................................................361
Pytania i odpowiedzi ....................................................................................................361
Warsztaty ...........................................................................................................................361
Przeznaczenie platformy .NET .................................................................................363
Środowisko CLR ..............................................................................................................364
Biblioteka FCL ..................................................................................................................365
Platforma przetwarzania równoległego .............................................................366
Środowisko DLR .............................................................................................................366
Język C# ..............................................................................................................................366
Podsumowanie ................................................................................................................374
Pytania i odpowiedzi ....................................................................................................374
Warsztaty ...........................................................................................................................374
Działy przetwarzania danych i IT ...........................................................................379
Stanowiska związane z komputerami ..................................................................383
Nazwy stanowisk ...........................................................................................................383
Ustrukturyzowane przeglądy ...................................................................................389
Przenoszenie programu do środowiska produkcyjnego .............................390
Konsulting .........................................................................................................................392
Podsumowanie ................................................................................................................393
Pytania i odpowiedzi ....................................................................................................393
Warsztaty ...........................................................................................................................393
Kwestie związane z rozpowszechnianiem aplikacji ......................................395
Korzystanie z systemu kontroli wersji .................................................................398
Podsumowanie ................................................................................................................399
Pytania i odpowiedzi ....................................................................................................399
Warsztaty ...........................................................................................................................399
BRANŻA PROGRAMISTYCZNA
CZĘŚĆ V
Godzina 22. Programowanie w firmach ..................................................... 379
Godzina 23. Rozpowszechnianie aplikacji ................................................... 395
Poleć książkęKup książkę10
Spis treści
Godzina 24. Przyszłość programowania ..................................................... 401
Przydatne narzędzia ......................................................................................................401
Czy programowanie przestanie być potrzebne? ..............................................404
Wymóg ciągłego dokształcania się .........................................................................407
Podsumowanie .................................................................................................................408
Pytania i odpowiedzi .....................................................................................................408
Warsztaty ............................................................................................................................409
Skorowidz .............................................................................. 411
Poleć książkęKup książkęGodzina 3.
Projektowanie programu
Programiści już na początku kariery uczą się cierpliwości. Zauważają, że aby program stał
się sukcesem, musi być właściwie zaprojektowany. Możliwe, że zetknąłeś się już z określe-
niem analiza i projektowanie systemów. Jest to nazwa nadana procesowi analizowania
problemu i projektowania na tej podstawie systemów. Z pewnością chcesz wrócić do prak-
tycznych ćwiczeń z programowania — wkrótce będziesz mieć ku temu okazję. Aby jed-
nak móc produktywnie programować, musisz najpierw zrozumieć znaczenie projektu.
W tej godzinie staramy się omówić najważniejsze aspekty projektowania programów i poka-
zać Ci, przez co przechodzą wydajni programiści przed rozpoczęciem pisania programów.
Oto najważniejsze zagadnienia omawiane w tej godzinie:
znaczenie projektu programu;
trzy kroki potrzebne do pisania programów;
definicja danych wyjściowych;
projektowanie w modelach „od ogółu do szczegółu” i „od szczegółu do ogółu”;
wyjaśnienie, w jaki sposób schematy blokowe i pseudokod pozwalają stosować
narzędzia RAD;
przygotowywanie się do ostatniego kroku w procesie programowania.
Gdy budowlańcy zaczynają stawiać dom, nie biorą młotka i nie zaczynają od zbijania
mebli kuchennych. Zanim będzie można zacząć prace, projektant musi zaprojektować
nowy dom. Wkrótce zobaczysz, że także program przed napisaniem trzeba zaprojektować.
Wykonawca musi najpierw ustalić, czego oczekuje inwestor, który zleca budowę. Niczego
nie można zbudować, dopóki kierownik budowy nie będzie miał w umyśle wyniku koń-
cowego. Dlatego inwestor musi się spotkać z architektem, by przedstawić mu swoje ocze-
kiwania co do wyglądu domu. Architekt pomaga klientowi podejmować decyzje, informując
go, co jest możliwe, a co nie jest. Na tym początkowym etapie zawsze istotna jest też cena,
ponieważ projektant i inwestor muszą osiągnąć w tej kwestii kompromis.
Gdy architekt opracuje już plany domu, wykonawca musi zaplanować, jakie zasoby będą
potrzebne do postawienia domu. Dopiero po ukończeniu projektu, uzyskaniu pozwoleń,
zapewnieniu finansowania, zakupieniu materiałów i zatrudnieniu pracowników można
rozpocząć fizyczny proces budowy. Im więcej wysiłku wykonawca włoży we wstępne prace,
tym szybciej będzie mógł potem zakończyć budowę domu.
Dlaczego potrzebny jest projekt?
Poleć książkęKup książkę52
Godzina 3. Projektowanie programu
Im więcej wstępnych prac projektowych wykonasz, tym szybciej ukończysz program.
Problem z budową domu przed przygotowaniem odpowiedniego projektu związany jest
z tym, że przyszli właściciele mogą chcieć wprowadzić poprawki na etapie, gdy zmiany
są już niemożliwe. Bardzo trudno jest dodać łazienkę pomiędzy dwiema sypialniami po
ukończeniu budowy. Celem jest więc uzgodnienie ostatecznej wersji domu przez wła-
ściciela i wykonawcę przed rozpoczęciem budowy. Gdy wszystkie zainteresowane strony
uzgodnią specyfikację, ryzyko późniejszych sporów jest małe. Im bardziej przejrzyste są
początkowe plany, tym mniej problemów pojawia się później, ponieważ wszystkie strony
wyraziły zgodę na te same projekty domu.
Oczywiście nie jest to książka poświęcona budowaniu domów, ale gdy piszesz większe
aplikacje, pamiętaj o podobieństwach między omawianymi dziedzinami. Nie należy siadać
do klawiatury i rozpoczynać wpisywania instrukcji w edytorze przed zaprojektowaniem
programu; podobnie budowniczy nie powinien podnosić młotka przed ukończeniem pro-
jektu domu.
Dzięki technologiom informatycznym programy komputerowe są łatwiejsze w modyfikacji
niż budynki. Jeśli pominiesz procedurę, na której zależy użytkownikowi, będziesz mógł
dodać ją później w łatwiejszy sposób niż pokój do gotowego domu. Mimo to dodawanie
elementów do programu nigdy nie jest tak łatwe jak pisanie kodu po poprawnym zapro-
jektowaniu aplikacji już za pierwszym razem.
Załóżmy, że przyjmujesz zlecenie od małej firmy, która chce ulepszyć swoją witrynę (po
ukończeniu wszystkich 24 lekcji będziesz lepiej rozumieć programowanie i nauczysz się
nawet tego, jak pisać programy sieciowe w Javie). Oczekiwane przez klienta zmiany
w witrynie wydają się proste. Firma chce, żebyś napisał interaktywne procedury w Javie
umożliwiające użytkownikom sprawdzenie przez internet stanu magazynu i wydruko-
wanie zamówienia z listą produktów, którą można przynieść do sklepu w celu dokona-
nia zakupu.
Po wysłuchaniu oczekiwań klienta uzgadniasz cenę za usługę, otrzymujesz zaliczkę, po-
bierasz pliki z kodem obecnych stron i udajesz się na kilka dni do domu, gdzie pracujesz.
Po tych kilku dniach wyczerpującej pracy przynosisz wspaniale przygotowane strony
internetowe do pokazania klientowi.
— Wyglądają dobrze — mówi klient. — Ale gdzie jest pole do wpisywania numerów
kart kredytowych? W jaki sposób użytkownik może zamówić produkty przez internet?
Dlaczego strona nie wyświetla produktów, które firma dopiero zamówiła i które nie są
jeszcze dostępne? I dlaczego są podane tylko ceny netto?
Umowa między użytkownikiem
a programistą
Poleć książkęKup książkę53
Etapy projektowania
Właśnie otrzymałeś bolesną lekcję związaną z umowami między użytkownikiem a pro-
gramistą. Użytkownicy kiepsko poradzili sobie z wyjaśnieniem swoich oczekiwań. Na ich
obronę można powiedzieć, że Ty też nie postarałeś się wydobyć z nich informacji o tym,
czego naprawdę potrzebują. Obie strony uznały, że wiesz, co masz zrobić, ale okazało
się to nieprawdą. Teraz widzisz, że pierwotna cena, jakiej zażądałeś, pokrywa tylko około
10 rzeczywistej pracy niezbędnej przy tym projekcie.
Zanim zaczniesz pracę i ją wycenisz, musisz ustalić, czego użytkownicy oczekują. Na-
uczenie się tego to jeden z aspektów nabywania doświadczenia w zakresie projektowania
programów. Musisz ustalić każdy szczegół, zanim będziesz mógł precyzyjnie wycenić swoją
pracę i zadowolić klientów.
Odpowiednia umowa między użytkownikiem a programistą jest niezbędna we
wszystkich obszarach programowania. Dotyczy to nie tylko programistów kon-
traktowych. Także jeśli pracujesz dla korporacji, przed rozpoczęciem prac musisz
uzyskać szczegółową specyfikację. Inni pracownicy korporacji, którzy będą korzy-
stać z danego systemu, muszą zatwierdzić spisane oczekiwania, tak by wszyscy od
początku wiedzieli, czego można się spodziewać. Jeżeli użytkownik później przyj-
dzie do Ciebie i zapyta, dlaczego nie dodałeś jakiejś funkcji, będziesz mógł odpowie-
dzieć: „Ponieważ nigdy na jej temat nie rozmawialiśmy; zatwierdziłeś specyfikację,
w której nie ma mowy o tej funkcji”.
Konserwacja programu, mająca miejsce po jego napisaniu, przetestowaniu i udostęp-
nieniu, to jeden z najbardziej czasochłonnych aspektów procesu programowania. Pro-
gramy są nieustannie aktualizowane, by odzwierciedlić nowe oczekiwania użytkowni-
ków. Czasem, jeśli program nie został poprawnie zaprojektowany przed jego napisaniem,
użytkownik nie będzie chciał z niego korzystać, dopóki ów program nie zacznie wyko-
nywać potrzebnych zadań.
Konsultanci z branży informatycznej szybko się uczą, aby przed rozpoczęciem progra-
mowania uzyskać akceptację projektu przez użytkownika (najlepiej na piśmie z podpisem).
Uzgodnienie przez użytkownika i programistów tego, co trzeba zrobić, zmniejsza ryzyko spo-
rów po zaprezentowaniu gotowego programu. Zasoby firmy są ograniczone. Nie ma czasu na
późniejsze dodawanie funkcji, które od początku powinny znajdować się w systemie.
Są trzy podstawowe etapy, przez które należy przejść w procesie pisania programu:
1. Definiowanie danych wyjściowych i przepływu danych.
2. Opracowanie logiki potrzebnej do uzyskania tych danych wyjściowych.
3. Napisanie programu.
Zauważ, że pisanie programu to ostatni krok w procesie tworzenia aplikacji. Nie jest to
tak dziwne, jak może się wydawać. Pamiętaj, że fizyczne stawianie domu to ostatni etap
w jego budowaniu. Przed jego rozpoczęciem bardzo istotne jest odpowiednie zaplano-
Etapy projektowania
Poleć książkęKup książkę54
Godzina 3. Projektowanie programu
Etap 1. Definiowanie danych wyjściowych
i przepływu danych
wanie prac. Odkryjesz, że samo wpisywanie wierszy programu to jeden z najłatwiej-
szych aspektów procesu programowania. Jeśli projekt jest dobrze przemyślany, pro-
gram niemal „sam się pisze”. Wprowadzanie kodu staje się jedynie formalnością.
Przed rozpoczęciem programowania musisz mieć dobre pojęcie o tym, co program powi-
nien generować i jakie dane wejściowe są niezbędne do uzyskania potrzebnych danych
wyjściowych. Podobnie jak budowniczy musi przed rozpoczęciem budowy domu znać
jego docelowy wygląd, programista przed przystąpieniem do pisania kodu musi wiedzieć,
jakie dane wyjściowe są oczekiwane. Wszystko, co program generuje i co widzi użyt-
kownik, jest uważane za dane wyjściowe, które należy zdefiniować. Musisz wiedzieć, jak
ma wyglądać każdy ekran programu i co znajdzie się na poszczególnych stronach wszyst-
kich drukowanych raportów.
Niektóre programy są małe, ale bez wiedzy o tym, dokąd zmierzasz, ukończenie pro-
gramu może zająć Ci więcej czasu, niż gdybyś najpierw szczegółowo określił dane wyj-
ściowe. Załóżmy, że chcesz napisać w JavaScripcie program, który umożliwia użytkowni-
kom witryny podanie danych kontaktowych. Najpierw należy przygotować listę wszystkich
pól, które program ma wyświetlać na ekranie. Trzeba nie tylko wymienić wszystkie pola,
ale też je opisać. W tabeli 3.1 znajdziesz szczegóły dotyczące pól z okna omawianego
programu.
TABELA 3.1. Pola, które może wyświetlać program do zarządzania danymi kontaktowymi
Pole
Typ
Opis
Lista przewijana
Wyświetla listę osób kontaktowych
Zawiera nazwisko osoby kontaktowej
Zawiera adres osoby kontaktowej
Zawiera miejscowość osoby kontaktowej
Zawiera województwo osoby kontaktowej
Zawiera kod pocztowy osoby kontaktowej
Zawiera numer telefonu domowego osoby kontaktowej
Zawiera numer telefonu komórkowego osoby kontaktowej
Zawiera adres e-mail osoby kontaktowej
Wyświetla listę możliwych etapów, na jakich może znajdować
się dana osoba kontaktowa (możliwe, że dopiero nawiązano
pierwszy kontakt z nią lub zaproponowano jej specjalną
dodatkową rozmowę)
Różne uwagi na temat osoby kontaktowej (na przykład o tym,
czy zakupiła coś wcześniej od firmy)
Lista
kontaktów
Nazwisko
Adres
Miejscowość
Województwo
Kod pocztowy
Telefon domowy
Telefon
komórkowy
Adres e-mail
Etap
Pole tekstowe
Pole tekstowe
Pole tekstowe
Pole tekstowe
Pole tekstowe
Pole tekstowe
Pole tekstowe
Pole tekstowe
Stałe wartości,
lista przewijana
Uwagi
Pole tekstowe
Poleć książkęKup książkęTABELA 3.1. Pola, które może wyświetlać program do zarządzania danymi kontaktowymi — ciąg dalszy
Etapy projektowania
55
Typ
Opis
Stałe wartości,
lista przewijana
Umożliwia użytkownikowi wyszukiwanie grup osób
kontaktowych na podstawie etapu (pozwala to na przykład
wyświetlić listę wszystkich osób, do których wysłano e-mail)
Umożliwia użytkownikowi modyfikację istniejących danych
osoby kontaktowej
Umożliwia użytkownikowi dodanie nowej osoby kontaktowej
Pole
Filtrowanie
kontaktów
Edytuj
Dodaj
OK
Przycisk
polecenia
Przycisk
polecenia
Przycisk
polecenia
Umożliwia użytkownikowi zamknięcie okna z osobami
kontaktowymi
Wiele pól wymienionych w definicji danych wyjściowych może być oczywistych. Pole
o nazwie Nazwisko oczywiście zawiera i pozwala wyświetlać nazwisko osoby kontaktowej.
Nie ma nic złego w tym, że coś jest oczywiste. Pamiętaj, że jeśli piszesz programy dla in-
nych osób (co zdarza się często), musisz uzyskać akceptację parametrów aplikacji. Jedną
z najlepszych metod jest zacząć od listy wszystkich pól tworzonego programu i upewnić
się, że użytkownik potwierdza, iż obejmuje ona wszystkie potrzebne pozycje. Możliwe,
że klient ma nietypowe potrzeby — na przykład chce dostępu do kontaktów z Twittera.
Dzięki rozmowie z klientem lepiej zrozumiesz, co powinieneś dodać do programu.
W dalszej części tej godziny, w podrozdziale „Narzędzia RAD”, zobaczysz, jak za pomocą
programów zbudować model ekranu z danymi wyjściowymi, który można pokazać
użytkownikom. Ten model razem z listą pól pozwala dwa razy sprawdzić, czy program
zawiera dokładnie to, czego użytkownik potrzebuje.
Okna na dane wyjściowe, na przykład ekran do wprowadzania danych w programie do
obsługi kontaktów, to także część definicji danych wyjściowych. Może się to wydawać
sprzeczne z intuicja, ale ekrany na dane wyjściowe wymagają wyświetlania przez program
pól na ekranie, dlatego należy zaplanować, gdzie umieścić te pola.
Tworzenie definicji danych wyjściowych to coś więcej niż etap wstępny projektowania
danych wyjściowych, ponieważ pozwala uzyskać wgląd w to, jakie elementy danych należy
rejestrować, obliczać i generować w programie. Ten etap pomaga też ustalić wszystkie
dane wejściowe potrzebne do wygenerowania danych wyjściowych.
Niektóre programy generują bardzo dużą ilość danych wyjściowych. Nie pomijaj
omawianego tu pierwszego i niezwykle ważnego etapu procesu projektowania
tylko dlatego, że ilość danych wyjściowych jest duża. Im więcej jest danych wyj-
ściowych, tym ważniejsze jest ich zdefiniowanie. Jest to stosunkowo prosty proces
(czasem nawet nudny), ale czasochłonny. Czas potrzebny na zdefiniowanie danych
wyjściowych może być porównywalny z czasem wpisywania programu. Jeśli jednak
pominiesz początkowe definiowanie danych wyjściowych, możesz stracić o wiele
więcej czasu.
Poleć książkęKup książkę56
Godzina 3. Projektowanie programu
Definicja danych wyjściowych obejmuje wiele stron szczegółowych informacji. Musisz
móc określić specyfikację wszystkich szczegółów problemu przed określeniem, jakich
danych wyjściowych będziesz potrzebować. Nawet przycisk poleceń i pola z przewija-
nymi listami to dane wyjściowe, ponieważ program je wyświetla.
Z godziny 1., „Praktyczne ćwiczenia z programowania”, wiesz, że dane trafiają do pro-
gramu, a ten zwraca znaczące informacje. Powinieneś przygotować spis wszystkich da-
nych przekazywanych do programu. Jeśli dodajesz kod w JavaScripcie do witryny, by
zwiększyć jej interaktywność, musisz wiedzieć, czy właściciele witryny chcą pobierać
dane od użytkowników. Zdefiniuj, jakie są to dane. Możliwe, że witryna umożliwia użyt-
kownikowi podanie nazwiska i adresu e-mail, pod który będzie można przesyłać coty-
godniowe wiadomości z ofertami. Czy firma chce pobierać od użytkowników dodatkowe
dane, na przykład adres zamieszkania, wiek lub dochód?
Projektowanie obiektowe
Z tego 24-godzinnego samouczka dowiesz się, czym jest programowanie obiektowe.
Podejście to polega na przekształcaniu wartości (na przykład nazw i cen) w obiekty,
które istnieją jako samodzielne jednostki w programach. Podstawy programowania
obiektowego opisaliśmy w części III, „Programowanie obiektowe z użyciem Javy”.
Parę lat temu kilku ekspertów od programowania obiektowego opracowało proces
projektowania programów obiektowych. Proces ten nazwano projektowaniem obiek-
towym. Projektowanie obiektowe to zaawansowana nauka określania danych, które
są potrzebne w programie, i definiowania tych danych w sposób odpowiedni dla
potrzeb programistów obiektowych. Jednym ze słynnych twórców projektowania
obiektowego był Grady Booch. To jego specyfikacje sprzed dwudziestu lat nadal po-
magają programistom obiektowym określać dane dla planowanych aplikacji i prze-
kształcać te dane w obiekty programów.
W godzinie 4., „Pobieranie danych wejściowych i wyświetlanie danych wyjściowych”,
dowiesz się, jak uwzględnić zdobytą wiedzę w programie. Zobaczysz, w jaki sposób program
żąda podania danych i wyświetla informacje na ekranie. Przetwarzanie wejścia – wyjścia
to najbardziej krytyczny aspekt aplikacji. Ważne jest, by pobrać wszystkie potrzebne dane
i zrobić to precyzyjnie.
W tej dyskusji na temat projektowania nadal czegoś brakuje. Znasz już wagę pobierania
danych. Masz świadomość , jak ważne jest zaprojektowanie danych wyjściowych w celu
ustalenia, co jest potrzebne. Jak jednak przejść od danych wejściowych do danych wyj-
ściowych? To następny krok w procesie projektowania. Musisz określić, jaki proces
przetwarzania jest potrzebny do wygenerowania danych wyjściowych na podstawie da-
nych wejściowych. Musisz przygotować właściwy przepływ danych i odpowiednie oblicze-
nia, tak by program operował danymi wejściowymi i generował poprawne dane wyjścio-
we. W ostatnich podrozdziałach z tej godziny opisaliśmy, jak opracować najważniejszą
część programu — logikę.
Poleć książkęKup książkęEtapy projektowania
57
Tworzenie prototypów
Wszystkie ekrany z danymi wyjściowymi, drukowane raporty i ekrany do wprowadzania
danych muszą być zdefiniowane wcześniej, abyś dokładnie wiedział, co jest potrzebne
w programach. Musisz też zdecydować, jakie dane zachować w plikach i jaki będzie ich
format. Wraz z postępami w edukacji programistycznej poznasz sposoby zapisywania
plików danych w potrzebnych formatach.
W trakcie zbierania danych należy przyjmować je od użytkowników w sensowny spo-
sób wymagający niewiele czasu. Prośby o dane powinny być przyjazne i niekłopotliwe.
W ich przygotowaniu pomocne mogą być tworzenie prototypów (opisane w następnym
punkcie) i narzędzia RAD.
W czasach, gdy sprzęt i czas korzystania z komputerów były kosztowne, proces projek-
towania systemów pod niektórymi względami był ważniejszy niż obecnie. Im więcej
czasu poświęcano na zaprojektowanie kodu, tym bardziej płynny był kosztowny proces
programowania. Obecnie jest to prawdą w mniejszym stopniu, ponieważ komputery są
tańsze i programiści mają dużo większą niż wcześniej możliwość zmiany zdania i dodania
opcji programu. Mimo to w pierwszej części tej godziny szczegółowo wyjaśniliśmy, dla-
czego przygotowanie projektu przed przystąpieniem do programowania jest tak ważne.
Podstawowy problem w podejściu wielu początkujących programistów polega na tym,
że w ogóle pomijają etap projektowania. Jest to przyczyną wielu kłopotów, takich jak
wspomniany wcześniej w tej godzinie, związany z tym, że firma oczekiwała od witryny
znacznie więcej, niż programista mógł sobie wyobrazić.
Choć projektowanie danych wyjściowych, danych wejściowych, a nawet logiki progra-
mu jest znacznie prostsze dzięki dostępnym obecnie narzędziom informatycznym i ich
niskim cenom, nadal trzeba zadbać o przygotowanie wstępnego projektu z danymi wyj-
ściowymi uzgodnionymi z użytkownikami. Przed przystąpieniem do pisania kodu mu-
sisz też określić wszystkie dane, jakie program ma zbierać. Jeśli tego nie zrobisz, narazisz
się na frustrację (niezależnie od tego, czy będziesz programistą kontraktowym czy etato-
wym w korporacji), ponieważ będziesz musiał stale dodawać funkcje, których użytkownicy
oczekują, ale o których nie poinformowali.
Jedną z zalet systemu operacyjnego Windows jest jego wizualny charakter. Przed po-
wstaniem tego systemu narzędzia programistyczne umożliwiały tylko tekstowe projekto-
wanie i implementowanie rozwiązań. Obecnie, gdy projektujesz ekran dla klienta, możesz
wybrać język programowania taki jak Visual Basic, narysować ekran i przeciągnąć na
niego obiekty (na przykład przycisk OK), z którymi użytkownik będzie wchodził w inte-
rakcje. Pozwala to szybko zaprojektować ekrany prototypowe, które można przesłać
użytkownikowi. Prototyp to model, a prototypowy ekran jest modelem tego, jak będzie
wyglądał ekran w gotowym programie. Gdy użytkownik zobaczy ekran, z którym ma
wchodzić w interakcje, będzie mu znacznie łatwiej ustalić, czy rozumiesz wymagania
stawiane programowi.
JavaScript (podobnie jak języki programowania dla systemu Windows takie jak Visual
C++ i Visual Basic) udostępnia narzędzia do tworzenia prototypów. Na rysunku 3.1 po-
kazaliśmy ekran do tworzenia programu w języku Visual Basic. Ekran zawiera wiele
Poleć książkęKup książkę58
Godzina 3. Projektowanie programu
RYSUNEK 3.1. Systemy do tworzenia programów, na przykład Visual Basic, udostępniają narzędzia
pozwalające w wizualny sposób tworzyć definicje danych wyjściowych
elementów; zwróć uwagę na panel Toolbox i projekt okna wyjściowego. Aby umieścić
kontrolki (na przykład przyciski poleceń i pola tekstowe) na formularzu reprezentującym
okno wyjściowe, programista musi tylko przeciągnąć daną kontrolkę z panelu Toolbox
na formularz. Tak więc by zbudować okno wyjściowe programu, programista musi je-
dynie przeciągnąć potrzebne kontrolki na formularz. Nie musi w tym celu napisać ani
jednego wiersza kodu.
Po umieszczeniu kontrolek w oknie formularza za pomocą narzędzia programistyczne-
go takiego jak Visual Basic można wyjść poza wyświetlanie formularza użytkownikom.
Formularz można skompilować (podobnie jak cały program) i umożliwić użytkownikom
interakcję z kontrolkami. Gdy użytkownik może korzystać z kontrolek, to nawet jeśli nie
prowadzi to do żadnych efektów, pozwala klientowi stwierdzić, czy programista zrozumiał
wymagania stawiane programowi. Użytkownik często zauważa, czy w programie czegoś
nie brakuje. Może też przedstawić sugestie pozwalające ułatwić poruszanie się po pro-
gramie z perspektywy użytkownika.
Poleć książkęKup książkęEtapy projektowania
59
Prototyp często jest tylko pustą powłoką, które nie robi nic oprócz symulowania
interakcji z użytkownikiem. Dopiero później formularz jest łączony z kodem.
Wraz z uzyskaniem akceptacji ekranów zadanie programisty dopiero się zaczyna,
jednak ekrany to punkt wyjścia, ponieważ musisz ustalić, czego użytkownicy oczeku-
ją, zanim będziesz mógł pójść dalej.
Narzędzia RAD
Bardziej zaawansowanym produktem do projektowania programów, umożliwiającym
definiowanie danych wyjściowych, przepływu danych i samej logiki, są narzędzia RAD
(ang. Rapid Application Development). Choć te narzędzia znajdują się jeszcze w powijakach,
zapewne w ciągu swej kariery będziesz z nich korzystać — zwłaszcza gdy staną się bardziej
popularne i tańsze.
RAD to proces szybkiego rozmieszczania kontrolek na formularzu (przebiega to podobnie
jak pokazaliśmy wcześniej na podstawie Visual Basica), łączenia tych kontrolek z danymi
i generowania fragmentów gotowego kodu. Pozwala to uzyskać w pełni funkcjonalną apli-
kację bez napisania choćby jednego wiersza kodu. Pod pewnymi względami systemy pro-
gramistyczne takie jak Visual Basic realizują wiele celów stawianych narzędziom RAD.
Gdy umieszczasz kontrolkę na formularzu ― co szczegółowo przedstawiliśmy w godzi-
nie 20., „Programowanie w języku Visual Basic 2012” ― Visual Basic obsługuje wszyst-
kie aspekty programistyczne potrzebne dla danej kontrolki. Nigdy nie musisz pisać żad-
nego kodu, by przycisk polecenia działał tak, jak powinien. Jedynym celem programisty
jest ustalenie, ile przycisków poleceń potrzeba w programie i gdzie należy je umieścić.
Omawiane narzędzia nie potrafią jednak czytać w myślach. Narzędzia RAD nie wiedzą,
że kliknięcie przez użytkownika określonego przycisku ma prowadzić do wydrukowania
raportu. Programiści są potrzebni do łączenia poszczególnych elementów ze sobą i z da-
nymi, a także do pisania szczegółowej logiki pozwalającej poprawnie przetwarzać dane.
Przed pojawieniem się tego rodzaju narzędzi do budowania programów programiści mu-
sieli pisać tysiące wierszy kodu (często w języku C), aby utworzyć prostą aplikację dla
systemu Windows. Teraz można przynajmniej szybko przygotować kontrolki i interfejs.
Możliwe, że któregoś dnia narzędzia RAD będą na tyle zaawansowane, że będą potrafiły
generować także logikę. Ale do tego czasu nie rzucaj pracy programisty, ponieważ wciąż
będzie zapotrzebowanie na Twoje usługi.
Naucz użytkowników, jak tworzyć prototypy ekranów! Do projektowania ekranów
nie jest potrzebna wiedza z zakresu programowania. Dzięki prototypom użytkowni-
cy będą mogli dokładnie pokazać Ci, czego chcą. Ponadto prototypy ekranów są
interaktywne. Oznacza to, że użytkownicy będą mogli klikać przyciski i wprowa-
dzać wartości w polach, choć w efekcie nic się nie stanie. Pomysł polega na tym,
by umożliwić użytkownikom wypróbowanie ekranów i upewnić się w ten sposób,
że klientom odpowiada rozmieszczenie i wygląd kontrolek.
Poleć książkęKup książkę60
Godzina 3. Projektowanie programu
Projektowanie programów metodą od ogółu do szczegółu
W dużych projektach wielu programistów stwierdza, że projektowanie metodą od ogółu
do szczegółu pomaga skoncentrować się na tym, co w aplikacji jest potrzebne, i ułatwia
szczegółowe opracowanie logiki koniecznej do uzyskania wyników programu. Projek-
towanie od ogółu do szczegółu (ang. top-down design) to proces rozbijania ogólnego pro-
blemu na coraz mniejsze części do momentu określenia wszystkich szczegółów. W tym
modelu określane są szczegóły potrzebne do wykonania zadania programistycznego.
Problem z tym podejściem polega na tym, że programiści zwykle go nie stosują. Prze-
ważnie posługują się odwrotnym modelem, czyli projektowaniem od szczegółu do
ogółu (ang. bottom-up design). Gdy ignorujesz projektowanie od ogółu do szczegółu,
obciążasz się koniecznością zapamiętania wszystkich potrzebnych szczegółów. Jeśli sto-
sujesz podejście od ogółu do szczegółu, szczegóły same się pojawiają. Nie musisz wtedy
martwić się o drobiazgi, ponieważ uzyskujesz szczegóły w wyniku stosowania omawia-
nego procesu.
Jednym z ważnych aspektów projektowania od ogółu do szczegółu jest to, że
zmusza do odłożenia szczegółów na później. Proces ten sprawia, że programista
przez możliwie długi czas myśli w kategoriach ogólnego problemu. Projektowa-
nie od ogółu do szczegółu pozwala utrzymać koncentrację. Jeśli stosujesz projek-
towanie od szczegółu do ogółu, narażasz się na to, że przestaniesz widzieć las zza
drzew. Zbyt szybko zajmiesz się wtedy szczegółami i utracisz z oczu podstawowe
wymagania stawiane programowi.
Oto trzyetapowy proces niezbędny w trakcie projektowania od ogółu do szczegółu:
1. Ustalenie ogólnego celu.
2. Rozbicie celu na bardziej szczegółowe elementy (dwa, trzy lub więcej). Zbyt duża
liczba szczegółów spowoduje, że niektóre z nich zostaną pominięte.
3. Odkładaj zajmowanie się szczegółami tak długo, jak to możliwe. Powtarzaj kroki 1.
i 2. do momentu, w którym nie zdołasz już rozbić podproblemów na mniejsze części.
Łatwiej zrozumiesz projektowanie od ogółu do szczegółu, jeśli przed przyjrzeniem się pro-
blemowi informatycznemu zastosujesz je do zadania z rzeczywistego świata. Omawiane
tu podejście jest przeznaczone nie tylko dla problemów programistycznych. Gdy już
opanujesz projektowanie od ogółu do szczegółu, będziesz mógł zastosować ten model
do dowolnego aspektu życia, który musisz szczegółowo zaplanować. Prawdopodobnie
najbardziej szczegółowym wydarzeniem, które człowiek może zaplanować, jest ślub. Dla-
tego jest to doskonały przykład odzwierciedlający, jak wygląda projektowanie od ogółu do
szczegółu w praktyce.
Co jest pierwszą rzeczą potrzebną, by wziąć ślub? Najpierw należy znaleźć potencjalną
partnerkę lub potencjalnego partnera (aby uzyskać pomoc w tym zakresie, będziesz po-
trzebować innej książki). Gdy przychodzi czas na planowanie ślubu, projektowanie od
ogółu do szczegółu jest najlepszym sposobem podejścia do zadania. Metodą, której nie
należy stosować, jest martwienie się najpierw szczegółami. A jednak wiele osób zaczyna
Poleć książkęKup książkę61
Etapy projektowania
właśnie od nich. Narzeczeni myślą wtedy najpierw o strojach, zespole, wystroju sali i po-
trawach serwowanych gościom na przyjęciu weselnym. Największy problem pojawiający
się przy próbie uwzględniania od początku wszystkich tego typu szczegółów polega na
tym, że wiele rzeczy przestaje być widocznych. Zbyt łatwo jest wtedy zapomnieć o nie-
których szczegółach i przypomnieć sobie o nich dopiero wtedy, gdy jest już za późno.
Dzieje się tak, ponieważ uwaga jest zajęta innymi detalami.
Jaki jest ogólny cel ślubu? W najbardziej ogólnym ujęciu można powiedzieć, że po prostu
„wziąć ślub”. Jeśli odpowiadasz za zaplanowanie ślubu, ogólny cel „wziąć ślub” zapewni
Ci właściwy kierunek. Załóżmy, że na najwyższym poziomie cel to właśnie „wziąć ślub”.
Ogólny cel pomaga Ci utrzymać koncentrację. Mimo swej nadmiarowej natury cel
„wziąć ślub” pozwala zrezygnować z uwzględniania takich szczegółów jak pla-
nowanie miesiąca miodowego. Jeśli nie odgraniczysz rozwiązywanego problemu
od innych zadań, możesz zacząć zajmować się niepotrzebnymi drobiazgami i, co
ważniejsze, pominąć istotne szczegóły. Jeżeli planujesz zarówno ślub, jak i miesiąc
miodowy, opracuj dwa projekty od ogółu do szczegółu lub uwzględnij podróż
poślubną w najbardziej ogólnym celu. Plan ślubu dotyczy tylko tego wydarzenia
(ceremonii zaślubin i wesela), natomiast nie powinien uwzględniać szczegółów
miesiąca miodowego. Zajęcie się szczegółami podróży poślubnej możesz pozosta-
wić partnerce lub partnerowi, dzięki czemu może czekać Cię niespodzianka. W koń-
cu masz wystarczająco dużo pracy z planowaniem ślubu, prawda?
Teraz, gdy wiesz już, dokąd zmierzasz, zacznij rozbijać ogólny cel na dwa lub trzy bar-
dziej szczegółowe punkty. W jakich kolorach zrobić wystrój sali, kogo zaprosić na we-
sele, co z opłatami dla księdza… — eh, szczegółów jest za dużo! W projektowaniu od
ogółu do szczegółu chodzi o to, by jak najdłużej odkładać zajmowanie się drobiazgami.
Nie spiesz się. Gdy zauważysz, że rozbijasz problem z danego poziomu na więcej niż trzy
lub cztery części, zapewne zanadto się spieszysz. Poczekaj ze szczegółami. Cel „wziąć
ślub” można rozbić na dwa podstawowe komponenty — ceremonię zaślubin i przyjęcie
weselne.
Następny krok projektowania od ogółu do szczegółu polega na podzieleniu nowych kom-
ponentów na części. W ramach ceremonii należy uwzględnić ludzi i miejsce. W przypadku
wesela należy ustalić menu, ludzi i miejsce. Ludzie związani z ceremonią to goście, narze-
czeni i obsługa (ksiądz, organista i tak dalej, ale tymi szczegółami zajmiesz się później).
Na razie nie martw się kwestiami związanymi z czasem. Celem projektowania od
ogółu do szczegółu jest uzyskanie (ostatecznie) wszystkich potrzebnych szczegó-
łów, a nie uporządkowanie ich w kolejności. Musisz wiedzieć, dokąd zmierzasz,
a także co jest potrzebne. Dopiero potem możesz zastanowić się nad tym, jak
szczegóły są powiązane ze sobą i jaki jest ich porządek chronologiczny.
Poleć książkęKup książkę62
Godzina 3. Projektowanie programu
Ostatecznie uzyskasz kilka stron szczegółów, których nie da się już podzielić. Prawdo-
podobnie otrzymasz szczegóły związane między innymi z potrawami weselnymi (na przy-
kład orzeszkami do podgryzania). Jeśli zaczniesz od razu wypisywać takie szczegóły, wiele
z nich może Ci umknąć.
Teraz przejdź do bardziej informatycznego problemu. Załóżmy, że otrzymałeś zadanie
napisania dla firmy programu kadrowo-płacowego. Czego wymaga taki program? Możesz
zacząć od wymienienia szczegółów takiej aplikacji:
drukowanie czeków z wypłatami,
obliczanie podatków państwowych,
obliczanie podatków lokalnych.
Co złego jest w tym podejściu? Jeśli odpowiedziałeś, że zbyt wczesne przechodzenie do
szczegółów, masz rację. Najlepiej zacząć od ogólnego poziomu. Najbardziej ogólnym celem
programu kadrowo-płacowego może być „opracować listę płac”. Ten ogólny cel pozwala
pominąć inne szczegóły programu (nie trzeba uwzględniać przetwarzania księgi głównej,
chyba że jakaś część systemu płacowego aktualizuje plik z księgą główną) i skoncentrować
się na rozwiązywanym problemie.
Przyjrzyj się rysunkowi 3.2. Może to być pierwsza strona projektu związanego z listą
płac i uzyskanego metodą od ogółu do szczegółu. Każdy program płacowy musi obejmować
mechanizmy do wprowadzania, usuwania i modyfikowania informacji o pracownikach
— imienia i nazwiska, adresu, dni zwolnienia itd. Jakie jeszcze szczegółowe dane o pra-
cownikach są potrzebne? Na tym etapie nie należy się tym zajmować. Projekt nie jest
jeszcze do tego gotowy.
RYSUNEK 3.2. Pierwsza strona uzyskanego metodą od ogółu do szczegółu projektu programu kadrowo-
płacowego obejmuje szczegóły z najwyższego poziomu
Czeka Cię jeszcze długa droga do ukończenia projektu związanego z płacami. Rysunek 3.2
to pierwszy etap. Musisz kontynuować dzielenie poszczególnych komponentów do mo-
mentu pojawienia się szczegółów.
Dopiero gdy razem z użytkownikami ustalicie wszystkie potrzebne szczegóły (za pomocą
projektowania od ogółu do szczegółu), możesz zdecydować, jak powinny one wyglądać.
Poleć książkęKup książkęEtapy projektowania
63
Etap 2. Tworzenie logiki
Gdy razem z użytkownikami uzgodnicie cele i dane wyjściowe programu, reszta zależy
od Ciebie. Twoje zadanie polega na tym, by na podstawie definicji danych wyjściowych
ustalić, jak sprawić, aby komputer wygenerował te dane. Przyjrzałeś się ogólnemu pro-
blemowi i rozbiłeś go na szczegółowe instrukcje, które komputer może wykonać. Nie
oznacza to, że jesteś już gotowy do pisania programu — wprost przeciwnie. Teraz przy-
szedł czas na opracowanie logiki, która wygeneruje dane wyjściowe.
Definicja danych wyjściowych dobrze opisuje, co program ma robić. Teraz musisz zde-
cydować, jak ma się to odbywać. Musisz uporządkować ustalone szczegóły, by operacje
odbywały się w określonym porządku chronologicznym. Ponadto musisz ustalić, jakie de-
cyzje program musi podejmować i jakie operacje mają wynikać z poszczególnych decyzji.
W pozostałej części tego 24-godzinnego samouczka opanujesz dwa ostatnie kroki roz-
wijania programów. Zdobędziesz wgląd w to, jak programiści piszą i testują programy
po opracowaniu definicji danych wyjściowych i zatwierdzeniu specyfikacji przez użyt-
kowników.
Dopiero gdy opanujesz programowanie, będziesz mógł nauczyć się wbudowywać
logikę w program. Musisz jednak przygotować logikę przed napisaniem programu,
by móc przejść od etapu definicji danych wyjściowych i wejściowych do kodu
aplikacji. Jest to problem „jajka i kury”, z którym zmaga się wielu początkujących
programistów. Gdy zaczniesz pisać własne
Pobierz darmowy fragment (pdf)