Skip to main content

Catálogo de lenguajes de programación

A la vista de que al menos en HxC el problema de con que lenguaje de programación comenzar es algo recurrente, me he decidido a hacer una recopilación de mini programas en distintos lenguajes para que quien comience pueda encontrar facilmente uno que se acerce a su forma de ver las soluciones de los problemas (personalmente creo que es un buen criterio para escojer un primer lenguaje).

Para no quedarse en los 4 de siempre me he tomado la libertad en escojer unos cuantos lenguajes que no suelen tener tanta visibilidad (sin ser tipo brainf*ck), he intentado también ser todo lo imparcial posible pero como humano que soy eso no es algo que suela salir bien ;).

Por ahora contiene alrededor de 30 lenguajes, pero solo un código de cada uno, así que aún queda mucho por andar, los códigos serían:

  • Uno que calcule un número de la secuencia de fibonacci y lo muestre por pantalla indicando el índice y el número (me parece que es simple y da una buena visión de como se ve el lenguaje). (este es el ejemplo que ya está programado).

  • Otro que muestre los tipos basicos de datos, los comentarios, que muestre como crear una estructura a partir de los tipos basicos y como crear una clase (si es posible).

  • Condicionales, bucles, y subrutinas.

Y seguramente uno o dos más que estan sin decidir.

