J (lenguaje de programación)

De Wikipedia, la enciclopedia libre
Saltar a: navegación, búsqueda

El lenguaje de programación J, diseñado por Kenneth Iverson y Roger Hui en los '90, es una síntesis de los lenguajes de programación APL (diseñado también por Iverson) y los lenguajes funcionales FP y FL creados por John Backus (famoso por FORTRAN, ALGOL y BNF).

Para eliminar el problema generado por el uso de un juego de caracteres especiales en APL, J sólo requiere el juego de caracteres básicos ASCII. Se usan tanto el punto como los dos puntos para extender el significado del juego de caracteres disponible.

Dado que se trata de un lenguaje de programación de array, J es muy conciso y potente, y es útil para crear programas en los campos de las matemáticas y de la estadística, especialmente cuando involucran operaciones con matrices.

De la misma manera que los lenguajes FP/FL, J soporta Programación a nivel de funciones (también conocida como programación funcional de alto orden), gracias a sus características de programación tácita (nótese que la programación a nivel de funciones no es lo mismo que programación funcional).

A diferencia de muchos lenguajes que soportan la programación orientada a objetos, el flexible esquema de espacio de nombres jerárquico del lenguaje J (donde cada nombre existe en un ámbito particular) puede ser usado con efectividad como un marco de trabajo para realizar programación orientada a objetos basada tanto en clases, como en instancias.

J es un lenguaje de programación no von Neumanniano, que sin embargo permite que el programador use el estilo de programación von Neumann a conveniencia.

Nótese que el lenguaje de programación J no está relacionado con J++, ni su nueva versión J# (una versión propietaria del Lenguaje de programación Java desarrollada por Microsoft).

Ejemplos[editar]

J es un lenguaje de programación extremadamente potente, y sus programas pueden ser muy tersos, pero incluso más crípticos.

El programa 'Hola Mundo' en J es:

   'Hola Mundo'

Esta implementación de 'Hola Mundo' refleja el uso tradicional de J -- los programas son introducidos durante una sesión del intérprete J, y los resultados de las expresiones se muestran de modo interactivo. También es posible hacer que scripts en J se puedan ejecutar como programas independientes, pero los mecanismos usados para asociar el script con el intérprete son dependientes del sistema. En un sistema Unix, se podría hacer como sigue:

  #!/bin/jc
  echo 'Hello, world!'
  exit ''

Sin embargo, estos mecanismos no son usados por muchos programadores expertos de J.

A continuación se muestra un programa J que calcula la media de una lista de números:

      avg =. +/ % #
      avg 1 2 3 4
  2.5

'#' - cuenta el número de elementos en la cadena. '+/' - suma todos los elementos de la cadena. '%' - divide la suma de los elementos por el número de elementos.

Ahora generaremos algunos números aleatorios y calcularemos su media:

     a =. ?20$100
     a
  31 16 60 64 64 71 13 3 76 26 25 77 68 48 42 91 99 97 99 9
     avg a
  53.95
  

Sigue una implementación del algoritmo quicksort, sacada del diccionario de funciones de J:

sel=: adverb def 'x. # ['

quicksort=: verb define
 if. 1 >: #y. do. y.
 else. 
  (quicksort y. <sel e),(y. =sel e), quicksort y. >sel e=.y.{~?#y.
 end.
)

La siguiente expresión (Roger Hui) calcula los primeros n dígitos de pi, y demuestra la capacidad de J de usar precisión extendida:

 n=.50                                           NB. asigna a n el número de dígitos requerido.
 <.@o. 10x^n                                     NB. precisión extendida 10^nth * pi
314159265358979323846264338327950288419716939937510

Puede encontrar también una implementación en J del Juego de la vida de Conway en http://ww2.lafayette.edu/~reiterc/j/vector/vlife_index.html

Estructuras y Tipos de Datos[editar]

J soporta tres tipos de datos simples:

  • Numérico
  • Literal (Carácter)
  • Empotrado

El tipo numérico es el que más variantes tiene de todos ellos.

