Índice

Tabla de contenido
Ruby ................................................................................................................................................. 3-6
Scala ................................................................................................................................................. 7-8
Go ................................................................................................................................................... 9-10
Conclusión ......................................................................................................................................... 11
Bibliografía ........................................................................................................................................ 12

1
RUBY
Ruby es un lenguaje con un balance cuidado. Su creador, Yukihiro “matz”
Matsumoto, mezcló partes de sus lenguajes favoritos (Perl, Smalltalk, Eiffel, Ada,
y Lisp) para formar un nuevo lenguaje que incorporara tanto la programación
funcional como la programación imperativa.
En el 2006, Ruby alcanzó reconocimiento masivo, formándose grupos de usuarios
activos en las ciudades más importantes del mundo y llenando las capacidades de
las conferencias relacionadas a Ruby. El índice TIOBE, que mide el crecimiento de
los lenguajes de programación, ubica a Ruby en la posición #13 del ranking mundial.
Refiriéndose a su crecimiento, predicen, “Todo indica que Ruby llegará a estar entre
los 10 primeros en menos de 6 meses”. Gran parte de su crecimiento se atribuye a
la popularidad alcanzada por aplicaciones desarrolladas con Ruby, en particular
el Framework de desarrollo web Ruby on Rails.
CARACTERÍSTICAS
SINTÁXIS
La sintaxis de Ruby es similar a la de Perl y Python. La definición de clases y
métodos está definida por palabras claves. Sin embargo, en Perl, las variables no
llevan prefijos. Cuando se usa, un prefijo indica el ámbito de las variables. La mayor
diferencia con C y Perl es que las palabras clave son usadas para definir bloques
de código sin llaves. Los saltos de línea son significativos y son interpretados como
el final de una sentencia; el punto y coma tiene el mismo uso. De forma diferente
que Python, la indentación no es significativa.
SEMÁNTICA
Ruby es orientado a objetos: todos los tipos de datos son un objeto, incluidas las
clases y tipos que otros lenguajes definen como primitivas, (como enteros,
booleanos, etcétera). Este lenguaje soporta herencia con enlace dinámico, mixins y
métodos singleton (pertenecientes y definidos por una sola instancia más que
definidos por la clase).
A pesar que Ruby no soporta herencia múltiple, las clases pueden importar módulos
como mixins.
Ruby ha sido descrito como un lenguaje de programación multiparadigma: permite
programación procedural, con orientada a objetos o funcionalmente. Además de
soporte para hilos de ejecución gestionados por el intérprete.
Este lenguaje tiene tipado dinámico y soporta polimorfismo de tipos (permite tratar
a subclases utilizando la interfaz de la clase padre). No requiere polimorfismo de
funciones al no ser fuertemente tipado.

2
LA FLEXIBILIDAD DE RUBY

Ruby es considerado un lenguaje flexible, ya que permite a sus usuarios alterarlo

libremente. Las partes esenciales de Ruby pueden ser quitadas o redefinidas a
placer. Se puede agregar funcionalidad a partes ya existentes. Ruby intenta no
restringir al desarrollador.

Por ejemplo, la suma se realiza con el operador suma (+). Pero si prefieres usar la
palabra sumar, puedes agregar un método llamado sumar a la claseNumeric que
viene incorporada.
class Numeric
def sumar(x)
self.+(x)
end
end

y = 5.sumar 6
# ahora y vale 11
Los operadores de Ruby son simples conveniencias sintácticas para los métodos.
Los puedes redefinir como y cuando quieras.

LOS BLOQUES, UNA FUNCIONALIDAD REALMENTE EXPRESIVA

Los bloques de Ruby son también vistos como una fuente de gran flexibilidad. El
desarrollador puede anexar una cláusula a cualquier método, describiendo cómo
debe actuar. La cláusula es llamada bloque y se ha convertido en una de las más
famosas funcionalidades para los recién llegados a Ruby que vienen de otros
lenguajes imperativos como PHP o Visual Basic.

Los bloques están inspirados por los lenguajes funcionales. Matz dijo, “en las
cláusulas de Ruby, quise respetar la cultura de Lisp3”.

motores_de_busqueda =
%w[Google Yahoo MSN].map do |motor|
"http://www." + motor.downcase + ".com"
end
En este código, el bloque está descrito entre la construcción do ... end. El
método map aplica el bloque a la lista de palabras provista. Muchos otros métodos
en Ruby dejan abierta la posibilidad al desarrollador para que escriba su propio
bloque describiendo los detalles de qué debe hacer ese método.

3
 RUBY Y EL MIXIN
A diferencia de otros lenguajes de programación orientada a objetos, Ruby se
caracteriza por su intencional herencia simple. Sin embargo, Ruby incorpora el
concepto de módulos (llamados categorías en Objective-C), que son colecciones de
métodos.

