Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00248 005433 13433324 na godz. na dobę w sumie
wyszukaj dokładnie | pobierz wtyczkę
Programowanie dla początkujących w 24 godziny. Wydanie III - ebook/pdf
Programowanie dla początkujących w 24 godziny. Wydanie III - ebook/pdf
Autor: , Liczba stron: 424
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-283-2940-9 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> webmasterstwo >> javascript - programowanie
Porównaj ceny (książka, ebook, audiobook).
Czytaj online.
Komentuj
Dziś mało kto potrafi obejść się bez komputera. Te niezwykle pożyteczne urządzenia służą do pracy i rozrywki, komunikowania się, diagnozowania chorób, zarządzania firmą, a nawet prowadzenia wojen. Właściwie trudno byłoby wyobrazić sobie dziedzinę, w której komputery i to, co potrafią, byłoby zbędne. Właśnie dlatego we współczesnym świecie umiejętność programowania jest bardzo cennym atutem. Zapotrzebowanie na programistów wciąż rośnie, a najlepsi w tym fachu mogą liczyć na niezwykle atrakcyjne warunki pracy.

Niniejszy samouczek pozwala przyswoić sobie podstawy programowania w ciągu 24 godzinnych lekcji, umożliwia solidne opanowanie podstaw i uczy poprawnego projektowania programów. Nie pominięto tu szczególnie ważnego przygotowania się do programowania ani zasad tworzenia oprogramowania w korporacjach, a równocześnie pokazano sposoby korzystania z najważniejszych technik programistycznych oraz kluczowe cechy najczęściej wykorzystywanych języków programowania.

W książce omówiono:

Programowania można się nauczyć - wystarczą 24 godziny!

Greg Perry- jest programistą i nauczycielem programowania od ponad dwudziestu lat. Jest dobrze znany jako osoba, która uczy solidnych podstaw programowania i potrafi mówić o tej dziedzinie w sposób niezwykle przystępny.
Dean Miller - od ponad dwudziestu lat jest autorem i redaktorem książek. Przyczynił się do wydania wielu bestsellerowych książek i serii w wydawnictwie Sams Publishing.
Znajdź podobne książki Ostatnio czytane w tej kategorii

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)

Gdzie kupić całą publikację:

Programowanie dla początkujących w 24 godziny. Wydanie III
Autor: ,
Sklep
Format
Cena
Helion.pl Helion.pl
ebook/pdf
59,00 zł
Idź do sklepu »

Opinie na temat publikacji:

Inne popularne pozycje z tej kategorii:

Czytaj również:

Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: