Historia Programowania - Część 2: Języki wysokiego poziomu

Slajd przedstawia przesłanki powstania języków wysokiego poziomu oraz ideę uniezależnienia algorytmów od fizycznej architektury procesora.

Abstrakcja od Sprzętu: Języki Kompilowane

Geneza języków 3GL: uciążliwość kodowania w asemblerze oraz brak przenośności programów wymusiły stworzenie języków trzeciej generacji.
Warstwy abstrakcji: oddzielenie zapisu struktur logicznych i matematycznych od fizycznych rejestrów oraz magistral procesora.
Rola kompilatora: zautomatyzowanie translacji kodu źródłowego na optymalny ciąg instrukcji maszynowych konkretnego procesora.
Przenośność oprogramowania: możliwość powtórnej kompilacji tego samego kodu źródłowego na zupełnie odmienne platformy sprzętowe.

Język wysokiego poziomu: język programowania, którego składnia i semantyka odzwierciedlają logiczny opis algorytmu, a nie budowę fizyczną procesora. Wprowadza on zaawansowane typy danych, konstrukcje sterujące oraz abstrakcje pamięciowe, wymagając translatora (kompilatora lub interpretera) do wykonania przez maszynę. Klasycznymi przykładami języków wysokiego poziomu są Fortran, COBOL, C oraz Java.

Poziomy Abstrakcji w Programowaniu

+-------------------------------------+
| Aplikacje (np. edytor tekstu)       |
+-------------------------------------+
| Języki Wysokiego Poziomu (C, Java)  |  <- Skupione na problemie
+-------------------------------------+
| Język Asemblera (mnemoniki)         |  <- Skupione na maszynie
+-------------------------------------+
| Kod Maszynowy (binarny)             |
+-------------------------------------+
| Sprzęt (CPU, Pamięć, Urządzenia)    |
+-------------------------------------+

Slajd ukazuje wkład Grace Hopper w zdefiniowanie koncepcji automatycznej translacji języka symbolicznego na kod maszynowy.

Pionierka Kompilacji: System A-0

Przełom myślowy: przełamanie panującego dogmatu, że komputery potrafią przetwarzać jedynie liczby, a nie ciągi symboli i słów.
System A-0 (1952 r.): stworzenie na maszynie UNIVAC I pierwszego programu łączącego predefiniowane podprogramy biblioteczne.
Instrukcje w języku naturalnym: wprowadzenie koncepcji sterowania maszyną za pomocą zrozumiałych, angielskich słów kluczowych.
Fundament pod COBOL: opracowanie języka FLOW-MATIC, który bezpośrednio zdefiniował założenia biznesowego standardu COBOL.

Kompilator: program komputerowy realizujący przekształcenie tekstu źródłowego zapisanego w języku wysokiego poziomu na semantycznie równoważny kod wynikowy w języku maszynowym lub asemblerze. Proces ten odbywa się w całości przed uruchomieniem aplikacji, co gwarantuje wysoką wydajność czasu wykonania. Pierwsze koncepcje zautomatyzowanej kompilacji sformułowała Grace Hopper w latach 1951-1952.

 Grace Hopper (1906-1992)
 Pionierka informatyki

 +-----------------------------+
 | System A-0 (1952 r.)        |
 |                             |
 | Kody mnemoniczne (pseudo)   |
 |            |                |
 |            v                |
 | [Translacja podprogramów]   |
 |            |                |
 |            v                |
 | Kod maszynowy UNIVAC I      |
 +-----------------------------+

Slajd omawia genezę i znaczenie pierwszego komercyjnego języka kompilowanego dla obliczeń inżynieryjno-naukowych.

Formula Translation System

Inicjatywa IBM (1954-1957 r.): zespół pod kierownictwem Johna Backusa opracował język dedykowany do obliczeń numerycznych na maszynie IBM 704.
Przełom optymalizacyjny: kompilator generował kod maszynowy o sprawności w pełni porównywalnej z ręcznym kodem asemblera.
Algebraiczna składnia: wprowadzenie instrukcji przypisania formuł, obsługi tablic wielowymiarowych oraz pętli iteracyjnej DO.
Trwały standard akademicki: ugruntowanie pozycji lidera w dziedzinie symulacji numerycznych i fizyki komputerowej na wiele dekad.

