“Não digitado” também significa “digitado dinamicamente” no mundo acadêmico da SC?

Estou lendo um slide deck que declara "JavaScript não digitado". Isso contradiz o que eu pensava ser verdade, então comecei a cavar para tentar aprender mais.

Todas as respostas para o JavaScript são uma linguagem não tipada? afirma que o JavaScript não é digitado e ofereceu exemplos de várias formas de digitação estática, dinâmica, forte e fraca com as quais estou familiarizado e feliz. Portanto, esse não era o caminho a seguir.

Então eu perguntei a Brendan Eich, o criador do JavaScript, e ele disse:

tipos acadêmicos usam "sem tipo" para significar "sem tipos estáticos". eles são inteligentes o suficiente para ver que os valores têm tipos (duh!). contexto importa.

O pessoal da ciência da computação com foco acadêmico usa "não digitado" como sinônimo de "digitado dinamicamente" (e isso é válido?) Ou há algo mais profundo nisso que estou perdendo? Concordo com Brendan que o contexto é importante, mas quaisquer citações de explicações seriam ótimas, pois meus livros atuais de "ir para" não estão jogando bola nesse tópico.

Quero esclarecer isso para melhorar minha compreensão e porque mesmo a Wikipedia não se refere a esse uso alternativo (que eu posso encontrar de qualquer maneira). Não quero estragar o uso do termo nem questionar o uso do termo no futuro, se estiver errado :-)

(Também vi um Smalltalker de primeira linha dizer que o Smalltalk também está "sem tipo", por isso não é um caso único, o que me motivou nessa missão! :-))

Sim, essa é uma prática padrão na literatura acadêmica. Para entendê-lo, ajuda saber que a noção de "tipo" foi inventada na década de 1930, no contexto do cálculo lambda (de fato, ainda mais cedo, no contexto da teoria dos conjuntos). Desde então, surgiu um ramo inteiro da lógica computacional, conhecido como "teoria dos tipos". A teoria da linguagem de programação é baseada nesses fundamentos. E em todos esses contextos matemáticos, "tipo" tem um significado particular e bem estabelecido.

A terminologia "digitação dinâmica" foi inventada muito mais tarde - e é uma contradição em termos diante do uso matemático comum da palavra "tipo".

Por exemplo, aqui está a definição de "sistema de tipos" que Benjamin Pierce usa em seu livro-texto padrão Tipos e linguagens de programação :

Um sistema de tipos é um método sintático tratável para provar a ausência de certos comportamentos do programa, classificando frases de acordo com os tipos de valores que eles calculam.

Ele também observa:

A palavra “estático” é algumas vezes adicionada explicitamente - falamos de uma “linguagem de programação com tipo estatístico”, por exemplo - para distinguir os tipos de análises em tempo de compilação que estamos considerando aqui da digitação dinâmica ou latente encontrada em linguagens como Scheme (Sussman e Steele, 1975; Kelsey, Clinger e Rees, 1998; Dybvig, 1996), onde tags de tipo de tempo de execução são usadas para distinguir diferentes tipos de estruturas na pilha. Termos como "digitado dinamicamente" são indiscutivelmente equivocados e provavelmente devem ser substituídos por "dinamicamente verificados", mas o uso é padrão.

A maioria das pessoas que trabalha no campo parece compartilhar esse ponto de vista.

Observe que isso não significa que "não digitado" e "digitado dinamicamente" são sinônimos. Pelo contrário, que o último é um nome (tecnicamente enganoso) para um caso particular do primeiro.

PS: E no FWIW, sou um pesquisador acadêmico em sistemas de tipos e um implementador não-acadêmico de JavaScript, então tenho que conviver com o cisma. :)

Eu sou um cientista da computação acadêmico especializado em linguagens de programação e, sim, a palavra "não digitado" é frequentemente (mal) usada dessa maneira. Seria bom reservar a palavra para uso em idiomas que não carregam tags de tipo dinâmico, como Forth e código de assembly, mas esses idiomas raramente são usados ​​e ainda mais raramente estudados, e é muito mais fácil dizer "não digitado" do que "digitado dinamicamente".

Bob Harper gosta de dizer que idiomas como Scheme, Javascript etc. devem ser considerados idiomas de tipo com apenas um único tipo: value. Eu me inclino a essa visão, pois torna possível construir uma visão de mundo consistente usando apenas um tipo de formalismo.