Nota: Este es un trabajo en curso, cualquier aportación es enormemente bienvenida. Todo el código se encuentra bajo la licencia WTFPL en este repositorio [ https://gitlab.com/kenkeiras/language-catalog ]. Además todos los lenguajes que se encuentran aquí disponen de algún intérprete o compilador libre.

A+

A+ es un lenguaje de programación de arrays descendiente del lenguaje A, diseñado este para sustituir a APL, fue diseñado para programas con muy centradas en los números, especialmente para las aplicaciones financieras.

Como curiosidad comentar que el lenguaje suele utilizarse con un editor y una fuente especiales, lo que permite escribir código casi como ecuaciones matemáticas, aunque también es posible sustituir los símbolos por caracteres ASCII, como en el ejemplo. fibonacci recursivo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
$mode ascii

fibonacci n: if (n < 2) n else (fibonacci(n - 1)) + (fibonacci(n - 2))

numero := 10
resultado := fibonacci numero

'<Elemento nº >,I2,< de fibonacci: >,I5' _fmt (numero; resultado)

sys.exit 0

Ada

Ada es un lenguaje orientado a objetos y concurrente diseñado por encargo del Departamente de Defensa de los EEUU, se utiliza principalmente en entornos que requiren mucha seguridad y fiabilidad. fibonacci recursivo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
with Ada.Text_IO, Ada.Integer_Text_IO;
use Ada.Text_IO, Ada.Integer_Text_IO;

procedure Fibonacci_Recursivo is
    function Fibonacci(n : in Integer) return Integer is
    begin
            if n < 2 then
                return n;
            else
                return Fibonacci(n - 1) + Fibonacci(n - 2);
            end if;
    end Fibonacci;


    Numero : Integer := 10;
    Resultado : Integer := Fibonacci(Numero);

begin

    Put_Line(Item => "Elemento nº" & Integer'Image (Numero) &
                     " de fibonacci:" & Integer'Image(Resultado));

end Fibonacci_Recursivo;

Assembler (ensamblador)

El lenguaje ensamblador es el lenguaje más cercano a la máquina, sus códigos se traducen directamente a binario, lo que permite un control total sobre las operaciones dando la posibilidad de afinarlo para obtener el mejor rendimiento a costa de no tener ninguna capa de abstracción.

Una consecuencia lógica es que el código no es portable entre sistemas operativos ni distintas arquitecturas de procesador, el ejemplo se probó en Gnu/Linux en un x86, ensamblado con NASM. (por comodidad utiliza la librería de C para mostrar el resultado por pantalla) fibonacci_recursivo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
[bits 32]
section .data
    numero: dd 10
    format_string: db 'Elemento nº %i de fibonacci: %i', 10, 0

section .text

global main
extern printf

; pasaremos el parametro por eax
fibonacci:
    ; solo hay cambios si eax es menor que 2
    cmp eax, 2
    jl .fibonacci_done

    ; Si n >= 2
    ;  a = fibonacci(n - 1)
    push dword eax ; guardamos n
    dec eax        ; le restamos 1
    call fibonacci ; llamamos a fibonacci
pop ebx        ; recuperamos el original en ebx

;  b = fibonacci(n - 2)
push eax       ; guardamos fibonacci(n - 1)
mov eax, ebx   ; pasamos el original a eax
sub eax, 2     ; le restamos 2
call fibonacci ; llamamos a fibonacci
pop ebx        ; recuperamos el original

; a + b
add eax, ebx   ; y los sumamos

fibonacci_done:
ret


main:
    mov eax, [numero]
    call fibonacci

    ; a C los parametros se le pasan al reves
    push dword eax            ; resultado
    push dword [numero]       ; numero
    push dword format_string  ; "Elemento nº %i de fibonacci: %i\n"
    call printf

    ; exit_syscall, se llama al kernel para salir
       mov eax, 1
    mov ebx, 0
    int 0x80

Bash

Bash es realmente un lenguaje de intérprete de comandos, por ello no es un lenguaje prominente en la manipulación de datos, en cambio si el problema se puede resolver encadenando otros programas se convierte en una solución extremadamente potente.

Es importante tener en cuenta que Bash es el shell por defecto en la mayoría de sistemas GNU/Linux, además de Mac OS X Tiger, y puede ejecutarse en la mayoría de los sistemas operativos tipo UNIX. También se ha portado a Microsoft Windows por el proyecto Cygwin. (Wikipedia). fibonacci_recursivo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
fibonacci(){
    if [ $1 -lt 2 ];then
        echo $1;
    else
        echo $(( `fibonacci $(( $1 - 1 ))` + `fibonacci $(( $1 - 2 ))` ));
    fi
}

numero=10
resultado=`fibonacci $numero`

echo "Numero $numero de fibonacci: $resultado"

BASIC

BASIC es un lenguaje de progamación estructurado diseñado en los '60 como una herramienta de enseñanza para los principiantes. Fue una vez un lenguaje importante en la programación sobre Windows, pero últimamente está siendo desplazado poco a poco por C#.

El lenguaje sufrió una cierta fragmentación, el ejemplo esta probado con Yabasic. fibonacci recursivo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
sub fibonacci(n)
  if n < 2 then 
      return n
  else 
      return (fibonacci(n - 1) + fibonacci(n - 2))
  endif
end sub

numero = 10
resultado = fibonacci(numero)

print "Elemento nº ", numero, " de fibonacci: ", resultado

C

C es un lenguaje de programación que a diferencia del resto de los que se presentan aquí, considerados de alto nivel, se observa como de medio nivel ya que aunque presenta construcciones propias de lenguajes de alto nivel también permite ejercer un contro de bajo nivel.

Es uno de los lenguajes más utilizados en la programación de entornos Unix, y el lenguaje de facto en el desarrollo de sistemas operativos. fibonacci recursivo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>

int fibonacci(int n){
    if (n < 2){
        return n;
    }
    else{
        return fibonacci(n - 1) + fibonacci(n - 2);
    }
}

int main(){
    int numero = 10;
    int resultado = fibonacci(numero);

    printf("Elemento nº %i de fibonacci: %i\n", numero, resultado);

    return 0;
}

C#  

C# es un lenguaje orientado a objetos desarrollado por Microsoft para la plataforma .NET. Es un lenguaje en el que se puede observar la sintaxis de la familia C y el modelo fuertemente orientado a objetos de Java. Existe una implementación libre que permite ejecutar el código C# sobre distintos sistemas operativos, Mono. fibonacci recursivo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;

class Program{

    static int fibonacci(int n){
        if (n < 2){
            return n;
        }
        else{
            return fibonacci(n - 1) + fibonacci(n - 2);
        }
    }

    static void Main(){
        int numero = 10;
        int resultado = fibonacci(numero);
        Console.Write("Elemento nº ");
        Console.Write(numero);
        Console.Write(" de fibonacci: ");
        Console.WriteLine(resultado);
    }
}

Common Lisp

Common Lisp no es realmente un lenguaje de programación, sinó una especificación que estandariza el lenguaje Lisp, normalmente utilizado en la investigación de IA y el desarrollo rápido de aplicaciones.

Como anécdota sobre la potencia del debugger de Lisp se cuenta el caso de la sonda Deep Space 1 donde un programa en Lisp controlaba una secuencia de experimentos, y medio año después del lanzamiento, a 160 millones de Kilometros de la Tierra, un equipo fue capaz de diagnosticar y corregir sobre la marcha un escurridizo fallo que no había aparecido durante las pruebas en la tierra. Practical Common Lisp. fibonacci recursivo

1
2
3
4
5
6
7
8
(defun fibonacci (n)
  (if (< n 2)
      n
      (+ (fibonacci (- n 1)) (fibonacci (- n 2)))))

(defvar numero 10)
(defvar resultado (fibonacci numero))
(format t "Numero ~D de fibonacci: ~D~%" numero resultado)

Dart

Dart es un lenguaje de programación estructurado diseñado por Google como un lenguaje de programación web en el lado del cliente, como un intento de actualizar el panorama de la programación web en el cliente dominado por Javascript.

Es un lenguaje que aunque aún no ha sido implementado en ningún navegador (excepto quizá chrome), pero puede ser convertido a código Javascript. fibonacci_recursivo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
int fibonacci(int n) {
    if (n < 2){
        return n;
    }
    else{
        return fibonacci(n - 1) + fibonacci(n - 2);
    }
}

main() {
  int numero = 10;
  int resultado = fibonacci(numero);
  // ó print('Elemento nº ${numero} de fibonacci: ${fibonacci(numero)');
  print('Elemento nº ${numero} de fibonacci: ${resultado}');
}

Erlang

Erlang es un lenguaje de programación concurrente desarrollado por Ericsson para realizar aplicaciones distribuidas, tolerantes a fallos, soft-real-time y de funcionamiento ininterrumpido. (Wikipedia).

Es un lenguaje funcional, un paradigma que pretende acercarse a la lógica formal a través de variables no mutables ('X' siempre tiene el mismo valor) y evitar funciones con efectos secundarios (que la llamada a una función tenga algun efecto en el programa mas que el valor que devuelve). fibonacci recursivo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
-module(fibonacci_recursivo).
-export([start/0, fibonacci/1]).

fibonacci(0) -> 0;
fibonacci(1) -> 1;
fibonacci(N) -> fibonacci(N - 1) + fibonacci(N - 2).


start() -> 
     Numero = 10,
     Resultado = fibonacci(Numero),
     io:format("Elemento nº ~p de fibonacci: ~p~n", [Numero, Resultado]).

Factor

Factor es un lenguaje de programación orientado a pila, esto es: para hacer una operación se introducen los datos en una pila global y después se llama a una función, por ejemplo para sumar dos números haríamos '10 20 +', añadiendo primero el 10 a la pila, después el 20 y a continuación llamando a la operación suma.

Aunque realmente es posible hacer operaciones con datos sin seguir ese esquema a través de llamadas a funciones o dentro de una misma función. fibonacci recursivohttps://gitlab.com/kenkeiras/language-catalog/blob/master/factor/fibonacci_recursivo.factor)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
USING: kernel math formatting ;
IN: fibonacci_recursivo

: fibonacci ( int -- int ) dup 2 < [ [ 1 - fibonacci ] [ 2 - fibonacci ] bi + ] unless ;

10
dup
fibonacci

"Elemento nº %d de fibonacci: %d" printf

FORTRAN

Fortran es un lenguaje de programación que pone especial énfasis en el cálculo numérico, fue uno de los primeros lenguajes de programación que no se limitó a poner mnemónicos a instrucciones del procesador.

Fortran se utiliza en la programación de alto rendimiento y los test de rendimiento de los supercomputadores. fibonacci recursivo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
! Escrito para Fortran 95
PROGRAM fibonacci_recursivo
    IMPLICIT NONE
    INTEGER :: numero = 10, resultado
    resultado = fibonacci(numero)

    PRINT *, "Elemento nº ", numero, " de fibonacci: ", resultado

CONTAINS

RECURSIVE FUNCTION fibonacci(n) RESULT (r)
    INTEGER :: n, r

    IF (n < 2) THEN
        r = n
    ELSE
        r = fibonacci(n - 1) + fibonacci(n - 2)
    END IF
END FUNCTION fibonacci

END PROGRAM fibonacci_recursivo

Genie

Genie es un lenguaje desarrollado por el proyecto GNOME como un dialecto más simple y limpio para el compilador de vala, manteniendo las funcionalidades de ese lenguaje.

Dado que Genie es fundamentalmente una representación alternativa del código vala, se pueden usar funciones, clases y demás de uno en el otro. fibonacci recursivo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
def fibonacci(n: int): int
    if n < 2 do
        return n
    else
        return fibonacci(n - 1) + fibonacci(n - 2)

init
    var numero = 10
    var resultado = fibonacci(numero)
    print "Elemento nº %i de fibonacci: %i", numero, resultado

Go

Desarrollado en Google, Go es un lenguaje de programación concurrente pensado para ofrecer la eficiencia de un lenguaje con tipado estático y la facilidad de programación de un lenguaje con tipado dinámico.

Curiosamente utiliza distintos nombres para el compilador y el enlazador según la arquitectura de la CPU. No confundir con el lenguaje Go!. fibonacci recursivo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
package main

import "fmt"

func fibonacci(n int)(r int){
    if (n < 2){
        r = n
    }else{
        r = fibonacci(n - 1) + fibonacci(n - 2)
    }
    return
}

func main() {
    numero := 10
    resultado := fibonacci(numero)
    fmt.Printf("Elemento nº %v de fibonacci: %v\n", numero, resultado)
}

Haskell

Haskell es un lenguaje funcional puro. A pesar de que por su constitucion pueda parecer lo contrario es posible utilizarlo para, por ejemplo, programar gestores de ventanas, como Xmonad. fibonacci recursivo branching sintaxis

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import Text.Printf

fibonacci 0 = 0
fibonacci 1 = 1
fibonacci n = fibonacci(n - 1) + fibonacci (n - 2)

main = do
    let numero = 10
    let resultado = fibonacci numero
    printf "Elemento nº %i de fibonacci: %i\n" (numero::Int) (resultado::Int)

Java

Java es un lenguaje de programación fuertemente orientado a objetos desarrollado por Sun, hasta el punto de que todo en el programa es un objeto. Es un lenguaje que se utiliza para programación de teléfonos móviles, desde los clásicos con Java SE hasta smartphones Android. fibonacci recursivo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
class fibonacci_recursivo{
    static int fibonacci(int n){
        if (n < 2){
            return n;
        }
        else{
            return fibonacci(n - 1) + fibonacci(n - 2);
        }
    }

    public static void main(String argv[]){
        int numero = 10;
        int resultado = fibonacci(numero);

        System.out.println("Elemento nº "+ numero +" de fibonacci: " + resultado);

    }
}

Javascript

Javascript (que no tiene nada que ver con Java, de hecho se llamaba originalmente ECMAscript) es el lenguaje de programación web en lado de cliente, terrento en el que no tiene ningún competidos exceptuando el reciente Dart, que aún está en desarrollo. Además en 2009 comenzó el desarrollo de la ya madura plataforma node.js que permite utilizarlo en una arquitectura orientada a eventos muy práctica para la programación de servidores. fibonacci recursivo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
function fibonacci(n){
    if (n < 2){
        return n;
    }
    else{
        return fibonacci(n - 1) + fibonacci(n - 2);
    }
}

var numero = 10;
var resultado = fibonacci(numero);

// Esto cambia segun el entorno, para webs
//document.write("Elemento nº "+ numero +" de fibonacci: "+resultado+"<br />");

// Para nodejs
process.stdout.write("Elemento nº "+ numero +" de fibonacci: "+resultado+"\n");

Logo

Logo es un lenguaje de programación diseñado como lenguaje de fácil aprendizaje, es especialmente conocido por que soporta de forma estándar los gráficos de tortuga, es decir, permite usar una "tortuga" a la que se le dan una serie de pasos a seguir (Avanza 10, Gira a la derecha, ...) y que deja un trazo como lo haría un lápiz, para hacer dibujos.

Hay varios intérpretes que permiten escribir las instrucciones en otros idiomas a parte del inglés, por ejemplo "Avanza" en vez de "Forward" o "Gira a la derecha" en vez de "Rotate right". fibonacci recursivo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
TO fibonacci :n
    if :n < 2 [output :n]
              output sum fibonacci difference n 2 fibonacci difference n 1
end

make "numero 10
make "resultado fibonacci :numero

print (word "Elemento\ nº\  :numero "\ de\ fibonacci:\  :resultado)

BYE

Lua

Lua es un lenguaje de scripting que por su sencillez se suele utilizar como lenguaje que interpretan los motores de programas grandes como juegos, escritos normalmente en lenguajes de más bajo nivel.

Además se puede utilizar para programar aplicaciones no oficiales en Wii y PSP, el gestor de ventanas AWESOME utiliza sus scripts como archivos de configuración y como lenguaje para extender juegos. (Lua uses). fibonacci recursivo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
function fibonacci(n)
    if n < 2 then
        return n
    else
        return fibonacci(n - 1) + fibonacci(n - 2)
    end
end

numero = 10
resultado = fibonacci(numero)

io.write(string.format("Elemento nº %i de fibonacci: %i\n", numero, resultado))

Objective C

Objective C es un lenguaje de programación orientado a objetos creado como una extension del lenguaje C.

Es el principal lenguaje de programación en Mac OS X e IPhone, pero también es posible utilizarlo en otras plataformas. fibonacci recursivo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
#import <stdio.h>

int fibonacci(int n){
    if (n < 2){
        return n;
    }
    else{
        return fibonacci(n - 1) + fibonacci(n - 2);
    }
}

int main(){
    int numero = 10;
    int resultado = fibonacci(numero);

    printf("Elemento nº %i de fibonacci: %i\n", numero, resultado);

    return 0;
}

Ocaml

Ocaml es un lenguaje de la familia ML que permite los paradigmas de programación funcional, imperativa (se describen los pasos a realizar) y orientado a objetos. fibonacci recursivo

1
2
3
4
5
6
7
let rec fibonacci n = if n < 2 then n
                      else fibonacci (n - 1) + fibonacci(n - 2)
in
let numero = 10 in
let resultado = fibonacci numero in
print_string "Elemento numero "; print_int numero;
print_string " de fibonacci: ";  print_int resultado; print_newline();;

Octave

Octave es un programa y lenguaje de programación de alto nivel diseñado para realizar análisis numérico.

Se puede considerar la alternativa libre a MATLAB, con el que mantiene cierta compatibilidad. fibonacci recursivo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
function ret = fibonacci(n)
   if (n < 2)
      ret = n;
   else
      ret = fibonacci(n - 1) + fibonacci(n - 2);
   end
end

numero = 10;
resultado = fibonacci(numero);
printf("Elemento nº %i de fibonacci: %i\n", numero, resultado);

Pascal

Pascal es un lenguaje de programación estructurado diseñado con el objetivo de crear un lenguaje que facilitase el aprendizaje de la programación.

Hay un cierto número de dialectos bastante compatibles, el compilador utilizado en este ejemplo es FreePascal, pero debería funcionar sobre cualquiera que respete el estándar básico. fibonacci recursivo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
program fibonacci_recursivo;

function fibonacci(n: integer): integer;
    var r: integer;
begin
    if (n < 2) then
        r := n
    else
        r := fibonacci(n - 1) + fibonacci(n - 2);
    fibonacci := r;
end;

var
    numero, resultado: integer;

begin
    numero := 10;
    resultado := fibonacci(numero);
    writeln('Elemento nº ', numero, ' de fibonacci: ', resultado);
end.

Perl

Perl es un lenguaje de scripting desarrollado para la manipulación de textos que provee de una gran flexibilidad. Cuenta con un repositorio de módulos central, CPAN que aloja código para programar compresores, servidores, web, interfaces gráficas, utilidades de red...

Es un lenguaje que ganó fama de ser poco legible precisamente por la libertad que da al programador pero en última instancia la claridad del código depende solo de quien lo escribe. fibonacci recursivo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
sub fibonacci{
    my $n = $_[0];
    if ($n < 2){
        return $n;
    }
    else{
        return fibonacci($n - 1) + fibonacci($n - 2);
    }
}

my $numero = 10;
my $resultado = fibonacci($numero);

print "Elemento nº $numero de fibonacci: $resultado\n";

PHP

PHP es un lenguaje de programación web del lado del servidor (aunque es posible utilizarlo en aplicaciones que no lo sean) siendo uno de los más utilizados, y normalmente el único lenguaje que suelen soportar los alojamientos web gratuitos.

Es un lenguaje especialmente diseñado para poder mezclarse con código HTML de forma cómoda. fibonacci recursivo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
<?php
    function fibonacci($n){
        if ($n < 2){
            return $n;
        }
        else{
            return fibonacci($n - 1) + fibonacci($n - 2);
        }
    }

$numero = 10;
$resultado = fibonacci($numero);

echo "Elemento nº $numero de fibonacci: $resultado\n";
?>

Python/Python3

Python es un lenguaje de programación multiparadigma que puede ser usada como lenguaje de scripting, o para la programación web.

De python suele llamar la atención el hecho de los bloques del programa se definen a través de la indentación (es decir, con espacios en blanco al principio de la línea), al contrario que en otros que se delimitan con simbolos '{', '}' o palabras clave 'begin', 'end', esto hay quien lo considera un estorbo y hay quien piensa que es una buena forma de forzar a escribir código legible. La versión ultima versión, 3, añade unos cambios que no son compatibles hacia atrás. fibonacci recursivo py2 py3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
def fibonacci(n):
    if n < 2:
        return n
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)


numero = 10
resultado = fibonacci(numero)

# En python2
print "Elemento numero", numero, "de fibonacci:", resultado

# En python3
print ("Elemento numero", numero, "de fibonacci:", resultado)

R

R es un entorno y un lenguaje de programación orientado a objetos pensado para el análisis estadístico.

Además el código en R puede ser invocado desde otros lenguajes como Perl y Python. fibonacci recursivo

1
2
3
4
5
6
7
8
9
fibonacci <- function(n){
    return (ifelse (n < 2, n, fibonacci(n - 2) + fibonacci(n - 1)))
}

numero <- 10
resultado <- fibonacci(numero)

s <- sprintf("Elemento nº %i de fibonacci: %i", numero, resultado)
print(s)

Ruby

Ruby es un lenguaje de programación reflexivo y orientado a objetos. Es un lenguaje que ha tomado mucha fuerza en la comunidad de programación web gracias al framework Ruby On Rails. fibonacci recursivo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
def fibonacci(n)
    if n < 2
        return n
    else
        return fibonacci(n - 1) + fibonacci(n - 2)
    end
end

numero = 10
resultado = fibonacci numero

print "Elemento n ", numero, " de fibonacci: ", resultado, "\n"

Scala

Scala es un lenguaje de programación funcional orientado a objetos que funciona sobre la máquina virtual de java. fibonacci recursivo

1
2
3
4
5
6
7
def fibonacci(n: Int): Int = if (n < 2) n
                             else fibonacci(n - 1) + fibonacci(n - 2)

val numero = 10
val resultado = fibonacci(numero)

Console.printf("Elemento nº %s de fibonacci: %s\n", numero, resultado)

Scheme

Scheme es un dialecto minimalista de Lisp.

El estándar de Scheme es realmente minimalista y específico en sí. Ello provoca que existan multitud de implementaciones diferentes, cada una de las cuales introduce extensiones y bibliotecas propias que las hace incompatibles entre sí. Los Scheme Requests for Implementation (SRFI) tratan de poner remedio a este problema. (Wikipedia). fibonacci recursivo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
(define (fibonacci n)
 (if (< n 2)
  n
  (+ (fibonacci (- n 2)) (fibonacci (- n 1)))
 )
)

(define numero 10)
(define resultado (fibonacci numero))

(display "Elemento nº"    )
(display numero           )
(display " de fibonacci: ")
(display resultado        )
(newline                  )

Tcl

Tcl es un lenguaje de scripting utilizado para el desarrollo de prototipos y de interfaces gráficas.

En su momento consiguió cierta popularidad gracias al plugin Expect que permitia automatizar tareas sobre herramientas como FTP, Telnet o SSH. fibonacci recursivo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
proc fibonacci n {
    if { $n < 2 } {
        return $n
    } else {
        return [expr [fibonacci [expr $n - 1]] + [fibonacci [expr $n - 2]]]
    }
}

set numero 10
set resultado [fibonacci $numero]
puts [format "Elemento nº %i de fibonacci: %i" $numero $resultado]

Unicon

Unicon es un lenguaje de programación orientado a objetos de muy alto nivel descendiente de Icon, siendo ambos especiamente útiles para tratar con cadenas de texto. fibonacci recursivo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
procedure fibonacci(n)
    if (n < 2) then
        return n
    else
        return fibonacci(n - 1) + fibonacci(n - 2);
end

procedure main()
    numero := 10
    resultado := fibonacci(numero)
    write( stdout, "Elemento nº ", numero, " de fibonacci: ", resultado)
end

Vala

Vala es un lenguaje orientado a objetos desarrollado por el proyecto GNOME como un lenguaje con las posibilidades de un lenguaje actual sin necesidad de librerías de runtime a mayores que las de C y con un coste adicional mínimo.

Vala se compila a código C, por ello es posible utilizar librerías y recursos escritos en este lenguaje. fibonacci recursivo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
int fibonacci(int n){
    if (n < 2){
        return n;
    }
    else{
        return fibonacci(n - 2) + fibonacci(n - 1);
    }
}

void main(){
     int numero = 10;
     int resultado = fibonacci(numero);

     stdout.printf("Elemento nº %i de fibonacci: %i\n",numero, resultado);
}

Que aproveche ;)