FORTRAN (Formula Translation): pierwszy skompilowany język programowania wysokiego poziomu ogólnego przeznaczenia, stworzony do numerycznych obliczeń inżynieryjnych i naukowych. Wprowadził zwięzłą notację formuł matematycznych oraz wyznaczył standardy w dziedzinie optymalizacji kodu maszynowego przez kompilatory. Dialekty Fortranu pozostają w powszechnym użyciu w klastrach superkomputerowych.

C     PROGRAM OBLICZAJACY POLE KOLA
      PROGRAM AREA
      REAL R, PI, S
      PI = 3.14159
      
      PRINT *, 'Podaj promien kola:'
      READ *, R
      
      S = PI * R * R
      
      PRINT *, 'Pole powierzchni wynosi:', S
      END PROGRAM AREA

Slajd przedstawia założenia i architekturę języka COBOL jako uniwersalnego standardu dla aplikacji księgowo-finansowych.

Common Business-Oriented Language

Inicjatywa CODASYL (1959 r.): standaryzacja jednolitego języka dla administracji rządowej i sektora finansowego pod patronatem Departamentu Obrony USA.
Składnia angielska: budowanie instrukcji w formie pełnych zdań języka angielskiego w celu ułatwienia audytu i konserwacji kodu.
Cztery dywizje: ustrukturyzowany podział programu na sekcje: Identification, Environment, Data oraz Procedure Division.
Przetwarzanie rekordów: zaawansowane mechanizmy definicji struktur rekordowych, liczb stałoprzecinkowych i plików wsadowych.

COBOL (Common Business-Oriented Language): język programowania wysokiego poziomu zaprojektowany do przetwarzania danych w bankowości, ubezpieczeniach i zarządzaniu przedsiębiorstwem. Charakteryzuje się składnią naśladującą naturalny język angielski oraz wysoce rozwiniętymi strukturami opisu danych i plików dyskowych. Do dziś przetwarza przeważającą część globalnych transakcji w środowiskach mainframe.

Struktura Programu w Języku COBOL

+-------------------------------------+
| IDENTIFICATION DIVISION.            |  <- Metadane programu
+-------------------------------------+
| ENVIRONMENT DIVISION.               |  <- Konfiguracja sprzętu
+-------------------------------------+
| DATA DIVISION.                      |  <- Definicje rekordów
+-------------------------------------+
| PROCEDURE DIVISION.                 |  <- Logika algorytmu
+-------------------------------------+

Slajd charakteryzuje etapy modularnej architektury kompilatora oraz zadania fazy analizy, optymalizacji i syntezy programu.

Wielofazowa Transformacja Kodu

Front-end (faza analizy): analiza leksykalna, składniowa i semantyczna badająca poprawność kodu i budująca drzewo AST.
Middle-end (optymalizacje IR): przekształcenia uniwersalne operujące na kodzie pośrednim niezależnym od procesora.
Back-end (faza syntezy): dobór rejestrów, uszeregowanie rozkazów i generowanie binarnego kodu dla konkretnego CPU.
Spójność semantyczna: kompilator gwarantuje precyzyjne zachowanie logiki algorytmu przy maksymalnej optymalizacji.

Kompilacja wielofazowa: metodyka budowy kompilatorów polegająca na podziale procesu translacji na sekwencję wyspecjalizowanych etapów transformujących kod z postaci tekstowej do binarnej. Umożliwia ona oddzielenie analizy zależnej od języka (front-end) od generowania kodu zależnego od procesora (back-end). Współczesne kompilatory wykorzystują ujednolicony kod pośredni łączący wiele języków z wieloma architekturami.

Architektura Trójfazowa Kompilatora

[ Kod źródłowy ]
       |
       v
+------------------+
|    FRONT-END     |  <- Lekser, Parser, AST
+------------------+
       |  (Kod Pośredni IR)
       v
+------------------+
|    MIDDLE-END    |  <- Optymalizacje niezależne
+------------------+
       |  (Zoptymalizowany IR)
       v
