BÁSICO

BASIC (Código de instrução simbólica multifuncional para iniciantes) é uma família de linguagens de programação de alto nível e de uso geral projetadas para facilitar o uso. A versão original foi criada por John G. Kemeny e Thomas E. Kurtz no Dartmouth College em 1963. Eles queriam permitir que alunos de áreas não científicas usassem computadores. Na época, quase todos os computadores exigiam a criação de software personalizado, que apenas cientistas e matemáticos tendiam a aprender.

Além da linguagem do programa, Kemeny e Kurtz desenvolveram o Dartmouth Time Sharing System (DTSS), que permitia a vários usuários editar e executar programas BASIC simultaneamente em terminais remotos. Este modelo geral tornou-se muito popular em sistemas de minicomputadores como o PDP-11 e o Data General Nova no final dos anos 1960 e início dos anos 1970. A Hewlett-Packard produziu uma linha inteira de computadores para esse método de operação, introduzindo a série HP2000 no final dos anos 1960 e continuando as vendas nos anos 1980. Muitos dos primeiros videogames traçam sua história para uma dessas versões do BASIC.

O surgimento de microcomputadores em meados da década de 1970 levou ao desenvolvimento de vários dialetos BASIC, incluindo o Microsoft BASIC em 1975. Devido à pequena memória principal disponível nessas máquinas, muitas vezes 4 KB, uma variedade de dialetos Tiny BASIC também foram criada. O BASIC estava disponível para quase todos os sistemas da época e se tornou a linguagem de programação de fato para sistemas de computadores domésticos que surgiram no final dos anos 1970. Esses PCs quase sempre tinham um interpretador BASIC instalado por padrão, geralmente no firmware da máquina ou às vezes em um cartucho ROM.

BASIC perdeu popularidade na década de 1990, à medida que microcomputadores mais poderosos chegaram ao mercado e linguagens de programação com recursos avançados (como Pascal e C) tornaram-se sustentáveis em tais computadores. Em 1991, a Microsoft lançou o Visual Basic, combinando uma versão atualizada do BASIC com um construtor de formulários visuais. Este uso reacendeu da linguagem e "VB" continua sendo uma das principais linguagens de programação nas formas de VBA e VB.NET.

Origem

John G. Kemeny era o chefe do departamento de matemática do Dartmouth College. Com base principalmente em sua reputação como inovador no ensino de matemática, em 1959 a escola ganhou um prêmio da Fundação Alfred P. Sloan de $ 500.000 para construir um novo prédio de departamentos. Thomas E. Kurtz ingressou no departamento em 1956 e, desde a década de 1960, Kemeny e Kurtz concordaram com a necessidade de alfabetização em programação entre os alunos fora dos campos STEM tradicionais. Kemeny observou mais tarde que "Nossa visão era que todos os alunos no campus deveriam ter acesso a um computador, e qualquer membro do corpo docente deveria poder usar um computador na sala de aula sempre que apropriado". Foi tão simples quanto isso."

Kemeny e Kurtz fizeram dois experimentos anteriores com linguagens simplificadas, DARSIMCO (Dartmouth Simplified Code) e DOPE (Dartmouth Oversimplified Programming Experiment). Eles não passaram de uma única turma de calouros. Seguiram-se novos experimentos usando Fortran e ALGOL, mas Kurtz concluiu que essas linguagens eram complicadas demais para o que desejavam. Como observou Kurtz, o Fortran tinha vários comandos formados de forma estranha, notavelmente uma convenção "quase impossível de memorizar para especificar um loop: DO 100, I = 1, 10, 2. É '1, 10, 2' ou '1, 2, 10', e a vírgula após o número da linha é necessária ou não?"

Além disso, a falta de qualquer tipo de feedback imediato foi um problema chave; as máquinas da época usavam processamento em lote e demoravam muito para concluir a execução de um programa. Enquanto Kurtz estava visitando o MIT, John McCarthy sugeriu que o compartilhamento de tempo oferecia uma solução; uma única máquina poderia dividir seu tempo de processamento entre muitos usuários, dando-lhes a ilusão de ter um computador (lento) só para eles. Pequenos programas retornariam resultados em alguns segundos. Isso levou a um interesse crescente em um sistema que usa compartilhamento de tempo e uma nova linguagem especificamente para uso por alunos não-STEM.

Kemeny escreveu a primeira versão do BASIC. A sigla BASIC vem do nome de um artigo inédito de Thomas Kurtz. A nova linguagem foi fortemente padronizada em FORTRAN II; as instruções eram uma-para-linha, os números eram usados para indicar o alvo de loops e desvios e muitos dos comandos eram semelhantes ou idênticos ao Fortran. No entanto, a sintaxe foi alterada onde quer que pudesse ser melhorada. Por exemplo, o loop DO difícil de lembrar foi substituído pelo estilo PARA I = 1 TO 10 ETAPA 2, e o número da linha usado no DO foi indicado pelo NEXT I. Da mesma forma, a enigmática instrução IF do Fortran, cuja sintaxe correspondia a uma instrução específica da máquina na qual foi escrita originalmente, tornou-se a mais simples SE I=5 ENTÃO VÁ PARA 100. Essas mudanças tornaram a linguagem muito menos idiossincrática, embora ainda tivesse uma estrutura geral e se parecesse com o FORTRAN original.

