**Ruby** é unha linguaxe de programación reflexiva e orientada a obxectos (linguaxe interpretada), creada polo programador xaponés Yukihiro "Matz" Matsumoto en 1993. Combina unha sintaxe inspirada en Python, Perl con características de programación orientada a obxectos similares a Smalltalk. Comparte tamén funcionalidade con outras linguaxes de programación como Lisp, Lua, Dylan e CLU. Ruby é unha linguaxe de programación interpretada nunha soa pasada e a súa posta en funcionamento oficial é distribuída baixo unha licenza 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 febreiro de 1993, e lanzouno ó público no ano 1995. O nome "Ruby" foi ideado en base á pedra correspondente ó mes de nacemento dun colega. En decembro de 2007,a última versión estable era a 1.8.6; o 26 de decembro de 2007 foi publicado Ruby 1.9.0: unha versión de desenvolvemento que incorpora melloras substanciais no rendemento da linguaxe, que se espera queden reflectidas na próxima versión estable de produción da linguaxe, Ruby 2.0. Diferenzas en rendemento entre a actual posta en funcionamento de Ruby (1.8.6) e outras linguaxes de programación más arraigados levaron ó desenvolvemento de varias máquinas virtuais para Ruby. Entre esas atópanse JRuby, un intento de levar Ruby á plataforma Java, e Rubinius, un intérprete modelado en base ás máquinas virtuais de Smalltalk.
.

Filosofía
---------

O creador da linguaxe, Yukihiro "Matz" Matsumoto, dixo que Ruby foi deseñado para a produtividade 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 humanos, fronte ás computadoras::

*A maioría da xente, especialmente os enxeñeiros informáticos, céntranse 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 ..." Céntranse 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 mestres. Eles os escravos.*

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

En maio de 2005 nunha discusión na grupo de novas comp.lang.ruby, Matz tentaba distanciar Ruby de POLS, explicando que dende calquera elección de deseño que sexa sorprendente para alguén, 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 estean acostumados ós estándares.

Matz definiuno desta forma nunha entrevista :
*Todos teñen un transfundo individual. Algúns 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 característica da linguaxe, porque Ruby viola o principio da menor sorpresa.' Espera. Espera. O principio da menor sorpresa non é só para 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 comezar a deseñar Ruby. Programei en C++ exclusivamente durante dous ou tres anos. E despois de dous anos de programación con C++, incluso me sorprendeu.*

Semántica
---------

Ruby é orientado a obxectos: tódolos tipos de datos son un obxecto, 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 obxectos, non os obxectos mesmos. Ruby soporta herdanza con enlace dinámico, mixins e padróns singleton (pertencentes e definidos por unha soa instancia máis que definidos pola clase). A pesar de que Ruby non soporta herdanza múltiple, as clases poden importar módulos como mixins. A sintaxe procedural esta soportada, pero tódolos métodos definidos fora do ámbito dun obxecto son realmente métodos da clase Object. Como esta clase é pai de todas as demais, os cambios son visibles para tódalas clases e obxectos.

Ruby describiuse coma unha linguaxe de programación multiparadigma: permite programación procedural (definindo funcións e variables fora das clases facéndoas parte do obxecto raíz Object), con orientación a obxectos, (todo é un obxecto) ou funcionalmente (ten funcións anónimas, clausuras ou closures, e continuations; tódalas sentenzas teñen valores, e as funcións devolven a última avaliación). Soporta introspección, reflexión e metaprogramación, ademais de soporte para fíos de execución xestionados polo intérprete. Ruby ten tipado 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 diferenza de deseño entre Python y Ruby/Perl pode que che convenza ou pode que non."

Características
---------------

* orientado a obxectos.
* catro niveis de ámbito de variable: global, clase, instancia e local.
* manexo de excepcións.
* iteradores e clausuras ou closures (pasando bloques de código).
* expresións regulares nativas similares ás de Perl a nivel de linguaxe.
* posibilidade de redefinir os operadores (sobrecarga de operadores).
* recolección de lixo 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.
* ampla librería estándar.
* soporta inxección de dependencias.
* soporta alteración de obxectos en tempo de execución.
* continuacións e xeradores.

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

Sintaxe
-------

A sintaxe de Ruby é moi similar á de Perl e Python. As definicións de clases e métodos son sinaladas por palabras chave. En contraste con Perl, as variables non son prefixadas obrigatoriamente cun símbolo símbolo. Cando son empregados, os símbolos cambian a semántica do ámbito da variable. A diferenza máis grande dende C e Perl son que as palabras chave son normalmente empregadas para definir bloques de código lóxico, sen corchetes (p.e. pares de { e }). Os finais de liña son significativos e recollen o final da declaración ; un punto e coma pode ser equivalentemente empregado. Fronte a Python, a indentación non é significativa.

