Gatsby V4, optimizations, and progress on spanish translation

.github/workflows/deploy.yml

@@ -9,10 +9,10 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - name: Use Node.js 12.x
+      - name: Use Node.js 16.x
         uses: actions/setup-node@v1
         with:
-          node-version: 12.x
+          node-version: 16.x
       - name: Install dependencies
         run: npm ci
       - name: Deploy with static

.nvmrc

@@ -0,0 +1 @@
+16

content/books/algorithms-for-visual-design/index.es.mdx

@@ -0,0 +1,10 @@
+---
+title: "Algorithms for Visual Design Using the Processing Language"
+author: "Kostas Terzidis"
+details: "Wiley. 384 Páginas. Cubierta dura."
+published: "2009-05"
+buy: "Ordena de Amazon-http://www.amazon.com/gp/product/0470375485?ie=UTF8&tag=processing09-20&linkCode=as2&camp=1789&creative=9325&creativeASIN=0470375485"
+language: ""
+---
+
+El sitio web de Wiley website dice: "este libro ofrece una serie de procedimientos genéricos que pueden funcionar como bloques constructores y te motiva a usarlos para experimentar, explorar y canalizar tus pensamientos, ideas y principios en soluciones potenciales. El libro cubre temas como formas estructuradas, geometría sólida, redes y bases de datos, computación física, procesamiento de imágenes, interfaces gráficas de usuario y mucho más."

content/books/built-with-processing/index.es.mdx