O projeto recebeu uma doação de $ 300.000 da National Science Foundation, que foi usada para comprar um computador GE-225 para processamento e um processador Datanet-30 em tempo real para lidar com os teleimpressores Teletype Model 33 usados para entrada e saída. Uma equipe de uma dúzia de estudantes de graduação trabalhou no projeto por cerca de um ano, escrevendo o sistema DTSS e o compilador BASIC. A primeira versão da linguagem BASIC foi lançada em 1º de maio de 1964.

Inicialmente, o BASIC concentrou-se no suporte ao trabalho matemático direto, com suporte aritmético de matriz desde sua implementação inicial como uma linguagem de lote, e a funcionalidade de cadeia de caracteres sendo adicionada em 1965. O uso na universidade se expandiu rapidamente, exigindo que a CPU principal fosse substituída por um GE-235, e ainda mais tarde por um GE-635. No início da década de 1970, havia centenas de terminais conectados às máquinas em Dartmouth, alguns deles remotamente.

Desejando que o uso da linguagem se tornasse generalizado, seus projetistas disponibilizaram o compilador gratuitamente. Na década de 1960, o software tornou-se uma mercadoria cobrável; até então, era fornecido gratuitamente como um serviço com os caríssimos computadores, geralmente disponíveis apenas para locação. Eles também o disponibilizaram para escolas de ensino médio na área de Hanover, New Hampshire e regionalmente em toda a Nova Inglaterra nos terminais de teleimpressão modelo 33 e modelo 35 conectados a Dartmouth por meio de linhas telefônicas discadas, e fizeram um esforço considerável para promover o idioma. Nos anos seguintes, conforme outros dialetos do BASIC apareceram, o dialeto BASIC original de Kemeny e Kurtz ficou conhecido como Dartmouth BASIC.

New Hampshire reconheceu a conquista em 2019, quando ergueu um marcador histórico de rodovia em Hanover, descrevendo a criação da "a primeira linguagem de programação amigável".

Divulgação em serviços de time-sharing

O surgimento do BASIC ocorreu como parte de um movimento mais amplo em direção a sistemas de compartilhamento de tempo. Conceitualizada pela primeira vez no final dos anos 1950, a ideia tornou-se tão dominante na indústria de computadores no início dos anos 1960 que seus proponentes falavam de um futuro em que os usuários "comprariam tempo no computador da mesma forma que uma família média compra energia e água de concessionárias".

A General Electric, tendo trabalhado no projeto de Dartmouth, escreveu seu próprio sistema operacional subjacente e lançou um sistema de compartilhamento de tempo on-line conhecido como Mark I. Ele apresentava o BASIC como um de seus principais pontos de venda. Outras empresas no campo emergente rapidamente seguiram o exemplo; A Tymshare introduziu o SUPER BASIC em 1968, a CompuServe tinha uma versão no DEC-10 em seu lançamento em 1969 e, no início dos anos 1970, o BASIC era amplamente universal em computadores mainframe de uso geral. Até a IBM acabou se juntando ao clube com a introdução do VS-BASIC em 1973.

Embora os serviços de compartilhamento de tempo com BASIC tenham sido bem-sucedidos por um tempo, o sucesso generalizado previsto anteriormente não aconteceria. O surgimento de minicomputadores durante o mesmo período, e especialmente microcomputadores de baixo custo em meados da década de 1970, permitiu que qualquer pessoa comprasse e executasse seus próprios sistemas, em vez de comprar tempo online, que normalmente era cobrado em dólares por minuto.

Divulgação em minicomputadores

O sistema HP 2000 foi projetado para executar o tempo compartilhado BASIC como sua principal tarefa.

O BASIC, pela sua própria natureza de pequeno porte, adequava-se naturalmente à portabilidade para o mercado dos minicomputadores, que surgia em simultâneo com os serviços de time-sharing. Essas máquinas tinham memória principal muito pequena, talvez apenas 4 KB na terminologia moderna, e não tinham armazenamento de alto desempenho, como discos rígidos, que tornavam os compiladores práticos. Nesses sistemas, o BASIC era normalmente implementado como um interpretador em vez de um compilador devido à necessidade reduzida de memória de trabalho.

Um exemplo particularmente importante foi o HP Time-Shared BASIC, que, como o sistema original de Dartmouth, usava dois computadores trabalhando juntos para implementar um sistema de compartilhamento de tempo. A primeira, uma máquina de baixo custo da série HP 2100, era usada para controlar a entrada do usuário e salvar e carregar seus programas em fita ou disco. O outro, uma versão de ponta da mesma máquina subjacente, executava os programas e gerava resultados. Por um custo de cerca de US$ 100.000, uma pessoa poderia ter uma máquina capaz de operar entre 16 e 32 usuários ao mesmo tempo. O sistema, empacotado como HP 2000, foi a primeira miniplataforma a oferecer compartilhamento de tempo e foi um sucesso imediato, catapultando a HP para se tornar o terceiro maior fornecedor no espaço de minicomputadores, atrás de DEC e Data General (DG).