+------------------+
|     BACK-END     |  <- Alokacja rejestrów, Emisja
+------------------+
       |
       v
[ Kod maszynowy ]

Slajd opisuje działanie analizatora leksykalnego jako pierwszego filtru przetwarzającego ciąg znaków w uporządkowany strumień tokenów.

Dzielenie Kodu na Słowa

Rola leksera (skanera): sekwencyjny odczyt surowego strumienia znaków z pliku źródłowego i grupowanie ich w leksemy.
Klasyfikacja tokenów: przypisywanie każdemu leksemowi typu syntaktycznego: słowo kluczowe, identyfikator, literał, operator.
Oczyszczanie kodu: bezwzględne usuwanie znaków formatujących, spacji, tabulacji oraz komentarzy programistycznych.
Wykrywanie błędów leksykalnych: natychmiastowe sygnalizowanie znaków niedozwolonych w alfabecie danego języka.

Analiza leksykalna (tokenizacja): wstępny etap kompilacji realizowany przez lekser, polegający na przekształceniu sekwencji znaków kodu źródłowego w strumień ustrukturyzowanych tokenów. Każdy token zawiera typ składniowy oraz przypisaną mu wartość leksykalną. Do automatycznego generowania lekserów powszechnie stosuje się automaty skończone oraz narzędzia typu Lex lub Flex.

Strumień znaków:
int a = 10;

        |
        v [ Lekser / Skaner ]
        v

Strumień tokenów:
+---------------+---------------+
| Typ tokena    | Wartość       |
+---------------+---------------+
| KEYWORD       | 'int'         |
| IDENTIFIER    | 'a'           |
| OPERATOR      | '='           |
| LITERAL_INT   | '10'          |
| SEPARATOR     | ';'           |
+---------------+---------------+

Slajd wyjaśnia mechanizm weryfikacji gramatycznej programu oraz tworzenia hierarchicznego drzewa składniowego.

Budowanie Struktury Programu

Rola parsera: weryfikacja poprawności sekwencji tokenów w oparciu o gramatykę bezkontekstową języka programowania.
Notacja BNF: formalny zapis reguł składniowych wprowadzony przez Johna Backusa i Petera Naura przy definicji ALGOL 60.
Budowa drzewa AST: generowanie hierarchicznej struktury obiektowej odzwierciedlającej priorytety operatorów i bloków.
Detekcja błędów składniowych: precyzyjne wykrywanie brakujących nawiasów, separatorów i niedozwolonych sekwencji poleceń.

Drzewo składni abstrakcyjnej (AST): hierarchiczna struktura danych reprezentująca logiczną budowę programu komputerowego, oczyszczona z nieistotnych detali czysto składniowych. Wierzchołki wewnętrzne drzewa odpowiadają operatorom i instrukcjom, natomiast liście reprezentują operandy, zmienne i literały. AST stanowi centralną strukturę roboczą dla fazy analizy semantycznej i generowania kodu pośredniego.

Instrukcja: a = b + 5;

Drzewo Składni Abstrakcyjnej (AST)

         [ ASSIGNMENT: = ]
             /                    /                [ IDENT: a ]   [ BIN_OP: + ]
                        /                            /                        [ IDENT: b ] [ LITERAL: 5 ]

Slajd charakteryzuje etap weryfikacji zgodności typów, zasięgu identyfikatorów i logicznej spójności programu.

Sprawdzanie Znaczenia i Poprawności Logicznej

Rola analizy semantycznej: badanie, czy składniowo poprawny program jest zgodny z logicznymi regułami języka.
Tablica symboli: zarządzanie rejestrem identyfikatorów, przechowującym informacje o typach, zasięgu i adresach zmiennych.
Kontrola typów (type checking): weryfikacja dopuszczalności operacji na operandach oraz poprawności niejawnych konwersji.
Kontrola zasięgu (scoping): sprawdzanie widoczności zmiennych lokalnych i globalnych oraz poprawności wywołań funkcji.

