Lenguajes fuertemente, débilmente, estáticamente y dinámicamente tipados

Uno de los aspectos más importantes de cualquier programa es, sin duda, el tema de los
datos.
Los datos son el soporte de la información, y la información es el corazón de cualquier
programa.
Los lenguajes de programación utilizan las variables como contenedores de datos, para
manipularlos y almacenarlos en una amplia variedad de maneras. Está claro que los datos
tienen distintos tipos. A nadie se le escapa que no es lo mismo un nombre de persona que su
edad, el primero es un texto y el segundo es un número.
Los distintos lenguajes de programación tienen en cuenta esta particularidad de los datos, y
por lo tanto, todos tienen alguna forma de distinción entre los tipos de datos.
No obstante, cada uno tiene una forma de afrontar esta particularidad. Ello ha llevado a
podamos en cierto modo "clasificar" los lenguajes de programación por la forma en la que
tratan con el problema de los tipos de datosl.

• Dinámica y estáticamente tipados

• Fuerte y débilmente tipados

El tema es, sin duda, controvertido. Cada sesudo investigador o aficionado al tema podrá
darle mil definiciones y argumentos acerca de lo que significa cada uno de esos términos,
pero en nuestra humilde opinión, no conviene obsesionarse ni llevar el tema al extremo.
Tener una ligera idea para entender que existen varias formas de afrontar el problema de los
tipos es una cosa, y emprender una cruzada para defender no-sé-qué-cosa de un lenguaje u
otro, o tratar de ponerle puertas al campo, es otra.
En este artículo, matizaremos los aspectos más importantes que nos permiten distinguir la
forma en que un lenguaje aborda el tema de los tipos de los datos, sin ánimo de controversia
ni de sentar cátedra... y por supuesto... influenciados por nuestra propia opinión de
aficionados ;-) Lo mejor que puedes hacer con un artículo como éste es leerlo, no creértelo
del todo, contrastarlo con otras fuentes y formarte tu propia opinión. La controversia entre
éstos tipados tiene fuertes raíces en el hecho de que cuando se diseña un lenguaje, se tiene
en mente si va a ser compilado o interpretado. Las diferencias en el diseño de un compilador
o de un intérprete son radicales. Además, debemos fijarnos en el hecho de que un mismo
lenguaje, generalmente se compila o generalmente se interpreta. Por ejemplo, el lenguaje C,
o C++ o C#, o Java generalmente es compilado. El lenguaje JavaScript, o PHP o Python,
generalmente se interpretan.
El tratamiento de tipos en un intérprete puede, en general, disfrutar de una riqueza mucho
mayor en las estructuras que internamente se utilizan para representar a las variables. El
compilador, por su parte, depende de una traducción a código máquina (puede ser de una
máquina real o una máquina virtual, como en el caso de .net o de Java). Eso hace que las
estructuras para representar variables tengan una flexibilidad algo menor, y, si se quiere
dotar de mecanismos más flexibles o más potentes a un compilador, generalmente redunde
en un mayor consumo de tiempo y de memoria y también generalmente, a los compiladores
se les suele exigir rapidez en el código que generan y consumo de recursos reducido.
Estos factores, en cierto modo, condicionan cómo los lenguajes tratan los tipos.

Tipos estáticos, tipos dinámicos. (static typing, dinamic typing)

En un lenguaje estáticamente tipado, cada variable debe ser declarada con un tipo. Eso
ocurre por ejemplo en C# o Java. Para utilizar una variable de tipo entero, es necesario
indicar que en efecto, es de ese tipo. El tipado estático es típico de los lenguajes
compilados.El tipo no se altera hasta que la variable se sale de ámbito y se extingue. Éste
comportamiento se aplica tanto a variables locales (a un método o función), a parámetros (de
un método o función), a varibles de instancia (de un objeto), a variables de clase ("static"), o
a variables globales (en lenguajes no orientados a objetos).
Por ejemplo, en C# o java, para utilizar una variable de nombre "i" que contenga un entero
int i; //Primero se declara
i=3; //y luego se utiliza
No es posible asignar un valor de otro tipo a una variable de un tipo concreto:
i="hola"; //incorrecto
En un lenguaje dinámicamente tipado, no suele ser necesario declarar el tipo de las
variables. Es típico de los intérpretes. Ocurre en lenguajes como PHP o Python. Las
variables empiezan a existir cuando se les da valor. Los lenguajes dinámicamente tipados
tienen en cuenta los tipos, desde luego, pero no en las variables, sino en su contenido.
Una misma variable puede contener en un instante dado un dato de un determinado tipo, y
en otro instante, puede contener otro dato de otro tipo.
Por ejemplo, en Python, podemos utilizar una variable "i" para contener un entero, sin
necesidad de indicar que va a contener un entero. (La almohadilla # (o gato) indica un
comentario)
i=3 #la variable comienza a existir al darle valor
i="hola" #luego, puede contener un valor de otro tipo
Vamos a contarlo de otro modo. Imagina que las variables fueran cajas de cartón (bueno, al
fin y al cabo, una caja de cartón sirve para contener cosas):

En los lenguajes estáticamente tipados se le asigna el tipo a la caja. Es como si en la caja,

