Dlaczego języki programowania, zwłaszcza C, używają nawiasów klamrowych, a nie kwadratowych?

Definicję „języka w stylu C” można praktycznie uprościć do „używa nawiasów klamrowych ( {})”. Dlaczego używamy tej konkretnej postaci (i dlaczego nie coś bardziej rozsądnego, na przykład [], co nie wymaga klawisza Shift przynajmniej na klawiaturach w USA)?

Czy jest jakaś rzeczywista korzyść dla wydajności programisty pochodzącej z tych nawiasów, czy też nowi projektanci języków powinni szukać alternatyw (np. Facetów stojących za Pythonem)?

Wikipedia mówi nam, że C używa wspomnianych aparatów ortodontycznych, ale nie dlaczego. Oświadczenie w artykule w Wikipedii na temat listy języków programowania opartych na języku C sugeruje, że ten element składniowy jest nieco wyjątkowy:

Mówiąc ogólnie, języki rodziny C to te, które używają składni bloków podobnych do C (w tym nawiasów klamrowych do rozpoczynania i kończenia bloku) ...

Dwa główne czynniki wpływające na C to rodzina języków Algol (Algol 60 i Algol 68) i BCPL (od której C bierze swoją nazwę).

BCPL był pierwszym językiem programowania nawiasów klamrowych, a nawiasy klamrowe przetrwały zmiany składniowe i stały się powszechnym środkiem oznaczania instrukcji kodu źródłowego programu. W praktyce, na ograniczonych klawiaturach dnia, programy źródłowe często używały sekwencji $ (i $) zamiast symboli {i}. Komentarze jednowierszowe „//” BCPL, które nie zostały uwzględnione w C, pojawiły się ponownie w C ++, a później w C99.

From http://www.princeton.edu/~achaney/tmve/wiki100k/docs/BCPL.html

BCPL wprowadził i wdrożył kilka innowacji, które stały się dość powszechnymi elementami w projektowaniu późniejszych języków. Tak więc był to pierwszy język programowania w nawiasach klamrowych (taki, w którym jako separatory bloków używano {}), a także jako pierwszy używano // do oznaczania wbudowanych komentarzy.

From http://progopedia.com/language/bcpl/

W ramach BCPL często widać nawiasy klamrowe, ale nie zawsze. Było to wówczas ograniczenie klawiatury. Znaki $(i $)były leksykograficznie równoważne do {i }. Digraphy i trigrafy były utrzymywane w C (choć inny zestaw do wymiany nawiasów klamrowych - ??<i ??>).

Zastosowanie nawiasów klamrowych zostało dodatkowo udoskonalone w B (które poprzedziło C).

Od odniesienia użytkowników do B autorstwa Kena Thompsona:

/* The following function will print a non-negative number, n, to
  the base b, where 2<=b<=10,  This routine uses the fact that
  in the ASCII character set, the digits 0 to 9 have sequential
  code values.  */

printn(n,b) {
        extern putchar;
        auto a;

        if(a=n/b) /* assignment, not test for equality */
                printn(a, b); /* recursive */
        putchar(n%b + '0');
}

Istnieją przesłanki, że nawiasy klamrowe były używane jako krótka ręka w Algolu begini endwewnątrz niego.

Pamiętam, że umieściłeś je również w 256-znakowym kodzie karty, który opublikowałeś w CACM, ponieważ uznałem za interesujące, że zaproponowałeś, aby można je było stosować zamiast słów kluczowych „początek” i „koniec” Algolu, czyli dokładnie jak zostały później użyte w języku C.

Od http://www.bobbemer.com/BRACES.HTM

Zastosowanie nawiasów kwadratowych (jako sugerowanego zamiennika w pytaniu) sięga jeszcze dalej. Jak wspomniano, rodzina Algola miała wpływ na C. W Algolu 60 i 68 (C napisano w 1972 r. I BCPL w 1966 r.) Nawias kwadratowy zastosowano do oznaczenia indeksu w tablicy lub macierzy.