All your buckets are belong to us: DOSsing PHP through associative arrays

Some hours ago I was reading /r/programming when I found a post about the posibility and consecuences of externally forcing colisions inside the associative arrays in PHP, it's something so... ¿overwhelming? you have to try it to see the danger it represents, let's go.

Note: The day 28 of this month took a place a_lecture which has a lot, everything! in relation with this in 28C3, it's very interesting.

The danger gets worse because a combination of factors which PHP groups:

  • The hash of an integer can be trivially guessed, the number itself.

  • There are some arrays the user can create at will: $_GET, $_POST y $_COOKIE.

Now imagine what whould happen if we launch a few malicious queries agaist a server, it can be a little tiresome to do it by hand, so there a script to do it prueba_hashmap_php.py... it's not pretty, it's not elengant, but it's not intended to either.

The script allows several posibilities, if it will or not wait for the answer from the server and how many time it will wait between query and query, this can be modified in lines lineas 10 and 11, it also can pass as parameters the number of variables to send, the number of queries to make and the number of threads to launch (in that order).

Ok, now let's get to the tests, the "attacker" is a simple netbook unable to run a mere N64 (just to give an idea), the "victim" is a Cuad Core, not the last from the market but it should perform well, shouldn't it?

Well, it doesn't

Launching a attack with a single query with 50000 elements and a single thread and waiting for the server we obtain the following data:

@TODO

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
[0] 500 > 0.192291021347 | 60.0323388577 <
----- Data -----
Codes:

500: 1 times



Average uploading time: 0.192291021347

Average downloading time: 60.0323388577

I think the problem is obvious, it took less than two tenths of a second to send the data (not counting the time to prepare the query, which is only done once) and nevertheless to the server not only it took 60 second, failing then with a 500 (Internal server error), but also in that time the a core was working at 100% of it's capacity.

And what if we repeat it with four threads?

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
[1] 500 > 0.75856590271  | 60.0828011036 <
[0] 500 > 0.740755081177 | 62.4277861118 <
[3] 500 > 0.806277036667 | 67.9619438648 <
[2] 500 > 0.784065008163 | 69.3936538696 <

----- Data -----

Codes:
500: 4 times

Average uploading time: 0.772415757179

Average downloading time: 64.9665462375

And during that time four (of four) cores are working at 100%

If someone is thinking a complex script explains this, here is the one tested:

1
2
3
<?php
   echo "Jau!";
?>

But it isn't just about a low traffic denial of service, it can get worst, what if inmediately after sending a query we disconnect and sends another one?

1
2
wait_for_server = False # Wait for the server to answer?
wait_between = 0.5 # Seconcs to wait between connections

If it's launched with blocks of 50000 values, with an infinite number of queries (-1 will do), and let's say... 10 threads, we'll se something interesting, apart from all cores going to 100% and at that first the attack takes a considerable bandwidth ~3mb (less than a minute after it only takes 1kb to maintain it), the use of memory grows, starting very fast and getting slower, but after ~10 minutes it'll consume almost 1 Gigabyte and all this while a mere netbook doesn't devote more than a 1% to the attack.

