**BASIC** é unha familia de linguaxes de programación. Foi orixinalmente ideado como unha ferramenta de ensino, estendeuse entre as microcomputadores caseiras na década de 1980, e segue sendo popular hoxe en día en moitos dialectos bastante distintos do orixinal.

BASIC é o acrónimo de ***B**eginners **A**ll-purpose **S**ymbolic **I**nstruction **C**ode* (en galego ‘código de instrucións simbólicas de propósito xeral para principiantes') e está ligado ao nome dun traballo sen publicar do coinventor da linguaxe, Thomas Kurtz (o nome non está relacionado coa serie de C. K. Ogden, *Basic English*).

### Antecedentes

A principios da década de 1960, as computadoras eran ferramentas sumamente caras que eran utilizadas unicamente para propósitos especiais, executando unha soa "tarefa" á vez. Con todo, durante esa década, os prezos comezaron a baixar ao momento que ata as pequenas empresas podían custealas. A velocidade das máquinas incrementouse ao momento que a miúdo quedaban ociosas porque non había suficientes tarefas para elas.
As linguaxes de programación daqueles tempos estaban deseñados como as máquinas nas que corrían: para propósitos específicos como o procesamento de fórmulas. Como as máquinas para unha soa tarefa eran caras, considerábase que a velocidade de execución era a característica máis importante de todas. En xeral, todas eran difíciles de utilizar, e achegaban pouca estética.

Foi naqueles tempos que o concepto de sistema de Tempo compartido comezou a popularizarse. Nun destes sistemas, o tempo de procesamento da computadora principal dividíase, e a cada usuario outorgábaselle unha pequena porción nunha secuencia. As máquinas eran o suficientemente rápidas como para enganar á maioría dos usuarios, dándolles a ilusión de que dispuñan dunha máquina enteira só para eles. En teoría a distribución do tempo entre os usuarios reduciu considerablemente o custo da computación, xa que unha soa máquina podía ser compartida, polo menos en teoría, entre centos de usuarios.

### Nacemento e primeiros anos

A linguaxe BASIC orixinal foi inventado en 1964 por John George Kemeny (1926-1993) e Thomas Eugene Kurtz (1928-) no Dartmouth College. Nos anos subseguintes, mentres que outros dialectos de BASIC aparecían, o BASIC orixinal de Kemeny e Kurtz era coñecido como *BASIC Dartmouth*.

BASIC foi deseñado para permitir aos estudantes escribir programas usando terminais de computador de tempo compartido. BASIC estaba intencionado para facilitar os problemas de complexidade das linguaxes anteriores, cunha nova linguaxe deseñada especificamente para a clase de usuarios que os sistemas de tempo compartido permitían: un usuario máis sinxelo, a quen non lle interesaba tanto a velocidade, senón o feito de ser capaz de usar a máquina. Os deseñadores da linguaxe tamén querían que permanecese no dominio público, o que contribuíu a que se diseminara.

Os oito principios de deseño de BASIC foron:

1. Ser fácil de usar para os principiantes.
2. Ser unha linguaxe de propósito xeral.
3. Permitir que os expertos engadisen características avanzadas, mentres que a linguaxe permanecía simple para os principiantes.
4. Ser interactivo.
5. Prover mensaxes de erro claros e amigables.
6. Responder rápido aos programas pequenos.
7. Non requirir un coñecemento do hardware da computadora.
8. Protexer ao usuario do sistema operativo.

A linguaxe foi en parte baseado en FORTRAN II e en parte en Algol 60, con adicións para facelo apropiado para tempo compartido e aritmética de matrices, BASIC foi implementado por primeira vez na mainframe GE-265, que soportaba múltiples terminais. Contrario á crenza popular, era unha linguaxe compilado ao momento da súa introdución. Case inmediatamente logo do seu lanzamento, os profesionais de computación comezaron a alegar que BASIC era moi lento e simple. Tal argumento é un tema recorrente na industria das computadoras.

Aínda así, BASIC expandiuse cara a moitas máquinas, e popularizouse moderadamente nas minicomputadores como a serie DEC PDP e a Data Xeral Nova. Nestes casos, a linguaxe era implementado como un intérprete, no canto dun compilador, ou alternativamente, de ambas as formas.

### Crecemento explosivo

Con todo, foi coa introdución da Microcomputador Altair 8800 en 1975 que BASIC se estendeu amplamente. A maioría das linguaxes de programación eran demasiado grandes para caber na pequena memoria que a maioría dos usuarios podía pagar para as súas máquinas, e co lento almacenamento que era a cinta de papel, e máis tarde a cinta de audiocasete (os discos magnéticos aínda non existían), e a falta de editores de texto adecuados, unha linguaxe pequena como BASIC era unha boa opción. Un dos primeiros en aparecer foi Tiny BASIC, unha implementación simple de BASIC escrita orixinalmente polo Dr. Li-Chen Wang, e portada máis tarde á Altair por Dennis Allison, a petición de Bob Albrecht (quen despois fundou o *Dr. Dobbs Journal*). O deseño de Tiny BASIC e o código fonte completo foi publicado en 1976 en DDJ.

En 1975 Microsoft (entón constaba de dúas persoas: Bill Gates e Paul Allen) lanzou Altair BASIC. Logo comezaron a aparecer baixo licenza versións para outras plataformas, e millóns de copias e variantes pronto estarían en uso. Converteuse nun das linguaxes estándar na Apple II. Para 1979 Microsoft estaba negociando con varios vendedores de microcomputadores, incluíndo a IBM, para licenciar un intérprete de BASIC para os seus computadores. Unha versión #incluír\\\\+se\\\\\\ nos chips ROM das PCs IBM, para PCs sen discos, e nas que dispuñan de unidade de diskettes o BASIC era iniciado automaticamente se é que non se colocaba ningún diskette de arranque de sistema operativo.

Mentres que as novas compañías intentaban seguir os pasos do éxito de Altair, IMSAI, North Star, e Apple, creando a revolución da computadora caseira. BASIC converteuse nunha característica estándar para case todas as computadores caseiras; a maioría viña cun intérprete de BASIC en ROM (algo feito por primeira vez pola Commodore PET en 1977). Pronto había moitos millóns de computadores correndo BASIC ao redor do mundo, un número moito máis grande que o de todos os usuarios doutras linguaxes xuntas. Moitos programas, especialmente os da Apple II e IBM PC, dependían da presenza do intérprete de BASIC de Microsoft e non correrían sen este; polo que Microsoft usou a licenza de copyright nos intérpretes de BASIC para influír nas negociacións cos vendedores de computadores.

O BASIC foi tamén a linguaxe prefixada nos computadores caseiros europeos da década dos 80 como o ZX Spectrum, Amstrad CPC, MSX ou o Commodore 64, facendo moitas veces a función de intérprete e sistema operativo primitivo xa que viñan implementados en ROM.

### Madurez

Neste período creáronse versións de BASIC novas e máis poderosas. Microsoft vendeu varias versións de BASIC para MS-DOS/PC-DOS, incluíndo BASICA, GW-BASIC (unha versión compatible con BASICA que non necesitaba a ROM de IBM), e Quick BASIC. O fabricante de Turbo Pascal, Borland, publicou Turbo BASIC 1.0 en 1985 (versións sucesoras aínda se venden baixo o nome de PowerBASIC por outra compañía). Apareceron varias extensións de BASIC para computadores caseiras, tipicamente con gráficos, son, e comandos DOS, así como facilidades para Programación estruturada. Outras linguaxes usan a sintaxe de BASIC como base para outros sistemas totalmente diferentes, por exemplo GRASS.

Con todo a finais da década de 1980 as computadores novas eran moito máis complexas, e incluían características (como a Interface gráfica de usuario) que facían a BASIC menos apropiado para programalas. Ao mesmo tempo as computadores progresaban de ser un interese para afeccionados a ferramentas usadas principalmente para executar aplicacións escritas por outros, e a programación en si foise facendo menos importante para unha crecente maioría de usuarios. BASIC comezou a desvanecerse, aínda que numerosas versións aínda estaban dispoñibles.

A sorte de BASIC deu un xiro novamente coa introdución de Visual Basic de Microsoft. Aínda que é algo difícil considerar esta linguaxe como BASIC (a pesar de que usa moitas palabras clave coñecidas de BASIC) converteuse nun das linguaxes máis usadas na plataforma Windows, e dise que representa do 70 ao 80% do desenvolvemento comercial de aplicacións. Visual Basic for Applications (VBA) foi engadido a Microsoft Excel 5.0 en 1993 e ao resto da liña de produtos de Microsoft Office en 1997. Windows 98 incluíu un intérprete de VBScript. A versión máis recente de Visual Basic é chamada VB.NET. A suite OpenOffice.org inclúe unha variante de BASIC menos poderosa que a súa contraparte de Microsoft.

A Linguaxe
----------

### Sintaxe

Unha sintaxe moi mínima de BASIC só necesita os comandos LET, PRINT, IF e GOTO. Un intérprete que executa programas con esta sintaxe mínima non necesita unha pila. Algunhas das primeiras implementaciones eran así de simples. Se se lle agrega unha pila, pódense agregar tamén ciclos FOR aniñados e o comando GOSUB. Un intérprete de BASIC con estas características necesita que o código teña números de liña.

Os dialectos modernos de BASIC MIUN abandonaron os números de liña, e a maioría (ou todos) engadiron control de fluxo estruturado e os construtores de declaración de datos como os doutras linguaxes como C e Pascal:

* do
* loop
* while
* until
* exit
* on... goto
* gosub
* switch
* case

Variantes recentes como Visual Basic introduciron características orientadas a obxectos, e ata herdanza na última versión. A administración de memoria é máis fácil que con moitos outras linguaxes de programación procedimentais debido ao colector de lixo (a costas da velocidade de execución).

### Procedementos e Control de Fluxo

BASIC non ten unha biblioteca externa estándar como outras linguaxes como C. En cambio, o intérprete (ou compilador) contén unha biblioteca incorporada de procedementos intrínsecos. Estes procedementos inclúen a maioría das ferramentas que un programador necesita para aprender a programar e escribir aplicacións sinxelas, así como funcións para realizar cálculos matemáticos, manexar cadeas, entrada da consola, gráficos e manipulación de arquivos.

Algúns dialectos de BASIC non permiten que os programadores escriban os seus propios procedementos. Os programadores en cambio deben escribir os seus programas cun gran número de enunciados GOTO para facer as ramificacións do programa. Isto pode producir un código fonte moi confuso, comunmente referido como *Código espagueti*. Os enunciados GOSUB ramifican o programa a unha especie de subrutinas sen parámetros ou variables locais. A maioría das versións de BASIC modernas, como Microsoft QuickBASIC engadiron soporte completo para subrutinas, funcións e programación estruturada. Este é outro área onde BASIC difire doutras moitas linguaxes de programación. BASIC, como Pascal, fai unha distinción entre un procedemento que non devolve un valor (chamado subrutina) e un procedemento que o fai (chamado función). Moitos outras linguaxes (como C) non fan esa distinción e consideran todo como unha función (algunhas que devolven un valor "*void*" [baleiro]).

Mentres que as funcións que devolven un valor son unha adición relativamente recente aos dialectos de BASIC, moitos dos primeiros sistemas soportaban a definición de funcións matemáticas en liña, con DEF FN ("*Define FunctioN*" [Definir FUNCIÓN]). O Dartmouth BASIC orixinal tamén soportaba funcións ao estilo de Algol, así como subrutinas desde os seus primeiros tempos.

### Tipos de Datos

BASIC é recoñecido por ter moi boas funcións para manipular cadeas. Os primeiros dialectos xa tiñan un xogo de funcións fundamentais (LEFT$, MID$, RIGHT$) para manipular cadeas facilmente. Como as cadeas son utilizadas en aplicacións diarias, esta era unha vantaxe considerable sobre outras linguaxes ao momento da súa introdución.

O Dartmouth BASIC orixinal soportaba unicamente datos de tipo numérico e cadeas. Non había un tipo enteiro. Todas as variables numéricas eran de punto flotante. As cadeas eran de tamaño dinámico. Os arranxos de ambos, números e cadeas, eran soportados, así como matrices (arranxos de dúas dimensións).

Cada dialecto moderno de BASIC posúe polo menos os tipos de datos enteiro e cadea. Os tipos de datos son xeralmente distinguidos por un posfixo, os identificadores de cadeas terminan con (signo $ de dólar), mentres que os enteiros non o fan. Nalgúns dialectos, as variables deben ser declaradas (con DIM) antes de usarse; outros dialectos non o requiren, pero teñen a opción para facelo (tipicamente usando unha directiva como OPTION EXPLICIT). Moitos dialectos tamén soportan tipos adicionais, como enteiros de 16 e 32 bits e números de punto flotante. Adicionalmente algúns permiten a utilización de tipos definidos polo usuario, similar aos "records" de Pascal, ou as "structs" de C.

A maioría dos dialectos de BASIC ademais dos arranxos de tipos primitivos, tamén soportan arranxos outros tipos. Nalgúns, os arranxos deben ser declarados antes de que poidan usarse (co enunciado DIM). É común tamén o soporte para arranxos de dous e máis dimensións.

```
DIM miArregloDeEnteros(100) AS INTEGER
DIM miListaDeNombres(50) AS STRING
```

Dependendo do dialecto de BASIC e do uso do enunciado OPTION BASE, os valores poden estar no rango miArregloDeEnteros(0) a miArregloDeEnteros(100), de miArregloDeEnteros(1) a miArregloDeEnteros(100), ou de miArregloDeEnteros(LimiteInferior) a miArregloDeEnteros(LimiteSuperior).

As

Dispoñibilidade e variantes do dialecto
---------------------------------------

BASIC está dispoñible para case todas as plataformas de microprocesador existentes. Unha posta en funcionamento gratuíta que cumpre con estándares e é multiplataforma é Bywater BASIC (bwBASIC). O intérprete está escrito en C e vén baixo a licenza GNU. Está deseñado para programas de consola de texto, así que non inclúe soporte para crear interfaces gráficas de usuario (GUIs). Un BASIC gratuíto que inclúe soporte para GUI, é similar a Visual Basic e execútase en Windows e Linux é Phoenix Object Basic.

As versións de compiladores máis coñecidos son a liña de produtos de Quick BASIC de Microsoft, e QBASIC (unha versión que non xera programas executables). Algunhas versións de Visual Basic tamén son compiladores, aínda que Microsoft mantivo a Visual Basic polo menos minimamente compatible con ata as primeiras versións das súas BASICs.

Outras versións inclúen PowerBASIC de PowerBASIC, así como True BASIC de True BASIC, que cumpre cos últimos estándares oficiais de BASIC. (True BASIC Inc. foi fundada polos creadores orixinais de Dartmouth BASIC.)

REALbasic é unha variante dispoñible para Mac Os Classic, Mac VOS X, Microsoft Windows e Linux. Unha variante dun dialecto simple de BASIC para a parrot virtual machine mostra como se pon en funcionamento un intérprete de BASIC nunha linguaxe parecida ao ensamblador. SmallBASIC é un dialecto que corre en moitas plataformas (Win32, DÚAS, Linux e PALMOS) e vén baixo a licenza GNU (GPL).

Os microcontroladoré tamén dispón das súas propias versións de BASIC.

Exemplos
--------

### Exemplo 1: Saúdo

```
 PRINT "Ola"

```

### Exemplo 2: BASIC orixinal non estruturado (Applesoft BASIC)

```
 10 INPUT "¿Cal é o seu nome? "; U$
 20 PRINT "Ola "; U$
 30 INPUT "¿Cantos asteriscos desexa? "; N
 35 S$ = ""
 40 FOR I = 1 TO N
 50 S$ = S$ + "*"
 55 NEXT I
 60 PRINT S$
 70 INPUT "¿Desexa máis asteriscos? "; A$
 80 IF LEN(A )$= 0 GOTO 70
 90 A =$ LEFT(A ,$1)
100 IF (A =$ "S") OR (A =$ "s") THEN GOTO 30
110 PRINT "Adeus ";
120 FOR I = 1 TO 200
130 PRINT Ou$; "";
140 NEXT I
150 PRINT

```

### Exemplo 3: BASIC estruturado moderno

```
INPUT "¿Cal é o seu nome?"; NomeUsuario$
PRINT "Ola "; NombreUsuario$
DO
   INPUT "¿Cantos asteriscos desexa?"; NoAsteriscos
   Asteriscos$ = ""
   Asteriscos$ = REPEAT
   PRINT Asteriscos$
   DO
      INPUT "¿Desexa máis asteriscos?"; Resposta$
   LOOP UNTIL Resposta$ <> ""
LOOP WHILE UCASE = "S"
PRINT "Adeus";
FOR I = 1 TO 200
   PRINT NombreUsuario$; "";
NEXT I
PRINT

```

Notas
-----

1. ↑  Por correspondencia con Thomas E. Kurtz.
2. ↑  Nun artigo de 1968 Edsger Dijkstra consideraba que as linguaxes de programación que usaban sentenzas GOTO para estruturar un programa eran nocivos para a produtividade do programador, e para a calidade do código resultante (*Comunications of the ACM* Volume 11, 147-148. 1968). Este artigo non menciona ningunha linguaxe de programación en particular. Unicamente menciona que o uso excesivo de GOTO é algo malo, e proporciona as razóns técnicas polas que isto é así.

Véxase tamén
------------

### Ligazóns externas

* Inline::Basic, módulo de Perl en CPAN para programar en Basic dentro de programas Perl (en inglés).

| * v
* c
* e
Linguaxes de programación |
| --- |
| Baixo nivel | 

|  |  |
| --- | --- |
| Primeira xeración | Código máquina |
| Segunda xeración | Assembly |

 |
| Alto nivel | 

|  |  |
| --- | --- |
| Terceira xeración | 
* A+
* ABC
* Algol
* B
* BASIC
* C
* C++
* C#
* COBOL
* CPL
* D
* E
* Fortran
* Go
* Java
* JavaScript
* Lisp
* Objective-C
* PL/1
* Pascal
* Smalltalk
* Visual Basic .NET

 |
| Cuarta xeración | 
* Clarion
* Clipper
* Clojure
* Common Lisp
* Erlang
* GNU Octave
* Haskell
* Lisp
* Lua
* Julia
* Perl
* PHP
* Prolog
* Python
* R
* Ruby
* Rust
* S
* Scilab
* Stata
* SQL

 |
| Quinta xeración | 
* Mercury
* OPS5
* Prolog

 |

 |
| 
* Ambiente de desenvolvemento
* Metaprogramación
* Programación a nivel funcional
* Programación estruturada
* Programación non estruturada
* Programación imperativa
* Programación modular
* Programación multidimensional
* Orientación a obxectos

 |

|  |  |
| --- | --- |
| Control de autoridades | 
* Wd: Q42979
* BNF: 11939574k
* EBID: ID
* GND: 4004624-2
* LCCN: sh85012076
* MAG: 2780323391
* NKC: ph117376
* PSH: 12484
* SUDOC: 027330176

 |