1954-56 John Backus wraz zespołem inżynierów IBM...

Materiały uzupełniające do wykładów z Języków Programowania II

Języki Programowaniamateriały uzupełniające do wykładów

19 maj, 2006

Wojciech Sobieski

Uniwersytet Warmińsko-MazurskiWydział Nauk Technicznych

Katedra Mechaniki i Podstaw Konstrukcji Maszyn10-957 Olsztyn, ul. M. Oczapowskiego 11.

tel.: (89) 5-23-32-40fax: (89) 5-23-32-55

[email protected]

Niniejszy dokument nie zawiera tekstów aktorskich lecz jest jedynie

kompilacją różnych materiałów internetowych, powstałą w okresie

opracowywania zakresu tematycznego przedmiotu Języki Programowania II

(lata 2001-2003), realizowanego na specjalności Inżynierskie Zastosowania

Komputerów WNT UWM w Olsztynie. Na podstawie zebranych materiałów

(przedstawionych w opracowaniu oraz innych) opracowany został autorski

cykl wykładów do tego przedmiotu.

Olsztyn ©2006

1/64

mailto:[email protected]


Spis treści 1 Historia rozwoju komputerów..........................................................................................................3

1.1 Od Starożytności do Średniowiecza......................................................................................... 3 1.2 Wiek XVII i XVIII................................................................................................................... 4 1.3 Charles Babbage (1791 - 1871)................................................................................................ 5 1.4 Przełom XIX i XX wieku......................................................................................................... 6 1.5 Początek XX wieku.................................................................................................................. 7 1.6 Pierwsze komputery..................................................................................................................8 1.7 John von Neumann (1903 - 1957) ........................................................................................... 9 1.8 Komputer typu PC.................................................................................................................... 9 1.9 Kronika................................................................................................................................... 10

2 Języki programowania....................................................................................................................17 2.1 Rozwój programowania..........................................................................................................17 2.2 Generacje języków programowania........................................................................................19 2.3 Podstawowe definicje............................................................................................................. 20 2.4 Środowisko programistyczne..................................................................................................22 2.5 Etapy kompilacji..................................................................................................................... 23 2.6 Podział języków programowania............................................................................................24 2.7 Przegląd języków programowania..........................................................................................25

3 Elementy języków programowania................................................................................................ 31 3.1 Podstawowe cechy języków programowania:........................................................................ 31 3.2 Zmienne i stałe........................................................................................................................36 3.3 Wyrażenia............................................................................................................................... 37 3.4 Instrukcje................................................................................................................................ 39 3.5 Wyjątki....................................................................................................................................45

4 Styl programowania........................................................................................................................46 4.1 Elementy stylu programowania.............................................................................................. 46 4.2 Metody testowania programów.............................................................................................. 50

5 Algorytmy.......................................................................................................................................51 5.1 Rodzaje algorytmów............................................................................................................... 51 5.2 Rodzaje zapisu algorytmów....................................................................................................51 5.3 Schematy blokowe..................................................................................................................52 5.4 Zasady tworzenia schematów blokowych:............................................................................. 53 5.5 Etapy rozwiązywania problemów:..........................................................................................53 5.6 Realizacja pętli i instrukcji warunkowych..............................................................................54 5.7 Przykłady schematów blokowych:......................................................................................... 55 5.8 Poprawność algorytmów.........................................................................................................56

6 Technologia programowania.......................................................................................................... 58 6.1 Fazy powstawania programu komputerowego:...................................................................... 58 6.2 Rodzaje programowania......................................................................................................... 62

2/64


1 Historia rozwoju komputerów.

Ludzkość wytwarza coraz więcej informacji. Tak wiele, że jej przetwarzanie, czyli pamiętanie, klasyfikowanie, poszukiwanie, obrazowanie i zestawianie jest ponad ludzkie siły. Dlatego tak duże znaczenie osiągnęły "maszyny", które radzą sobie z tym zadaniem lepiej i szybciej od człowieka - komputery.

Komputery, czyli maszyny liczące (z ang. compute - obliczać) mają więcej lat niż się na ogół przypuszcza. Za przodków komputera uznać bowiem należy wszystkie urządzenia służące do liczenia.

1.1 Od Starożytności do Średniowiecza.

W wykopaliskach między Mezopotamią i Indiami odnaleziono ślady stosowanych już w X wieku p.n.e. systematycznych metod znajdowania wyniku najprostszych operacji za pomocą specjalnie przygotowanych i poukładanych kamieni. Początkowo kamienie układano w rzędach na piasku tworząc w ten sposób plansze obliczeniowe, które nazywamy abakami (lub abakusami). Później zaczęto nawlekać kamienie na pręty, tworząc liczydła, czyli kompletne i przenośne przyrządy do obliczeń. W obu przypadkach, abakusa i liczydła, stan obliczeń określało rozmieszczenie elementów ruchomych na piasku lub na prętach. Liczydła przeżywały swój renesans w wiekach średnich. Wtedy na przykład ukształtował się japoński soroban w swej obecnej postaci. Jest on jeszcze dzisiaj dość powszechnie stosowanym liczydłem w Japonii. Soroban - jak każde liczydło - ma wady, które zostały naprawione częściowo w kalkulatorze, a ostatecznie dopiero w komputerach. Służy on bowiem tylko do odnotowania bieżących wyników obliczeń, gdyż nie ma w nim miejsca ani na pamiętanie wyników pośrednich, ani na pamiętanie kolejno wykonywanych działań.

Rys. 1. Starożytna figurka przedstawiająca człowieka z abacusem.

Wiemy, że Leonardo da Vinci był geniuszem, którego pomysły wykraczały daleko poza jego epokę, ale mało kto wie, że próbował on również skonstruować maszynę liczącą. 13 marca 1967 roku amerykańscy naukowcy pracujący w Madrycie w Bibliotece Narodowej Hiszpanii napotkali dwie nieznane dotąd prace Leonarda da Vinci nazwane "Codex Madrid". Dotyczyły one maszyny liczącej. Dr Roberto Guatelli znany ekspert w dziedzinie twórczości Leonarda, tworzący także repliki jego prac postanowił razem ze swoimi asystentami odtworzyć również i tą maszynę. Dokonano tego w 1968 r. jednak dzisiejsze dzieje tej repliki są nieznane i nie wiadomo gdzie ona się znajduje. Specjaliści zarzucali Guatellemu, że w swojej rekonstrukcji nadmiernie kierował się intuicją i współczesną wiedzą oraz, że wyszedł poza projekt Leonarda. Tak więc Leonardo da Vinci - geniusz epoki renesansu wniósł również wkład w rozwój maszyn liczących.

3/64


Rys. 2. Na zdjęciach: oryginalne zapiski Leonarda da Vinci oraz replika maszyny jego pomysłu

1.2 Wiek XVII i XVIII.

Na początku XVII wieku John Neper opublikował najpierw swoje dzieło o logarytmach a następnie przedstawił system wspomagający wykonywanie mnożenia, zwany pałeczkami Nepera. Genialność tego systemu polegała na sprowadzeniu mnożenia do serii dodawań. Pomysł Nepera wykorzystało wielu konstruktorów urządzeń liczących, jemu współczesnych i żyjących po nim.

Za twórcę pierwszej w historii mechanicznej maszyny do liczenia jest uznawany Wilhelm Schickard (1592 - 1635), który przez długie lata był zupełnie zapomniany. Schickard opisał projekt swojej czterodziałaniowej maszyny, wykorzystując udoskonalone pałeczki Nepera w postaci walców, w liście do Keplera, któremu miała ona pomóc w jego astronomicznych (dosłownie i w przenośni) rachunkach. Niestety jedyny zbudowany egzemplarz maszyny spłonął w niewyjaśnionych okolicznościach, a dzisiejsze jej repliki zostały odtworzone dopiero niedawno na podstawie opisu z listu Keplera.

W XVII wieku żyli i tworzyli wielcy matematycy Gottfried Wilhelm Leibniz (1646 - 1716) i Blaise Pascal (1623 - 1662). Pascal zainteresował się zbudowaniem maszyny liczącej z myślą o dopomożeniu swojemu ojcu, który był poborcą podatkowym. Wyprodukowano około 50 egzemplarzy Pascaliny - maszyny według pomysłu Pascala. Kilka egzemplarzy istnieje w muzeach do dzisiaj; część z nich była przeznaczona do obliczeń w różnych systemach monetarnych, a część - dla różnych miar odległości i powierzchni (z przeznaczeniem dla geodetów). Pascal który zbudował maszynę wykonującą tylko dwa działania (dodawanie i odejmowanie) przez ponad trzysta lat uchodził niesłusznie za wynalazcę pierwszej mechanicznej maszyny do liczenia. Schickard i Pascal wprowadzili w swoich maszynach mechanizm do przenoszenia cyfr przy dodawaniu i odejmowaniu. Obie maszyny miały także pewne możliwości zapamiętywania niektórych wyników pośrednich. Leibniz odkrył na nowo pochodzący ze starożytnych Chin system dwójkowy (zwany także binarnym) do zapisu liczb. Przypisuje się jemu także zbudowanie pierwszej mechanicznej maszyny mnożącej. Chociaż w tym czasie istniała już Pascalina i Leibniz miał możność zapoznania

4/64


się z nią w Paryżu, projekt swojej "żywej ławy do liczenia" opisał przed pierwszą wizytą w Paryżu. W maszynie tej wprowadził wiele części, które zostały użyte w późniejszych maszynach biurowych. Maszyny Schickarda, Pascala, i Leibniza wymagały od użytkownika manualnej pomocy w wielu czynnościach związanych z kolejnymi krokami obliczeń. Za ich pomocą nie było jeszcze można w pełni automatycznie i w całości wykonać prostego działania na dwóch liczbach.

Rys. 3. Z lewej: pascalina; z prawej: maszyna Laibnizta.

W tym miejscu wypada wspomnieć o udziale naszego rodaka w dziele tworzenia maszyn liczących. Abraham Stern (1769 - 1842), z zawodu zegarmistrz, wykonał serię maszyn, które poza czterema działaniami podstawowymi, wyciągały także pierwiastki kwadratowe. Jedna z jego maszyn, raz uruchomiona, potrafiła wykonać za pomocą mechanizmu zegarowego wszystkie operacje bez ingerencji człowieka. Maszyny skonstruowane przez Sterna okazały się jednak mało praktyczne ze względu na wyjątkowo delikatną budowę.

1.3 Charles Babbage (1791 - 1871).

Za najwybitniejszego twórcę maszyn liczących, żyjącego przed erą elektroniczną, uważa się Anglika Charlesa Babbage'a.