DEC, líder no segmento de minicomputadores desde meados da década de 1960, inicialmente ignorou o BASIC. Isso se deveu ao trabalho com a RAND Corporation, que comprou um PDP-6 para executar sua linguagem JOSS, que era conceitualmente muito semelhante ao BASIC. Isso levou a DEC a introduzir uma versão menor e mais limpa do JOSS, conhecida como FOCAL, que eles promoveram fortemente no final dos anos 1960. No entanto, com os sistemas de compartilhamento de tempo oferecendo amplamente o BASIC e toda a concorrência no espaço do minicomputador fazendo o mesmo, os clientes da DEC clamavam pelo BASIC. Depois que a administração ignorou repetidamente seus apelos, David H. Ahl assumiu a responsabilidade de comprar um BASIC para o PDP-8, que foi um grande sucesso no mercado educacional. No início dos anos 1970, FOCAL e JOSS foram esquecidos e o BASIC tornou-se quase universal no mercado de minicomputadores. A DEC iria apresentar sua versão atualizada, BASIC-PLUS, para uso no sistema operacional de compartilhamento de tempo RSTS/E.

Durante esse período, vários jogos simples baseados em texto foram escritos em BASIC, principalmente o Star Trek de Mike Mayfield. David Ahl os coletou, alguns portados do FOCAL, e os publicou em um boletim educacional que ele compilou. Mais tarde, ele reuniu vários deles em forma de livro, 101 BASIC Computer Games, publicado em 1973. Durante o mesmo período, Ahl esteve envolvido na criação de um pequeno computador para uso educacional, um dos primeiros computadores pessoais. Quando a administração se recusou a apoiar o conceito, Ahl deixou a DEC em 1974 para fundar a seminal revista de informática Creative Computing. O livro permaneceu popular e foi republicado em várias ocasiões.

Crescimento explosivo: a era do computador doméstico

Commodore BASIC v2.0 no Commodore 64

MSX BASIC versão 3.0

"Train Basic todos os dias!" — lê um cartaz (centro inferior) em uma escola russa (c. 1985-1986)

A introdução dos primeiros microcomputadores em meados da década de 1970 foi o início do crescimento explosivo do BASIC. Ele tinha a vantagem de ser bastante conhecido pelos jovens designers e entusiastas de computador que se interessavam por microcomputadores, muitos dos quais tinham visto o BASIC em minis ou mainframes. Apesar do famoso julgamento de Dijkstra em 1975, "É praticamente impossível ensinar boa programação para alunos que tiveram uma exposição anterior ao BASIC: como programadores em potencial, eles estão mentalmente mutilados além da esperança de regeneração", BASIC foi uma das poucas linguagens que era de alto nível o suficiente para ser usada por aqueles sem treinamento e pequena o suficiente para caber nos microcomputadores da época, tornando-a a linguagem de programação padrão de fato nos primeiros microcomputadores.

A primeira versão do BASIC para microcomputador foi co-escrita por Bill Gates, Paul Allen e Monte Davidoff para sua empresa recém-formada, a Micro-Soft. Isso foi lançado pelo MITS em formato de fita perfurada para o Altair 8800 logo após a própria máquina, consolidando imediatamente o BASIC como a linguagem principal dos primeiros microcomputadores. Membros do Homebrew Computer Club começaram a distribuir cópias do programa, fazendo com que Gates escrevesse sua Carta Aberta aos Hobbyists, reclamando desse exemplo inicial de pirataria de software.

Em parte em resposta à carta de Gates e em parte para fazer um BASIC ainda menor que rodaria de maneira útil em máquinas de 4 KB, Bob Albrecht pediu a Dennis Allison que escrevesse sua própria variação da linguagem. Como projetar e implementar uma versão simplificada de um interpretador para a linguagem BASIC foi abordado em artigos de Allison nas três primeiras edições trimestrais do boletim People's Computer Company publicado em 1975 e implementações com código-fonte publicado em Dr. Dobb's Journal of Tiny BASIC Calisthenics & Ortodontia: Running Light Sem Overbyte. Isso levou a uma grande variedade de Tiny BASICs com recursos adicionais ou outras melhorias, com versões de Tom Pittman e Li-Chen Wang tornando-se particularmente conhecidas.

A Micro-Soft, na época Microsoft, portou seu interpretador para o MOS 6502, que rapidamente se tornou um dos microprocessadores mais populares da era de 8 bits. Quando novos microcomputadores começaram a aparecer, notadamente o "1977 trindade" do TRS-80, Commodore PET e Apple II, eles incluíram uma versão do código MS ou introduziram rapidamente novos modelos com ele. Os computadores pessoais da Ohio Scientific também aderiram a essa tendência na época. Em 1978, o MS BASIC era um padrão de fato e praticamente todos os computadores domésticos da década de 1980 o incluíam na ROM. Na inicialização, um interpretador BASIC em modo direto foi apresentado.

