Historia Programowania - Część 1: Od Babbage'a do Basha

Slajd przedstawia genezę myśli informatycznej oraz etapy ewolucji programowania od fizycznej rekonfiguracji obwodów po współczesne języki skryptowe.

Wprowadzenie do Historii Programowania

Ewolucja programowania: przejście od manualnej rekonfiguracji obwodów maszyn do zaawansowanych paradygmatów deklaratywnych i obiektowych.
Rola abstrakcji: budowanie kolejnych warstw pośrednich uniezależniających algorytmy od fizycznej architektury procesora.
Miejsce asemblera: wyeliminowanie uciążliwego zapisu binarnego na rzecz mnemonicznej reprezentacji rozkazów maszynowych.
Fundamenty automatyzacji: zrozumienie historycznych architektur stanowi warunek konieczny sprawnego tworzenia skryptów powłoki.

Programowanie komputerów: proces projektowania, tworzenia i testowania sekwencji instrukcji realizowanych przez maszynę cyfrową w celu automatycznego rozwiązania określonego problemu obliczeniowego. Obejmuje ono dobór struktur danych oraz precyzyjną implementację algorytmu w wybranym języku programowania. Współczesna inżynieria oprogramowania opiera się na wielopoziomowej hierarchii abstrakcji, od rozkazów mikrokodu po wysokopoziomowe języki skryptowe.

+---------------------------+
|    WITAJ NA WYKŁADZIE     |
+---------------------------+
|                           |
|   Historia Programowania  |
|            i              |
|  Języków Skryptowych      |
|                           |
|   Od Babbage'a do Basha   |
|                           |
+---------------------------+

Slajd omawia przełomowe konstrukcje mechaniczne XVII i XIX wieku, które zdefiniowały koncepcję automatycznego przetwarzania danych za pomocą kart perforowanych.

Mechaniczne Kalkulatory i Maszyny Analityczne

Pascalina (1642 r.): arytmometr Blaise'a Pascala wykorzystujący przekładnie zębate do dodawania i odejmowania liczb.
Maszyna różnicowa: projekt Charlesa Babbage'a do automatycznego tablicowania wielomianów metodą różnic skończonych.
Maszyna analityczna: pierwsza architektura komputera ogólnego przeznaczenia z podziałem na moduł obliczeń (młyn) i magazyn pamięci.
Karty perforowane: nośnik danych zaadaptowany z krosna tkackiego Jacquarda (1804 r.) umożliwiający programowe sterowanie maszyną.

