Por que linguagens de programação, especialmente C, usam chaves curvas e não quadradas?

A definição de "linguagem C-Style" pode ser praticamente simplificada para "usa chaves ( {})." Por que usamos esse caractere em particular (e por que não algo mais razoável, como [], que não requer a tecla Shift pelo menos nos teclados dos EUA)?

Existe algum benefício real na produtividade do programador proveniente desses aparelhos, ou os novos designers de linguagem devem procurar alternativas (por exemplo, os caras por trás do Python)?

A Wikipedia nos diz que C usa os aparelhos mencionados, mas não o porquê. Uma declaração no artigo da Wikipedia sobre a lista de linguagens de programação baseadas em C sugere que esse elemento de sintaxe é algo especial:

Em termos gerais, os idiomas da família C são aqueles que usam sintaxe de bloco do tipo C (incluindo chaves para iniciar e finalizar o bloco) ...

Duas das principais influências para C foram a família de idiomas Algol (Algol 60 e Algol 68) e BCPL (da qual C leva seu nome).

O BCPL foi a primeira linguagem de programação entre colchetes, e os colchetes sobreviveram às mudanças sintáticas e se tornaram um meio comum de denotar instruções de código fonte do programa. Na prática, em teclados limitados do dia, os programas de origem costumavam usar as seqüências $ (e $) no lugar dos símbolos {e}. Os comentários de linha única '//' do BCPL, que não foram utilizados em C, reapareceram em C ++ e, posteriormente, em C99.

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

O BCPL introduziu e implementou várias inovações que se tornaram elementos bastante comuns no design de idiomas posteriores. Portanto, foi a primeira linguagem de programação entre parênteses (uma usando {} como delimitadores de bloco) e foi a primeira linguagem a usar // para marcar comentários embutidos.

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

Dentro da BCPL, geralmente se vê chaves, mas nem sempre. Essa era uma limitação dos teclados da época. Os caracteres $(e $)eram lexicograficamente equivalentes a {e }. Dígrafos e trigramas foram mantidos em C (embora um conjunto diferente para substituição de chaves - ??<e ??>).

O uso de chaves foi mais refinado em B (que precedeu C).

Da referência dos usuários ao B de Ken Thompson:

/* 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');
}

Há indicações de que os aparelhos foram usados ​​como mão curta para begine enddentro de Algol.

Lembro que você também os incluiu no código do cartão de 256 caracteres que você publicou no CACM, porque achei interessante que você propusesse que eles pudessem ser usados ​​no lugar das palavras-chave 'begin' e 'end' do Algol, o que é exatamente como eles foram usados ​​mais tarde na linguagem C.

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

O uso de colchetes (como uma substituição sugerida na pergunta) remonta ainda mais. Como mencionado, a família Algol influenciou C. No Algol 60 e 68 (C foi escrito em 1972 e BCPL em 1966), o colchete foi usado para designar um índice em uma matriz ou matriz.

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

Como os programadores já estavam familiarizados com colchetes para matrizes em Algol e BCPL e chaves para blocos em BCPL, havia pouca necessidade ou desejo de mudar isso ao criar outro idioma.

A pergunta atualizada inclui um adendo de produtividade para o uso de chaves e menciona python. Existem alguns outros recursos que fazem este estudo, embora a resposta se refira a "É anedótico e o que você está acostumado é com o que é mais produtivo". Devido às habilidades amplamente variadas em programação e familiaridade com diferentes idiomas, elas se tornam difíceis de explicar.

Veja também: Estouro de pilha Existem estudos estatísticos que indicam que o Python é "mais produtivo"?

Muitos dos ganhos dependeriam do IDE (ou falta de) usado. Nos editores baseados em vi, colocar o cursor sobre uma abertura / fechamento correspondente e pressionar pressionará %o cursor para o outro caractere correspondente. Isso é muito eficiente nos idiomas baseados em C nos velhos tempos - menos agora.

Uma melhor comparação seria entre {}e begin/ endquais eram as opções do dia (o espaço horizontal era precioso). Muitas línguas Wirth foram baseadas em um begine endestilo (Algol (mencionados acima), pascal (muitos estão familiarizados com), ea família Modula).

Tenho dificuldade em encontrar alguém que isole esse recurso específico de idioma - na melhor das hipóteses, posso mostrar que os idiomas entre chaves são muito mais populares do que os idiomas finais e é uma construção comum. Conforme mencionado no link de Bob Bemer acima, a chave foi usada para facilitar a programação como taquigrafia.

De Por Pascal não é minha linguagem de programação favorita

Os programadores C e Ratfor consideram 'início' e 'final' volumosos em comparação com {e}.

O que é tudo o que pode ser dito - sua familiaridade e preferência.

Colchetes []são mais fáceis de escrever, desde IBM 2741 terminal que foi "amplamente utilizado em Multics" OS, que por sua vez tinha Dennis Ritchie, um dos criadores da linguagem C como membro da equipe dev .

^{Observe a ausência de chaves no layout do IBM 2741!}

Em C, chaves entre colchetes são "tiradas", pois são usadas para matrizes e ponteiros . Se os projetistas de linguagem esperassem que matrizes e ponteiros fossem mais importantes / usados ​​com mais freqüência do que blocos de código (o que soa como uma suposição razoável ao seu lado, mais no contexto histórico do estilo de codificação abaixo), isso significaria que chaves entre chaves seriam "menos importantes" "sintaxe.

A importância das matrizes é bastante aparente no artigo O desenvolvimento da linguagem C de Ritchie. Existe até uma suposição explicitamente declarada de "prevalência de indicadores em programas C" .

... nova linguagem retinha uma explicação coerente e viável (se não usual) da semântica de matrizes ... Duas idéias são as mais características de C entre os idiomas de sua classe: a relação entre matrizes e ponteiros ... A outra característica de C, seu tratamento de matrizes ... tem virtudes reais . Embora a relação entre ponteiros e matrizes seja incomum, ela pode ser aprendida. Além disso, a linguagem mostra um poder considerável para descrever conceitos importantes, por exemplo, vetores cuja duração varia em tempo de execução, com apenas algumas regras e convenções básicas ...

Para uma melhor compreensão do contexto histórico e do estilo de codificação da época em que a linguagem C foi criada, é necessário levar em consideração que "a origem de C está intimamente ligada ao desenvolvimento do Unix" e, especificamente, que portar o SO para um PDP- 11 "levou ao desenvolvimento de uma versão inicial do C" ( fonte de citações ). Segundo a Wikipedia , "em 1972, o Unix foi reescrito na linguagem de programação C" .

O código fonte de várias versões antigas do Unix está disponível online, por exemplo, no site da árvore Unix . Das várias versões apresentadas lá, a mais relevante parece ser a Segunda Edição Unix, datada de 1972-06:

A segunda edição do Unix foi desenvolvida para o PDP-11 no Bell Labs por Ken Thompson, Dennis Ritchie e outros. Ele estendeu a Primeira Edição com mais chamadas do sistema e mais comandos. Esta edição também viu o início da linguagem C, que foi usada para escrever alguns dos comandos ...

Você pode procurar e estudar o código fonte C na página Second Edition Unix (V2) para ter uma idéia do estilo de codificação típico da época.

Um exemplo proeminente que apóia a idéia de que naquela época era bastante importante que o programador pudesse digitar colchetes com facilidade pode ser encontrado no código-fonte 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;

É interessante observar como a motivação pragmática de escolher caracteres para denotar elementos de sintaxe da linguagem com base em seu uso em aplicações práticas direcionadas se assemelha à Lei de Zipf, conforme explicado nesta resposta fantástica ...

A relação observada entre frequência e duração é chamada Lei de Zipf

... com a única diferença de que o comprimento na instrução acima é substituído por / generalizado como velocidade de digitação.

C (e subsequentemente C ++ e C #) herdou seu estilo de suporte do antecessor B , que foi escrito por Ken Thompson (com contribuições de Dennis Ritchie) em 1969.

Este exemplo é da referência dos usuários a B de Ken Thompson (via Wikipedia ):

/* 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');
}

O próprio B foi novamente baseado no BCPL , uma linguagem escrita por Martin Richards em 1966 para o sistema operacional Multics. O sistema de órtese de B usava apenas chavetas, modificadas por caracteres adicionais (exemplo de fatorial de impressão de Martin Richards, via Wikipedia ):

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)

Os chavetas usadas em B e nos idiomas subsequentes "{...}" são uma melhoria que Ken Thompson fez sobre o estilo de chaveta composto original em BCPL "$ (...) $".