As Commodore Business Machines incluíam o Commodore BASIC, baseado no Microsoft BASIC. O Apple II e o TRS-80 tinham cada um duas versões do BASIC, uma versão introdutória menor introduzida com os lançamentos iniciais das máquinas e uma versão baseada em MS introduzida conforme o interesse nas plataformas aumentava. À medida que novas empresas entraram no campo, foram adicionadas versões adicionais que mudaram sutilmente a família BASIC. A família Atari 8-bit tinha seu próprio Atari BASIC que foi modificado para caber em um cartucho ROM de 8 KB. O Sinclair BASIC foi introduzido em 1980 com o Sinclair ZX80, e mais tarde foi estendido para o Sinclair ZX81 e o Sinclair ZX Spectrum. A BBC publicou o BBC BASIC, desenvolvido pela Acorn Computers Ltd, incorporando muitas palavras-chave de programação extra estruturadas e recursos avançados de operação de ponto flutuante.

À medida que a popularidade do BASIC crescia nesse período, as revistas de informática publicavam o código-fonte completo em BASIC para videogames, utilitários e outros programas. Dada a natureza direta do BASIC, foi uma questão simples digitar o código da revista e executar o programa. Diferentes revistas foram publicadas apresentando programas para computadores específicos, embora alguns programas BASIC fossem considerados universais e pudessem ser usados em máquinas rodando qualquer variante do BASIC (às vezes com pequenas adaptações). Muitos livros de programas de digitação também estavam disponíveis e, em particular, Ahl publicou versões dos 101 jogos BASIC originais convertidos para o dialeto da Microsoft e os publicou da Creative Computing como BASIC Computer Games. Este livro e suas sequências fornecem centenas de programas prontos para uso que podem ser facilmente convertidos em praticamente qualquer plataforma de execução BASIC. O livro chegou às lojas em 1978, quando o mercado de computadores domésticos estava começando, e se tornou o primeiro livro de computador vendido por um milhão. Pacotes posteriores, como o Learn to Program BASIC, também teriam jogos como foco introdutório. Nos computadores CP/M voltados para negócios, que logo se difundiram em ambientes de pequenas empresas, o Microsoft BASIC (MBASIC) foi um dos principais aplicativos.

Em 1978, David Lien publicou a primeira edição de The BASIC Handbook: An Encyclopedia of the BASIC Computer Language, documentando palavras-chave em mais de 78 computadores diferentes. Em 1981, a segunda edição documentou palavras-chave de mais de 250 computadores diferentes, mostrando o crescimento explosivo da era do microcomputador.

IBM PC e compatíveis

IBM Cassette BASIC 1.10

Quando a IBM estava projetando o IBM PC, eles seguiram o paradigma dos computadores domésticos existentes em ter um interpretador BASIC integrado. Eles obtiveram isso da Microsoft - IBM Cassette BASIC - mas a Microsoft também produziu várias outras versões do BASIC para MS-DOS/PC DOS, incluindo IBM Disk BASIC (BASIC D), IBM BASICA (BASIC A), GW-BASIC (um compatível com BASICA versão que não precisava da ROM da IBM) e QBasic, todos normalmente empacotados com a máquina. Além disso, eles produziram o Microsoft BASIC Compiler voltado para programadores profissionais. A Borland, editora do Turbo Pascal, publicou o Turbo Basic 1.0 em 1985 (as versões sucessoras ainda estão sendo comercializadas sob o nome de PowerBASIC).

Essas variações posteriores introduziram muitas extensões, como manipulação aprimorada de strings e suporte a gráficos, acesso ao sistema de arquivos e tipos de dados adicionais. Mais importantes foram as facilidades para programação estruturada, incluindo estruturas de controle adicionais e sub-rotinas apropriadas suportando variáveis locais. No entanto, na segunda metade da década de 1980, os usuários estavam usando cada vez mais aplicativos pré-fabricados escritos por outros, em vez de aprender a programar sozinhos; enquanto os programadores profissionais agora tinham uma ampla variedade de linguagens mais avançadas disponíveis em pequenos computadores. C e mais tarde C++ tornaram-se as linguagens de escolha para "embalagem retrátil" desenvolvimento de aplicações.

Visual Basic

Em 1991, a Microsoft introduziu o Visual Basic, um desenvolvimento evolutivo do QuickBASIC. Incluía construções dessa linguagem, como instruções de controle estruturadas em blocos, sub-rotinas parametrizadas e tipagem estática opcional, bem como construções orientadas a objetos de outras linguagens, como "With" e "Para Cada". A linguagem manteve alguma compatibilidade com suas predecessoras, como a palavra-chave Dim para declarações, instruções "Gosub"/Return e números de linha opcionais que podem ser usados para localizar erros. Um fator importante para o desenvolvimento do Visual Basic foi a nova linguagem de macro para o Microsoft Excel, um programa de planilhas. Para a surpresa de muitos na Microsoft, que inicialmente a comercializavam como uma linguagem para amadores, a linguagem tornou-se amplamente utilizada para pequenos aplicativos personalizados de negócios logo após o lançamento da versão 3.0 do VB, que é amplamente considerada a primeira versão relativamente estável.

