1 files changed, 260 insertions, 0 deletions
diff --git a/es-es/make-es.html.markdown b/es-es/make-es.html.markdown
new file mode 100644
index 00000000..0e07ec13
--- /dev/null
+++ b/es-es/make-es.html.markdown
@@ -0,0 +1,260 @@
+---
+category: tool
+tool: make
+filename: Makefile
+contributors:
+    - ["Robert Steed", "https://github.com/robochat"]
+    - ["Stephan Fuhrmann", "https://github.com/sfuhrm"]
+translators:
+    - ["Andrés Perdomo", "https://github.com/andres7293"]
+lang: es-es
+---
+
+Un archivo Makefile define un conjunto de reglas para crear un objetivo (o
+varios objetivos). Su propósito es hacer la mínima cantidad de trabajo necesaria
+para actualizar un objetivo a la versión más reciente de la fuente. Escrito
+famosamente en un fin de semana por Stuart Feldman en 1976, todavía se utiliza
+ampliamente (especialmente en Unix y Linux) a pesar de muchos competidores y
+críticas.
+
+Existen muchas variedades de Make en existencia, no obstante, este artículo
+asume que estamos utilizando GNU Make, que es el estándar en Linux.
+
+```make
+# Los comentarios se pueden escribir de esta forma.
+
+# El fichero debe tener el nombre de Makefile y luego puede ser ejecutado
+# como `make <objetivo>`.
+# De lo contrario, se utiliza `make -f "nombre_archivo" <objetivo>`
+
+# Advertencia: ¡solo use TABULACIONES para la identación en Makefiles, nunca
+# espacios!
+
+#-----------------------------------------------------------------------
+# Fundamentos
+#-----------------------------------------------------------------------
+
+# Las reglas tienen el formato
+# objetivo: <prerrequisito>
+# donde prerrequisito es opcional.
+
+# Una regla - esta regla solamente se ejecutará si file0.txt no existe.
+file0.txt:
+	echo "foo" > file0.txt
+	# Incluso los comandos en esta sección de 'receta' se pasan a la shell.
+	# Prueba `make file0.txt` o  simplemente 'make' - La primera regla es la
+	# predeterminada.
+
+# Esta regla se ejecutará solo si file0.txt es más reciente que file1.txt.
+file1.txt: file0.txt
+	cat file0.txt > file1.txt
+	# Use las mismas reglas de comillas que en la shell.
+	@cat file0.txt >> file1.txt
+	# @ evita que el comando se muestre en stdout.
+	-@echo 'hello'
+	# - Quiere decir que make continuará en caso de error.
+	# Pruebe 'make file1.txt` en la línea de comandos.
+
+# Una regla puede tener múltiples objetivos y múltiples prerrequisitos
+file2.txt file3.txt: file0.txt file1.txt
+	touch file2.txt
+	touch file3.txt
+
+# Make se quejará de múltiples recetas para la misma regla. Sin embargo,
+# las reglas vacías no cuentan y se pueden utilizar para agregar nuevas
+# dependencias
+
+#-----------------------------------------------------------------------
+# Objetivos ficticios (Phony Targets)
+#-----------------------------------------------------------------------
+
+# Un objetivo ficticio (phony target). Cualquier objetivo que no sea un archivo.
+# Nunca estará actualizado, por lo que make siempre tratará de ejecutarlo.
+all: make process
+
+# Podemos declarar cosas sin orden.
+maker:
+	touch ex0.txt ex1.txt
+
+# Se puede evitar que las reglas ficticias (phony) se rompan cuando un archivo
+# real tiene el mismo nombre usando:
+.PHONY: all maker process
+# Esto es un objetivo especial. Hay varios otros.
+
+# Una regla con una dependencia en un objetivo ficticio (phony target)
+# se ejecutara siempre:
+ex0.txt ex1.txt: maker
+
+# Los objetivos ficticios (phony target) más comunes son: 
+# all make clean install...
+
+#-----------------------------------------------------------------------
+# Variables automáticas y Wildcards
+#-----------------------------------------------------------------------
+
+process: file*.txt	# usa un wildcard para coincidir con los nombres de archivos.
+	@echo $^	# $^ es una variable que contiene una lista de todos los prerrequisitos
+	@echo $@	# imprime el nombre del objetivo
+	#(para reglas con múltiples objetivos, $@ es el que hizo que se ejecutara la regla)
+	@echo $<	#  el primer prerrequisito listado
+	@echo $?	# solo las dependencias que están desactualizadas
+	@echo $+	# todas las dependencias incluyendo las duplicadas (a diferencia de lo normal)
+	#@echo $|	# solo los 'prerrequisitos solicitados'
+
+# Incluso si dividimos las definiciones de las dependencias, de las reglas, $^
+# las encontrará
+process: ex1.txt file0.txt
+# ext1.xt se encontrará pero file0.txt se duplicará.
+
+#-----------------------------------------------------------------------
+# Patrones
+#-----------------------------------------------------------------------
+
+# Se puede instruir a make sobre como convertir ciertos tipos de archivos en
+# otros archivos.
+
+%.png: %.svg
+	inkscape --export-png $^
+
+# Las reglas de patrones solo harán algo si make decide crear el objetivo.
+
+# Los directorios no suelen tenerse en cuenta al coincidir con reglas de
+# patrones.
+# Pero make intentará usar la regla más apropiada disponible.
+
+small/%.png: %.svg
+	inkscape --export-png --export-dpi 30 $^
+
+# make usará la última versión de una regla de patrón que encuentre.
+%.png: %.svg
+	@echo esta regla es elegida
+
+# Sin embargo make usará la primera regla de patrón que pueda construir el
+# objetivo.
+%.png: %.ps
+	@echo esta regla no es elegida si *.svg y *.ps están ambas presentes
+
+# Make ya tiene algunas reglas de patrón integradas.
+# Por ejemplo, sabe cómo convertir archivos *.c en archivos *.o.
+
+# En makefiles antiguos se solían utilizar las reglas de sufijo en lugar de las
+# reglas de patrón
+.png.ps:
+	@echo esta regla es similar a una regla de patrón.
+
+# Instruye a make sobre una regla de sufijo
+.SUFFIXES: .png
+
+#-----------------------------------------------------------------------
+# Variables
+#-----------------------------------------------------------------------
+# también conocidas como macros.
+
+# Las variables son básicamente de tipo cadena (string)
+
+name = Ted
+name2="Sarah"
+
+echo:
+	@echo $(name)
+	@echo ${name2}
+	@echo $name    # Esto no funcionará, se tratará como $(n)name.
+	@echo $(name3) # Variables desconocidas se tratarán como cadenas vacías.
+
+# Hay 4 lugares donde se pueden definir variables.
+# En orden de prioridad de mayor a menor:
+# 1: argumentos de línea de comando.
+# 2: Makefile.
+# 3: variables de entorno de la shell - make las importa automáticamente.
+# 4: make tiene algunas variables predefinidas.
+
+name4 ?= Jean
+# Solo establece la variable si la variable de entorno no está aún definida.
+
+override name5 = David
+# Detiene que los argumentos de línea de comandos modifiquen esta variable.
+
+name4 +=grey
+# Añade valores a la variable (incluye un espacio).
+
+# Valores de variables específicos de patrones (Extension de GNU).
+echo: name2 = Sara # Verdadero dentro de la regla coincidente
+	# y también dentro de sus dependencias recursivas rehechas
+	# (¡excepto que puede romperse cuando el grafo se complica demasiado!)
+
+# Algunas variables son definidas automáticamente por make.
+echo_inbuilt:
+	echo $(CC)
+	echo ${CXX}
+	echo $(FC)
+	echo ${CFLAGS}
+	echo $(CPPFLAGS)
+	echo ${CXXFLAGS}
+	echo $(LDFLAGS)
+	echo ${LDLIBS}
+
+#-----------------------------------------------------------------------
+# Variables 2
+#-----------------------------------------------------------------------
+
+# El primer tipo de variables se evalúan cada vez que se usan.
+# Esto puede ser costoso, por lo que existe un segundo tipo de variable que se
+# evalúa solo una vez. (Esta es una extensión de GNU make)
+
+var := hello
+var2 ::=  $(var) hello
+#:= y ::= son equivalentes
+
+# Estas variables se evalúan de manera procedimental (en el orden en que
+# aparecen), ¡rompiendo así con el resto del lenguaje!
+
+# Esto no funciona
+var3 ::= $(var4) and good luck
+var4 ::= good night
+
+#-----------------------------------------------------------------------
+# Funciones
+#-----------------------------------------------------------------------
+
+# make tiene muchas funciones disponibles.
+
+sourcefiles = $(wildcard *.c */*.c)
+objectfiles = $(patsubst %.c,%.o,$(sourcefiles))
+
+# El formato es $(func arg0,arg1,arg2...)
+
+# Algunos ejemplos
+ls:	* src/*
+	@echo $(filter %.txt, $^)
+	@echo $(notdir $^)
+	@echo $(join $(dir $^),$(notdir $^))
+
+#-----------------------------------------------------------------------
+# Directrices (Directives)
+#-----------------------------------------------------------------------
+
+# Incluye otros makefiles, útil para código de plataformas específicas
+include foo.mk
+
+sport = tennis
+# Compilación condicional
+report:
+ifeq ($(sport),tennis)
+	@echo 'game, set, match'
+else
+	@echo "They think it's all over; it is now"
+endif
+
+# También existe ifneq, ifdef, ifndef
+
+foo = true
+
+ifdef $(foo)
+bar = 'hello'
+endif
+```
+
+### Más recursos (en inglés)
+
++ [GNU Make documentation](https://www.gnu.org/software/make/manual/)
++ [Software carpentry tutorial](http://swcarpentry.github.io/make-novice/)