Uno de los tipos numéricos de J es el bit. Existen dos valores en este tipo: 0 y 1. Además, varios bits pueden formar una lista. Por ejemplo, 1 0 1 0 1 1 0 0 es una lista de ocho bits. Sintácticamente, el parser de J los trata como una única palabra (los caracteres espacio se reconocen como formadores de palabras cuando están situados entre lo que serían palabras numéricas de forma individual). J soporta listas de longitud arbitraria.

Además, J soporta todas las operaciones habituales sobre estas listas, tales como y, o, o exclusivo, rotación, traslación, no, etc. Por ejemplo,

   1 0 0 1 0 0 1 0 +. 0 1 0 1 1 0 1 0     NB. ó
1 1 0 1 1 0 1 0
   3 |. 1 0 1 1 0 0 1 1 1 1 1             NB. rotación
1 0 0 1 1 1 1 1 1 0 1

Nótese que J también soporta arrays de bits de orden mayor -- es decir, se pueden formar arrays bidimensionales, tridimensionales, etc. Las operaciones descritas arriba se ejecutan de igual manera sobre estos arrays.

Otros tipos numéricos incluyen entero (3, 42), punto flotante (3.14, 8.8e22), complejo (0j1, 2.5j3e88), entero de precisión extendida (12345678901234567890x), y fracción racional (de precisión extendida) (1r2, 3r4). De igual forma que pasaba con los bits, pueden formarse tanto listas como arrays de un número arbitrario de dimensiones. También de forma similar, las operaciones sobre el array se ejecutan sobre todos los números contenidos en el array.

Las listas de bits pueden ser convertidas en enteros usando el verbo #. Los enteros pueden ser convertidos en listas de bits usando el verbo #:. (Durante el análisis sintáctico, J interpreta . y : como caracteres que forman palabras. Nunca los considera elementos por sí mismos salvo que estén precedidos por un espacio blanco).

J también soporta el tipo literal (carácter). Los literales se encierran entre comillas simples, por ejemplo 'a' ó 'b'. J soporta también listas de literales usando la convención habitual de poner una secuencia de caracteres entre comillas simples, por ejemplo 'abcdefg'. Típicamente, los literales individuales tienen 8 bits (ASCII), pero J también soporta otros tipos de literales (Unicode). Los operadores numéricos y booleanos no están soportados sobre los literales, pero las operaciones sobre colecciones (tales como la rotación) sí que lo están.

Por último, existe el tipo empotrado. Típicamente, los datos se empotran usando la operación < (sin ningún argumento a la izquierda -- si hay un argumento a la izquierda, este carácter se interpreta como la operación 'menor que'). Es análogo a la operación & del C (sin argumento a la izquierda). Sin embargo, los resultados del operador de C & tienen semántica de referencia, minetras que el resultado de la operación < de J tienen semántica de copia. Dicho de otro modo, < es una función y produce un resultado. El resultado tiene 0 dimensiones, a pesar de la estructura de los datos que contiene. Desde el punto de vista de un programador en J, < 'pone los datos en una caja' y permite al programador trabajar con arrays de cajas (que pueden ensamblarse con otras cajas, y/o se pueden hacer copias adicionales de la caja). El intérprete de J muestra los datos empotrados de forma similar a la que un intérprete de SQL podría decorar los resultados de un comando select.

   <1 0 0 1 0
+---------+
|1 0 0 1 0|
+---------+

El único tipo colección ofrecido por J es el array arbitrariamente dimensionado. La mayor parte de los algoritmos pueden expresarse de forma muy concisa usando operaciones sobre estos arrays.

Los arrays en J están homogéneamente tipados, por ejemplo la lista 1 2 3 se considera una lista de enteros, a pesar de que 1 es un bit. Normalmente estos asuntos son transparentes para el programados. Sólo ciertas operaciones especializadas revelan las diferencias en el tipo. Por ejemplo, la mayor parte de las operaciones tratarían de igual forma las listas 1.0 0.0 1.0 0.0 y 1 0 1 0.

J también soporta arrays numéricos dispersos, donde los valores no nulos son almacenados con sus índices. Este mecanismo es eficiente cuando relativamente pocos valores son no nulos.