Embora muitos programadores avançados ainda zombassem de seu uso, o VB atendia às necessidades de pequenas empresas com eficiência, pois naquela época os computadores que executavam o Windows 3.1 haviam se tornado rápidos o suficiente para que muitos processos relacionados a negócios pudessem ser concluídos "em um piscar de olhos de um olho" mesmo usando um "lento" linguagem, desde que grandes quantidades de dados não estivessem envolvidas. Muitos proprietários de pequenas empresas descobriram que poderiam criar seus próprios aplicativos pequenos, mas úteis, em algumas noites para atender às suas próprias necessidades especializadas. Eventualmente, durante o longo tempo de vida do VB3, o conhecimento do Visual Basic tornou-se uma habilidade de trabalho comercializável. A Microsoft também produziu VBScript em 1996 e Visual Basic.NET em 2001. Este último tem essencialmente o mesmo poder que C# e Java, mas com uma sintaxe que reflete a linguagem Basic original. O IDE, com seu construtor de GUI orientado a eventos, também influenciou outras ferramentas, principalmente o Delphi for Object Pascal da Borland Software e seus próprios descendentes, como o Lazarus.

O suporte principal para a versão final 6.0 do Visual Basic original terminou em 31 de março de 2005, seguido pelo suporte estendido em março de 2008. Em 11 de março de 2020, a Microsoft anunciou que a evolução da linguagem VB.NET também foi concluída, embora ainda fosse suportado. Enquanto isso, existem concorrentes como Xojo e Gambas.

Três modernos Variantes básicas: Mono Basic, OpenOffice.org Básico e Gambas

Versões e dialetos posteriores a 1990

Muitos outros dialetos BASIC também surgiram desde 1990, incluindo o código aberto QB64 e FreeBASIC, inspirados no QBasic, e RapidQ, HBasic, Basic For Qt e Gambas no estilo Visual Basic. Encarnações comerciais modernas incluem PureBasic, PowerBASIC, Xojo, Monkey X e True BASIC (o sucessor direto do Dartmouth BASIC de uma empresa controlada por Kurtz).

Agora também existem vários interpretadores BASIC simples baseados na Web, incluindo o Small Basic da Microsoft. Muitas versões do BASIC também estão disponíveis para smartphones e tablets através da Apple App Store ou Google Play Store para Android. Em consoles de jogos, um aplicativo para Nintendo 3DS e Nintendo DSi chamado Petit Computer permite a programação em uma versão ligeiramente modificada do BASIC com suporte a botões DS. Uma versão também foi lançada para o Nintendo Switch.

Calculadoras

Variantes do BASIC estão disponíveis em calculadoras gráficas e outras programáveis feitas pela Texas Instruments, HP, Casio e outras.

Linha de comando do Windows

O QBasic, uma versão do Microsoft QuickBASIC sem o linker para criar arquivos EXE, está presente nos fluxos de sistemas operacionais Windows NT e DOS-Windows 95 e pode ser obtido para versões mais recentes, como o Windows 7, que não os possui. Antes do DOS 5, o interpretador básico era o GW-Basic. QuickBasic faz parte de uma série de três idiomas emitidos pela Microsoft para o usuário avançado doméstico e de escritório e desenvolvimento profissional em pequena escala; QuickC e QuickPascal são os outros dois. Para Windows 95 e 98, que não possuem o QBasic instalado por padrão, eles podem ser copiados do disco de instalação, que terá um conjunto de diretórios para softwares antigos e opcionais; outros comandos ausentes, como Exe2Bin e outros, estão nesses mesmos diretórios.

Outro

BASIC chegou a alguns sistemas de videogame, como o Nintendo Famicom.

As várias suítes de escritório Microsoft, Lotus e Corel e produtos relacionados são programáveis com Visual Basic de uma forma ou de outra, incluindo LotusScript, que é muito semelhante ao VBA 6. O emulador de terminal Host Explorer usa WWB como uma linguagem macro; ou, mais recentemente, o programa e o conjunto no qual ele está contido são programáveis em uma variante básica interna conhecida como Hummingbird Basic. A variante VBScript é usada para programar conteúdo da Web, Outlook 97, Internet Explorer e Windows Script Host. O WSH também possui um mecanismo Visual Basic for Applications (VBA) instalado como o terceiro dos mecanismos padrão junto com VBScript, JScript e vários mecanismos proprietários ou de código aberto que podem ser instalados como PerlScript, alguns mecanismos baseados em Rexx, Python, Ruby, Tcl, Delphi, XLNT, PHP e outros; o que significa que as duas versões do Basic podem ser usadas junto com as outras linguagens mencionadas, assim como o LotusScript, em um arquivo WSF, através do modelo de objeto componente, e outras construções WSH e VBA. VBScript é uma das linguagens que podem ser acessadas pelos shells aprimorados 4Dos, 4NT e Take Command. SaxBasic e WWB também são muito semelhantes à linha Visual Basic de implementações básicas. A linguagem de macro anterior ao Office 97 para o Microsoft Word é conhecida como WordBASIC. O Excel 4 e 5 usam o próprio Visual Basic como uma linguagem de macro. Chipmunk Basic, um interpretador old-school semelhante aos BASICs da década de 1970, está disponível para Linux, Microsoft Windows e macOS.

