Tiny BASIC - Tiny BASIC

Tiny BASIC
Projetado por Dennis Allison
Apareceu pela primeira vez 1975
Linguagem de implementação IL (linguagem interpretativa)
Licença Domínio público
Dialetos
Denver Tiny BASIC, Enhanced 6800 Tiny BASIC, MINOL, National Industrial Basic Language, Palo Alto Tiny BASIC, 6800 Tiny BASIC, TBI68K, Tiny BASIC Extended
Influenciado por
Dartmouth BASIC , 8008 BASIC
Influenciado
Astro BASIC , Atari BASIC , Nível I BASIC

Tiny BASIC é uma família de dialetos da linguagem de programação BASIC que pode caber em 4 ou menos KBs de memória . O Tiny BASIC foi projetado em resposta à carta aberta publicada por Bill Gates reclamando sobre os usuários pirateando o Altair BASIC , que foi vendido por US $ 150. O Tiny BASIC foi criado para ser uma versão totalmente gratuita do BASIC que rodaria nos mesmos microcomputadores anteriores .

Tiny BASIC foi lançado como uma especificação, não uma implementação, publicada na edição de setembro de 1975 do boletim informativo People's Computer Company (PCC). O artigo convidava os programadores a implementá-lo em suas máquinas e enviar a implementação da linguagem assembler resultante de volta para inclusão em uma série de três boletins informativos planejados. Dr. Li-Chen Wang , autor de Palo Alto Tiny BASIC, cunhou o termo " copyleft " para descrever este conceito. A resposta da comunidade foi tão impressionante que o boletim foi relançado como Dr. Dobb's Journal , o primeiro periódico regular a se concentrar em software de microcomputador. O Dr. Dobb durou 34 anos na forma impressa e depois online até 2014.

O tamanho pequeno e o código-fonte livre tornaram essas implementações inestimáveis ​​nos primeiros dias dos microcomputadores em meados da década de 1970, quando a RAM era cara e o tamanho de memória típico era de apenas 4 a 8 KB. Enquanto a versão mínima do Altair BASIC da Microsoft também rodava em máquinas de 4 KB, ele deixava apenas 790 bytes livres para programas BASIC. Mais espaço livre foi uma vantagem significativa do Tiny BASIC. Para atender a esses limites estritos de tamanho, os dialetos do Tiny BASIC geralmente careciam de uma variedade de recursos comumente encontrados em outros dialetos, por exemplo, a maioria das versões carecia de variáveis ​​de string , carecia de matemática de ponto flutuante e permitia apenas nomes de variáveis ​​de uma única letra.

As implementações do Tiny BASIC ainda são usadas hoje, para programar microcontroladores como o Arduino .

História

Altair BASIC

Uma fita de papel contendo a versão expandida 8k do Micro-Soft BASIC.

Os primeiros microcomputadores , como o MITS Altair 8800 , geralmente não tinham entrada / saída (E / S) embutida além dos interruptores do painel frontal e lâmpadas LED . O trabalho útil geralmente exigia a adição de uma placa de expansão de E / S e o uso de algum tipo de terminal . Na época, os terminais baseados em vídeo eram muito caros, muito mais do que o próprio computador, então muitos usuários optaram por dispositivos mecânicos como o Teletype Model 33 . O Modelo 33, como a maioria dos teleimpressores da época, incluía um sistema de fita perfurada que permitia aos operadores pré-gravar suas mensagens e reproduzi-las em "alta velocidade", mais rápido do que digitar a mensagem ao vivo. Para os primeiros microcomputadores, isso fornecia um formato de armazenamento de computador conveniente , permitindo aos usuários escrever programas em fita de papel e distribuí-los para outros usuários.

O Homebrew Computer Club se reuniu pela primeira vez em março de 1975, e seus membros logo usaram as reuniões para trocar software em fita adesiva. Na reunião de junho, uma fita contendo uma versão de pré-lançamento do Altair BASIC desapareceu. A fita foi entregue a Steve Dompier, que a passou para Dan Sokol, que teve acesso a um furador de fita de alta velocidade. Na reunião seguinte, 50 cópias do Altair BASIC em fita de papel apareceram em uma caixa de papelão. Quando Ed Roberts , fundador do MITS, soube disso, ele declarou: "Qualquer pessoa que estiver usando uma cópia roubada do MITS BASIC deve se identificar pelo que é, um ladrão." Bill Gates tornou isso mais formal, escrevendo uma carta aberta aos amadores , reclamando que "Como a maioria dos amadores deve estar ciente, a maioria de vocês rouba seu software."

Tiny BASIC

A reclamação não foi bem recebida. Entre as muitas respostas, Bob Albrecht, outro membro do Homebrew e fundador da People's Computer Company (PCC), sentiu que a melhor resposta seria produzir seu próprio BASIC que fosse totalmente gratuito para qualquer pessoa. Ele abordou Dennis Allison , um membro do corpo docente de Ciência da Computação da Universidade de Stanford , para escrever uma especificação para uma versão do BASIC que caberia em 2 a 3 kilobytes de memória. Para ajudar na portabilidade , o design foi baseado em uma linguagem intermediária (IL), um intérprete para o intérprete, o que significa que apenas uma pequena parte do código total teve que ser portada.

O design inicial de Allison foi publicado na edição de setembro de 1975 do boletim informativo PCC, junto com uma versão Intel 8080 do interpretador IL. O artigo pediu aos programadores que implementassem o design em seus computadores e enviassem a versão resultante da linguagem assembler de volta ao PCC. Eles declararam seus planos de publicar três newsletters especiais contendo essas versões enviadas pelo usuário, junto com correções de bugs, programas escritos no novo BASIC e sugestões e melhorias. O conceito ganhou mais atenção quando foi republicado na edição de janeiro de 1976 do ACM Special Interest Group on Programming Languages. As inscrições choveram. Entre as primeiras versões notáveis ​​estava o Tiny BASIC Extended de Dick Whipple e John Arnold, que rodou em 3K de RAM, adicionou FOR ... NXT loops e permitiu uma única matriz numérica. Eles evitaram o uso do IL e escreveram diretamente em código de máquina, usando octal .