Swoją pierwszą maszynę nazwaną maszyną różnicową, (gdyż wykonywała obliczenia metodą różnicową), konstruował przez ponad 10 lat. Trapiony jednak wieloma kłopotami rodzinnymi i finansowymi oraz nie mogąc do końca porozumieć się ze swoim głównym wykonawcą - konstruktorem Clementem zaprzestał dalszych prac nad nią w 1842 roku. Zmontowaną część maszyny (podobno nadal sprawną) można oglądać w Muzeum Nauk w Londynie. Należy dodać, że w odróżnieniu od maszyn Leibniza i Pascala, po ręcznym ustawieniu początkowego stanu, dalsze działania maszyny różnicowej nie wymagają już żadnej ingerencji użytkownika poza kręceniem korbą. Prace Babbage'a zainspirowały wielu jemu współczesnych, którzy jak na przykład Szwedzi George i Edward Scheutzowie, często z większym powodzeniem ukończyli swoje, może mniej ambitne ale nadal praktyczne konstrukcje maszyn różnicowych.

Ale Babbage nie poprzestał na próbie skonstruowania maszyny różnicowej. Marzył o maszynie, która mogłaby rozwiązywać bardziej złożone zadania. Tak narodził się jeszcze w trakcie prac nad maszyną różnicową pomysł zbudowania maszyny analitycznej, którym Babbage żył do śmierci. Było to przedsięwzięcie czysto abstrakcyjne - przewidywane przeszkody techniczne i trudności finansowe nie pozwoliły nawet na rozpoczęcie prac konstrukcyjnych. W projekcie Babbage zawarł jednak wiele pomysłów zrealizowanych dopiero we współczesnych komputerach. Między innymi rozdzielił pamięć (zwaną magazynem) od jednostki liczącej (młyna), czyli miejsce przechowywania danych od jednostki wykonującej na nich działania. Obie te części maszyny analitycznej miały być

5/64


sterowane za pomocą dodatkowego urządzenia kontrolnego, które otrzymywało polecenia na kartach perforowanych, udoskonalonych i rozpowszechnionych przez Jacquarda do programowania maszyn tkackich. Można więc uznać maszynę analityczną Babbege'a za pierwszy pomysł kalkulatora sterowanego programem zewnętrznym.

Rys. 4. Maszyna Babbaga.

Opis działania maszyny analitycznej trafił w ręce Ady ( jej pełne nazwisko: Ada Augusta hrabina Lovelace), znanej w owych czasach z błyskotliwego umysłu. Urzeczona doskonałością projektu uważała, że... " maszyna analityczna tkać będzie wzory algebraiczne, tak jak krosna Jacquarda tkają licie i kwiaty...".

Nie czekając na skonstruowanie maszyny (czego i tak by nie doczekała), Ada zajęła się sporządzaniem opisów jej używania do rozwiązywania konkretnych zadań obliczeniowych. Opisy te nazwano by dzisiaj programami, dlatego uważa się ją za pierwszą programistkę komputerów. Dla uczczenia zasług Ady na tym polu nazwano jej imieniem jeden z najbardziej uniwersalnych języków programowania.

1.4 Przełom XIX i XX wieku.

Koniec XIX wieku był początkiem rozwoju urządzeń mechanograficznych, których głównym przeznaczeniem było usprawnienie rachunków statystycznych, księgowych i biurowych. Zaczęło się w Stanach Zjednoczonych od Hermana Holleritha, który postanowił zautomatyzować prace statystyczne związane ze spisem ludności przeprowadzanym wtedy w Stanach co dziesięć lat. Hollerith sięgnął po elektryczność, jako źródło impulsów i energii, rozwinął postać karty perforowanej, na której zapisywano dane i zbudował elektryczny czytnik - sorter kart. Olbrzymim sukcesem Holleritha okazał się spis 1890 roku, którego wyniki zostały całkowicie opracowane za pomocą jego urządzeń na podstawie danych zebranych na jego kartach. W następnych latach Hollerith dostarczał lub wypożyczał swoje urządzenia do przeprowadzenia spisów w wielu krajach, w tym także w Europie, między innymi w Rosji. Na przełomie XIX i XX wieku powstało wiele firm, które początkowo oferowały maszyny sterowane kartami perforowanymi i z latami zyskiwały na swojej potędze a wiele z nich przetrwało do dzisiaj, jak na przykład IBM, Bull, Remington - Rand, Burroughs, a także NCR (kasy), i Bell (telefony).

Udoskonalona i znormalizowana karta perforowana przez wiele dziesięcioleci była uniwersalnym nośnikiem informacji, a pierwsze maszyny mechaniczne do przetwarzania danych zapoczątkowały stale rosnący popyt na przetwarzanie informacji. Wniosło to także zmiany w stosunkach

6/64


międzyludzkich, a w szczególności między państwem (posiadaczem maszyn do obróbki informacji) i obywatelem.

1.5 Początek XX wieku.

Wśród modeli obliczeń powstałych w pierwszej połowie XX wieku największą popularność zdobyły maszyny Turinga. W swojej fundamentalnej pracy z 1936 roku, Alan Turing bardzo przystępnie opisał tok mylenia prowadzący od obliczeń wykonywanych ręcznie do obliczeń wykonywanych przez bardzo prostą maszynę. Oto jej opis.

Obliczenia ręczne są najczęściej wykonywane na pokratkowanej kartce papieru, której pojedyncze kratki są wypełnione cyframi i symbolami działań. Dysponujemy tylko skończoną liczbą znaków ( cyfr, np. 0 oraz 1 i symboli działań ), które mogą być wpisywane w kratki. To, co robimy w ustalonej chwili, zależy od znaków, które obserwujemy i od działania, jakie podjęliśmy. Można przyjąć, że liczba kratek obserwowanych w danej chwili jest ograniczona. Przejrzenie za większej ich liczby sprowadza się do wykonania ciągu obserwacji. Możemy także założyć, że liczba wszystkich stanów, w jakich może znaleźć się nasz umysł wykonujący obliczenia, chociaż duża jest skończona.

Turing doszedł do koncepcji swojej maszyny wprowadzając pewne uproszczenia i uściślenia w działaniach na kartce i nad nią. Po pierwsze, zapis obliczeń na kartce papieru (a dokładniej na dwuwymiarowym układzie kratek) można sprowadzić do zapisu na jednowymiarowej pokratkowanej kartce, czyli na tamie podzielonej na kratki. Wystarczy w tym celu treść obliczeń wypełniających kartkę zapisać wierszami. Traci się przy tym czytelność, ale zyskuje redukcję wymiaru kartki. Po drugie, umysł wykonujący obliczenia można zastąpić przez obiekt bardziej fizyczny zwany głowicą, która znajduje się nad tamą, może się poruszać w obie strony tamy, a w danej chwili widzi jedynie symbol umieszczony w kratce, nad którą zawisła. Działanie głowicy jest określone przez ustalony zbiór instrukcji, zgodnie z którymi może poruszać się w lewo, w prawo lub stać w miejscu, potrafi rozpoznawać symbole i może zmieniać zawartości kratki, nad którą się znajduje. Wykonanie instrukcji przez maszynę Turniga jest działaniem głowicy, uzależnionym od stanu, w jakim się znajduje i co widzi.

Obliczenia wykonywane za pomocą maszyny Turinga zależą od początkowego zapisu symboli na tamie i od przyjętego zestawu dozwolonych instrukcji. Zatem działa ona podobnie jak dzisiejsze komputery - wyniki obliczeń zależą od zapisanych w pamięci komputera danych i od zestawu wykonywanych instrukcji. Zawartoć tamy po zatrzymaniu się maszyny zależy od obu tych czynników. Nieodparcie nasuwa się pytanie o to, co można policzyć za pomocą tak prostych maszyn. Okazuje się, że bardzo wiele. Sam Turing sformułował tezę, iż na maszynie tego typu można zrealizować każdy algorytm. Do dzisiaj nie obalono tej tezy. Zauważa się, że w związku z tym można przyjąć, iż algorytmem jest dowolny opis wykonania obliczeń na maszynie Turinga.

Analizując moc swoich maszyn, Turing doszedł jednak do wniosku, że istnieją funkcje, których wartości nie mogą one obliczać.

Wspomnieć tutaj należy jeszcze o dwóch innych dziedzinach działalności Turinga ściśle związanych z automatyzacją obliczeń i komputerami. W latach II wojny światowej Turing został włączony do grupy specjalistów zajmujących się w Wielkiej Brytanii deszyfracją kodów Enigmy - maszyny, którą Niemcy używali do kodowania meldunków i rozkazów rozsyłanych swoim jednostkom na wszystkich frontach. W 1941 roku działalność tej grupy przyczyniła się do zredukowania brytyjskich strat na morzach o 50%. Brytyjscy specjaliści korzystali z materiałów ( wśród których był egzemplarz Enigmy oraz maszyna deszyfrująca zwana bombą ) przekazanych im w 1939 roku przez grupę Polaków kierowaną przez Mariana Rejewskiego, zajmujących się od

7/64


pięciu lat skonstruowaniem maszyny deszyfrującej. Chociaż Brtyjczycy udoskonalili maszynę deszyfrującą otrzymaną od Polaków, pozostawała ona nadal maszyną mechaniczną i jej działanie nie nadążało za ciągle udoskonalanymi i zmienianymi przez Niemców egzemplarzami Enigmy. Ocenia się że w szczytowym okresie II wojny światowej Niemcy używali ponad 70 tysięcy maszyn szyfrujących Enigma.

Prace nad maszyną deszyfrującą Enigmę przyczyniły się do powstania pod koniec wojny w Wielkiej Brytanii kalkulatorów elektronicznych. Powstało kilka wersji maszyny o nazwie Coloss, których głównym konstruktorem był T.H. Fowers.

Były to już maszyny elektroniczne, w których wykorzystano arytmetykę binarną, sprawdzane były warunki logiczne (a więc można było projektować obliczenia z rozgałęzieniami), zawierały rejestry, mogły wykonywać programy (poprzez uruchomienie tablic rozdzielczych) i wyprowadzać wyniki na elektryczną maszynę do pisania.

1.6 Pierwsze komputery.

Pierwsze komputery zbudowano dopiero w naszym stuleciu, chociaż pomysły, jakie w nich zrealizowano, pojawiły się przynajmniej sto lat wcześniej, już za czasów Babbage'a. Zastosowane w komputerach środki techniczne pojawiły się bowiem dopiero w latach międzywojennych. Za największego inspiratora powstania komputera w jego obecnej postaci uważa się Johna von Neumanna. Ale najpierw trzeba oddać właściwe miejsce twórcom rzeczywiście najwcześniejszych konstrukcji, pretendujących do miana komputera. Pojawienie się większości z nich przyspieszyła II wojna światowa.

