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
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
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 LIST
na 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 RUN
comando, 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: GOTO
e GOSUB
podia 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 100
e é 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
STEP
e usou a palavraNXT
- 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.
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
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 IF
e 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 STEP
modificador 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 @
, STOP
alé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 SORRY
para 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, A0
a Z9
), funções lógicas ( AND()
, OR()
, XOR()
), um CALL
comando para executar rotinas linguagem de máquina, mais PRINT
opções de Formatação, e outros ( GET()
e em PUT()
vez de PEEK
e 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 GOSUB
e 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; OS
retorna 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)"); CALL
executa uma sub-rotina em linguagem de máquina.
Dialetos diversos
Muitos dialetos apareceram em várias outras publicações.
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/RESTORE
declaraçõ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.
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 |
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
(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 |
(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 |
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 |
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 |
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 |
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 |
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 | |
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 |
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 |
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 |
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 |
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 $ |
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 |
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 |
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 |
(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
- "Folha de Código TB" . Dr. Dobb's Journal of Computer Calisthenics & Orthodontia, Running Light Without Overbyte . 1 (1). Dezembro de 1975.
- Manes, Stephen ; Andrews, Paul (1994). Gates: Como o magnata da Microsoft reinventou uma indústria e se tornou o homem mais rico da América . Nova York: Touchstone, Simon and Schuster. ISBN 0-671-88074-8.
links externos
- Tiny Basic User Manual e Experimenter's Kit - por Tom Pittman
- BASIC de Robert Uiterwyk e de Robert Uiterwyk Micro Básico - A MC6800 pequena BASIC mais tarde vendido com o SWTPc computador 6800
- MINOL - MINOL de Erik Mueller - Tiny BASIC com strings para Intel 8080
- Tiny BASIC - Uma versão para a biblioteca de manipulação de tela de personagens de maldições
- tinyBasic - uma implementação escrita em iziBasic
- Tiny BASIC - Uma versão da web ao vivo, portada para Run BASIC do iziBasic
- Palo Alto BASIC menor que 500 linhas - Exemplo de interpretador BASIC escrito em Ruby.
- TinyBasic - Uma porta do interpretador TinyBasic C de Tom Pittman para Java , C # e Adobe Flex . Inclui versões da web ao vivo.
- TinyBASIC Windows - uma versão do Windows do TinyBASIC