PS No cálculo lambda puro, os únicos "valores" são termos na forma normal e os únicos termos fechados na forma normal são funções. Mas a maioria dos cientistas que usam o cálculo lambda adiciona tipos de base e constantes e, em seguida, você inclui um sistema de tipos estático para lambda ou volta às tags de tipo dinâmico.

PPS Para o pôster original: quando se trata de linguagens de programação e, especialmente, de sistemas de tipos, as informações na Wikipedia são de baixa qualidade. Não confie nisto.

Analisei o assunto e descobri que a resposta para sua pergunta é simples e surpreendentemente "sim": os tipos acadêmicos de CS, ou pelo menos alguns deles, usam "untyped" para significar "digitado dinamicamente". Por exemplo, Linguagens de Programação: Princípios e Práticas , Terceira Edição (por Kenneth C. Louden e Kenneth A. Lambert, publicado em 2012) diz o seguinte:

Os idiomas sem sistemas de tipo estático são geralmente chamados de idiomas não tipados (ou idiomas tipados dinamicamente ). Essas linguagens incluem Scheme e outros dialetos do Lisp, Smalltalk e a maioria das linguagens de script, como Perl, Python e Ruby. Observe, no entanto, que uma linguagem não digitada não permite necessariamente que os programas corrompam dados - isso significa apenas que todas as verificações de segurança são realizadas no tempo de execução. [...]

[ link ] (nota: em negrito no original) e continua a usar "untyped" dessa maneira.

Acho isso surpreendente (pelas mesmas razões que afrischke e Adam Mihalcin dão), mas aí está. :-)

Editado para adicionar: você pode encontrar mais exemplos conectando "untyped languages"a Pesquisa de Livros do Google. Por exemplo:

[…] Este é o principal mecanismo de ocultação de informações e muitas linguagens não tipadas. Por exemplo, o esquema PLT [4] usa structs generativos , […]

- Jacob Matthews e Amal Ahmed, 2008 [ link ]

[…], Apresentamos uma análise de tempo de encadernação para uma linguagem funcional não tipada […]. […] Foi implementado e é usado em um avaliador parcial para um dialeto livre de efeito colateral do Esquema. A análise é suficientemente geral, no entanto, para ser válida para linguagens funcionais de tipo não estrito, como Haskell. [...]

- Charles Consel, 1990 [ link ]

A propósito, minha impressão, depois de analisar esses resultados de pesquisa, é que, se um pesquisador escreve sobre uma (s) linguagem (s) funcional (s) não digitada (s), ele provavelmente considera que ela é "não digitada" no mesmo sentido que o lambda não digitado cálculo que Adam Mihalcin menciona. Pelo menos, vários pesquisadores mencionam Scheme e o cálculo lambda na mesma respiração.

O que a pesquisa não diz, é claro, é se há pesquisadores que rejeitam essa identificação e não consideram esses idiomas "não digitados". Bem, eu encontrei isso:

Percebi então que realmente não há circularidade, porque as linguagens dinamicamente tipadas não são linguagens não tipadas - é apenas que os tipos não costumam ser imediatamente óbvios no texto do programa.

- alguém (não sei quem), 1998 [ link ]

mas, obviamente, a maioria das pessoas que rejeita essa identificação não sentiria a necessidade de dizê-lo explicitamente.

Não digitados e digitados dinamicamente não são absolutamente sinônimos. A linguagem que é mais frequentemente chamada "não digitada" é o Cálculo Lambda, que na verdade é uma linguagem unificada - tudo é uma função, para que possamos provar estaticamente que o tipo de tudo é a função. Uma linguagem digitada dinamicamente possui vários tipos, mas não adiciona uma maneira de o compilador os verificar estaticamente, forçando o compilador a inserir verificações de tempo de execução nos tipos de variáveis.

Em seguida, o JavaScript é uma linguagem de tipo dinâmico: é possível escrever programas em JavaScript, de modo que alguma variável xpossa ser um número, uma função, uma string ou qualquer outra coisa (e determinar qual deles exigiria a solução do Problema de Parada ou alguma problema matemático difícil), para que você possa aplicar xa um argumento e o navegador precisar verificar, em tempo de execução, se essa xé uma função.

Ambas as instruções estão corretas, dependendo se você está falando sobre valores ou variáveis. As variáveis ​​JavaScript não são tipadas, os valores JavaScript têm tipos e as variáveis ​​podem variar sobre qualquer tipo de valor em tempo de execução (ou seja, 'dinamicamente').