W 1941 roku Konrad Zuse ukończył w Niemczech prace nad maszyną Z 3, która wykonywała obliczenia na liczbach binarnych zapisanych w reprezentacji, nazywanej dzisiaj zmiennopozycyjną, sterowane programem zewnętrznym podawanym za pomocą perforowanej tamy filmowej. Maszyna Z 3 została całkowicie zniszczona w czasie bombardowania w 1945 roku. Następny model maszyny Zusego, Z 4 przetrwał i działał do końca lat pięćdziesiątych. Maszyny Zusego były kalkulatorami przekaźnikowymi. W tym czasie znane już były prace Claude Shannona dotyczące działań binarnych (logicznych) za pomocą układów elektronicznych zgodnie z regułami Boole'a.

Rys. 5. ENIAC.

W roku 1942 zespół specjalistów pod kierunkiem J.W. Mauchly'ego i J.P. Eckerta zaprojektował i zbudował maszynę ENIAC (ang. Electronic Numerical Integrator And Computer). Pierwsze obliczania maszyna ta wykonała w listopadzie 1945 roku. Maszyna ENIAC jest uznawana powszechnie za pierwszy kalkulator elektroniczny, chociaż w 1976 roku okazało się, że wczeniej zaczęły pracować w Wielkiej Brytanii maszyny Coloss I i II. Maszyna ENIAC była monstrualną konstrukcją złożoną z 50 szaf o wysokości 3 metrów zawierających około 20 tysięcy lamp.

8/64


Słabością tej maszyny było: użycie zwykłego systemu dziesiętnego do pamiętania liczb, brak rozdziału między funkcjami liczenia i pamiętania oraz bardzo uciążliwy sposób zewnętrznego programowania. Wady te zostały usunięte dopiero w projekcie EDVAC.

1.7 John von Neumann (1903 - 1957) .

John von Neumann, z pochodzenia Węgier, był w swoich czasach jednym z najwybitniejszych matematyków. W 1946 roku zainspirował on prace w projekcie EDVAC (ang. Electronic Discrete Variable Automatic Computer ), których celem było zbudowanie komputera bez wad poprzednich konstrukcji. Zaproponowano architekturę, zwaną odtąd von neumannowską, według której buduje się komputery do dzisiaj.

W komputerze von Neumanna można wyróżnić przynajmniej następujące elementy: pamięć złożoną z elementów przyjmujących stan 0 lub 1, arytrometr zdolny wykonywać działania arytmetyczne, logiczne i inne, sterowanie, wprowadzanie danych i wyprowadzanie wyników. Program, czyli zbiór instrukcji, według których mają odbywać się obliczenia, jest wpisywany do pamięci. Kolejne rozkazy programu są pobierane przez jednostkę sterującą komputerem w takt centralnego zegara i rozpoznawane zgodnie z mikroprogramem wpisanym w układ elektroniczny. Należy podkreślić, że program jest przechowywany w pamięci komputera i jego działanie może zmieniać zawartość dowolnego obszaru pamięci (programy mogą się także same modyfikować). Fizycznie nie ma żadnej różnicy między danymi i programami przechowywanymi w pamięci komputera: są podobnie kodowane jako ciąg zer i jedynek i tak samo zrealizowane technicznie. Można więc powiedzieć, że celem działania komputera von neumannowskiego jest przejście w takt zegara od jednego stanu zawartości pamięci (danego na początku) do innego, zawierającego oczekiwany wynik. Można zauważyć podobieństwo tego spojrzenia na komputer von Neumanna do maszyny Turinga. Nie ma w tym nic dziwnego gdyż von Neumann bardzo dobrze znał osiągnięcia Turinga.

Postęp w elektronice umożliwił dalszy rozwój komputerów. W latach sześćdziesiątych lampy zastąpiono tranzystorami. Pierwszy tranzystorowy komputer zbudowano w 1956 roku w Massachusettes Institute of Technology. Z kolei układy scalone zastąpiły tranzystory (układ scalony zawierał w jednej obudowie kilkadziesiąt tranzystorów i innych elementów elektronicznych). Dalszy postęp produkcji tych układów pozwolił umieszczać w jednej "kostce" dziesiątki tysięcy tranzystorów. Obwody takie nazwano układami wielkiej skali integracji ( VLSI z ang. Very Large Scale of Integration ).

Wymyślono termin: " generacja komputerów " i nazwano komputery lampowe mianem pierwszej generacji, tranzystorowe - drugiej, zbudowane z układów scalonych - trzeciej, a w technologii VLSI - czwartej.

Postęp w technologii produkcji komputerów odbywał się tak szybko, że zaczęto mówić o rewolucji komputerowej. Wprowadzenie na rynek tanich układów scalonych umożliwiło powstanie mikrokomputerów, w których elementy przetwarzające informacje umieszczono w jednym układzie - mikroprocesorze.

1.8 Komputer typu PC.

Pierwsze komputery osobiste (PC z ang. Personal Computer) zostały opracowane przez IBM. Ponieważ firma ta nie miała nic przeciwko temu, by inne przedsiębiorstwa skorzystały z jej pomysłu i podążyły jej śladem, wielu producentów sprzedaje dziś własne komputery, które jednak są wciąż budowane według tej samej koncepcji firmy IBM. Ponieważ na rynku pojawiało się coraz więcej produktów, zaczęto pisać programy dla tego typu komputerów. Producenci sprzętu

9/64


odpowiedzieli na to kolejną falą unowocześnionych komputerów typu IBM - PC. Proces ten rozwijał się na zasadzie lawiny: komputery, nowe komponenty i oprogramowanie są obecnie tworzone przez setki najróżniejszych producentów. Tym sposobem PC stał się najbardziej rozpowszechnionym typem komputera na wiecie.

Niemal w tym samym czasie, którym narodził się PC, firma Apple zaczęła budować swój własny typ komputera osobistego, dzieło Steve Woźniaka i Steve Jobsa. System Apple nie był jednak zgodny z IBM - PC ani pod względem sprzętu, ani oprogramowania. Swój sukces zawdzięczał on faktowi, iż po raz pierwszy wykorzystano tam graficzny sposób komunikowania się z użytkownikiem bazujący na obrazkach i oknach - na rok przed rozpowszechnieniem się Windows firmy Microsoft.

Komputery Apple od samego początku były systemami kompletnymi. Oznaczało to, że w ich przypadku nie było już konieczne kupowanie dodatkowych komponentów, aby na przykład osiągnąć dźwięk odpowiedniej jakości. W przeciwieństwie do ówczesnych komputerów PC - tów, komputery Apple były znacznie prostsze w obsłudze. Mac, jak chętnie nazywa się komputer firmy Apple, szybko stał się ulubionym narzędziem ludzi z kręgów twórczych. Używali go przede wszystkim architekci, muzycy i projektanci, którym najczęściej potrzebny był właśnie wydajny i łatwy w obsłudze komputer. Tak więc Mac wciąż pozostaje główną alternatywą dla komputerów typu IBM - PC, a fakt, iż w porównaniu z PC -tem jest mniej dostępny na rynku, wynika głównie stąd, że firma Apple nie udostępniła nikomu praw do kopii swojego projektu.

Większość producentów skorzystała co prawda z koncepcji peceta firmy IBM, niemniej niektórzy wyłamali się i podążyli własną drogą tworząc komputery osobiste niezgodne ze standardem. Stąd też oprogramowanie stworzone dla typowego komputera PC z reguły nie może być na nich uruchamiane.

W zupełnym oderwaniu od standardu IBM - a powstały rozwiązania, które przewyższają pierwowzór czy to pod względem ceny, czy przydatności do gier, czy też obróbki dźwięku czy też grafiki. Niejeden z tego typu systemów był i wciąż jeszcze jest wspaniałym narzędziem, jednakże przeznaczonym wyłącznie dla specjalistów skupiających się na wykonywaniu określonej grupy zadań.

1.9 Kronika1.

1642:• Blaise Pascal skonstruował jedną z pierwszych maszyn matematycznych.

1822:• Brytyjski matematyk Charles Babbage zaprezentował model maszyny różnicowej, który

miał różnice drugiego rzędu i osiem miejsc po przecinku. Zajął się on następnie maszyną o różnicach siódmego rzędu i 290 miejscach po przecinku, poniósł jednak porażkę przy rozwiązywaniu problemu wykonania skomplikowanego napędu zębatego.

1 http://www.republika.pl/pomoce/komputer.htm http://www.computerworld.pl http://386.bajo.pl/chronologicznie.htm http://fizar.pu.kielce.pl/history/hist1.html http://www.teleinfo.com.pl/ti/1999/51/t30.html

10/64

http://www.teleinfo.com.pl/ti/1999/51/t30.htmlhttp://fizar.pu.kielce.pl/history/hist1.htmlhttp://386.bajo.pl/chronologicznie.htmhttp://www.computerworld.pl/http://www.republika.pl/pomoce/komputer.htm


1833:• Charles Babbage przedstawił pomysł pierwszej cyfrowej maszyny analitycznej. Nie została

ona nigdy zbudowana. Projekt przewidywał jednak istotne składniki nowoczesnego przetwarzania danych.

1930:• W Massachusetts Institute of Technology w Cambridge (USA) grupa naukowców pod

kierownictwem inżyniera elektryka Vannevara Busha konstruuje pierwszy - pracujący elektromechanicznie - komputer analogowy.

1936:• Francuz R. Valtat zgłosił do opatentowania maszynę liczącą, której zasada działania oparta

była na systemie dwójkowym.

1937:• Niemiec Konrad Zuse zbudował elektromechaniczną maszynę liczącą opartą na systemie

dwójkowym. • George Stibitz zbudował binarną maszynę sumującą Model K. George Stibitz tworzy w

Laboratoriach Bella pierwszy cyfrowy obwód.

1940:• Alianci zbudowali pierwszą nadającą się do użytku maszynę deszyfrującą.

1941:• Niemiecki inżynier Konrad Zuse zaprezentował swoją cyfrową maszynę liczącą "Zuse

Z3".Była to pierwsza sterowana programowo maszyna matematyczna, o wysokich parametrach eksploatacyjnych. "Zuse Z3" posiadała binarny mechanizm liczący z prawie 600 przekaźnikami jako bistabilnymi elementami i pamięcią z około 1400 przekaźnikami.

1942:• Amerykanin John V. Atanasoff ukończył pierwszą sprawną elektroniczną maszynę liczącą

w technice lampowej. Atanasoff podjął plan już w roku 1937. Był przekonany, że metoda cyfrowa i zastosowanie liczb binarnych będzie najwłaściwsze do budowy maszyn liczących.

1943:• Niemiecki inżynier Henning Schreyer zgłosił do opatentowania pełnoelektroniczną pamięć i

urządzenie liczące z lampami jarzeniowymi. Schreyer od 1937 r. wspólnie z Konradem Zuse zajmował się konstruowaniem układu połączeń lampowych do przetwarzania danych. Teraz opracował on ideę budowy pełnoelektronicznej maszyny liczącej. Jednakże w czasie wojny w Niemczech brakowało środków na realizację jego planów.

