Ruby

Ruby
Paradigma	multiparadigma: orientado a obxectos.
Data	1995
Deseñador	Yukihiro Matsumoto
Desenvolvedor	Yukihiro Matsumoto (e outros)
Última versión	1.9.0
Tipo de dato	forte, dinámico
Influído por	Smalltalk, Perl, Lisp, Scheme, Python, CLU, Eiffel, Ada, Dylan
Influíu	Groovy
Sistema operativo	Cross-platform
Licenza	Ruby License GNU General Public License
Web	[1]

Ruby é unha linguaxe de programación reflexivo e orientado a obxetos(linguaxe interpretada), creado polo programador xaponés Yukihiro "Matz" Matsumoto en 1993. Combina unha sintaxe inspirada en Python, Perl con características de programación orientada a obxetos similares a Smalltalk. Comparte tamén funcionalidade con outras linguaxes de programación como Lisp, Lua (linguaxe de programación), Dylan e CLU. Ruby é unha linguaxe de programación interpretada nunha soa pasada e a súa implementación oficial é distribuida baixo unha licencia de software libre.

Historia

Yukihiro Matsumoto, creador de Ruby.

A linguaxe foi creado por Yukihiro "Matz" Matsumoto, quen comezou a traballar o Ruby en 24 de febrero de 1993, e lanzóuno ó público no año 1995. O nome "Ruby" foi ideado en base á pedra correspondente ó mes de nacemento dun colega. Á data de Decembro de 2007,a última versión estable é a 1.8.6; o 26 de Decembro de 2007 foi publicado Ruby 1.9.0: unha versión de desenrrolo que incorpora melloras sustanciaies no rendimiento da linguaxe, que se espera queden reflexadas na próxima versión estable de producción da lenguaje, Ruby 2.0. Diferenzas en rendemento entre a actual implementación de Ruby (1.8.6) e outras lenguaxes de programación más arraigados levaron ó desarrollo de varias máquinas virtuales para Ruby. Entre ésas atópanse JRuby, un intento de levar Ruby á plataforma Java, e Rubinius, un intérprete modelado en base ás máquinas virtuales de Smalltalk.

.

Filosofía

O creador da linguaxe, Yukihiro "Matz" Matsumoto, dixo que Ruby foi deseñado para a productividade e divertimento do desenvolvedor, seguindo os principios dun bo deseño de interface de usuario. El afirma que os deseños de sistemas precisan ser deseñados para os humáns, fronte ás computadoras: :

A maioría da xente, especialmente os enxeñeiros informáticos, centranse nas máquinas. Pensan, "Facendo isto, a máquina correrá máis rápido. Facendo isto, a máquina será máis eficiente. Facendo isto, a máquina ..." Centranse nas máquinas. Pero de feito precisamos centrarnos nos humanos, en como os humanos levan a cabo a programación ou traballan cos ordenadores. Nos somos os maestros. Eles os escravos.

Ruby segue o principio da menor sorpresa (POLS), que significa que a linguaxe debería comportarse da forma que leve á minima confusión á experiencia do usuario. Matz ten dito que a súa primeira finalidade do deseño é facer unha linguaxe que el mesmo se divirpregando, minimizando o traballo do programador e a posible confusión. El non empregou o priniciop da menor sorpresa ó deseño de Ruby pero de todolos xeitos a frase xa está ben ligada á linguaxe de programación Ruby.

En mayo de 2005 nunha discusión na grupo de novas comp.lang.ruby, Matz tentaba distanciar Ruby de POLS, explicando que dende calqueira elección de deseño que sexa sorprendente para alguen, el emprega un estándar persoal na avaliación da sorpresa. Se o estándar persoal segue sendo consistente terá poucas sorpresas para aqueles que estexan acostumados ós estándares.[2]