Solution

As the first referenced post says, there is already a commit in the PHP SVN which adds a max input vars directive to limit the number of parameters that can be received in one query. According to the post, it'll arrive with version 5.3.9 (in the trisquel repositories there's the 5.3.5), theoretically another option would be use the Suhosin patch, which Debian and derivates ship by default but, after trying it I cannot say it works :/

That's all, see you soon.

Link compilation

Now I'm too busy to work on the blog, here you have some links that could be interesting, just looking at the link it's possible to expect what awaits behind it.

Sets de Julia y Mandelbrot con Python

Creo que cualquiera que programe algo en cualquier momento de su vida acabará por preguntarse como podría generar ese carnaval de colores que son los fractales, y es posible que acabe por desistir bajo el pensamiento de que es complicado.

Bien, sin llegar a tocar la teoría, el algoritmo para determinar el número:
1. Tomamos C como el punto ( un número complejo, dos valores ).
2. Z = C
3. Mientras no se haya completado el límite de iteraciones:
4. Si Z.real2 + Z.imag 2 >= 4:
5. Devolvemos el número de iteraciones [ FIN ]
6. Sinó, Z = Z**2 + C [ volvemos a 3 ]
7. Si se acabaron las iteraciones, el punto no tiende a infinito.

Así de sencillo, para el set de Julia lo mismo, pero Z es el punto, y C una constante para todo el set que se renderiza.