Analiza semantyczna: faza kompilatora odpowiedzialna za sprawdzenie poprawności logicznej i znaczeniowej programu w oparciu o reguły semantyki statycznej języka. Obejmuje kontrolę typów danych, badanie zasięgu deklaracji zmiennych oraz weryfikację sygnatur wywoływanych funkcji. Wykrywa błędy merytoryczne, których nie jest w stanie zidentyfikować parser badający wyłącznie składnię gramatyczną.

Tablica Symboli (Symbol Table)

+---------+--------+--------+---------------+
| Nazwa   | Typ    | Zasięg | Adres/Offset  |
+---------+--------+--------+---------------+
| a       | int    | local  | ebp - 4       |
| b       | int    | local  | ebp - 8       |
| total   | float  | global | 0x00408000    |
+---------+--------+--------+---------------+

Weryfikacja reguły:
a = b + "tekst";  --> [ BŁĄD SEMANTYCZNY: Niezgodność typów ]

Slajd przedstawia ideę i zastosowanie kodu pośredniego jako uniwersalnego mostu łączącego języki źródłowe z procesorami.

Uniwersalna Reprezentacja Programu

Niezależność od architektury: zapis algorytmu w ujednoliconym formacie maszyny wirtualnej niezależnym od fizycznego procesora.
Kod trójadresowy (TAC): rozbicie złożonych wyrażeń na sekwencję elementarnych instrukcji z maksymalnie trzema adresami.
Postać SSA: modelowanie przypisań w konwencji Static Single Assignment ułatwiającej śledzenie przepływu danych.
Skalowalność środowiska: obsługa N języków i M architektur procesorów wymaga jedynie N front-endów i M back-endów.

Kod pośredni (Intermediate Representation, IR): uniwersalna, niskopoziomowa reprezentacja programu generowana w trakcie kompilacji, niezależna od języka źródłowego i platformy sprzętowej. Ułatwia przeprowadzanie uniwersalnych optymalizacji oraz umożliwia modułową budowę kompilatorów wieloplatformowych. Przykładami IR są kod trójadresowy (TAC), LLVM IR oraz bajtokod maszyn wirtualnych.

Drzewo AST:        Kod Trójadresowy (TAC):
   x = a + b * c      t1 = b * c
                      t2 = a + t1
                      x = t2

Zasada N x M kompilatorów:
Język C   ---\               /---> x86-64
Fortran   ----+--> [ IR ] --+----> ARM64
Rust      ---/               \---> RISC-V

Slajd omawia metody optymalizacji kodu oraz procedurę translacji do ostatecznych instrukcji binarnych procesora.

Tworzenie Wydajnego Kodu Maszynowego

Optymalizacje niezależne: zwijanie stałych (constant folding), eliminacja martwego kodu oraz usuwanie wspólnych podwyrażeń.
Optymalizacje pętli: rozwijanie pętli (loop unrolling), wektoryzacja SIMD oraz wynoszenie niezmienników poza pętlę.
Alokacja rejestrów: odwzorowanie nieograniczonej puli zmiennych IR na ograniczoną liczbę rejestrów fizycznych procesora.
Generowanie kodu maszynowego: dobór specyficznych instrukcji CPU, uszeregowanie rozkazów i emisja pliku obiektowego.

Optymalizacja kodu: proces systematycznej transformacji kodu programu realizowany przez kompilator w celu minimalizacji czasu jego wykonania, zużycia pamięci lub rozmiaru pliku binarnego bez zmiany zewnętrznego zachowania algorytmu. Obejmuje optymalizacje uniwersalne oraz niskopoziomowe dostrojenie rozkazów do architektury jednostki centralnej.

Kod przed optymalizacją:     Kod po optymalizacji:
x = 10 + 5;                  x = 15;      (zwijanie stałych)
y = x * 1;                   y = x;       (redukcja siły)
if (0) { z = 20; }           // usunięto  (martwy kod)

Alokacja Rejestrów (Kolorowanie Grafu):
Zmienne [t1, t2, t3, t4] ---> Rejestry CPU [RAX, RBX, RCX]

Slajd analizuje zyski wydajnościowe oraz ograniczenia technologiczne wynikające ze stosowania klasycznej kompilacji wyprzedzającej AOT.

