Historia Programowania - Część 3: Języki skryptowe

Slajd przedstawia aksjomaty filozofii projektowej systemu UNIX i koncepcję budowania złożonych procesów z prostych narzędzi.

Małe Narzędzia, Wielkie Możliwości

Zasada modułowości: projektuj programy, które wykonują tylko jedno ściśle określone zadanie, ale wykonują je doskonale.
Kompozycyjność procesów: twórz narzędzia zaprojektowane od podstaw do współpracy z innymi programami narzędziowymi.
Strumienie tekstowe: standaryzacja interfejsu wymiany danych w oparciu o uniwersalny format strumienia znaków.
Rola spoiwa: języki powłoki systemowej pełnią funkcję elastycznego spoiwa łączącego pojedyncze aplikacje w złożone potoki.

Filozofia systemu UNIX: zbiór reguł i wzorców projektowych inżynierii oprogramowania sformułowanych przez twórców systemu UNIX (m.in. Kena Thompsona i Douga McIlroya). Kładzie nacisk na prostotę, minimalizm kodu, unifikację interfejsów wejścia-wyjścia w formacie tekstowym oraz kompozycyjność narzędzi za pomocą potoków. Wyznaczyła fundamenty pod architekturę współczesnych systemów Linux i ruch open source.

Kanoniczne Reguły Filozofii UNIX

1. Pisz programy, które robią jedną rzecz
   i robią ją dobrze.
2. Pisz programy, które współpracują ze sobą.
3. Pisz programy operujące na strumieniach
   tekstowych (uniwersalny interfejs).

      +-------------------+
      | Narzędzie A (cat) |
      +---------+---------+
                | [ POTOK | ]
                v
      +-------------------+
      | Narzędzie B (grep)|
      +---------+---------+
                | [ POTOK | ]
                v
      +-------------------+
      | Narzędzie C (sort)|
      +-------------------+

Slajd demonstruje praktyczne zastosowanie potoku uniksowego do wieloetapowego przetwarzania danych tekstowych.

Potęga Potoków (Pipelines)

Potok wieloetapowy: zestawienie standardowych filtrów (tr, sort, uniq, head) w zwięzłą procedurę statystyczną.
Transfer strumieniowy: bezpośrednie łączenie wyjścia stdout poprzednika z wejściem stdin następnika za pomocą |.
Optymalizacja pamięci: brak konieczności alokowania plików tymczasowych na dysku dzięki przetwarzaniu w buforze RAM.
Równoległość wykonania: jądro systemu uruchamia wszystkie ogniwa potoku jednocześnie, koordynując przepływ danych.

Potok uniksowy (pipeline): mechanizm komunikacji międzyprocesowej (IPC) w systemach rodziny Unix, który łączy standardowe wyjście (stdout) jednego procesu ze standardowym wejściem (stdin) następnego procesu za pomocą operatora |. Umożliwia sekwencyjne przetwarzanie strumieni danych w locie bez konieczności tworzenia plików pośrednich na dysku. Buforowaniem i synchronizacją potoku zarządza bezpośrednio jądro systemu operacyjnego.

Analiza Najczęstszych Słów w Pliku:

$ tr -cs '[:alnum:]' '
' < plik.txt | sort | uniq -c | sort -rn | head -n 5

Przebieg Transformacji Danych:
1. tr -cs      -> rozbicie tekstu na słowa w wierszach
2. sort        -> alfabetyczne uporządkowanie leksemów
3. uniq -c     -> zliczenie unikalnych wystąpień słów
4. sort -rn    -> sortowanie liczbowe malejące
5. head -n 5   -> wyselekcjonowanie 5 liderów zestawienia

Slajd charakteryzuje powłokę GNU Bash jako podstawowe środowisko skryptowe i narzędzie automatyzacji w systemach Linux.

Ewolucja Powłoki: Bash jako Standard

Projekt GNU (1989 r.): powłoka stworzona przez Briana Foxa jako wolne, w pełni kompatybilne rozwinięcie powłoki Bourne'a (sh).
Rozszerzenia składniowe: wzbogacenie języka o tablice asocjacyjne, arytmetykę liczb całkowitych i zaawansowane pętle for/while.
Integracja z Coreutils: ścisła współpraca ze standaryzowanym pakietem podstawowych narzędzi systemowych GNU.
Automatyzacja procesów: wszechobecne zastosowanie w skryptach startowych systemd, harmonogramach cron i procedurach CI/CD.

