Wszystko było w porządku, dopóki BASIC nie pojawił się na scenie.

Edsger Dijkstra w halucynacji AI z 2023 roku

Prostota jest ostatecznym wyrafinowaniem.

Leonardo Da Vinci

Praktycznie niemożliwe jest nauczenie dobrego programowania uczniów, którzy mieli wcześniejszą styczność z BASIC: jako potencjalni programiści są umysłowo okaleczeni poza nadzieję regeneracji.

Edsger Dijkstra,
Jak mówimy prawdy, które mogą zaboleć?, 18 czerwca 1975
Wybrane Pisma o Informatyce: Perspektywa Osobista, Wydawnictwo Springer, 1982. ISBN 0–387–90652–5.

Ostatnia aktualizacja: 2023-12-24. Zaktualizowano wzmianki dotyczące odniesień do Fortranu – przykład z 1976 roku był zbyt nowoczesny i nie odpowiadał standardom tamtych czasów. Dodano akapit na temat, dlaczego BASIC w latach 80. nadal używał numerów linii. Dodano wzmiankę o Pythonie jako współczesnych alternatywach oraz notkę końcową, że język programowania nie był jedynym czynnikiem dla tych, którzy zaczynali programowanie w BASIC na komputerach domowych.

BASIC był odpowiedzialny za rozbudzenie zainteresowania komputerami w jednym pokoleniu ^{(cytat komentarza glimshe)}. A jednak Edsger Dijkstra, znany informatyk, w 1975 roku słynnie dokonał tego ostatniego kontrowersyjnego stwierdzenia w liście niewygodnych prawd w postaci listy punktowanej. Dijkstra był znany ze swoich silnych opinii na temat języków programowania i uważał, że prostota i brak zasad programowania strukturalnego w BASIC mogą przeszkodzić uczniom w opanowaniu solidnych podstaw programowania.

Jaki jest kontekst słynnego cytatu?

Ta opinia Dijkstry była tak mocna i wzbudziła tyle urazy, że dziś wielu programistów, a nawet czaty AI wydają się łączyć go z wystarczającą nienawiścią do języka, by w przypadku tych ostatnich wyobrazić sobie cytaty takie jak “Wszystko było w porządku, dopóki BASIC nie wszedł do gry”, czego nigdy tak naprawdę nie powiedział.

Można jednak argumentować, że drugi cytat jest przeciwstawny, ponieważ sam język BASIC jest, co właśnie wzbudziło tyle żalu, dość prosty. To powinno czynić go znacznie lepszym narzędziem, pozwalającym programiście skupić się na celu. Jak nowoczesny ubogi Golang 😉 Czy to oznacza, że BASIC jest zbyt prosty? Czy wszystkie popularne alternatywy były lepsze?

Należy zauważyć, że stwierdzenie Dijkstry zostało dokonane w innej erze, gdy BASIC był jednym z niewielu powszechnie dostępnych języków programowania. Dzisiaj dostępne są nowsze, potężniejsze języki programowania i zasoby, które mogą pomóc uczniom rozwijać silne umiejętności programowania, niezależnie od ich wcześniejszej styczności z BASIC, co potwierdza fakt, że była to przesada użyta do udowodnienia tezy.

Stwierdzenie to było również tylko punktem listy podobnie negatywnych deklaracji, takich jak „PL/I – «śmiertelna choroba» – należy bardziej do zbioru problemów niż rozwiązań”. (Pamiętasz? PL/I był językiem stojącym za Multics, projektem, który – nie dotrzymując harmonogramu – dał nam Unix) lub, o wiele ostrzejszym, „Użycie COBOLA kalekczy umysł; jego nauczanie powinno być zatem uznane za przestępstwo”.

Wracając do pytania „czy to zbyt proste?”, możemy spojrzeć na ewolucję BASIC w trzech erach:

• Lata 70., kiedy to wywołało u niego taką niechęć
• Lata 80. i 90., kiedy jego oświadczenie tak rozzłościło użytkowników domowych komputerów
• BASIC dzisiaj

BASIC na przestrzeni lat

Lata 70.

Odmiana BASIC najprawdopodobniej skrytykowana przez Dijkstrę to Dartmouth BASIC, oryginalna (!) wersja języka programowania BASIC z 1964 roku. Jak podaje Wikipedia, został on zaprojektowany przez dwóch profesorów z Dartmouth College, Johna G. Kemeny’ego i Thomasa E. Kurtza. W oparciu o leżący u jego podstaw system Dartmouth Time Sharing System (DTSS), oferował interaktywne środowisko programistyczne wszystkim studentom, a także szerszej społeczności uniwersyteckiej.

Nie był to BASIC, który zna większość starszych użytkowników komputerów na całym świecie. W rzeczywistości nie był to nawet język interpretowany, ale kompilowany!

Uwaga dla początkującego:
Skompilowane języki, takie jak większość, ale nie wszystkie, z tych popularnych dzisiaj (C, C++, Go, Rust) to takie, w których program nie może być bezpośrednio uruchomiony po napisaniu. Zamiast tego musi przejść proces sprawdzania wszystkich odwołań między plikami i modułami (w tym odpowiadania na pytania takie jak: skąd one pochodzą? czy istnieją? czy wszystkie wartości mają poprawny typ?), tłumaczenia każdej instrukcji na zestaw instrukcji niższego poziomu, które mogą być bezpośrednio wykonywane przez główny procesor komputera. Ten proces nosi nazwę kompilacji. Może on trochę potrwać, od kilku sekund dla średniej wielkości bazy kodu, do wielu godzin (Chromium, rdzeń przeglądarki Chrome, zajęłoby 6-8 godzin kompilacji na 4-rdzeniowej maszynie).
Oznacza to kilka rzeczy – przede wszystkim zawsze jest to proces dwuetapowy, mniej interaktywny niż uruchamianie poleceń po kolei. Musisz poczekać aż program sprawdzi cały kod pod kątem błędów składni i skompiluje go, co daje korzyść w postaci podstawowej (!) kontroli błędów jeszcze przed wykonaniem kodu.
Interpretowane języki, a raczej interpretery języków programowania działają w drugą stronę. Tutaj tradycyjnie każda instrukcja z kodu źródłowego jest tłumaczona na kod maszynowy dopiero gdy wykonanie dociera do danej instrukcji.
Z kolei oznacza to, że niektóre błędy mogą pozostać niezauważone aż do osiągnięcia danego punktu w kodzie, takie jak odwołanie do nieistniejącej zmiennej lub takiej, której typ jest niekompatybilny z tym w jaki sposób chcemy z niej skorzystać. Jednak częstą zaletą jest to, że interpretowane języki są zwykle mniej restrykcyjne jeśli chodzi o typ zmiennej i większość konstrukcji działa równie dobrze z liczbami całkowitymi jak i zmiennoprzecinkowymi (tymi z częścią ułamkową), a nawet dynamicznie dostosowuje się gdy jest to ciąg znaków (tekst). Python na przykład rozszerza ten koncept na wszystkie obiekty z pomysłem nazwanym „jeśli to wygląda jak kaczka i kwacze jak kaczka, to prawdopodobnie jest kaczką”. I można go używać we wszystkich miejscach kodu, gdzie oczekiwana byłaby kaczka.
Z czasem rozróżnienie między kodem kompilowanym i interpretowanym stało się mniej wyraźne, a różnica wydajności zmniejszyła się na przestrzeni lat. Tradycyjnie interpretowane języki, takie jak JavaScript, wykorzystują obecnie techniki takie jak kompilacja Just-In-Time, co oznacza, że fragment kodu jest rzeczywiście kompilowany przed wykonaniem, i może nawet być automatycznie rekompilowany z większą liczbą optymalizacji, jeśli wykonuje się go często.
Niektóre języki, takie jak Java czy C#, zostały również uznane za połączenie obu światów – etap kompilacji tłumaczy ich kod źródłowy na tzw. „kod bajtowy”, który jest znacznie niższego poziomu, ale nie wykonuje się go bezpośrednio w sprzęcie – zamiast tego, te uproszczone instrukcje tłumaczą się na jedną lub więcej instrukcji sprzętowych w czasie wykonywania.