O primeiro dos três boletins planejados, com o título "Dr. Dobb's Journal of Computer Calisthenics & Orthodontia, Running Light Without Overbyte", foi publicado em janeiro de 1976. Começa com uma nota de Albrecht, sob o pseudônimo de "o dragão", sugerindo que três edições não seriam suficientes e perguntando aos leitores se gostariam de ver continuação. Ele também reimprimiu o artigo original sobre Tiny BASIC do PCC, incluiu a lista completa de Extended TB e incluiu uma série de pequenos programas BASIC, incluindo dicas e truques de Allison. A resposta ao primeiro número foi tão impressionante que a introdução ao segundo número indicava que eles já haviam decidido continuar a publicar o novo boletim informativo com o nome simplificado do Dr. Dobb's Journal . Nas várias edições seguintes, versões adicionais da linguagem foram publicadas e artigos semelhantes começaram a aparecer em outras revistas como Interface Age .

Espalhar

A fonte monoespaçada diz "Tiny basic for Intel 8080, versão 2.0 por Li-Chen Wang, modificado e traduzido para Intel mnemônicos por Roger Rausklob, 10 de outubro de 1976. @ Copyleft, All Wrongs Reserved."
O uso de "Copyleft; All Wrongs Reserved" em 1976

Em meados de 1976, os intérpretes Tiny BASIC estavam disponíveis para os processadores Intel 8080 , Motorola 6800 e MOS Technology 6502 . Este foi um precursor do desenvolvimento colaborativo da comunidade do software livre antes que a internet permitisse uma transferência fácil de arquivos e foi um exemplo de projeto de software livre antes do movimento do software livre . Os entusiastas do computador trocavam fitas de papel, cassetes ou até redigitavam os arquivos das listagens impressas.

Jim Warren, editor do Dr. Dobb's , escreveu no boletim ACM Programming Language de julho de 1976 sobre as motivações e métodos desse projeto bem-sucedido. Ele começou assim: "Há uma alternativa viável para os problemas levantados por Bill Gates em sua carta irada aos entusiastas da informática sobre 'roubo' de software. Quando o software é gratuito, ou tão barato que é mais fácil pagar por ele do que duplicar então não será 'roubado'. " A carta de Bill Gates foi escrita para transformar software em produtos . O método alternativo era ter um profissional experiente para fazer o design geral e, em seguida, delinear uma estratégia de implementação. Amadores experientes implementariam o projeto para uma variedade de sistemas de computador. Warren previu que essa estratégia seria continuada e expandida.

A edição de maio de 1976 do Dr. Dobbs tinha o Palo Alto Tiny BASIC de Li-Chen Wang para o 8080. A lista começava com o título usual, o nome do autor e a data, mas também tinha "@COPYLEFT ALL WRONGS RESERVED". Um colega do Homebrew Computer Club , Roger Rauskolb, modificou e melhorou o programa de Li-Chen Wang e isso foi publicado na edição de dezembro de 1976 da revista Interface Age . Roger adicionou seu nome e preservou o aviso de COPYLEFT.

Descrição

Conceitos Básicos

Veja intérpretes BASIC

O Tiny BASIC foi projetado para usar o mínimo de memória possível, e isso se reflete na escassez de recursos, bem como nos detalhes de seu sistema de intérprete . Os primeiros microcomputadores não tinham RAM e armazenamento secundário para um compilador BASIC , o que era mais típico de sistemas de compartilhamento de tempo.

Como a maioria dos BASICs da época, o Tiny Basic era interativo com o usuário digitando instruções em uma linha de comando. Como os microcomputadores da época eram frequentemente usados ​​com máquinas de teletipo ou terminais "burros", a edição direta do texto existente não era possível e o editor, em vez disso, usava caracteres para viagem, geralmente a barra invertida, para indicar onde o usuário fez backup para editar o texto existente.

Se o usuário digitou uma instrução na linha de comando, o sistema a examinou para ver se começava com um número. Caso contrário, a linha era imediatamente analisada e operada, potencialmente gerando saída via PRINT. Isso era conhecido como "modo direto".

Se a linha foi inserida com um número à esquerda, o número foi convertido do formato decimal, como "50", e convertido para um valor de 8 bits, neste caso, $ 32 hexadecimal . Esse número foi usado como um índice em uma área de armazenamento semelhante a um array , onde o resto da linha foi armazenado exatamente no formato em que foi digitado. Quando o usuário digitava LISTna linha de comando, o sistema fazia um loop sobre a matriz, convertia o número da linha de volta para o formato decimal e, a seguir, imprimia o restante do texto na linha.

Quando um programa estava presente na memória e o usuário digita o RUNcomando, o sistema entra no "modo indireto". Neste modo, um ponteiro é definido para apontar para a primeira linha do programa, por exemplo, 10 ($ 0A hex). O texto original dessa linha é então recuperado da loja e executado como se o usuário tivesse acabado de digitá-lo no modo direto. O ponteiro então avança para a próxima linha e o processo continua.

Gramática formal