1944:• Węgiersko-amerykański matematyk i chemik John von Neuman rozpoczął próby z modelem

pierwszej maszyny liczącej z pamięcią EDVAC (Electronic Discrete Variable Automatic Computer). W urządzeniu kodowano program, składający się z serii pojedynczych instrukcji. Program zawierał instrukcje warunkowe, które umożliwiały tworzenie pętli. Każda instrukcja programowa mogła być zmieniona przez samą maszynę, jak każdy inny argument operacji. Z takim sposobem działania maszyna zdecydowanie górowała nad wszystkimi dotychczasowymi maszynami matematycznymi.

• Fizyk Howard Hathavay oddał do użytku na Universytecie Harvarda cyfrową maszynę liczącą. Nazywała się MARK I bądź ASCC - miała potężne wymiary i była pierwszą sterowaną programowo maszyną liczącą USA.

11/64


1945:• Na Uniwersytecie Pensylwania uruchomiono pierwszą wielką elektroniczną maszynę

liczącą wiata ENIAC (Electronic Numerical Integrator and Computer). Zbudowana została przez Johna Prespera Ecckerta i Johna Williama Mauchly. Do czasu aż wszystkie jej zespoły stały się całkowicie zdolne do użytku, minęły jeszcze dwa lata. Wielka maszyna matematyczna wyposażona była w lampy elektronowe i liczyła 2000 razy szybciej niż komputer z elektromechanicznymi przekaźnikami. ENIAC zajmował powierzchnię zasadniczą 140 m.kw., posiadał przeszło 17 486 lamp elektronowych, 1500 przekaźników i zużywał 174 000 W mocy. Całe urządzenie waży ok. 80 ton i może wykonać maksymalnie 5000 operacji dodawania i 360 mnożenia w ciągu sekundy. Komputer cechuje duża awaryjność – średnio co 5 minut przepala się jedna z kilkunastu tysięcy lamp elektronowych. Szybkość taktowania zegara ENIAC-a wynosi 100. Powstaje pierwszy podręcznik obsługi komputera. Instrukcję posługiwania się komputerem ENIAC pisze Amerykanka Emily Goldstine. Grace M. Hopper w prototypie komputera Mark II znajduje pierwszą „pluskwę”. Jest nią ćma, która spowodowała błąd w pracy jednego z przekaźników. John von Neumann opracowuje koncepcję programu, który – umieszczony w pamięci – steruje komputerem. Rozpoczyna karierę termin „bit”.

• Niemiecki inżynier Konrad Zuse zakończył prace nad swoją maszyną liczącą " Zuse Z4". Komputer był rozwinięciem poprzedniego typu Z3.

1947:• W Stanach Zjednoczonych zbudowano maszynę liczącą " Mark II " w technice

przekaźnikowej. • Amerykańska firma IBM buduje komputer SSEC z 12500 lampami i 21400 przekaźnikami.

Jest on sterowany za pomocą tamy dziurkowanej. Umożliwiono ingerencję w program.

1948:• W toku rozwoju elektronicznych maszyn liczących, opartych na dwójkowym systemie

liczbowym, znaczenie praktyczne zyskuje ugruntowana już przed ok. stu laty algebra Boole'a. Posługuje się ona wartościami logicznymi "Tak / Nie" lub " 0 / 1". Ten " krok binarny" określa matematyk John W. Tukey jako " bit" (binarny digit). Bit staje się jednostką informacji w przetwarzaniu danych.

• IBM 604 jest pierwszą dużą maszyną liczącą sterowaną tamą perforowaną. • Richard Hamming opracowuje sposób wykrywania błędów w programach.

1949:• Short Order Code, wymyślony przez Johna Mauchly, jest pierwszym językiem

programowania wysokiego poziomu. • Na Uniwersytecie Manchester (Anglia) pod kierownictwem Maurica V. Wilkesa

skonstruowano po trzech latach pierwszy komputer lampowy z programowalną pamięcią EDSAC (Electronic Delay Storage Automatic Computer).

• W tym samym czasie również IBM uruchamia w Nowym Jorku pod kierownictwem Johna Prespera Eckerta układ z programowalną pamięcią - SSEC (Selective Sequence Electronic Calculator). EDSAC pracuje z 4500 lampami elektronowymi, a SSEC z 12500 lampami elektronowymi i 21400 przekaźnikami. Nowością w tych komputerach jest to, że tak przebieg programu jak i obróbka danych są zakodowane w pamięci maszyny, program zawiera rozkazy warunkowe, które umożliwiają rozgałęzienia i skoki i wreszcie każdy rozkaz programowy z operacyjną częścią adresową może samodzielnie zmienić. Koncepcję tych komputerów opracował już w 1944 r. matematyk amerykański pochodzenia węgierskiego John von Neamann. Jednakże jego urządzenie EDVAC rozpoczyna pracę dopiero w roku 1952. Np. w 1945 r. Zuse sformułował ogólny algorytmiczny język formuł, który uwzględniał możliwe warianty programowania pamięci.

12/64


1950:• Univac I firmy Eckert and Mauchly Computer Company jest komputerem produkowanym

seryjnie. • Komputer " Mark III " używa tamy magnetycznej zamiast kart perforowanych.

1951:• Grace Murray Hopper wymyśla pierwszy kompilator A-0. • Na Uniwersytecie Harwarda w Cambridge (Massachusetts) matematyk Howard H. Aiken

uruchomił swoją maszynę cyfrową MARK III. Urządzenie to było kontynuacją urządzeń poprzednich MARK I i MARK II, które Aiken budował już od roku 1939. W niedługim czasie Aiken buduje pierwszy, wykonany w pełni w technice lampowej maszynę liczącą MARK IV.

1952:• Pierwsze asemblery.• Howard H. Aiken uruchomił w USA lampową maszynę liczącą MARK IV.

1954:• J.W. Backus stworzył język komputerowy FORTRAN (formula translator). Umożliwia on

dialog pomiędzy użytkownikiem a bankiem danych bez konieczności korzystania z pomocy programisty. FORTRAN jest skomplikowanym językiem komputerowym, który nie tylko przekazuje maszynie polecenia, lecz zawiera w sobie szereg wzorów ułatwiających programowanie.

1955:• W Bell Telephone Laboratory w USA rozpoczęła pracę pierwsza tranzystorowa maszyna

licząca " Tradic " skonstruowana przez zespół pod kierownictwem J. H. Felkera. Jest ona znana jako " komputer drugiej generacji ".Wkrótce pojawiły się na rynku tranzystorowe komputery ("7090 IBM" i "Gamma 60 Bull").

1957:• Fortran II.• John McCarthy tworzy wydział sztucznej inteligencji na Uniwersytecie MIT.

1958:• Opracowano komputerowy język programowania ALGOL (Algorithmic Language).

Podobnie jak FORTRAN - ALGOL jest językiem problemowo zorientowanym, ale nie bardziej niż te, które są specjalistycznymi językami naukowo-technicznymi. Ma on inną strukturę niż FORTRAN.

1959:• John McCarthy opracowuje język programowania Lisp (list processing).

1960:• Powstaje język programowania Algol 60. • Zostaje opracowany język programowania COBOL (Common Business Oriented

Language). COBOL używa stosunkowo dużej liczby symboli słownych. • Powstaje LISP.• W listopadzie firma DEC przedstawia PDP-1, pierwszy komputer wyposażony w monitor i

klawiaturę.

13/64


1962:• Powstaje APL, APL/PC, APL*PLUS.• Powstaje SIMULA.• Maleńkie tranzystory zwiększają prędkość elektronicznego przetwarzania danych (trzecia

generacja komputerów).

1963:• Powstaje program Eliza, który wykazuje pewne przejawy inteligencji. Potrafi prowadzić

proste rozmowy z człowiekiem. • Na uniwersytecie Kalifornijskim rozpoczynają się prace nad logiką rozmytą (fuzzy logic),

która ma pomóc w stworzeniu komputera myślącego.• Zatwierdzony zostaje 7-bitowy kod ASCII.

1964:• Powstaję języki PL/I, dialekty: EPL, PL/S, XPL.• Thomas Kurz i John Kemeny opracowują w Dartmouth College prosty język

programowania Basic.

1966:• Fortran IV (1966).

1967:• Ole-Johan Dahl i Kristen Nygaard z Norwegian Computing Centre opracowują język

Simula, który jest pierwszym obiektowo zorientowanym językiem programowania. • Holender Edsger Dijkstra opracowuje zasady programowania strukturalnego.• Powstaje firma Intel założona przez dwóch byłych pracowników Fairchild Semiconductor. • Powstaje pierwszy radziecki superkomputer - BESM-6.

1968:• Powstaje Algol 68.• Edsger Dijkstra przekonuje, że instrukcja GOTO może być szkodliwa i nie powinno się jej

stosować. • Monolityczne układy przełączające zastępują minitranzystory i hybrydowe układy scalone.

Zaczyna się czwarta generacja komputera. Podczas gdy komputery drugiej generacji wykonywały na sekundę 1300 dodawań, a trzeciej 160 000 dodawań, to nowe urządzenia wykonują ponad 300 000.

• Dzięki upowszechnieniu się komputerów Odra powstają pierwsze ZETO - Zakłady Elektronicznej Techniki Obliczeniowej.

1969:• IBM podejmuje decyzję o niedostarczaniu programów aplikacyjnych razem ze sprzętem.

Tak powstaje rynek oprogramowania. • Szwajcar Niklaus Wirth opracowuje język programowania Pascal. • Douglas Engelbart z Xerox PARC (Palo Alto Research Center) tworzy podstawy hipertekstu

(pierwowzoru HTML). Engelbart jest również twórcą myszy komputerowej (1964 r.).

1970:• Powstaje Prolog, Prolog-2, Prolog++, Prolog-D-Linda.• W IMM powstają dwa zespoły zajmujące się technikami kompilacji. Zespół Jana Walaska

buduje kompilatory COBOL i Pascala. Zespół Stanisława Niewolskiego tworzy kompilator Fortran IV dla RIAD. Prace te podjęto, by możliwe było samodzielne opracowywanie i

14/64


rozpowszechnianie kolejnych języków oprogramowania oraz tworzenie przy ich użyciu programów systemowych i aplikacyjnych.

1972:• Dennis Ritchie opracowuje język programowania C w firmie Bell Labs. • W laboratoriach PARC powstaje obiektowy języka programowania Smalltalk, stworzony

przez Alana Kaya.• Powstaje procesor Intel 8008 (200 Khz), pierwszy 8 bitowy układ, zastąpiony niebawem

przez Intel 8080.

1974:• W kwietniu powstaje 8 bitowy procesor 8080 (2 Mhz). Składa się z 6 tys. tranzystorów.

1976:• Departament Obrony USA ogłasza przetarg na opracowanie środowiska i języka do