Analiza Modelu Kompilowanego

Maksymalna wydajność: bezpośrednie wykonywanie przez jednostkę centralną bez narzutu interpretera czasu rzeczywistego.
Wczesna weryfikacja błędów: statyczna kontrola typów i składni gwarantuje eliminację usterek przed wdrożeniem produkcyjnym.
Wydłużony cykl budowania: konieczność czasochłonnej rekompilacji i linkowania projektów przy każdej drobnej modyfikacji.
Zależność binarna od platformy: plik wykonywalny jest ściśle związany z danym systemem operacyjnym i architekturą procesora.

Kompilacja AOT (Ahead-Of-Time): model translacji, w którym cały kod źródłowy programu zostaje przekształcony do binarnego kodu maszynowego przed dystrybucją i uruchomieniem aplikacji. Zapewnia najwyższą sprawność energetyczną i obliczeniową, lecz uniemożliwia bezpośrednie przeniesienie pliku binarnego na inną platformę sprzętowo-systemową. Stosowana w językach C, C++, Rust i Go.

+-----------------------------------+
| Zalety Modelu Kompilowanego (AOT) |
+-----------------------------------+
| + Najwyższa wydajność wykonania   |
| + Optymalizacja zużycia pamięci   |
| + Statyczne wykrywanie błędów     |
| + Ochrona kodu źródłowego (binar) |
+-----------------------------------+
| Ograniczenia i Wady Kompilacji    |
+-----------------------------------+
| - Długi czas kompilacji projektów |
| - Brak bezpośredniej przenośności |
| - Sztywny cykl: kod-budowa-test   |
+-----------------------------------+

Slajd wprowadza model interpretacji jako metodę bezpośredniego wykonywania kodu źródłowego bez konieczności tworzenia plików binarnych.

Alternatywa dla Kompilacji

Bezpośrednie wykonanie: program jest wykonywany bezpośrednio z tekstu źródłowego lub pamięci podręcznej bajtokodu.
Rola interpretera: wyspecjalizowana aplikacja odczytuje instrukcje w locie i natychmiast zleca ich realizację procesorowi.
Elastyczność deweloperska: eliminacja fazy kompilacji i linkowania umożliwia natychmiastowe testowanie wprowadzanych zmian.
Uniwersalna przenośność: ten sam plik źródłowy działa na dowolnej platformie wyposażonej w zgodny interpreter.

Interpretacja: metoda wykonywania oprogramowania, w której program zwany interpreterem bezpośrednio analizuje i wykonuje instrukcje kodu źródłowego lub pośredniego krok po kroku bez uprzedniego tworzenia natywnego pliku binarnego. Zapewnia pełną przenośność kodu źródłowego oraz elastyczność programowania kosztem niższego tempa wykonywania obliczeń. Pionierskim językiem interpretowanym był LISP (1958 r.).

Model Kompilowany (AOT)
[ Kod źródł. ] -> [ Kompilator ] -> [ Plik Binarny ] -> CPU
                    (oddzielny etap budowy)

Model Interpretowany
[ Kod źródł. ] ---                   +--> [ INTERPRETER ] --> Natychmiastowe
Dane programu  ---/                         wykonanie (CPU)

Slajd opisuje architekturę wewnętrzną interpretera oraz mechanizm interaktywnej pętli Read-Eval-Print Loop (REPL).

Program Wykonujący Inne Programy

Wirtualna maszyna logiczna: interpreter symuluje działanie procesora, dekodując rozkazy języka na wewnętrzne procedury.
Pętla REPL: sekwencyjny cykl: odczyt instrukcji (Read), ewaluacja semantyczna (Eval), druk wyniku (Print) i powrót (Loop).
Brak kodu maszynowego: interpreter sam wywołuje prekompilowane funkcje biblioteczne realizujące żądane zadanie.
Dynamiczne środowisko: możliwość inspekcji i modyfikacji stanu programu, zmiennych oraz struktur danych w czasie rzeczywistym.