J también soporta objetos y clases, pero son artefactos en la forma en que se nombran las cosas, y no son tipos de datos por sí mismos. Se suelen usar literales empotrados para referirse a objectos (y a clases). Los datos en J tienen semántica de copia, pero los objetos y clases necesitan que el lenguaje soporte semántica de referencia.

Otro pseudo-tipo -- asociado con nombre, en lugar de con valor -- es el fichero mapeado a memoria.


Diccionario[editar]


La documentación de J está organizada como un diccionario, con palabras en J identificadas como sustantivos, verbos, adverbios, conjunciones, etc. Las diversas partes de un programa se indican usando markup: nombres verbos, y varios adverbios, y conjunciones. Nótese que los verbos tienen dos formas -- unarios (con argumentos sólo a la derecha), y binarios (con argumentos a la izquierda y a la derecha). Por ejemplo, en '-1' el operador - es unario, y en '3-2' el operador - es binario. La definición de un operador unario es casi independiente de la definición del operador binario, sin importar si el verbo es primitivo ó derivado.

Vocabulario[editar]

Constantes
Controles
Foreigns
Partes de un programa
= Self-Classify • Equal =. Is (Local) =: Is (Global)
< Box • Less Than <. Floor • Lesser Of (Min) <: Decrement • Less Or Equal
> Open • Larger Than >. Ceiling • Larger of (Max) >: Increment • Larger Or Equal
_ Negative Sign / Infinity _. Indeterminate _: Infinity
 
+ Conjugate • Plus +. Real / Imaginary • GCD (Or) +: Double • Not-Or
* Signum • Times *. Length/Angle • LCM (And) *: Square • Not-And
- Negate • Minus -. Not • Less -: Halve • Match
% Reciprocal • Divide %. Matrix Inverse • Matrix Divide %: Square Root • Root
 
^ Exponential • Power ^. Natural Log • Logarithm ^: Power
$ Shape Of • Shape $. Sparse $: Self-Reference
~ Reflex • Passive / EVOKE ~. Nub • ~: Nub Sieve • Not-Equal
| Magnitude • Residue |. Reverse • Rotate (Shift) |: Transpose
 
. Determinant • Dot Product .. Even .: Odd
: Explicit / Monad-Dyad :. Obverse :: Adverse
, Ravel • Append ,. Ravel Items • Stitch ,: Itemize • Laminate
; Raze • Link ;. Cut ;: Word Formation •
 
# Tally • Copy #. Base 2 • Base #: Antibase 2 • Antibase
! Factorial • Out Of !. Fit (Customize) !: Foreign
/ Insert • Table /. Oblique • Key /: Grade Up • Sort
\ Prefix • Infix \. Suffix • Outfix \: Grade Down • Sort
 
[ Same • Left   [: Cap
] Same • Right    
{ Catalogue • From {. Head • Take {: Tail •   {:: Map • Fetch
} Item Amend • Amend }. Behead • Drop }: Curtail •
 
" Rank ". Do • Numbers ": Default Format • Format
` Tie (Gerund)   `: Evoke Gerund
@ Atop @. Agenda @: At
& Bond / Compose &. Under (Dual) &: Appose
&.: Under
? Roll • Deal ?. Roll • Deal (fixed seed)
 
a. Alphabet a: Ace (Boxed Empty) A. Anagram Index • Anagram
b. Boolean / Basic c. Characteristic Values C. Cycle-Direct • Permute
d. Derivative D. Derivative D: Secant Slope
e. Raze In • Member (In) E. • Member of Interval f. Fix
 
H. Hypergeometric i. Integers • Index Of i: Integers • Index Of Last
j. Imaginary • Complex L. Level Of L: Level At
m. n. Explicit Noun Args NB. Comment o. Pi Times • Circle Function
p. Polynomial p.. Poly. Deriv. • Poly. Integral p: Primes •
 
q: Prime Factors • Prime Exponents r. Angle • Polar s: Symbol
S: Spread t. Taylor Coefficient t: Weighted Taylor
T. Taylor Approximation u. v. Explicit Verb Args u: Unicode
x. y. Explicit Arguments x: Extended Precision _9: to 9: Constant Functions


Véase también[editar]

Enlaces externos[editar]