No JavaScript e em muitos outros idiomas, valores e não variáveis ​​carregam tipos. Todas as variáveis ​​podem abranger todos os tipos de valores e podem ser consideradas "digitadas dinamicamente" ou "não tipadas" - da perspectiva da verificação de tipo, uma variável que não possui um tipo desconhecido / desconhecido e uma variável que pode assumir qualquer tipo é lógica e praticamente equivalente . Quando os teóricos do tipo falam sobre idiomas e tipos, geralmente estão falando sobre isso - variáveis ​​que carregam tipos - porque estão interessados ​​em escrever verificadores e compiladores de tipos e assim por diante, que operam no texto do programa (ou seja, variáveis) e não em um programa em execução na memória (ou seja, valores).

Por outro lado, em outros idiomas, como C, as variáveis ​​carregam tipos, mas os valores não. Em linguagens como Java, variáveis ​​e valores carregam tipos. No C ++, alguns valores (aqueles com funções virtuais) carregam tipos e outros não. Em alguns idiomas, é até possível que os valores alterem os tipos, embora isso geralmente seja considerado um design ruim.

Esta questão é sobre semântica

Se eu fornecer esses dados: 12qual é o seu tipo? Você não tem como saber com certeza. Pode ser um número inteiro - pode ser um ponto flutuante - pode ser uma sequência. Nesse sentido, são muitos dados "não digitados".

Se eu fornecer uma linguagem imaginária que permita usar operadores como "adicionar", "subtrair" e "concatenar" nesses dados e em alguns outros dados arbitrários, o "tipo" é um tanto irrelevante (para a minha linguagem imaginária) (exemplo : talvez add(12, a)rendimentos 109que é 12mais o valor ASCII a).

Vamos conversar C por um segundo. C praticamente permite que você faça o que quiser com qualquer dado arbitrário. Se você estiver usando uma função que leva dois uints - você pode converter e transmitir o que quiser - e os valores serão simplesmente interpretados como uints. Nesse sentido, C é "não digitado" (se você o tratar dessa maneira).

No entanto - e chegando ao ponto de Brendan - se eu lhe disser que "Minha idade é 12" - então 12tem um tipo - pelo menos sabemos que é numérico. Com o contexto, tudo tem um tipo - independentemente da linguagem.

É por isso que eu disse no começo - sua pergunta é de semântica. Qual é o significado de "não digitado"? Acho que Brendan bateu na cabeça quando disse "sem tipos estáticos" - porque é tudo o que isso pode significar. Os seres humanos naturalmente classificam as coisas em tipos. Nós sabemos intuitivamente que há algo fundamentalmente diferente entre um carro e um macaco - sem nunca ter sido ensinado a fazer essas distinções.

Voltando ao meu exemplo no começo - um idioma que "não se preocupa com tipos" (por si só) pode permitir que você "adicione" uma "idade" e um "nome" sem produzir um erro de sintaxe ... mas isso não significa que é uma operação lógica.

Javascript pode permitir que você faça todo tipo de coisa maluca sem considerá-las "erros". Isso não significa que o que você está fazendo é logicamente correto. Isso é para o desenvolvedor dar certo.

Um sistema / idioma que não impõe a segurança de tipo no tempo de compilação / construção / interpretação é "não digitado" ou "digitado dinamicamente"?

Semântica.

EDITAR

Eu queria adicionar algo aqui, porque algumas pessoas parecem estar se envolvendo com "sim, mas o Javascript tem alguns" tipos "".

No meu comentário sobre a resposta de outra pessoa, eu disse:

Em Javascript, eu poderia ter objetos criados para serem "Macacos" e objetos criados para serem "Humanos" e algumas funções poderiam ser projetadas para operar apenas em "Humanos", outras em apenas "Macacos" e outros ainda apenas em "Things With Arms". Se a linguagem já foi informada ou não de que existe uma categoria de objetos como "coisas com armas" é tão irrelevante para montagem ("sem tipo") quanto para Javascript ("dinâmica"). É tudo uma questão de integridade lógica - e o único erro seria usar algo que não tivesse armas com esse método.

Portanto, se você considera que o Javascript possui alguma "noção de tipos" internamente - e, portanto, "tipos dinâmicos" - e acha que isso é "distintamente diferente de um sistema não digitado" - você deve ver no exemplo acima que qualquer "noção de tipos "internamente é realmente irrelevante.

Para executar a mesma operação com C #, por exemplo, eu precisaria de uma interface chamada ICreatureWithArmsou algo semelhante. Não é assim em Javascript - não é em C ou ASM.

Claramente, se o Javascript tem ou não conhecimento de "tipos" é irrelevante.

