Zacznijmy najpierw od wyjaśnienia podstawowych pojęć jak programowanie i język programowania.
A więc programowanie to proces projektowania, tworzenia, testowania i utrzymywania kodu źródłowego programów komputerowych lub urządzeń mikroprocesorowych (mikrokontrolery). Kod źródłowy jest napisany w języku programowania, z użyciem określonych reguł, może on być modyfikacją istniejącego programu lub czymś zupełnie nowym. Programowanie wymaga dużej wiedzy i doświadczenia w wielu różnych dziedzinach, jak projektowanie aplikacji, algorytmika, struktury danych, znajomość języków programowania i narzędzi programistycznych, wiedza nt. kompilatorów, czy sposób działania podzespołów komputera. W inżynierii oprogramowania, programowanie (implementacja) jest tylko jednym z etapów powstawania programu.
Z kolei język programowania to zbiór zasad określających, kiedy ciąg symboli tworzy program (czyli ciąg symboli opisujący obliczenia) oraz jakie obliczenia opisuje.
Podobnie jak języki naturalne, język programowania składa się ze zbiorów reguł syntaktycznych oraz semantycznych, które opisują, jak należy budować poprawne wyrażenia oraz jak komputer ma je rozumieć. Wiele języków programowania posiada pisemną specyfikację swojej składni oraz semantyki, lecz inne zdefiniowane są jedynie przez oficjalne implementacje. Język programowania pozwala na precyzyjny zapis algorytmów oraz innych zadań, jakie komputer ma wykonać. W niektórych pracach pojęcie języka programowania jest ograniczane wyłącznie do tych języków, w których można zapisać wszystkie istniejące algorytmy – od strony matematycznej oznacza to, że język musi być przynajmniej zupełny w sensie Turinga, jednak można się także spotkać z wykorzystaniem tego pojęcia na określenie również bardziej ograniczonych języków.
Języki programowania dzielimy:
1. Ze względu na kryterium przydatności:
- Imperatywne
- Funkcyjne
- Logiczne
- Obiektowe
- Inne
2. Pod względem stopnia zaawansowania na języki generacji:
- Pierwszej
- Drugiej
- Trzeciej
- Czwartej
- Piątej
Programowanie imperatywne
Programowanie imperatywne to paradygmat programowania, który opisuje proces wykonywania jako sekwencję instrukcji zmieniających stan programu. Podobnie jak tryb rozkazujący w lingwistyce wyraża żądania jakichś czynności do wykonania, programy imperatywne składają się z ciągu komend do wykonania przez komputer. Powszechnie programowanie imperatywne uważane jest za synonim programowania proceduralnego.Programowanie imperatywne znacznie różni się od funkcyjnego czy też programowania logicznego. W tamtych paradygmatach nie istnieje pojęcie instrukcji; kładą one bardziej nacisk na to, co ma zostać wykonane, natomiast nie w jaki sposób, co ma miejsce w przypadku programowania proceduralnego.
Historia
Najwcześniejszymi językami imperatywnymi był kod maszynowy pierwotnych komputerów. Istniejące w nich zestawy komend były bardzo proste lub nawet prymitywne - można je było bardzo prosto zaimplementować po stronie sprzętowej, lecz pisanie przy ich pomocy bardziej złożonych programów było niezwykle trudne. Zaprojektowany przez Johna Backusa z IBM język FORTRAN był pierwszym ważniejszym projektem usuwającym niedogodności płynące z pisania bezpośrednio w kodzie maszynowym. Był to język kompilowany umożliwiający stosowanie nazywanych zmiennych, złożonych wyrażeń, procedur i wielu innych struktur typowych dla współczesnego imperatywnego języka programowania. Następne dwie dekady to burzliwy rozwój takich języków. Pod koniec lat pięćdziesiątych i sześćdziesiątych stworzono ALGOL, umożliwiający jeszcze łatwiejsze programowanie algorytmów matematycznych, a nawet występował jako podstawowy język niektórych systemów operacyjnych. COBOL (1960) i BASIC były projektami posiadającymi składnię zbliżoną wyglądem do normalnego języka angielskiego. W latach siedemdziesiątych powstały dwa najpowszechniej stosowane języki imperatywne: Pascal autorstwa Niklausa Wirtha oraz C stworzony przez Dennisa Ritchie, gdy pracował w Bell Laboratories. Wirth rozpoczął później prace nad Modula-2, Modula-3 oraz Oberonem. Na potrzeby Departamentu Obrony Stanów Zjednoczonych Jean Ichbiah oraz zespół inżynierów z Honeywell stworzyli język Ada w 1974, jednak prace nad kompletną specyfikacją trwały aż do 1983 roku.
Od lat osiemdziesiątych datuje się gwałtowny wzrost zainteresowania językami zorientowanymi obiektowo. W swych podstawach nadal miały one charakter imperatywny, lecz dodawały wsparcie dla obiektów. W 1980 roku Xerox Palo Alto Research Center wypuściło na rynek Smalltalk-80, pierwotnie sformułowanego 11 lat wcześniej przez Alana Kaya. Bjarne Stroustrup, bazując na koncepcji pierwszego obiektowego języka na świecie, Simula, wprowadził obiektowość do języka C, tworząc C++, którego pierwsza implementacja powstała w 1985 roku. W latach dziewięćdziesiątych powstał cały szereg imperatywno-obiektowych języków:
• Perl autorstwa Larry'ego Walla (1987)
• Python autorstwa Guido van Rossuma (1990)
• Ruby autorstwa Yukihiro Matsumoto (1995)
• PHP autorstwa Rasmusa Lerdorfa (1995)
• Java wydana po raz pierwszy przez Sun Microsystems w 1994.
Programowanie funkcyjne
Programowanie funkcyjne (lub programowanie funkcjonalne) - filozofia programowania będąca odmianą programowania deklaratywnego, w której funkcje należą do wartości podstawowych, a nacisk kładzie się na wartościowanie (często rekurencyjnych) funkcji, a nie na wykonywanie poleceń.
Języki funkcyjne dzielimy na dwie grupy:
1. Języki czysto funkcyjne
Do tej grupy należą języki, w których nie występują zmienne ani efekty uboczne, a wartościowanie jest leniwe.Wejście/wyjście w takich językach musi się odbywać jakimś alternatywnym mechanizmem, np. za pomocą monad.Przedstawiciele tej podgrupy to Haskell oraz Clean.
2. Języki mieszane
Języki tej grupy są popularniejsze niż języki czysto funkcyjne. Umożliwiają one stosowanie zmiennych, pozwalają na efekty uboczne, tradycyjne wejście/wyjście i mieszanie stylu funkcyjnego z imperatywnym bądź obiektowym. Wartościowanie w nich jest przeważnie zachłanne.Do grupy tej należą LISP z wszystkimi pochodnymi, Scala, języki grupy ML (Standard ML, ocaml więc i bazujący na nim F# Microsoftu), tworzony przez polskich studentów język Nemerle, a także języki, w których elementy funkcyjne nie są aż tak ważne, jak Python, Ruby, a nawet do pewnego stopnia Perl.
Historia
Podstawą teoretyczną programowania funkcyjnego jest opracowany w latach 30. XX wieku przez Alonzo Churcha rachunek lambda, a dokładnie rachunek lambda z typami.
Pierwszym funkcyjnym językiem programowania był Information Processing Language (IPL) opracowany przez Allena Newella, Cliffa Shawa i Herberta Simona w połowie lat 50. XX wieku dla maszyny JOHNNIAC. Jednakże przełom dla programowania funkcyjnego stanowiło opracowanie przez Johna McCarthy pod koniec lat pięćdziesiątych języka LISP dla maszyn IBM 700/7000. LISP wprowadził wiele cech spotykanych we współczesnych językach programowania. Opracowany w latach 70. język Scheme miał za zadanie uproszczenie i poprawienie języka LISP.
W latach 70. powstały dwa kolejne funkcyjne języki programowania: język ML opracowany przez Robina Milnera na Uniwersytecie w Edynburgu oraz język Miranda opracowany przez Davida Turnera na Uniwersytecie w Kent. Język ML dał początek kilku dialektom, z których najpopularniejsze obecnie to Objective Caml oraz Standard ML. Pod koniec lat 80. został opracowany i ustandaryzowany język programowania Haskell, wywodzący się z języka Miranda. Jednym z najnowszych języków funkcyjnych jest rozwijany przez firmę Microsoft język F#. Jest to przeniesienie języka Objective Caml na platformę .NET. Język jest w bardzo dużym stopniu zgodny z oryginałem.
Programowanie logiczne
Programowanie logiczne (nazywane także programowaniem w logice lub programowaniem w języku logiki) to będąca odmianą programowania deklaratywnego metoda programowania, w której program podawany jest jako pewien zestaw zależności, a obliczenia są dowodem pewnego twierdzenia w oparciu o te zależności.
Na przykład chcemy stwierdzić, czy w danym grafie skierowanym istnieje ścieżka z pewnego punktu do pewnego innego punktu. Krawędzie zapisane są relacją edge(Skąd, Dokąd). Nasz program wyglądałby w Prologu tak:
connected(X, Y) :- X = Y.
connected(X, Y) :- edge(X,Z), connected(Z, Y).
Co czytamy następująco:
• istnieje ścieżka z X do Y, jeśli X = Y
• istnieje ścieżka z X do Y, jeśli dla jakiegoś Z istnieje krawędź z X do Z, oraz ścieżka z Z do Y
Programowanie logiczne umożliwia łatwy zapis wielu algorytmów, a programy logiczne w przeciwieństwie do imperatywnych łatwo też wykonywać równolegle.
Programowanie obiektowe
Programowanie obiektowe (ang. object-oriented programming) — paradygmat programowania, w którym programy definiuje się za pomocą obiektów — elementów łączących stan (czyli dane, nazywane najczęściej polami) i zachowanie (czyli procedury, tu: metody). Obiektowy program komputerowy wyrażony jest jako zbiór takich obiektów, komunikujących się pomiędzy sobą w celu wykonywania zadań.
Podejście to różni się od tradycyjnego programowania proceduralnego, gdzie dane i procedury nie są ze sobą bezpośrednio związane. Programowanie obiektowe ma ułatwić pisanie, konserwację i wielokrotne użycie programów lub ich fragmentów.
Programowanie obiektowe dzielimy na:
1. Programowanie oparte na klasach
Definiowane są klasy, czyli typy zmiennych, a następnie tworzone są obiekty, czyli zmienne (w uproszczeniu) tych typów.
2. Programowanie oparte na prototypach
W tym podejściu nie istnieje pojęcie klasy. Nowe obiekty tworzy się w oparciu o istniejący już obiekt - prototyp, po którym dziedziczone są pola i metody i można go rozszerzać o nowe. Spotykany raczej w językach interpretowanych np. JavaScript.
Historia
Koncepcja programowania obiektowego pierwotnie pojawiła się w Simuli 67, języku zaprojektowanym do zastosowań symulacyjnych, stworzonym przez Ole-Johana Dahla i Kristena Nygaarda z Norsk Regnesentral w Oslo. (Mówi się, że pracowali oni nad symulacjami zachowania się statków i mieli kłopoty z opanowaniem wszystkich zależności, jakie wywierały na siebie nawzajem wszystkie parametry statków w symulacji. Wtedy wpadli na pomysł, by pogrupować typy statków w różne klasy obiektów, a każda z klas sama odpowiadałaby za określanie własnych danych i zachowań.) Później koncepcja została dopracowana w języku Smalltalk, stworzonym w Simuli w Xerox PARC, ale zaprojektowanym jako w pełni dynamiczny system, w którym obiekty mogą być tworzone i modyfikowane "w locie", a nie system oparty na statycznych programach.
Programowanie obiektowe zyskało status techniki dominującej w połowie lat 80., głównie ze względu na wpływ C++, stanowiącego rozszerzenie języka C. Dominacja C++ została utrwalona przez wzrost popularności graficznych interfejsów użytkownika, do tworzenia których programowanie obiektowe nadaje się szczególnie dobrze.
W tym okresie cechy obiektowe dodano do wielu języków programowania, w tym Ady, BASIC-a, Lispu, Pascala i innych. Dodanie obiektowości do języków, które pierwotnie nie były do niej przystosowane zrodziło szereg problemów z kompatybilnością i konserwacją kodu. Z kolei "czysto" obiektowym językom brakowało cech, z których programiści przyzwyczajeni byli korzystać. By zapełnić tę lukę podejmowano liczne próby stworzenia języków obiektowych dostarczających jednocześnie "bezpiecznych" elementów proceduralności. Eiffel Bertranda Meyera był wczesnym przykładem w miarę udanego języka spełniającego te założenia; obecnie został on w zasadzie całkowicie zastąpiony przez Javę, głównie za sprawą pojawienia się Internetu, dla którego Java dostarcza szeregu użytecznych funkcji.
Podobnie, jak programowanie funkcyjne doprowadziło do udoskonalenia technik takich, jak programowanie strukturalne, do współczesnych metod projektowania oprogramowania obiektowego zaliczają się takie usprawnienia, jak wzorce projektowe (ang. design patterns), design by contract i języki modelowania (np. UML).
Obiektowość rozprzestrzeniła się dość znacznie, jednak zwykle w systemach hybrydowych, w połączeniu z programowaniem niskopoziomowym (assembler), funkcyjnym (Ocaml, niektóre dialekty Lispu), sieciowym (Java), skryptowym (Perl, Python, Ruby) itd. Systemy czysto obiektowe typu Smalltalka nie znalazły zbyt szerokiego zastosowania.
Stopień zaawansowania języków generacji
Języki programowania dzieli się przede wszystkim pod względem stopnia zaawansowania:
• Języki pierwszej generacji - są to języki maszynowe, czyli języki procesorów. Instrukcje są w nich zapisywane w postaci liczb binarnych.
Przykładowy kod programu:
111010100000000000001111111111111111100010011101100000000010100000001
wbrew pozorom ma to jakiś sens
• Języki drugiej generacji - języki symboliczne, asemblery. Języki niskiego poziomu, pod względem składni tożsame z maszynowymi, z tą różnicą że zamiast liczb używa się tu łatwiejszych do zapamiętania mnemoników.
Przykładowy kod programu:
jmp ffff:0
mov ax, bx
add ax, 1
Należy dodać, iż pod względem znaczenia kod ten jest jednoznaczny z kodem binarnym przedstawionym w poprzednim punkcie (tylko dla procesorów z grupy 80x86).
• Języki trzeciej generacji - języki wysokiego poziomu, proceduralne (imperatywne). W językach tych jedna instrukcja jest tłumaczona na kilka instrukcji procesora, najczęściej od 5 do 10. Pierwszym językiem tego typu był ALGOL. Do tej grupy należą między innymi: FORTH, BASIC - języki niestrukturalne, Pascal, C, FORTRAN - języki strukturalne, C++, Java - języki zorientowane obiektowo.
Przykładowy kod:
if(!x)
{
printf("Nie wolno dzielić przez zero\n");
return 1;
}
• Języki czwartej generacji - języki bardzo wysokiego poziomu, nieproceduralne (deklaratywne). Korzystając z tych języków programista skupia się na problemie, a nie na sposobie jego rozwiązania (języki zorientowane problemowo, ang. task oriented languages). Syntaktyka wielu języków czwartej generacji przypomina składnię języka naturalnego. Są one często używane do dostępu do baz danych. Przykładem języka z tej grupy jest: SQL.
Przykładowy kod:
SELECT Nazwa FROM "Faktura.db" WHERE Cena > 1000
• Języki piątej generacji - języki sztucznej inteligencji, języki systemów ekspertowych. Języki najbardziej zbliżone do języka naturalnego. Przykładem języka piątej generacji jest PROLOG.
Przykładowy kod:
dziadek( A , C ) :-
ojciec( A , B ),
ojciec( B , C ).
dziadek( A , C ) :-
ojciec( A , B ),
matka( B , C).
dziadek( A , C ) :-
matka( A , B ),
ojciec( B , C ).
dziadek( A , C ) :-
matka( A , B ),
matka( B , C ).