Legado

A onipresença de intérpretes BASIC em computadores pessoais era tal que os livros didáticos incluíam instruções simples "Experimente em BASIC" exercícios que incentivavam os alunos a experimentar conceitos matemáticos e computacionais em sala de aula ou computadores domésticos. As revistas de informática populares da época geralmente incluíam programas de digitação.

O escritor futurista e de ficção científica David Brin lamentou a perda do onipresente BASIC em um artigo do Salon de 2006, assim como outros que usaram computadores pela primeira vez nessa época. Por sua vez, o artigo levou a Microsoft a desenvolver e lançar o Small Basic; também inspirou projetos semelhantes como o Basic-256. Dartmouth realizou uma celebração do 50º aniversário do BASIC em 1º de maio de 2014, assim como outras organizações; pelo menos uma organização de programadores VBA organizou uma observância do 35º aniversário em 1999.

O Dartmouth College comemorou o 50º aniversário da linguagem BASIC com um dia de eventos em 30 de abril de 2014. Um pequeno documentário foi produzido para o evento.

Sintaxe

Palavras-chave BASIC típicas

Manipulação de dados

LET

atribui um valor (que pode ser o resultado de uma expressão) a uma variável. Na maioria dos dialetos da BASIC, LET é opcional, e uma linha com nenhuma outra palavra-chave identificável assumirá a palavra-chave a ser LET.

DATA

contém uma lista de valores que são atribuídos sequencialmente usando o comando READ.

READ

lê um valor de um DATA declaração e atribui a uma variável. Um ponteiro interno acompanha o último DATA elemento que foi lido e move-o uma posição para a frente com cada READ. A maioria dos dialetos permite múltiplas variáveis como parâmetros, lendo vários valores em uma única operação.

RESTORE

redefiniu o ponteiro interno para o primeiro DATA declaração, permitindo que o programa comece READing do primeiro valor. Muitos dialetos permitem que um número de linha opcional ou valor ordinal permita que o ponteiro seja redefinido para um local selecionado.

DIM

Configura um array.

Controle de fluxo do programa

IF... THEN... {ELSE}

usado para realizar comparações ou tomar decisões. Os primeiros dialetos só permitiram um número de linha após o THEN, mas versões posteriores permitiram que qualquer declaração válida seguisse. ELSE não foi amplamente suportado, especialmente em versões anteriores.

FOR... TO... {STEP}... NEXT

repetir uma seção de código um determinado número de vezes. Uma variável que atua como contador, o "index", está disponível dentro do loop.

WHILE... WEND e REPEAT... UNTIL

repetir uma seção de código enquanto a condição especificada é verdadeira. A condição pode ser avaliada antes de cada iteração do loop, ou depois. Ambos os comandos são encontrados principalmente em dialetos posteriores.

DO... LOOP {WHILE} ou {UNTIL}

repetir uma seção de código indefinidamente ou enquanto/até que a condição especificada seja verdadeira. A condição pode ser avaliada antes de cada iteração do loop, ou depois. Semelhante a WHILE, essas palavras-chave são encontradas principalmente em dialetos posteriores.

GOTO

salta para uma linha numerada ou rotulada no programa. A maioria dos dialetos também permitiu a forma GO TO.

GOSUB... RETURN

salta para uma linha numerada ou rotulada, executa o código que encontra lá até atingir um RETURN comando, no qual ele pula de volta para a declaração seguinte ao GOSUB, ou depois de um cólon, ou na próxima linha. Isso é usado para implementar subrotinas.

ON... GOTO/GOSUB

escolhe onde pular com base nas condições especificadas. Veja a declaração do interruptor para outros formulários.

DEF FN

um par de palavras-chave introduzidas no início dos anos 1960 para definir funções. As funções BASIC originais foram modeladas em funções de linha única FORTRAN. As funções BASIC foram uma expressão com argumentos variáveis, em vez de subrotinas, com uma sintaxe no modelo de DEF FND(x) = x*x no início de um programa. Nomes de função foram originalmente restritos a FN, mais uma letra, Ou seja.FNA, FNB...

Entrada e saída

LIST

exibe o código fonte completo do programa atual.

PRINT

exibe uma mensagem na tela ou outro dispositivo de saída.

INPUT

pede ao usuário para inserir o valor de uma variável. A declaração pode incluir uma mensagem rápida.

TAB

usado com PRINT para definir a posição onde o próximo personagem será mostrado na tela ou impresso em papel. AT é uma forma alternativa.

SPC

imprime um número de personagens espaciais. Semelhante ao conceito TAB mas move-se por um número de espaços adicionais da coluna atual em vez de mover-se para uma coluna especificada.