Embora seja verdade que a maioria dos pesquisadores de CS que escrevem sobre tipos considere essencialmente apenas idiomas com tipos sintaticamente derivados como idiomas digitados, há muito mais de nós usando linguagens dinamicamente / latentes que se ofendem com esse uso.

Considero que existem 3 tipos [SIC] de idiomas:

Sem tipo - apenas o operador determina a interpretação do valor - e geralmente funciona em qualquer coisa. Exemplos: Assembler, BCPL

Tipicamente estaticamente - expressões / variáveis ​​têm tipos associados a elas, e esse tipo determina a interpretação / validade do operador em tempo de compilação. Exemplos: C, Java, C ++, ML, Haskell

Digitados dinamicamente - os valores têm tipos associados a eles, e esse tipo determina a interpretação / validade do operador no tempo de execução. Exemplos: LISP, Esquema, Smalltalk, Ruby, Python, Javascript

Que eu saiba, todas as linguagens dinamicamente digitadas são seguras quanto ao tipo - ou seja, apenas operadores válidos podem operar com valores. Mas o mesmo não se aplica à linguagem de tipo estaticamente. Dependendo da potência do sistema de tipos usado, alguns operadores podem ser verificados apenas no tempo de execução, ou de modo algum. Por exemplo, a maioria das linguagens de tipo estaticamente não manipula o excesso de número inteiro adequadamente (a adição de 2 números inteiros positivos pode produzir um número inteiro negativo) e as referências de matriz fora do limite não são verificadas (C, C ++) ou são verificadas apenas em tempo de execução. Além disso, alguns sistemas de tipos são tão fracos que a programação útil requer hachuras de escape (conversão em C e família) para alterar o tipo de expressões em tempo de compilação.

Tudo isso leva a afirmações absurdas, como a de que o C ++ é mais seguro que o Python porque é (tipicamente estatístico), enquanto a verdade é que o Python é intrinsecamente seguro enquanto você pode se livrar com o C ++.

Eu não sou um cientista da computação, mas ficaria surpreso se "não digitado" fosse realmente usado como sinônimo de "digitado dinamicamente" na comunidade de CS (pelo menos em publicações científicas), pois esses dois termos descrevem conceitos diferentes. Uma linguagem digitada dinamicamente tem uma noção de tipos e aplica as restrições de tipo em tempo de execução (você não pode, por exemplo, dividir um número inteiro por uma string no Lisp sem obter um erro), enquanto uma linguagem não digitada não tem noção de tipos em tudo (por exemplo, montador). Até o artigo da Wikipedia sobre linguagens de programação (http://en.m.wikipedia.org/wiki/Programming_language#Typed_versus_untyped_languages) faz essa distinção.

Atualização: Talvez a confusão venha do fato de que alguns textos dizem algo na medida em que "variáveis ​​não são digitadas" em Javascript (o que é verdade). Mas isso não significa automaticamente que o idioma está sem tipo (o que seria falso).

Concordo com Brendan - o contexto é tudo.

Minha vez:

Lembro-me de estar confuso, por volta de 2004, porque houve discussões sobre se o Ruby foi digitado ou digitado dinamicamente. As pessoas C / C ++ da velha escola (das quais eu era uma) estavam pensando no compilador e dizendo que Ruby não era digitado.

Lembre-se, em C, não há tipos de tempo de execução, existem apenas endereços e se o código que está executando decide tratar o que estiver nesse endereço como algo que não é, gritos. Definitivamente sem tipo e muito diferente do tipo dinamicamente.

Nesse mundo, "digitar" é tudo sobre o compilador. O C ++ teve "digitação forte" porque as verificações do compilador eram mais rigorosas. Java e C foram mais "fracamente tipados" (havia até argumentos sobre se Java era tipicamente forte ou fracamente). As linguagens dinâmicas foram, nesse continuum, "não tipadas" porque não tinham verificação de tipo de compilador.

Hoje, para praticantes programadores, estamos tão acostumados a linguagens dinâmicas que, obviamente, pensamos que não tipado significa sem verificação de tipo de compilador ou intérprete, o que seria incrivelmente difícil de depurar. Mas houve um período em que isso não era óbvio e, no mundo mais teórico da CS, pode até não ser significativo.

Em um sentido profundo, nada pode ser digitado (ou quase nada, de qualquer maneira), porque você deve ter alguma intenção de manipular um valor para escrever um algoritmo significativo. Este é o mundo do CS teórico, que não trata das especificidades de como um compilador ou intérprete é implementado para um determinado idioma. Portanto, "não digitado" é (provavelmente, não sei) totalmente sem sentido nesse contexto.