BEGIN
  FILE F(KIND=REMOTE);
  EBCDIC ARRAY E[0:11];
  REPLACE E BY "HELLO WORLD!";
  WRITE(F, *, E);
END.

Ponieważ programiści znali już nawiasy kwadratowe dla tablic w Algolu i BCPL oraz nawiasy klamrowe dla bloków w BCPL, nie było potrzeby ani chęci zmiany tego przy tworzeniu innego języka.

Zaktualizowane pytanie zawiera dodatek produktywności dla użycia nawiasów klamrowych i wspomina o pythonie. Istnieją inne zasoby, które zajmują się tym badaniem, chociaż odpowiedź sprowadza się do „Jest to anegdota, a to, do czego jesteś przyzwyczajony, to to, z czego jesteś najbardziej produktywny”. Ze względu na bardzo różne umiejętności programowania i znajomość różnych języków, stają się one trudne do wytłumaczenia.

Zobacz także: Przepełnienie stosu Czy istnieją badania statystyczne wskazujące, że Python jest „bardziej produktywny”?

Wiele korzyści będzie zależało od zastosowanego IDE (lub jego braku). W edytorach opartych na vi, umieszczenie kursora nad jednym pasującym otwieraniem / zamykaniem i naciśnięcie %spowoduje przeniesienie kursora do drugiego pasującego znaku. Jest to bardzo wydajne w przypadku języków opartych na C w dawnych czasach - teraz mniej.

Lepszym porównaniem byłoby między {}i begin/ endktóre były opcjami dnia (przestrzeń pozioma była cenna). Wiele języków Wirth opartych było na stylu begini end(Algol (wspomniany powyżej), pascal (wielu zna) i rodzina Modula).

Mam trudności ze znalezieniem tych, które izolują tę konkretną cechę języka - co mogę zrobić, to pokazać, że języki nawiasów klamrowych są znacznie bardziej popularne niż języki początkowe i jest to wspólna konstrukcja. Jak wspomniano w linku Boba Bemera powyżej, nawias klamrowy został użyty, aby ułatwić programowanie jako skrót.

Od Dlaczego Pascal nie jest moim ulubionym językiem programowania

Programiści C i Ratfor uważają, że „początek” i „koniec” są nieporęczne w porównaniu do {i}.

To wszystko, co można powiedzieć - jego znajomość i preferencje.

Kwadratowe nawiasy klamrowe []są łatwiejsze do wpisania, odkąd terminal IBM 2741, który był „szeroko stosowany w systemie operacyjnym Multics” , który z kolei miał Dennisa Ritchiego, jednego z twórców języka C jako członka zespołu programistów .

^{Zwróć uwagę na brak nawiasów klamrowych w układzie IBM 2741!}

W C nawiasy kwadratowe są „pobierane”, ponieważ są używane do tablic i wskaźników . Jeśli projektanci języków spodziewali się, że tablice i wskaźniki będą ważniejsze / używane częściej niż bloki kodu (co brzmi jak rozsądne założenie po ich stronie, bardziej w kontekście historycznego stylu kodowania poniżej), oznaczałoby to, że nawiasy klamrowe byłyby „mniej ważne „składnia.

Znaczenie tablic jest dość widoczne w artykule The Development of the C Language autorstwa Ritchie. Istnieje nawet wyraźnie określone założenie „rozpowszechnienia wskaźników w programach C” .

... nowy język zachował spójne i wykonalne (jeśli nietypowe) wyjaśnienie semantyki tablic ... Dwie idee są najbardziej charakterystyczne dla C wśród języków jego klasy: związek między tablicami i wskaźnikami ... Inna charakterystyczna cecha C, jego traktowanie tablic ... ma prawdziwe zalety . Chociaż związek między wskaźnikami a tablicami jest niezwykły, można się tego nauczyć. Co więcej, język wykazuje znaczną moc opisywania ważnych pojęć, na przykład wektorów, których długość zmienia się w czasie wykonywania, z jedynie kilkoma podstawowymi zasadami i konwencjami ...