Unha das diferenzas de Ruby comparado con Python e Perl é que Ruby fai as variables de instancia totalmente privadas á clase e só as mostra a través de métodos accesores (attr\_writer, attr\_reader etc).

Fronte ós métodos "getter" e "setter" doutras linguaxes como C++ ou Java, os métodos de acceso en Ruby poden ser escritos nunha soa liña de código. Como a invocación destes métodos non require o emprego de parénteses isto fai trivial os cambios nas variables de instancia nunha clase completa, modificando unha única liña de código e sen ter que facer unha refactorización para ter outra funcionalidade, isto é similar ás propiedades dos membros en C# e VB.NET. Os descritores de propiedades en Python son similares, pero traen un proceso de desenvolvemento. Se un comeza en Python a empregar variables de instancia expostas publicamente, o código interno da clase pode precisar o axuste para empregar unha variable de privada fronte a unha propiedade pública, Ruby elimina esta decisión de deseño forzando a tódalas variables de instancia a ser privadas, pero tamén proporciona unha forma simple de declarar métodos de set e get. Isto mantén nunha idea de que en Ruby, un nunca accederá directamente ós valores internos dos membros da clase dende fóra dela. Polo tanto terá que a pasar unha mensaxe á clase e recibir unha resposta.

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

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

```

Falla
-----

### Características da linguaxe

En termos de velocidade, Ruby ten un rendemento inferior a algunhas linguaxes compiladas (xa que é unha linguaxe interpretada) e outras linguaxes maioritarias de script como Python e Perl. Porén, en futuras versións (revisión actual: 1.9), Ruby será compilado bytecode para ser executado en YARV (*Yet Another Ruby VM*). Actualmente, o memory footprint(emprego de memoria) de Ruby é superior para as mesmas operacións que as de Perl e Python.

A omisión dos parénteses nos argumentos dos métodos poden levar a resultados inesperados se os métodos recollen parámetros múltiples. Nótese que os desenvolvedores de Ruby advertiron que a omisión de parénteses en métodos multi-parametrais será eliminado en futuras versións de Ruby, o intérprete de Ruby actualmente (Feb 2007) volta unha advertencia que advirte ó escritor de *non* omitir os `()`, para evitar significados ambiguos no código. O non emprego dos `()` así e todo é tamén unha práctica moi común, e pode ser especialmente boa para empregar Ruby coma unha linguaxe de máis lexible polas persoas, ademais do método chamado `method_missing()`.

A lista de "falla" pode ser atopado no libro de Hal Fulton *The Ruby Way*, 2nd ed (ISBN 0-672-32884-4), Section 1.5. Unha lista similar á da 1ª edición escrita para a anterior versión da linguaxe (versión 1.6), algúns problemas solucionáronse co tempo. `retry`, por exemplo, agora funciona con `while`, `until`, e `for`, así coma cos iteradores.

Repositorios e librarías
------------------------

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

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

Implementacións
---------------

Ruby ten dúas grandes postas en funcionamento: O Ruby oficial intérprete tamén chamando como o Matz's Ruby Interpreter(Intérprete de Ruby de Matz) (MRI), o máis estendido, e JRuby, a posta en funcionamento baseada en Java.

Hai outras postas en funcionamento como son IronRuby (pre-alpha fontes dispoñibles dende o 31 de agosto de 2007), Rubinius, Ruby.NET, XRuby e YARV. YARV é a nova máquina virtual oficial de Ruby 1.9 non estará dispoñible como un proxecto separado dende a devandita versión.

### Sistemas operativos

Están dispoñibles versións do interprete de Ruby para os seguintes sistemas operativos:

* Acorn RISC OS.
* Amiga.
* BeOS.
* DOS.
* Linux.
* Mac OS X.
* Maemo.
* Microsoft Windows 95/98/2000/2003/NT/XP/Vista.
* Microsoft Windows CE.
* MorphOS.
* OS/2.
* OpenVMS.
* Syllable.
* Symbian OS.
* Blue Gene/L nodo de computo do kernel.
* A maioría dos sabores de Unix.

Existen outros portes que non se listaron aquí.

Críticas
--------

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

* **Rendemento** -- o rendemento do intérprete de Ruby está por detrás das linguaxes comparables coma Perl, PHP, and Python [http://www.joelonsoftware.com/items/2006/09/12.html, principalmente debido ó deseño do interprete: para executar código Ruby, o interprete constrúe unha árbore de sintaxe do código fonte e logo avalía a árbore de sintaxe directamente, no canto de compilala directamente nunha forma executable máis eficiente.
* **Threading** -- o modelo de fíos de ruby emprega fíos verdes , e este modelo ten algunhas limitacións inherentes que carrexan a dificultade de empregalo ou de non ter seguranza en escenarios específicos..
* **Unicode** -- Ruby non ten aínda soporte nativo para Unicode ou cadeas multibyte .
* **Compatibilidade cara atrás** -- Ruby sofre de problemas de compatibilidade cara atrás con versións novas e vellas .

Ruby 2.0 é o obxectivo para eliminar estes problemas mencionados:

* **Rendemento** -- un novo e máis rápido intérprete, YARV, unha máquina virtual que executa instrucións, que son compiladas en instrución nativas do procesador empregando o compilador JIT.
* **Threading** -- os fíos nativos empregaranse no canto de fíos verdes.
* **Unicode** -- soporte completo para cadeas Unicode.

A versión 1.9, o código base que é considerado a versión de desenvolvemento de 2.0 2.0, foi liberada  Arquivado 04 de setembro de 2012 en Wayback Machine. o 26 de decembro de 2007.

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

* Ruby aínda falla na especificación, a actual implementación C é a especificación referencia *de facto*   Arquivado 28 de marzo de 2008 en Wayback Machine. .

Licenza
-------

O intérprete e as bibliotecas están licenciadas de forma dual (inseparable) baixo as licenzas libres e de código aberto GPL e Licenza Ruby Arquivado 26 de agosto de 2011 en Wayback Machine..

Notas
-----

1. ↑  A linguaxe de programación Ruby foi liberada por Yukihiro Matsumoto o día 06-12-2000 (informit.com)
2. ↑  A filosofía de Ruby, unha conversa con Yukihiro Matsumoto, Parte I por Bill Venners en 29-9-2003 (Desenvolvedor de Artima)
3. ↑  "Ruby FAQ". Arquivado dende o orixinal o 09 de decembro de 2007. Consultado o 07 de xaneiro de 2008.
4. 1 2  "The Computer Language Benchmarks Game". Arquivado dende o orixinal o 29 de maio de 2018. Consultado o 19 de xaneiro de 2008.
5. ↑  John Lam (2007-08-31). "IronRuby on Rubyforge!". Arquivado dende o orixinal o 03 de setembro de 2007. Consultado o 19 de xaneiro de 2008.

Véxase tamén
------------

### Outros artigos

* RubyGems (xestor de paquetes para Ruby)
* Ruby on Rails (framework orientado a aplicacións web en Ruby)

### Ligazóns externas

* Ruby Sitio principal de Ruby en Internet.
* 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 obxectos dRuby (en inglés)

| * v
* c
* e
Linguaxes de programación |
| --- |
| Baixo nivel | 

|  |  |
| --- | --- |
| Primeira xeración | Código máquina |
| Segunda xeración | Assembly |

 |
| Alto nivel | 

|  |  |
| --- | --- |
| Terceira xeración | 
* A+
* ABC
* Algol
* B
* BASIC
* C
* C++
* C#
* COBOL
* CPL
* D
* E
* Fortran
* Go
* Java
* JavaScript
* Lisp
* Objective-C
* PL/1
* Pascal
* Smalltalk
* Visual Basic .NET

 |
| Cuarta xeración | 
* Clarion
* Clipper
* Clojure
* Common Lisp
* Erlang
* GNU Octave
* Haskell
* Lisp
* Lua
* Julia
* Perl
* PHP
* Prolog
* Python
* R
* Ruby
* Rust
* S
* Scilab
* Stata
* SQL

 |
| Quinta xeración | 
* Mercury
* OPS5
* Prolog

 |

 |
| 
* Ambiente de desenvolvemento
* Metaprogramación
* Programación a nivel funcional
* Programación estruturada
* Programación non estruturada
* Programación imperativa
* Programación modular
* Programación multidimensional
* Orientación a obxectos

 |

|  |  |
| --- | --- |
| Control de autoridades | 
* Wd: Q161053
* BNE: XX4424926
* BNF: 144105976
* GND: 4653817-3
* LCCN: sh00000128
* NKC: ph503938
* PSH: 13862
* SUDOC: 07705802X

 |