GNU Bash (Bourne-Again Shell): domyślna powłoka systemowa i język skryptowy w większości dystrybucji systemu Linux, stworzona w ramach projektu GNU. Zapewnia pełną zgodność wsteczną ze standardem powłoki Bourne'a (sh), wprowadzając zaawansowane mechanizmy tablicowe, kontrolę zadań oraz rozbudowaną składnię funkcyjną. Stanowi podstawowe narzędzie administrowania serwerami i tworzenia skryptów automatyzacji infrastruktury.

Skrypt Bash z Tablicą i Pętlą Iteracyjną

#!/bin/bash
# Deklaracja tablicy plików konfiguracyjnych
PLIKI=("/etc/hosts" "/etc/resolv.conf" "/etc/hostname")

for PLIK in "${PLIKI[@]}"; do
    if [ -f "$PLIK" ]; then
        echo "Plik $PLIK: ISTNIEJE (rozmiar: $(wc -c < "$PLIK") B)"
    else
        echo "Brak pliku: $PLIK" >&2
    fi
done

Slajd przedstawia genezę i architekturę plików wsadowych BAT/CMD jako pierwszych narzędzi automatyzacji w środowisku Microsoftu.

Automatyzacja w Świecie DOS i Windows

Interpreter COMMAND.COM: sekwencyjny mechanizm wykonywania komend wprowadzony w 1981 r. w systemie MS-DOS.
Ewolucja w architekturze NT: wprowadzenie 32-bitowego interpretera cmd.exe oraz formatu plików wsadowych .cmd.
Ograniczenia techniczne: operowanie wyłącznie na ciągach znaków, brak typowania i prymitywna kontrola błędów przez ERRORLEVEL.
Dziedzictwo przemysłowe: pliki .bat pozostają obecne w systemach produkcyjnych ze względu na kompatybilność wsteczną.

Plik wsadowy (Batch file): plik tekstowy z rozszerzeniem .bat lub .cmd zawierający sekwencję poleceń przeznaczonych do interpretacji przez powłokę COMMAND.COM lub cmd.exe w systemach MS-DOS i Microsoft Windows. Umożliwia realizację prostych scenariuszy kopiowania plików, uruchamiania programów i podstawowej konfiguracji środowiska użytkownika. Ze względu na ograniczone możliwości przetwarzania danych strukturalnych został w środowiskach profesjonalnych zastąpiony przez PowerShell.

Przykładowy Plik Wsadowy Windows (deploy.bat)

@echo off
REM Skrypt wsadowy automatyzacji kompilacji
echo Rozpoczynam przetwarzanie wsadowe...

IF NOT EXIST "C:\Build" (
    mkdir "C:\Build"
)

copy /Y *.dat "C:\Build"
IF %ERRORLEVEL% NEQ 0 (
    echo BLAD: Kopiowanie zakonczone niepowodzeniem!
    exit /b 1
)

echo Przetwarzanie zakonczone pomyslnie.

Slajd omawia przełom technologiczny platformy PowerShell polegający na wprowadzeniu obiektowego potoku danych.

Nowoczesne Skryptowanie w Środowisku Windows

Projekt Monad (2006 r.): opracowanie przez Jeffreya Snovera powłoki zintegrowanej z obiektowym środowiskiem .NET CLR.
Potok obiektowy: przekazywanie w potoku żywych obiektów z metodami i polami zamiast surowego strumienia tekstu.
Standaryzacja cmdletów: jednolita reguła nazewnicza Czasownik-Rzeczownik (np. Get-Process, Where-Object, Stop-Service).
Wieloplatformowość: rozwój PowerShell Core jako środowiska open source dostępnego w systemach Windows, Linux i macOS.

PowerShell: zaawansowana powłoka systemowa i zorientowany obiektowo język skryptowy opracowany przez firmę Microsoft, zintegrowany ze środowiskiem .NET. Jej fundamentalną cechą jest potok obiektowy (Object Pipeline), który zamiast tekstu przekazuje ustrukturyzowane obiekty z kompletem atrybutów i metod. Stanowi wiodące narzędzie zarządzania infrastrukturą chmurową Azure, systemami Windows Server oraz środowiskami heterogenicznymi.

Potok Tekstowy (UNIX) vs Potok Obiektowy (PowerShell)

UNIX (Tekst):
$ ps aux | grep "nginx" | awk '{print $2}'
-> Strumień bajtów tekstowych, wymaga parsowania kolumn

PowerShell (Obiekty):
PS> Get-Process -Name "nginx" | Where-Object WorkingSet -gt 100MB
-> Przekazywanie obiektów System.Diagnostics.Process:
   [ Id: 1420, Name: "nginx", CPU: 2.4, WS: 112MB ]

