SMALL to język programowania stworzony w latach 80. jako odpowiedź na rosnącą złożoność ówczesnych języków. W czasach, gdy C++ dodawał kolejne features, a Ada próbowała być wszystkim dla wszystkich, SMALL szedł w przeciwnym kierunku: minimalizm. Mały kompilator, mały runtime, mała składnia, małe wymagania sprzętowe. To język, który udowadnia, że “mniej” może znaczyć “lepiej” — przynajmniej w określonych kontekstach.

SMALL nie jest dobrze znany, nawet w środowisku retro-computingu. Istnieje kilka języków o nazwie “SMALL” lub “Small” (nie mylić ze Smalltalk!), co dodaje zamieszania. Najbardziej znany to SMALL z ekosystemu akademickiego — prosty język imperatywny używany do nauczania podstaw programowania i teorii kompilatorów.

Dlaczego warto go znać? Bo SMALL to case study w minimalizmie projektowym. W erze, gdy języki puchną od features (patrz: C++, JavaScript), SMALL przypomina, że prostota ma wartość. To też świetny język do nauki teorii kompilatorów — jego gramatyka jest na tyle prosta, że możesz napisać parser w weekend.

Spis treści

Krótka historia i ewolucja

SMALL powstał w środowisku akademickim w latach 80. jako narzędzie do nauczania. Jego twórcy (różne uniwersytety miały swoje wersje) chcieli języka, który byłby prosty na tyle, by studenci mogli zrozumieć cały kompilator — od parsowania po generowanie kodu. W erze, gdy kompilatory były ogromne i skomplikowane, SMALL był odtrutką.

Niektóre wersje SMALL były używane jako “target language” dla kursów kompilatorów — studenci pisali kompilatory z prostszych języków do SMALL, a następnie z SMALL do assemblera lub kodu maszynowego. Ta warstwowa architektura (source → SMALL → machine code) była popularnym podejściem dydaktycznym.

SMALL nigdy nie wyszedł poza środowisko akademickie. Nie miał komercyjnych zastosowań, nie miał ekosystemu bibliotek, nie miał społeczności poza studentami i badaczami. Ale jako narzędzie dydaktyczne był skuteczny — i w tej roli przetrwał w niektórych programach nauczania do dziś.

Kluczowe cechy i filozofia

SMALL jest językiem imperatywnym z minimalnym zestawem konstrukcji. Zmienne, przypisania, instrukcje warunkowe (if/else), pętle (while), procedury i funkcje — to w zasadzie wszystko. Nie ma tu OOP, nie ma zaawansowanych struktur danych, nie ma metaprogramowania. Jest za to czystość i prostota.

Typowanie w SMALL jest statyczne i proste: liczby całkowite, liczby zmiennoprzecinkowe, booleany i (w niektórych wersjach) tablice i stringi. Brak typów złożonych (struct, class) w większości wersji — jeśli potrzebujesz struktury danych, budujesz ją z tablic.

Filozofia SMALL to “minimum viable language”. Język ma wystarczająco dużo mocy, by wyrazić dowolny algorytm (jest Turing-complete), ale nie więcej. To sprawia, że SMALL jest idealny do nauki: nie musisz uczyć się 200 stron specyfikacji, by zacząć pisać. Cały język mieści się na jednej stronie A4.

Brak biblioteki standardowej (lub bardzo minimalna) oznacza, że wszystko piszesz od zera. To wada w produkcji, ale zaleta w edukacji — rozumiesz każdy aspekt swojego programu, bo nie ma “magii” ukrytej w bibliotekach.

Gdzie SMALL sprawdza się najlepiej

SMALL sprawdza się w jednym kontekście: edukacji. Kursy teorii kompilatorów, podstaw programowania i semantyki języków — to naturalne środowisko SMALL. Studenci piszą w SMALL proste programy, a następnie budują kompilatory, interpretery i analizatory dla tego języka.

Niektóre wersje SMALL były używane jako “intermediate representation” w kompilatorach — prosty język pośredni między source language a kodem maszynowym. To zastosowanie jest podobne do tego, co dziś robi LLVM IR, ale na znacznie mniejszą skalę.

Poza edukacją, SMALL nie ma praktycznych zastosowań. Nie napiszesz w nim aplikacji webowej, mobilnej ani desktopowej. Nie ma bibliotek, frameworków ani narzędzi do czegokolwiek poza kompilacją i uruchomieniem prostych programów.

Jak wygląda kod w SMALL

program silnia
    function fact(n)
        if n = 0 then
            return 1
        else
            return n * fact(n - 1)

    var wynik
    wynik := fact(10)
    write(wynik)

Prosty, czytelny, bez zbędnych ceremonii. SMALL wygląda jak pseudokod — i to jest komplement. Składnia jest tak oczywista, że nie wymaga komentarzy.

program sortowanie
    var tab[10], i, j, temp

    for i := 0 to 9 do
        read(tab[i])

    for i := 0 to 8 do
        for j := 0 to 8 - i do
            if tab[j] > tab[j+1] then
                temp := tab[j]
                tab[j] := tab[j+1]
                tab[j+1] := temp

    for i := 0 to 9 do
        write(tab[i])

Bubble sort w SMALL — prosta implementacja, która pokazuje wszystkie podstawowe konstrukcje: tablice, pętle for, warunki i operacje wejścia/wyjścia.

Ekosystem i narzędzia

SMALL nie ma ekosystemu w komercyjnym sensie. Kompilatory i interpretery SMALL istnieją jako projekty akademickie — często pisane przez studentów jako część kursów kompilatorów. Nie ma “oficjalnej” implementacji, bo nie ma “oficjalnego” SMALL — każda uczelnia mogła mieć swoją wersję.

Niektóre implementacje SMALL są dostępne na GitHub jako open source — zwykle proste kompilatory pisane w C, C++ lub Javie, które tłumaczą SMALL na kod maszynowy, bytecode lub C. Te projekty są wartościowe jako materiały edukacyjne, ale nie jako narzędzia produkcyjne.

Społeczność SMALL to studenci i wykładowcy, którzy używają go w kursach. Nie ma forów, konferencji ani grup dyskusyjnych. SMALL istnieje w sylabusach i materiałach kursowych, nie w ekosystemie open source.

Mocne i słabe strony

Mocne strony SMALL to jego prostota. Dla studentów uczących się teorii kompilatorów, SMALL jest idealny — gramatyka jest na tyle mała, że można ją zrozumieć w godzinę, a kompilator można napisać w semestr. Brak “ukrytej złożoności” oznacza, że wszystko jest jawne i zrozumiałe.

Słabe strony to… wszystko inne. SMALL nie ma bibliotek, nie ma narzędzi, nie ma ekosystemu, nie ma zastosowań produkcyjnych. Jest zbyt prosty do czegokolwiek poza edukacją. Brak OOP, brak zaawansowanych struktur danych, brak concurrency — to wszystko sprawia, że SMALL jest “zabawką” w sensie technicznym (choć wartościową zabawką edukacyjną).

Podsumowanie

SMALL to język dla studentów i wykładowców teorii kompilatorów. Jeśli uczysz się, jak działają kompilatory, parsery i generatory kodu — SMALL jest idealnym “królikiem doświadczalnym”. Nie planuj jednak używać go do czegokolwiek poza nauką.

Przyszłość SMALL to dalsze istnienie w niszy edukacyjnej. Dopóki uniwersytety uczą teorii kompilatorów, dopóty SMALL (lub języki do niego podobne) będzie używany jako narzędzie dydaktyczne. To nie jest język, który zmieni świat — ale to język, który pomaga zrozumieć, jak działają języki, które świat zmieniły.