Las clases pueden mezclar (mixin) un módulo e incorporar todos sus métodos
gratuitamente. Por ejemplo, cualquier clase que implemente el método eachpuede
incorporar el módulo Enumerable, que le agrega un conjunto de métodos que
usan each para recorrer sus elementos.

class MiArray
include Enumerable
end

En general, los Rubyistas ven esto como una forma mucho más clara de herencia
múltiple, que es compleja e incluso puede ser restrictiva.

LA APARIENCIA VISUAL DE RUBY

A pesar de que Ruby utiliza la puntuación muy limitadamente y se prefieren las

palabras clave en inglés, se utiliza algo de puntuación para decorar el código. Ruby
no necesita declaraciones de variables. Se utilizan convenciones simples para
nombrar y determinar el alcance de las mismas.

 var puede ser una variable local.

 @var es una variable de instancia.
 $var es una variable global.
Estos detalles mejoran la legibilidad permitiendo que el desarrollador identifique
fácilmente los roles de las variables. También se hace innecesario el uso del
molesto self. como prefijo de todos los miembros de instancia.

4
 MÁS ALLÁ DE LO BÁSICO
Ruby tiene un conjunto de otras funcionalidades entre las que se encuentran las
siguientes:

 Manejo de excepciones, como Java y Python, para facilitar el manejo de errores.

 Un verdadero mark-and-sweep garbage collector para todos los objetos de Ruby.

No es necesario mantener contadores de referencias en bibliotecas externas. Como
dice Matz, “Esto es mejor para tu salud”.

 Escribir extensiones en C para Ruby es más fácil que hacer lo mismo para Perl o
Python, con una API muy elegante para utilizar Ruby desde C. Esto incluye llamadas
para embeber Ruby en otros programas, y así usarlo como lenguaje de scripting.
También está disponible una interfaz SWIG.

 Puede cargar bibliotecas de extensión dinámicamente si lo permite el sistema

operativo.

 Tiene manejo de hilos (threading) independiente del sistema operativo. De esta

forma, tienes soporte multi-hilo en todas las plataformas en las que corre Ruby, sin
importar si el sistema operativo lo soporta o no, ¡incluso en MS-DOS!

 Ruby es fácilmente portable: se desarrolla mayoritariamente en GNU/Linux, pero

corre en varios tipos de UNIX, Mac OS X, Windows 95/98/Me/NT/2000/XP, DOS,
BeOS, OS/2, etc.

5
SCALA

Scala es un lenguaje de programación moderno multi-paradigma diseñado para

expresar patrones de programación comunes de una forma concisa, elegante, y de
tipado seguro. Integra fácilmente características de lenguajes orientados a objetos
y funcionales.

CARACTERÍSTICAS
SCALA ES ORIENTADO A OBJETOS
Scala es un lenguaje puramente orientado a objetos en el sentido de que todo es
un objeto. Los tipos y comportamientos de objetos son descritos
por clases y traits (que podría ser traducido como un “rasgo”). Las clases pueden
ser extendidas a través de subclases y un mecanismo flexible de composición
mezclada que provee un claro remplazo a la herencia múltiple.

SCALA ES FUNCIONAL

Scala es también un lenguaje funcional en el sentido que toda función es un valor.

Scala provee una sintaxis ligera para definir funciones anónimas. Soporta funciones
de primer orden, permite que las funciones sean anidadas, y soporta currying.
Las clases caso de Scala y las construcciones incorporadas al lenguaje
para reconocimiento de patrones modelan tipos algebraicos usados en muchos
lenguajes de programación funcionales.
Además, la noción de reconocimiento de patrones de Scala se puede extender
naturalmente al procesamiento con la ayuda de patrones de expresiones regulares.
En este contexto,seq comprehensions resultan útiles para formular consultas. Estas
características hacen a Scala ideal para desarrollar aplicaciones como Web
Services.

SCALA ESTÁTICAMENTE TIPADO

Scala cuenta con un expresivo sistema de tipado que fuerza estáticamente las
abstracciones a ser usadas en una manera coherente y segura. En particular, el
sistema de tipado soporta: * Clases genéricas * anotaciones variables, * límites de
tipado superiores e inferiores, * clases internas y tipos abstractos como miembros
de objetos, * tipos compuestos * auto-referencias explícitamente tipadas * implicit
conversions * métodos polimórficos.
El mecanismo de inferencia de tipos locales se encarga de que el usuario no tengan
que anotar el programa con información redundante de tipado. Combinadas, estas
características proveen una base poderosa para el reusó seguro de abstracciones
de programación y para la extensión segura (en cuanto a tipos) de software.

6
SCALA ES EXTENSIBLE

En la práctica el desarrollo de aplicaciones específicas para un dominio

