Merge pull request #694 from DanielZendejas/master

[xml/es] created

3 files changed, 368 insertions, 0 deletions

diff --git a/es-es/brainfuck-es.html.markdown b/es-es/brainfuck-es.html.markdown
new file mode 100644
index 00000000..e33d672d
--- /dev/null
+++ b/es-es/brainfuck-es.html.markdown
@@ -0,0 +1,87 @@
+---
+language: brainfuck
+contributors:
+    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
+    - ["Mathias Bynens", "http://mathiasbynens.be/"]
+translators:
+    - ["Daniel Zendejas", "https://github.com/DanielZendejas"]
+lang: es-es
+---
+
+Brainfuck (con mayúscula sólo al inicio de una oración) es un
+lenguaje de programación mínimo, computacionalmente universal
+en tamaño con sólo 8 comandos.
+
+```
+
+Cualquier caracter que no sea "><+-.,[]" (sin incluir las comillas)
+será ignorado.
+
+Brainfuck es representado por un arreglo de 30,000 celdas inicializadas
+en cero y un apuntador en la celda actual.
+
+Existen ocho comandos:
+
++ : Incrementa 1 al valor de la celda actual.
+- : Decrementa 1 al valor de la celda actual.
+> : Mueve el apuntador a la siguiente celda. (a la derecha)
+< : Mueve el apuntador a la celda anterior. (a la izquierda)
+. : Imprime el valor en ASCII de la celda actual (i.e. 65 = 'A')
+, : Lee un caracter como input y lo escribe en la celda actual.
+[ : Si el valor en la celda actual es cero mueve el apuntador
+	hasta el primer ']' que encuentre. Si no es cero sigue a la
+	siguiente instrucción.
+] : Si el valor en la celda actual es cero, entonces sigue con 
+	la siguiente instrucción. Si no entonces mueve el apuntador
+	hacia atrás	hasta encontrar el primer '['.
+
+[ y ] forman un while. Obviamente, deben estar balanceados.
+
+Ahora unos ejemplos de programas escritos con brainfuck.
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+Este programa imprime la letra 'A'. Primero, incrementa la celda #1 a 
+6. La celda #1 será usada para hacer los ciclos. Después entra al ciclo
+([) y se mueve a la celda #2 (>). Después incrementa la celda #2 10 veces,
+y se regresa a la celda #1 (<), para después decrementarla en 1 (-).
+Este ciclo ocurre 6 veces (le toma 6 decrementos a la celda #1 volverse 0),
+cuando esto pasa se salta a (]) y continúa.
+
+En este punto estamos en la celda #1, que tiene un valor de 0, mientras
+que la celda #2 tiene un valor de 60. Nos movemos a la celda #2 (>),
+la incrementamos 5 veces para tener un valor de 65 y luego imprimimos
+el valor de la celda #2 (.). 65 es 'A' en ASCII así que la letra 'A'
+se imprime.
+
+, [ > + < - ] > .
+
+Este programa lee un caracter del input y lo copia en la celda #2 (,). 
+Después empieza un ciclo. Nos movemos a la celda #2 (>) e incrementamos su
+valor (+). Regresamos a la celda #1 y decrementamos su valor en 1 (-).
+Esto continúa hasta que la celda #1 contenga un cero. Cuando #1 contenga un 
+cero la celda #2 tendrá el valor inicial de #1. Como este ciclo siempre
+terminara en la celda #1 nos movemos a la celda #2 e imprimimos (.).
+
+Ten en mente que los espacios son sólo para fines de legibilidad.
+Es lo mismo escribir el ejemplo de arriba que esto:
+,[>+<-]>.
+
+Intenta descrifrar lo que hace este programa:
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+
+Este programa toma dos números como input y los multiplica.
+
+Primero recibe dos números del usuario. Luego empieza el ciclo externo,
+condicionado en la celda #1. Luego se mueve a la celda #2, comenzando
+el ciclo interno condicionado en la celda #2 incrementando la celda #3.
+Sin embargo viene un problema: El ciclo interior no funcionará nuevamente
+hasta la próxima vez. Para resolver este problema también incrementamos la
+celda #4 y luego copiamos la celda #4 a la celda #2. La celda #3 contiene
+el resultado.
+```
+Y eso es brainfuck. ¿No tan difícil o sí? Como diversión, puedes escribir
+tu propio intérprete de brainfuck o tu propio programa en brainfuck. El
+intérprete es relativamente sencillo de hacer, pero si eres masoquista,
+intenta construir tu proprio intérprete de brainfuck... en brainfuck.
diff --git a/es-es/xml-es.html.markdown b/es-es/xml-es.html.markdown
new file mode 100644
index 00000000..2e9326cf
--- /dev/null
+++ b/es-es/xml-es.html.markdown
@@ -0,0 +1,131 @@
+---
+language: xml
+filename: learnxml.xml
+contributors:
+  - ["João Farias", "https://github.com/JoaoGFarias"]
+translators:
+  - ["Daniel Zendejas", "https://github.com/DanielZendejas"]
+lang: es-es
+---
+XML es un lenguaje diseñado para guardar y transportar datos
+
+A diferencia de HTML, XML no especifica cómo desplegar la información,
+sólo la guarda.
+
+* Sintaxis XML
+
+```xml
+<!-- Los comentarios en XML son de esta forma -->
+
+<?xml version="1.0" encoding="UTF-8"?>
+<tiendaDeLibros>
+  <libro categoria="COCINA">
+    <titulo lenguaje="en">Everyday Italian</titulo>
+    <autor>Giada De Laurentiis</autor>
+    <anio>2005</anio>
+    <precio>30.00</precio>
+  </libro>
+  <libro categoria="INFANTES">
+    <titulo lenguaje="en">Harry Potter</titulo>
+    <autor>J K. Rowling</autor>
+    <anio>2005</anio>
+    <precio>29.99</precio>
+  </libro>
+  <libro categoria="WEB">
+    <titulo lenguaje="en">Learning XML</titulo>
+    <autor>Erik T. Ray</autor>
+    <anio>2003</anio>
+    <precio>39.95</precio>
+  </libro>
+</tiendaDeLibros>
+
+<!-- Este es un archivo típico de XML.
+  Empieza con una declaración de metadatos (opcional).
+  
+  XML usa una estructura de árbol. El nodo raíz es 'tiendaDeLibros', el cual
+  tiene tres nodos hijos, todos llamados 'libros'. 
+  Esos nodos tienen más nodos hijos, y así continúa... 
+  
+  Los nodos son creados usando tags que abren y cierran, y los hijos 
+  son sólo nodos entre estas tags.-->
+
+
+<!-- XML guarda dos tipos de datos:
+  1 - Atributos -> Son los metadatos de un nodo.
+	  Usualmente el parseador XML usa esta información para guardar los datos
+	  apropiadamente. Aparecen con el formato (nombre="valor") dentro de la
+	  tag que abre.
+  2 - Elementos -> Ese es el dato puro.
+  	  Eso es lo que el parseador recuperará del archivo XML.
+  	  Los elementos aparecen entre las tags que abren y cierran.-->
+      
+  
+<!-- Debajo, un elemento con dos atributos. -->
+<archivo tipo="gif" id="4293">computer.gif</archivo>
+
+
+```
+
+* Documentos con buen formato x Validación
+
+Un documento XML está bien formado cuando es sintácticamente correcto.
+Aún esto, es posible inyectar más restricciones en el documento,
+usando definiciones de documento, así como DTD o XML Schemas.
+
+Un documento XML que sigue a una definición de documento (un esquema) es
+válida. 
+
+Con esta herramienta puedes validar datos XML fuera de la aplicación
+
+```xml
+
+<!-- Debajo puedes encontrar una versión simplificada del documento 
+  tiendaDeLibros en adición a la definición DTD.-->
+
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE note SYSTEM "tiendaDeLibros.dtd">
+<tiendaDeLibros>
+  <libro categoriq="COCINA">
+    <titulo>Everyday Italian</titulo>
+    <precio>30.00</precio>
+  </libro>
+</tiendaDeLibros>
+
+<!-- El DTD de este documento podría verse algo así:-->
+
+<!DOCTYPE note
+[
+<!ELEMENT tiendaDeLibros (libro+)>
+<!ELEMENT libro (titulo,precio)>
+<!ATTLIST libro categoria CDATA "Literatura">
+<!ELEMENT titulo (#PCDATA)>
+<!ELEMENT precio (#PCDATA)>
+]>
+
+<!--El DTD empieza con una declaración.
+	Después el nodo raíz es declarado, requiriendo 1 o más nodos 'libro'
+	Cada 'libro' debe contener exactamente un 'titulo' y un 'precio' y
+	un atributo llamado 'categoria', con "Literatura" como su valor 
+	default.
+	Los nodos 'titulo' y 'precio' contienen datos de caracteres
+	parseados.
+	
+	El DTD puede ser declarado dentro del XML mismo.-->
+
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!DOCTYPE note
+[
+<!ELEMENT tiendaDeLibros (libro+)>
+<!ELEMENT libro (titulo,precio)>
+<!ATTLIST libro categoria CDATA "Literatura">
+<!ELEMENT titulo (#PCDATA)>
+<!ELEMENT precio (#PCDATA)>
+]>
+<tiendaDeLibros>
+  <libro categoriq="COCINA">
+    <titulo>Everyday Italian</titulo>
+    <precio>30.00</precio>
+  </libro>
+</tiendaDeLibros>
+```
diff --git a/es-es/yaml-es.html.markdown b/es-es/yaml-es.html.markdown
new file mode 100644
index 00000000..0423261a
--- /dev/null
+++ b/es-es/yaml-es.html.markdown
@@ -0,0 +1,150 @@
+---
+language: yaml
+filename: learnyaml-es.yaml
+contributors:
+  - ["Adam Brenecki", "https://github.com/adambrenecki"]
+translators:
+  - ["Daniel Zendejas","https://github.com/DanielZendejas"]
+---
+Tutorial de YAML en español.
+
+YAML es un lenguaje de serialización de datos diseñado para ser
+leído y escrito por humanos.
+
+Basa su funcionalidad en JSON, con la adición de líneas nuevas
+e indentación inspirada en Python. A diferencia de Python, YAML
+no permite tabs literales.
+
+```yaml
+# Los comentarios en YAML se ven así.
+
+###################
+# TIPOS ESCALARES #
+###################
+
+# Nuestro objeto raíz (el cual es el mismo a lo largo de todo el
+# documento) será un mapa, equivalente a un diccionario, hash,
+# u objeto en otros lenguajes.
+
+llave: valor
+otra_llave: Otro valor
+un_valor_numerico: 100
+notacion_cientifica: 1e+12
+booleano: true
+valor_nulo: null
+llave con espacios: valor
+# Nótese que los strings no deben estar entre comillas, aunqué también es válido.
+llave: "Un string, entre comillas."
+"Las llaves tambien pueden estar entre comillas.": "valor entre comillas"
+
+# Los strings de líneas múltiples pueden ser escritos 
+# como un 'bloque literal' (usando pipes |)
+# o como un 'bloque doblado' (usando >)
+
+bloque_literal: |
+	Este bloque completo de texto será preservado como el valor de la llave
+	'bloque_literal', incluyendo los saltos de línea.
+	
+	Se continúa guardando la literal hasta que se cese la indentación. 
+		Cualquier línea que tenga más indentación, mantendrá los espacios dados
+		(por ejemplo, estas líneas se guardarán con cuatro espacios)
+
+nloque_doblado: >
+	De la misma forma que el valor de 'bloque_literal', todas estas
+	líneas se guardarán como una sola literal, pero en esta ocasión todos los
+	saltos de línea serán reemplazados por espacio.
+
+	Las líneas en blanco, como la anterior, son convertidos a un salto de línea.
+
+        Las líneas con mayor indentación guardan sus saltos de línea.
+        Esta literal ocuparán dos líneas.
+
+########################
+# TIPOS DE COLECCIONES #
+########################
+
+# La indentación se usa para anidar.
+un_mapa_indentado:
+    llave: valor
+    otra_llave: otro valor
+    otro_mapa_indentado:
+        llave_interna: valor_interno
+
+# Las llaves de los mapas no deben ser strings necesariamente
+0.25: una llave numérica
+
+# Las llaves también pueden ser objetos de multi línea, usando ? para indicar
+# el inicio de una llave
+? |
+    Esto es una llave
+    que tiene múltiples líneas
+: y este es su valor
+
+# YAML tambien permite colecciones como llaves, pero muchos lenguajes de 
+# programación se quejarán.
+
+# Las secuencias (equivalentes a listas o arreglos) se ven así:
+una_secuencia:
+    - Item 1
+    - Item 2
+    - 0.5 # las secuencias pueden tener distintos tipos en su contenido.
+    - Item 4
+    - llave: valor
+      otra_llave: otro_valor
+    -
+        - Esta es una secuencia
+        - ...dentro de otra secuencia
+
+# Dado que todo JSON está incluído dentro de YAML, también puedes escribir 
+# mapas con la sintaxis de JSON y secuencias: 
+mapa_de_json: {"llave": "valor"}
+secuencia_de_json: [3, 2, 1, "despegue"]
+
+##################################
+# CARACTERÍSTICAS EXTRAS DE YAML #
+##################################
+
+# YAML tiene funciones útiles llamadas 'anchors' (anclas), que te permiten
+# duplicar fácilmente contenido a lo largo de tu documento. En el ejemplo
+# a continuación, ambas llaves tendrán el mismo valor:
+contenido_anclado: &nombre_del_ancla Este string será el valor de las llaves
+otra_ancla: *nombre_del_ancla
+
+# YAML también tiene tags, que puedes usar para declarar tipos explícitamente.
+string_explícito: !!str 0.5
+# Algunos parseadores implementar tags específicas del lenguaje, como el 
+# que se muestra a continuación, encargado de manejar números complejos en
+# Python:
+numero_complejo_python: !!python/complex 1+2j
+
+########################
+# TIPOS EXTRAS EN YAML #
+########################
+
+# Stirngs y números no son los únicos escalares que YAML puede entener.
+# YAML también puede parsear fechas en formato ISO .
+fechaHora: 2001-12-15T02:59:43.1Z
+fechaHora_con_espacios: 2001-12-14 21:59:43.10 -5
+fecha: 2002-12-14
+
+# La tag !!binary indica que un string es, en realidad, un blob
+# representado en base-64.
+archivo_gif: !!binary |
+    R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5
+    OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+
+    +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
+    AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=
+
+# YAML también tiene un tipo set, que se ve de la siguiente forma:
+set:
+    ? item1
+    ? item2
+    ? item3
+
+# Al igual que Python, los sets sólo son mapas con valores nulos.
+# El ejemplo de arriba es equivalente a: 
+set2:
+    item1: null
+    item2: null
+    item3: null
+```