Interpreter: oprogramowanie symulujące maszynę wirtualną zdolną do natychmiastowego dekodowania i wykonywania instrukcji zapisanych w określonym języku programowania. Współczesne interpretery często łączą szybką minikompilację do bajtokodu z jego interpretacją na wirtualnej maszynie stosowej. Podstawową cechą interpretera jest udostępnianie interaktywnego środowiska REPL.

Pętla Interpretera (REPL)

  +--------------------------------+
  |              START             |
  +--------------------------------+
                  |
                  v
  +--------------------------------+
  | READ  (Odczytaj kod/linię)     | <-- Wejście użytkownika / plik
  +--------------------------------+
                  |
                  v
  +--------------------------------+
  | EVAL  (Przeanalizuj i wykonaj) | <-- Wywołanie procedur
  +--------------------------------+
                  |
                  v
  +--------------------------------+
  | PRINT (Wyświetl rezultat)      | <-- Wyjście na terminal
  +--------------------------------+
                  |
                  v
  +--------------------------------+
  | LOOP  (Powrót do nowego cyklu) |
  +--------------------------------+

Slajd zestawia techniczne i ekonomiczne właściwości kompilacji statycznej oraz dynamicznej interpretacji.

Dwa Podejścia, Różne Kompromisy

Moment translacji: pełna translacja przed uruchomieniem (AOT jednorazowo) vs translacja w trakcie biegu aplikacji.
Profil wydajnościowy: bezpośrednia szybkość kodu natywnego vs elastyczność i narzut emulacyjny interpretera.
Wykrywanie błędów: weryfikacja statyczna w fazie budowania projektu vs detekcja dynamiczna w momencie wykonania danej linii.
Technologia JIT: hybrydowa kompilacja w locie łącząca natychmiastowy start interpretera z optymalizacją gorących pętli.

Kompilacja Just-In-Time (JIT): hybrydowa technologia wykonywania programów, w której kod pośredni lub kod źródłowy jest interpretowany, a najczęściej wykonywane fragmenty (tzw. gorące ścieżki) są dynamicznie kompilowane do natywnego kodu maszynowego w pamięci RAM w trakcie działania programu. Łączy zalety szybkiego uruchomienia i przenośności z wydajnością kodu skompilowanego. Stosowana m.in. w silnikach Java i JavaScript.

Zestawienie Komparatywne Modeli

+-------------------+---------------------+---------------------+
| Cecha             | Kompilacja (AOT)    | Interpretacja       |
+-------------------+---------------------+---------------------+
| Moment translacji | Przed uruchomieniem | W trakcie biegu     |
| Plik wynikowy     | Binarny kod CPU     | Brak (kod w locie)  |
| Wydajność         | Bardzo wysoka       | Średnia / niska     |
| Czas startu       | Natychmiastowy      | Natychmiastowy      |
| Czas modyfikacji  | Długi (rekompilacja)| Błyskawiczny        |
| Przenośność       | Wymaga rekompilacji | Przenośny skrypt    |
+-------------------+---------------------+---------------------+

Slajd przedstawia motywy powstania języków skryptowych jako narzędzi integracji gotowych komponentów systemowych.

Języki Stworzone do Integracji Systemu

Dychotomia Ousterhouta: podział na języki kompilowane do budowy komponentów oraz języki skryptowe do ich łączenia (glue languages).
Automatyzacja procesów: zastąpienie powtarzalnych procedur manualnych wiersza poleceń zwięzłymi skryptami zadaniowymi.
Wysoka ekspresja tekstowa: silne wbudowane wsparcie dla manipulacji plikami, ciągami znaków i potokami I/O.
Dynamiczne typowanie: brak uciążliwych deklaracji typów przyspieszający pisanie narzędzi administracyjnych.

Język skryptowy: język programowania wysokiego poziomu zaprojektowany z myślą o szybkiej automatyzacji zadań administracyjnych, przetwarzaniu tekstu oraz łączeniu istniejących komponentów i aplikacji w zintegrowane systemy. Charakteryzuje się zazwyczaj dynamicznym typowaniem, brakiem jawnego kroku kompilacji oraz rozbudowanym wsparciem dla operacji wejścia-wyjścia i wywołań systemowych. Do kanonu języków skryptowych należą Bash, Perl, Python oraz PowerShell.