produkcji oprogramowania, które ma być wbudowane w postaci sterowników do dział okrętowych, stacji radiolokacyjnych, wyrzutni rakietowych. W konkursie wygrywa zespół reprezentujący kilka wydziałów informatyki uczelni francuskich. Ostatecznie Departament Obrony zatwierdza specyfikację wynikową języka ADA oraz związane z nim środowisko programistyczne.

• Cray 1 - pierwszy komputer wektorowy do intensywnych obliczeń numerycznych. • Zilog wprowadza na rynek procesor Z80.

1977:• Fortran 77

1978:• W czerwcu Intel przedstawia pierwszy 16-bitowy procesor - 8086 (4,77 Mhz). Składał się z

29 tys. tranzystorów.

1979:• Powstają Modula-2, Modula-2+, Modula-3, Modula-P, Modula/R.

1980:• Powstaje język programowania Ada. • Powstaje dBASE II - wersje późniejsze: dBASE III, III+, IV, V• Brytyjscy inżynierowie wprowadzili na rynek komputer osobisty (Sinclair ZX - 80). • Microsoft tworzy pierwowzór DOS-u.

1981:• IBM dostarcza pierwszy Personal Computer (PC) z 16-bitowym procesorem 8088,

pracującym z częstotliwością 4,7 MHz pod kontrolą DOS.

1982:• W lutym Intel prezentuje 16-bitowy procesor 80286 (6 Mhz). Zawiera on 134 tys.

tranzystorów. • John Warnock opracowuje w firmie Adobe język PostScript.

1983:• Bjarne Stroustroup opracowuje C++. • Borland wprowadza Turbo Pascal. • Powstaje Smalltalk-80, Smalltalk/V na PC.

15/64


• Powstaje standard Ada 83, rozszerzenia Ada++, Ada 9X.• Microsoft wprowadza edytor Word dla DOS.

1984:• Powstaje Macintosh. • Microsoft prezentuje system operacyjny Windows.

1985:• Powstaje COBOL 85• W październiku Intel przedstawia 32 bitowy procesor 80386.

1986:• Intel wprowadza procesor 80386.

1989:• W kwietniu powstaje procesor Intel 80486, który zawiera 1,2 mln tranzystorów.

1990:• Powstaje procesor Intel i486. • Microsoft wprowadza ikony do Windows 3.0.

1991:• Fortran 90• Linus Thorvalds opracowuje system operacyjny Linux.

1992:• Pojawia się Windows 3.1 przeznaczony dla krajów naszego regionu. System Microsoftu nie

ma jeszcze polskego menu, ale obsługuje polskie znaki diakrytyczne.

1993:• W marcu powstaje procesor Pentium • Microsoft wprowadza Windows NT. Do sprzedaży trafiają polskie wersje Word i Excel. Z

Wordem konkuruje edytor QR-Tekst firmy Malkom.

1994:• Uchwalona przez Sejm Ustawa o prawie autorskim miała ograniczyć piractwo

komputerowe.

1995:• Sun przedstawia światu język Java. • Powstaje Visual Fortran 95.• 24 sierpnia na rynku pojawia się Windows 95.

1996:• Powstaje Pentium Pro

1998:• W kwietniu Intel przedstawia procesor Pentium II (350 MHz i 400 MHz). • W czerwcu Microsoft wypuszcza system operacyjny Windows 98.

16/64


2 Języki programowania.

2.1 Rozwój programowania.