Funções matemáticas

ABS

Valor absoluto

ATN

Arctangent (resultado em radianos)

COS

Cosine (argumento em radianos)

EXP

Função experiencial

INT

Parte de inteiro (função de pisotipicamente)

LOG

Logarithm natural

RND

Geração de números aleatórios

SIN

Sine (argumento em radianos)

SQR

raiz quadrada

TAN

Tangente (argumento em radianos)

Diversos

REM

detém o comentário de um programador ou REMark; muitas vezes usado para dar um título ao programa e para ajudar a identificar o propósito de uma dada seção de código.

USR

transfere o controle do programa para uma subrotina da linguagem da máquina, geralmente inserido como uma cadeia alfanumérica ou em uma lista de declarações de DADOS.

CALL

forma alternativa de USR encontrado em alguns dialetos. Não requer um parâmetro artificial para completar a sintaxe semelhante à função de USR, e tem um método claramente definido de chamar diferentes rotinas na memória.

TRON / TROFF

gira em exibição de cada número de linha como é executado ("TRace ON"). Isso foi útil para depuração ou correção de problemas em um programa. O TROFF desliga outra vez.

ASM

alguns compiladores como Freebasic, Purebasic e Powerbasic também suportam a linguagem de montagem em linha, permitindo que o programador intermix o código de alto nível e baixo nível, tipicamente prefixado com "ASM" ou "!

Tipos de dados e variáveis

Versões mínimas do BASIC tinham apenas variáveis inteiras e nomes de variáveis com uma ou duas letras, o que minimizava os requisitos de memória limitada e cara (RAM). Versões mais poderosas tinham aritmética de ponto flutuante e as variáveis podiam ser rotuladas com nomes de seis ou mais caracteres. Houve alguns problemas e restrições nas primeiras implementações; por exemplo, o Applesoft BASIC permitia nomes de variáveis com vários caracteres, mas apenas os dois primeiros eram significativos, portanto, era possível escrever inadvertidamente um programa com variáveis "LOSS" e "EMPRÉSTIMO", que seriam tratados como sendo o mesmo; atribuir um valor a "EMPRÉSTIMO" substituiria silenciosamente o valor pretendido como "PERDA". Palavras-chave não podiam ser usadas em variáveis em muitos dos primeiros BASICs; "PONTUAÇÃO" seria interpretado como "SC" OR "E", onde OR era uma palavra-chave. Variáveis de string são geralmente distinguidas em muitos dialetos de microcomputadores por terem $ como sufixo em seus nomes como um sigilo, e os valores são frequentemente identificados como strings por serem delimitados por "aspas duplas". Arrays em BASIC podem conter números inteiros, ponto flutuante ou variáveis de string.

Alguns dialetos do BASIC suportam matrizes e operações matriciais, que podem ser usadas para resolver conjuntos de equações algébricas lineares simultâneas. Esses dialetos dariam suporte direto a operações de matriz, como atribuição, adição, multiplicação (de tipos de matriz compatíveis) e avaliação de um determinante. Muitos BASICs de microcomputadores não suportavam este tipo de dados; as operações de matriz ainda eram possíveis, mas tinham que ser programadas explicitamente nos elementos da matriz.

Exemplos

Um jogo simples implementado na BASIC

BASIC não estruturado

Os novos programadores BASIC em um computador doméstico podem começar com um programa simples, talvez usando a instrução PRINT da linguagem para exibir uma mensagem na tela; um exemplo bem conhecido e frequentemente replicado é Kernighan e Ritchie's "Hello, World!" programa:

10. PRINTEIRA "Olá, Mundo!"20. FIM

Um loop infinito pode ser usado para preencher a tela com a mensagem:

10. PRINTEIRA "Olá, Mundo!"20. GOTO 10.

Observe que a instrução END é opcional e não tem ação na maioria dos dialetos do BASIC. Nem sempre foi incluído, como é o caso neste exemplo. Este mesmo programa pode ser modificado para imprimir um número fixo de mensagens usando a instrução FOR...NEXT comum:

10. Vamos. N= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =10.20. Por favor. Eu...= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =1 A N30 PRINTEIRA "Olá, Mundo!"40 TEXTO Eu...

A maioria das versões BASIC de primeira geração, como MSX BASIC e GW-BASIC, suportam tipos de dados simples, ciclos de loop e arrays. O exemplo a seguir foi escrito para GW-BASIC, mas funcionará na maioria das versões do BASIC com alterações mínimas:

10. INP "Qual é o teu nome: "; U$20. PRINTEIRA "Olá"; U$30 INP "Quantas estrelas queres: "; N40 S$ = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = "50 Por favor. Eu... = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = 1 A N60 S$ = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = S$ + "*"70 TEXTO Eu...80 PRINTEIRA S$90 INP "Queres mais estrelas? "; R$100. IF LER(R$) = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = 0 A GOTO 90110 R$ = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = AUXÍLIOS(R$, 1)120 IF R$ = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = "Y" OU R$ = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = "Y" A GOTO 30130 PRINTEIRA Adeus.; U$140 FIM