Slajd identyfikuje uniwersalne właściwości techniczne odróżniające języki skryptowe od języków kompilacji statycznej.

Kluczowe Cechy i Mechanizmy

Dynamiczne typowanie: typ danych jest związany z wartością zmiennej w pamięci, a nie z jej nazwą w kodzie źródłowym.
Automatyczne zarządzanie pamięcią: wbudowany odśmiecacz pamięci (Garbage Collector) usuwa nieużywane obiekty.
Struktury wysokopoziomowe: natywne wsparcie dla list dynamicznych, słowników haszujących i wyrażeń regularnych.
Szybki cykl deweloperski: natychmiastowe uruchamianie kodu bez konieczności oczekiwania na kompilację i linkowanie.

Język dynamicznie typowany: język programowania, w którym weryfikacja poprawności typów operacji odbywa się w trakcie wykonywania programu (runtime), a nie podczas statycznej kompilacji kodu. Zmienne mogą dynamicznie zmieniać typ przechowywanej wartości w trakcie działania aplikacji, co przyspiesza tworzenie oprogramowania kosztem wyższego ryzyka błędów czasu wykonania. Mechanizm ten jest charakterystyczny dla języków Python, JavaScript, Ruby i PHP.

Typowanie Statyczne vs Typowanie Dynamiczne

C / C++ (Statyczne):
int a = 10;
a = "tekst";    // <-- BŁĄD KOMPILACJI (niezgodność typów)

Python / Bash / JS (Dynamiczne):
x = 10          # x wskazuje na obiekt liczbowy
x = "tekst"     # x wskazuje na obiekt łańcuchowy (POPRAWNE)

Zarządzanie Pamięcią:
[ Obiekt A ] <-- brak referencji --> [ Usunięty przez GC ]

Slajd przedstawia dominujące obszary zastosowania języków skryptowych we współczesnej inżynierii informatycznej.

Od Automatyzacji po Aplikacje Webowe

Inżynieria DevOps: orkiestracja kontenerów, wdrażanie infrastruktury jako kodu (IaC) oraz potoki CI/CD.
Data Science i AI: dominacja Pythona w analizie danych, modelowaniu matematycznym i bibliotekach uczenia maszynowego.
Ekosystem Web: pełna kontrola nad warstwą klienta (JavaScript) oraz serwera (Node.js, Python, Ruby, PHP).
Automatyzacja sieci: skrypty konfiguracji i telemetrii urządzeń brzegowych (Ansible, MikroTik RouterOS, pyATS).

Infrastruktura jako kod (Infrastructure as Code, IaC): metodyka zarządzania środowiskiem serwerowym i sieciowym za pomocą deklaratywnych lub imperatywnych skryptów konfiguracyjnych podlegających wersjonowaniu. Pozwala na automatyczne, powtarzalne i bezbłędne powoływanie zasobów chmurowych i kontenerowych. Do jej realizacji powszechnie stosuje się języki skryptowe oraz narzędzia Ansible, Terraform i Docker.

Spektrum Zastosowań Języków Skryptowych

          +-------------------------------+
          |  Współczesna Inżynieria IT    |
          +---------------+---------------+
                          |
     +------------+-------+-------+------------+
     |            |               |            |
     v            v               v            v
+----------+ +----------+   +----------+ +----------+
| DevOps   | | Data Sci |   | Web Dev  | | Network  |
| Ansible  | | Python   |   | JS / Node| | MikroTik |
| Bash     | | Pandas   |   | Python   | | Python   |
| CI/CD    | | PyTorch  |   | PHP/Ruby | | REST API |
+----------+ +----------+   +----------+ +----------+

Slajd wyjaśnia proces konwergencji modeli kompilacji i interpretacji we współczesnych środowiskach uruchomieniowych.

Kompilatory JIT i Języki Hybrydowe

Kompilacja do bajtokodu: wstępna translacja kodu źródłowego do zwartego formatu maszyny wirtualnej (.pyc, .class).
Maszyny wirtualne: wykonywanie bajtokodu na abstrakcyjnej platformie stosowej uniezależniającej program od CPU.
Silniki JIT (Just-In-Time): dynamiczna kompilacja gorących ścieżek kodu bezpośrednio do kodu maszynowego w pamięci RAM.
Zatarcie podziału: nowoczesne środowiska łączą elastyczność i przenośność skryptu z wydajnością kompilatu natywnego.