Chociaż Dartmouth BASIC był językiem kompilowanym, nie przynosił ze sobą wszystkich wad dodatkowego kroku kompilacji przed wykonaniem – w przypadku wielu innych języków kompilowanych lat 80. na domowych komputerach, gdy mieliśmy tylko jeden komputer, i to jednozadaniowy, prawdopodobnie wymagającej wyjścia z kompilatora, załadowania programu, zobaczenia jego pierwszej awarii, ponownego załadowania kompilatora, załadowania naszych plików, naprawienia problemu, ponownej kompilacji… wszystko to znacząco wydłużało cykl aktualizacji. Dartmouth poradził sobie lepiej. W dowolnym momencie, gdy program był w pamięci, można było użyć SAVE, aby zapisać go i nie stracić po zakończeniu pracy z komputerem oraz RUN, aby skompilować i wykonać go od razu. Polecenie RUN jest znane użytkownikom późniejszych 8-bitowych środowisk BASIC na domowych komputerach, w których instruuje ono komputer do rozpoczęcia interpretowania kodu linia po linii.
Dartmouth BAISC posiadał również najbardziej rozpoznawalną cechę BASIC – każda linia zaczyna się od numeru linii, więc nawet jeśli nie masz dostępnego pełnoekranowego edytora, możesz dodać linie w dowolnych pozycjach pomiędzy istniejącymi (stąd także konwencja numerowania ich co 10, a nie 1, 2, 3… – daje to szansę na wstawienie dodatkowego kodu między liniami 10 i 20, jeśli to konieczne).

Dlaczego miałbyś nie mieć edytora? Nie oznacza to, że one nie istniały, nawet dokumentacja języków z lat 60. wspomina o kilku edytorach tekstu. Problem polegał na tym, że edytory wymagają zasobów, a przez dziesięciolecia oprogramowanie komputerowe naprawdę chciało oszczędzać każdy kilobajt pamięci jeśli to możliwe i pozostawiać go wolnym dla programów użytkownika. Lub gier.

Pierwsza wersja języka była niezwykle ograniczona w porównaniu z późniejszymi popularnymi wersjami BASICa. Jedyne obsługiwane słowa kluczowe poza funkcjami matematycznymi to: LET, PRINT, END, FOR...NEXT, GOTO, GOSUB...RETURN, IF...THEN, DEF, READ, DATA, DIM i REM. Oznacza to bardzo podstawową kontrolę przepływu (jaki kod kiedy ma się wykonać), proste operacje wejścia/wyjścia, komentarze i podstawowe tablice. Ta ostatnia cecha nie jest trywialna, więc była jedną z niewielu cech, które czyniły go bardziej przydatnym niż język assembler (pisanie programu bezpośrednio jako sekwencji instrukcji procesora). Nazwy zmiennych były ograniczone do pojedynczej litery lub litery po której następowała cyfra (286 możliwych nazw zmiennych), co znacznie utrudniało czytanie programów przez człowieka.

Do 1975 roku język osiągnął szóstą edycję. Dodano możliwość interaktywnego wprowadzania danych przez użytkownika, pojawiło się wiele operatorów matematycznych (typu ABS, LOG, RND, SIN). Czy pozwalał on na “normalne” (dłuższe) nazwy zmiennych? Nie ma śladu takiej funkcji. Czy pozwalał na pełne instrukcje (wyrażenia) w IF...THEN? Również nie! Była to tylko warunkowa instrukcja GOTO, co oznacza, że musiałeś ją napisać jako IF A>0 100, gdzie 100 to linia do wykonania, jeśli warunek zostanie spełniony.

Rozumiem, skąd wzięła się wściekłość na maszynę działającą w BASICu, gdy wezmę pod uwagę klasyczny przykład “gry w zgadywanie” (komputer wybiera losową liczbę, a użytkownik powinien ją odgadnąć, otrzymując wskazówki typu “za duża” lub “za mała”):

100 REM GRA W ZGADYWANIE
110 
120 PRINT "ZGADNIJ LICZBĘ MIĘDZY 1 A 100"  
130
140 LET X = INT(100*RND(0)+1)
150 LET N = 0
160 PRINT "TWOJA ODPOWIEDŹ";
170 INPUT G
180 LET N = N+1  
190 IF G = X THEN 300
200 IF G < X THEN 250
210 PRINT "ZA DUŻA, SPRÓBUJ PONOWNIE"
220 GOTO 160
230
250 PRINT "ZA MAŁA, SPRÓBUJ PONOWNIE"
260 GOTO 160
270
300 PRINT "ZGADŁEŚ, W"; N; "PRÓBACH"
310 PRINT "JESZCZE JEDNA GRA (TAK = 1, NIE = 0)";  
320 INPUT A
330 IF A = 1 THEN 140
340 PRINT "DZIĘKI ZA GRĘ"
350 END

źródło: Przykład pochodzi bezpośrednio z Dartmouth College.