Możliwość zaprogramowania maszyny, a tym samym dostosowanie jej działania do wymogów użytkownika w danym momencie, przyczyniła się do tego, że komputer stał się obecnie urządzeniem niemal niezbędnym w wielu dziedzinach. Byłoby to niemożliwe bez znaczących postępów w programowaniu, a w szczególności bez rozwoju języków i narzędzi automatyzujących pracę programisty. Pierwsze komputery były programowanie przez fizyczną zmianę układów elektronicznych (tzw. hardware'u) lub przestawienie przeznaczonych do tego przełączników. Była to metoda powolna, kosztowna, o bardzo ograniczonych możliwościach. W ten sam sposób były wprowadzane dane. Z biegiem czasu ilość danych do opracowywania wzrosła tak bardzo, że nie pozostało nic innego, jak tylko poszukać nowego systemu. Tak powstały dziurkowane karty i taśmy. Kolejnym krokiem było zastosowanie takich samych kart i taśm do przechowywania programów. Dzięki temu komputery zyskały pewną elastyczność. Można było stosunkowo szybko i łatwo załadować dany program do pamięci maszyny. Możliwość przechowywania w pamięci komputera programu i danych stanowiła wielki krok naprzód, lecz jednocześnie stworzyła nowe problemy. Teraz bowiem okazało się, że potrzebny jest prosty system porozumiewania się z komputerem i kodowania programów, które maszyna ma wykonywać. I tak doszło do pojawienia się pierwszych języków programowania. Żeby komputer wykonał określone zadanie, należy wskazać mu sposób, w jaki ma to uczynić. Nie jest to proste, gdyż trzeba posłużyć się językiem zrozumiałym dla maszyny, którego podstawę stanowi szereg precyzyjnych instrukcji. Takie porozumiewanie się z komputerem odbywa się za pomocą środków, których dostarczają języki programowania, a które w swoich początkach były bardzo prymitywne i trudne w użyciu. Wszystkie języki programowania wykorzystują system ściśle ustalonych reguł, które w większym lub mniejszym stopniu mają zbliżyć do siebie język naturalny człowieka i maszyny; są pośrednikiem między skompilowanym kodem maszynowym (zrozumiałym dla komputera) a językiem naturalnym.

Ponieważ jednak komputer rozumie i posługuje się tylko tzw. językiem binarnym, którego podstawę stanowi rozróżnienie dwóch stanów, jakie może przyjąć wyłącznik (włączone/wyłączone), a reprezentowanych przez 0 i 1, to ciąg instrukcji - czyli program - trzeba przetworzyć tak, aby stał się zrozumiały dla maszyny. Na szczęście, tłumaczenie takiego kodu na język zrozumiały dla komputera jest procesem mechanicznym i powtarzalnym, więc może być wykonane przez samą maszynę. Służy do tego specjalny program tłumaczący zwany translatorem. Obecnie do tłumaczenia kodu z języka programowania na język maszynowy używa się dwóch typów programów tłumaczących: kompilatorów i interpreterów. Kompilator przekształca program napisany w języku wysokiego poziomu na program w języku zrozumiałym dla maszyny. W ten sposób otrzymuje się tak zwany kod wynikowy, który może być wykonywany dowolnie wiele razy. W przypadku kompilatorów należy rozróżniać trzy języki: ten, w którym napisano program i który jest mniej lub bardziej zbliżony do naturalnego (kod źródłowy); właściwy dla danego typu komputera język maszynowy, na który tłumaczony jest program (kod wynikowy); język samego kompilatora, którym może być język programu źródłowego lub maszynowy (albo jeszcze jakiś inny).

Interpreter natomiast tłumaczy kolejno poszczególne instrukcje programu napisanego w języku wysokiego poziomu (może to być ten sam język, co w przypadku kompilatora), a te są natychmiast wykonywane. Tak więc, odmiennie niż kompilator, który jednorazowo przekształca program w całości, interpreter tłumaczy każdą instrukcję oddzielnie, bezpośrednio przed jej wykonaniem. Interpreter nie generuje programu wynikowego. Dlatego za każdym razem, kiedy wykonuje się

17/64


dany program, interpreter ponownie musi go tłumaczyć linia po linii. Co więcej, również powtarzające się fragmenty programu muszą być tłumaczone oddzielnie, za każdym razem od nowa. W przypadku interpretera rozróżnia się tylko dwa języki. Jeden - to język programu źródłowego, a drugi - to język, w jakim został napisany sam interpreter. Nie wyodrębnia się kodu wykonywalnego, gdyż jest on podawany stopniowo, w miarę jak mikroprocesor zgłasza taką potrzebę. Programy interpretowane wykonują się wolniej niż kompilowane, ale interpreter, jako środowisko programowania i uruchomieniowe, jest bardziej elastyczny, gdyż wszelkie błędy (termin przejęty z angielskiego: bug - pluskwa) mogą być wyłapywane i poprawiane już w trakcie normalnego wykonywania programu.

Techniki programowania rozwijały się równolegle do ewolucji komputera. Pierwsze języki starały się maksymalnie wykorzystać niewielką moc ówczesnych procesorów oraz skromne możliwości systemów operacyjnych. W tamtym czasie do programowania używano często języka niskiego poziomy zwanego asemblerem (w jęz. angielskim assembler), który jest językiem symbolicznym, lecz ściśle związanym z maszyną, na której program będzie wykonywany. W asemblerze jedna instrukcja tłumaczy się na jedną instrukcję procesora. Mimo tej niedogodności asembler był dobrą alternatywą dla żmudnego wprowadzania do pamięci maszyny nie kończących się ciągów zer i jedynek lub liczb szesnastkowych, z drugiej strony, wpisany weń stopień komplikacji sprawił, że środowisko to było wyłączną domeną wysokiej klasy profesjonalistów. Wprowadzenie asemblera przyczyniło się głównie do tego, że programy stały się czytelniejsze, chociaż do kodu symbolicznego dodano instrukcje nie mające swojego odpowiednika w rozkazach procesora. Służą one do przekazywania informacji kompilatorowi i zostały nazwane "pseudorozkazami". Pseudorozkazem są na przykład te, które określają początek i koniec pewnych części programu (podprogramów i procedur) lub wskazują kompilatorowi sposób wykonania konkretnego zadania. Wkrótce stwierdzono, że język symboliczny nie rozwiązuje ostatecznie problemów związanych z programowaniem, gdyż zmiana procesora wymaga nowego asemblera, dostosowanego do instrukcji nowej maszyny, a programowanie w asemblerze wymaga bardzo dobrego poznania mikroprocesora, jego rejestrów, struktury pamięci i wielu innych rzeczy. Mimo tych wad języki symboliczne są nadal stosowane z dwóch zasadniczych powodów. Po pierwsze, istnieje jeszcze olbrzymia ilość oprogramowania napisanego w tych językach, z którego nie można po prostu zrezygnować. Po drugie, z języków symbolicznych korzysta się do pisania niektórych krytycznych sekcji programów, gdyż dzięki temu, że stoją blisko języka wewnętrznego maszyny, mają bardzo wydajny kod, co pozwala budować zajmujące niewiele miejsca i szybko działające programy, specjalnie dostosowane do danego modelu.

Reasumując można powiedzieć, że programowanie w języku maszynowym lub symbolicznym ma pewne zalety (lepsze dostosowanie do sprzętu, maksymalna prędkość działania, minimalne zajęcie pamięci), ale i znaczne wady (niemożność napisania kodu nie związanego z maszyną, wyższy stopień trudności przy pisaniu programu oraz w rozumieniu kodu programu).

Kolejny krok naprzód w dziedzinie programowania nastąpił wraz z pojawieniem się języków wysokiego poziomu. Ponieważ języki te nie są tak ściśle związane z konkretną maszyną, programista znający którykolwiek z nich jest w stanie zaprogramować dowolny komputer, pod warunkiem, że istnieje odpowiedni dla niego kompilator lub interpreter. Zazwyczaj kompilatory języków wysokiego poziomu działają dwuetapowo. W pierwszej fazie kod źródłowy jest przekształcany do pewnej postaci pośredniej, również niezależnej od maszyny. W drugiej fazie, otrzymany w ten sposób kod pośredni jest tłumaczony na kod wewnętrzny maszyny, na której ma być wykonywany dany program. W ten sposób, zmieniając jedynie program tłumaczący w drugiej fazie, niewielkim wysiłkiem można przekształcić dany kod do postaci różnych języków maszynowych.

18/64


Pierwsze języki wysokiego poziomu, jak COBOL, FORTRAN i APL, pochodzą z lat pięćdziesiątych i sześćdziesiątych. Choć znacznie uprościły proces, w praktyce nie wyszły poza krąg zastosowań zawodowych. Wszystkie języki programowania - również asembler - muszą być tłumaczone na język zrozumiały dla komputera, a ten rozumie tylko ciągi zer i jedynek i jedynie na nich operuje. Obecnie oprócz języków dysponujących zarówno kompilatorem jak i interpreterem, na przykład BASIC, stosowane są inne, tradycyjnie interpretowane, np. APL, oraz takie, które są niemal wyłącznie kompilowane, np. COBOL i FORTRAN.

W miarę pojawiania się na rynku kolejnych języków wysokiego poziomu użytkownicy stwierdzili, że do konkretnych zadań jedne były lepsze od innych. Dlatego też COBOL stał się ulubionym narzędziem do tworzenia aplikacji dotyczących zarządzania, podczas gdy FORTRAN rozpowszechnił się jako język do prac naukowo-technicznych dzięki łatwości, z jaką radzi sobie z wyrażeniami i skomplikowanymi działaniami matematycznymi. Pomimo że języki, o których wyżej mowa, są nadal stosowane, to obecnie zawodowi programiści korzystają zazwyczaj z bardziej rozwiniętych języków wysokiego poziomu, w szczególności dla środowiska komputerów osobistych PC, które bardzo upraszczają programowanie. Takimi językami są np. PASCAL i C, choć ten ostatni jest stopniowo wypierany przez swoją wydajniejszą odmianę C++.

Innym, szybko rozpowszechniającym się językiem, jest JAVA. Z założenia przeznaczony do wykorzystania w Internecie, umożliwia jednak konstruowanie złożonych aplikacji. Główne cechy wyróżniające język JAVA to przenośność pomiędzy różnymi platformami sprzętowymi i systemami operacyjnymi oraz czytelny kod źródłowy programów napisanych w tym języku. Do tworzenia stron Internetu korzysta się również z innego języka - HTML (angielski skrót nazwy Hypertext Markup Language). Oferuje on mniej możliwości niż Java, a zasadniczym jego przeznaczeniem jest właśnie tworzenie stron WWW.

Odpowiedzią na konieczność szybkiego i łatwego konstruowania złożonych programów było pojawienie się na rynku tzw. języków programowania wizualnego. Są to narzędzia, które na bazie języków wysokiego poziomu, takich jak BASIC, PASCAL i C++ , pozwalają na budowanie programu przez wybranie obiektów i elementów, które mają pojawić się na ekranie. Główną zaletą języków wizualnych jest to, że udostępniają użytkownikowi środowisko graficzne, pozwalające budować kompletne aplikacje, nawet bez dobrej znajomości skomplikowanej składni danego języka. Spośród tego typu środowisk programistycznych należy wymienić, w szczególności, Delphi i ObjectVision firmy Borland oraz Visual Basic Microsoftu. Czasem narzędzia te są określane także mianem automatycznych generatorów kodu źródłowego.

2.2 Generacje języków programowania.

Języki programowania można podzielić na pięć wyraźnie różniących się generacji (niektórzy mówią o czterech). W miarę jak zmieniał się komputer, wystąpiła konieczność dostarczania użytkownikowi narzędzi programistycznych, które umożliwiłyby mu maksymalne wykorzystanie sprzętu. Nie ma jednak pełnej zbieżności chronologicznej między poszczególnymi generacjami języków i sprzętu.

Pierwsza generacja - Programowanie pierwszych komputerów akceptujących zmianę oprogramowania odbywało się bezpośrednio w kodzie binarnym, który można przedstawić jako ciągi zer i jedynek. Każdy typ komputera operuje własnym kodem, który dlatego został określony nazwą język maszynowy lub wewnętrzny. I to właśnie stanowi główną wadę tych języków, gdyż programista każdorazowo musi dostosowywać się do języka konkretnej maszyny.

Druga generacja - Ponieważ operowanie ciągami zerojedynkowymi nie jest wygodne dla programisty, przypisano im łatwiejsze do zrozumienia znaki mnemotechniczne. Tak narodziły się

19/64


języki symboliczne, zwane też asemblerami. Choć stanowią proste tłumaczenie języka maszynowego na symbole i są ściśle związane z danym modelem komputera, to ułatwiają pisanie instrukcji i czynią je bardziej czytelnymi.

Trzecia generacja - Kolejnym krokiem w rozwoju języków programowania było powstanie języków wysokiego poziomu. Symbole asemblera reprezentujące konkretne instrukcje zostały zastąpione kodem nie związanym z maszyną, bardziej zbliżonym do języka naturalnego lub matematycznego.

Czwarta generacja - Na czwartą generację języków programowania składa się szereg narzędzi, które umożliwiają budowę prostych aplikacji przez zestawianie „prefabrykowanych” modułów. Obecnie wielu specjalistów uważa, że nie są to języki programowania w ścisłym znaczeniu, gdyż częstokroć stanowią jedynie rozszerzenie języków już istniejących. Niektórzy autorzy proponują stosować nazwę „czwarta generacja” wyłącznie w odniesieniu do programowania obiektowego (OOP).

Piąta generacja - Nazwę „język piątej generacji” stosuje się czasem w odniesieniu do języków używanych do tworzenia programów wykorzystujących tzw. sztuczną inteligencję (AI) lub inaczej - systemów ekspertowych.

2.3 Podstawowe definicje.

Język - jest to ogólna nazwa zdefiniowanego zbioru znaków i symboli oraz reguł określających sposoby i kolejność ich użycia. Język, który jest stosowany do przetwarzania algorytmów nosi nazwę języka algorytmicznego, a przy zastosowaniu go do celów programowania określony jest jako język programowania. Ponieważ komputer posługuje się językiem binarnym, tzn. rozróżnia stany 0,1, program w języku programowania należy przetworzyć tak, aby był zrozumiały dla maszyny – zadaniem tym zajmują się translatory.

Język programowania - zbiór zasad składni, instrukcji, dzięki którym powstaje kod źródłowy programu. Procesor jest w stanie wykonywać program w kodzie maszynowym. Jednakże tworzenie programów w tym języku jest praktycznie niemożliwe. Dlatego programista używa języka zrozumiałego dla człowieka, który następnie jest kompilowany bądź interpretowany do postaci maszynowej. Istnieje wiele rodzajów języków programowania. Można je podzielić na języki strukturalne i obiektowe. Innym kryterium podziału jest zastosowanie języków (innych używa się do tworzenia programów multimedialnych, a innych do obliczeń numerycznych czy np. aplikacji sieciowych). Niektóre z języków są bardziej uniwersalne niż inne.

Język niskiego poziomu (angielskie low-level language) – język programowania, w którym środki strukturalizacji kodu są ograniczone do co najwyżej podprogramów i makroinstrukcji. Polecenia w nim są zapisywane symbolicznie, a jednemu rozkazowi dla komputera odpowiada jeden rozkaz programisty. Do języków niskiego poziomu zalicza się języki adresów symbolicznych, czyli asemblery. Poziom języków programowania nie określa jego jakości, lecz rodzaj zastosowań.

Język wysokiego poziomu (angielskie high-level language) – język programowania, zazwyczaj o budowie blokowej, spełniający wymagania programowania strukturalnego, programowania z użyciem obiektów lub nawet programowania obiektowego. Typowymi i najczęściej używanymi językami wysokiego poziomu są języki: C, C++, Smalltalk, Java, Pascal i Lisp, lecz również języki specjalizowane, np. język SQL służący do formułowania zapytań do baz danych lub edukacyjny język Logo. Istnieje wiele modyfikacji języków starszej generacji, np. Fortranu, Basica lub Cobolu, które po unowocześnieniu spełniają w zupełności kryteria języków wysokiego poziomu. Cechą znamienną dla nich jest możliwość bezpieczniejszego programowania, tj. programowania mniej

20/64


podatnego na błędy, i wynikająca z tego możliwość opracowywania większych programów (powyżej 10 000 wierszy kodu).

Język maszynowy, język wewnętrzny (angielskie machine language) - wewnętrzna, dwójkowa reprezentacja rozkazów procesora. Do początku lat siedemdziesiątych rozruch niektórych typów komputerów wymagał wprowadzenia z konsoli elementarnego programu ładującego w postaci dwójkowych kodów języka maszynowego. Moduły wyrażone w dowolnym języku programowania są po ostatecznym przetłumaczeniu sprowadzane do postaci języka maszynowego.

Język strukturalny (angielskie structural language) - język spełniający paradygmat programowania strukturalnego, tj. zaopatrzony w instrukcje strukturalne. Większość języków zaprojektowanych po 1970 spełnia wymogi strukturalności.

Język proceduralny (angielskie procedural language) - język spełniający paradygmat programowania proceduralnego, np. Fortran, Pascal lub C, lecz także każdy nowszy język w swej warstwie proceduralnej.

Język imperatywny (angielskie imperative language) – język, w którym program jest pojmowany jako ciąg wykonywanych po sobie instrukcji. Programista używający języka imperatywnego osiąga zamierzony efekt przez manipulowanie wartościami zmiennych. Przykładami języków imperatywnych są Pascal i C.

Język problemowy - jest przeznaczony do określonych zadań. Do tworzenia programów powiązanych czymś ze sobą. Jego przeciwieństwo to język uniwersalny, taki jak np. Pascal, który może być zastosowany praktycznie do wszystkiego.

Język obiektowy (angielskie object-oriented language) – język, który umożliwia realizowanie paradygmatu obiektowego, tzn. programowanie z użyciem hierarchii klas (zwłaszcza klas abstrakcyjnych). Popularnymi językami obiektowymi są: C++, Java, Smalltalk, Object Pascal, Beta, Theta, CLOS, Eiffel, Ada98, Python i in. W języku angielskim rozróżnia się też słabsze pojęcie: object-based language, tj. język umożliwiający stosowanie obiektów, w którym użytkownik może definiować i stosować własne typy danych. Od lat osiemdziesiątych języki obiektowe uważa się za szczytowe osiągnięcie inżynierii oprogramowania.

Kod maszynowy - język rozumiany przez procesor. Program w kodzie maszynowym składa się z ciągu wartości binarnych, które oznaczają zarówno instrukcje jak i dane. Program, który jest napisany w pewnym języku programowania, musi zostać skompilowany, aby mógł być wykonywany przez komputer. Postać kodu maszynowego zależy od architektury procesora, na który dany program jest przeznaczony. Dlatego program musi zostać skompilowany na konkretnej maszynie, ewentualnie na systemie kompatybilnym z systemem docelowym.

Kod źródłowy - program komputerowy napisany w języku programowania. Jest to postać programu, która jest zrozumiała dla programisty (bez konieczności jego uruchamiania). Kod źródłowy jest przekształcany na kod maszynowy w procesie kompilacji programu.

Kod wynikowy (angielskie object code) - rezultat pracy translatora (np. kompilatora), nadający się do bezpośredniego wykonywania przez procesor albo wymagający dalszej obróbki (np. konsolidacji).

21/64


2.4 Środowisko programistyczne.

Jak zostało to wcześniej wspomniane, stworzenie działającego programu komputerowego wymaga posiadania translatora. Większość języków programowania, powstałych szczególnie w ostatnich latach, zawiera jednak znacznie więcej elementów:

translator – służy do wykonania kompilacji lub interpretacji kodu źródłowego. Standardowym katalogiem, w których umieszcza się pliki translatora jest katalog BIN (w systemach Windows) w głównym katalogu aplikacji. Aby proces translacji był możliwy, system operacyjny musi znać dokładne położenie translatora i jego bibliotek. W tym celu należy dokonać odpowiedniego wpisu w pliku wsadowym autoexec.bat (czasami wpis tworzony jest automatycznie podczas instalacji).

Przykłady:

Fortran 90SET PATH=C:\F90\BIN;"%PATH%"SET INCLUDE=C:\F90\INCLUDE;"%INCLUDE%"SET LIB=C:\F90\LIB;"%LIB%"

VFortSET PATH=%PATH%;C:\VFort\BinSET LIBRARY_PATH=C:\VFort\Lib

Delphi 6.0SET PATH=C:\ DELPHI6\BIN;C:\ DELPHI6\PROJECTS\BPL;%PATH%

FreePascalSET PATH=C:\FreePas\Bin\Win32;%PATH%

Przykłady są przedstawione dla przypadku, gdy każdy program zainstalowany jest bezpośrednio w katalogu głównym – inne położenie wymaga odpowiedniego wpisu. Podczas instalacji programu (języka programowania) należy pamiętać, że niektóre translatory, szczególnie starsze, nie akceptują długich nazw (np. kompilator G77) – co może stać się powodem niezrozumiałych z pozoru błędów (translator nie będzie działał). Może się również zdarzyć, że w pliku autoexec.bat będzie tak dużo wpisów do zmiennej PATH, że zajmą one całą przeznaczoną na nią pamięć, co w efekcie może doprowadzić do problemów z uruchomieniem systemu (plik win.com) – należy wówczas w miarę możliwości ograniczyć długości ścieżek.

biblioteki i dodatkowe pliki wsadowe – służą do rozszerzania możliwości języka, szczególnie w zakresie pewnych zastosowań (np. obliczeń matematycznych, numerycznych, obróbki grafiki). Standardowo instalowane są w katalogach LIBRARY i INCLUDE w głównym katalogu aplikacji. Biblioteki podstawowe dostarczane są wraz z środowiskiem programistycznym, biblioteki dodatkowe rozprowadzane są w postaci osobnych pakietów.

edytor kodu – służący do pisania tekstu kodu źródłowego. Edytory mogą być uniwersalne (np. ConText, Amigo, Crimson, Codex, EditPlus, UltraEdit, Editeur, EmEditor i inne) lub też zintegrowane z konkretną implementacją języka (np. Borland Delphi, Compaq Visual Fortran i inne). Edytory uniwersalne pozwalają na podłączanie kompilatorów jednego lub wielu języków i są rozprowadzane jako oddzielne programy. Podłączenie konkretnego kompilatora odbywa się poprzez odpowiednią definicję opcji programu. Zaletą edytorów jest to, że poprawiają znacznie przejrzystość i wygodę tworzenia kodu, a także „pomagają” pisać kod źródłowy programu

22/64


wyróżniając, zazwyczaj kolorem lub wytłuszczoną czcionką, słowa kluczowe danego języka – łatwo wówczas zauważyć błąd już na etapie jego popełniania.

debugger (analizator kodu) – służy do analizy poprawności tworzonego kodu źródłowego i stanowi zazwyczaj integralną część translatora (może być to również oddzielny program). Podczas analizy kodu źródłowego generowane są informacje o błędach – czasami wymaga to podania dodatkowych opcji kompilacji – na bieżąco (analizator zatrzymuje się w miejscu wykrycia błędu) lub też w postaci końcowego raportu. Oprócz sygnałów o błędach, analizatory podają również tzw. ostrzeżenia, tzn. informacje o znalezieniu niejasności w kodzie lub o wykryciu miejsca potencjalnie niebezpiecznego. Typowym ostrzeżeniem jest wiadomość o wykryciu deklaracji zmiennej, która nie została nigdzie w kodzie wykorzystana.

edytor formularzy – służy do budowy okien widzianych przez użytkownika po uruchomieniu programu (formularzy). Element ten występuje jedynie w językach wizualnych, takich jak Visual Basic, Delphi, Compaq Visual Fortan i innych. W różnych implementacjach języków, edytor formularzy może być dostępny bezpośrednio po uruchomieniu programu lub też po wybraniu odpowiedniej opcji z menu. Zaletą stosowania tego narzędzia jest łatwość tworzenia dowolnie skomplikowanych okien i określania ich właściwości. Nie traci się wówczas czasu na pisanie elementów kodu, odpowiedzialnych za tworzenie się formularzy i ich elementów, a programista skupia się jedynie na realizacji założonego algorytmu. Brak edytora formularzy nie przesądza o tym, że nie można tworzyć standardowych, „okienkowych” aplikacji – wygląd definiowany jest wówczas przez programistę w kodzie źródłowym.

menadżer projektu – służy do zarządzania modułami i plikami projektu. Rzadko bowiem tak się zdarza, że cały kod źródłowy zawarty jest w jednym pliku – przeważnie jest ich wiele i zawierają nie tylko poszczególne moduły kodu, ale również biblioteki, różne pliki wsadowe, grafikę i pliki multimedialne. Zazwyczaj istnieje główny plik projektu zawierający wszystkie potrzebne do kompilacji informacje. Z pomocą menadżera łatwo można modyfikować zawartość i strukturę projektu.

narzędzia dodatkowe – służą do tworzenia systemu pomocy, ikon i kursorów, programów instalacyjnych. Ilość narzędzi i poziom ich zaawansowania zależy od implementacji języka.

system pomocy – służy do uzyskiwania informacji o środowisku programistycznym, zasadach jego użytkowania, elementach języka (wraz z przykładami), rodzaju licencji, autorach i kontaktach. Zależnie od implementacji języka oraz jego rodzaju pomoc może być mniej lub bardziej rozwinięta. Dobrze zorganizowanie, obszerne systemy pomocy zawierają często kompendium wiedzy na temat danego języka programowania.

2.5 Etapy kompilacji.

Proces przetwarzania kodu źródłowego na plik wykonywalny typu *.exe składa się kilku etapów:

etap preprocesingu – jego zadaniem jest wstępne przygotowanie programu do właściwej kompilacji. W tej fazie mogą być również dołączane dodatkowe pliki, realizuje się to specjalną instrukcją (np. INCLUDE) umieszczoną na początku kodu źródłowego. Po napotkaniu takiej instrukcji preprocesor wstawi zawartość odpowiedniego pliku. Zazwyczaj w ten sposób włącza się do kodu źródłowego pliki z deklaracjami funkcji lub informacją o rozmiarach zmiennych indeksowanych.

etap kompilator – służy do przetłumaczenia kodu źródłowego na kod wynikowy (binarny), zrozumiały dla komputera.

23/64


etap konsolidacji (linkowania) – służy do dołączania bibliotek do tworzonego programu. Jeżeli dany program używa funkcji z bibliotek, niezbędne jest aby taka biblioteka została do tego programu dołączona. Biblioteka jest również pewnym „programem”, który różni się tylko tym iż nie może być samodzielnie uruchomiony. Po prostu zawiera on tylko funkcje, do których odwołują się inne programy. Po konsolidacji program jest gotowy do użycia.

Rys. 1. Etapy kompilacji.

2.6 Podział języków programowania.

Podział ze względu na rodzaj translacji:

• kompilowane,• interpretowane.

Podział ze względu na strukturę2 (1):

• języki proceduralne (imperatywne) – programista określa JAKIE operacje maja być wykonane i JAKIEJ KOLEJNOŚCI

• języki nie proceduralne (deklaratywne) – programista opisuje to, CO chce wykazać. Decyzja JAK to wykonać należy do kompilatora.

Podział ze względu na strukturę3 (2):

• języki strukturalne – program rozbity na procedury (podprogramy), z których każda odpowiada za rozwiązanie określonego problemu. Procedury stanowią wtedy odrębne, samodzielnie działające całości, które możemy wykorzystać także i w innych pisanych programach.

• języki niestrukturalne – brak wydzielonych obszarów odpowiedzialnych za rozwiązywanie określonych problemów.

2 http://orfi.geo.kortowo.pl/kierunek/przedmioty/wstep/99/jez1.htm3 http://orfi.geo.kortowo.pl/kierunek/przedmioty/wstep/99/jez1.htm

24/64

kod źródłowy

preprocesor

kompilator

plik wykonywalny

konsolidator (linker)


Podział języków ze względu na zastosowania4:

a) algorytmiczne: do zapisywania algorytmów