Kod bajtowy (Bytecode): niskopoziomowa, zorientowana na wydajność reprezentacja programu generowana przez kompilator języka hybrydowego, przeznaczona do wykonania przez maszynę wirtualną, a nie bezpośrednio przez fizyczny procesor komputera. Charakteryzuje się niezależnością od architektury sprzętowej oraz znacznie szybszym czasem interpretacji niż surowy tekst źródłowy. Wykorzystywany m.in. w technologiach Java, Python oraz WebAssembly.

Nowoczesny Model Wykonywania Hybrydowego

[ Kod źródłowy ] (np. JS / Python)
       |
       v [ Szybka kompilacja wstępna ]
[ Kod bajtowy (Bytecode) ]
       |
       v
+-----------------------------------+
| Wirtualna Maszyna (Interpreter VM)|
+-----------------------------------+
       |              ^
       | [Profilowanie| gorącego kodu]
       v              |
+-----------------------------------+
|      Kompilator JIT w locie       |
+-----------------------------------+
       |
       v
[ Natywny kod procesora (RAM/CPU) ]

Slajd syntezuje wnioski z ewolucji programowania, wskazując na uzupełniający się charakter języków systemowych i skryptowych.

Współistnienie i Specjalizacja

Architektura dwuwarstwowa: krytyczny wydajnościowo rdzeń w języku C++/Rust połączony z logiką skryptową w Pythonie/Bashu.
Programowanie wielojęzykowe: dobór optymalnego narzędzia i paradygmatu do specyfiki danego podsystemu informatycznego.
Interfejsy FFI: bezpośrednie wywoływanie skompilowanych bibliotek natywnych z poziomu interpretera języka skryptowego.
Nieustanna ewolucja: dążenie myśli informatycznej do minimalizacji czasu programisty przy zachowaniu sprawności maszyn.

Interfejs funkcji obcych (Foreign Function Interface, FFI): mechanizm programistyczny umożliwiający programowi napisanemu w jednym języku (np. w skryptowym Pythonie) bezpośrednie wywoływanie funkcji i procedur skompilowanych w innym języku (np. C lub Rust). Stanowi fundament symbiozy paradygmatów, pozwalając na łączenie wygody pisania skryptów z maksymalną wydajnością bibliotek natywnych.

Symbioza Paradygmatów Programowania

+---------------------------------------------------+
| Warstwa Skryptowa (Python, Bash, JS)              |
| - Szybki rozwój, automatyzacja, interfejs API     |
| - Prototypowanie, orkiestracja zadań              |
+-------------------------+-------------------------+
                          |
             [ Interfejsy FFI / API ]
                          |
+-------------------------v-------------------------+
| Warstwa Systemowa (C, C++, Rust, Asembler)        |
| - Maksymalna wydajność obliczeniowa               |
| - Bezpośredni dostęp do rejestrów i pamięci CPU   |
+---------------------------------------------------+

Slajd podsumowuje cykl wykładów z historii programowania oraz formułuje kluczowe pytania sprawdzające wiedzę inżynierską.

Dyskusja i Zagadnienia Egzaminacyjne

Ewolucja poziomów abstrakcji: prześledzenie drogi od krosna Jacquarda i maszyny Babbage'a po nowoczesne języki skryptowe.
Kompilacja a interpretacja: zrozumienie kompromisów dotyczących wydajności, zużycia pamięci i czasu deweloperskiego.
Filozofia automatyzacji: rola potoków uniksowych i powłoki systemowej w budowie współczesnej infrastruktury IT.
Pytania kontrolne: weryfikacja zrozumienia architektury von Neumanna, struktury drzewa AST oraz potoku obiektowego.

Inżynieria oprogramowania skryptowego: dziedzina informatyki stosowanej koncentrująca się na projektowaniu, implementacji i utrzymaniu skryptów automatyzujących procesy systemowe, sieciowe i aplikacyjne. Łączy znajomość architektur systemów operacyjnych, teorii powłok i protokołów komunikacyjnych w celu budowy niezawodnych środowisk wykonawczych. Wymaga zrozumienia kompromisów pomiędzy wydajnością kodu a szybkością jego modyfikacji.

Kluczowe Zagadnienia Egzaminacyjne

1. Czym różni się architektura von Neumanna
   od maszyn o stałym programie sprzętowym?
2. Jakie są kolejne fazy kompilatora i jaką rolę
   pełni drzewo składni abstrakcyjnej (AST)?
3. Dlaczego wczesny FORTRAN zyskał akceptację
   inżynierów sceptycznych wobec języków HLL?
4. Jaka jest fundamentalna różnica pomiędzy potokiem
   w powłoce UNIX a potokiem w PowerShell?