A caixa de diálogo resultante pode se parecer com:

Como se chama? Mike.
Olá, Mike.
Quantas estrelas você quer: 7
- Sim.
Queres mais estrelas? Sim.
Quantas estrelas você quer: 3
- Sim.
Queres mais estrelas? Não.
Adeus Mike.

O Dartmouth Basic original era incomum por ter uma palavra-chave de matriz, MAT. Embora não implementado pela maioria dos derivados de microprocessador posteriores, é usado neste exemplo do manual de 1968, que calcula a média dos números que são inseridos:

5 Vamos. S = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = 010. MAT INP V 20. Vamos. N = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = NUM 30 IF N = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = 0 A 99 40 Por favor. Eu... = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = 1 A N 45 Vamos. S = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = S + V(Eu...) 50 TEXTO Eu... 60 PRINTEIRA S/N 70 Vai. A 5 99 FIM

BÁSICO Estruturado

Basics de segunda geração (por exemplo, VAX Basic, SuperBASIC, True BASIC, QuickBASIC, BBC BASIC, Pick BASIC, PowerBASIC, Liberty BASIC e (possivelmente) COMAL) introduziram uma série de recursos na linguagem, principalmente relacionados a estruturas e programação orientada a procedimentos. Normalmente, a numeração de linha é omitida da linguagem e substituída por rótulos (para GOTO) e procedimentos para encorajar um design mais fácil e flexível. Além disso, foram introduzidas palavras-chave e estruturas para dar suporte à repetição, seleção e procedimentos com variáveis locais.

O exemplo a seguir está no Microsoft QuickBASIC:

REM QuickBASIC exemploREM Declaração antecipada - permite que o código principal chame umSubrotina REM que é definida mais tarde no código fonteDECLARAÇÃO ASSUNTO PrintSomeStars (StarCount!)REM O programa principal segueINP "Qual é o teu nome: ", Nome do usuário $PRINTEIRA "Olá"; Nome do usuário $- Sim. INP "Quantas estrelas queres: ", NoStars PORTO PrintSomeStars(NoStars) - Sim. INP "Queres mais estrelas? ", Responder LOCAL UNIÃO EUROPEIA Responder < " Responder = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = AUXÍLIOS(Responder, 1)LOCAL PORTUGAL UCASE(Responder) = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = "Y"PRINTEIRA Adeus.; Nome do usuário $FIMDefinição de subrotina de REMASSUNTO PrintSomeStars (StarCount) REM Isto é... procedimento uso um local local variável chamado Estrelas Estrelas = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = STRING(StarCount, "*") PRINTEIRA EstrelasFIM ASSUNTO

BASIC orientado a objetos

Dialetos BASIC de terceira geração, como Visual Basic, Xojo, Gambas, StarOffice Basic, BlitzMax e PureBasic, introduziram recursos para dar suporte ao paradigma de programação orientado a objetos e a eventos. A maioria dos procedimentos e funções integrados agora são representados como métodos de objetos padrão em vez de operadores. Além disso, o sistema operacional tornou-se cada vez mais acessível à linguagem BASIC.

O exemplo a seguir está em Visual Basic.NET:

Público Módulo Programa das Estrelas Privado Função Pergunte(prompt Como String) Como String Console.Escrever(prompt) Voltar Console.ReadLine() Fim Função Público Subscrição Principal() Dim Nome do usuário = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = Pergunte("Qual é o teu nome: ") Console.Linha de produção(Olá., Nome do usuário) Dim resposta Como String Do Dim # = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = IC(Pergunte("Quantas estrelas queres: ") Dim estrelas Como Novo String("C", #) Console.Linha de produção(estrelas) Do resposta = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = Pergunte("Queres mais estrelas? ") Loop Até lá. resposta < " Loop Enquanto resposta.Começa com("Y", StringComparison.OrdinalIgnore Processo) Console.Linha de produção(Adeus., Nome do usuário) Fim SubscriçãoFim Módulo

Padrões

• ANSI/ISO/IEC Padrão para Minimal BASIC:
  • ANSI X3.60-1978 "Para a BASIC mínima"
  • ISO/IEC 6373:1984 " Processamento de dados - Linguagens de programação - BASIC mínima"
• ECMA-55 Minimal BASE (com desenho semelhante ao ANSI X3.60-1978)
• ANSI/ISO/IEC Standard for Full BASIC:
  • ANSI X3.113-1987 "Línguas de programação completa BASIC"
  • INCITS/ISO/IEC 10279-1991 (R2005) "Information Technology – Programming Languages – Full BASIC"
• ANSI/ISO/IEC Addendum Defining Modules:
  • ANSI X3.113 Interpretations-1992 «BASIC Technical Information Bulletin # 1 Interpretations of ANSI 03.113-1987» (em inglês).
  • ISO/IEC 10279:1991/ Amd 1:1994 "Módulos e realce de entrada de caracteres único"
• CEMA-116 BASE (com desenho semelhante ao ANSI X3.113-1987)

Compiladores e interpretadores