generalmente requiere de “Lenguajes de dominio específico” (DSL). Scala provee
una única combinación de mecanismos del lenguaje que simplifican la creación de
construcciones propias del lenguaje en forma de librerías: * cualquier método puede
ser usado como un operador de infijo o postfijo * las closures son construidas
automáticamente dependiendo del tipo esperado (tipos objetivo).
El uso conjunto de ambas características facilita la definición de nuevas sentencias
sin tener que extender la sintaxis y sin usar facciones de meta-programación como
tipo macros.
Scala está diseñado para interoperar bien con el popular Entorno de ejecución de
Java 2 (JRE). En particular, la interacción con el lenguaje orientado a objetos Java
es muy sencillo. Scala tiene el mismo esquema de compilación (compilación
separada, carga de clases dinámica) que java y permite acceder a las miles de
librerías de gran calidad existentes.

7
GO

Go, al igual que C y C++, es un lenguaje compilado, obviamente, comparte

características con otros lenguajes compilados, pero lo cierto es que tiene algunas
características únicas, veamos algunas

CONCURRENTE

Es un lenguaje concurrente que soporta canales de comunicación basados en el

lenguaje CSP de Sir Charles Antony Richard Hoare.La concurrencia en Go es
diferente a los criterios de programación basados en bloqueos como pthreads.

RECOLECTOR DE BASURA

Como la mayoría de los lenguajes modernos, Go implementa un recolector de

basura. El recolector de basura de Go está siendo reimplementado para elevar al
máximo la eficiencia y reducir la latencia todo lo posible.

SIMPLICIDAD

Los lenguajes más utilizados como C++, Java o C# son más pesados y
voluminosos. La sencillez es la característica principal de Go, su sintaxis es clara y
concisa. Mientras que C es tristemente célebre por la complejidad de la sintaxis de
sus declaraciones, Go utiliza inferencia implícita de tipos pudiéndose de esta
manera evitar la declaración explícita de variables. La declaración de variables es
simple y conveniente, y difiere de la de C.

DUCK TYPING (TIPIFICACIÓN DINÁMICA)

Go admite la tipificación dinámica de datos también conocida como duck Typing

presente en multitud de lenguajes dinámicos como por ejemplo JavaScript, Ruby o
Python. Un struct puede implementar una interfaz de forma automática, lo cual es
una característica potente y novedosa.

8
GOROUTINES

No son ni threads, ni co-rutinas ni procesos. La comunicación entre goroutinesse

realiza a través de una característica del lenguaje llamada canales —basada en
CSP—, que es mcho más seguro y fácil de usar que los sistemas predominantes
basados en bloqueos de pthreads o características modernas de Java.

EXCEPCIONES

Go no tiene excepciones. Los creadores del lenguaje dan varios motivos para que
esto sea así. Uno de ellos es que añadir una capa de excepciones añade una
complejidad innecesaria al lenguaje y al entorno de ejecución. Por definición
deberían de ser excepcionales, pero al final se acaban usando como controladores
del flujo de la aplicación y dejan de tener nada de excepcional. Según los creadores,
las excepciones tienen que ser realmente excepcionales y el uso que se le da
mayoritariamente no justifica su existencia.

INNOVACIÓN

Durante muchos años, los desarrolladores hemos tenido que elegir entre lenguajes
de programación de tipado estático compilados, por regla general, bastante
complejos pero que proveen grandes características relacionadas con la
optimización y el rendimiento y lenguajes de tipado dinámico interpretados con
características de mucho más alto nivel que hacían su aprendizaje, uso y sintaxis
más sencilla y por tanto divertido programar en ellos, eso sí, sacrificando
rendimiento y control.

Go mezcla lo mejor de ambos mundos y nos aporta una sintaxis sencilla, clara y
divertida junto a la potencia que nos ofrece un lenguaje fuertemente tipado y
compilado incorporando además características de alto nivel que facilitan el uso del
lenguaje por los desarrolladores.

9
 Conclusión
Los lenguajes de programación han sido de suma importancia para el área de
informática y cada día han sacados mejoras de estos, así como por ejemplo los
lenguajes de programación Ruby, Scala y Go han sido lenguajes que poco a poco
se han dado a conocer, cada uno de estos lenguajes mencionados tienen algo en
común y una de ella es la manera en que facilitan mas la programación a los
desarrolladores es decir hacerlo de una manera mas sencilla con un sintaxis más
claro y divertido.

10
Bibliografía
(s.f.). Obtenido de https://www.ecured.cu/Lenguaje_de_Programaci%C3%B3n_Ruby

(s.f.). Obtenido de https://es.scribd.com/doc/317006684/lenguajes-y-compiladores-para-Ruby-

Scala-y-Go

(s.f.). Obtenido de http://aplicaciones-web-lenguajes-programaci.blogspot.mx/2011/12/ruby.html

11