A gramática está listada abaixo na forma Backus-Naur , quase exatamente como foi especificada na Nota de Design. Na listagem, um asterisco (" * ") denota zero ou mais do objeto à sua esquerda - exceto para o primeiro asterisco na definição de " termo ", que é o operador de multiplicação; parênteses agrupam objetos; e um épsilon (" ε ") significa o conjunto vazio. Como é comum na notação gramatical da linguagem de computador, a barra vertical (" | ") distingue as alternativas, assim como elas são listadas em linhas separadas. O símbolo " CR " denota um retorno de carro (geralmente gerado pela tecla "Enter" do teclado). Uma QUEBRA no console interromperá a execução do programa.

    line ::= number statement CR | statement CR
 
    statement ::= PRINT expr-list
                  IF expression relop expression THEN statement
                  GOTO expression
                  INPUT var-list
                  LET var = expression
                  GOSUB expression
                  RETURN
                  CLEAR
                  LIST
                  RUN
                  END
 
    expr-list ::= (string|expression) (, (string|expression) )*
 
    var-list ::= var (, var)*
 
    expression ::= (+|-|ε) term ((+|-) term)*
 
    term ::= factor ((*|/) factor)*
 
    factor ::= var | number | (expression)
 
    var ::= A | B | C ... | Y | Z
 
    number ::= digit digit*
 
    digit ::= 0 | 1 | 2 | 3 | ... | 8 | 9
 
    relop ::= < (>|=) | > (<|=) | =

    string ::= " ( |!|#|$ ... -|.|/|digit|: ... @|A|B|C ... |X|Y|Z)* "

Observe que a string não foi definida na Design Note.

Essa sintaxe, por mais simples que seja, acrescentou uma inovação: GOTOe GOSUBpodia aceitar uma expressão em vez de apenas um número de linha, fornecendo um GOTO atribuído em vez da instrução switch de GOTO/GOSUB ... OF ..., uma estrutura então suportada no HP Time-Shared BASIC e anterior ON ... GOTO. A sintaxe que permite IF-THEN statement(ao contrário de apenas um número de linha para a qual ramificar) ainda não era suportada no Dartmouth BASIC desta vez, mas foi introduzida pela Digital e copiada pela Microsoft.

Implementação em uma máquina virtual

A Design Note especificava uma máquina virtual , na qual o interpretador Tiny BASIC é executado em um interpretador de máquina virtual. A ideia do designer de usar uma máquina virtual de aplicativo remonta a Val Schorre (com META II , 1964) e Glennie (Syntax Machine). A escolha de uma abordagem de máquina virtual economizou espaço de memória e esforço de implementação, embora os programas BASIC executados nela tenham sido executados um tanto lentamente.

Os dialetos que usavam a máquina virtual incluíam Tiny BASIC Extended, Tiny BASIC de Tom Pittman e NIBL. Outros dialetos como Denver Tiny BASIC (DTB) e Palo Alto Tiny BASIC foram intérpretes diretos. Alguns programadores, como Fred Greeb com DTB, trataram o programa IL (Interpretive Language) como pseudocódigo para o algoritmo implementar em linguagem assembly; Denver Tiny BASIC não usava uma máquina virtual, mas seguia de perto o programa IL.

Este é um trecho representativo do programa IL de 120 linhas:

S1:  TST     S3,'GO'       ;GOTO OR GOSUB?
     TST     S2,'TO'       ;YES...TO, OR...SUB
     CALL    EXPR          ;GET LABEL
     DONE                  ;ERROR IF CR NOT NEXT
     XFER                  ;SET UP AND JUMP
S3:  TST     S8,'PRINT'    ;PRINT.

Um padrão comum no programa é testar uma palavra-chave ou parte de uma palavra-chave e, em seguida, agir com base nessa informação. Cada teste é uma afirmação sobre o que vem a seguir no buffer de linha. Se a asserção falhar, o controle pula para um rótulo subsequente (geralmente procurando por uma nova palavra-chave ou token). Aqui, o sistema avança o cursor do buffer sobre quaisquer espaços e testa GO e, se não conseguir encontrá-lo, salta para a linha S3 . Se o encontrar, a execução continua com o próximo comando IL. Nesse caso, o sistema testa a seguir TO , pulando para a linha S2 se ela falhar (um teste para SUB , para ver se este é um comando GOSUB ). Se passar, o controle continua; neste caso, chamando uma sub-rotina IL que começa no rótulo EXPR , que analisa uma expressão. No Tiny BASIC, GOTO X*10+100(um GO TO computado) é tão legal quanto GOTO 100e é a alternativa para o ON-GOTO de implementações BASIC maiores. A sub-rotina EXPR coloca o resultado da expressão na pilha aritmética (neste caso, o número da linha). DONE verifica se nenhum outro texto segue a expressão e dá um erro se isso acontecer. O XFER retira o número da pilha e transfere a execução (VAI PARA) o número da linha correspondente, se existir.

A tabela a seguir fornece uma lista parcial dos 32 comandos da máquina virtual em que o primeiro interpretador Tiny BASIC foi escrito.

TST lbl , string
Se a string corresponder à linha BASIC, avance o cursor sobre a string e execute a próxima instrução IL; se o teste falhar, execute a instrução IL no rótulo lbl
LIGAR lbl
Execute a sub-rotina IL começando em lbl ; salvar o endereço IL seguindo o CALL na pilha de controle
FEITO
Relate um erro de sintaxe se, após excluir os espaços em branco à esquerda, o cursor não estiver posicionado para alcançar um retorno de carro
XFER
Teste o valor no topo da pilha AE para estar dentro do intervalo. Caso contrário, relate um erro. Nesse caso, tente posicionar o cursor nessa linha. Se existir, comece a interpretação aí; caso contrário, relate um erro.
JUMP lbl
Continue a execução do IL no rótulo especificado
RTN
Retorne ao local IL especificado no topo da pilha de controle
PRS
Imprimir caracteres do texto BASIC até, mas não incluindo as aspas de fechamento
PRN
Imprimir o número obtido ao estourar o topo da pilha de expressões
SPC
Insira espaços para mover a cabeça de impressão para a próxima zona
NLINE
Envie um CRLF para a impressora