Así, podemos escribir un script que genere fractales con poco código, hay poco más de una decena para cada set, pero hay mucho código que se podría evitar, como la clase Imagen, pero que es necesario para compilarlo con shedskin, que carece de PIL. [ fractal_shedskin.py ] Después del salto, explicación de las opciones y colorinchos ejemplos !

Los parámetros son estos: [-g] [-j ] [-p ][ -b ] [ -q ] [-x] [-o ] [- w ] [-h ] [-c

] [-i ] [- z ]

-g: La imágen se guarda en escala de grises -x: El coloreado se invierte -j: Se muestra el set de julia para el punto especificado ( dos números de punto flotante ) -p: Potencia ( normalmente 2 ) -b: Se toma el conjugado de Z antes de la transformación de cada iteración -q: No se muestra la salida -o: Imágen de salida [out.png] -w/h: / de la imágen [600x600] -c: s de la función ( dos números de punto flotante ) [ 0., 0.] -i: Número máximo de iteraciones [ 100 ] -z: Nivel de zoom ( tamaño que abarca la imágen ) [ 4. ] * Ejemplos ( Mandelbrot set ): ***

[caption id="attachment_614" align="aligncenter" width="300" caption="./ fractal_shedskin"][/caption]

[caption id="attachment_615" align="aligncenter" width="300" caption="./ fractal_shedskin -b"][/caption]

[caption id="attachment_616" align="aligncenter" width="300" caption="./ fractal_shedskin -c 0.36644749414062499637 0.59162698007812497547 - z 0.000002373046874999999448 -i 400"][/caption]

[caption id="attachment_617" align="aligncenter" width="300" caption="./ fractal_shedskin -p 5 -b -x"][/caption]

[caption id="attachment_618" align="aligncenter" width="300" caption="./ fractal_shedskin -p -2 -b"][/caption]

[caption id="attachment_619" align="aligncenter" width="300" caption="./ fractal_shedskin -p -4 -g"][/caption]

* Ejemplos ( Julia set ): ***

[caption id="attachment_620" align="aligncenter" width="300" caption="./ fractal_shedskin -j -1.1 0.1"][/caption]

[caption id="attachment_621" align="aligncenter" width="300" caption="./ fractal_shedskin -j -1.1 0.1 -b"][/caption]

[caption id="attachment_622" align="aligncenter" width="300" caption="./ fractal_shedskin -j 0.6 0.55 -p 4 -g"][/caption]

[caption id="attachment_613" align="aligncenter" width="300" caption="./ fractal_shedskin -j 0.3 0.6 -b"][/caption]

[Referencias] http://www.idiap.ch/~pabbet/code-snippets/image-processing/ [Código de HSL to RGB] http://mcgoodwin.net/julia/juliajewels.html