Aby lepiej zrozumieć kontekst historyczny i styl kodowania w czasie, gdy język C był tworzony, należy wziąć pod uwagę, że „pochodzenie C jest ściśle związane z rozwojem Uniksa”, a w szczególności przenosi system operacyjny na PDP- 11 „doprowadziło do opracowania wczesnej wersji C” ( źródło cytatów ). Według Wikipedii , „w 1972 roku, Unix został przepisany w języku programowania C” .

Kod źródłowy różnych starych wersji Uniksa jest dostępny online, np. Na stronie The Unix Tree . Spośród różnych przedstawionych tam wersji, najbardziej odpowiednia wydaje się być Second Edition Unix z 1972-06:

Druga edycja Uniksa została opracowana dla PDP-11 w Bell Labs przez Kena Thompsona, Dennisa Ritchie i innych. Rozszerzył pierwszą edycję o więcej wywołań systemowych i więcej poleceń. W tej edycji pojawił się także początek języka C, który był używany do pisania niektórych poleceń ...

Możesz przeglądać i studiować kod źródłowy C ze strony drugiej edycji Uniksa (V2), aby uzyskać wyobrażenie o typowym stylu kodowania tamtych czasów.

Wybitny przykład, który popiera pomysł, że w tamtym czasie programiści mogli z łatwością pisać nawiasy kwadratowe, można znaleźć w kodzie źródłowym V2 / c / ncc.c :

/* C command */

main(argc, argv)
char argv[][]; {
    extern callsys, printf, unlink, link, nodup;
    extern getsuf, setsuf, copy;
    extern tsp;
    extern tmp0, tmp1, tmp2, tmp3;
    char tmp0[], tmp1[], tmp2[], tmp3[];
    char glotch[100][], clist[50][], llist[50][], ts[500];
    char tsp[], av[50][], t[];
    auto nc, nl, cflag, i, j, c;

    tmp0 = tmp1 = tmp2 = tmp3 = "//";
    tsp = ts;
    i = nc = nl = cflag = 0;
    while(++i < argc) {
        if(*argv[i] == '-' & argv[i][1]=='c')
            cflag++;
        else {
            t = copy(argv[i]);
            if((c=getsuf(t))=='c') {
                clist[nc++] = t;
                llist[nl++] = setsuf(copy(t));
            } else {
            if (nodup(llist, t))
                llist[nl++] = t;
            }
        }
    }
    if(nc==0)
        goto nocom;
    tmp0 = copy("/tmp/ctm0a");
    while((c=open(tmp0, 0))>=0) {
        close(c);
        tmp0[9]++;
    }
    while((creat(tmp0, 012))<0)
        tmp0[9]++;
    intr(delfil);
    (tmp1 = copy(tmp0))[8] = '1';
    (tmp2 = copy(tmp0))[8] = '2';
    (tmp3 = copy(tmp0))[8] = '3';
    i = 0;
    while(i<nc) {
        if (nc>1)
            printf("%s:\n", clist[i]);
        av[0] = "c0";
        av[1] = clist[i];
        av[2] = tmp1;
        av[3] = tmp2;
        av[4] = 0;
        if (callsys("/usr/lib/c0", av)) {
            cflag++;
            goto loop;
        }
        av[0] = "c1";
        av[1] = tmp1;
        av[2] = tmp2;
        av[3] = tmp3;
        av[4] = 0;
        if(callsys("/usr/lib/c1", av)) {
            cflag++;
            goto loop;
        }
        av[0] = "as";
        av[1] = "-";
        av[2] = tmp3;
        av[3] = 0;
        callsys("/bin/as", av);
        t = setsuf(clist[i]);
        unlink(t);
        if(link("a.out", t) | unlink("a.out")) {
            printf("move failed: %s\n", t);
            cflag++;
        }
loop:;
        i++;
    }
nocom:
    if (cflag==0 & nl!=0) {
        i = 0;
        av[0] = "ld";
        av[1] = "/usr/lib/crt0.o";
        j = 2;
        while(i<nl)
            av[j++] = llist[i++];
        av[j++] = "-lc";
        av[j++] = "-l";
        av[j++] = 0;
        callsys("/bin/ld", av);
    }
delfil:
    dexit();
}
dexit()
{
    extern tmp0, tmp1, tmp2, tmp3;

    unlink(tmp1);
    unlink(tmp2);
    unlink(tmp3);
    unlink(tmp0);
    exit();
}