Tom Pittman, discutindo o IL, diz: "O interpretador TINY BASIC foi projetado por Dennis Allison como um analisador descendente recursivo . Parte da simplicidade elegante desse design foi perdida na adição de açúcar sintático à linguagem, mas a forma básica permanece. O IL é especialmente adequado para análise de descida recursiva de TINY BASIC devido à natureza recursiva geral de seus procedimentos e à simplicidade dos tokens TINY BASIC. A linguagem IL é efetivamente otimizada para a interpretação de TINY. A experiência mostra que a dificuldade de adicionar os novos recursos da linguagem estão fora de proporção com a natureza dos recursos. Normalmente, é necessário adicionar sub-rotinas de linguagem de máquina para oferecer suporte aos novos recursos. Freqüentemente, a dificuldade supera as vantagens. "

Desvios do design

Definindo Tiny BASIC para o Homebrew Computer Club, Pittman escreveu: "Tiny BASIC é um subconjunto apropriado do Dartmouth BASIC, consistindo apenas nos seguintes tipos de instrução: LET, PRINT, INPUT, IF, GOTO, GOSUB, RETURN, END, CLEAR, LIST , RUN. A aritmética é feita em inteiros de 16 bits apenas com os operadores + - * / e parênteses aninhados. Existem apenas os 26 nomes de variáveis ​​de uma única letra A, B, ... Z e nenhuma função. Não há strings ou matrizes ... Tiny BASIC especifica números de linha menores que 256. " Ele então descreveu sua implementação: "Esta linguagem foi aumentada para incluir as funções RND, USR e PEEK e POKE, dando ao usuário acesso a todos os componentes do sistema no 6800 a partir do programa BASIC."

Muitos implementadores trouxeram suas próprias experiências com HP Time-Shared BASIC ou DEC BASIC-PLUS para seus projetos e relaxaram a especificação formal da linguagem Tiny BASIC. Das sete implementações proeminentes publicadas em 1977:

  • Todos adicionaram algum tipo de função de número aleatório, normalmente RND () . Embora não esteja incluído na especificação, um artigo do boletim informativo anterior à Design Note for Tiny BASIC solicitou apenas esta função.
  • Todos habilitaram LET para serem opcionais e a maioria das expressões let em instruções de atribuição contêm operadores relacionais .
  • Todos, exceto 6800 TB, suportavam delimitadores de instrução em linhas, normalmente : embora TBX usasse $ e PATB usasse ; .
  • Nas instruções IF , todos, exceto MINOL, removeram a necessidade de expressões para conter operadores relacionais (por exemplo, era válido). As implementações removiam ENTÃO totalmente ou tornavam-no opcional ou suportavam apenas para GOTO implícito .IF X THEN LET Y=X
  • Muitos PRINT modificados para suportar zonas de impressão, usando ,para ir para a próxima zona e ;não avançar o cursor.
  • Todos, exceto 6800 TB e DTB adicionados NOVOS .
  • Todos, exceto 6800TB e MINOL, adicionaram uma função para retornar o tamanho da memória: TBX tinha SZE , DTB e PATB tinha SIZE , L1B tinha MEM e NIBL ​​tinha TOP .
  • Quatro implementações adicionaram matrizes, seja uma única matriz não dimensionada em PATB e L1B ou matrizes programáveis ​​por DIM em TBX e DTB.
  • Quatro implementações adicionaram a instrução REM ark.
  • Quatro implementações adicionaram o loop FOR : PATB, NIBL ​​e L1B ofereceram FOR-TO-STEP / NEXT , enquanto TBX não suportou STEPe usou a palavra NXT- chave para encerrar um loop.
  • Apenas a NIBL ​​tinha qualquer inclinação para a programação estruturada, com DO / UNTIL , apesar do lamento de Allison na edição 2 sobre problemas com o BASIC.

Como alternativa à tokenização, para salvar as palavras-chave truncadas de RAM, TBX, DTB e MINOL: PR para PRINT , IN para INPUT , RET para RETURN . As palavras-chave tradicionais completas não foram aceitas. Em contraste, PATB permitia palavras-chave tradicionais aceitas, mas também permitia que qualquer palavra-chave fosse abreviada em sua string única mínima, com um ponto final. Por exemplo, PRINT pode ser digitado P. , embora PR. e outras variações também funcionaram. Este sistema foi mantido no Nível I BASIC para o TRS-80 , que usava PATB, e também foi encontrado mais tarde no Atari BASIC e no BASIC de vários computadores de bolso da Sharp .

Dialetos

Os dialetos mais proeminentes do Tiny BASIC eram o Design Note original, Tiny BASIC Extended, Palo Alto Tiny BASIC e 6800 Tiny BASIC. No entanto, muitas outras versões do Tiny BASIC existiam.

Lista de dialetos proeminentes

O Tiny BASIC foi publicado pela primeira vez em um boletim informativo da People's Computer Company , um boletim informativo que se tornou o Dr. Dobb's Journal , uma revista de computação de longa duração. Cerca de dez versões foram publicadas na revista.