Matz definíno desta forma nunha entrevista [3]: Todos teñen un transfondo individual. Alguns poden vir dende Python, outros dende Perl, e poden estar sorprendidos por diferentes aspectos da linguaxe. Eles poden vir e dicirme, 'Estou sorprendido por esta carcterística da linguaxe, porque Ruby vila o principio da menor sorpresa.' Espera. Espera. O principio da menor sorpresa non é prar ti. O principio da menor sorpresa significa principio da miña menor sorpresa. E isto significa a menor sorpresa despois de que aprendas Ruby bastante ben. Por exemplo, Eu fun un programador de C++ antes de que comezara a deseñar Ruby. Programei en C++ exclusivamente durante dous ou tres anos. E despois de dous anos de programación con C++, todavía me sorprendeu.

Semántica

Ruby é orientado a objetos: tódolos tipos de datos son un obxeto, incluídas as clases e tipos que outras linguaxes definen como primitivas, (como enteiros, booleanos, e "nil"). Toda función é un método. As variables sempre son referencias a obxetos, non os obxetos mismos. Ruby soporta herdanza con enlace dinámico, mixins e patróns singleton (pertencentes e definidos por unha soa instancia máis que definidos poa clase). A pesar de que Ruby non soporta herdanza múltiple, as clases poden importar módulos como mixins. A sintáxis procedural esta soportada, pero tódolos métodos definidos fora do ámbito dun objeto son realmente métodos da clase Object. Como esta clase é pai de tódalas demáis, os cambios son visibles para tódalas clases e obxetos.

Ruby descibíuse coma unha linguaxe de programación multiparadigma: permite programación procedural (definindo funcións e variables fora das clases facéndoas parte do obxeto raiz Object), con orientación a obxetos, (todo é un obxeto) ou funcionalmente (ten funcións anónimas, clausuras ou closures, e continuations; tódalas sentencias teñen valores, e as funcións devolven a última avaliación). Soporta introspección, reflexión e metaprogramación, ademáis de soporte para fios de execución xestionados polo intérprete . Ruby tentipado dinámico, e soporta polimorfismo.

De acordo coas preguntas frecuentes de Ruby , "Se che gusta Perl, gustarache Ruby e a súa sintaxe. Se che Smalltalk, gustarache Ruby e a súa semántica. Se che gusta Python, a enorme diferencia de diseño entre Python y Ruby/Perl pode que che convenza ou pode que non."

Características

• orientado a obxetos
• catro niveles de ámbito de variable: global, clase, instancia y local.
• manexo de excepcións
• iteradores e clausuras o closures (pasando bloques de código)
• expresións regulares nativas similares ás de Perl a nivel de linguaxe
• posibilidad de redefinir los operadores (sobrecarga de operadores)
• recolección de basura automática
• altamente portable
• Fíos de execución simultáneos en tódalas plataformas empregando green threads
• Carga dinámica de DLL/librerías compartidas na maioría das plataformas
• introspección, reflexión e metaprogramación
• amplia librería estándar
• soporta inxección de dependencias
• soporta alteración de obxetos en tempo de execución
• continuacións e xeneradores

Ruby actualmente non tiene soporte completo de Unicode, a pesar de tener soporte parcial para UTF-8.

Interacción

A distribución oficial de Ruby inclúe "irb"(Interactive Ruby Shell), un intérprete interactivo de líña de comandos que pode ser empregado para probar código de manera rápida. O seguinte fragmento de código representa unha mostra dunha sesión empregando irb:

$ irb
irb(main):001:0> puts "Hola Galiza"
Hola Galiza
=> nil
irb(main):002:0> 1+2
=> 3

Exemplos

Os seguintes exemplos poden ser executados na liña de comandos Ruby irb Interactive Ruby Shell ou gardados nun ficheiro e correlos dende a liña de comandos escribindo ruby <nome de ficheiro>

Exemplo Clásico Hola Mundo:

puts "Hola Mundo!"

Algún código Básico de Ruby:

# Todo, incluído os literais, son obxetos, así traballa:
-199.abs                                                # 199
"ruby mola".length                                   # 9
"Rick".index("c")                                       # 2
"¿Caralludo o día non?".downcase.split(//).sort.uniq.join  # " '?acdelnoru"

Conversións:

puts '¿Cal é o teu día favorito?'
numbero = gets.chomp
numero_saida = numbero.to_i + 1
puts numero_saida.to_s + ' é un número máis grande que o meu número favorito.'

Coleccións

Construído e empregando un array:

a = [1, 'hi', 3.14, 1, 2, [4, 5]]
 
a[2]           # 3.14
a.reverse      # [[4, 5], 2, 1, 3.14, 'hi', 1]
a.flatten.uniq # [1, 'hi', 3.14, 2, 4, 5]

Construcíndo e empregando un hash:

hash = { :auga => 'mollada', :lume => 'quente' }
puts hash[:lume] # Prints:  quente

hash.each_pair do |key, value| # ou:  hash.each do |key, value|
	puts "#{key} é #{value}"
end
 
# Imprimer:  auge é mollada
#          	 lume é quente

hash.delete_if {|key, value| key == :water} # Borra :water => 'wet'

Bloques e iteradores

Dúas sintaxes para crear un bloque de código:

{ puts "Hola Mundo!" } # Olla os { corchetes }

do puts "Hola Mundo!" end

Paso de parámetros a un bloque para ser envolto:

# Nunha variable de instancia de obxeto (denotado como '@'), lembra o bloque.
def recorda(&a_block)
	@bloque = a_block
end
 
# Invocamos o método anterior, pasándolle un bloque que colle un nome.
recorda {|nome| puts "Hola, #{nome}!"}
 
# Cando é o momento (para o obxeto) -- chamamos a envoltura!
@block.call("Jon")
# => "Hola, Jon!"

Retornando envolturas dun método:

def crear_set_e_get(valor_inicial=0) # Nota o valor por defecto de 0
	valor_envoltura = valor_inicial
	return Proc.new {|x| valor_envoltura = x}, Proc.new { valor_envoltura }
end

setter, getter = crear_set_and_get  # ie. volta dous valores
setter.call(21)
getter.call # => 21

Producindo o fluxo de control dun programa a un bloque que nos foi proporcionado cando se nos chamou:

 
def use_hola
	yield "hola"
end
 
# Invocamos o método anterior, pasandolle un bloque.
use_hola {|cadea| puts cadea} # => 'hola'

Iterando sobre enumeracións e arrays empregando bloques:

array = [1, 'hi', 3.14]
array.each { |elemento| puts elemento }
# => 1
# => 'hi'
# => 3.14

array.each_index { |indice| puts indice.to_s + ": " + array[indice] }
# => 0: 1
# => 1: 'hi'
# => 2: 3.14

(3..6).each { |num| puts num }
# => 3
# => 4
# => 5
# => 6

Un método como é inject() pode aceptar ámbolos parámetros e un bloque. Inject itera sobre cada elemento da lista, levando a cabo algunha función mentras se obten e agrega. Isto é analogo á función foldl nos linguaxes de programación funcional. Por exemplo:

[1,3,5].inject(10) {|suma, elemento| suma + elemento} # => 19

Na primeira chamada, o bloque recibe 10 (o argumento a inxectar) como suma, e 1 (o primeiro elmeento do array) como elmento, Isto volta 11. 11 logo é a suma no seguinte paso, ó cal se lle engade 3 para recoller 14. a 14 logo engadeselle 5, para finalmente voltar 19.

Traballo dos bloques en algúns métodos internos da linguaxe:

File.open('ficheiro.txt', 'w') do |ficheiro| # 'w' denota "modo escritura".
	file.puts 'Escribiu algún texto.'
end                                  # O ficheiro é automaticamente pechado aquí

File.readlines('ficheiro.txt').each do |liña|
	puts liña
end
# => Escribiru algún texto.

Empregando unha enumeración e un bloque para facer o cuadrado dos númeors 1 a 10:

(1..10).collect {|x| x*x} # => [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Repositorios e Librarías

O Ruby Application Archive (RAA), tamén coñecido coma RubyForge, serve como repositorio para un amplo rango de aplicazóns Ruby e librarías, contendo máis de dous centos de elementos. Aínda que o número de aplicacións non coinccide moito co volume de material dispoñíbel na comunidade Perl ou Python, hai un amplo rango de ferramentas e utilidades as cales seven para impulsar o desenvolvemento da linguaxe.

RubyGems chegou a ser o mantedor de paquetes estándar para as librarías Ruby. É moi similar en propositos ó de Perl CPAN, aínda que o seu uso é moi parecido a apt-get.

Criticas

A versión 1.8, a actual versión estable do interprete, ten algunhas limitacións, que inclúen:

• Rendemento -- o rendemento do interprete de Ruby está por detras das linguaxes comparables coma Perl, PHP, and Python [4] [5], principalmente debido ó deseño do interprete: para executar código Ruby, o interprete construe un arbore de sintaxe do código fonte e logo avalia o arbore de sintaxe directamente, no canto de compilalo directamente nunha forma executable máis eficiente.
• Threading -- o modelo de fios de ruby emprega fios verdes [6], e este modelo ten algunhas limitacións inherentes que acarrexan a dificultade de empregalo ou de non ter seguranza en escenarios específicos.[7].
• Unicode -- Ruby non ten todavía suporte nativo para Unicode ou cadeas multibyte [8].
• Compatibilidade cara atrás -- Ruby sofre de problemas de compatibilidade cara atrás con versións novas e vellas [9].

Ruby 2.0 é o obxetivo para eliminar estes problemas mencionados:

• Rendemento -- un novo e máis rápido intérprete, YARV, unha máquina virtual que executa instruccións, que son compiladas en instrucción nativas do procesador empregando o compilador JIT.
• Threading -- os fíos nativos empregaránse no canto de fíos verdes.[10]
• Unicode -- suporte compreto para cadeas Unicode.

A version 1.9, o código base que é considerado a versión de desenrrolo de 2.0 2.0, foi liberdada [11] o 26 de Decembro de 2007.

Algúns problemas aínda non foron solventados, polo que na versión 2.0 serán incluídos:

• Ruby todavía falla na especificación, a actual implementación C é a especificación referenza de facto [12] [13] .

Licenza

O intérprete e as bibliotecas están licenciadas de forma dual (inseparable) baixo as licencias libres e de código aberto GPL e Licenza Ruby.

Vexase tamén

• RubyGems (xestor de paquetes para Ruby)
• Ruby on Rails (framework orientado a aplicacións web en Ruby)
• JRuby (implementación en Java do intérprete de Ruby)
• Orientado a obxetos (Programación orientada a obxetos)

Ligazóns externas

• Ruby Sitio principal de Ruby en Internet.
• Ruby central Recursos sobre Ruby en Inglés.
• Rubíes Comunidad hispana de usuarios de Ruby.
• Ruby Tutorial tutorial en castelán de Ruby.
• Programming Ruby, David Thomas e Andrew Hunt. Libro libre
• Ruby Argentina Comunidad Arxentina de Ruby
• Ruby Venezuela Ruby de Venezuela
• Full Ruby on Rails Tutorial
• Inline::Ruby módulo Perl en CPAN para programar Ruby dentro de Perl (en inglés)
• rubyisms módulo Perl en CPAN que incorpora algunhas ideas de Ruby para Perl (en inglés)
• HTML::ERuby módulo Perl en CPAN que procesa linguaxe ERuby (en inglés)
• Syntax::Highlight::Engine::Kate::Ruby módulo Perl en CPAN para o coloreado sintáctico de Ruby dentro de Kate (en inglés)
• Inline::Ruby::dRuby::Client módulo Perl en CPAN, delegador de obxetos dRuby (en inglés)