getsuf(s)
char s[];
{
    extern exit, printf;
    auto c;
    char t, os[];

    c = 0;
    os = s;
    while(t = *s++)
        if (t=='/')
            c = 0;
        else
            c++;
    s =- 3;
    if (c<=8 & c>2 & *s++=='.' & *s=='c')
        return('c');
    return(0);
}

setsuf(s)
char s[];
{
    char os[];

    os = s;
    while(*s++);
    s[-2] = 'o';
    return(os);
}

callsys(f, v)
char f[], v[][]; {

    extern fork, execv, wait, printf;
    auto t, status;

    if ((t=fork())==0) {
        execv(f, v);
        printf("Can't find %s\n", f);
        exit(1);
    } else
        if (t == -1) {
            printf("Try again\n");
            return(1);
        }
    while(t!=wait(&status));
    if ((t=(status&0377)) != 0) {
        if (t!=9)       /* interrupt */
            printf("Fatal error in %s\n", f);
        dexit();
    }
    return((status>>8) & 0377);
}

copy(s)
char s[]; {
    extern tsp;
    char tsp[], otsp[];

    otsp = tsp;
    while(*tsp++ = *s++);
    return(otsp);
}

nodup(l, s)
char l[][], s[]; {

    char t[], os[], c;

    os = s;
    while(t = *l++) {
        s = os;
        while(c = *s++)
            if (c != *t++) goto ll;
        if (*t++ == '\0') return (0);
ll:;
    }
    return(1);
}

tsp;
tmp0;
tmp1;
tmp2;
tmp3;

Warto zauważyć, jak pragmatyczna motywacja wybierania znaków w celu oznaczenia elementów składni języka na podstawie ich użycia w ukierunkowanych praktycznych zastosowaniach przypomina Prawo Zipfa, jak wyjaśniono w tej wspaniałej odpowiedzi ...

zaobserwowany związek między częstotliwością a długością nazywa się prawem Zipfa

... z tą różnicą, że długość powyższego wyrażenia jest zastępowana / uogólniona jako szybkość pisania.

C (a następnie C ++ i C #) odziedziczył swój styl wzmacniający po swoim poprzedniku B , który został napisany przez Kena Thompsona (z udziałem Dennisa Ritchiego) w 1969 roku.

Ten przykład pochodzi z odniesienia użytkownika do B autorstwa Kena Thompsona (za pośrednictwem Wikipedii ):

/* The following function will print a non-negative number, n, to
   the base b, where 2<=b<=10,  This routine uses the fact that
   in the ASCII character set, the digits 0 to 9 have sequential
   code values.  */

printn(n,b) {
        extern putchar;
        auto a;

        if(a=n/b) /* assignment, not test for equality */
                printn(a, b); /* recursive */
        putchar(n%b + '0');
}

Sam B był ponownie oparty na BCPL , języku napisanym przez Martina Richardsa w 1966 roku dla systemu operacyjnego Multics. System stężeń B wykorzystywał tylko okrągłe stężenia, modyfikowane dodatkowymi znakami (przykład czynnikowy wydruku Martin Richards, z Wikipedii ):

GET "LIBHDR"

LET START() = VALOF $(
        FOR I = 1 TO 5 DO
                WRITEF("%N! = %I4*N", I, FACT(I))
        RESULTIS 0
)$

AND FACT(N) = N = 0 -> 1, N * FACT(N - 1)

Nawiasy klamrowe używane w języku B i kolejnych językach „{...}” to ulepszenie wprowadzone przez Kena Thompsona w stosunku do oryginalnego stylu złożonego aparatu klamrowego w BCPL „$ (...) $”.