Alpha del plugin de liberateca para moovida

Me extenderé poco que ando con prisas. Como se deduce del título del post, el plugin de liberateca para moovida ya es usable, esto quiere decir que aunque queda mucho por pulir ( por root, si usa menus de ajustes para las series :/ ! ), pero ya es capaz de ver series que tengan enlaces ( por ahora solo a megaupload, se ve que eso es lo que más guerra va a dar ), así que:

Para instalarlo hay que hacer sh build_and_install.sh

después ya lo subiré todo a github, y empaquetado en un .egg, por si los usuarios de guindows ReactOS

Realmente hay que esperar 45 segundos después de seleccionar el episodio ( cosas de megaupload ), pero salto una notificación y no es plan.

Con root...

De permisos de directorios [unix]

Andaba yo leyendo cierto post [ http://blog.jgc.org/2009/01/single-line- assignment-filled-with-epic.html ] cuando, sin previo aviso descubrí la respuesta a una pregunta que me llevo haciendo meses sinó años, ¿como @#$% hacen para que algunos directorios los pueda listar cualquiera y otros no?... ¿y para acceder?
[...]  It also removes execute permission. In the UNIX world
execute permission on a directory means that you can CD into it; with
it removed the directory cannot be accessed (i.e. you can't get a
list of the files in the directory). [...]

Así que resulta que con los directorios las cosas funcionan así:

* x: Acceso al directorio

* r: Leer los contenidos del directorio
*
* w: Crear/eliminar archivos
*

Escapando caracteres especiales en Python [tip]

Actuliazación: json is the way

Supongamos que tenemos un texto como este:
Bla
blablabla\ /
blabla

Y queremos representarlo todo en una línea sin perder información, como hacerlo? def miniscape(s):

return str([s])[2:-2]

Resultado: \nBla\nblablabla\ /\nblabla\n

Y para darle la vuelta? def miniunscape(s):

i = 0

while True:

   try:

       x = s.index("\\x", i)

       if not((x > 0) and (s[x-1] == "\\")):

           s = s[:x]+chr(int(s[x+2:x+4],16))+s[x+4:]

       i = x + 1

   except:

       break

reptable = [("\\","\"),("\n","\n"),("\'","'"),("\a","\a"),

               ("\\b","\b"),("\\f","\f"),("\\r","\r"),("\\t","\t"),

               ("\\v","\v")]

for r in reptable:

   i = 0

   while True:

       try:

           x = s.index(r[0], i)

           if not((x > 0) and (s[x-1] == "\\")):

               s = s[:x]+r[1]+s[x+2:]

           i = x + 1

       except:

           break

return s

En pastebin [ http://pastebin.com/5uvf3tBK ]

Y ya está, nos vemos

Compilando en entornos hostiles: Dia

No, no penseis nada raro, con "compilar en entornos hostiles" me refiero a hacerlo donde no tenemos a mano las librerías necesarias para compilar un programa en concreto, ni permisos para instalarlas, la idea es mostrar como se puede hacer para quien necesite usar algún programa cuando solo dispone de una cuenta con acceso mínimo.

Pero volvamos al principio, Dia es un software para hacer diagramas desarrollado por el proyecto Gnome, supongamos que quremos usarlo en una máquina, una opción sería descargar el paquete ya compilado y ejecutarlo, pero... sorpresa! , utiliza una librería que no esta instalada ( libxml2 en este caso) .

Entonces habrá que seleccionar un lugar donde se instalarán las  librerías y el programa ( no tiene que ser el mismo, pero por comodidad aquí sí lo será ), digamos que le llamamos myroot, entonces nos colocaremos en ese directorio, abrimos un terminal y haremos:

export myroot=pwd

Ahora descargamos el código fuente de libxml2 ( necesario para nuestro programa, recordemos ) y lo descomprimimos:

wget ftp://xmlsoft.org/libxml2/libxml2-2.7.2.tar.gz

tar -xf libxml2-2.7.2.tar.gz

Después podemos borrar el archivo .tar.gz.

Ahora entramos en el directorio de libxml y le decimos donde se va a realizar la instalación

cd libxml2-2.7.2/

./configure --prefix=$myroot

Si todo sale bien, al final nos dirá "Done configuring", ahora hay que pasar a compilarlo, esto se hará con

make

Si no hubo ningún problema, lo "instalamos" en el directorio que especificamos antes con

make install

Nota: para quien ya instaló antes algo desde el código fuente, en este caso no son necesarios permisos de root

Ahora volvemos al directorio que nos sirve de raiz y comprobamos que todo fue bien:

cd $myroot

bin/xml2-config

Vamos a definir dos variables de entorno más, una que indicará donde se encuentran las librerías y otra que nos permitirá acceder a los ejecutables que instalemos como si fueran propios del sistema:

export LD_RUN_PATH=$myroot/lib/

export PATH=$PATH:$myroot/bin/

Ahora necesitamos instalar Dia, descargamos el_código_fuente y lo descomprimimos ( aquí he tenido que instalar la versión 0.96 que no es la última porque sinó la intltool instalada era demasiado antigua ) :

wget http://ftp.gnome.org/pub/gnome/sources/dia/0.96/dia-0.96.1.tar.bz2

tar -xf dia-0.96.1.tar.bz2

De nuevo, una vez descomprimido podemos borrar el archivo .tar.bz2 Repetimos entonces el proceso en la carpeta de Dia:

cd dia-0.96.1/

./configure --prefix=$myroot

Y paf! nos damos de morros con que no encuentra la libxml2 ( porque no está instalada formalmente )

Pero sabemos que sí está instalada ( al menos dentro de nuestro entorno, fuera no ), así que desactivamos esa comprobación en el archivo configure, buscamos "found_libxml=false" y cambiamos el false por un true, y después buscamos los "GTK_MODULES=" y eliminamos el libxml-2.0.

Volvemos a intentar el configure y esta vez debería ir bien, poniendo algo como "Now type make to build dia..." al final.

Le hacemos caso y ejecutamos make:

make

Pero volvemos a chocar con otro error, si hacemos scroll hacia arriba veremos que:

===============================================================================

In file included from object.h:33, from dynamic_obj.h:26, from diagramdata.c:33: dia_xml.h:26:25: error: libxml/tree.h: No such file or directory In file included from object.h:33, from dynamic_obj.h:26, from diagramdata.c:33: ===============================================================================

Le falta los headers de libxml, no problem, los copiamos y ya está, desde el directorio de Dia:

cp -R ../libxml2-2.7.2/include/libxml lib/

Y volvemos a hacer make, la cosa avanza sin problemas, hasta que cerca del final detiene el proceso un montón de "undefined reference", el archivo está en la carpeta app, y por el nombre de las funciones (  "xmlFree", "xmlGetProp" ) parece que tiene que ver con el linkado a libxml.

Así que abrimos el Makefile del directorio app, buscamos "XML_CFLAGS =" y añadimos lo que nos muestra el comando xml2-config --cflags , después buscamos "XML_LIBS =" y añadimos la salida de xml2-config --libs.

Nota: el comando xml2-config se instaló con libxml, si no nos acordamos de añadir $myroot/bin al PATH habría que llamar directamente al ejecutable con $myroot/bin/xml2-config.

Seguimos con el make desde la carpeta de Dia, que esta vez debería por fin acabar sin mayores problemas.

Solo queda instalarlo en nuestro entorno:

make install

Y ya podemos utilizar Dia con el comando dia ( repito, si no se modificó la variable de entorno $PATH habría que incluir la ruta completa al ejecutable ).

ps: en las pruebas Dia mostraba un pequeño error al iniciar, decía que "Could not find plugin init function in `< $myroot >/lib/dia/libxslt_filter.la'", pero parece que no tiene consecuencias perceptibles.

Hasta otra.

La curva del dragón con Logo

Nada, que después de encontrarse uno con que alguien se las arreglo para hacer este fractal con redcode [ http://impomatic.blogspot.com/2011/01/dragon-curve-in-redcode.html ] (para quitarse el sombrero, vaya :P !) no se puede menos que intentarlo en otro lenguaje, y a falta de poder tirar de los gráficos de tortuga el python por cosas de la vida, la siguiente opción es logo.

Realmente no tiene mucha complicación, la wikipedia nos da la_fórmula_lista para_programar, simplemente hay que hacer:

===============================================================================

G = B ^ (B >> 1)

===============================================================================

(El ^ es XOR y el>>1 es mover todos los bits una posición a la derecha). Y después hacer AND de este "G" y el NOT del anterior, así puede quedar por ejemplo en Logo:

=============================================================================== to ge :g :gz

ifelse (bitand (bitnot :g) :gz) > 0 [

   rt 90

] [

   lt 90

]

end

to dragon :length :step :base :gz

if :base > :length [stop]

ge bitxor :base (lshift :base -1 ) :gz

fd :step

dragon :length :step :base+1 bitxor :base (lshift :base -1)

end

ht ; Hace que vaya más rápido

dragon 100000 1 0 0

Si al final todo es más fácil de lo que parece :P

Proyectos varios [off-topic]

Tengo esto medio abandonado, por falta de una buena gestión del tiempo, es decir, no me puedo quejar de tener poco tiempo, pero no se repartirlo :P a modo de excusa dejo un par de proyectos a medio/largo plazo en los que ando metido:

Nota: me enteré de que el código de github no es libre, así que migre los otros proyectos a gitorious que si lo es, el posible desarrollo continuará ahí [ https://www.gitorious.org/~kenkeiras ]

* Paint wars ***

Un juego ( un amago de bullet_hell ) muy, muy sencillo, hecho con python y pygame, aunque no tiene un rumbo definido ya es "jugable". Lo utilizo sobretodo como campo de pruebas para ideas sobre este tipo de juegos. [ https:// www.gitorious.org/rand/paint_wars ]

* BLK ( Bytecode Land Kit ) ***

Es un proyecto para el Concurso_Universitario_de_Software_Libre, citando la descripción que escribió un colega ( que parece que entendió el proyecto mejor que yo :P ):

Es un conjunto de herramientas distribuidas en módulos que permiten
experimentar con el proceso de compilación, en sus diferentes
etapas.

Debido a su modularidad, nos permite adaptar dicho proceso de
compilación a nuestras necesidades, personalizando o adaptando
algunos de sus módulos ya sea el parser del código fuente o el
compilador de una arquitectura, sin que deba preocuparse de crear,
modificar o adaptar otras fases de la compilación que pueden hacerle
perder tiempo de su proyecto.

Aunque por ahora solo le pude dedicar un par de días es un proyecto que me ilusiona mucho, estoy acabando el preprocesador de C, y espero poder acabar durante la semana que viene el parser de ese lenguaje y la primera versión de la definición del bytecode alrededor de la que se basa todo para poder empezar a documentar.

ps: que mal rollo da ver el nombre de uno en internet brrrrr... adios al poco pseudoanonimato que me quedaba xD

Enfin, eso, excusas, excusas, a ver si las cosas hechan a rodar y puedo volver a escribir desvarios por aquí