Jak widać, kod wygląda niezwykle prosto, z warunkowymi skokami (IF G = X THEN 300), które wymagają od czytelnika, jego wzroku i wraz z nim jego uwagi, skakania po kodzie i które nie obsługują instrukcji ELSE (w tym prostym przykładzie, ELSE jest zrealizowane jak w asemblerze – poprzez pominięcie i po prostu kontynuowanie dalej. Jeśli nie odgadłeś liczby i nie wykonałeś skoku w linii 190, liczba którą podałeś jest albo za mała, i wtedy skaczesz z linii 200 do 250, albo po prostu idziesz dalej do linii 210, ponieważ po wykluczeniu, że liczby są równe i G<X, jedyną pozostałą możliwością jest G>X.

Cały kod wygląda bardzo płasko w porównaniu do dzisiejszych standardów. Dzieje się tak, ponieważ większość implementacji BASICa nie tylko w latach 60. i 70., ale także niektóre w latach 80. i 90., nie radziły sobie dobrze z nieoczekiwanymi odstępami. Już wiesz, dlaczego nie widzisz wciętych bloków w blokach IF...THEN… nie ma nic do wcięcia, jeśli nie możesz umieszczać poleceń w klauzuli THEN, a nawet w wersjach BASICa, gdzie możesz, i tak nie możesz użyć wielu naraz. To będzie małe oszustwo, ale zajrzyjmy do 1982 roku i sprawdźmy kod Commodore 64:

10 PRINT"HELLO, HOW OLD ARE YOU", : REM ILE MASZ LAT?
20 INPUT A
30 IF A > 30 THEN
35  REM TO ŚWIETNY WIEK NA CZYTELNIKA RETROFUN.PL! 
40  PRINT"THAT'S A GOOD AGE FOR A RETROFUN.PL VISITOR!"
50 END

Jeśli przyjmiemy, że 25-latek wykona ten program, na ekranie możemy zobaczyć:

Chociaż 25 to zdecydowanie dobry wiek dla odwiedzającego RetroFun.pl, możemy zobaczyć, że ani linia 40 nie wykonuje się tylko wtedy, gdy spełniony jest warunek A>30, ani też nie ma żadnego błędu, że nasz blok THEN był efektywnie pusty. Posiadanie jakiejkolwiek struktury kodu będzie oparte na GOTO, GOSUB (to GOTO, które może powrócić (RETURN) do miejsca, z którego zostało wywołane) i większej liczbie “płaskich” linii kodu.
(A tak, w rzeczywistości oszukiwałem dwa razy – używając END, które kończy program w sposób, który mógł wprowadzić Cię w błąd, aby sądzić, że ma cokolwiek wspólnego z instrukcją IF).

Jeszcze jeden słoń w pokoju

To samo źródło podaje przykład tego, jak narysować krzywą Gaussa (zadziwiająco proste do obliczenia w tym matematycznie zaawansowanym uniwersyteckim BASICu):

100 REM NARYSUJ KRZYWĄ ROZKŁADU NORMALNEGO  
110
120 DEF FNN(X) = EXP(-(X^2/2))/SQR(2*3.14159265)
130 
140 FOR X = -2 TO 2 STEP .1
150 LET Y = FNN(X)
160 LET Y = INT(100*Y)
170 FOR Z = 1 TO Y
180 PRINT " ";
190 NEXT Z
200 PRINT "*"
210 NEXT X
220 END

Możesz zauważyć, że język nie posiada żadnych słów kluczowych, które ułatwiłyby rzeczywiste rysowanie czegokolwiek na ekranie (jak np.: podświetlenie piksela), a przykład również ogranicza się do trybu tekstowego.

Ale to nie jest brakująca funkcjonalność języka, a konkretnie nie taka, która jest konieczna, ale brakująca. Gdybyś zapytał o to, odpowiedzieliby…

Jakim ekranie?

Słoniem w pokoju jest komputer wielkości słonia. Dartmouth BASIC, podobnie jak system, na którym działał (DTSS), był obsługiwany ze zdalnych terminali, które stanowią wyzwanie nawet dla dzisiejszej definicji lekkiego terminala (można by się spodziewać, że to proste urządzenie z klawiaturą i ekranem… och, i lekkie), czy terminala z lat 80. To w zasadzie ciężkie biurko z klawiaturą i zdalnie sterowaną maszyną do pisania (Nie, nie drukarką igłową). Stąd nazwa “Teletype” (dalekopis).

Konkurencja (chociaż też krytykowana)

Czy to jest język programowania? Tak. Czy to jest dobry język? Niekoniecznie. Czy jest lepszy od konkurencji? Cóż, Dijkstra w tym samym artykule odniósł się do PL/I, COBOL, Fortran, APL (cudowna mieszanka pochwał i drwin: “APL to błąd, doprowadzony do perfekcji. To język przyszłości dla technik programowania z przeszłości: tworzy nowe pokolenie żuli kodowych.“), i FORTRAN (“beznadziejnie nieadekwatny”).

A tak swoją drogą, jeśli “PL” kojarzy Ci się z “PL/SQL”, to tak, istnieje pewne podobieństwo między nimi, ale to nie są te same języki (akronimy reprezentują inne nazwy: “Język Programowania” vs “Język Proceduralny” w SQL). Nawet prosta pętla for wygląda trochę inaczej (zobacz poniżej). Z drugiej strony, oba języki używają słów kluczowych takich jak BEGIN i END zamiast nawiasów klamrowych, co sprawia, że są do siebie bardziej podobne, ale również do Pascala czy ADA (te dwa ostatnie to oddzielny nowy świat, który możemy zgłębić).

-- PL/SQL:
  FOR i IN 1..10 LOOP
    DBMS_OUTPUT.PUT_LINE(i);
  END LOOP;

-- PL/I:
DO I = 1 TO 10;
  PUT SKIP LIST(I);  
END;

Ciekawostka – w grudniu 1967 roku w 5. wydaniu biuletynu PL/I opublikowano porównanie języków PL/I, COBOL i Fortran.

Porównywano te języki, używając dobrych kryteriów – trudność nauczenia się i trudność użycia, ta druga mierzona liczbą instrukcji potrzebnych do osiągnięcia danego celu, przydatność w zastosowaniach naukowych i biznesowych. Jednak ze względu na niewielki rozmiar publikacji (list do biuletynu) wyniki są raczej cytowane niż prezentowane, statystyki dla liczby instrukcji podane są bez kodów źródłowych. Bez zaskoczenia (w końcu to biuletyn PL/I), PL/I uznano za lepszy w niektórych obszarach, a przynajmniej tak samo dobry w innych. Miał łączyć najlepsze cechy pozostałych dwóch. W rzeczywistości miał też problemy z dotrzymaniem kroku ich indywidualnemu rozwojowi, co może być powodem tego, że nigdy się w tym samym stopniu nie przyjął.

Przykładowy kod PL/I z tamtych czasów można znaleźć w tym samym wydaniu (zobacz archiwum biuletynów PL/I), ale jakość skanu utrudnia osadzenie lub zacytowanie w poście. Jednakże, znalazłem przykład z października 1976 roku (strona 92), z dokumentacji kompilatora, i moim zdaniem pokazuje on, jak dużo więcej struktury miał kod (zauważ: wcięcia, złożone instrukcje if-else, procedury, argumenty procedur i fakt, że argumenty mogą mieć tę samą nazwę co zmienne z zewnątrz, zasłaniając je – w BASICu w tamtych czasach niemożliwe). A tak przy okazji, słowa kluczowe nie są wrażliwe na wielkości liter.

A: PROCEDURE;
   DECLARE S CHARACTER (20);
   DCL SET ENTRY(FIXED DEClMAL(1))
   OUT ENTRY(LABEL);
   CALL SET (3);
E: GET LIST (S,M,N);
   B:  BEGIN;
       DECLARE X(M,N), Y(M);
       GET LIST (X,Y);
       CALL C(X,Y);
C:  PROCEDURE (P,Q);
         DECLARE P(*,*), Q(*),
              S BINARY FIXED EXTERNAL;
            S = 0;
            DO I = 1 TO M;
         IF SUM (P(I,*)) = Q(I)
               THEN GO TO B;
         S = S+1;
         IF S = 3 THEN CALL OUT (E);
         CALL D(1);
     B:  END;
         END C;
     D:  PROCEDURE (N);
           PUT LIST ('ERROR IN ROW ', N, 'TABLE NAME ', S);
         END D;
     END B;
  GO TO E;
  END A;
OUT:  PROCEDURE (R);
      DECLARE R LABEL,
        (M,L) STATIC INTERNAL INITIAL (0),
        S BINARY FIXED EXTERNAL,
        Z FIXED DECIMAL(l);
      M M+l; S=O;
      IF M<L THEN STOP; ELSE GO TO R;
SET:  ENTRY (Z);
      L=Z;
      RETURN;
      END OUT;

Specyfikacja języka z 1965 roku dokumentuje również obsługę złożonych struktur danych (rekordów), tablic oraz tablic struktur. Na stronie 65 zdefiniowano:

Struktura jest hierarchicznym zbiorem skalarnych zmiennych, tablic i struktur. Nie muszą one być tego samego typu danych ani mieć tych samych atrybutów.

IBM Operating System/360, PL/I: Specyfikacja języka (lipiec 1965 r.)

Nic z tego nie istniało w BASICU przez dziesięciolecia i znając te ograniczenia oraz okropieństwa, do których doprowadzałyby programistę BASICa, aby je obejść w swoim kodzie, z pewnością można dojść do wniosku, że psuje to szanse na nauczenie się właściwych nawyków.

COBOL był do pewnego stopnia podobny. Opierał się na języku przetwarzania danych Flow-Matic zaprojektowanym przez Grace Hopper. W 1950 roku Hopper została inżynierem systemów i dyrektorem ds. opracowywania oprogramowania automatów w dziale UNIVAC. Miała doświadczenie w kompilatorach i kontynuowała pracę nad nimi, publikując swój pierwszy artykuł na ten temat w 1952 roku. Następnie uczestniczyła w pracach nad stworzeniem specyfikacji wspólnego języka biznesowego. Ponieważ Flow-Matic był jedynym istniejącym wówczas językiem biznesowym, posłużył również jako podstawy specyfikacji języka COBOL (COmmon Business-Oriented Language), który ostatecznie opracowano się w 1959 roku. Jej celem było międzynarodowe ustandaryzowanie języków komputerowych.

Pierwsza wersja COBOLA została opublikowana w 1960 roku, podczas gdy najnowsza – w 2023 roku.

Losowe przemyślenia z weryfikacji faktów na temat COBOLA:

• Jest na tyle stary, że wytyczne dotyczące stylu kodu / specyfikacja formatu biorą pod uwagę karty perforowane, ale to nie jedyna opcja: “Twój program może być dziurkowany na autonomicznej dziurkaczce lub utworzony za pomocą edytora tekstu online.”
• To właśnie format kart dziurkowanych standaryzował 80 znaków w wierszu. W innych przykładach wymieniono 122 znaki w wierszu. Sprawdź swój plik .editorconfig.
• Czytanie podręcznika COBOLA jest tak samo przyjemne, jak czytanie dzisiejszych stron podręcznika Linux, formatowanie też jest podobne.

Co mogło sprawić, że był lepszy od BASICa i co mogło spowodować, że Dijkstra powiedział, że kaleczy umysł? Zalety, moim zdaniem: miał również struktury danych typu rekord; pozwalał na złożone i zagnieżdżone instrukcje IF… i to by było na tyle; Wady: był bardzo rozwlekły (co niekoniecznie jest wadą, ale BARDZO rozwlekły) – między innymi zawsze określał 4 zdefiniowane sekcje (“działy”) kodu, nawet jeśli puste; deklaracja zmiennych wygląda dziwnie jak na dzisiejsze standardy; używa wielu angielskich słów, aby być naturalnym i samoopisującym się, ale brak krótszych, łatwiejszych do zrozumienia symboli sprawił, że uznano go za “niezrozumiały”. Był krytykowany za to, że był tworzony przez biznes i rząd, a nie środowiska akademickie. COBOL obsługiwał procedury, ale nie były one powszechnie stosowane (więcej osób używało instrukcji GO TO), nie było też możliwości przekazania parametrów do procedury, podobnie jak w Dartmouth i innych BASICach, więc i tak nie były one tak przydatne dla czytelności kodu lub konserwacji.

Sytuacja poprawiła się, gdy COBOL przyjął więcej funkcji. COBOL-74 dodał podprogramy, dając programistom możliwość kontrolowania, do których danych każda część programu mogła uzyskać dostęp. Nie mogło to jednak uratować reputacji języka kojarzonego z ogromnymi monolitycznymi i niestrukturalnymi makaronami/poplątanym kodem, przez co COBOL zaczął tracić popularność. Do 1985 roku było dwa razy więcej książek o FORTRANie i cztery razy więcej o BASICu niż o COBOLu w Bibliotece Kongresu.^[wikipedia]

Ponieważ ten post pokazuje fragmenty kodu we wszystkich językach, oto prosty przykład odniesienia do COBOLA:

PRG 11 Napisz program wykonujący operacje arytmetyczne za pomocą Czasowników Arytmetycznych. 
(Ćwiczenie na Liczbach Całkowitych, Liczbach Dziesiętnych i Liczbach Ze Znakiem).
* by surender, www.suren.space

      IDENTIFICATION DIVISION.                              
      PROGRAM-ID. PRG10.                                   
      ENVIRONMENT DIVISION.                                 
      DATA DIVISION.                                       
      WORKING-STORAGE SECTION.                              
      77 NUM1       PIC 9(4).                               
      77 NUM2       PIC 9(4).
      77 TOTAL      PIC 9(5).                               
      PROCEDURE DIVISION.                                   
          ACCEPT NUM1.                                      
          ACCEPT NUM2.                                      
          ADD NUM1 TO NUM2 GIVING TOTAL.                    
          DISPLAY TOTAL.                                 
          SUBTRACT NUM1 FROM NUM2 GIVING TOTAL.           
          DISPLAY TOTAL.                                 
          MULTIPLY NUM1 BY NUM2 GIVING TOTAL.             
          DISPLAY TOTAL.                                 
          DIVIDE NUM1 BY NUM2 GIVING TOTAL.               
          DISPLAY TOTAL.                                 
          STOP RUN.           

Fortran IV i 70

Kolejny “zły język”, a jednocześnie jeden z najpopularniejszych w tamtym czasie, więc nadal konkurent BASICa pod koniec lat 70:

Fortran — “dziecięca choroba” — mający już teraz prawie 20 lat, jest beznadziejnie nieadekwatny do jakiegokolwiek zastosowania komputerowego, które masz dzisiaj na myśli: jest zbyt nieporęczny, zbyt ryzykowny i zbyt kosztowny w użyciu.

Edsger Dijkstra, Jak mówimy prawdy, które mogą zaboleć?

Z dużej odległości, Fortran ma pewne podobieństwa do COBOLa. Był ważny, gdy powstał w 1957 roku, stworzony przez Johna Backusa, ponieważ był pierwszym szeroko rozpoznawalnym (i prawdopodobnie drugim w historii po Speedcoding tego samego twórcy) bardziej ogólnym, językiem wyższego poziomu, zastępującym szerokie stosowanie bezpośredniego programowania asemblerowego, które było ściśle związane z konkretną platformą sprzętową (od lat 50. do 90. istniała ogromna różnorodność rodzin CPU i języków maszynowych, które komputery “rozumiały” wewnętrznie; następnie na jakiś czas rynek ujednolicił się na architekturze x86, dzięki dużej popularności komputerów klasy IBM PC, a obecnie znów rozchodzimy się na x86 vs ARM).

Przykład kodu udostępniony przez vajrabum na HN będzie lepszy od przykładu Fortran 70, który początkowo zawarłem, a pokazuje jak typowy kawałek kodu w Fortranie wyglądał w tamtym czasie:

    C POLE POWIERZCHNI TRÓJKĄTA - WZÓR HERONA
    C WEJŚCIE - CZYTNIK KART JEDNOSTKA 5, LICZBY CAŁKOWITE, PUSTA KARTA NA KONIEC DANYCH
    C WYJŚCIE - DRUKARKA LINIOWA JEDNOSTKA 6, LICZBY RZECZYWISTE 
    C KOMUNIKAT BŁĘDU WEJŚCIA WYŚWIETLANY W WYJŚCIU 
      501 FORMAT(3I5)
      601 FORMAT(4H A= ,I5,5H  B= ,I5,5H  C= ,I5,8H  POLE= ,F10.2, $14H JEDNOSTKI KW.)
      602 FORMAT(10HZAKOŃCZONO) 
      603 FORMAT(25HBŁĄD DANYCH, WARTOŚĆ ZERO)
          INTEGER A,B,C
       10 READ(5,501) A,B,C
          IF(A.EQ.0 .AND. B.EQ.0 .AND. C.EQ.0) GO TO 50
          IF(A.EQ.0 .OR. B.EQ.0 .OR. C.EQ.0) GO TO 90
          S = (A + B + C) / 2.0
          POLE = SQRT( S * (S - A) * (S - B) * (S - C) )
          WRITE(6,601) A,B,C,POLE
          GO TO 10
       50 WRITE(6,602)
          STOP
       90 WRITE(6,603)
          STOP
          END

Nie był to ładny kod, opierał się na prefixach linii tak samo jak COBOL (z C oznaczającym Comment), ale miał też (opcjonalne!) numery linii, do których można było skakać poleceniem GO TO, podobnie jak w BASIC — ponieważ BASIC również zapożyczył tę cechę z Fortranu, nie tylko po to, by zapewnić rodzaj etykiet dla miejsc docelowych skoków w kodzie, ale także po to, by ułatwić edycję kodu linia-po-linii na dalekopisach. Oznacza to, że numery linii będące tutaj etykietami skoków, były sposobem na interaktywne programowanie online, dla komputerów obsługiwanych zdalnie.

Późniejszy Fortran 70 dał programistom więcej struktury, złożone i zagnieżdżone instrukcje warunkowych, instrukcje SUBROUTINE, FUNCTION. Jednak zmylił mnie swoją nazwą, sugerującą popularność już w 75 roku. Tak nie było, wciąż powszechnie używano Fortran IV i 66. Fortran 70 był raczej specyfikacją, nad którą pracowano, a dopiero w 1978 wydano wersję o nazwie Fortran 77. Pod koniec lat 70. można było zobaczyć kod Fortranu zastępujący GOTO zagnieżdżonymi instrukcjami IF:

      PROGRAM C1202A
      INTEGER YEAR,N,MONTH,DAY,T
C
C CALCULATES DAY AND MONTH FROM YEAR AND DAY-WITHIN-YEAR
C T IS AN OFFSET TO ACCOUNT FOR LEAP YEARS
C NOTE THE FIRST CRITERIA IS DIVISION BY 4
C BUT THAT CENTURIES ARE ONLY LEAP YEARS IF DIVISIBLE BY 400
C NOT 100 (4*25) ALONE
C - CORRECTED 14/3/12
C
      PRINT*,' YEAR, FOLLOWED BY DAY WITHIN YEAR'
      READ*,YEAR,N
C CHECKING FOR ORDINARY LEAP YEARS
      IF(((YEAR/4)*4).EQ.YEAR)THEN
        T=1
        IF ((YEAR/400)*400.EQ.YEAR)THEN
          T=1
        ELSEIF((YEAR/100)*100.EQ.YEAR)THEN
          T=0
        ENDIF
      ELSE
        T=0
      ENDIF
C ACCOUNTING FOR FEBRUARY
      IF(N.GT.(59+T))THEN
        DAY=N+2-T
      ELSE
        DAY=N
      ENDIF
      MONTH=(DAY+91)*100/3055
      DAY=(DAY+91)-(MONTH*3055)/100
      MONTH=MONTH-2
      PRINT*,' CALENDAR DATE IS ',DAY,MONTH,YEAR
      END

Składnia jest nieco bardziej sensowna, gdy ponownie zdamy sobie sprawę, jak dużo starszy jest ten język i o ile bardziej papierowy był domyślny format kodu.

Widać, że numery linii były w tamtym czasie jedynie opcjonalnym “numerem instrukcji”, aby ułatwić odniesienie do instrukcji podczas skakania do niej z innej części programu.

Patrząc jednak na PL/I, FORTRAN i COBOL, widzimy, że nawet najwcześniejsze języki programowania miały więcej cech programowania strukturalnego niż BASIC (definiowanie funkcji z własnymi argumentami, zagnieżdżone złożone instrukcje warunkowe).
Te języki nie były wszystkim, co było na rynku w latach 70., ale były zdecydowanie najpopularniejsze! Osobno przyjrzymy się pojawiającym się alternatywom.
Z najpopularniejszych – FORTRAN, COBOL i BASIC – wszystkie wciąż bardziej przypominały składnię asemblera ubraną w pewne wygodniejsze dla programisty konstrukcje (takie jak pętle, funkcje, zmienne), niż kompletne wysokopoziomowe języki programowania. Można powiedzieć, że były one rodzajem “cukru składniowego” nad asemblerem, ułatwiającym pisanie kodu, ale nie abstrahującym całkowicie od specyfiki procesora i pamięci.

Wspominając o wyborach, które byłyby bardziej oczywiste w następnych dekadach: Niklaus Wirth zaprojektował Pascal w 1970 roku. Do końca lat 70. zdobył on znaczną popularność. Podobny wzrost odnotowano dla języka C.

Lata 80./90.

Co się zmieniło?

Minęło kilka lat, a postęp technologiczny zaczął powodować, że komputery stawały się coraz mniejsze (niż pomieszczenie, w którym się znajdowały), stały się też na tyle przystępne cenowo, że oprócz rządów, uniwersytetów i największych firm, stać na nie było coraz więcej zwykłych ludzi. Rozpoczęła się rewolucja komputerów domowych.

Steve’owie i Ronald Wayne w 1976 roku zlutowali razem swoje komputery Apple I, po których w 1977 roku pojawił się szalenie popularny (w USA) Apple II. Miały one 4kB pamięci RAM, procesor taktowany 1 MHz i kosztowały znacznie poniżej 1000 dolarów. Apple I w 1976 roku kosztował “przystępne” 666 dolarów, przy czym warto pamiętać, że byłoby to 3600 dolarów w 2023 roku (za kalkulatorem inflacji).
1977 to rok premiery Atari 2600, które spopularyzowało gry komputerowe w domach, co zrewolucjonizowało przemysł rozrywki elektronicznej, do tej pory prężnie działający w salonach gier ze specjalnie zbudowanymi, i całkiem imponującymi, automatami do gier arcade.

Lata 80. otworzyły worek cudów: w 1980 roku na rynek weszły TRS-80, Commodore VIC-20 i ZX-80. W 1981 roku pojawił się ulepszony ZX-81.

Wtedy zaczęły pojawiać się komputery domowe, które są najmilej wspominane i które na dekady zdefiniowały rynek – zaczynając od 1982 roku, ze szczytem popularności około 1985 roku: wymieniając je parami 64kB/128kB były to Commodore 64/128, Atari 65/130XE, Amstrad CPC464/6128. Nawet graficznie hipnotyzujące MSX i Amiga 500 pojawiły się do 1985 roku! Widać też, że właśnie tutaj sprzedaż zwalniała (przyczyny tego same w sobie stanowią materiał na osobny post), a IBM-owska wersja “komputera osobistego” stała się “tym komputerem osobistym”.

Dziś już nie mówimy “komputer osobisty“, to po prostu komputer. Ale nie zawsze było to tak oczywiste. Jak widziałeś, terminale – ogromne biurka z zautomatyzowaną maszyną do pisania, podłączone do wielodostępnego komputera mainframe dzielącego zasoby… komputery były super-narzędziem naukowców w poprzednich dwóch-trzech dekadach. Dopiero w latach 80. zaczęły pojawiać się w wielu domach i mieć użytkowników, którzy nie są naukowcami, inżynierami czy korporacjami.

Okej, wróćmy do BASICa! Jak widać, właśnie tutaj zwykli ludzie, przeciętni użytkownicy komputerów, zyskali możliwość programowania. Przeciętna ZX Spectrum, Amstrad, Atari czy Commodore witały użytkownika kuszącym znakiem zachęty języka BASIC, gotowe do programowania sekundę po włączeniu!

Doświadczenie użytkownika

To nie było nawet “doświadczenie programisty”, ponieważ 8-bitowe komputery z lat 80. uruchamiały się prosto w BASICu, zachęcając wszystkich użytkowników do rozpoczęcia przygody z programowaniem.

W BASICu można stworzyć wiele świetnych programów – przykłady obejmują nawet oprogramowanie dowodzenia łodziami podwodnymi.

Najlepszym dowodem na to, ile wartości edukacyjnej i rozrywkowej można stworzyć w BASICu, jest popularność programów i gier typu wpisz-i-uruchom w tamtych dekadach. Posiadanie tak wielu domowych komputerów, które od razu po uruchomieniu witały użytkownika prostym językiem programowania i interpretem poleceń, umożliwiło spopularyzowanie prostego kodowania. Popularne w tamtych czasach magazyny komputerowe, takie jak Byte w USA czy jego mniejszy kuzyn Bajtek w Polsce (musielibyśmy to potwierdzić, ale skoro “Bajtek” jako “mały bajt” jest idealnym nawiązaniem zarówno do informatyki, jak i do amerykańskiego magazynu), drukowały tzw. programy “do wklepania”, co oznaczało, że można je było dosłownie przepisać z magazynu do swojego komputera, w rozsądnym czasie, i chwilę później dobrze się przy nich bawić!

Niektóre programy do wpisania to narzędzia, takie jak kalkulatory fizyczne czy liczniki wyrazów dla pisarzy. Inne to gry. Oto przykładowa gra wpisz-i-uruchom z magazynu BYTE z 1982 roku:

Czy automat do gry z czasopisma Bajtek:

Dodajmy mentalną notatkę: medium do przesyłania programów komputerowych? Papier.

W kolejnym wydaniu Byte’a, z czerwca 1982 roku, magazyn porusza ważny temat – brak standaryzacji. Mimo że prace nad standardem określającym to, co język powinien zapewniać, rozpoczęły się w 1970 roku, dopiero w 1983 roku pojawiła się propozycja standardu (Byte 02/1983).

Dlaczego wciąż używać numerów linii?

Popularne jest nienawidzenie BASICa za użycie numerów linii, cechy bardzo widocznej tutaj i bardzo źle postrzeganej, jeśli zaczynało się od potężniejszego komputera. Ale przypomnijmy sobie fakty, aby zobaczyć, dlaczego to w rzeczywistości miałoby sens:

• Umożliwiało dodanie linii do programu w pamięci – bez zapisywania go na kasetę magnetofonową lub, jeśli kupiło się jeden z droższych komputerów lub dodatków, dyskietkę. Można było edytować dowolne numery linii bez poświęcania lwiej części 16, 48 lub 64 kilobajtów pamięci RAM na edytor tekstu.
• Wciąż służyły jako dobre etykiety dla GOTO i GOSUB do skakania – zestaw etykiet tekstowych zająłby znacznie więcej miejsca w pamięci komputera, a to byłby luksus, który był wtedy bardzo drogi.
  Nawet słowa kluczowe, reprezentowane jako PRINT lub INPUT na ekranie, były przechowywane jako pojedyncze bajty tokenów w pamięci, aby zaoszczędzić miejsce. To materiał na inny artykuł.
• Można było mieszać edycję programu z interaktywnym sprawdzaniem, czy polecenie działa – czego nie można było zrobić, gdyby komputer był teraz w trybie edytora tekstu (8-bitowe komputery domowe nie były zorganizowane wokół wielozadaniowości – zazwyczaj pracowało się z jednym programem na raz).
  Powiedzmy, że kodowałeś prostą grę i chciałeś dodać dźwięk, gdy coś się dzieje. Napisałeś kod do momentu reakcji, którą dodajesz, ale chcesz przetestować, czy Twoje polecenie SOUND brzmi dobrze. Możesz po prostu pominąć numer linii, aby wykonać je natychmiast. Miałeś (-łaś) podgląd, byłeś (-łaś) zadowolona (-ny) z rezultatu, dodawałaś (-łeś) go do programu.
• Zdecydowanie pomagało też nie gubić się podczas wpisywania kodu z magazynu lub książki! Dodatkowo, mając edytory tekstu w tamtych czasach nie numerujące linii za Ciebie, możliwość powiedzenia “proszę spójrz na linię 230” podczas omawiania kodu z kimś innym była w tym kontekście faktycznie pomocna.

Ale jak dobrym językiem i jak łatwy w użyciu był BASIC do rozwiązywania problemów?
Postanowiłem sprawdzić to ponownie i zacząłem rozwiązywać kilka tegorocznych zadań z wyzwania Advent Of Code w BASICu. Żeby nie wymagało nawet emulatora, zdecydowałem się wybrać współczesny BBC BASIC, ale ograniczyłem się do funkcji, które pamiętam z Amstrada CPC6128 (lub tak mi się wydawało). Czyli z czasu, gdy każdy użytkownik mógł wykonać na przykład IF ... THEN ... <więcej niż 1 instrukcja> ... END IF. Mogliśmy mieć zmienne o dowolnej długości nazwy (jednak niektóre źródła sugerowały, że jednoliterowe są najszybsze, ponieważ mają statyczny adres pamięci; czy to prawda?), więc nie powinno być tak źle, prawda?

To był koszmar.

Rozwiązywanie wyzwań z dnia 1 (rozwiązanie) czy dnia 2 (rozwiązanie) było dobrą zabawą, nawet – lub zwłaszcza – gdy próbowałem być dość wydajny pamięciowo i nieco “niechlujny” w podejściu. Wtem nadchodzi dzień 3, w którym pracujemy z macierzą 140×140 znaków. Niektóre z nich tworzą liczby, niektóre to symbole, wszystko inne jest wypełnione . jako pusta przestrzeń.

Pierwszym zadaniem jest znalezienie wszystkich liczb, które są przyległe do symbolu (obok niego, powyżej lub poniżej, lub po skosie). Można to zrobić na jeden z możliwych sposobów, wczytując do pamięci 3 linie na raz i przetwarzając środkową jako “bieżącą”, i przewijając się przez zestaw danych bez zatrzymywania w pamięci więcej niż 3 linie. Następnie, mając na uwadze brak bardziej zaawansowanych funkcji manipulacji ciągami znaków, takich jak “split”, “find” czy “indexOf”, nie wspominając o wyrażeniach regularnych, możemy przetwarzać taką linię znak po znaku. Jeśli to cyfra, jesteśmy wewnątrz liczby. Aktualizuj liczbę cyfra po cyfrze (n=10*n+cyfra), dodaj do znanych liczb, gdy skończą się cyfry, i sprawdź czy występuje sąsiedztwo symbolu.

Wszystko brzmi prosto, jeśli możesz abstrahować logikę do funkcji lub jakiegoś rodzaju mniejszych modułów. Ale gdy kod trochę urośnie, a z powodu braku pamięci, narzędzi i całej reszty, chcesz zachować kilka dodatkowych flag dla swojej szczęśliwej małej maszyny stanów, rzeczy się komplikują.
Rozwiązanie dla dnia 3, które działa, ma 210 linii. W IDE z 2020 roku i języku programowania z 20XX, to byłoby małe i łatwe w utrzymaniu. Ale w tym momencie, mając wszystkie zmienne globalne, trudno je śledzić i poprawnie ponownie wykorzystać, nie mogąc mieć funkcji lub procedur, trudniej jest znać dane wejściowe i wyjściowe (więc GOSUB rozwiązuje tylko połowę problemu), rośnie też poczucie, że poświęcasz więcej czasu na niższym poziomie każdej operacji niż na faktyczne rozwiązanie głównego problemu. Gdy spróbowałem uruchomić to w BBC BASIC dla CP/M, okazało się również, że nawet część odczytująca jedną linię z pliku wymagałaby przepisania na podejście bardziej niskopoziomowe, bajt-po-bajcie, ponieważ operacja GET$#... TO ... nie jest obsługiwana.

Zdeterminowani programiści

Te trudności nie oznaczają, że wyrafinowane programy lub gry nie mogły być tworzone dla komputerów w ich rodzimym BASICu! Program demonstracyjny Amstrada CPC jest napisany w całości w BASICu, z wyjątkiem fragmentu gry “Roland w czasie”, prezentującego grafikę, muzykę, arkusz kalkulacyjny i funkcje edytora tekstów.

Możesz też zobaczyć nowocześniejsze (2006) demo, ale napisane całkowicie w Atari BASIC dla Atari XL/XE (możesz użyć 2x szybkości odtwarzania):

Te dema prezentują coś, czego wcześniej nie widziałeś! Grafika (i dźwięk)! Mniej lub bardziej zaawansowana, ale widzimy rzeczy w kolorze, widzimy je w ruchu, a w niektórych przypadkach możemy również słyszeć dźwięki i muzykę. Nie byłoby to możliwe w dialektach BASIC zaprojektowanych do zdalnego uruchamiania i drukowania na dalekopisach. Przenosząc komputer fizycznie do pokoju użytkownika, branża otworzyła drzwi do multimediów i bardziej dynamicznej rozrywki.
Uwaga: nie wszystkie BASICi w tamtym czasie miały słowa kluczowe grafiki. Na przykład Commodore 64 ich nie miał, ale niektóre efekty graficzne kodowane w BASICu mogły sprytnie wykorzystać sposób, w jaki drukował znaki tekstowe w kolorze, a także mogły obsługiwać sprite’y – które były grafiką nakładaną na zwykłą zawartość ekranu bez dodatkowych operacji kopiowania!

Jestem artystą!

Umożliwienie interakcji bogatszej niż monity tekstowe i odpowiedzi to coś więcej niż tylko techniczna różnica, coś więcej niż pozycja na liście specyfikacji.

Każdy język, który ułatwia tworzenie sztuki, otwiera twoją kreatywność, zaprasza do eksperymentowania i daje kontrolę oraz środki wyrazu.

I właśnie to zrobił, dwie sekundy od przełączenia włącznika zasilania. Wiele przykładów, w tym gotowych do wpisania, łączyło funkcje matematyczne i PLOT (rysuj punkt) lub LINE (rysuj linię) dla zaskakujących, hipnotyzujących efektów artystycznych. Poniżej znajduje się (przyspieszone 10x) nagranie demo “Crystals” napisanego w Atari BASIC na Atari XL/XE.

Te możliwości, pozwalające każdemu tworzyć proceduralną sztukę na własną rękę, są tym, co moim zdaniem jest największą zaletą i największym wpływem języka BASIC na przeciętnego użytkownika komputera. Pełny kod źródłowy nie jest nawet duży, zobacz pełny listing pod linkiem poniżej:

Magia programowania wizualnego to coś, co może przyciągnąć nie-nerda i co wprowadziło podstawy kodowania dla mas w latach 80. i 90.

Postawiłem tę ryzykowną hipotezę w tytule postów: że BASIC mógł zrobić coś lepiej niż większość języków. To jest ta lepsza rzecz w BASICu – łatwy dostęp do fundamentalnych możliwości graficznych i muzycznych komputera. Polecenia były proste, a prostota zapraszała do eksperymentowania i budowania na ich podstawie. Podręczniki do komputerów w tamtych czasach często uczyły cię również matematyki stojącej za niektórymi kształtami, wyjaśniając jak i dlaczego okrąg można wyrazić jako (x, y) = r*sin(x),r*cos(y), a tym samym jak narysować go poleceniem PLOT.

Oczywiście współczesne, popularne języki obsługują to wszystko (dlaczego usuwać coś, co działa?), jednym z najbliższych przykładów pod względem prostoty i popularności byłby JavaScript canvas. Przykładowy kod i efekt po lewej dla JavaScript, po prawej dla BASIC:

const canvas = document.getElementById("myCanvas");
const ctx = canvas.getContext("2d");

ctx.beginPath();
ctx.arc(100, 75, 50, 0, 2 * Math.PI);
ctx.stroke();

ORIGIN 100,75:r=50
FOR i=0 TO 360:PLOT r*sin(i),r*cos(i):NEXT

Przykład w BASICu wydaje się prostszy, mimo że nie ma słowa kluczowego/funkcji dla łuków czy okręgów, jest za to wynikiem wpisania kodu po prawej stronie bezpośrednio po uruchomieniu 8-bitowego komputera. Przykład po lewej stronie, gładszy, wyższej rozdzielczości i dużo szybszy w rysowaniu, jest z kolei dłuższy i… niekompletny. Odwołuje się do elementu myCanvas w dokumencie HTML, który nie jest nawet częścią przykładu (więc potrzebujemy przynajmniej jednej dodatkowej linijki, gdzieś indziej, i przeglądarki internetowej).

Większość języków będzie miała wiele sposobów na rysowanie rzeczy na ekranie i będzie do wyboru dziesiątki bibliotek – jest to zarówno dobre, jak i złe. Jeśli język nie obsługuje czegoś wbudowanymi narzędziami, oznacza to zarówno elastyczność, jak i potrzebę znalezienia i zrozumienia najlepszego narzędzia do realizacji danego zadania, sposobu odwołania się do niego, ewentualnie zainstalowania lub dołączenia do programu itd. Te problemy nie istnieją, jeśli pracujesz w środowisku prostym, ale wysoce zintegrowanym. BASIC pomagał poznać podstawy. Kiedy już się je opanuje, zazwyczaj chce się przejść do bardziej zaawansowanego zestawu narzędzi, niezależnie od maszyny.

Dzisiaj

Daje nam to dwa aspekty do rozpatrzenia “dzisiaj”:

• Jak radzi sobie dzisiaj BASIC? Jak radzą sobie konkurenci? Które inne języki są najpopularniejsze? 🙂
• Co daje podobne doświadczenie użytkownika dzisiaj, ale jest nowocześniejsze, łatwiejsze w użyciu i równie zabawne?

Inni jeszcze nie umarli

Co może być zaskakujące, żaden z języków wymienionych wcześniej dla lat 70., 80. i 90. nie umarł.

• PL/I jest nadal wspierany i utrzymywany przez, jak zawsze, IBM. Oto podręcznik PL/I z 2019 roku.
• Nordea nadal zatrudnia programistów COBOL. Rozpaczliwie, jak przypuszczam.
• Fortran żyje i jakoś sobie radzi. Najnowsza specyfikacja to Fortran 2023.
• APL to bardziej ciekawostka – język, w którym poprawna instrukcja może wyglądać jak {↑1 ⍵∨.∧3 4=+/, ̄1 0 1∘.⊖ ̄1 0 1∘.⌽⊂⍵} nie jest łatwo przyswajalny i zdobywa serca raczej hobbystów i matematyków niż przeciętnych programistów.

Najpopularniejsze 10 języków programowania zmieniło się od lat 70. (lub 80.). Według rankingu IEEE na 2023 rok, top 10 języków to: Python, Java, C++, C, JavaScript, C#, SQL, Go, TypeScript i… HTML (co? w nazwie dosłownie jest napisane, że to Markup Language – język znaczników, do opisu dokumentu). Warto zauważyć, że C, które powstało w 1972 ale zostało oficjalnie opublikowane w 1978 roku, nie mogło być skrytykowane przez Dijkstrę w tamtym czasie. Visual Basic jest na 24. miejscu, ponieważ Microsoft zdecydował się zaprzestać dalszego rozwoju języka w 2020 roku. Fortran pozostaje na 27. miejscu, COBOL na 34. a Ada na 36. Na końcu, Pascal/Delphi jest wymieniony na 45. pozycji.

BASIC też żyje

BASIC oczywiście też nie przestał się rozwijać. Poniższe przykłady pokazują, że język nadal jest ceniony za prostotę i łatwość użycia bezpośrednio ze sprzętem. Godne uwagi wzmianki obejmują:

• QuickBASIC, który był dołączony do MS-DOS, utrzymując możliwość łatwego dostępu do podstawowego języka programowania.
• Visual Basic (z Visual Basic .NET, VBScript i językami skryptowymi pakietów biurowych, takimi jak Visual Basic for Applications firmy Microsoft i OpenOffice Basic, które wyewoluowały z tego) – kontynuacja rodowodu BASIC przez lata przez Microsoft. Można prześledzić jego ewolucję od języka przyjaznego początkującym do pełnowartościowego profesjonalnego narzędzia programistycznego. Jednak w 2020 roku Microsoft ogłosił, że nie planuje dalszego rozwoju języka.
• FreeBASIC. Jest to projekt open source, bardzo bogaty w funkcje.
• BBC BASIC – ten ma długą historię! Jest ewolucją języka stworzonego dla komputera BBC Micro w 1981 roku. Obsługuje ogromną liczbę systemów operacyjnych (od komputerów CP/M z lat 80., przez Raspberry Pi, po Android i iOS). Strona jest również mocna po stronie dokumentacji.
• SmallBasic firmy Microsoft – przeznaczony do nauki programowania, “nawet przez dzieci”, co sugeruje, że może się skupiać na prostocie “zabawnych” funkcji, które wprowadził BASIC. Wprowadza również grafikę żółwia, koncepcję wprowadzoną przez język LOGO, która przyniosła nowe, względne podejście do rysowania rzeczy na ekranie.
• Dialekty BASIC, takie jak B4X mogą nawet działać na mikrokontrolerach – wersje BASIC zostały stworzone dla Arduino i innych płytek mikrokontrolerów, przywracając ducha wczesnych BASICów na PC.
• PBASIC – komercyjny wariant BASIC stworzony specjalnie dla mikrokontrolerów BASIC Stamp firmy Parallax. Znany ze swojej dostępności i przystępnej dokumentacji.

Jak widać, BASIC wciąż ewoluuje i jest wykorzystywany w wielu dziedzinach – od nauki programowania, przez skryptowanie aplikacji biurowych, po programowanie mikrokontrolerów. Jego prostota, łatwość nauki i uniwersalność sprawiają, że pozostaje popularnym językiem programowania mimo upływu dekad od powstania.

Ale co miałoby ten sam efekt dzisiaj?

Chociaż sam BASIC może nie mieć już takiej popularności, jaką miał w erze domowych komputerów 8-bitowych, dziedzictwo tego języka wciąż żyje dziś w różnych formach.

Świetnym punktem wyjścia, gdzie można zobaczyć interesujące efekty przy niewielkiej ilości kodu, byłby język Processing (dostępny również w JS jako p5js). Zapewnia on proste interfejsy API do rysowania grafiki, animacji i wizualizacji w sposób natychmiastowy, przypominający klasyczne interpretatory BASIC. Spójrz na przykład: Recursive Tree / Examples / Processing.org – język ma funkcje, których brakowało BASIC, pozwalające poprawnie strukturyzować kod, i ma niezwykle łatwe w użyciu polecenia do rysowania rzeczy na ekranie, a nawet renderowania obiektów 3D.
Inny fajny przykład z dźwiękiem, prosta koncepcja, ale zabawna: p5.js Web Editor | BUBBLE WORDS (p5js.org)

Pojęcie, którego Processing jest przykładem, nazywa się “kreatywne programowanie”, a Processing jest w tym tak samo dobry, jak BASIC był w latach 80. Spójrz na poniższą demonstrację “celu”, lub Dryfując w przestrzeni kosmicznej:

Bardzo polecam Processing do kreatywnych i zabawnych eksperymentów, ale oczywiście istnieją też inne opcje. Wymienimy przynajmniej kilka z nich.

Scratch, kolorowy język programowania oparty na blokach, zaprojektowany dla dzieci, niesie kaganek dziedzictwa BASIC lepiej niż jakiekolwiek inne nowoczesne narzędzie. Poprzez użycie bloków wizualnych, które łączą się ze sobą jak klocki układanki, zamiast wpisywanej składni, usuwa on główną wczesną barierę dla kreatywności w programowaniu, która istniała nawet w uproszczonych wersjach BASIC. Tematyczna grafika, animacje i biblioteki dźwiękowe sprawiają, że eksploracja jest jeszcze bardziej zabawna dla młodych programistów. Tak jak BASIC i wczesne domowe komputery stworzyły bramę dla wielu pionierów technologii, Scratch ma na celu pielęgnowanie tego samego eksperymentalnego ducha, niezależnie od wcześniejszego dostępu dziecka do technologii czy edukacji. Jego społeczność internetowa również łączy rówieśników, aby dzielić się projektami i tworzyć ich remiksy – zdecydowanie bardziej społeczne podejście niż samotne majsterkowanie z BASIC w przeszłości.

Jeśli czujesz się swobodniej w programowaniu w ogóle i nie wahasz się używać większej liczby poleceń, aby osiągnąć swój rezultat, kosztem większej elastyczności i przenośności, rozważ JavaScript – mimo że nie jest ściśle pochodną BASIC, JS ma bardzo luźny, dynamiczny styl, który przypomina niektóre cechy tego języka. Szczególnie w preglądarce ma dostęp do wielu interfejsów progrmamistycznych pozwalających łatwo eksperymentować z tekstem, obrazem i dźwiekiem. Fakt, że jest w ten sposób tak szeroko stosowany w swobodnie interaktywnych aplikacjach internetowych, łączy go z interaktywną naturą BASICa i jego dawną dostępnością.

Jak wspomina todd8 na HackerNews, jedną z najlepszych opcji do rozpoczęcia programowania i wypróbowania rozwiązywania problemów programistycznych – czy to czegoś prostego, czy bardziej złożonego, wyzwanie programistyczne, gra czy automatyzacja domowa – jest Python.
Używałem Pythona jako mojego głównego języka programowania z przerwami od początku tej części mojego życia, w której programowanie stało się moją profesją, w tym kilka lat skupienia wyłącznie na Pythonie. Zdecydowanie jest to język, który usuwa na drugi plan “jak” (wykonać daną operację na twoich danych), pozwalając skupić się na “co” (próbujesz zrobić lub zbudować). Posiada pewne udogodnienia składniowe, które dla nowicjusza mogą wydawać się “magiczne”, takie jak listy składane, ale po pewnym czasie dobry ogląd tego co jest idiomatyczne w Pythonie pozwala pisać bardzo czytelny kod, który osiąga wiele w zaledwie kilku lub jednej linijce kodu – a mimo to pozostaje doskonale czytelny!
Jeśli jesteś nowy w programowaniu i kreatywna część (wizualna, dźwiękowa, artystyczna) nie jest tym, na czym skupiasz się najbardziej, polecam Pythona. Jeśli nie jesteś nowicjuszem, odpowiedź wciąż może być Python 🙂

Żaden z nich nie powita cię na ekranie dwie sekundy po naciśnięciu przycisku zasilania, jednak. Doświadczenie komputera gotowego (Ready) na polecenia w ciągu kilku sekund, środowiska wolnego od rozpraszaczy, zachęcającego do eksperymentów (link do wpisu otwierającego, który skłonił mnie do założenia RetroFunPL), było bardziej wciągające niż szukanie odpowiedniego języka, edytora, przeglądarki, katalogu na dysku lub instalowanie pythona/czegokolwiek innego poza przeglądarką, jeśli wszystko to jest dla kogoś nowe.

Dawniej i dziś

Chociaż sama nazwa BASIC może nie mieć już takiej popularności, jaką miała w erze domowych komputerów, dziedzictwo tego języka wciąż żyje dziś w różnych formach. Nowoczesne narzędzia takie jak Processing i p5.js do projektów kreatywnego kodowania odziedziczyły po BASICu nacisk na dostępność i szybką wizualizację dla początkujących. Dostarczają one prostych interfejsów API do rysowania grafiki, animacji i wizualizacji z natychmiastowymi efektami, przypominający klasyczne interpretatory BASIC. Scratch kontynuuje misję BASICa w zakresie wprowadzania młodych uczniów w świat programowania, w zabawnym i intuicyjnym środowisku.

Nawet poza dziedziną czysto edukacyjnych narzędzi, sam JavaScript, pomimo braku bezpośredniego pokrewieństwa z BASICiem, ma elastyczny, przyjazny dla początkujących styl kodowania, przypominający jedną z najsłynniejszych cech BASICa. Fakt, że JavaScript napędza dziś większość interaktywnych stron internetowych i aplikacji webowych, przypomina sposób, w jaki BASIC otworzył nowe dziedziny interaktywnego oprogramowania we wczesnej erze komputerów. A dla tych, którzy tęsknią za złotymi czasami BASICa na mikrokomputerach, nowoczesne płytki mikrokontrolerów takie jak Arduino często mają niestandardowe interpretatory i kompilatory BASICa, stworzone przez społeczność, do sterowania projektami sprzętowymi. Więc podczas gdy BASIC ewoluuje na nowych platformach, jego dostępność i nacisk na szybką iterację utrzymują się w DNA wielu nowoczesnych narzędzi programistycznych.

Wiele dyskusji wokół “BASIC jest zły” koncentruje się również wokół “GOTO jest złe”. Tak, bezwarunkowy skok do dowolnego miejsca w programie może być zły, jeśli naruszy się granice struktur kodu, na przykład skokiem ze środka jednej funkcji do środka drugiej. Ale w przypadkach, o których mówimy, nie ma struktur, więc nie sposób je naruszyć.
Można również stwierdzić, i niektórzy się z tym zgodzą (jeśli dobrze rozumiem komentarz zozbot234 na HN), że problem leży nie tylko w miejscu, z którego wykonujemy skok GOTO, ale i po “odbiorczej stronie” – jeśli możesz skoczyć do dowolnej linii w kodzie, trudno jest wiedzieć, czy dana linia jest celem takich skoków i skąd one pochodzą. Jest to spory problem podczas czytania kodu, który funkcje, procedury i klasy rozwiązują bardziej elegancko.

Chociaż krytyka BASICa przez Dijkstrę była kontrowersyjna, wywołała ona dyskusję, która miała wpływ na rozwój edukacji informatycznej oraz projektowania języków programowania. Historia BASICa pokazuje, jak bardzo opinie mogą się różnić co do najlepszego sposobu zrównoważenia prostoty i mocy podczas tworzenia narzędzi dla początkujących programistów. We wczesnych latach BASIC koncentrował się na łatwości użycia, kosztem zaawansowanych możliwości. Jednak z czasem ewoluował, włączając więcej funkcji bez utraty przystępności. Nowoczesne wersje BASICa mają na celu zaoferowanie łagodnego punktu startowego dla początkujących, a jednocześnie możliwości pisania bardziej złożonego kodu. Wciąż toczą się debaty nad znalezieniem optymalnej równowagi w obsłudze programistów o różnych umiejętnościach. Jednak różne perspektywy posunęły tę dziedzinę do przodu. Ostatecznie, mnogość różnorodnych języków programowania może koegzystować, pasując do różnych potrzeb. Intensywność poglądów Dijkstry rzuca światło na to, jak namiętnie programiści troszczą się o budowanie najlepszych systemów dla swoich kolegów, aby tworzyć magiczne oprogramowanie i odblokować ludzki potencjał. Chociaż jego krytyka była skrajna, otworzyła wartościowy dialog.

Zobacz także

Dokument Dartmouth College o BASICu z okazji 50-lecia (2014) podkreśla inne kluczowe cechy systemu, takie jak dzielenie czasu (BASIC był faktycznie używany jednocześnie przez wielu użytkowników!).

BASIC

• Przykładowe podręczniki Dartmouth BASIC: pierwsza i czwarta edycja języka:

• Książki BASIC Seana McManusa: Amstrad CPC 464 664 6128 Podręcznik programowania Basic i gier. Podstawowa idea (sean.co.uk)

PL/I

• Archiwum biuletynów PL/I na stronie teampli.net
• Jeśli jesteś ciekawy, jak PL/I był używany w kodzie źródłowym Multics, oto przykładowy program narzędziowy.

COBOL

• Kilka przyjaznych przykładów COBOL ze współczesną terminologią tutaj: 7 przykładów COBOL z wyjaśnieniami. | Yvan Scher | Medium — Nie popieram zamkniętych platform takich jak Medium, Yvan napisał, że przeniósł swój blog na własną domenę, ale ta domena już nie działa.

Przetwarzanie

• Odkryj – OpenProcessing – galeria przykładów, źródeł inspiracji