Dialetos proeminentes do Tiny BASIC (no Diário do Dr. Dobb)
Data de publicação Edição Dialeto Autor Processador Tamanho
Dezembro de 1975 1 Nota de Design Dennis Allison N / D N / D
Fevereiro de 1976 2 Tiny BASIC Extended (TBX) Dick Whipple e John Arnold 8080 2,9 K
Março de 1976 3 Denver Tiny BASIC (DTB) Fred Greeb 8080 2,75 K
Março de 1976 3 6800 Tiny BASIC (6800 TB) Tom Pittman 6800 2K
Abril de 1976 4 MINOL Eric T. Mueller 8080 1,75K
Maio de 1976 5 Palo Alto Tiny BASIC (PATB) Li-Chen Wang 8080 1,77 K
Novembro de 1976 10 Idioma Básico Industrial Nacional (NIBL) Mark Alexander e Steve Leininger SC / MP 4K
Outubro de 1980 49 6800 Tiny BASIC aprimorado Robert Hudson 6800 N / D
Fevereiro de 1985 100 TBI68K Gordon Brandly 68000 N / D
Janeiro de 2006 351 Retorno do Tiny BASIC Tom Pittman N / A ( C ) N / D

TBX também era conhecido como Texas Tiny BASIC.

Ambos SCELBAL e 6800 Tiny BASIC foram anunciados na revista, mas não publicaram seu código-fonte.

Palo Alto Tiny BASIC

Palo Alto Tiny BASIC
Desenvolvedor Li Chen Wang
Apareceu pela primeira vez 1976
Licença Domínio público
Dialetos
3K Control Basic
Influenciado por
Tiny BASIC Design Note, Tiny BASIC Extended
Influenciado
Astro BASIC , Nível I BASIC , Sharp PC-1211 BASIC

Uma das versões mais populares do Tiny BASIC foi o Palo Alto Tiny BASIC, ou PATB, de Li-Chen Wang . O PATB apareceu pela primeira vez na edição de maio de 1976 do Dr. Dobbs , escrito em uma linguagem montadora personalizada com mnemônicos não padrão. Isso levou a outras portas que funcionavam com montadores convencionais no 8080. A primeira versão do interpretador ocupava 1,77 kilobytes de memória e pressupunha o uso de uma máquina de teletipo (TTY) para entrada / saída do usuário . Uma errata ao artigo original apareceu na edição de junho / julho do Dr. Dobb's (Vol. 1, No 6). Este artigo também incluiu informações sobre como adicionar dispositivos de E / S adicionais, usando o código para a exibição de vídeo VDM da Processor Technology como exemplo.

Wang foi um dos primeiros a usar a palavra copyleft . No aviso de distribuição do Palo Alto Tiny BASIC, ele escreveu "@COPYLEFT ALL WRONGS RESERVED". O Tiny BASIC não foi distribuído sob nenhuma forma formal de termos de distribuição copyleft, mas foi apresentado em um contexto onde o código-fonte estava sendo compartilhado e modificado. Na verdade, Wang já havia contribuído com edições para o Tiny BASIC Extended antes de escrever seu próprio intérprete. Ele encorajou outros a adaptar seu código-fonte e publicar suas adaptações, como com a versão de PATB de Roger Rauskolb publicada na Interface Age . Ele próprio publicou uma terceira versão no Livro de Referência de Computação Pessoal e Doméstica do PCC .

Uma das mudanças mais notáveis ​​no PATB é a adição do loop FOR ... NEXT . No TB original, os loops só podiam ser implementados usando IFe GOTO. Como no Microsoft BASIC , os limites superior e inferior do loop foram definidos na entrada do loop e não mudaram durante o loop, portanto, se um dos limites foi baseado em uma expressão de variável, alterar a variável não alterou o limite. O STEPmodificador era opcional, como no MS.

Outra mudança significativa foi a capacidade de colocar várias declarações em uma única linha. Por razões não explicadas, o PATB usou o ponto ;- e - vírgula para separar as declarações, em vez dos já comuns dois pontos :.

Outras alterações incluem a adição de uma única matriz numérica, com o nome da variável @, STOPalém de END, e o uso de #para não iguais em comparações, ao invés de <>.

PATB usava palavras para mensagens de erro em vez de números. Para reduzir a quantidade de memória necessária, havia apenas três mensagens e consistiam em palavras únicas. O sistema responderia com WHAT?para erros de sintaxe, HOW?para erros de tempo de execução como GOTOs para uma linha que não existia ou estouros numéricos e SORRYpara problemas de falta de memória.

Wang também escreveu um programa STARTREK em seu Tiny BASIC, que apareceu na edição de julho de 1976 do People's Computer Company Newsletter .

Mais tarde, ele adaptou a língua para 3K Controle Basic for Cromemco , acrescentando nomes de variáveis da forma de carta dígitos (por exemplo, A0a Z9), funções lógicas ( AND(), OR(), XOR()), um CALLcomando para executar rotinas linguagem de máquina, mais PRINTopções de Formatação, e outros ( GET()e em PUT()vez de PEEKe POKE; funções de porta de E / S).

Palo Alto Tiny BASIC foi adaptado para muitas outras implementações, incluindo Nível I BASIC (1977), BASIC para o computador de bolso Sharp PC-1211 (1980) e Astro BASIC (1982, por Jamie Fenton ).

MINOL