@@ -0,0 +1,12 @@
+---
+title: "Built with Processing"
+author: ""
+details: "BNN. 232 páginas. Pasta blanda."
+published: "2007-03"
+buy: ""
+language: "Japonés"
+---
+Nota de Casey: "He recibido una copia de este libro de los autores en un viaje reciente a Japón. Es un libro producido bellamente a todo color que presenta Processing, mostrando trabajos creados con Processing (muchos de ellos en la sección de Exhibición del sitio web de Processing), he introduciendo la programación a través de ejemplos cada vez más complicados. La mayor parte del libro es una introducción a la programación. Hay muy buenos ejemplos y el código esta a color como en el Entorno Processing. Este libro es menos comprehensivo que los libros de Greenberg y Reas/Fry, pero parece ser una breve y buena introducción."
+
+Hay información adicional en el sitio web del [ editor.](http://www.bnn.co.jp/books/title_index/web/processing.html)
+

content/books/coding-art/index.es.mdx

@@ -0,0 +1,10 @@
+---
+title: "Coding Art: The Four Steps to Creative Programming with the Processing Language"
+author: "Yu Zhang, Mathias Funk"
+details: "Apress. 280 páginas. Pasta blanda."
+published: "2021-01"
+buy: "Ordena de Apress-https://www.apress.com/gp/book/9781484262634,Ordena de Amazon-https://www.amazon.com/gp/product/1484262638"
+language: ""
+---
+El autor escribe: "Finalmente, un libro sobre programación creativa, escrito directamente para artistas y diseñadores! En lugar de seguir un temario de ciencias computacionales, este libro está dirigido a creativos que están trabajando en la intersección de diseño, arte y educación. En este libro aprenderás como aplicar la computación dentro del proceso creativo al seguir un proceso de cuatro pasos, ubicándote en la intersección del código y el arte, y con el foco en ejemplos prácticos y estructuras de trabajo relevantes. Seguirás un caso de uso del mundo real de arte computacional y verás como se relaciona con cuatro pilares clave, considerando fallos y retos potenciales en el proceso creativo. Todo el código de los ejemplos está integrado en una biblioteca de ejemplos de Processing, haciendo fácil a los lectores el empezar."
+

content/books/learn-python-visually/index.es.mdx

@@ -0,0 +1,20 @@
+---
+title: "Learn Python Visually: Creative Coding with Processing.py"
+author: "Tristan Bunn"
+details: "No Starch Press. 296 páginas. Libro de bolsillo y libro electrónico."
+published: "2021-04"
+buy: "Ordena de No Starch Press-https://nostarch.com/Learn-Python-Visually,Ordena de Amazon-https://www.amazon.com/Learn-Python-Visually-Tristan-Bunn/dp/1718500963"
+language: ""
+---
+
+Un enfoque accesible, visual y creativo para aprender conceptos básicos de programación usando el modo Python de Processing, Processing.py.
+
+El editor escribe: "Desde el primer capítulo tú producirás y manipularás coloridos dibujos, formas y patrones mientras el autor te encamina a través de una serie de proyectos gráficos fáciles de seguir que van incrementando su complejidad. Irás de dibujar con código a animar el rebote de un DVD para un protector de pantalla mientras prácticas técnicas de visualización de datos. En el transcurso te encontraras con retos creativos pero prácticos que se relacionan con video juegos, carros, café, bellas artes, amibas y Pink Floyd. Mientras crece tu fluidez tanto en programación como en Python, los temas se dirigen hacia el pensamiento algorítmico mientras exploras movimiento periódico, curvas de Lissajous y usas clases para crear objetos."
+
+El editor lista:
+
+- Teorías y conceptos básicos de programación, como variables, tipos de datos, coordenadas de píxeles, flujo de control y algoritmos
+- Escribirás código que produce dibujos, patrones, animaciones, visualización de datos, interfaces de usuario y simulaciones
+- usarás declaraciones condicionales, iteraciones, aleatoriedad, listas y diccionarios
+- definirás funciones, reduciendo la repetición y haciendo tu código más modular
+- escribirás clases y crearás objetos para estructurar tu código de manera eficiente

content/books/nature-of-code/index.es.mdx

@@ -0,0 +1,13 @@
+---
+title: "The Nature of Code: Simulating Natural Systems with Processing"
+author: "Daniel Shiffman"
+details: "PDF, Web, Pasta blanda."
+published: "2012-12"
+buy: "Ordena de Amazon-http://www.amazon.com/gp/product/0985930802/ref=as_li_ss_tl?ie=UTF8&camp=1789&creative=390957&creativeASIN=0985930802&linkCode=as2&tag=processing09-20"
+language: ""
+---
+
+Visita [La naturaleza del código](http://natureofcode.com/)
+
+¿Cómo podemos capturar las impredecibles propiedades evolucionarias y emergentes de la naturaleza en código?¿Cómo puede el entender los principios matemáticos detrás de nuestro mundo físico ayudarnos a crear mundos digitales? Este libro se enfoca a un rango de estrategias de programación detrás de las simulaciones computacionales de sistemas naturales, desde conceptos elementales en matemáticas y física a algoritmos avanzados que permiten sofisticados resultados visuales. Los lectores progresarán desde la construcción de un motor de física básico hasta la creación de objetos inteligentes y móviles, sentando las bases para diversos experimentos en diseño generativo. Los temas incluyen fuerzas, trigonometría, fractales, automatas celulares, auto-organización y algoritmos genéticos
+

content/contributions/$1_Unistroke_Recognizer.es.json

@@ -0,0 +1,19 @@
+{
+  "name": "$1 Reconocedor Unistroke",
+  "authors": ["[Darius Morawiec](http://nok.onl)"],
+  "url": "https://github.com/nok/onedollar-unistroke-recognizer",
+  "categories": ["Utilities"],
+  "sentence": "Implementación del [ Reconocedor de Gestos $1 ](http://depts.washington.edu/aimgroup/proj/dollar/), un reconocedor de gestos basado en una plantilla bidimensional.",
+  "paragraph": "",
+  "id": "069",
+  "type": "library",
+  "packages": [
+    {
+      "mode": "java",
+      "minRevision": "215",
+      "maxRevision": "0",
+      "props": "https://raw.githubusercontent.com/nok/onedollar-unistroke-recognizer/master/download/OneDollarUnistrokeRecognizer.txt",
+      "download": "https://raw.githubusercontent.com/nok/onedollar-unistroke-recognizer/master/download/OneDollarUnistrokeRecognizer.zip"
+    }
+  ]
+}

content/contributions/(Weka4P)_Weka_Machine_Learning_for_Processing.es.json

@@ -0,0 +1,23 @@
+{
+  "name": "(Weka4P) Weka Aprendizaje de Máquina para Processing",
+  "authors": [
+    "[Rong-Hao Liang](r.liang@tue.nl), [Wesley Hartogs](https://wesleyhartogs.nl), [Janet Huang](Y.C.Huang@tue.nl)"
+  ],
+  "url": "https://ronghaoliang.page/Weka4P/",
+  "categories": [
+    "Data"
+  ],
+  "sentence": "Implementación de la biblioteca de Código Abierto Weka para Aprendizaje de Máquina paraProcessing 3.",
+  "paragraph": "Entrena y carga modelos para traer el Aprendizaje de Máquina (por ejemplo: clasificación y regresión) a tus proyectos de Processing.",
+  "id": "270",
+  "type": "library",
+  "packages": [
+    {
+      "mode": "java",
+      "minRevision": "0",
+      "maxRevision": "0",
+      "props": "https://ronghaoliang.page/Weka4P/download/Weka4P.txt",
+      "download": "https://ronghaoliang.page/Weka4P/download/Weka4P.zip"
+    }
+  ]
+}

content/contributions/AI_for_2D_Games.es.json

@@ -0,0 +1,23 @@
+{
+  "name": "IA para juegos 2D",
+  "authors": [
+    "[Peter Lager](http://www.lagers.org.uk)"
+  ],
+  "url": "http://www.lagers.org.uk/ai4g/index.html",
+  "categories": [
+    "Simulation"
+  ],
+  "sentence": "Un framework que puede ser usado para juegos 2D y simulaciones.",
+  "paragraph": "Este proyecto soporta la creación de sketches que requieren agentes autónomos manejados por estados. Todo esta aquí para que empieces, incluyendo muchos ejemplos demostrando las características de la biblioteca. El [sitio web] (http://www.lagers.org.uk/ai4g/index.html) tiene muchos artículos y ejemplos de programas explicando esta sofisticada biblioteca.",
+  "id": "127",
+  "type": "library",
+  "packages": [
+    {
+      "mode": "java",
+      "minRevision": "0227",
+      "maxRevision": "0",
+      "props": "http://www.lagers.org.uk/processing/ai4g/AI_for_2D_Games.txt",
+      "download": "http://www.lagers.org.uk/processing/ai4g/AI_for_2D_Games.zip"
+    }
+  ]
+}

content/contributions/Apple_Light_Sensor.es.json

@@ -0,0 +1,23 @@
+{
+  "name": "Apple Light Sensor",
+  "authors": [
+    "[Martin Raedlinger](http://www.formatlos.de/)"
+  ],
+  "url": "http://projects.formatlos.de/ambientlightsensor/",
+  "categories": [
+    "Hardware"
+  ],
+  "sentence": "Interfaz para el sensor de luz en computadoras MacBook Pro.",
+  "paragraph": "",
+  "id": "028",
+  "type": "library",
+  "packages": [
+    {
+      "mode": "java",
+      "minRevision": "0",
+      "maxRevision": "228",
+      "props": "http://projects.formatlos.de/ambientlightsensor/download/AmbientLightSensor.txt",
+      "download": "http://projects.formatlos.de/ambientlightsensor/download/AmbientLightSensor.zip"
+    }
+  ]
+}

content/contributions/Getting_Started.es.json

@@ -0,0 +1,21 @@
+{
+  "name": "Primeros Pasos",
+  "authors": [
+    "[Jae Hyun](http://www.github.com/jaewhyun)"
+  ],
+  "url": "http://www.github.com/jaewhyun/GettingStarted",
+  "categories": null,
+  "sentence": "Una Herramienta que provee una rápida introducción al Entorno de Desarrollo Processing (PDE) para usuarios nuevos o principiantes.",
+  "paragraph": "",
+  "id": "233",
+  "type": "tool",
+  "packages": [
+    {
+      "mode": "java",
+      "minRevision": "228",
+      "maxRevision": "0",
+      "props": "https://github.com/jaewhyun/GettingStarted/releases/download/latest/GettingStarted.txt",
+      "download": "https://github.com/jaewhyun/GettingStarted/releases/download/latest/GettingStarted.zip"
+    }
+  ]
+}

content/contributions/Git_Manager.es.json

@@ -0,0 +1,22 @@
+{
+  "name": "Administrador Git",
+  "authors": [
+    "[Joel Moniz](http://joelmoniz.com)"
+  ],
+  "url": "http://joelmoniz.com/git-manager",
+  "categories": null,
+  "sentence": "Un cliente gráfico de GIT para Processing",
+  "paragraph": "Una herramienta que actúa como una interfaz completa y conveniente para usuarios de varios servicios de almacenamiento de repositorios GIT, y que integra todas las ventajas del control de versiones con Processing.",
+  "lastUpdated": "1443010051000",
+  "id": "160",
+  "type": "tool",
+  "packages": [
+    {
+      "mode": "java",
+      "minRevision": "0242",
+      "maxRevision": "0",
+      "props": "https://github.com/joelmoniz/Git-Manager/releases/download/latest/GitManager.txt",
+      "download": "https://github.com/joelmoniz/Git-Manager/releases/download/latest/GitManager.zip"
+    }
+  ]
+}

content/examples/Basics/Arrays/Array/Array.es.json

@@ -0,0 +1,9 @@
+{
+  "name": "Arreglo",
+  "title": "Arreglo",
+  "author": "",
+  "level": "Beginner",
+  "order": "0",
+  "description": "Un arreglo es una lista de datos. Cada uno de los datos en un arreglo \n  es identificado por un numero de índice representando su posición en \n el arreglo. Los arreglos empiezan desde el índice 0, lo  que significa que el primer \n  elemento en el arreglo es [0], es segundo elemento es [1], y asi subsecuentemente . \n  En este ejemplo, un arreglo llamado \"coswave\" es creado y \n llenado con valores de coseno. Estos datos son desplegados en 3 \n distintas formas en la pantalla.",
+  "featured": ["Array", "cos_"]
+}

content/examples/Basics/Arrays/Array/Array.es.pde

@@ -0,0 +1,51 @@
+/**
+ * Arreglo.
+ *
+ * Un arreglo es una lista de datos. Cada elemento en la lista es
+ * identificado por un número de índice, el cual representa su
+ * posición en el arreglo. Los arreglos son basados en cero, lo que
+ * significa que el primer elemento del arreglo es [0], el segundo
+ * elemento es [1], y así sucesivamente.
+ * En este ejemplo, un arreglo llamado "coswave" es creado y
+ * llenado con valores de coseno. Estos datos son desplegados en 3
+ * distintas formas en la pantalla.
+ */
+
+
+float[] coswave;
+
+void setup() {
+  size(640, 360);
+  coswave = new float[width];
+  for (int i = 0; i < width; i++) {
+    float amount = map(i, 0, width, 0, PI);
+    coswave[i] = abs(cos(amount));
+  }
+  background(255);
+  noLoop();
+}
+
+void draw() {
+
+  int y1 = 0;
+  int y2 = height/3;
+  for (int i = 0; i < width; i++) {
+    stroke(coswave[i]*255);
+    line(i, y1, i, y2);
+  }
+
+  y1 = y2;
+  y2 = y1 + y1;
+  for (int i = 0; i < width; i++) {
+    stroke(coswave[i]*255 / 4);
+    line(i, y1, i, y2);
+  }
+
+  y1 = y2;
+  y2 = height;
+  for (int i = 0; i < width; i++) {
+    stroke(255 - coswave[i]*255);
+    line(i, y1, i, y2);
+  }
+
+}

content/examples/Basics/Arrays/Array2D/Array2D.es.json

@@ -0,0 +1,9 @@
+{
+  "name": "Arreglos 2D",
+  "title": "Arreglos 2D",
+  "author": "",
+  "level": "Intermedio",
+  "order": "1",
+  "description": "Demuestra la sintaxis para crear un arreglo bidimensional (2D).\n Valores en un arreglo bidimensional son accesados usando dos valores de índices.\n Los arreglos bidimensionales son útiles para almacenar imágenes. En este ejemplo cada punto \n  esta coloreado en relación a su distancia desde el centro de la imagen.",
+  "featured": ["Array", "dist_"]
+}

content/examples/Basics/Arrays/Array2D/Array2D.es.pde

@@ -0,0 +1,41 @@
+/**
+ * Arreglo 2D.
+ *
+ * Demuestra la sintaxis para crear un arreglo bidimensional (2D).
+ * Valores en un arreglo bidimensional son accesados usando dos valores de índices.
+ * Los arreglos bidimensionales son útiles para almacenar imágenes. En este ejemplo cada punto
+ * esta coloreado en relación a su distancia desde el centro de la imagen.
+ */
+
+float[][] distances;
+float maxDistance;
+int spacer;
+
+void setup() {
+  size(640, 360);
+  maxDistance = dist(width/2, height/2, width, height);
+  distances = new float[width][height];
+  for (int y = 0; y < height; y++) {
+    for (int x = 0; x < width; x++) {
+      float distance = dist(width/2, height/2, x, y);
+      distances[x][y] = distance/maxDistance * 255;
+    }
+  }
+  spacer = 10;
+  strokeWeight(6);
+  noLoop();  // Se ejecuta una vez y para.
+}
+
+void draw() {
+  background(0);
+  // este ciclo brinca sobre los valores en los arreglos basados en la variable, hay más valores
+  // en el arreglo que los dibujados aquí
+  // Cambia el valor de la variable spacer para
+  // cambiar la densidad de los pixeles
+  for (int y = 0; y < height; y += spacer) {
+    for (int x = 0; x < width; x += spacer) {
+      stroke(distances[x][y]);
+      point(x + spacer/2, y + spacer/2);
+    }
+  }
+}

content/examples/Basics/Arrays/ArrayObjects/ArrayObjects.es.json

@@ -0,0 +1,9 @@
+{
+  "name": "Arreglo de Objetos",
+  "title": "Arreglo de Objetos",
+  "author": "",
+  "level": "Avanzado",
+  "order": "2",
+  "description": "Demuestra la sintaxis para crear un arreglo de objetos.",
+  "featured": ["Array", "Object"]
+}

content/examples/Basics/Arrays/ArrayObjects/ArrayObjects.es.pde

@@ -0,0 +1,33 @@
+/**
+ * Arreglo de Objetos
+ *
+ * Demuestra la sintaxis para crear un arreglo de objetos.
+ */
+
+int unit = 40;
+int count;
+Module[] mods;
+
+void setup() {
+  size(640, 360);
+  noStroke();
+  int wideCount = width / unit;
+  int highCount = height / unit;
+  count = wideCount * highCount;
+  mods = new Module[count];
+
+  int index = 0;
+  for (int y = 0; y < highCount; y++) {
+    for (int x = 0; x < wideCount; x++) {
+      mods[index++] = new Module(x*unit, y*unit, unit/2, unit/2, random(0.05, 0.8), unit);
+    }
+  }
+}
+
+void draw() {
+  background(0);
+  for (Module mod : mods) {
+    mod.update();
+    mod.display();
+  }
+}

content/examples/Basics/Camera/Orthographic/Orthographic.es.json

@@ -0,0 +1,9 @@
+{
+  "name": "Ortográfica",
+  "title": "Perspectiva vs Ortográfica",
+  "author": "",
+  "level": "Intermedio",
+  "order": "2",
+  "description": "Mueve el mouse de izquierda a derecha para cambiar el parámetro \"far\" \n  de las funciones perspective() y ortho().\n Este parámetro fija la distancia máxima desde el origen \n al espectador y cortará la geometría.\n Haz click en un botón del mouse para alternar entre proyecciones\n en perspectiva y ortográfica.",
+  "featured": ["ortho_", "perspective_"]
+}