• algebraiczne (Fortran, Pascal, C) - do zapisu algorytmów numerycznego przetwarzania informacji

• ekonomiczne (COBOL, PL/1) - opis algorytmów przetwarzania informacji o charakterze ekonomicznym, bankowym, handlowym. Rozbudowane mechanizmy operacji we/wy i pewne możliwości wykonywania operacji na danych nienumerycznych.

• do symbolicznego przetwarzania informacji (LISP) - do zapisu algorytmów przetwarzania informacji numerycznych i na danych symbolicznych

• języki symulacyjne (SIMULA) - ułatwiają opisywanie algorytmów modelowania i symulacji

• bezpośredniego dostępu (BASIC) - pozwalają na konwersję z maszyną.

b) problemowe - ściśle dostosowane do konkretnej klasy zadań.

Podział według struktury (3):

• języki strukturalne (Fortran, Pascal, Algol)• języki zorientowane obiektowo5 (C++ , Visual C++, Turbo Pascal, Delphi, Smalltalk,

Objective-C, Eiffel , Lisp, Oberon, Actor , CLOS, Ada95, Prolog++, Zink, JAVA, J++, Visual Objects, Python):

W ostatnich latach w projektowaniu oprogramowania zorientowanego obiektowo wykształcił się wyraźny podział na:

• OOA - Object Oriented Analysis (Analiza Zorientowana Obiektowo)• OOD - Object Oreinted Design (Projektowanie Zorientowane Obiektowo)• OOP - Object Oriented Programming (Programowanie Zorientowane Obiektowo)

2.7 Przegląd języków programowania.

Asembler – język najbliższy kodu maszynowego. Języki wyższego rzędu często tłumaczą najpierw na asembler, potem na kod maszynowy. Darmowe kompilatory: Flat Assembler, New Basic Assembler. Visual Assembler.

BASIC (Begginers All-purpose Symbolic Instruction Code) - przełomowy w chwili powstania w 1964, potem mocno krytykowany za brak strukturalności, prosty, interpretowany język programowania, spopularyzowany w komputerach ośmiobitowych i kalkulatorach programowanych. Jego twórcy – J. Kemeny i T. Kurtz (Dartmouth College, USA) – przedstawili go jako rewolucyjną propozycję wobec języków algolopodobnych. Basic z założenia nadawał się do pracy interakcyjnej i miał ujmować prostotą (m. in. brak typów, numerowane instrukcje ułatwiały redagowanie programu). Pierwsze implementacje Basica były wykonywane na minikomputerach, a nawet na komputerach stacjonarnych (m. in. na polskich komputerach ODRA 1204 i ODRA 1305, także w wersji kompilowanej). Oprzyrządowany w podstawowe operacje plikowe Basic na długo stał się nie tylko podstawowym językiem mikrokomputerów, lecz także ich systemem operacyjnym. Mimo przydatności do programowania doraźnego w małej skali, oryginalny Basic został odrzucony jako nieprzystosowany do nauczania początkowego informatyki i wyparty przez strukturalny język Logo. Odrodzony i zmetamorfozowany zarówno pod względem struktur sterowania i danych, jak i 4 http://orfi.geo.kortowo.pl/kierunek/przedmioty/wstep/99/jez1.htm5 27

25/64


interfejsu systemowego Basic znajduje szerokie zastosowanie w programowaniu aplikacji dla komputerów typu PC pod postacią platformy programowania RAD o nazwie VisualBasic. W tym nowoczesnym produkcie z Basica pozostała głównie nazwa.

Fortran (FORmula TRANslation - czyli „tłumacz formuł") - jeden z pierwszych szeroko używanych, algorytmicznych języków programowania, opracowany przez J. Backusa w 1957 roku. Po wielu unowocześnieniach jest stosowany do dzisiaj. Język Fortran powstał jako wynik wczesnych doświadczeń w programowaniu komputerów za pomocą autokodów z lat 1951-56. Pierwszą implementację Fortranu wykonano dla maszyny IBM-704. W 1958 powstała wersja Fortran II wprowadzająca możliwość kompilacji niezależnej (IBM-704), a w 1959 jej odpowiednik dla komputera IBM-709. Kolejna wersja Fortranu nosiła nazwę XTRAN, jej autorzy weszli w skład grupy projektującej język Algol 58. Wersja Fortran IV nosiła już wyraźny wpływ języka Algol. Kolejne implementacje to: Fortran II, Fortran IV, Fortran 77, Fortran 90, Fortran 95, Lahey Fortran, Compaq Visual Fortran. W latach sześćdziesiątych XX wieku IBM-owski Fortran spopularyzował się na komputerach różnych typów – zaletą jest duży stopień standaryzacji: od PC do superkomputerów. Fortran posiada z reguły kompilatory (interpreter o nazwie „Watfive” mało popularny). Główne zastosowanie Fortranu to zastosowania numeryczne (rozbudowane biblioteki procedur numerycznych), naukowe i inżynierskie, wymagające programów o dużej szybkości działania. Darmowe kompilatory: G77 (VFort, Prospero).

APL (A Programming Language) - język wysokiego poziomu, stosowany do obliczeń w wyższej matematyce i zagadnieniach inżynierskich (w USA w środowisku inżynierów 80% programów bazuje na APL). Cechą charakterystyczną środowiska APL są specjalne klawiatury z greckimi literami. Język APL umożliwia wykorzystania komputera jako super-kalkulatora: oferuje wielowymiarowe tablice liczb - główne struktury danych.

Język J - nowsza wersja APL, nie wymagającą znaków specjalnych na klawiaturze.

APL2 - lansowany przez IBM jako interakcyjne narzędzie do rozwiązywania problemów, wizualizacji danych i dostępu do baz danych.

Pascal – strukturalny język programowania stworzony w 1971 roku N. Wirth z Politechniki w Zurychu jako język przeznaczony do nauki programowania. Pozostaje on przez to jednym z najszerzej znanych i popularnych języków, zwłaszcza wśród początkujących programistów. Popularność zdobył dzięki implementacji TurboPascal (1983) firmy Borland. TP ma wiele rozszerzeń, dobre zintegrowane środowisko: edytor, debuger, projekty, doskonała pomoc, stosunkowo duża szybkość kompilacji i wykonania, ale bardzo długo ograniczenia pamięci do 64 K. Istnieje wiele udanych kompilatorów i narzędzi do programowania w Pascalu. Siła języka - rozbudowane struktury danych. Typ prosty porządkowy, wyliczeniowy, okrojony, całkowity (shortint, longint, byte), logiczny znakowy (bajt), rzeczywisty (single, double, extended, comp), łańcuchowy, strukturalny, tablicowy, rekordowy, zbiorowy, plikowy, wskaźnikowy. Darmowe kompilatory: Free Pascal, TMTPascal, Inno Pascal, Bloodshed Dev-Pascal, Virtual Pascal, Compas, Ipcute, Irie Pascal.

Modula, Modula-2 - wersje języka programowania wysokiego poziomu, będącego pochodną języka pascal. Język Modula-2 został opracowany przez N. Wirtha w 1980 (pierwsza implementacja na PDP-11 w 1979). W języku Modula (podobnie jak w nowszych wersjach języka Pascal), doceniono znaczenie modularyzacji w budowie oprogramowania. Poszczególne części programu w tym języku mogą niezależnie opracowywać różne osoby, przy czym istnieje system komunikacji między modułami będącymi jednostkami kompilacji. Język pozwala odwoływać się bezpośrednio do sprzętu oraz umożliwia programowanie współbieżne. Implementacje języka:

26/64


Modula-Prolog - do programowania logicznego Modula/R - do programowania baz danych. Modula-2 i Modula-3 o orientacji obiektowej.

Oberon, Oberon-2 – są to kolejne dwa języki Wirtha, zbliżone do języków obiektowych, mało znane.

Język C – proceduralny język programowania wysokiego poziomu, zaprojektowany w 1972 przez D. M. Ritchiego i zrealizowany pod systemem operacyjnym UNIX dla komputera PDP-11. Początkowo C był językiem oprogramowania systemowego (powstał jako język do przeprogramowania systemu UNIX). Szybko zyskał popularność jako uniwersalny język programowania. Cechami języka C są zwięzłość i elastyczność, przy jednoczesnym przerzucaniu dużej odpowiedzialności na programistę (nie ma np. wbudowanej kontroli indeksowania tablic). Język C ma duże możliwości, pozwala dobierać się do rejestrów procesora podobnie jak asembler, łatwo przenosić programy C między różnymi systemami komputerowymi. Struktury danych w C są prostsze niż w Pascalu. W latach 1983-1988 język C uległ standaryzacji. Znormalizowany język C nosi nazwę ANSI C. Jest to jeden z najczęściej obecnie używanych języków na PC.

Ada - język powstał na zlecenie Departamentu Obrony (DoD) USA, gdyż żaden istniejący język nie spełniał ich wymagań. Wymagania: zmniejszyć koszty oprogramowania, zapewnić bezbłędność programu (bezpieczeństwo), ułatwić dalszy rozwój oprogramowania (czytelność), stosować naturalne konstrukcje, zapewnić sprawność. Ada 95 - rozszerza wymagania o większe możliwości współpracy z innymi językami, giętkość konstrukcji języka (używanie obiektów), kontrolę nad zarządzaniem bazami danych i synchronizacją rozproszonych danych oraz standaryzacją bibliotek oprogramowania. Ada 95 jest pierwszym obiektowo zorientowanym językiem, który przeszedł przez proces standaryzacji. Jest uniwersalnym językiem programowania, nadaje się również do programowania w czasie rzeczywistym (sterowanie procesami). Pozwala nawet wstawiać fragmenty kodu maszynowego do programu. Ada jest językiem bogatym, niełatwo go dobrze opanować. Przeprowadzone w połowie lat 90-tych badania efektywności programowania w C i w Adzie pokazały, ze koszty rozwoju programów w C były dwukrotnie wyższe. Składa się na to kiepska czytelność programów napisanych w C i trudności w usuwaniu w nich błędów. Na etapie tworzenia programów zanotowano 70% mniej błędów, a na etapie obsługi klienta aż 90% mniej błędów korzystając z Ady zamiast C. Kompilatory muszą przejść ostre testy zgodności ze standardem. GNAT to darmowy kompilator Ady 95. Darmowe kompilatory: Gnat.

Forth - ciekawy język, opracowany przez Charlesa Moore około 1970 roku do sterowania radioteleskopem, początkowo realizacje na 8-bitowych komputerach, 1994 - standard ANSI Forth. Prosty język, programy są niewielkie, efektywne ale mało czytelne. Odwrotna Polska notacja (Reverse Polish Notation, RPN), używaną również w popularnych kalkulatorach Hewletta-Packarda. Np. (3+4)*5 trzeba napisać: 3 4 + 5 * . __35 ok. Programowanie = definiowanie słów z listy ok. 30 słów bazowych, słowa kompilowane są w całość i dodawane do listy słów. Hierarchia słów = program. Wady: mało używany i nie ma chyba szans na rozpowszechnienie. Darmowe kompilatory: Forth, Forth CMP, GForth, KForth, PForth, Tile-Forth, WForth

Logo – edukacyjny język programowania, biorący początek z badań nad psychologią uczenia się i jego wpływem na kształtowanie osobowości (J. Piaget). Logo stworzone zostało w latach 60-tych przez Daniela Bobrowa, Wallace'a Feurzeiga oraz Seymura Paperta, profesora informatyki z MIT (język

1954-56 John Backus wraz zespołem inżynierów IBM...

Documents

Transcript of 1954-56 John Backus wraz zespołem inżynierów IBM...