summaryrefslogtreecommitdiffhomepage
path: root/es-es
diff options
context:
space:
mode:
Diffstat (limited to 'es-es')
-rw-r--r--es-es/c-es.html.markdown2
-rw-r--r--es-es/clojure-es.html.markdown393
-rw-r--r--es-es/coffeescript-es.html.markdown57
-rw-r--r--es-es/csharp-es.html.markdown632
-rw-r--r--es-es/git-es.html.markdown411
-rw-r--r--es-es/go-es.html.markdown326
-rw-r--r--es-es/julia-es.html.markdown759
-rw-r--r--es-es/perl-es.html.markdown160
8 files changed, 2739 insertions, 1 deletions
diff --git a/es-es/c-es.html.markdown b/es-es/c-es.html.markdown
index b109f761..5d3aae0c 100644
--- a/es-es/c-es.html.markdown
+++ b/es-es/c-es.html.markdown
@@ -284,7 +284,7 @@ for (xx=0; xx<20; xx++) {
// impredecibles
printf("%d\n", *(my_ptr + 21)); // => Prints who-knows-what?
-// Cuando hallas acabado con el bloque de memoría malloc, necesitas
+// Cuando hayas acabado con el bloque de memoría malloc, necesitas
// liberarlo o sino nadie más podrá usarlo hasta que tu programa se cierre
free(my_ptr);
diff --git a/es-es/clojure-es.html.markdown b/es-es/clojure-es.html.markdown
new file mode 100644
index 00000000..150d0bb2
--- /dev/null
+++ b/es-es/clojure-es.html.markdown
@@ -0,0 +1,393 @@
+---
+language: clojure
+filename: learnclojure-es.clj
+contributors:
+ - ["Adam Bard", "http://adambard.com/"]
+translators:
+ - ["Antonio Hernández Blas", "https://twitter.com/nihilipster"]
+ - ["Guillermo Vayá Pérez", "http://willyfrog.es"]
+lang: es-es
+---
+
+Clojure es un lenguaje de la familia Lisp desarrollado sobre la Máquina Virtual
+de Java. Tiene un énfasis mayor en la [programación funcional](https://es.wikipedia.org/wiki/Programación_funcional) pura
+que Common Lisp, pero incluyendo la posibilidad de usar [SMT](https://es.wikipedia.org/wiki/Memoria_transacional) para manipular
+el estado según se presente.
+
+Esta combinación le permite gestionar la concurrencia de manera muy sencilla
+y a menudo automáticamente.
+
+(Necesitas la versión de Clojure 1.2 o posterior)
+
+
+```clojure
+; Los comentatios comienzan con punto y coma.
+
+; Clojure se escribe mediante "forms" (patrones), los cuales son
+; listas de objectos entre paréntesis, separados por espacios en blanco.
+
+; El "reader" (lector) de Clojure asume que el primer objeto es una
+; función o una macro que se va a llamar, y que el resto son argumentos.
+
+; El primer form en un archivo debe ser ns, para establecer el namespace (espacio de
+; nombres)
+(ns learnclojure)
+
+; Algunos ejemplos básicos:
+
+; str crea una cadena de caracteres a partir de sus argumentos
+(str "Hello" " " "World") ; => "Hello World"
+
+; Las operaciones matemáticas son sencillas
+(+ 1 1) ; => 2
+(- 2 1) ; => 1
+(* 1 2) ; => 2
+(/ 2 1) ; => 2
+
+; La igualdad es =
+(= 1 1) ; => true
+(= 2 1) ; => false
+
+; También es necesaria la negación para las operaciones lógicas
+(not true) ; => false
+
+; Cuando se anidan Los patrones, estos funcionan de la manera esperada
+(+ 1 (- 3 2)) ; = 1 + (3 - 2) => 2
+
+; Tipos
+;;;;;;;;;;;;;
+
+; Clojure usa los tipos de objetos de Java para booleanos, strings (cadenas de
+; caracteres) y números.
+; Usa class para saber de qué tipo es.
+(class 1); Los enteros son java.lang.Long por defecto
+(class 1.); Los numeros en coma flotante son java.lang.Double
+(class ""); Los strings van entre comillas dobles, y son
+; son java.lang.String
+(class false); Los Booleanos son java.lang.Boolean
+(class nil); El valor "null" se escribe nil
+
+; Si quieres crear una lista de datos, precedela con una comilla
+; simple para evitar su evaluación
+'(+ 1 2) ; => (+ 1 2)
+; (que es una abreviatura de (quote (+ 1 2)) )
+
+; Puedes evaluar una lista precedida por comilla con eval
+(eval '(+ 1 2)) ; => 3
+
+; Colecciones & Secuencias
+;;;;;;;;;;;;;;;;;;;
+
+; Las Listas están basadas en las listas enlazadas, mientras que los Vectores en
+; arrays.
+; ¡Los Vectores y las Listas también son clases de Java!
+(class [1 2 3]); => clojure.lang.PersistentVector
+(class '(1 2 3)); => clojure.lang.PersistentList
+
+; Una lista podría ser escrita como (1 2 3), pero debemos ponerle una
+; comilla simple delante para evitar que el reader piense que es una función.
+; Además, (list 1 2 3) es lo mismo que '(1 2 3)
+
+; Las "Colecciones" son solo grupos de datos
+; Tanto las listas como los vectores son colecciones:
+(coll? '(1 2 3)) ; => true
+(coll? [1 2 3]) ; => true
+
+; Las "Secuencias" (seqs) son descripciones abstractas de listas de datos.
+; Solo las listas son seqs.
+(seq? '(1 2 3)) ; => true
+(seq? [1 2 3]) ; => false
+
+; Una seq solo necesita proporcionar una entrada cuando es accedida.
+; Así que, las seqs pueden ser perezosas -- pueden establecer series infinitas:
+(range 4) ; => (0 1 2 3)
+(range) ; => (0 1 2 3 4 ...) (una serie infinita)
+(take 4 (range)) ; (0 1 2 3)
+
+; Usa cons para agregar un elemento al inicio de una lista o vector
+(cons 4 [1 2 3]) ; => (4 1 2 3)
+(cons 4 '(1 2 3)) ; => (4 1 2 3)
+
+; conj agregará un elemento a una colección en la forma más eficiente.
+; Para listas, se añade al inicio. Para vectores, al final.
+(conj [1 2 3] 4) ; => [1 2 3 4]
+(conj '(1 2 3) 4) ; => (4 1 2 3)
+
+; Usa concat para concatenar listas o vectores
+(concat [1 2] '(3 4)) ; => (1 2 3 4)
+
+; Usa filter y map para actuar sobre colecciones
+(map inc [1 2 3]) ; => (2 3 4)
+(filter even? [1 2 3]) ; => (2)
+
+; Usa reduce para combinar sus elementos
+(reduce + [1 2 3 4])
+; = (+ (+ (+ 1 2) 3) 4)
+; => 10
+
+; reduce puede tener un argumento indicando su valor inicial.
+(reduce conj [] '(3 2 1))
+; = (conj (conj (conj [] 3) 2) 1)
+; => [3 2 1]
+
+; Funciones
+;;;;;;;;;;;;;;;;;;;;;
+
+; Usa fn para crear nuevas funciones. Una función siempre devuelve
+; su última expresión
+(fn [] "Hello World") ; => fn
+
+; (Necesitas rodearlo con paréntesis para invocarla)
+((fn [] "Hello World")) ; => "Hello World"
+
+; Puedes crear una var (variable) mediante def
+(def x 1)
+x ; => 1
+
+; Asigna una función a una var
+(def hello-world (fn [] "Hello World"))
+(hello-world) ; => "Hello World"
+
+; Puedes defn como atajo para lo anterior
+(defn hello-world [] "Hello World")
+
+; El [] es el vector de argumentos de la función.
+(defn hello [name]
+ (str "Hello " name))
+(hello "Steve") ; => "Hello Steve"
+
+; Otra abreviatura para crear funciones es:
+(def hello2 #(str "Hello " %1))
+(hello2 "Fanny") ; => "Hello Fanny"
+
+; Puedes tener funciones multi-variadic: funciones con un numero variable de
+; argumentos
+(defn hello3
+ ([] "Hello World")
+ ([name] (str "Hello " name)))
+(hello3 "Jake") ; => "Hello Jake"
+(hello3) ; => "Hello World"
+
+; Las funciones pueden usar argumentos extras dentro de un seq utilizable en la función
+(defn count-args [& args]
+ (str "You passed " (count args) " args: " args))
+(count-args 1 2 3) ; => "You passed 3 args: (1 2 3)"
+
+; Y puedes mezclarlos con el resto de argumentos declarados de la función.
+(defn hello-count [name & args]
+ (str "Hello " name ", you passed " (count args) " extra args"))
+(hello-count "Finn" 1 2 3)
+; => "Hello Finn, you passed 3 extra args"
+
+
+; Mapas
+;;;;;;;;;;
+
+; Mapas de Hash y mapas de arrays comparten una misma interfaz. Los mapas de Hash
+; tienen búsquedas más rápidas pero no mantienen el orden de las claves.
+(class {:a 1 :b 2 :c 3}) ; => clojure.lang.PersistentArrayMap
+(class (hash-map :a 1 :b 2 :c 3)) ; => clojure.lang.PersistentHashMap
+
+; Los mapas de arrays se convertidos en mapas de Hash en la mayoría de
+; operaciones si crecen mucho, por lo que no debes preocuparte.
+
+; Los mapas pueden usar cualquier tipo para sus claves, pero generalmente las
+; keywords (palabras clave) son lo habitual.
+; Las keywords son parecidas a cadenas de caracteres con algunas ventajas de eficiencia
+(class :a) ; => clojure.lang.Keyword
+
+(def stringmap {"a" 1, "b" 2, "c" 3})
+stringmap ; => {"a" 1, "b" 2, "c" 3}
+
+(def keymap {:a 1, :b 2, :c 3})
+keymap ; => {:a 1, :c 3, :b 2}
+
+; Por cierto, las comas son equivalentes a espacios en blanco y no hacen
+; nada.
+
+; Recupera un valor de un mapa tratandolo como una función
+(stringmap "a") ; => 1
+(keymap :a) ; => 1
+
+; ¡Las keywords pueden ser usadas para recuperar su valor del mapa, también!
+(:b keymap) ; => 2
+
+; No lo intentes con strings.
+;("a" stringmap)
+; => Exception: java.lang.String cannot be cast to clojure.lang.IFn
+
+; Si preguntamos por una clave que no existe nos devuelve nil
+(stringmap "d") ; => nil
+
+; Usa assoc para añadir nuevas claves a los mapas de Hash
+(def newkeymap (assoc keymap :d 4))
+newkeymap ; => {:a 1, :b 2, :c 3, :d 4}
+
+; Pero recuerda, ¡los tipos de Clojure son inmutables!
+keymap ; => {:a 1, :b 2, :c 3}
+
+; Usa dissoc para eliminar llaves
+(dissoc keymap :a :b) ; => {:c 3}
+
+; Conjuntos
+;;;;;;
+
+(class #{1 2 3}) ; => clojure.lang.PersistentHashSet
+(set [1 2 3 1 2 3 3 2 1 3 2 1]) ; => #{1 2 3}
+
+; Añade un elemento con conj
+(conj #{1 2 3} 4) ; => #{1 2 3 4}
+
+; Elimina elementos con disj
+(disj #{1 2 3} 1) ; => #{2 3}
+
+; Comprueba su existencia usando el conjunto como una función:
+(#{1 2 3} 1) ; => 1
+(#{1 2 3} 4) ; => nil
+
+; Hay más funciones en el namespace clojure.sets
+
+; Patrones útiles
+;;;;;;;;;;;;;;;;;
+
+; Las construcciones lógicas en clojure son macros, y presentan el mismo aspecto
+; que el resto de forms.
+(if false "a" "b") ; => "b"
+(if false "a") ; => nil
+
+; Usa let para crear un binding (asociación) temporal
+(let [a 1 b 2]
+ (> a b)) ; => false
+
+; Agrupa expresiones mediante do
+(do
+ (print "Hello")
+ "World") ; => "World" (prints "Hello")
+
+; Las funciones tienen implicita la llamada a do
+(defn print-and-say-hello [name]
+ (print "Saying hello to " name)
+ (str "Hello " name))
+(print-and-say-hello "Jeff") ;=> "Hello Jeff" (prints "Saying hello to Jeff")
+
+; Y el let también
+(let [name "Urkel"]
+ (print "Saying hello to " name)
+ (str "Hello " name)) ; => "Hello Urkel" (prints "Saying hello to Urkel")
+
+; Módulos
+;;;;;;;;;;;;;;;
+
+; Usa use para obtener todas las funciones del módulo
+(use 'clojure.set)
+
+; Ahora podemos usar más operaciones de conjuntos
+(intersection #{1 2 3} #{2 3 4}) ; => #{2 3}
+(difference #{1 2 3} #{2 3 4}) ; => #{1}
+
+; Puedes escoger un subgrupo de funciones a importar, también
+(use '[clojure.set :only [intersection]])
+
+; Usa require para importar un módulo
+(require 'clojure.string)
+
+; Usa / para llamar a las funciones de un módulo
+; Aquí, el módulo es clojure.string y la función es blank?
+(clojure.string/blank? "") ; => true
+
+; Puedes asignarle una abreviatura a un modulo al importarlo
+(require '[clojure.string :as str])
+(str/replace "This is a test." #"[a-o]" str/upper-case) ; => "THIs Is A tEst."
+; (#"" es una expresión regular)
+
+; Puedes usar require (y use, pero no lo hagas) desde un espacio de nombre
+; usando :require,
+; No necesitas preceder con comilla simple tus módulos si lo haces de esta
+; forma.
+(ns test
+ (:require
+ [clojure.string :as str]
+ [clojure.set :as set]))
+
+; Java
+;;;;;;;;;;;;;;;;;
+
+; Java tiene una enorme librería estándar, por lo que resulta util
+; aprender como interactuar con ella.
+
+; Usa import para cargar un módulo de java
+(import java.util.Date)
+
+; Puedes importar desde un ns también.
+(ns test
+ (:import java.util.Date
+ java.util.Calendar))
+
+; Usa el nombre de la clase con un "." al final para crear una nueva instancia
+(Date.) ; <un objeto Date>
+
+; Usa "." para llamar a métodos o usa el atajo ".método"
+(. (Date.) getTime) ; <un timestamp>
+(.getTime (Date.)) ; exactamente la misma cosa
+
+; Usa / para llamar métodos estáticos.
+(System/currentTimeMillis) ; <un timestamp> (System siempre está presente)
+
+; Usa doto para hacer frente al uso de clases (mutables) más tolerable
+(import java.util.Calendar)
+(doto (Calendar/getInstance)
+ (.set 2000 1 1 0 0 0)
+ .getTime) ; => A Date. set to 2000-01-01 00:00:00
+
+; STM
+;;;;;;;;;;;;;;;;;
+
+; Software Transactional Memory es un mecanismo que usa clojure para gestionar
+; el estado persistente. Hay unas cuantas construcciones en clojure que
+; hacen uso de este mecanismo.
+
+; Un atom es el más sencillo. Se le da un valor inicial
+(def my-atom (atom {}))
+
+; Actualiza un atom con swap!
+; swap! toma una función y la llama con el valor actual del atom
+; como su primer argumento, y cualquier argumento restante como el segundo
+(swap! my-atom assoc :a 1) ; Establece my-atom al resultado de (assoc {} :a 1)
+(swap! my-atom assoc :b 2) ; Establece my-atom al resultado de (assoc {:a 1} :b 2)
+
+; Usa '@' para no referenciar al atom sino para obtener su valor
+my-atom ;=> Atom<#...> (Regresa el objeto Atom)
+@my-atom ; => {:a 1 :b 2}
+
+; Un sencillo contador usando un atom sería
+(def counter (atom 0))
+(defn inc-counter []
+ (swap! counter inc))
+
+(inc-counter)
+(inc-counter)
+(inc-counter)
+(inc-counter)
+(inc-counter)
+
+@counter ; => 5
+
+; Otros forms que utilizan STM son refs y agents.
+; Refs: http://clojure.org/refs
+; Agents: http://clojure.org/agents
+### Lectura adicional
+
+Ésto queda lejos de ser exhaustivo, pero espero que sea suficiente para que puedas empezar tu camino.
+
+Clojure.org tiene muchos artículos:
+[http://clojure.org/](http://clojure.org/)
+
+Clojuredocs.org contiene documentación con ejemplos para la mayoría de
+funciones principales (pertenecientes al core):
+[http://clojuredocs.org/quickref/Clojure%20Core](http://clojuredocs.org/quickref/Clojure%20Core)
+
+4Clojure es una genial forma de mejorar tus habilidades con clojure/FP:
+[http://www.4clojure.com/](http://www.4clojure.com/)
+
+Clojure-doc.org (sí, de verdad) tiene un buen número de artículos con los que iniciarse en Clojure:
+[http://clojure-doc.org/](http://clojure-doc.org/)
diff --git a/es-es/coffeescript-es.html.markdown b/es-es/coffeescript-es.html.markdown
new file mode 100644
index 00000000..6bf430e6
--- /dev/null
+++ b/es-es/coffeescript-es.html.markdown
@@ -0,0 +1,57 @@
+---
+language: coffeescript
+lang: es-es
+contributors:
+ - ["Tenor Biel", "http://github.com/L8D"]
+translators:
+ - ["Pablo Elices", "http://github.com/pabloelices"]
+filename: coffeescript-es.coffee
+---
+
+``` coffeescript
+# CoffeeScript es un lenguaje hipster.
+# Tiene convenciones de muchos lenguajes modernos.
+# Los comentarios son como en Ruby y Python, usan almohadillas.
+
+###
+Los comentarios en bloque son como estos, y se traducen directamente a '/*' y '*/'
+para el código JavaScript resultante.
+
+Deberías entender la mayor parte de la semántica de JavaScript antes de continuar.
+###
+
+# Asignación:
+number = 42 #=> var number = 42;
+opposite = true #=> var opposite = true;
+
+# Condiciones:
+number = -42 if opposite #=> if(opposite) { number = -42; }
+
+# Funciones:
+square = (x) -> x * x #=> var square = function(x) { return x * x; }
+
+# Rangos:
+list = [1..5] #=> var list = [1, 2, 3, 4, 5];
+
+# Objetos:
+math =
+ root: Math.sqrt
+ square: square
+ cube: (x) -> x * square x
+#=> var math = {
+# "root": Math.sqrt,
+# "square": square,
+# "cube": function(x) { return x * square(x); }
+#}
+
+# Número de argumentos variable:
+race = (winner, runners...) ->
+ print winner, runners
+
+# Existencia:
+alert "I knew it!" if elvis?
+#=> if(typeof elvis !== "undefined" && elvis !== null) { alert("I knew it!"); }
+
+# Listas:
+cubes = (math.cube num for num in list) #=> ...
+```
diff --git a/es-es/csharp-es.html.markdown b/es-es/csharp-es.html.markdown
new file mode 100644
index 00000000..ef26d8ce
--- /dev/null
+++ b/es-es/csharp-es.html.markdown
@@ -0,0 +1,632 @@
+---
+language: c#
+contributors:
+ - ["Irfan Charania", "https://github.com/irfancharania"]
+ - ["Max Yankov", "https://github.com/golergka"]
+translators:
+ - ["Olfran Jiménez", "https://twitter.com/neslux"]
+filename: LearnCSharp-es.cs
+lang: es-es
+---
+
+C# es un lenguaje orientado a objetos elegante y de tipado seguro que
+permite a los desarrolladores construir una variedad de aplicaciones
+seguras y robustas que se ejecutan en el Framework .NET.
+
+[Lee más aquí.](http://msdn.microsoft.com/es-es/library/vstudio/z1zx9t92.aspx)
+
+```c#
+// Los comentarios de una sola línea comienzan con //
+/*
+Los comentarios de múltiples líneas son de esta manera
+*/
+/// <summary>
+/// Este es un comentario de documentación XML
+/// </summary>
+
+// Especifica el espacio de nombres que estará usando la aplicación
+using System;
+using System.Collections.Generic;
+
+
+// Define un ambito para organizar el código en "paquetes"
+namespace Learning
+{
+ // Cada archivo .cs debe contener al menos una clase con el mismo nombre que el archivo
+ // Se permite colocar cualquier nombre, pero no deberías por cuestiones de consistencia.
+ public class LearnCSharp
+ {
+ // Una aplicación de consola debe tener un método main como punto de entrada
+ public static void Main(string[] args)
+ {
+ // Usa Console.WriteLine para imprimir líneas
+ Console.WriteLine("Hello World");
+ Console.WriteLine(
+ "Integer: " + 10 +
+ " Double: " + 3.14 +
+ " Boolean: " + true);
+
+ // Para imprimir sin una nueva línea, usa Console.Write
+ Console.Write("Hello ");
+ Console.Write("World");
+
+
+ ///////////////////////////////////////////////////
+ // Variables y Tipos
+ //
+ // Declara una variable usando <tipo> <nombre>
+ ///////////////////////////////////////////////////
+
+ // Sbyte - Entero de 8 bits con signo
+ // (-128 <= sbyte <= 127)
+ sbyte fooSbyte = 100;
+
+ // Byte - Entero de 8 bits sin signo
+ // (0 <= byte <= 255)
+ byte fooByte = 100;
+
+ // Short - Entero de 16 bits con signo
+ // (-32,768 <= short <= 32,767)
+ short fooShort = 10000;
+
+ // Ushort - Entero de 16 bits sin signo
+ // (0 <= ushort <= 65,535)
+ ushort fooUshort = 10000;
+
+ // Integer - Entero de 32 bits con signo
+ // (-2,147,483,648 <= int <= 2,147,483,647)
+ int fooInt = 1;
+
+ // Uinteger - Entero de 32 bits sin signo
+ // (0 <= uint <= 4,294,967,295)
+ uint fooUint = 1;
+
+ // Long - Entero de 64 bits con signo
+ // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+ long fooLong = 100000L;
+ // L es usado para indicar que esta variable es de tipo long o ulong
+ // un valor sin este sufijo es tratado como int o uint dependiendo del tamaño.
+
+ // Ulong - Entero de 64 bits sin signo
+ // (0 <= ulong <= 18,446,744,073,709,551,615)
+ ulong fooUlong = 100000L;
+
+ // Float - Precisión simple de 32 bits. IEEE 754 Coma flotante
+ // Precisión: 7 dígitos
+ float fooFloat = 234.5f;
+ // f es usado para indicar que el valor de esta variable es de tipo float
+ // de otra manera sería tratado como si fuera de tipo double.
+
+ // Double - Doble precisión de 32 bits. IEEE 754 Coma flotante
+ // Precisión: 15-16 dígitos
+ double fooDouble = 123.4;
+
+ // Bool - true & false (verdadero y falso)
+ bool fooBoolean = true;
+ bool barBoolean = false;
+
+ // Char - Un solo caracter Unicode de 16 bits
+ char fooChar = 'A';
+
+ // Strings
+ string fooString = "My string is here!";
+ Console.WriteLine(fooString);
+
+ // Formato de cadenas
+ string fooFs = string.Format("Check Check, {0} {1}, {0} {1:0.0}", 1, 2);
+ Console.WriteLine(fooFormattedString);
+
+ // Formato de fechas
+ DateTime fooDate = DateTime.Now;
+ Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy"));
+
+ // \n es un caracter de escape que comienza una nueva línea
+ string barString = "Printing on a new line?\nNo Problem!";
+ Console.WriteLine(barString);
+
+ // Puede ser escrito mejor usando el símbolo @
+ string bazString = @"Here's some stuff
+ on a new line!";
+ Console.WriteLine(bazString);
+
+ // Las comillas deben ser escapadas
+ // usa \" para escaparlas
+ string quotedString = "some \"quoted\" stuff";
+ Console.WriteLine(quotedString);
+
+ // usa "" cuando las cadenas comiencen con @
+ string quotedString2 = @"some MORE ""quoted"" stuff";
+ Console.WriteLine(quotedString2);
+
+ // Usa const o readonly para hacer las variables inmutables
+ // los valores const son calculados en tiempo de compilación
+ const int HOURS_I_WORK_PER_WEEK = 9001;
+
+ // Tipos que aceptan valores NULL (Nullable)
+ // cualquier tipo de dato puede ser un tipo nulo añadiendole el sufijo ?
+ // <tipo>? <variable> = <valor>
+ int? nullable = null;
+ Console.WriteLine("Nullable variable: " + nullable);
+
+ // Para usar valores nulos, tienes que usar la propiedad Value
+ // o usar conversión explícita
+ string? nullableString = "not null";
+ Console.WriteLine("Nullable value is: " + nullableString.Value + " or: " + (string) nullableString );
+
+ // ?? is una manera corta de especificar valores por defecto
+ // en caso de que la variable sea null
+ int notNullable = nullable ?? 0;
+ Console.WriteLine("Not nullable variable: " + notNullable);
+
+ // var - el compilador escogerá el tipo de dato más apropiado basado en el valor
+ var fooImplicit = true;
+
+ ///////////////////////////////////////////////////
+ // Estructura de datos
+ ///////////////////////////////////////////////////
+ Console.WriteLine("\n->Data Structures");
+
+ // Arreglos
+ // El tamaño del arreglo debe decidirse al momento de la declaración
+ // El formato para declarar un arreglo es el siguiente:
+ // <tipo_de_dato>[] <nombre_variable> = new <tipo_de_dato>[<tamaño>];
+ int[] intArray = new int[10];
+ string[] stringArray = new string[1];
+ bool[] boolArray = new bool[100];
+
+ // Otra forma de declarar e inicializar un arreglo
+ int[] y = { 9000, 1000, 1337 };
+
+ // Indexar arreglos - Acceder a un elemento
+ Console.WriteLine("intArray @ 0: " + intArray[0]);
+
+ // Los arreglos son de índice cero y son mutables.
+ intArray[1] = 1;
+ Console.WriteLine("intArray @ 1: " + intArray[1]); // => 1
+
+ // Listas
+ // Las listas son usadas más frecuentemente que los arreglos ya que son más flexibles
+ // El formato para declarar una lista es el siguiente:
+ // List<tipo_de_dato> <nombre_variable> = new List<tipo_de_dato>();
+ List<int> intList = new List<int>();
+ List<string> stringList = new List<string>();
+
+ // Otra forma de declarar e inicializar una lista
+ List<int> z = new List<int> { 9000, 1000, 1337 };
+
+ // Indexar una lista - Acceder a un elemento
+ // Las listas son de índice cero y son mutables.
+ Console.WriteLine("z @ 0: " + z[2]);
+
+ // Las listas no tienen valores por defecto;
+ // Un valor debe ser añadido antes de acceder al índice
+ intList.Add(1);
+ Console.WriteLine("intList @ 0: " + intList[0]);
+
+
+ // Otras estructuras de datos a chequear:
+ //
+ // Pilas/Colas
+ // Diccionarios
+ // Colecciones de sólo lectura
+ // Tuplas (.Net 4+)
+
+
+ ///////////////////////////////////////
+ // Operadores
+ ///////////////////////////////////////
+ Console.WriteLine("\n->Operators");
+
+ int i1 = 1, i2 = 2; // Modo corto para múltiples declaraciones
+
+ // La aritmética es sencilla
+ Console.WriteLine("1+2 = " + (i1 + i2)); // => 3
+ Console.WriteLine("2-1 = " + (i2 - i1)); // => 1
+ Console.WriteLine("2*1 = " + (i2 * i1)); // => 2
+ Console.WriteLine("1/2 = " + (i1 / i2)); // => 0 (0.5 truncated down)
+
+ // Módulo
+ Console.WriteLine("11%3 = " + (11 % 3)); // => 2
+
+ // Operadores de comparación
+ Console.WriteLine("3 == 2? " + (3 == 2)); // => false
+ Console.WriteLine("3 != 2? " + (3 != 2)); // => true
+ Console.WriteLine("3 > 2? " + (3 > 2)); // => true
+ Console.WriteLine("3 < 2? " + (3 < 2)); // => false
+ Console.WriteLine("2 <= 2? " + (2 <= 2)); // => true
+ Console.WriteLine("2 >= 2? " + (2 >= 2)); // => true
+
+ // Operadores a nivel de bits
+ /*
+ ~ Complemento a nivel de bits
+ << Desplazamiento a la izquierda con signo
+ >> Desplazamiento a la derecha con signo
+ >>> Desplazamiento a la derecha sin signo
+ & AND a nivel de bits
+ ^ XOR a nivel de bits
+ | OR a nivel de bits
+ */
+
+ // Incremento
+ int i = 0;
+ Console.WriteLine("\n->Inc/Dec-remento");
+ Console.WriteLine(i++); //i = 1. Posincrementación
+ Console.WriteLine(++i); //i = 2. Preincremento
+ Console.WriteLine(i--); //i = 1. Posdecremento
+ Console.WriteLine(--i); //i = 0. Predecremento
+
+
+ ///////////////////////////////////////
+ // Estructuras de control
+ ///////////////////////////////////////
+ Console.WriteLine("\n->Control Structures");
+
+ // Las condiciones if son como en lenguaje c
+ int j = 10;
+ if (j == 10)
+ {
+ Console.WriteLine("I get printed");
+ }
+ else if (j > 10)
+ {
+ Console.WriteLine("I don't");
+ }
+ else
+ {
+ Console.WriteLine("I also don't");
+ }
+
+ // Operador ternario
+ // Un simple if/else puede ser escrito de la siguiente manera;
+ // <condición> ? <true> : <false>
+ string isTrue = (true) ? "True" : "False";
+ Console.WriteLine("Ternary demo: " + isTrue);
+
+
+ // Bucle while
+ int fooWhile = 0;
+ while (fooWhile < 100)
+ {
+ //Console.WriteLine(fooWhile);
+ //Incrementar el contador
+ //Iterar 99 veces, fooWhile 0->99
+ fooWhile++;
+ }
+ Console.WriteLine("fooWhile Value: " + fooWhile);
+
+ // Bucle Do While
+ int fooDoWhile = 0;
+ do
+ {
+ //Console.WriteLine(fooDoWhile);
+ //Incrementar el contador
+ //Iterar 99 veces, fooDoWhile 0->99
+ fooDoWhile++;
+ } while (fooDoWhile < 100);
+ Console.WriteLine("fooDoWhile Value: " + fooDoWhile);
+
+ // Bucle For
+ int fooFor;
+ //Estructura del bucle for => for(<declaración_inicial>; <condición>; <incremento>)
+ for (fooFor = 0; fooFor < 10; fooFor++)
+ {
+ //Console.WriteLine(fooFor);
+ //Iterated 10 times, fooFor 0->9
+ }
+ Console.WriteLine("fooFor Value: " + fooFor);
+
+ // Switch Case
+ // El switch funciona con los tipos de datos byte, short, char e int
+ // También funciona con las enumeraciones (discutidos en in Tipos Enum),
+ // la clase string y algunas clases especiales que encapsulan
+ // tipos primitivos: Character, Byte, Short, Integer.
+ int month = 3;
+ string monthString;
+ switch (month)
+ {
+ case 1:
+ monthString = "January";
+ break;
+ case 2:
+ monthString = "February";
+ break;
+ case 3:
+ monthString = "March";
+ break;
+ default:
+ monthString = "Some other month";
+ break;
+ }
+ Console.WriteLine("Switch Case Result: " + monthString);
+
+
+ ////////////////////////////////
+ // Conversión de tipos de datos
+ ////////////////////////////////
+
+ // Convertir datos
+
+ // Convertir String a Integer
+ // esto generará una excepción al fallar la conversión
+ int.Parse("123");//retorna una versión entera de "123"
+
+ // TryParse establece la variable a un tipo por defecto
+ // en este caso: 0
+ int tryInt;
+ int.TryParse("123", out tryInt);
+
+ // Convertir Integer a String
+ // La clase Convert tiene algunos métodos para facilitar las conversiones
+ Convert.ToString(123);
+
+ ///////////////////////////////////////
+ // Clases y Funciones
+ ///////////////////////////////////////
+
+ Console.WriteLine("\n->Classes & Functions");
+
+ // (Definición de la clase Bicycle (Bicicleta))
+
+ // Usar new para instanciar una clase
+ Bicycle trek = new Bicycle();
+
+ // Llamar a los métodos del objeto
+ trek.speedUp(3); // Siempre deberías usar métodos setter y métodos getter
+ trek.setCadence(100);
+
+ // ToString es una convención para mostrar el valor del objeto.
+ Console.WriteLine("trek info: " + trek.ToString());
+
+ // Instanciar otra nueva bicicleta
+ Bicycle octo = new Bicycle(5, 10);
+ Console.WriteLine("octo info: " + octo.ToString());
+
+ // Instanciar un Penny Farthing (Biciclo)
+ PennyFarthing funbike = new PennyFarthing(1, 10);
+ Console.WriteLine("funbike info: " + funbike.ToString());
+
+ Console.Read();
+ } // Fin del método main
+
+
+ } // Fin de la clase LearnCSharp
+
+ // Puedes incluir otras clases en un archivo .cs
+
+
+ // Sintaxis para la declaración de clases:
+ // <public/private/protected> class <nombre_de_clase>{
+ // //campos, constructores, funciones todo adentro de la clase.
+ // //las funciones son llamadas métodos como en java.
+ // }
+
+ public class Bicycle
+ {
+ // Campos/Variables de la clase Bicycle
+ public int cadence; // Public: Accesible desde cualquier lado
+ private int _speed; // Private: Sólo es accesible desde dentro de la clase
+ protected int gear; // Protected: Accesible desde clases y subclases
+ internal int wheels; // Internal: Accesible en el ensamblado
+ string name; // Todo es privado por defecto: Sólo es accesible desde dentro de esta clase
+
+ // Enum es un tipo valor que consiste un una serie de constantes con nombres
+ public enum Brand
+ {
+ AIST,
+ BMC,
+ Electra,
+ Gitane
+ }
+ // Definimos este tipo dentro de la clase Bicycle, por lo tanto es un tipo anidado
+ // El código afuera de esta clase debería referenciar este tipo como Bicycle.Brand
+
+ public Brand brand; // Declaramos un tipo enum, podemos declarar un campo de este tipo
+
+ // Los miembros estáticos pertenecen al tipo mismo, no a un objeto en específico.
+ static public int bicyclesCreated = 0;
+ // Puedes acceder a ellos sin referenciar ningún objeto:
+ // Console.WriteLine("Bicycles created: " + Bicycle.bicyclesCreated);
+
+ // Los valores readonly (Sólo lectura) son establecidos en tiempo de ejecución
+ // sólo pueden ser asignados al momento de la declaración o dentro de un constructor
+ readonly bool hasCardsInSpokes = false; // privado de sólo lectura
+
+ // Los constructores son una forma de crear clases
+ // Este es un constructor por defecto
+ private Bicycle()
+ {
+ gear = 1;
+ cadence = 50;
+ _speed = 5;
+ name = "Bontrager";
+ brand = Brand.AIST;
+ bicyclesCreated++;
+ }
+
+ // Este es un constructor específico (contiene argumentos)
+ public Bicycle(int startCadence, int startSpeed, int startGear,
+ string name, bool hasCardsInSpokes, Brand brand)
+ {
+ this.gear = startGear; // La palabra reservada "this" señala el objeto actual
+ this.cadence = startCadence;
+ this._speed = startSpeed;
+ this.name = name; // Puede ser útil cuando hay un conflicto de nombres
+ this.hasCardsInSpokes = hasCardsInSpokes;
+ this.brand = brand;
+ }
+
+ // Los constructores pueden ser encadenados
+ public Bicycle(int startCadence, int startSpeed, Brand brand) :
+ this(startCadence, startSpeed, 0, "big wheels", true)
+ {
+ }
+
+ // Sintaxis para Funciones:
+ // <public/private/protected> <tipo_retorno> <nombre_funcion>(<args>)
+
+ // Las clases pueden implementar getters y setters para sus campos
+ // o pueden implementar propiedades
+
+ // Sintaxis para la declaración de métodos:
+ // <ámbito> <tipo_retorno> <nombre_método>(<argumentos>)
+ public int GetCadence()
+ {
+ return cadence;
+ }
+
+ // Los métodos void no requieren usar return
+ public void SetCadence(int newValue)
+ {
+ cadence = newValue;
+ }
+
+ // La palabra reservada virtual indica que este método puede ser sobrescrito
+ public virtual void SetGear(int newValue)
+ {
+ gear = newValue;
+ }
+
+ // Los parámetros de un método pueden tener valores por defecto.
+ // En este caso, los métodos pueden ser llamados omitiendo esos parámetros
+ public void SpeedUp(int increment = 1)
+ {
+ _speed += increment;
+ }
+
+ public void SlowDown(int decrement = 1)
+ {
+ _speed -= decrement;
+ }
+
+ // Propiedades y valores get/set
+ // Cuando los datos sólo necesitan ser accedidos, considera usar propiedades.
+ // Las propiedades pueden tener get, set o ambos
+ private bool _hasTassles; // variable privada
+ public bool HasTassles // acceso público
+ {
+ get { return _hasTassles; }
+ set { _hasTassles = value; }
+ }
+
+ // Las propiedades pueden ser auto implementadas
+ public int FrameSize
+ {
+ get;
+ // Puedes especificar modificadores de acceso tanto para get como para set
+ // esto significa que sólo dentro de la clase Bicycle se puede modificar Framesize
+ private set;
+ }
+
+ //Método para mostrar los valores de atributos de este objeto.
+ public override string ToString()
+ {
+ return "gear: " + gear +
+ " cadence: " + cadence +
+ " speed: " + _speed +
+ " name: " + name +
+ " cards in spokes: " + (hasCardsInSpokes ? "yes" : "no") +
+ "\n------------------------------\n"
+ ;
+ }
+
+ // Los métodos también pueden ser estáticos. Puede ser útil para métodos de ayuda
+ public static bool DidWeCreateEnoughBycles()
+ {
+ // Dentro de un método esático,
+ // Sólo podemos hacer referencia a miembros estáticos de clases
+ return bicyclesCreated > 9000;
+ } // Si tu clase sólo necesita miembros estáticos,
+ // considera establecer la clase como static.
+
+ } // fin de la clase Bicycle
+
+ // PennyFarthing es una subclase de Bicycle
+ class PennyFarthing : Bicycle
+ {
+ // (Penny Farthings son las bicicletas con una rueda delantera enorme.
+ // No tienen engranajes.)
+
+ // llamar al constructor de la clase padre
+ public PennyFarthing(int startCadence, int startSpeed) :
+ base(startCadence, startSpeed, 0, "PennyFarthing", true)
+ {
+ }
+
+ public override void SetGear(int gear)
+ {
+ gear = 0;
+ }
+
+ public override string ToString()
+ {
+ string result = "PennyFarthing bicycle ";
+ result += base.ToString(); // Llamar a la versión base del método
+ return reuslt;
+ }
+ }
+
+ // Las interfaces sólo contienen las declaraciones
+ // de los miembros, sin la implementación.
+ interface IJumpable
+ {
+ void Jump(int meters); // todos los miembros de interfaces son implícitamente públicos
+ }
+
+ interface IBreakable
+ {
+ // Las interfaces pueden contener tanto propiedades como métodos, campos y eventos
+ bool Broken { get; }
+ }
+
+ // Las clases sólo heredan de alguna otra clase, pero pueden implementar
+ // cualquier cantidad de interfaces
+ class MountainBike : Bicycle, IJumpable, IBreakable
+ {
+ int damage = 0;
+
+ public void Jump(int meters)
+ {
+ damage += meters;
+ }
+
+ public void Broken
+ {
+ get
+ {
+ return damage > 100;
+ }
+ }
+ }
+} // Fin del espacio de nombres
+
+```
+
+## Temas no cubiertos
+
+ * Flags
+ * Attributes
+ * Generics (T), Delegates, Func, Actions, lambda expressions
+ * Static properties
+ * Exceptions, Abstraction
+ * LINQ
+ * ASP.NET (Web Forms/MVC/WebMatrix)
+ * Winforms
+ * Windows Presentation Foundation (WPF)
+
+
+
+## Lecturas recomendadas
+
+ * [DotNetPerls](http://www.dotnetperls.com)
+ * [C# in Depth](http://manning.com/skeet2)
+ * [Programming C#](http://shop.oreilly.com/product/0636920024064.do)
+ * [LINQ](http://shop.oreilly.com/product/9780596519254.do)
+ * [MSDN Library](http://msdn.microsoft.com/es-es/library/618ayhy6.aspx)
+ * [ASP.NET MVC Tutorials](http://www.asp.net/mvc/tutorials)
+ * [ASP.NET Web Matrix Tutorials](http://www.asp.net/web-pages/tutorials)
+ * [ASP.NET Web Forms Tutorials](http://www.asp.net/web-forms/tutorials)
+ * [Windows Forms Programming in C#](http://www.amazon.com/Windows-Forms-Programming-Chris-Sells/dp/0321116208)
+
+
+
+[Convenciones de código de C#](http://msdn.microsoft.com/es-es/library/vstudio/ff926074.aspx)
diff --git a/es-es/git-es.html.markdown b/es-es/git-es.html.markdown
new file mode 100644
index 00000000..5c9d3378
--- /dev/null
+++ b/es-es/git-es.html.markdown
@@ -0,0 +1,411 @@
+---
+category: tool
+tool: git
+contributors:
+ - ["Jake Prather", "http://github.com/JakeHP"]
+translator:
+ - ["Raúl Ascencio", "http://rscnt.github.io"]
+filename: LearnGit.txt
+lang: es-es
+
+---
+
+Git es un sistema de control de versiones distribuido diseñado para manejar
+cualquier tipo de proyecto ya sea largos o pequeños, con velocidad y eficiencia.
+
+Git realiza esto haciendo "snapshots" del proyecto, con ello permite
+versionar y administrar nuestro código fuente.
+
+## Versionamiento, conceptos.
+
+### Que es el control de versiones?
+El control de versiones es un sistema que guarda todos los cambios realizados a
+uno o varios archivos, a lo largo del tiempo.
+
+### Versionamiento centralizado vs Versionamiento Distribuido.
+
++ El versionamiento centralizado se enfoca en sincronizar, rastrear, y respaldar
+ archivos.
++ El versionamiento distribuido se enfoca en compartir los cambios realizados.
+ Cada cambio tiene un único identificador.
++ El versionamiento distribuido no tiene una estructura definida, incluso se
+ puede mantener el estilo de los repositorios SVN con git.
+
+[Informacion adicional](http://git-scm.com/book/es/Empezando-Acerca-del-control-de-versiones)
+
+### Por que usar Git?
+
+* Se puede trabajar sin conexion.
+* Colaborar con otros es sencillo!.
+* Derivar, Crear ramas del proyecto (aka: Branching) es facil!.
+* Combinar (aka: Marging)
+* Git es rapido.
+* Git es flexible.
+
+## Arquitectura de Git.
+
+### Repositorio
+
+Un repositorio es un conjunto de archivos, directorios, registros, cambios (aka:
+comits), y encabezados (aka: heads). Imagina que un repositorio es una clase,
+y que sus atributos otorgan acceso al historial del elemento, ademas de otras
+cosas.
+
+Un repositorio esta compuesto por la carpeta .git y un "arbol de trabajo".
+
+### Directorio .git (componentes del repositorio)
+
+El directorio .git contiene todas las configuraciones, registros, branches, HEAD
+y mas.
+
+[Lista detallada.](http://es.gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html)
+
+### Directorio de trabajo (componentes del repositorio)
+
+Es basicamente los directorios y archivos dentro del repositorio. La mayorioa de
+las veces se le llama "directorio de trabajo".
+
+### Inidice (componentes del directorio .git)
+
+El inidice es la area de inicio en git. Es basicamente la capa que separa el
+directorio de trabajo, del repositorio en git. Esto otorga a los desarrolladores
+mas poder sobre lo que envia y recibe en el repositorio.
+
+### Commit (aka: cambios)
+
+Un commit es una captura de un conjunto de cambios, o modificaciones hechas en
+el directorio de trabajo. Por ejemplo, si se añaden 5 archivos, se remueven 2,
+estos cambios se almacenaran en un commit (aka: captura). Este commit puede ser o
+no ser enviado (aka: "pusheado") hacia un repositorio.
+
+### Branch (rama)
+
+Un "branch", es escencialmente un apuntador hacia el ultimo commit (cambio
+registrado) que se ha realizado. A medida que se realizan mas commits, este
+apuntador se actualizara automaticamente hacia el ultimo commit.
+
+### "HEAD" y "head" (component of .git dir)
+
+"HEAD" es un apuntador hacia la rama (branch) que se esta utilizando. Un
+repositorio solo puede tener un HEAD activo. En cambio "head", es un apuntador a
+cualquier commit realizado, un repositorio puede tener cualquier numero de
+"heads".
+
+### conceptos - recursos.
+
+* [Git para informaticos](http://eagain.net/articles/git-for-computer-scientists/)
+* [Git para diseñadores](http://hoth.entp.com/output/git_for_designers.html)
+
+
+## Comandos.
+
+
+### init
+
+Crear un repositorio de git vacio. Las configuraciones, informacion almacenada y
+demas son almacenadas en el directorio ".git".
+
+```bash
+$ git init
+```
+
+### config
+
+Se utiliza para configurar las opciones ya sea globalmente, o solamente en el
+repositorio.
+
+```bash
+# Imprime y guarda algunas variables de configuracion basicas. (Globalmente)
+$ git config --global user.email
+$ git config --global user.name
+
+$ git config --global user.email "corre@gmail.com"
+$ git config --global user.name "nombre"
+```
+
+[Mas sobre git config.](http://git-scm.com/book/es/Personalizando-Git-Configuración-de-Git)
+
+### help
+
+Otorga un accceso rapido a una guia extremadamente detallada de cada comando en
+git. O puede ser usada simplemente como un recordatorio de estos.
+
+```bash
+# Una vista rapido de los comandos disponibles.
+$ git help
+
+# Chequear todos los comandos disponibles
+$ git help -a
+
+# Obtener ayuda especifica de un comando - manual de usuario
+# git help <comando>
+$ git help add
+$ git help commit
+$ git help init
+```
+
+### status
+
+Muestra las diferencias entre el archivo indice y el commit al cual apunta el
+HEAD actualmente.
+
+
+```bash
+# Mostrara el "branch", archivos sin añadir a la repo, cambios y otras
+# diferencias
+$ git status
+
+# Devuelve ayuda sobre el comando status.
+$ git help status
+```
+
+### add
+
+Para añadir archivos al arbol (directorio, repositorio) de trabajo. Si no se
+utiliza `git add`, los nuevos archivos no se añadiran al arbol de trabajo, por
+lo que no se incluiran en los commits (cambios).
+
+```bash
+# Añade un archivo en el directorio de trabajo actual.
+$ git add FooBar.java
+
+# Añade un archivo que se encuentra bajo un directorio.
+$ git add /directorio/del/archivo/Foo.c
+
+# Soporte para expresiones regulares!
+$ git add ./*.py
+```
+
+### branch
+
+Administra las ramas del repositorios ("branches"). Puedes ver, editar, crear y
+borrar ramas ("branches"), usando este comando.
+
+```bash
+# lista todas las ramas (remotas y locales)
+$ git branch -a
+
+# Añada una nueva rama ("branch").
+$ git branch branchNueva
+
+# Eliminar una rama.
+$ git branch -d branchFoo
+
+# Renombra una rama.
+# git branch -m <anterior> <nuevo>
+$ git branch -m youngling padawan
+
+# Edita la descripcion de la rama.
+$ git branch master --edit-description
+```
+
+### checkout
+
+Actualiza todos los archivos en el directorio de trabajo para que sean igual que
+las versiones almacenadas en el indice, o en un arbol de trabajo especificado.
+
+```bash
+# Despachar un repositorio. - Por defecto la master branch. (la rama principal llamada 'master')
+$ git checkout
+# Despacha una rama especifica.
+$ git checkout padawan
+# Crea una nueva rama y cambia hacia ella, es igual a utilizar: "git brach jedi; git checkout jedi"
+$ git checkout -b jdei
+```
+
+### clone
+
+Clona, o copia, una repo existente en un nuevo directorio. Tambien añada el
+seguimiento hacia las ramas existentes del repo que ha sido clonada, lo que
+permite subir (push) los archivos hacia una rama remota.
+
+```bash
+# Clonar la repo de jquery.
+$ git clone https://github.com/jquery/jquery.git
+```
+
+### commit
+
+Almacena los cambios que almacenados en el indice en un nuevo "commit". Este
+commit contiene los cambios hechos mas un resumen hecho por el desarrollador.
+
+```bash
+# commit with a message
+# realizar un commit y añadirle un mensaje.
+$ git commit -m "jedi anakin wil be - jedis.list"
+```
+
+### diff
+
+Muestra las diferencias entre un archivo en el directorio de trabajo, el indice
+y commits.
+
+```bash
+# Muestra la diferencia entre un directorio de trabajo y el indice.
+$ git diff
+
+# Muestra la diferencia entre el indice y los commits mas recientes.
+$ git diff --cached
+
+# Muestra la diferencia entre el directorio de trabajo y el commit mas reciente.
+$ git diff HEAD
+```
+
+### grep
+
+Permite realizar una busqueda rapida en un repositorio.
+
+Configuracion opcionales:
+
+```bash
+# Gracias a Travis Jeffery por compartir lo siguiente.
+# Permite mostrar numeros de lineas en la salida de grep.
+$ git config --global grep.lineNumber true
+
+# Realiza una busqueda mas lejible, incluyendo agrupacion.
+$ git config --global alias.g "grep --break --heading --line-number"
+```
+
+```bash
+# Busca por "unaVariable" en todos los archivos ,java
+$ git grep 'unaVariable' -- '*.java'
+
+# Busca por una linea que contenga "nombreArreglo" y , "agregar" o "remover"
+$ git grep -e 'nombreArreglo' --and \( -e agregar -e remover \)
+```
+
+Mas ejemplos:
+[Git Grep Ninja](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja)
+
+### log
+
+Muestra los commits (cambios) registrados en el repositotrio.
+
+```bash
+# Muestra todos los commits.
+$ git log
+
+# Muestra un numero x de commits.
+$ git log -n 10
+
+# Muestra solo los commits que se han combinado en el hisotrial
+$ git log --merges
+```
+
+### merge
+
+Combina los cambios de commits realizados externamente dentro de la rama en la
+que se trabaja.
+
+```bash
+# Combina la rama especificada en la rama actual.
+$ git merge jediMaster
+
+# Siempre genere un solo merge commit cuando se utilizar merge.
+$ git merge --no-ff jediMaster
+```
+
+### mv
+
+Renombra o mueve un archivo
+
+```bash
+# Renombrando un archivo
+$ git mv HolaMundo.c AdiosMundo.c
+
+# Moviendo un archivo.
+$ git mv HolaOtraVezMundo.c ./nuevo/directorio/NuevoArchivo.c
+
+# Sustituye un archivo.
+$ git mv -f archivoA archivoB
+```
+
+### pull
+
+Sube (Empuja) de un repositorio y lo combina en otro en una rama diferente.
+
+```bash
+# Actualiza el repositorio local, combinando los nuevos cambios.
+# de las ramas remotas "origin" y "master".
+# from the remote "origin" and "master" branch.
+# git pull <remota> <rama>
+$ git pull origin master
+```
+
+### push
+
+Push and merge changes from a branch to a remote & branch.
+
+```bash
+# Push and merge changes from a local repo to a
+# Empuja y combina cambios de un repositorio local hacian un repositorio remoto
+# llamados "origin" y "master", respectivamente.
+# git push <remota> <rama>
+# git push => por defecto es lo mismo que poner => git push origin master
+$ git push origin master
+```
+
+
+Toma todos los cambios que fueron registrados en una rama, y los repite dentro
+de otra rama.
+*No reescribe los commits que se han empujado antes a un repositorio publico*
+
+```bash
+# Integrar ramaExperimento dentro de la rama "master"
+# git rebase <basebranch> <topicbranch>
+$ git rebase master experimentBranch
+```
+
+[Informacion adicional.](http://git-scm.com/book/es/Ramificaciones-en-Git-Procedimientos-básicos-para-ramificar-y-fusionar)
+
+### reset (precaucion)
+
+Reinicia el cabezal actual hacia un estado especificado. Esto permite desacer
+combinaciones (merges), pulls, commits, adds y mas. Es un comando util, pero
+tambien peligrosa si no se sabe lo que se hace.
+
+```bash
+# Reinica el area principal, con el ultimo cambio registrado. (deja los
+# directorios sin cambios)
+$ git reset
+
+# Reinica el area principal, con el ultimo cambio registrado, y reescribe el
+# directorio de trabajo.
+$ git reset --hard
+
+# Mueve la rama actual hacia el commit especificado (no realiza cambios a los
+# directorios), todos los cambios aun existen el directorio.
+$ git reset 31f2bb1
+
+# Mueve la rama actual devuelta a un commit especificado asi como el
+# directorios (borra todos los cambios que no fueron registros y todos los
+# cambios realizados despues del commit especificado).
+$ git reset --hard 31f2bb1
+```
+
+### rm
+
+Lo contrario de git add, git rm remueve los archivos del directorio de trabajo
+actual.
+
+```bash
+# Remueve FooBar.c
+$ git rm FooBar.c
+
+# Remueve un archivo de un directorio.
+$ git rm /directorio/del/archivo/FooBar.c
+```
+
+## Informacion Adicional
+
+* [tryGit - Una forma entretenida y rapida de aprender Git.](http://try.github.io/levels/1/challenges/1)
+
+* [git-scm - Video-tutoriales](http://git-scm.com/videos)
+
+* [git-scm - Documentacion](http://git-scm.com/book/es)
+
+* [Atlassian Git - Tutoriales y Flujos de trabajo](https://www.atlassian.com/git/)
+
+* [SalesForce Chuleta](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf)
+
+* [GitGuys](http://www.gitguys.com/)
diff --git a/es-es/go-es.html.markdown b/es-es/go-es.html.markdown
new file mode 100644
index 00000000..e788e810
--- /dev/null
+++ b/es-es/go-es.html.markdown
@@ -0,0 +1,326 @@
+---
+language: Go
+lang: es-es
+filename: learngo-es.go
+contributors:
+ - ["Sonia Keys", "https://github.com/soniakeys"]
+translators:
+ - ["Adrian Espinosa", "http://www.adrianespinosa.com"]
+ - ["Jesse Johnson", "https://github.com/holocronweaver"]
+---
+
+Go fue creado por la necesidad de hacer el trabajo rápidamente. No es
+la última tendencia en informática, pero es la forma nueva y más
+rápida de resolver problemas reales.
+
+Tiene conceptos familiares de lenguajes imperativos con tipado
+estático. Es rápido compilando y rápido al ejecutar, añade una
+concurrencia fácil de entender para las CPUs de varios núcleos de hoy
+en día, y tiene características que ayudan con la programación a gran
+escala.
+
+Go viene con una librería estándar muy buena y una comunidad entusiasta.
+
+```go
+// Comentario de una sola línea
+/* Comentario
+ multi línea */
+
+// La cláusula package aparece al comienzo de cada archivo fuente.
+// Main es un nombre especial que declara un ejecutable en vez de una librería.
+package main
+
+// La declaración Import declara los paquetes de librerías
+// referenciados en este archivo.
+import (
+ "fmt" // Un paquete en la librería estándar de Go.
+ "net/http" // Sí, un servidor web!
+ "strconv" // Conversiones de cadenas.
+ m "math" // Librería matemáticas con alias local m.
+)
+
+// Definición de una función. Main es especial. Es el punto de
+// entrada para el ejecutable. Te guste o no, Go utiliza llaves.
+func main() {
+ // Println imprime una línea a stdout.
+ // Cualificalo con el nombre del paquete, fmt.
+ fmt.Println("Hello world!")
+
+ // Llama a otra función de este paquete.
+ beyondHello()
+}
+
+// Las funciones llevan parámetros entre paréntesis.
+// Si no hay parámetros, los paréntesis siguen siendo obligatorios.
+func beyondHello() {
+ var x int // Declaración de una variable.
+ // Las variables se deben declarar antes de utilizarlas.
+ x = 3 // Asignación de variables.
+ // Declaración "corta" con := para inferir el tipo, declarar y asignar.
+ y := 4
+ sum, prod := learnMultiple(x, y) // Función devuelve dos valores.
+ fmt.Println("sum:", sum, "prod:", prod) // Simple salida.
+ learnTypes() // < y minutes, learn more!
+}
+
+// Las funciones pueden tener parámetros y (múltiples!) valores de retorno.
+func learnMultiple(x, y int) (sum, prod int) {
+ return x + y, x * y // Devolver dos valores.
+}
+
+// Algunos tipos incorporados y literales.
+func learnTypes() {
+ // La declaración corta suele darte lo que quieres.
+ s := "Learn Go!" // tipo cadena
+
+ s2 := ` Un tipo cadena "puro" puede incluir
+saltos de línea.` // mismo tipo cadena
+
+ // Literal no ASCII. Los fuentes de Go son UTF-8.
+ g := 'Σ' // Tipo rune, un alias de uint32, alberga un punto unicode.
+ f := 3.14195 // float64, el estándar IEEE-754 de coma flotante 64-bit.
+ c := 3 + 4i // complex128, representado internamente por dos float64.
+ // Sintaxis Var con inicializadores.
+ var u uint = 7 // Sin signo, pero la implementación depende del
+ // tamaño como en int.
+ var pi float32 = 22. / 7
+
+ // Sintáxis de conversión con una declaración corta.
+ n := byte('\n') // byte es un alias de uint8.
+
+ // Los Arrays tienen un tamaño fijo a la hora de compilar.
+ var a4 [4]int // Un array de 4 ints, inicializados a 0.
+ a3 := [...]int{3, 1, 5} // Un array de 3 ints, inicializados como se indica.
+
+ // Los Slices tienen tamaño dinámico. Los arrays y slices tienen sus ventajas
+ // y desventajas pero los casos de uso para los slices son más comunes.
+ s3 := []int{4, 5, 9} // Comparar con a3. No hay puntos suspensivos.
+ s4 := make([]int, 4) // Asigna slices de 4 ints, inicializados a 0.
+ var d2 [][]float64 // Solo declaración, sin asignación.
+ bs := []byte("a slice") // Sintaxis de conversión de tipo.
+
+ p, q := learnMemory() // Declara p, q para ser un tipo puntero a int.
+ fmt.Println(*p, *q) // * sigue un puntero. Esto imprime dos ints.
+
+ // Los Maps son arrays asociativos dinámicos, como los hash o
+ // diccionarios de otros lenguajes.
+ m := map[string]int{"three": 3, "four": 4}
+ m["one"] = 1
+
+ // Las variables no utilizadas en Go producen error.
+ // El guión bajo permite "utilizar" una variable, pero descartar su valor.
+ _, _, _, _, _, _, _, _, _ = s2, g, f, u, pi, n, a3, s4, bs
+ // Esto cuenta como utilización de variables.
+ fmt.Println(s, c, a4, s3, d2, m)
+
+ learnFlowControl() // Vuelta al flujo.
+}
+
+// Go posee recolector de basura. Tiene puntero pero no aritmética de
+// punteros. Puedes cometer un errores con un puntero nil, pero no
+// incrementando un puntero.
+func learnMemory() (p, q *int) {
+ // q y p tienen un tipo puntero a int.
+ p = new(int) // Función incorporada que asigna memoria.
+ // La asignación de int se inicializa a 0, p ya no es nil.
+ s := make([]int, 20) // Asigna 20 ints a un solo bloque de memoria.
+ s[3] = 7 // Asignar uno de ellos.
+ r := -2 // Declarar otra variable local.
+ return &s[3], &r // & toma la dirección de un objeto.
+}
+
+func expensiveComputation() float64 {
+ return m.Exp(10)
+}
+
+func learnFlowControl() {
+ // La declaración If requiere llaves, pero no paréntesis.
+ if true {
+ fmt.Println("told ya")
+ }
+ // El formato está estandarizado por el comando "go fmt."
+ if false {
+ // Pout.
+ } else {
+ // Gloat.
+ }
+ // Utiliza switch preferiblemente para if encadenados.
+ x := 42.0
+ switch x {
+ case 0:
+ case 1:
+ case 42:
+ // Los cases no se mezclan, no requieren de "break".
+ case 43:
+ // No llega.
+ }
+ // Como if, for no utiliza paréntesis tampoco.
+ // Variables declaradas en for y if son locales de su ámbito local.
+ for x := 0; x < 3; x++ { // ++ es una sentencia.
+ fmt.Println("iteration", x)
+ }
+ // x == 42 aqui.
+
+ // For es la única sentencia de bucle en Go, pero tiene formas alternativas.
+ for { // Bucle infinito.
+ break // Solo bromeaba!
+ continue // No llega.
+ }
+ // Como en for, := en una sentencia if significa declarar y asignar primero,
+ // luego comprobar y > x.
+ if y := expensiveComputation(); y > x {
+ x = y
+ }
+ // Los literales de funciones son "closures".
+ xBig := func() bool {
+ return x > 100 // Referencia a x declarada encima de la sentencia switch.
+ }
+ fmt.Println("xBig:", xBig()) // verdadero (la última vez asignamos 1e6 a x).
+ x /= m.Exp(9) // Esto lo hace x == e.
+ fmt.Println("xBig:", xBig()) // Ahora es falso.
+
+ // Cuando lo necesites, te encantará.
+ goto love
+love:
+
+ learnInterfaces() // Buen material dentro de poco!
+}
+
+// Define Stringer como un tipo interfaz con un método, String.
+type Stringer interface {
+ String() string
+}
+
+// Define pair como un struct con dos campos int, x e y.
+type pair struct {
+ x, y int
+}
+
+// Define un método del tipo pair. Pair ahora implementa Stringer.
+func (p pair) String() string { // p se llama "recibidor"
+ // Sprintf es otra función pública del paquete fmt.
+ // La sintaxis con punto referencia campos de p.
+ return fmt.Sprintf("(%d, %d)", p.x, p.y)
+}
+
+func learnInterfaces() {
+ // La sintaxis de llaves es un "literal struct". Evalúa a un struct
+ // inicializado. La sintaxis := declara e inicializa p a este struct.
+ p := pair{3, 4}
+ fmt.Println(p.String()) // Llamar al método String de p, de tipo pair.
+ var i Stringer // Declarar i como interfaz tipo Stringer.
+ i = p // Válido porque pair implementa Stringer.
+ // Llamar al metodo String de i, de tipo Stringer. Misma salida que arriba.
+ fmt.Println(i.String())
+
+ // Las funciones en el paquete fmt llaman al método String para
+ // preguntar a un objeto por una versión imprimible de si mismo.
+ fmt.Println(p) // Salida igual que arriba. Println llama al método String.
+ fmt.Println(i) // Salida igual que arriba.
+
+ learnVariadicParams("great", "learning", "here!")
+}
+
+// Las funciones pueden tener número variable de argumentos.
+func learnVariadicParams(myStrings ...interface{}) {
+ // Iterar cada valor de la variadic.
+ for _, param := range myStrings {
+ fmt.Println("param:", param)
+ }
+
+ // Pasar valor variadic como parámetro variadic.
+ fmt.Println("params:", fmt.Sprintln(myStrings...))
+
+ learnErrorHandling()
+}
+
+func learnErrorHandling() {
+ // ", ok" forma utilizada para saber si algo funcionó o no.
+ m := map[int]string{3: "three", 4: "four"}
+ if x, ok := m[1]; !ok { // ok será falso porque 1 no está en el map.
+ fmt.Println("no one there")
+ } else {
+ fmt.Print(x) // x sería el valor, si estuviera en el map.
+ }
+ // Un valor de error comunica más información sobre el problema aparte de "ok".
+ if _, err := strconv.Atoi("non-int"); err != nil { // _ descarta el valor
+ // Imprime "strconv.ParseInt: parsing "non-int": invalid syntax".
+ fmt.Println(err)
+ }
+ // Revisarmeos las interfaces más tarde. Mientras tanto,
+ learnConcurrency()
+}
+
+// c es un canal, un objeto de comunicación de concurrencia segura.
+func inc(i int, c chan int) {
+ c <- i + 1 // <- es el operador "enviar" cuando un canal aparece a la izquierda.
+}
+
+// Utilizaremos inc para incrementar algunos números concurrentemente.
+func learnConcurrency() {
+ // Misma función make utilizada antes para crear un slice. Make asigna e
+ // inicializa slices, maps, y channels.
+ c := make(chan int)
+ // Iniciar tres goroutines concurrentes. Los números serán incrementados
+ // concurrentemente, quizás en paralelo si la máquina es capaz y
+ // está correctamente configurada. Las tres envían al mismo channel.
+ go inc(0, c) // go es una sentencia que inicia una nueva goroutine.
+ go inc(10, c)
+ go inc(-805, c)
+ // Leer los tres resultados del channel e imprimirlos.
+ // No se puede saber en que orden llegarán los resultados!
+ fmt.Println(<-c, <-c, <-c) // Channel a la derecha, <- es el operador "recibir".
+
+ cs := make(chan string) // Otro channel, este gestiona cadenas.
+ ccs := make(chan chan string) // Un channel de cadenas de channels.
+ go func() { c <- 84 }() // Iniciar una nueva goroutine solo para
+ // enviar un valor.
+ go func() { cs <- "wordy" }() // Otra vez, para cs en esta ocasión.
+ // Select tiene una sintáxis parecida a la sentencia switch pero
+ // cada caso involucra una operacion de channels. Selecciona un caso
+ // de forma aleatoria de los casos que están listos para comunicarse.
+ select {
+ case i := <-c: // El valor recibido puede ser asignado a una variable,
+ fmt.Printf("it's a %T", i)
+ case <-cs: // o el valor puede ser descartado.
+ fmt.Println("it's a string")
+ case <-ccs: // Channel vacío, no está listo para la comunicación.
+ fmt.Println("didn't happen.")
+ }
+
+ // En este punto un valor fue devuelvto de c o cs. Uno de las dos
+ // goroutines que se iniciaron se ha completado, la otrá permancerá
+ // bloqueada.
+
+ learnWebProgramming() // Go lo hace. Tu también quieres hacerlo.
+}
+
+// Una simple función del paquete http inicia un servidor web.
+func learnWebProgramming() {
+ // El primer parámetro de la direccinón TCP a la que escuchar.
+ // El segundo parámetro es una interfaz, concretamente http.Handler.
+ err := http.ListenAndServe(":8080", pair{})
+ fmt.Println(err) // no ignorar errores
+}
+
+// Haz pair un http.Handler implementando su único método, ServeHTTP.
+func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+ // Servir datos con un método de http.ResponseWriter.
+ w.Write([]byte("You learned Go in Y minutes!"))
+}
+```
+
+## Para leer más
+
+La raíz de todas las cosas de Go es la [web oficial de Go](http://golang.org/).
+Ahí puedes seguir el tutorial, jugar interactivamente y leer mucho.
+
+La propia definición del lenguaje también está altamente
+recomendada. Es fácil de leer e increíblemente corta (como otras
+definiciones de lenguajes hoy en día)
+
+En la lista de lectura de estudiantes de Go está el código fuente de
+la librería estándar. Muy bien documentada, demuestra lo mejor de Go
+leíble, comprendible, estilo Go y formas Go. Pincha en el nombre de
+una función en la documentación y te aparecerá el código fuente!
+
diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown
new file mode 100644
index 00000000..41a7c68b
--- /dev/null
+++ b/es-es/julia-es.html.markdown
@@ -0,0 +1,759 @@
+---
+language: julia
+contributors:
+ - ["Leah Hanson", "http://leahhanson.us"]
+ - ["Guillermo Garza" ]
+filename: learnjulia-es.jl
+lang: es-es
+---
+
+Julia es un nuevo lenguaje funcional homoiconic enfocado en computación técnica.
+Aunque que tiene todo el poder de macros homoiconic, funciones de primera
+clase, y control de bajo nivel, Julia es tan fácil de aprender y utilizar como
+Python.
+
+Esto se basa en la versión de desarrollo actual de Julia, del 18 de octubre de
+2013.
+
+```ruby
+
+# Comentarios de una línea comienzan con una almohadilla (o signo gato)
+
+#= Commentarios multilinea pueden escribirse
+ usando '#=' antes de el texto y '=#'
+ después del texto. También se pueden anidar.
+=#
+
+####################################################
+## 1. Tipos de datos primitivos y operadores.
+####################################################
+
+# Todo en Julia es una expresión.
+
+# Hay varios tipos básicos de números.
+3 # => 3 (Int64)
+3.2 # => 3.2 (Float64)
+2 + 1im # => 2 + 1im (Complex{Int64})
+2//3 # => 2//3 (Rational{Int64})
+
+# Todos los operadores infijos normales están disponibles.
+1 + 1 # => 2
+8 - 1 # => 7
+10 * 2 # => 20
+35 / 5 # => 7.0
+5/2 # => 2.5 # dividir un Int por un Int siempre resulta en un Float
+div (5, 2) # => 2 # para un resultado truncado, usa div
+5 \ 35 # => 7.0
+2 ^ 2 # => 4 # exponente, no es xor
+12 % 10 # => 2
+
+# Refuerza la precedencia con paréntesis
+(1 + 3) * 2 # => 8
+
+# Operadores a nivel de bit
+~2 # => -3 # bitwise not
+3 & 5 # => 1 # bitwise and
+2 | 4 # => 6 # bitwise or
+2 $ 4 # => 6 # bitwise xor
+2 >>> 1 # => 1 # logical shift right
+2 >> 1 # => 1 # arithmetic shift right
+2 << 1 # => 4 # logical/arithmetic shift left
+
+# Se puede utilizar la función bits para ver la representación binaria de un
+# número.
+bits(12345)
+# => "0000000000000000000000000000000000000000000000000011000000111001"
+bits(12345.0)
+# => "0100000011001000000111001000000000000000000000000000000000000000"
+
+# Valores 'boolean' (booleanos) son primitivos
+true
+false
+
+# Operadores Boolean (booleanos)
+!true # => false
+!false # => true
+1 == 1 # => true
+2 == 1 # => false
+1 != 1 # => false
+2 != 1 # => true
+1 < 10 # => true
+1 > 10 # => false
+2 <= 2 # => true
+2 >= 2 # => true
+# ¡Las comparaciones pueden ser concatenadas!
+1 < 2 < 3 # => true
+2 < 3 < 2 # => false
+
+# Strings se crean con "
+"Esto es un string."
+
+# Literales de caracteres se escriben con '
+'a'
+
+# Una string puede ser indexado como una array de caracteres
+"Esto es un string."[1] # => 'E' # Índices en Julia empiezen del 1
+# Sin embargo, esto no va a funcionar bien para strings UTF8,
+# Lo que se recomienda es la iteración (map, for, etc).
+
+# $ puede ser utilizado para la interpolación de strings:
+"2 + 2 = $(2 + 2)" # => "2 + 2 = 4"
+# Se puede poner cualquier expresión de Julia dentro los paréntesis.
+
+# Otro forma de formatear strings es el macro printf
+@printf "%d es menor de %f" 4.5 5.3 # 5 es menor de 5.300000
+
+# Imprimir es muy fácil
+println("Soy Julia. ¡Encantado de conocerte!")
+
+####################################################
+## 2. Variables y Colecciones
+####################################################
+
+# No hay necesidad de declarar las variables antes de asignarlas.
+una_variable = 5 # => 5
+una_variable # => 5
+
+# Acceder a variables no asignadas previamente es una excepción.
+try
+ otra_variable # => ERROR: some_other_var not defined
+catch e
+ println(e)
+end
+
+# Los nombres de variables comienzan con una letra.
+# Después de eso, puedes utilizar letras, dígitos, guiones y signos de
+# exclamación.
+OtraVariable123! = 6 # => 6
+
+# También puede utilizar caracteres unicode
+☃ = 8 # => 8
+# Estos son especialmente útiles para la notación matemática
+2 * π # => 6.283185307179586
+
+# Una nota sobre las convenciones de nomenclatura de Julia:
+#
+# * Los nombres de las variables aparecen en minúsculas, con separación de
+# palabra indicado por underscore ('\ _').
+#
+# * Los nombres de los tipos comienzan con una letra mayúscula y separación de
+# palabras se muestra con CamelCase en vez de underscore.
+#
+# * Los nombres de las funciones y los macros están en minúsculas, sin
+# underscore.
+#
+# * Funciones que modifican sus inputs tienen nombres que terminan en!. Estos
+# funciones a veces se llaman mutating functions o in-place functions.
+
+# Los Arrays almacenan una secuencia de valores indexados entre 1 hasta n
+a = Int64[] # => 0-element Int64 Array
+
+# Literales de arrays 1-dimensionales se pueden escribir con valores separados
+# por comas.
+b = [4, 5, 6] # => 3-element Int64 Array: [4, 5, 6]
+b[1] # => 4
+b[end] # => 6
+
+# Los arrays 2-dimensionales usan valores separados por espacios y filas
+# separados por punto y coma.
+matrix = [1 2; 3 4] # => 2x2 Int64 Array: [1 2; 3 4]
+
+# Añadir cosas a la final de una lista con push! y append!
+push!(a,1) # => [1]
+push!(a,2) # => [1,2]
+push!(a,4) # => [1,2,4]
+push!(a,3) # => [1,2,4,3]
+append!(a,b) # => [1,2,4,3,4,5,6]
+
+# Eliminar de la final con pop
+pop!(b) # => 6 y b ahora es [4,5]
+
+# Vamos a ponerlo de nuevo
+push!(b, 6) # b es ahora [4,5,6] de nuevo.
+
+a[1] # => 1 # recuerdan que los índices de Julia empiezan desde 1, no desde 0!
+
+# end es una abreviatura para el último índice. Se puede utilizar en cualquier
+# expresión de indexación
+a[end] # => 6
+
+# tambien hay shift y unshift
+shift!(a) # => 1 y a es ahora [2,4,3,4,5,6]
+unshift!(a,7) # => [7,2,4,3,4,5,6]
+
+# Nombres de funciónes que terminan en exclamaciones indican que modifican
+# su argumento.
+arr = [5,4,6] # => 3-element Int64 Array: [5,4,6]
+sort(arr) # => [4,5,6]; arr es todavía [5,4,6]
+sort!(arr) # => [4,5,6]; arr es ahora [4,5,6]
+
+# Buscando fuera de límites es un BoundsError
+try
+ a[0] # => ERROR: BoundsError() in getindex at array.jl:270
+ a[end+1] # => ERROR: BoundsError() in getindex at array.jl:270
+catch e
+ println(e)
+end
+
+# Errors dan la línea y el archivo de su procedencia, aunque sea en el standard
+# library. Si construyes Julia de source, puedes buscar en el source para
+# encontrar estos archivos.
+
+# Se puede inicializar arrays de un range
+a = [1:5] # => 5-element Int64 Array: [1,2,3,4,5]
+
+# Puedes mirar en ranges con sintaxis slice.
+a[1:3] # => [1, 2, 3]
+a[2:end] # => [2, 3, 4, 5]
+
+# Eliminar elementos de una array por índice con splice!
+arr = [3,4,5]
+splice!(arr,2) # => 4 ; arr es ahora [3,5]
+
+# Concatenar listas con append!
+b = [1,2,3]
+append!(a,b) # ahroa a es [1, 2, 3, 4, 5, 1, 2, 3]
+
+# Comprueba la existencia en una lista con in
+in(1, a) # => true
+
+# Examina la longitud con length
+length(a) # => 8
+
+# Tuples son immutable.
+tup = (1, 2, 3) # => (1,2,3) # un (Int64,Int64,Int64) tuple.
+tup[1] # => 1
+try:
+ tup[1] = 3 # => ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64)
+catch e
+ println(e)
+end
+
+# Muchas funciones de lista también trabajan en las tuples
+length(tup) # => 3
+tup[1:2] # => (1,2)
+in(2, tup) # => true
+
+# Se puede desempacar tuples en variables
+a, b, c = (1, 2, 3) # => (1,2,3) # a is now 1, b is now 2 and c is now 3
+
+# Los tuples se crean, incluso si se omite el paréntesis
+d, e, f = 4, 5, 6 # => (4,5,6)
+
+# Un tuple 1-elemento es distinto del valor que contiene
+(1,) == 1 # => false
+(1) == 1 # => true
+
+# Mira que fácil es cambiar dos valores
+e, d = d, e # => (5,4) # d is now 5 and e is now 4
+
+
+# Dictionaries almanecan mapeos
+dict_vacio = Dict() # => Dict{Any,Any}()
+
+# Se puede crear un dictionary usando un literal
+dict_lleno = ["one"=> 1, "two"=> 2, "three"=> 3]
+# => Dict{ASCIIString,Int64}
+
+# Busca valores con []
+dict_lleno["one"] # => 1
+
+# Obtén todas las claves
+keys(dict_lleno)
+# => KeyIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
+# Nota - claves del dictionary no están ordenados ni en el orden en que se
+# insertan.
+
+# Obtén todos los valores
+values(dict_lleno)
+# => ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
+# Nota - Igual que el anterior en cuanto a ordenamiento de claves.
+
+# Compruebe si hay existencia de claves en un dictionary con in y haskey
+in(("uno", 1), dict_lleno) # => true
+in(("tres", 3), dict_lleno) # => false
+haskey(dict_lleno, "one") # => true
+haskey(dict_lleno, 1) # => false
+
+# Tratando de buscar una clave que no existe producirá un error
+try
+ dict_lleno["dos"] # => ERROR: key not found: dos in getindex at dict.jl:489
+catch e
+ println(e)
+end
+
+# Utilice el método get para evitar ese error proporcionando un valor
+# predeterminado
+# get(dictionary,key,default_value)
+get(dict_lleno,"one",4) # => 1
+get(dict_lleno,"four",4) # => 4
+
+# Usa Sets para representar colecciones (conjuntos) de valores únicos, no
+# ordenadas
+conjunto_vacio = Set() # => Set{Any}()
+# Iniciar una set de valores
+conjunto_lleno = Set(1,2,2,3,4) # => Set{Int64}(1,2,3,4)
+
+# Añadir más valores a un conjunto
+push!(conjunto_lleno,5) # => Set{Int64}(5,4,2,3,1)
+push!(conjunto_lleno,5) # => Set{Int64}(5,4,2,3,1)
+
+# Compruebe si los valores están en el conjunto
+in(2, conjunto_lleno) # => true
+in(10, conjunto_lleno) # => false
+
+# Hay funciones de intersección de conjuntos, la unión, y la diferencia.
+conjunto_otro= Set(3, 4, 5, 6) # => Set{Int64}(6,4,5,3)
+intersect(conjunto_lleno, conjunto_otro) # => Set{Int64}(3,4,5)
+union(conjunto_lleno, conjunto_otro) # => Set{Int64}(1,2,3,4,5,6)
+setdiff(Set(1,2,3,4),Set(2,3,5)) # => Set{Int64}(1,4)
+
+
+####################################################
+## 3. Control de Flujo
+####################################################
+
+# Hagamos una variable
+una_variable = 5
+
+# Aquí está una declaración de un 'if'. La indentación no es significativa en
+# Julia
+if una_variable > 10
+ println("una_variable es completamente mas grande que 10.")
+elseif una_variable < 10 # Este condición 'elseif' es opcional.
+ println("una_variable es mas chica que 10.")
+else # Esto también es opcional.
+ println("una_variable es de hecho 10.")
+end
+# => imprime "una_variable es mas chica que 10."
+
+# For itera sobre tipos iterables
+# Tipos iterables incluyen Range, Array, Set, Dict, y String.
+for animal=["perro", "gato", "raton"]
+ println("$animal es un mamifero")
+ # Se puede usar $ para interpolar variables o expresiónes en strings
+end
+# imprime:
+# perro es un mamifero
+# gato es un mamifero
+# raton es un mamifero
+
+for a in ["perro"=>"mamifero","gato"=>"mamifero","raton"=>"mamifero"]
+ println("$(a[1]) es un $(a[2])")
+end
+# imprime:
+# perro es un mamifero
+# gato es un mamifero
+# raton es un mamifero
+
+for (k,v) in ["perro"=>"mamifero", "gato"=>"mamifero", "raton"=>"mamifero"]
+ println("$k es un $v")
+end
+# imprime:
+# perro es un mamifero
+# gato es un mamifero
+# raton es un mamifero
+
+# While itera hasta que una condición no se cumple.
+x = 0
+while x < 4
+ println(x)
+ x += 1 # versión corta de x = x + 1
+end
+# imprime:
+# 0
+# 1
+# 2
+# 3
+
+# Maneja excepciones con un bloque try/catch
+try
+ error("ayuda")
+catch e
+ println("capturando $e")
+end
+# => capturando ErrorException("ayuda")
+
+
+####################################################
+## 4. Funciones
+####################################################
+
+# Usa 'function' para crear nuevas funciones
+
+#function nombre(arglist)
+# cuerpo...
+#end
+function suma(x, y)
+ println("x es $x e y es $y")
+
+ # Las funciones devuelven el valor de su última declaración
+ x + y
+end
+
+suma(5, 6) # => 11 # después de imprimir "x es 5 e y es de 6"
+
+# Puedes definir funciones que toman un número variable de
+# argumentos posicionales
+function varargs(args...)
+ return args
+ # Usa la palabra clave return para devolver en cualquier lugar de la función
+end
+# => varargs (generic function with 1 method)
+
+varargs(1,2,3) # => (1,2,3)
+
+# El ... se llama un splat.
+# Acabamos de utilizar lo en una definición de función.
+# También se puede utilizar en una llamada de función,
+# donde va splat un Array o el contenido de un Tuple en la lista de argumentos.
+Set([1,2,3]) # => Set{Array{Int64,1}}([1,2,3]) # Produce un Set de Arrays
+Set([1,2,3]...) # => Set{Int64}(1,2,3) # esto es equivalente a Set(1,2,3)
+
+x = (1,2,3) # => (1,2,3)
+Set(x) # => Set{(Int64,Int64,Int64)}((1,2,3)) # un Set de Tuples
+Set(x...) # => Set{Int64}(2,3,1)
+
+
+# Puede definir funciones con argumentos posicionales opcionales
+function defaults(a,b,x=5,y=6)
+ return "$a $b y $x $y"
+end
+
+defaults('h','g') # => "h g y 5 6"
+defaults('h','g','j') # => "h g y j 6"
+defaults('h','g','j','k') # => "h g y j k"
+try
+ defaults('h') # => ERROR: no method defaults(Char,)
+ defaults() # => ERROR: no methods defaults()
+catch e
+ println(e)
+end
+
+# Puedes definir funciones que toman argumentos de palabra clave
+function args_clave(;k1=4,nombre2="hola") # note the ;
+ return ["k1"=>k1,"nombre2"=>nombre2]
+end
+
+args_clave(nombre2="ness") # => ["nombre2"=>"ness","k1"=>4]
+args_clave(k1="mine") # => ["k1"=>"mine","nombre2"=>"hola"]
+args_clave() # => ["nombre2"=>"hola","k1"=>4]
+
+# Puedes combinar todo tipo de argumentos en la misma función
+function todos_los_args(arg_normal, arg_posicional_opcional=2; arg_clave="foo")
+ println("argumento normal: $arg_normal")
+ println("argumento optional: $arg_posicional_opcional")
+ println("argumento de clave: $arg_clave")
+end
+
+todos_los_args(1, 3, arg_clave=4)
+# imprime:
+# argumento normal: 1
+# argumento optional: 3
+# argumento de clave: 4
+
+# Julia tiene funciones de primera clase
+function crear_suma(x)
+ suma = function (y)
+ return x + y
+ end
+ return suma
+end
+
+# Esta es el sintaxis "stabby lambda" para crear funciones anónimas
+(x -> x > 2)(3) # => true
+
+# Esta función es idéntica a la crear_suma implementación anterior.
+function crear_suma(x)
+ y -> x + y
+end
+
+# También puedes nombrar la función interna, si quieres
+function crear_suma(x)
+ function suma(y)
+ x + y
+ end
+ suma
+end
+
+suma_10 = crear_suma(10)
+suma_10(3) # => 13
+
+
+# Hay funciones integradas de orden superior
+map(suma_10, [1,2,3]) # => [11, 12, 13]
+filter(x -> x > 5, [3, 4, 5, 6, 7]) # => [6, 7]
+
+# Podemos usar listas por comprensión para mapeos
+[suma_10(i) for i=[1, 2, 3]] # => [11, 12, 13]
+[suma_10(i) for i in [1, 2, 3]] # => [11, 12, 13]
+
+####################################################
+## 5. Tipos
+####################################################
+
+# Julia tiene sistema de tipos.
+# Cada valor tiene un tipo y las variables no tienen propios tipos.
+# Se puede utilizar la función `typeof` para obtener el tipo de un valor.
+typeof(5) # => Int64
+
+# Los tipos son valores de primera clase
+typeof(Int64) # => DataType
+typeof(DataType) # => DataType
+# DataType es el tipo que representa los tipos, incluyéndose a sí mismo.
+
+# Los tipos se usan para la documentación, optimizaciones, y envio.
+# No están comprobados estáticamente.
+
+# Los usuarios pueden definir tipos
+# Son como registros o estructuras en otros idiomas.
+# Nuevos tipos se definen utilizado la palabra clave `type`.
+
+# type Nombre
+# field::OptionalType
+# ...
+# end
+type Tigre
+ longituddecola::Float64
+ colordelpelaje # no incluyendo una anotación de tipo es el mismo que `::Any`
+end
+
+# Los argumentos del constructor por default son las propiedades
+# del tipo, en el orden en que están listados en la definición
+tigger = Tigre(3.5,"anaranjado") # => Tiger(3.5,"anaranjado")
+
+# El tipo funciona como la función constructora de valores de ese tipo
+sherekhan = typeof(tigger)(5.6,"fuego") # => Tiger(5.6,"fuego")
+
+
+# Este estilo de tipos son llamados tipos concrete
+# Se pueden crear instancias, pero no pueden tener subtipos.
+# La otra clase de tipos es tipos abstractos (abstract types).
+
+# abstract Nombre
+abstract Gato # sólo un nombre y un punto en la jerarquía de tipos
+
+# De los tipos Abstract no se pueden crear instancias, pero pueden tener
+# subtipos. Por ejemplo, Number es un tipo abstracto.
+subtypes(Number) # => 6-element Array{Any,1}:
+ # Complex{Float16}
+ # Complex{Float32}
+ # Complex{Float64}
+ # Complex{T<:Real}
+ # Real
+subtypes(Gato) # => 0-element Array{Any,1}
+
+# Cada tipo tiene un supertipo, utilice la función `súper` para conseguirlo.
+typeof(5) # => Int64
+super(Int64) # => Signed
+super(Signed) # => Real
+super(Real) # => Number
+super(Number) # => Any
+super(super(Signed)) # => Number
+super(Any) # => Any
+# Todo de estos tipos, a excepción de Int64, son abstractos.
+
+# <: es el operador de subtipos
+type Leon <: Gato # Leon es un subtipo de Gato
+ color_de_crin
+ rugido::String
+end
+
+# Se puede definir más constructores para su tipo.
+# Sólo defina una función del mismo nombre que el tipo
+# y llame a un constructor existente para obtener un valor del tipo correcto
+Leon(rugido::String) = Leon("verde",rugido)
+# Este es un constructor externo porque es fuera de la definición del tipo
+
+type Pantera <: Gato # Pantera tambien es un a subtipo de Cat
+ color_de_ojos
+ Pantera() = new("verde")
+ # Panteras sólo tendrán este constructor, y ningún constructor
+ # predeterminado.
+end
+# Utilizar constructores internos, como Panther hace, te da control sobre cómo
+# se pueden crear valores del tipo. Cuando sea posible, debes utilizar
+# constructores exteriores en lugar de los internos.
+
+####################################################
+## 6. Envio múltiple
+####################################################
+
+# En Julia, todas las funciones nombradas son funciones genéricas.
+# Esto significa que se construyen a partir de muchos métodos pequeños
+# Cada constructor de Leon es un método de la función genérica Leon.
+
+# Por ejemplo, vamos a hacer un maullar función:
+
+# Definiciones para Leon, Pantera, y Tigre
+function maullar(animal::Leon)
+ animal.rugido # acceso utilizando notación de puntos
+end
+
+function maullar(animal::Pantera)
+ "grrr"
+end
+
+function maullar(animal::Tigre)
+ "rawwwr"
+end
+
+# Prueba de la función maullar
+maullar(tigger) # => "rawwr"
+maullar(Leon("cafe","ROAAR")) # => "ROAAR"
+maullar(Pantera()) # => "grrr"
+
+# Revisar la jerarquía de tipos locales
+issubtype(Tigre,Gato) # => false
+issubtype(Leon,Gato) # => true
+issubtype(Pantera,Gato) # => true
+
+# Definición de una función que toma Gatos
+function mascota(gato::Gato)
+ println("El gato dice $(maullar(gato))")
+end
+
+mascota(Leon("42")) # => imprime "El gato dice 42"
+try
+ mascota(tigger) # => ERROR: no method mascota(Tigre))
+catch e
+ println(e)
+end
+
+# En los lenguajes orientados a objetos, expedición única es común. Esto
+# significa que el método se recogió basándose en el tipo del primer argumento.
+# En Julia, todos los tipos de argumentos contribuyen a seleccionar el mejor
+# método.
+
+# Vamos a definir una función con más argumentos, para que podamos ver la
+# diferencia
+function pelear(t::Tigre,c::Gato)
+ println("¡El tigre $(t.colordelpelaje) gana!")
+end
+# => pelear (generic function with 1 method)
+
+pelear(tigger,Pantera()) # => imprime ¡El tigre anaranjado gana!
+pelear(tigger,Leon("ROAR")) # => ¡El tigre anaranjado gana!
+
+# Vamos a cambiar el comportamiento cuando el Gato es específicamente un Leon
+pelear(t::Tigre,l::Leon) = println("El león con melena $(l.color_de_crin) gana")
+# => pelear (generic function with 2 methods)
+
+pelear(tigger,Pantera()) # => imprime ¡El tigre anaranjado gana!
+pelear(tigger,Leon("ROAR")) # => imprime El león con melena verde gana
+
+# No necesitamos un tigre para poder luchar
+pelear(l::Leon,c::Gato) = println("El gato victorioso dice $(maullar(c))")
+# => fight (generic function with 3 methods)
+
+pelear(Leon("balooga!"),Pantera()) # => imprime El gato victorioso dice grrr
+try
+ pelear(Pantera(),Leon("RAWR")) # => ERROR: no method pelear(Pantera, Leon))
+catch
+end
+
+# Un metodo con el gato primero
+pelear(c::Gato,l::Leon) = println("El gato le gana al León")
+# Warning: New definition
+# pelear(Gato,Leon) at none:1
+# is ambiguous with:
+# pelear(Leon,Gato) at none:1.
+# To fix, define
+# pelear(Leon,Leon)
+# before the new definition.
+# pelear (generic function with 4 methods)
+
+# Esta advertencia se debe a que no está claro que metodo de pelear será llamado
+# en:
+pelear(Leon("RAR"),Leon("cafe","rar")) # => imprime El gato victorioso dice rar
+# El resultado puede ser diferente en otras versiones de Julia
+
+pelear(l::Leon,l2::Leon) = println("Los leones llegan a un empate")
+pelear(Leon("GR"),Leon("cafe","rar")) # => imprime Los leones llegan a un empate
+
+
+# Un vistazo al nivel bajo
+# Se puede echar un vistazo a la LLVM y el código ensamblador generado.
+
+area_cuadrada(l) = l * l # area_cuadrada (generic function with 1 method)
+
+area_cuadrada(5) # => 25
+
+# ¿Qué sucede cuando damos area_cuadrada diferentes argumentos?
+code_native(area_cuadrada, (Int32,))
+ # .section __TEXT,__text,regular,pure_instructions
+ # Filename: none
+ # Source line: 1 # Prologue
+ # push RBP
+ # mov RBP, RSP
+ # Source line: 1
+ # movsxd RAX, EDI # Fetch l from memory?
+ # imul RAX, RAX # Square l and store the result in RAX
+ # pop RBP # Restore old base pointer
+ # ret # Result will still be in RAX
+
+code_native(area_cuadrada, (Float32,))
+ # .section __TEXT,__text,regular,pure_instructions
+ # Filename: none
+ # Source line: 1
+ # push RBP
+ # mov RBP, RSP
+ # Source line: 1
+ # vmulss XMM0, XMM0, XMM0 # Scalar single precision multiply (AVX)
+ # pop RBP
+ # ret
+
+code_native(area_cuadrada, (Float64,))
+ # .section __TEXT,__text,regular,pure_instructions
+ # Filename: none
+ # Source line: 1
+ # push RBP
+ # mov RBP, RSP
+ # Source line: 1
+ # vmulsd XMM0, XMM0, XMM0 # Scalar double precision multiply (AVX)
+ # pop RBP
+ # ret
+ #
+
+# Ten en cuenta que Julia usará instrucciones de "floating point" si alguno de
+# los argumentos son "floats"
+# Vamos a calcular el área de un círculo
+area_circulo(r) = pi * r * r # circle_area (generic function with 1 method)
+area_circulo(5) # 78.53981633974483
+
+code_native(area_circulo, (Int32,))
+ # .section __TEXT,__text,regular,pure_instructions
+ # Filename: none
+ # Source line: 1
+ # push RBP
+ # mov RBP, RSP
+ # Source line: 1
+ # vcvtsi2sd XMM0, XMM0, EDI # Load integer (r) from memory
+ # movabs RAX, 4593140240 # Load pi
+ # vmulsd XMM1, XMM0, QWORD PTR [RAX] # pi * r
+ # vmulsd XMM0, XMM0, XMM1 # (pi * r) * r
+ # pop RBP
+ # ret
+ #
+
+code_native(area_circulo, (Float64,))
+ # .section __TEXT,__text,regular,pure_instructions
+ # Filename: none
+ # Source line: 1
+ # push RBP
+ # mov RBP, RSP
+ # movabs RAX, 4593140496
+ # Source line: 1
+ # vmulsd XMM1, XMM0, QWORD PTR [RAX]
+ # vmulsd XMM0, XMM1, XMM0
+ # pop RBP
+ # ret
+ #
+```
+
+## ¿Listo para más?
+
+Puedes obtener muchos más detalles en [The Julia Manual](http://docs.julialang.org/en/latest/manual/)
+
+El mejor lugar para obtener ayuda con Julia es el (muy amable) [lista de correos](https://groups.google.com/forum/#!forum/julia-users).
+
diff --git a/es-es/perl-es.html.markdown b/es-es/perl-es.html.markdown
new file mode 100644
index 00000000..4f0c26c1
--- /dev/null
+++ b/es-es/perl-es.html.markdown
@@ -0,0 +1,160 @@
+---
+name: perl
+category: language
+language: perl
+filename: learnperl-es.pl
+contributors:
+ - ["Korjavin Ivan", "http://github.com/korjavin"]
+translators:
+ - ["Francisco Gomez", "http://github.com/frncscgmz"]
+lang: es-es
+---
+
+Perl 5 es un lenguaje de programación altamente capaz, rico en características con mas de 25 años de desarrollo.
+
+Perl 5 corre en mas de 100 plataformas desde portales hasta mainframes y es adecuado para realizar prototipos rápidos hasta desarrollar proyectos a gran escala.
+
+```perl
+# Comentarios de una sola linea con un carácter hash.
+
+#### Tipos de variables en Perl
+
+# Las variables comienzan con el símbolo $.
+# Un nombre de variable valido empieza con una letra o un guión bajo,
+# seguido por cualquier numero de letras, números o guiones bajos.
+
+### Perl tiene tres tipos principales de variables: escalares, arreglos y hashes.
+
+## Escalares
+# Un escalar representa un solo valor:
+my $animal = "camello";
+my $respuesta = 42;
+
+# Los valores escalares pueden ser cadenas de caracteres, números enteros o
+# de punto flotante, Perl automáticamente los convertirá como sea requerido.
+
+## Arreglos
+# Un arreglo representa una lista de valores:
+my @animales = {"camello","llama","buho"};
+my @numeros = {23,42,69};
+my @mixto = {"camello",42,1.23};
+
+
+
+## Hashes
+# Un hash representa un conjunto de pares llave/valor:
+
+my %color_fruta = {"manzana","rojo","banana","amarillo"};
+
+# Puedes usar un espacio en blanco y el operador "=>" para asignarlos mas
+# fácilmente.
+
+my %color_fruta = (
+ manzana => "rojo",
+ banana => "amarillo",
+ );
+# Los escalares, arreglos y hashes están mas documentados en perldata. (perldoc perldata).
+
+# Los tipos de datos mas complejos pueden ser construidos utilizando
+# referencias, las cuales te permiten construir listas y hashes dentro
+# de listas y hashes.
+
+#### Estructuras condicionales y de ciclos
+
+# Perl tiene la mayoría de las estructuras condicionales y de ciclos mas comunes.
+
+if ( $var ) {
+ ...
+} elsif ( $var eq 'bar' ) {
+ ...
+} else {
+ ...
+}
+
+unless ( condicion ) {
+ ...
+ }
+# Esto es proporcionado como una version mas fácil de leer que "if (!condición)"
+
+# La post condición al modo Perl
+print "Yow!" if $zippy;
+print "No tenemos bananas" unless $bananas;
+
+# while
+ while ( condicion ) {
+ ...
+ }
+
+
+# for y foreach
+for ($i = 0; $i <= $max; $i++) {
+ ...
+ }
+
+foreach (@array) {
+ print "Este elemento es $_\n";
+ }
+
+
+#### Expresiones regulares
+
+# El soporte de expresiones regulares en Perl es muy amplio y profundo, y es
+# sujeto a una extensa documentación en perlrequick, perlretut, entre otros.
+# Sin embargo, resumiendo:
+
+# Pareo simple
+if (/foo/) { ... } # verdadero si $_ contiene "foo"
+if ($a =~ /foo/) { ... } # verdadero si $a contiene "foo"
+
+# Substitución simple
+$a =~ s/foo/bar/; # remplaza foo con bar en $a
+$a =~ s/foo/bar/g; # remplaza TODAS LAS INSTANCIAS de foo con bar en $a
+
+
+#### Archivos e I/O
+
+# Puedes abrir un archivo para obtener datos o escribirlos utilizando la
+# función "open()".
+
+open(my $entrada, "<" "entrada.txt") or die "No es posible abrir entrada.txt: $!";
+open(my $salida, ">", "salida.txt") or die "No es posible abrir salida.txt: $!";
+open(my $log, ">>", "mi.log") or die "No es posible abrir mi.log: $!";
+
+# Es posible leer desde un gestor de archivo abierto utilizando el operador "<>"
+# operador. En contexto escalar leer una sola linea desde el gestor de
+# archivo, y en contexto de lista leer el archivo completo en donde, asigna
+# cada linea a un elemento de la lista.
+
+my $linea = <$entrada>;
+my @lineas = <$entrada>;
+
+#### Escribiendo subrutinas
+
+# Escribir subrutinas es fácil:
+
+sub logger {
+ my $mensajelog = shift;
+ open my $archivolog, ">>", "mi.log" or die "No es posible abrir mi.log: $!";
+ print $archivolog $mensajelog;
+}
+
+# Ahora podemos utilizar la subrutina al igual que cualquier otra función
+# incorporada:
+
+logger("Tenemos una subrutina logger!");
+
+
+```
+
+#### Utilizando módulos Perl
+
+Los módulos en Perl proveen una gama de funciones que te pueden ayudar a evitar reinventar la rueda, estas pueden ser descargadas desde CPAN( http://www.cpan.org/ ). Algunos de los módulos mas populares ya están incluidos con la misma distribución de Perl.
+
+perlfaq contiene preguntas y respuestas relacionadas con muchas tareas comunes, y algunas veces provee sugerencias sobre buenos módulos CPAN para usar.
+
+#### Material de Lectura
+
+ - [perl-tutorial](http://perl-tutorial.org/)
+ - [Aprende en www.perl.com](http://www.perl.org/learn.html)
+ - [perldoc](http://perldoc.perl.org/)
+ - y perl incorporado: `perldoc perlintro`