pusieramos una etiqueta: "esta caja sólo puede contener zapatos". A partir de ese momento,
en esa caja sólo se pueden meter zapatos, hasta que la caja sea destruida.
En los lenguajes dinámicamente tipados, es el contenido el que tiene el tipo. En la caja no
colocamos ninguna indicación acerca del contenido. Si metemos un par de zapatos será una
caja de zapatos, y si metemos un juguete será una caja de juguetes. Nadie impide que
metamos cualquier cosa.

Bueno la segunda opción parece, al menos intuitivamente, más sencilla más flexible ¿Por
qué no se utiliza siempre? Ah... amigo muy sencillo: en la segunda opción, hay que abrir las
cajas para saber lo que contienen.
Con el tipado estático, dadas dos variables enteras, si después queremos hacer una suma,
seguro que se puede hacer sin mirar, dado que el compilador sabe que seguro que contienen
un entero, por lo tanto, la suma se puede hacer sin comprobaciones previas.
int i1=3; int i2=5; int i3=i1+i2; //No se hacen comprobaciones en la
suma: seguro que i1 e i2 contienen un entero.
Con el tipado dinámico, las operaciones son algo más costosas el intérprete deberá obtener
el contenido de las variables ("abrir las cajas") y decidir qué operación hacer y cómo,
suponiendo que ésta sea posible.
En Python, la tercera línea necesita comprobaciones adicionales a nivel interno, con respecto
al tipado estático.
i1=3
i2=5
i3=i1+i2

Fuertemente tipados, débilmente tipados(strong typing, weak typing)

En este punto, la controversia es algo mayor. No hay un criterio unánime acerca del grado de
fortaleza o debilidad en los tipos.
Comunmente, se entiende que un lenguaje tiene un sistema de tipos más fuerte si para una
determinada operación, que requiera un determinado tipo de datos, el lenguaje no acepta
tipos que pudieran ser "compatibles".
Por ejemplo, si un lenguaje nos permite declarar un método o función que acepte como
parámetro un número real de doble precisión (es decir, un double), consideraríamos que el
lenguaje está muy fuertemente tipado si sólo permitiese llamadas o invocaciones a esa
función o método pasándole como parámetro un dato con un tipo double.
A partir de ahí, podríamor ir rebajando el listón. Por ejemplo, en la situación descrita, casi
todos los lenguajes permiten una serie de conversiones implícitas. Es decir, muchos
lenguajes (como C# o Java, que son estáticamente tipados) permitirían invocar un método
que aceptase un double como parámetro pasándole un float (un número con decimales de
simple precisión), o incluso un entero. Es decir, en ese sentido, C# o Java están fuertemente
tipados, pero no todo lo fuertemente tipado que se puede estar.
Todavía se podría rebajar más el listón: si en el mismo caso, el método que acepta un
double, intentásemos una llamada pasándole una cadena (que podría contener en sus
carácteres la representación de un double, y por lo tanto, la operación podría tener cierto
sentido, ej: "3.1416"), un lenguaje débilmente tipado permitiría la llamada, e intentaría, en el
interior del método o función, interpretar la cadena como un double.
Prácticamente todos los lenguajes permiten una cierta conversión implícita de tipos,
especialmente si se pueden considerar seguras. Por ejemplo, convertir un entero a un double
suele ser una operación segura, dado que un entero no tiene decimales, y un double sí... es
decir, es un tipo más amplio. Una conversión de éste tipo puede ser implícita con un alto
grado de seguridad. Al reves no es así. Si yo tengo un double (Ej: 2.68) y lo utilizo en un
contexto en el que se requiere un entero, ¿qué debería hacer el lenguaje con los decimales?
¿Los quita? ¿Los redondea?
Un lenguaje débilmente tipado, en general, permite éste tipo de conversiones implícitas
inseguras. Es su filosofía que el programador se encargue de programar, y el lenguaje se
encargará de hacer todo lo posible para que el programa ejecute, liberando al programador
de llevar también la cuenta de posibles conversiones de tipos.
Esta última forma de actuar proporciona, sin duda, una manera más sencilla de programar.
Es decir, en un lenguaje débilmente tipado, el lenguaje prestará poca atención a una
definición estricta de los tipos. Eso hace que el programador pueda centrarse en el objetivo
del problema que resuelve, que el lenguaje intentará encargarse de todo lo referido a los
tipos, sin embargo, la consecuencia lógica es que los posibles errores se detectarán más
tarde, en tiempo de ejecución.
Éste hecho de permitir una mayor o menor relajación en el uso de los tipos no está tan
íntimamente relacionado con la compilación o la interpretación. Ni siquiera tiene una relación
evidente con el tipado estático o dinámico. Sin embargo, sí puede verse una cierta tendencia
a que los lenguajes estáticamente tipados (como C# o Java) también tengan una cierta
fortaleza en el tratamiento de los tipos.

Conclusión

Sacar conclusiones es complicado. Valorar si es mejor tal o cual cosa es esfuerzo perdido...
para según que aplicaciones puede venir mejor una y para otras no.Valóralo tú mism@ y
saca tus propias conclusione: será el mejor criterio que puedas tener ;-)

ver: 1 Pseint es dinamicamente tipado.psc

Fuente:
http://latecladeescape.com/articulos/1520-lenguajes-fuertemente-debilmente-estaticamente-y-dinamicamente-
tipados