El Paradigma OOP (Parte 2)

En la entrada anterior finalizé haciendo referencia al lenguaje de programación SmallTalk. En esta entrada continuaré con el tema que venía desarrollando.

Así como Pascal fué en su momento, el paradigma de la programación estructurada ( Algoritmos + Estructuras de Datos = Programas). Smalltalk ha sido hasta ahora el paradigma de la programación orientada a objetos.

Otros lenguajes tales como C++, Java y Object Pascal, no son realmente orientados a objetos en toda la extensión de la palabra; son mas bien lenguajes híbridos, lenguajes procedurales con algunas extensiones que permiten programar con objetos, pero nada que ver con la orientación a objetos pura y real de Smalltalk, en donde incluso un bloque de código es un objeto, y como tal tiene un protocolo de mensajes definido. Vaya, incluso lo que en los lenguajes procedurales conocemos como "estructuras de control", en Smalltalk son mensajes y sus parámetros son bloques de código. Nada que ver con los lenguajes procedurales híbridos, esto en sí mismo representa una forma radicalmente distinta de ver el código.

Así pues, fué que reconociendo mi ignorancia y por tanto mis carencias y necesidades, decidí que fuera precisamente Smalltalk quien me sacara del paradigma de la programación procedural y me enseñara el verdadero paradigma de la programación orientada a objetos.

Comencé entonces a hacer mis primeros pininos en Smalltalk y me sorprendió muy gratamente.
De entrada transcribí mi programa mascota "NomEdad" un programita sumamente simple que pide una cadena y un número y despliega como resultado una suma en un letrero.

La versión en Java de este programita es la siguiente:

/* nomedad.java */
import java.io.*;
class nomedad {
    public static void main (String[] args) throws IOException {
        Integer   edad;
        String   strnombre;
        BufferedReader   brin;
        int   n;
        /* Inicialización */
        brin = new BufferedReader(new
InputStreamReader(System.in));
        /* Comienza rutina principal */
        System.out.print("Hola, ¿Cuál es tu nombre? ");
        strnombre = new String(brin.readLine());
        System.out.print("¿En que año naciste? ");
        edad = new Integer(brin.readLine());
        n = 2006 - edad.intValue();
        System.out.print("Hola, ");
        System.out.println(strnombre);
        System.out.print("En el año 2006 tendrás ");
        System.out.print(n);
        System.out.println(" años");
    }
}

Pues bien este programita que al escribirlo en Java por primera vez me causó algunos dolores de cabeza debido a las sutilezas del lenguaje, que copia la sintaxis de C pero no necesariamente su semántica, debido a que las variables se crean pero no se inicializan, debido a que el Standard Output si puede usarse directamente pero el Standard Input no, debido a la sintaxis para declarar excepciones y debido a otras linduras tales como el kilométrico import ...bla bla bla... class ... bla bla ba ... public static void main ( String [] args ) throws ...bla bla bla... etc, etc. (Años después sufriría yo igual o peor con Visual Basic .NET y toda su verborrea).

Este mismo programa en Smalltalk ( Squeak) lo pude escribir en poco más de cinco líneas de código claro, legible y entendible:

"nomedad.st"
| nombre edad |
    nombre := FillInTheBlank request:'Hola, ¿Cual es tu nombre?'.
    edad := FillInTheBlank request:'¿En que año naciste?'.
    edad := 2006 - (edad asInteger).
    Transcript show:'Hola '; show: nombre; cr.
    Transcript show:'En el año 2006 tendras '; show: edad; show:'
años'; cr.

¡¡Que gran diferencia!! ¡¡Solo seis líneas de código, claro y entendible !!.

Esto a pesar de no ser necesariamente Smalltalk idiomático.

Es impresionante saber que en 1980, Smalltalk ya tenía su propia máquina virtual, su propio byte-code, compilador JIT, entorno de programación IDE, ambiente gráfico, implementación del patrón de diseño Model-View-Controller (MVC), entre otras cosas. Elementos que mas de diez años después se venderían como "innovaciones" por parte de Sun con Java y más de veinte años después por parte de Micro$oft con .NET (quien por cierto apenas está logrando cuajar bien su implementación del MVC).

Esta primera aproximación nos muestra ya algunas características del lenguaje Smalltalk que son importantes para entender el paradigma que nos ocupa de las cuales seguiremos escribiendo en nuestro siguiente post.