Maszyna Analityczna: zaprojektowane w 1837 r. przez Charlesa Babbage'a mechaniczne urządzenie ogólnego przeznaczenia, uznawane za pierwszy projekt programowalnego komputera. Architektura ta po raz pierwszy rozdzieliła jednostkę wykonawczą (młyn) od pamięci danych (magazynu), wprowadzając sterowanie sekwencją operacji za pomocą kart dziurkowanych. Urządzenie zapewniało teoretyczną zupełność obliczeniową w sensie maszyny Turinga.

 +--------------------------+
 |  Maszyna Analityczna     |
 |    (Koncepcja Babbage'a) |
 +--------------------------+
 |                          |
 |  +-------------------+   |
 |  |   Karty Wejściowe |   |
 |  |   (Instrukcje)    |   |
 |  +-------------------+   |
 |           |              |
 |           v              |
 |  +-------------------+   |
 |  |     "Młyn"        |   |
 |  | (Jednostka CPU)   |   |
 |  +--------+----------+   |
 |           ^              |
 |           |              |
 |  +--------v----------+   |
 |  |    "Magazyn"      |   |
 |  |     (Pamięć)      |   |
 |  +-------------------+   |
 |                          |
 +--------------------------+

Slajd przybliża wkład Ady Lovelace w stworzenie pierwszego opublikowanego algorytmu komputerowego oraz sformułowanie koncepcji uniwersalnego manipulowania symbolami.

Wizja Ady Lovelace

Współpraca naukowa: analiza konstrukcji Maszyny Analitycznej i przekład pracy Luigiego Menabrei z 1842 r. na język angielski.
Notatka G: opracowanie pierwszego formalnego algorytmu komputerowego wyznaczającego liczby Bernoulliego w zdefiniowanych krokach operacyjnych.
Struktury sterujące: pionierskie zastosowanie pętli programowych oraz rozgałęzień warunkowych w analizie stanów obliczeniowych maszyny.
Wizja symboliczna: przewidzenie, że komputer może przetwarzać nie tylko liczby, lecz dowolne dane symboliczne podlegające regułom algebry.

Program komputerowy: uporządkowany ciąg instrukcji określających operacje, które maszyna cyfrowa ma wykonać na danych wejściowych w celu uzyskania oczekiwanego wyniku. Za pierwszy program uznaje się algorytm Ady Lovelace z 1843 r., który zawierał tablicę wykonawczą, powtórzenia pętlowe oraz rejestrację stanów zmiennych. Koncepcja ta wyprzedziła fizyczną realizację komputerów elektronicznych o całe stulecie.

  ,d88b.d88b,
  88888888888
  `Y8888888Y'
    `Y888Y'
      `Y'
 Ada Lovelace (1815-1852)

 "Maszyna Analityczna tka
 wzory algebraiczne, tak jak
 krosno Jacquarda tka
 kwiaty i liście."

Slajd przedstawia ograniczenia pierwszych komputerów elektronicznych, w których zmiana realizowanego algorytmu wymagała manualnej rekonfiguracji połączeń kablowych.

ENIAC i "Programowanie" przez Rekonfigurację

Wczesne systemy lampowe: brytyjski Colossus (1943 r.) dedykowany kryptoanalizie oraz amerykański ENIAC (1945 r.) jako uniwersalny kalkulator elektroniczny.
Panele krosownicze: proces programowania polegający na fizycznym łączeniu modułów przewodami i manualnym ustawianiu tysięcy przełączników.
Wkład programistek: opracowanie planów okablowania, weryfikacja poprawności logicznej i usuwanie awarii lamp przez sześcioosobowy zespół kobiecy.
Brak separacji warstw: brak pamięci programu sprawiał, że maszyna fizyczna i oprogramowanie stanowiły nierozłączną całość.

Programowanie sprzętowe: wczesna metoda sterowania pracą maszyny liczącej polegająca na fizycznej zmianie struktury jej obwodów elektronicznych. Rekonfiguracja obejmowała ręczne przełączanie kabli na tablicach rozdzielczych oraz modyfikację stanów rejestrów funkcyjnych dla każdego nowego zadania obliczeniowego. Metoda ta charakteryzowała się wielogodzinnym czasem przygotowania maszyny do pracy oraz wysokim ryzykiem błędu montażowego.

Panel Krosowniczy ENIAC (Uproszczony Schemat)

+---------------------------------------------+
|                                             |
|  [Moduł A]      [Moduł B]      [Moduł C]    |
|  o-o-o-o        o-o-o-o        o-o-o-o      |
|  | | | |        | | | |        | | | |      |
|  o-o-o-o        o-o-o-o        o-o-o-o      |
|    |   \__________/   |          |          |
|    \------------------/          |          |
|        |                         |          |
|  [Moduł D]      [Moduł E]      [Moduł F]    |
|  o-o-o-o        o-o-o-o        o-o-o-o      |
|  | | | |        | | | |        | | | |      |
|  o-o-o-o        o-o-o-o        o-o-o-o      |
|                                             |
+---------------------------------------------+
   "Programowanie" = Ręczne łączenie modułów kablami

Slajd wyjaśnia fundamentalną zasadę architektury von Neumanna polegającą na przechowywaniu kodu programu i danych w jednolitej pamięci operacyjnej.

Koncepcja Programu Przechowywanego w Pamięci

Raport EDVAC (1945 r.): sformalizowanie przez Johna von Neumanna i zespół projektowy modelu komputera z programem w pamięci.
Główne komponenty: procesor zawierający jednostkę arytmetyczno-logiczną (ALU) i sterującą (CU), pamięć oraz moduły I/O.
Równouprawnienie instrukcji: traktowanie rozkazów w sposób tożsamy z danymi, co umożliwiło wczytywanie i modyfikowanie kodu bez zmian sprzętowych.
Wąskie gardło magistrali: fizyczne ograniczenie przepustowości wynikające ze współdzielenia jednej szyny danych i rozkazów.

Architektura von Neumanna: paradygmat budowy komputera, w którym zarówno dane przetwarzane, jak i instrukcje programu są kodowane binarnie i przechowywane we wspólnej przestrzeni adresowej pamięci operacyjnej. Procesor cyklicznie pobiera instrukcje, dekoduje je i wykonuje za pomocą wyspecjalizowanych jednostek sterujących i arytmetycznych. Koncepcja ta stanowi podstawę konstrukcji niemal wszystkich współczesnych procesorów ogólnego przeznaczenia.

+---------------------------------+
|      Architektura von Neumanna  |
+---------------------------------+
|                                 |
|      +-------------------+      |
|      | Jednostka         |      |
|      | Sterująca (CU)    |      |
|      +--------+----------+      |
|               ^                 |
|               |                 |
|      +--------v----------+      |
|      | ALU               |<---->|
|      +-------------------+      |
|               ^                 |
|               |                 |
|      +--------v----------+      |
|      | Pamięć            |      |
|      |(Dane i Instrukcje)|      |
|      +-------------------+      |
|          ^         ^            |
|          |         |            |
|      Wejście     Wyjście        |
+---------------------------------+

Slajd charakteryzuje pierwsze działające implementacje architektury von Neumanna oraz genezę bibliotek podprogramów wielokrotnego użytku.

Od Teorii do Praktyki: Manchester Baby i EDSAC

Manchester Baby (SSEM, 1948 r.): pomyślne wykonanie pierwszego programu z pamięci elektrostatycznej opartej na lampach Williamsa.
EDSAC (1949 r., Cambridge): pierwszy praktyczny komputer Maurice'a Wilkesa wykorzystujący rtęciowe linie opóźniające.
Rozkazy początkowe (Initial Orders): wczesny program rozruchowy w pamięci stałej automatyzujący ładowanie kodu z taśmy perforowanej.
Biblioteki podprogramów: sformalizowanie modularności kodu i procedur wielokrotnego użytku w literaturze informatycznej z 1951 r.

Komputer z programem w pamięci: maszyna cyfrowa zdolna do przechowywania instrukcji sterujących w elektronicznej pamięci operacyjnej o dostępie swobodnym i ich samoczynnego, sekwencyjnego wykonywania. Pierwszym takim działającym prototypem był Manchester Baby z czerwca 1948 r., a pierwszym pełnoskalowym systemem użytkowym - brytyjski EDSAC z maja 1949 r. Maszyny te udowodniły wyższość programowania pamięciowego nad krosowaniem sprzętowym.

     1948 - Manchester Baby                 1949 - EDSAC
+-------------------------+      +-------------------------------+
| Uruchomienie pierwszego |      | Pierwszy praktycznie użyteczny|
| programu z pamięci      |      | komputer z programem w pamięci|
|                         |      |                               |
| Pamięć: 32 słowa 32-bit |      | Pamięć: 1024 słowa 17-bitowe  |
|                         |      |                               |
| Cel: Dowód koncepcji    |      | Cel: Narzędzie badawcze       |
+-------------------------+      +-------------------------------+
             |                                  |
             +----------------------------------+
                             |
                             v
           +-------------------------------------+
           | Kamienie milowe w realizacji        |
           | architektury von Neumanna           |
           +-------------------------------------+

Slajd podsumowuje etap przejścia od maszyn mechanicznych do komputerów elektronicznych oraz oddzielenie warstwy oprogramowania od sprzętu.

Od Mechaniki do Programu w Pamięci

Kamienie milowe: ewolucja od projektu Babbage'a i algorytmu Lovelace do maszyn realizujących architekturę von Neumanna.
Przełom technologiczny: zastąpienie manualnego krosowania obwodów elektronicznym zapisem instrukcji w pamięci RAM.
Narodziny software'u: uniezależnienie tworzenia algorytmów od fizycznej budowy maszyny zapoczątkowało inżynierię oprogramowania.
Wzrost uniwersalności: zdolność maszyny do wykonywania dowolnych zadań wyłącznie poprzez załadowanie nowego pakietu rozkazów.

Oprogramowanie: logiczny zestaw programów, procedur i powiązanych danych umożliwiający komputerowi wykonywanie określonych operacji obliczeniowych i przetwarzania informacji. Pojęcie to powstało w momencie fizycznego oddzielenia kodu programu od układów elektronicznych (hardware) w komputerach architektury von Neumanna. Umożliwiło to seryjną produkcję standaryzowanego sprzętu oraz niezależny rozwój algorytmów.

Ewolucja Koncepcji Programowania

1. Maszyna Analityczna (idea)
   [Program na kartach perfor.]

           |
           v

2. ENIAC (sprzęt)
   [Program = okablowanie]
   +-----------+
   |           |
   | Hardware  |
   | +Software |
   |           |
   +-----------+

           |
           v

3. EDSAC (arch. von Neumanna)
   [Program w pamięci]
   +----------+   +----------+
   | Hardware |   | Software |
   +----------+   +----------+

Slajd ukazuje genezę powstania języka symbolicznego jako bariery ochronnej programisty przed złożonością czystego kodu binarnego.

Potrzeba Abstrakcji: Języki Niskiego Poziomu

Bariera kodu binarnego: konieczność bezpośredniego operowania na ciągach zer i jedynek w pierwszych komputerach.
Uciążliwość adresowania: ręczne wyliczanie bezwzględnych adresów pamięci dla każdego skoku warunkowego i zmiennej.
Podatność na błędy: wysokie ryzyko pomyłki zapisu bitowego i skomplikowany proces lokalizacji usterek w pamięci.
Pojawienie się mnemoników: wprowadzenie pierwszego poziomu abstrakcji w postaci czytelnych symboli rozkazów procesora.

Język niskiego poziomu: język programowania, którego konstrukcje ściśle odzwierciedlają architekturę fizyczną danego procesora i jego zestaw instrukcji. Zapewnia on bezpośredni dostęp do rejestrów, portów wejścia-wyjścia i pamięci operacyjnej bez warstw pośrednich. Podstawowymi reprezentantami tej klasy są kod maszynowy oraz język asemblera.

Problem:
+------------------------------------+
| Programista vs. Kod maszynowy      |
+------------------------------------+
|                                    |
| Człowiek     <------>     Maszyna  |
| (logika)     (nieczytelny) (bity)  |
|                                    |
|   10110010 00010110                |
|   10001001 11011000                |
|   01010010                         |
|   ...                              |
|                                    |
|   Potrzeba: Język pośredni!        |
+------------------------------------+

Slajd wyjaśnia budowę rozkazu maszynowego oraz mechanizm bezpośredniego wykonywania instrukcji dwójkowych przez procesor.

Bezpośrednia Komunikacja ze Sprzętem

Język natywny CPU: jedyny format instrukcji dekodowany bezpośrednio przez obwody jednostki sterującej.
Budowa rozkazu: podział słowa maszynowego na kod operacji (opcode) oraz pole adresów rejestrów lub operandów.
Specyfika architektury (ISA): unikalność binarnego zestawu instrukcji sprawia, że programy nie są przenośne między procesorami.
Cykl maszynowy: powtarzalna realizacja faz pobrania rozkazu (Fetch), dekodowania (Decode) oraz wykonania (Execute).

Kod maszynowy: ciąg instrukcji dwójkowych zapisanych w postaci binarnej lub szesnastkowej, interpretowanych bezpośrednio przez układy elektroniczne mikroprocesora. Każda instrukcja koduje elementarną operację procesora, taką jak odczyt z rejestru, dodawanie arytmetyczne lub skok do komórki pamięci. Zestaw tych instrukcji definiuje architekturę zestawu instrukcji (ISA) danego układu scalonego.

// Przykład (hipotetyczny) kodu maszynowego
// Zadanie: Oblicz sumę wartości 5 i 7 w rejestrze R1

10110001 // Instrukcja: Załaduj stałą do rejestru R1
00000101 // Wartość stałej: 5

10110010 // Instrukcja: Załaduj stałą do rejestru R2
00000111 // Wartość stałej: 7

00000011 // Instrukcja: Dodaj zawartość R2 do R1 (R1 = R1 + R2)
11001010 // Kod rejestrów docelowego i źródłowego (R1, R2)

Slajd omawia istotę języka asemblera jako czytelnej dla człowieka symbolicznej reprezentacji rozkazów procesora.

Mnemoniki w Służbie Programisty

Mnemoniki operacji: zastąpienie kodów binarnych krótkimi skrótami słownymi (np. MOV, ADD, JMP).
Etykiety symboliczne: zastąpienie adresów komórek pamięci czytelnymi nazwami zmiennych i podprogramów.
Relacja 1:1: zachowanie bezpośredniego przełożenia pojedynczej instrukcji asemblera na dokładnie jeden rozkaz maszynowy.
Maksymalna kontrola: możliwość precyzyjnego sterowania każdym rejestrem i cyklem taktującym procesora.

Asembler: symboliczny język programowania niskiego poziomu, w którym rozkazy maszynowe procesora zastąpiono mnemonicznymi nazwami operacji, a adresy komórek pamięci - etykietami tekstowymi. Pozwala programiście pisać kod w postaci zrozumiałej dla człowieka przy zachowaniu stuprocentowej kontroli nad zasobami sprzętowymi. Każda rodzina procesorów posiada własną, specyficzną składnię asemblera.

// To samo zadanie w asemblerze (konwencja dydaktyczna RISC)
MOV R1, #5      // Załaduj wartość 5 do rejestru R1
MOV R2, #7      // Załaduj wartość 7 do rejestru R2
ADD R1, R1, R2 // Dodaj R2 do R1, wynik umieść w R1

Slajd opisuje działanie programu translatora (asemblera) przekształcającego kod symboliczny na binarny plik wykonywalny.

Automatyzacja Tłumaczenia na Kod Maszynowy

Mechanizm translacji: asembler czyta plik źródłowy i zamienia mnemoniki oraz nazwy rejestrów na binarne kody operacji.
Rozwiązywanie etykiet: automatyczne przeliczanie nazw symbolicznych na konkretne adresy w przestrzeni pamięci.
Asemblacja dwuprzebiegowa: budowa tablicy symboli w pierwszym przejściu i generowanie kodu binarnego w drugim.
Tworzenie modułu obiektowego: przygotowanie kodu maszynowego do ostatecznej konsolidacji z bibliotekami systemowymi.

Asemblacja: proces translacji programu zapisanego w języku asemblera na odpowiadający mu kod maszynowy realizowany przez wyspecjalizowany program translatora. Translacja asemblerowa jest procesem deterministycznym o relacji jeden do jednego, w przeciwieństwie do kompilacji języków wysokiego poziomu, która przekłada złożone konstrukcje na serie rozkazów maszynowych. Wynikiem asemblacji jest najczęściej plik obiektowy wymagający linkowania.

Proces Asemblacji

+-----------------------+      +---------------------+      +-----------------------+
| Plik źródłowy         |      |                     |      | Plik wykonywalny      |
| (np. program.asm)     |      |      ASEMBLER       |      | (kod maszynowy)       |
|                       |----->| (Tłumaczy mnemoniki |----->|                       |
| MOV R1, #5            |      |  i etykiety na kod  |      | 10110001 00000101     |
| ADD R1, R2            |      |  binarny)           |      | 00000011 11001010     |
+-----------------------+      +---------------------+      +-----------------------+

Slajd identyfikuje bariery programowania w asemblerze, które wymusiły stworzenie uniwersalnych języków wysokiego poziomu.

Brak Przenośności i Wysoka Złożoność

Brak przenośności: ścisłe powiązanie kodu ze zbiorem instrukcji danego procesora wyklucza uruchomienie na innej platformie.
Złożoność utrzymania: ręczne kodowanie elementarnych operacji prowadzi do powstawania tysięcy trudnych w analizie wierszy.
Brak abstrakcji danych: brak wbudowanych typów złożonych, struktur obiektowych oraz dynamicznego zarządzania pamięcią.
Kryzys oprogramowania: rosnące koszty pracy programistów wymusiły automatyzację generowania rozkazów maszynowych.

Przenośność oprogramowania: cecha kodu źródłowego umożliwiająca jego skompilowanie i uruchomienie na różnych platformach sprzętowych i systemowych przy minimalnych modyfikacjach. Języki niskiego poziomu są z definicji nieprzenośne, ponieważ bazują na unikalnych rejestrach i architekturze danego procesora. Wymóg przenośności był głównym motorem napędowym rozwoju języków wysokiego poziomu, takich jak Fortran, COBOL czy C.

+-------------------------+
| Problem:                |
| Brak Przenośności       |
+-------------------------+

+-------------------------+
| Program.asm dla x86     |
+-------------------------+
          |
          v
+-------------------------+
| Procesor Intel (x86)    | -- OK
+-------------------------+
          |
          v
+-------------------------+
| Procesor ARM            | -- BŁĄD!
+-------------------------+

Każda architektura wymagała
oddzielnego kodu.

Slajd analizuje problem przestojów procesorów mainframe w latach 50. i 60. XX wieku oraz ekonomiczne podłoże automatyzacji zadań.

Wykorzystanie Czasu Drogocennych Maszyn

Wysoki koszt maszyn: wielomilionowe inwestycje w mainframe wymuszały ich nieprzerwaną pracę obliczeniową.
Bezczynność procesora (idle): operatorzy ręcznie ładowali karty i taśmy, marnując cenne cykle zegara procesora.
Bariera wejścia-wyjścia: drastyczna dysproporcja prędkości między elektronicznym CPU a mechanicznymi czytnikami kart.
Koncepcja automatyzacji: połączenie odrębnych zadań w nieprzerwany ciąg wykonywany bez udziału człowieka.

Przetwarzanie wsadowe: metoda wykonywania programów na komputerze bez bezpośredniego udziału użytkownika, polegająca na zgrupowaniu zadań w zorganizowane pakiety (wsady) i ich sekwencyjnej realizacji przez system operacyjny. Została wprowadzona w latach 50. XX wieku w celu minimalizacji bezczynności kosztownych procesorów mainframe. Do dziś stanowi podstawę nocnego przetwarzania wielkich wolumenów danych w sektorze bankowym.

Problem: Niska utylizacja CPU

 Operator         CPU             Drukarka
|                |               |
| Ładuje Zadanie |---------------| Bezczynna
|                |               |
| Czeka...       | Oblicza...    | Bezczynna
|                |               |
|                | Kończy        | Bezczynna
|                |               |
|                | Bezczynny     | Drukuje...
|                |               |
| Ładuje kolejne | Bezczynny     | Bezczynna
|                |               |
+-------------------------------------------> Czas

Cel: Minimalizacja bezczynności CPU.

Slajd przedstawia mechanizm działania monitora wsadowego oraz buforowania zadań obliczeniowych.

Automatyzacja Kolejki Zadań

Partia zadań (batch): seryjne pakowanie programów i danych wejściowych na nośnikach magnetycznych lub kartach.
Monitor wsadowy: rezydentny w pamięci protoplasta systemu operacyjnego samodzielnie sterujący przepływem pracy.
Buforowanie SPOOL: równoległe zapisywanie wejścia i wyjścia na dyskach odciążające procesor od powolnych drukarek.
Separacja użytkownika: oddanie zadania do centrum obliczeniowego i późniejszy odbiór gotowych wydruków wierszowych.

Monitor wsadowy: rezydentny komponent wczesnych systemów operacyjnych odpowiedzialny za automatyczne wczytywanie, alokowanie pamięci, uruchamianie i zwalnianie kolejnych zadań z partii wsadowej. Eliminował on konieczność manualnego resetowania maszyny i ładowania programów przez operatora pomiędzy kolejnymi zleceniami. Rozwiązanie to stanowiło bezpośredni zalążek współczesnych jąder systemów operacyjnych.

+-------------------------+
|  Partia Zadań (Batch)   |
|  (np. na taśmie)        |
+-------------------------+
|  [Nagłówek Zadania 1]   |
|  [Dane dla Zadania 1]   |
|  [Program 1]            |
|  ---------------------  |
|  [Nagłówek Zadania 2]   |
|  [Dane dla Zadania 2]   |
|  [Program 2]            |
|  ---------------------  |
|  [Nagłówek Zadania 3]   |
|  ...                    |
+-------------------------+
          |
          v
+-------------------------+
|  System Operacyjny      |
|  (Monitor Wsadowy)      |
|  * Czyta zadanie        |
|  * Uruchamia            |
|  * Przechodzi do nast.  |
+-------------------------+

Slajd charakteryzuje strukturę i instrukcje języka sterowania zadaniami JCL jako narzędzia automatyzacji środowiska mainframe.

Rola Job Control Language (JCL)

Język deklaratywny: JCL precyzował zapotrzebowanie zadania na czas procesora, rozmiar pamięci oraz pliki danych.
Karta JOB: definiowanie nazwy zadania, konta rozliczeniowego, klasy wykonania oraz priorytetu systemowego.
Karta EXEC: wskazanie modułu programu binarnego ładowanego z biblioteki systemowej do wykonania danego kroku.
Karty DD (Data Definition): powiązanie logicznych deskryptorów w kodzie programu ze zbiorami dyskowymi i taśmami.

Job Control Language: wyspecjalizowany język deklaratywny wprowadzony w 1964 r. w systemach IBM OS/360, służący do instruowania systemu operacyjnego o sposobie uruchomienia zadania wsadowego i alokacji wymaganych zasobów sprzętowych. Składa się z instrukcji JOB (identyfikacja zadania), EXEC (wskazanie programu) oraz DD (przypisanie zbiorów danych). Do dziś pozostaje standardem zarządzania zadaniami w korporacyjnych systemach mainframe klasy IBM z/OS.

//* Przykład poprawnego zadania JCL w standardzie IBM OS/360 i z/OS
//CALCJOB  JOB (ITDEPT),'STUDENT',CLASS=A,MSGCLASS=X
//* Krok 1: wykonanie programu analitycznego CALCULATE
//STEP01   EXEC PGM=CALCULATE
//* Definicja zbioru wejściowego i strumienia wyjściowego
//INPUT    DD DSN=PROJ.DATA.INPUT,DISP=SHR
//OUTPUT   DD SYSOUT=A
//SYSIN    DD DUMMY

Slajd wyjaśnia motywy odejścia od przetwarzania wsadowego na rzecz systemów wielozadaniowych i podziału czasu procesora.

Ograniczenia Modelu Wsadowego i Potrzeba Interakcji

Wady trybu wsadowego: brak interakcji z programem i wielogodzinny czas oczekiwania na wyniki utrudniający debugowanie.
Wieloprogramowość: obecność wielu programów w pamięci RAM i przełączanie CPU podczas oczekiwania na operacje wejścia-wyjścia.
Podział czasu (time-sharing): przydzielanie użytkownikom cyklicznych kwantów czasu CPU z mechanizmem wywłaszczania zadań.
Przełom CTSS i Multics: umożliwienie dziesiątkom użytkowników równoczesnej, interaktywnej pracy z jednym komputerem.

Podział czasu: technika pracy systemu operacyjnego polegająca na cyklicznym przydzielaniu poszczególnym programom krótkich kwantów czasu procesora (zwykle rzędu kilkunastu milisekund). Dzięki dużej częstotliwości przełączania kontekstu wielu użytkowników pracujących na oddzielnych terminalach odnosi wrażenie równoległego i wyłącznego dostępu do maszyny. Model ten umożliwił powstanie interaktywnych środowisk programistycznych.

System z podziałem czasu

      +-----------+
      | Program A | ----> Czeka na I/O
      +-----------+
      +-----------+       +---------+
      | Program B | <---- |   CPU   |
      +-----------+       +---------+
      +-----------+           ^
      | Program C | ----------+
      +-----------+

System operacyjny szybko przełącza
CPU pomiędzy programami, które są
gotowe do wykonania.

Slajd przedstawia genezę powłoki tekstowej jako interpretera poleceń oraz fundamentu rozwoju języków skryptowych.

Bezpośredni Dialog z Maszyną

Model terminalowy: komunikacja użytkownika z jądrem systemu w czasie rzeczywistym za pomocą terminali znakowych TTY.
Koncepcja powłoki: stworzenie przez Louisa Pouzina w projekcie Multics (1964 r.) modułu shell realizującego polecenia i skrypty.
Rewolucja UNIX: implementacja powłoki przez Kena Thompsona (1971 r.) z mechanizmem potoków i przekierowań wejścia-wyjścia.
Narodziny skryptów: połączenie prostych narzędzi tekstowych w złożone procesy przetwarzania danych zapoczątkowało języki skryptowe.

Powłoka systemowa: program stanowiący interfejs pośredniczący pomiędzy użytkownikiem a jądrem systemu operacyjnego, interpretujący wpisywane polecenia tekstowe i zlecający ich wykonanie. Współczesne powłoki są pełnoprawnymi językami programowania wyposażonymi w zmienne, instrukcje warunkowe, pętle oraz funkcje, co umożliwia automatyzację zadań administracyjnych za pomocą skryptów. Standard powłoki uniksowej definiuje specyfikacja POSIX.

Model Interaktywny

+------------+     +-----------------+     +-----------------+
| Użytkownik |<--->|     Terminal    |<--->|     Powłoka     |
+------------+     +-----------------+     |     (Shell)     |
                                           +--------+--------+
                                                    |
                                                    v
+------------------------------------------------------------------------+
|                          System Operacyjny (Jądro)                     |
|                                                                        |
| [Zarządzanie plikami]  [Zarządzanie procesami]  [Zarządzanie pamięcią] |
+------------------------------------------------------------------------+