Escrito por um aluno do primeiro ano do ensino médio, o MINOL era a única implementação que não suportava o Design Note completo, sem precedência de operador , tendo apenas três relops (<, =, #), omitindo GOSUBe RETURN. Suportava apenas precisão de 8 bits sem sinal (em contraste com a precisão de 16 bits com sinal para todas as outras implementações) e números de linha de 0 a 254.

Nenhum espaço foi permitido, exceto em cordas; !retorna um número aleatório, $antes que uma expressão carregue uma string naquele endereço; OSretorna ao sistema operacional. A memória era endereçável como se fosse uma matriz bidimensional de bytes altos e baixos (por exemplo, "(0,0)" a "(255,255)"); CALLexecuta uma sub-rotina em linguagem de máquina.

Dialetos diversos

Muitos dialetos apareceram em várias outras publicações.

A edição de maio de 1977 apresentou um disquete ROM contendo MICRO-BASIC.

Inspirado pela chamada do PCC para Tiny BASICs, Robert Uiterwyk escreveu MICRO BASIC 1.3 para o SWTPC (um sistema 6800 ), que o SWTPC publicou na edição de junho de 1976 do boletim informativo SWTPC. Uiterwyk havia escrito a língua à mão em uma tabuinha legal. Mais tarde, ele expandiu a linguagem para 4K, adicionando suporte para ponto flutuante; esta implementação foi única entre os intérpretes BASIC por usar Binary Coded Decimal com 9 dígitos de precisão, com um intervalo de até 10 99 , e por ser publicada gratuitamente como um encarte de revista "Floppy ROM". Uma versão 8K adicionou variáveis ​​de string e funções de trigonometria . Ambas as versões 4K e 8K foram vendidas pela SWTPC. Em janeiro de 1978, Uiterwyk vendeu os direitos do código-fonte para a Motorola .

Thomas F. Waitman escreveu um Tiny BASIC em 1976 para os terminais Hewlett-Packard HP-2640 e HP-2645 (que usavam os processadores Intel 8008 e 8080), que foi publicado no Hewlett-Packard Journal .

Publicado na edição de dezembro de 1976 da Interface Age foi LLL ( Lawrence Livermore Laboratory ) BASIC, o primeiro rascunho do qual foi desenvolvido por Steve Leininger a partir da especificação de Allison antes de Leininger deixar a National Semiconductor pela Tandy Corporation . O intérprete final foi desenvolvido por John Dickenson, Jerry Barber e John Teeter da Universidade de Idaho em um contrato com a LLL. Tomando 5K, incluiu um pacote de ponto flutuante, desenvolvido por David Mead, Hal Brand e Frank Olken. O programa foi colocado em domínio público pela LLL, que desenvolveu o sistema sob os auspícios da Administração de Pesquisa e Desenvolvimento de Energia dos Estados Unidos.

4K BASICs

Altair BASIC , 4K BASIC, pode ser executado em uma máquina de 4kB RAM, deixando apenas cerca de 790 bytes livres para o código do programa. A iniciativa Tiny BASIC começou em resposta à cobrança de $ 150 pelo Altair 4K BASIC.

Em 1975, Steve Wozniak se juntou ao recém-formado Homebrew Computer Club , que tinha os membros Li-Chen Wang (Palo Alto Tiny BASIC) e Tom Pittman (6800 Tiny BASIC). Wozniak concluiu que sua máquina teria que ter um BASIC próprio, que seria, esperançosamente, o primeiro para o processador MOS Technology 6502 . Como a linguagem precisava de 4 kB de RAM, ele tornou essa memória o mínimo para o projeto. Integer BASIC foi publicado originalmente em Compact Cassette em 1976.

Em 1977, a Radio Shack (como era conhecida na época) lançou seu primeiro computador, o TRS-80 , um sistema Z80 com Nível I BASIC em uma ROM de 4kB. O funcionário de Tandy, Steve Leininger, escreveu o primeiro rascunho do intérprete NIBL ​​(National Industrial Basic Language) para o SC / MP enquanto trabalhava na National Semiconductor . Incapaz de levar o código-fonte com ele, ele adaptou Palo Alto Tiny BASIC de Li-Chen Wang para o protótipo original do TRS-80 Modelo I. Ele revisou extensivamente o interpretador, adicionando suporte de ponto flutuante, preto e simples gráficos brancos e READ/DATA/RESTOREdeclarações.

Originalmente desenvolvido em 1979, o Sinclair 4K BASIC , escrito por John Grant, usava como definição de linguagem o padrão Minimal BASIC do American National Standards Institute (ANSI) de 1978 , mas era uma implementação incompleta de 4Kb com aritmética inteira apenas.

Dialetos de microcontroladores

As implementações do Tiny BASIC foram adaptadas para o controle do processador e para microcontroladores como o Arduino :

  • Stephen A. Ness escreveu XYBASIC para a Mark Williams Company em 1977, uma implementação de inteiro de 4K. A linguagem era frequentemente usada para aplicativos de controle de processo.
  • Arduino BASIC - Adaptado do 68000 Tiny BASIC de Gordon Brandly, portado para C por Mike Field.
  • Tiny Basic Plus - Adaptado do Arduino BASIC de Scott Lawrence.
  • Half-Byte Tiny Basic - Adaptado do Arduino BASIC.
  • Tiny Basic no Micro: Bit - Adaptado de Palo Alto Tiny BASIC.

Implementações posteriores

Em 2002, Emmanuel Chailloux, Pascal Manoury e Bruno Pagano publicaram um Tiny BASIC (faltando GOSUB/ RETURN) em Developing Applications with Objective Caml como um exemplo de aplicativo Objective Caml .

Em 2013, Alex Yang publicou uma implementação em Python .

Em 2019, Sergey Kuznetsov publicou uma versão em Ruby .

Dialetos comparados

A tabela a seguir compara o recurso de linguagem das implementações do Tiny BASIC com outros BASICs proeminentes que os precederam.

Comparação de implementações BASIC - Tiny BASICs e outros BASICs
Data de
Publicação
Dialeto
Programador (es) Processador Modelo ENTRADA DEIXAR IMPRIMIR VAMOS PARA SE ENTÃO GOSUB RETORNA FIM CORRE LISTA CLARO NOVO REM A SEGUIR LER / DADOS / RESTAURAR Adicionado comandos BASIC Personalizações Expressões relop Funções RND Função de Memória Números de linha Delimitador de declaração Erros Precisão Aritmética Variáveis Matrizes Cordas
Outubro de
1964
DTSS Dartmouth BASIC
(versão 2)
(Alunos de Dartmouth) GE-225 Compile-and-go N / D [!] LET var = expressão PRINT lista expr {, /; /} IR PARA o número IF expressão relop expressão ENTÃO linha-número Número GOSUB RETORNA FIM CORRE LISTA - começar - NOVO [solicitações para o nome do programa] REM PARA / PARA / PASSO / SEGUINTE LEIA, DADOS PARE N / D precedência, ^ <<= => => <> INT, SIN, COS, TAN, ATN, EXP, LOG, ABS, SQR, DEF FN RND (0) 0..1 - 1 a 99999 Nenhum 22 definido 9 dígitos ± 999.999.999; Notação E de base 2 -256 a +255 (E ± 76). AZ, A0-Z9 DIM (nome de uma letra, duas dimensões); se omitido, assume-se que vai de 0 a 10; até 1.500 elementos em todas as matrizes Nenhum
Fevereiro de
1970
DEC BASIC-8
(Equipe DEC) PDP-8 Compile-and-go INPUT var-list LET var = expressão PRINT lista expr {, /; /} IR PARA o número IF expressão relop expressão [THEN / GO TO] número de linha Número GOSUB RETORNA FIM CORRE LISTA (primeiro (, último)) - NOVO [solicitações para o nome do programa] REM PARA / PARA / PASSO / SEGUINTE READ, DATA, RESTORE PARAR, ANTIGO, SALVAR, ANULAR DELETE (primeiro (, último)), Tchau precedência, ^ <<= => => <> INT, SGN, SIN, COS, TAN, ATN, EXP, LOG, ABS, SQR, DEF FN RND (0) 0..1 - 1 a 2045 Nenhum 23 definido ? ± 134.217.727; 14E-38 <N <1,7E38 AZ, AA-Z9 DIM (nome de uma letra, duas dimensões) Nenhum
Junho de
1974
UIUC BASIC
Alfred Weaver, Michael Tindall, Ronald Danielson 8008 Intérprete INPUT <variable> {, <variable>} * LET var = formula PRINT <string> / <formula> {, <string> / <formula>} * IR PARA o número IF expressão ENTÃO linha-número Número GOSUB RETORNA FIM CORRE não documentado não documentado não documentado REM PARA / PARA / PASSO / SEGUINTE - DEF FN, PARAR N / D precedência, ^ <<= => => # E OU NÃO FNA..Z, SIN, COS, LOG, SQR, EXP, ATN - - 0 a 999 Nenhum não documentado Mantissa de 4 bytes e expoente de 1 byte [pacote aritmético de ponto flutuante Datapoint 2200] não documentado AZ, A0-Z9 DIM (nome de uma letra, três dimensões) Nenhum
1975
Altair 4K BASIC
Bill Gates, Paul Allen, Monte Davidoff 8080 Intérprete INPUT ("string",) lista-var (LET) var = expressão PRINT lista expr {, /; } Número GOTO IF expressão THEN linha-número / instrução Número GOSUB RETORNA FIM CORRE LIST (início) - NOVO REM PARA / PARA / PASSO / SEGUINTE READ, DATA, RESTORE PARE - precedência <<= => => <> ABS, INT, SGN, SQR, TAB, USR RND (X) <0, novo usando X como semente; = 0, repetir; > 0, próximo - 1 a 65535 : 12 definidos Operando flutuante de 40 bits ? ? DIM (uma dimensão) Nenhum
Dezembro de
1975
Nota de Design
Dennis Allison N / D Intérprete INPUT var-list LET var = expressão PRINT expr-list Expressão GOTO IF expressão relop expressão instrução THEN Expressão GOSUB RETORNA FIM CORRE LISTA [eq. Para novo] - - - - - - precedência <<= => => <>> < Nenhum Nenhum - 1 a 255 Nenhum 8 definidos 16 bits ± 32767 AZ Nenhum Nenhum
Fevereiro de
1976
Tiny BASIC Extended
Dick Whipple e John Arnold 8080 Intérprete NO (LET) var = expressão ;} VAMOS PARA Expressão IF [sem THEN] declaração GO SUB RET FIM CORRE LST (primeiro (, último)) - NOVO - FOR-NXT (sem STEP) DTA (matriz LET) - - precedência <<= => => <>> < TB () espaços impressos RN (aleatório 0-10000) SZE 1 a 65535 $ 14 definidos 16 bits ± 32767 AZ DIM, 1 ou 2 dimensões, 255x255 máx. Nenhum
Março de
1976
Denver Tiny BASIC
Fred Greeb 8080 Intérprete NO (LET) var = expressão ;} VAMOS PARA Expressão IF [sem THEN] declaração GOSUB RET FIM CORRE LISTA (primeiro último) [eq. Para novo] - - - - FITA [SALVAR], CARREGAR CLRS [CLS] precedência <<= => => <>> < RND (0), RND (1) TAMANHO 2 a 255 : 20 definidos 16 bits ± 32767 AZ, A1 a A6 a Z6 DIM, 1 dimensão Nenhum
Março de
1976
6800 Tiny BASIC
Tom Pittman 6800 Intérprete INPUT (expressão) lista-var LET var = expressão PRINT lista expr {, /; } Expressão GOTO IF expressão relop expressão instrução THEN Expressão GOSUB RETORNA FIM CORRE LISTA (primeiro último) [eq. Para novo] - REM - - - - precedência <<= => => <>> < USR () RND () - 1 a 65535 Nenhum 53 definido 16 bits ± 32767 AZ Nenhum Nenhum
Abril de
1976
MINOL
Eric T. Mueller 8080 Intérprete NO (LET) var = expressão Lista expr de PR {;} [GOTO 0 salta para o início da instrução direta] Expressão IF expressão relop; demonstração N / D N / D FIM CORRE LISTA CLEAR [apenas variáveis] NOVO - - - - Não são permitidos espaços, exceto em strings Sem precedência de operador <= # $ [CHR $] ! [RND] - 1 a 254 : 6 definido 8 bits 0 a 255 AZ (H, L) localização da memória único char
Maio de
1976
Palo Alto Tiny BASIC
Li-Chen Wang 8080 Intérprete INPUT [(expressão) var] * (LET) var = expressão PRINT expr-list Expressão GOTO Expressão IF [sem THEN] declaração Expressão GOSUB RETORNA PARE CORRE LIST (início) - NOVO REM PARA / PARA / PASSO / SEGUINTE - PARE - precedência <<= => => # ABDÔMEN() RND () TAMANHO 1 a 32767 ; 3 definidos 16 bits ± 32767 AZ @ (1 matriz de 1 dimensão) Nenhum
Novembro de
1976
NIBL
Mark Alexander e Steve Leininger SC / MP Intérprete INPUT ($) var (LET) var = expressão PR / PRINT lista expr Expressão GOTO Declaração de expressão IF (THEN) Expressão GOSUB RETORNA FIM CORRE LIST (início) CLEAR [variáveis ​​e pilha] NOVO REM PARA / PARA / PASSO / SEGUINTE - FAZER / ATÉ Endereçamento de memória (@ [PEEK / POKE], STAT, PAGE) precedência <<= => => <> MOD (), AND, OR, NOT, RND (A, Z) PRINCIPAL 0 a 32.767 : 13 quatro caracteres definidos 16 bits ± 32767 AZ endereçamento de memória INPUT $, PRINT $, $ exp = exp
Agosto de
1977
Nível I BÁSICO
Steve Leininger Z80 Intérprete INPUT (# dígitos) [(expressão) var] * (LET) var = expressão PRINT (# dígitos) lista expr Número GOTO Expressão IF declaração THEN Número GOSUB RETORNA FIM RUN (iniciar) LIST (início) - NOVO REM PARA / PARA / PASSO / SEGUINTE READ, DATA, RESTORE PARAR, CONT, ON-GOTO / GOSUB CLOAD, CSAVE, CLS, SET, RESET, precedência <<= => => <>> < ABS (), INT (), MEM, POINT (X, Y) RND () MEM 1 a 32767 : 3 definidos 16 bits ± 32767 AZ A (1 matriz de 1 dimensão) A $, B $
Junho de
1976
MICRO BASIC 1.3
Robert Uiterwyk 6800 Intérprete INPUT var-list (LET) var = expressão PRINT lista expr {, /; } Expressão GOTO IF expressão relop expressão instrução THEN Expressão GOSUB RETORNA FIM CORRE LISTA (primeiro (, último)) - NOVO - PARA / PARA / PRÓXIMO (sem ETAPA) - ABA() - precedência <<= => => <>> < RND, SIZE RND [retorna 1-32762] SIZE (instrução que imprime bytes usados ​​e bytes livres) 1 a 65535 Nenhum 17 definidos 16 bits [BCD posterior!] ± 32767 AZ DIM (duas dimensões, tamanho máximo de 255) Nenhum
Junho de
1976
Linguagem científica ELementary
BAsic
(SCELBAL)
Mark Arnold e Nat Wadsworth 8008 Intérprete INPUT var-list (LET) var = expressão PRINT lista expr {, /; /} Número GOTO Declaração ENTÃO Número GOSUB RETORNA FIM CORRE LISTA - Coçar, arranhão] REM PARA / PARA / PASSO / SEGUINTE - SALVAR, CARREGAR UDF [USR] precedência, ^ <<= => => <> INT, SGN, ABS, SQR, CHR [utilizável apenas em PRINT], TAB RND (0) 0..1 - 1 a 999999 Nenhum 18 definido Operando de 32 bits flutuante ou ponto fixo ± 134.217.727; 14E-38 <N <1,7E38 ? DIM (nome de uma letra, uma dimensão; até 4 matrizes de até 64 entradas no total) Nenhum
Outubro de
1976
Apple I BASIC
Steve Wozniak 6502 Intérprete INPUT ("string",) lista-var (LET) var = expressão PRINT lista expr {, /; } Expressão GOTO IF expressão relop expressão THEN número de linha / instrução Expressão GOSUB RETORNA FIM RUN (iniciar) LISTA (primeiro (, último)) - SCR REM PARA / PARA / PASSO / SEGUINTE - AUTO, DEL, POKE TAB (comando), CALL precedência <<= => => <> # E OU NÃO MOD SGN, ABS, PEEK (), LEN () RND (X) 0..X (ou X..0!) HIMEM, LOMEM 1 a 32767 Nenhum [versão inicial, então:] 16 definidos 16 bits ± 32767 AZ seguido por qualquer número alfanumérico DIM (uma dimensão) dimensionado
Dezembro de
1976
LLL BASIC
(Equipe da Universidade de Idaho) 8080 Intérprete INPUT var-list (LET) var = expressão PRINT lista expr {, /;} IR PARA o número Expressão IF expressão relop declaração (THEN) Número GO SUB RETORNA FIM CORRE LISTA - SCR REM PARA / PARA / PRÓXIMO (sem ETAPA) - PARE LIGAR, RECEBER (), COLOCAR () precedência <<= => => <>> < Sem RND? - 0 a 32.767 : 14 definidos Ponto flutuante de operando de 32 bits ? AZ, A0-Z9 DIM (apenas números inteiros, nome de uma letra, uma dimensão, tamanho máximo de 255) Nenhum

Veja também

Notas

Referências

Citações

Bibliografia

links externos