Dychotomia Johna Ousterhouta

Języki Kompilowane (C, C++, Rust)
+-----------------------------------+
| Tworzenie komponentów od podstaw  |
| - Maksymalna wydajność            |
| - Ścisła kontrola pamięci         |
| - Statyczne typowanie             |
+-----------------------------------+
                 |
                 v  [ Komponenty binarne ]
+-----------------------------------+
| Języki Skryptowe jako Spoiwo      |
| - Bash, Python, Perl, PowerShell  |
| - Łączenie programów w potoki     |
| - Szybka automatyzacja zadań      |
+-----------------------------------+

Slajd charakteryzuje strukturę skryptu jako samowykonywalnego pliku tekstowego sterującego podsystemami operacyjnymi.

Zapisana Sekwencja Poleceń

Metafora scenariusza: plik skryptowy zawiera ścisłą sekwencję dyrektyw wykonywanych przez interpreter krok po kroku.
Mechanizm Shebang: nagłówek #!/bin/bash wskazujący jądru systemu ścieżkę do właściwego interpretera poleceń.
Prawa wykonywalności: uniksowy atrybut chmod +x umożliwiający bezpośrednie uruchamianie skryptu z poziomu powłoki.
Rozbudowana logika: wzbogacenie sekwencji komend o zmienne, instrukcje warunkowe, pętle i kody zakończenia (exit codes).

Skrypt: plik tekstowy zawierający sekwencję instrukcji i poleceń przeznaczonych do wykonania przez określony interpreter języka skryptowego. Pełni rolę zautomatyzowanego scenariusza realizującego złożone procesy przetwarzania danych, administrowania zasobami i zarządzania plikami. W systemach uniksowych nagłówek shebang precyzuje środowisko wykonawcze skryptu.

Anatomia Skryptu Powłoki (backup.sh)

#!/bin/bash
# Shebang: informacja dla jądra o interpreterze

echo "Rozpoczynam tworzenie kopii zapasowej..."

# Krok 1: Archiwizacja katalogu
tar -czf /tmp/backup.tar.gz /home/user

# Krok 2: Weryfikacja kodu zakończenia
if [ $? -eq 0 ]; then
    echo "Kopia wykonana pomyslnie."
else
    echo "BLAD archiwizacji!" >&2
    exit 1
fi

Slajd podsumowuje powstanie powłoki Uniksa jako pierwszego kompletnego, interaktywnego środowiska programowania skryptowego.

Środowisko Skryptowe od samego Początku

Ewolucja powłok: dynamiczny rozwój od Thompson shell (1971 r.), przez standardowy Bourne shell (1979 r.), po C shell i Bash.
Potoki i strumienie: unifikacja komunikacji między programami za pomocą standardowego wejścia, wyjścia i potoku |.
Powłoka jako interpreter: wyposażenie powłoki w zmienne środowiskowe, pętle for/while oraz testy warunkowe.
Fundament automatyzacji: stworzenie uniwersalnego środowiska administracji, które położyło podwaliny pod nowoczesne technologie DevOps.

Powłoka uniksowa (Unix shell): program pełniący rolę tekstowego interfejsu użytkownika (CLI) oraz pełnoprawnego języka programowania skryptowego w systemach rodziny Unix i Linux. Umożliwia uruchamianie programów, sterowanie procesami, przekierowywanie strumieni wejścia-wyjścia oraz automatyzację zadań administracyjnych. Do klasycznych standardów powłoki należą sh (Bourne shell) oraz Bash (Bourne-Again Shell).

Potok Uniksowy w Praktyce

Polecenie:
$ cat log.txt | grep "ERROR" | wc -l

Przepływ Strumieni Tekstowych:
+-------------+ stdout      stdin +-------------+
| cat log.txt | --------+--------> | grep ERROR  |
+-------------+         |         +-------------+
                     [ POTOK | ]         | stdout
                                         |
                                         v stdin
                                  +-------------+
                                  |    wc -l    |
                                  +-------------+
                                         | stdout
                                         v
                                  Terminal (Ekran)