[CONTENT] Agregando el contenido de la introduccion

components/NodeCard.vue

@@ -4,6 +4,12 @@
   import { Handle, Position } from '@vue-flow/core'
 
   const ignoreTypes = ["topics", "transparent"]
+  const positions = {
+      top: Position.Top,
+      left: Position.Left,
+      right: Position.Right,
+      bottom: Position.Bottom,
+  }
 
   const props = defineProps({
     data: Object,
@@ -32,24 +38,26 @@
     console.log(node)
   })
 
-  const checkSourceHandle = (ty) => {
-    return Object.values(props.data.sourcePosition || {}).includes(ty)
-  }
-  const checkTargetHandle = (ty) => {
-    return Object.values(props.data.targetPosition || {}).includes(ty)
+  const generateStyle = (handle, index) => {
+    return { [handle]: `${index * 10}px` }
   }
 </script>
 
 <template>
-  <Handle v-if="checkSourceHandle('right')" type="source" :position="Position.Right"  />
-  <Handle v-if="checkSourceHandle('top')" type="source" :position="Position.Top"  />
-  <Handle v-if="checkSourceHandle('left')" type="source" :position="Position.Left" />
-  <Handle v-if="checkSourceHandle('bottom')" type="source" :position="Position.Bottom"/>
-
-  <Handle v-if="checkTargetHandle('right')" type="target" :position="Position.Right" />
-  <Handle v-if="checkTargetHandle('top')" type="target" :position="Position.Top" />
-  <Handle v-if="checkTargetHandle('left')" type="target" :position="Position.Left" />
-  <Handle v-if="checkTargetHandle('bottom')" type="target" :position="Position.Bottom" />
+  <Handle
+    v-for="(handle, index) in Object.values(props.data.sourcePosition || {})"
+    :position="positions[handle]"
+    :key="`source-${index}-${handle}`"
+    :id="`source-${index}-${handle}`"
+    type="source"
+    />
+  <Handle
+    v-for="(handle, index) in Object.values(props.data.targetPosition || {})"
+    :position="positions[handle]"
+    :key="`target-${index}-${handle}`"
+    :id="`target-${index}-${handle}`"
+    type="target"
+    />
 
   {{ props.data.position }}
   <Card class="flex flex-row gap-x-2" :class="'topic-' + props.data.topicLevel" :moreTransparency="props.data.moreTransparency" :noInteractive="props.data.noInteractive">

content/1.introduction/0.index.md

@@ -0,0 +1,61 @@
+---
+title: 'Introducción a Rust'
+description: 'Introducción a Rust: El Lenguaje del Futuro en Programación de Sistemas'
+draft: true
+data:
+  type: 'custom'
+  topicLevel: 'start'
+  position:
+    x: 320
+    y: 100
+  sourcePosition:
+    rust: 'top'
+  targetPosition: 
+    basic: 'bottom'
+    why-rust: 'right'
+    rust-channels: 'right'
+    environment: 'right'
+  externalLinks:
+    - name: 'Web Oficial'
+      english: true
+      link: 'https://rust-lang.org'
+    - name: 'Hicimos el sitio web de nuestra boda en Angular y Rust'
+      english: false
+      link: 'https://blog.rustlang-es.org/articles/hicimos-el-sitio-web-de-nuestra-boda-en-angular-y-rust-pk8'
+---
+## Introducción a Rust: El Lenguaje del Futuro en Programación de Sistemas
+
+En el vasto universo de los lenguajes de programación, Rust ha emergido como una estrella en ascenso, atrayendo la atención de desarrolladores de todo el mundo por su enfoque único en la seguridad y el rendimiento. Rust no solo promete, sino que cumple con la difícil tarea de ofrecer un control de bajo nivel sin sacrificar la seguridad y la facilidad de uso. En este post, exploraremos qué hace que Rust sea tan especial y por qué deberías considerarlo para tus próximos proyectos.
+
+### ¿Qué es Rust?
+
+Rust es un lenguaje de programación de sistemas que fue desarrollado por Mozilla Research, con su primera versión estable lanzada en 2015. A diferencia de muchos lenguajes modernos que priorizan la productividad y la simplicidad en detrimento de la eficiencia y el control, Rust busca ofrecer lo mejor de ambos mundos. Está diseñado para ser seguro, concurrente y práctico, permitiendo a los desarrolladores escribir código de bajo nivel sin temor a errores comunes como los desbordamientos de búfer y las condiciones de carrera.
+
+### Características Clave de Rust
+
+1. **Seguridad de Memoria sin Recolección de Basura:**
+   Una de las características más distintivas de Rust es su enfoque en la seguridad de la memoria. A diferencia de otros lenguajes que utilizan un recolector de basura para gestionar la memoria, Rust emplea un sistema de propiedad y préstamo. Este sistema permite que el compilador gestione la memoria de manera segura y eficiente, previniendo errores comunes como los punteros colgantes y las fugas de memoria.
+
+2. **Control y Rendimiento:**
+   Rust proporciona un control de bajo nivel similar al de C y C++, permitiendo a los desarrolladores optimizar su código para un rendimiento máximo. Esto lo hace ideal para aplicaciones donde el rendimiento es crítico, como los motores de juegos, los sistemas embebidos y las aplicaciones de tiempo real.
+
+3. **Concurrencia sin Miedo:**
+   La concurrencia es uno de los aspectos más complejos y propensos a errores en la programación. Rust aborda este problema con su sistema de tipos y el análisis estático en tiempo de compilación, lo que ayuda a evitar las condiciones de carrera y otros errores de concurrencia. Su modelo de propiedad garantiza que dos hilos no puedan acceder al mismo recurso mutable simultáneamente, asegurando así una concurrencia segura.
+
+4. **Ecosistema y Herramientas:**
+   Rust cuenta con un ecosistema robusto y en constante crecimiento. Herramientas como Cargo, el gestor de paquetes y compilador de Rust, facilitan la gestión de dependencias y la compilación del código. Además, la comunidad de Rust es conocida por ser extremadamente acogedora y activa, lo que hace que aprender y resolver problemas sea más accesible.
+
+### ¿Por Qué Elegir Rust?
+
+1. **Proyectos Críticos de Alto Rendimiento:**
+   Si estás trabajando en proyectos donde el rendimiento y la eficiencia son cruciales, como sistemas operativos, navegadores web o motores de juegos, Rust es una excelente opción. Su capacidad para ofrecer un control de bajo nivel sin sacrificar la seguridad lo hace ideal para estos entornos exigentes.
+
+2. **Seguridad en Aplicaciones:**
+   Para aplicaciones donde la seguridad es una prioridad, Rust proporciona una base sólida para prevenir vulnerabilidades comunes. Su sistema de tipos riguroso y su énfasis en la seguridad de la memoria ayudan a evitar errores que pueden ser explotados en ataques de seguridad.
+
+3. **Desarrollo Moderno:**
+   Rust no solo se trata de rendimiento y seguridad; también está diseñado para ser agradable de usar. Su sintaxis moderna y expresiva, junto con herramientas avanzadas, hacen que el desarrollo sea más eficiente y menos propenso a errores.
+
+### Conclusión
+
+Rust está cambiando la forma en que pensamos sobre la programación de sistemas. Su capacidad para ofrecer seguridad y rendimiento sin compromisos lo convierte en una herramienta poderosa para los desarrolladores modernos. Si aún no has explorado Rust, ahora es el momento de sumergirte y descubrir cómo puede transformar tus proyectos. Con una comunidad en crecimiento y un ecosistema robusto, Rust está preparado para ser un pilar en el desarrollo de software del futuro.

content/1.introduction/1.why-rust.md

@@ -0,0 +1,96 @@
+---
+title: '¿Por Qué Rust?'
+description: '¿Por Qué Usar Rust Hoy en Día? Casos de Éxito que Demuestran su Potencial'
+draft: true
+data:
+  type: 'custom'
+  topicLevel: 'start'
+  position:
+    x: 620
+    y: 100
+  width: 320
+  sourcePosition:
+    introduction: 'left'
+  externalLinks:
+    - name: 'Web Oficial'
+      english: true
+      link: 'https://rust-lang.org'
+    - name: 'Un paseo por Rust'
+      english: false
+      link: 'https://blog.rustlang-es.org/articles/un-pequeno-paseo-por-rust-4lko'
+    - name: 'Herramientas integradas en Rust'
+      english: false
+      link: 'https://www.rust-lang.org/es/tools'
+---
+## ¿Por Qué Rust?
+
+En el competitivo mundo de la programación, elegir el lenguaje adecuado puede marcar una gran diferencia en la eficiencia, seguridad y escalabilidad de tus proyectos. Rust, un lenguaje relativamente nuevo, ha captado la atención de la comunidad de desarrolladores por su enfoque innovador en la seguridad y el rendimiento. A medida que más empresas e individuos adoptan Rust, los casos de éxito continúan demostrando su valor en aplicaciones del mundo real. En este post, exploraremos por qué deberías considerar usar Rust hoy en día y examinaremos algunos ejemplos notables de su éxito.
+
+### ¿Por Qué Elegir Rust?
+
+1. **Seguridad de Memoria:**
+    Rust es conocido por su enfoque en la seguridad de memoria, lo que ayuda a prevenir errores comunes como los desbordamientos de búfer, los punteros colgantes y las fugas de memoria. Este enfoque se logra a través de su sistema de propiedad y préstamo, que garantiza la seguridad en tiempo de compilación sin necesidad de un recolector de basura.
+
+2. **Rendimiento:**
+    Al ser un lenguaje de bajo nivel, Rust permite un control preciso sobre el hardware, lo que se traduce en un rendimiento cercano al de C y C++. Esto lo hace ideal para aplicaciones de alto rendimiento, como motores de juegos, sistemas embebidos y software de tiempo real.
+
+3. **Concurrencia Segura:**
+    La concurrencia es una de las características más difíciles de manejar en la programación. Rust aborda este desafío con su sistema de tipos y análisis estático, previniendo condiciones de carrera y asegurando que los programas concurrentes sean seguros y eficientes.
+
+4. **Ecosistema y Comunidad:**
+    Rust cuenta con un ecosistema robusto, con herramientas como Cargo, su gestor de paquetes y compilador, que facilita la gestión de dependencias y la compilación de proyectos. Además, la comunidad de Rust es conocida por ser acogedora y activa, proporcionando un entorno de aprendizaje colaborativo.
+
+Ademas Rust ofrece ventajas significativas en el proceso de desarrollo, respaldadas por sus herramientas, su compilador y sus características:
+
+1. **Compilador Robusto:**
+    El compilador de Rust es conocido por ser riguroso y detectar errores en tiempo de compilación. Esto significa que muchos errores comunes que suelen pasar desapercibidos hasta la ejecución se descubren de inmediato. Esto conduce a un desarrollo más rápido y menos errores en el código final.
+
+2. **Gestión de Memoria sin Problemas:**
+    Rust elimina la necesidad de lidiar con problemas de asignación y liberación de memoria manualmente, ya que utiliza su sistema de propriedad de memoria y sistema de préstamo de referencias, lo que disminuye la posibilidad de fugas de memoria y corrupciones de datos.
+
+3. **Ecosistema de Paquetes:**
+    Cargo, el sistema de gestión de paquetes de Rust, es fácil de usar y eficiente. Facilita la importación de bibliotecas y la gestión de dependencias de proyectos, lo que agiliza el desarrollo.
+
+4. **Concurrencia Segura:**
+    Rust ofrece facilidades para escribir código concurrente de manera segura a través de su sistema de hilos y canales (threads y channels) sin preocupaciones por problemas de carrera. Esto es vital para aplicaciones modernas que necesitan explotar la capacidad de las CPU multinúcleo.
+
+5. **Documentación en Línea Clara:**
+    La documentación en línea de Rust es de alta calidad y accesible. Esto facilita el aprendizaje del lenguaje y la resolución de problemas durante el desarrollo.
+
+6. **Testing Integrado:**
+    Rust incluye herramientas de prueba integradas, lo que facilita la escritura y ejecución de pruebas unitarias y de integración.
+
+7. **Compatibilidad con WebAssembly (Wasm):**
+    Rust es ampliamente utilizado en el desarrollo de aplicaciones web a través de WebAssembly, lo que permite la ejecución de código Rust en navegadores web.
+
+8. **Herramientas de Análisis Estático:**
+    Rust cuenta con herramientas de análisis estático como Clippy, que ayudan a identificar problemas de estilo y posibles errores en el código.
+
+9. **Facilidad de Refactorización:**
+    La concordancia de patrones y la tipificación fuerte hacen que la refactorización del código sea más segura y sencilla.
+
+10. **Seguridad y Mantenibilidad a Largo Plazo:**
+    El énfasis en la seguridad y la eliminación de errores comunes en tiempo de compilación contribuye a una mayor confiabilidad y mantenibilidad del código a lo largo del tiempo.
+
+### Casos de Éxito con Rust
+
+1. [**Mozilla y Servo:**](https://github.com/servo/servo)
+    Uno de los ejemplos más conocidos del uso de Rust es el navegador experimental Servo, desarrollado por Mozilla. Servo está diseñado para ser rápido, seguro y paralelizable, aprovechando al máximo las capacidades de Rust. El proyecto ha demostrado cómo Rust puede mejorar la seguridad y el rendimiento en aplicaciones de alto impacto como los navegadores web .
+
+2. [**Dropbox:**](https://dropbox.tech/application/why-we-built-a-custom-rust-library-for-capture)
+    Dropbox ha utilizado Rust para mejorar el rendimiento de su infraestructura. En particular, han reescrito partes críticas de su backend en Rust, logrando mejoras significativas en la eficiencia y la confiabilidad. Rust ha permitido a Dropbox manejar grandes volúmenes de datos con un alto grado de seguridad y rendimiento .
+
+3. [**Amazon Web Services (AWS):**](https://aws.amazon.com/es/blogs/opensource/sustainability-with-rust)
+    AWS ha adoptado Rust para varios de sus servicios, incluyendo el servicio de monitoreo de redes Firecracker, que es utilizado para lanzar microVMs. Rust proporciona la seguridad y el rendimiento necesarios para gestionar la infraestructura en la nube a gran escala de AWS, asegurando que los servicios sean rápidos y seguros  .
+
+4. [**Discord:**](https://discord.com/blog/why-discord-is-switching-from-go-to-rust)
+    La popular plataforma de comunicación Discord ha integrado Rust en sus sistemas backend para mejorar la velocidad y la eficiencia. Rust ha permitido a Discord manejar una gran cantidad de tráfico de manera eficiente, reduciendo la latencia y mejorando la experiencia del usuario final .
+
+5. [**Linux**](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=8aebac82933ff1a7c8eede18cab11e1115e2062b)
+    La integración de Rust en el kernel de Linux representa un cambio significativo en el desarrollo de uno de los sistemas operativos más fundamentales y ampliamente utilizados en el mundo. Este movimiento tiene profundas implicaciones para la seguridad, el rendimiento y la sostenibilidad del desarrollo del kernel. En este post, exploraremos las razones detrás de la adopción de Rust en Linux, cómo se está llevando a cabo esta integración y qué significa esto para el futuro del sistema operativo.
+
+### Conclusión
+
+Rust no es solo una moda pasajera; es un lenguaje que ofrece soluciones reales a problemas complejos en el desarrollo de software moderno. Su enfoque en la seguridad de la memoria, el rendimiento y la concurrencia segura lo convierte en una opción atractiva para una amplia gama de aplicaciones. Los casos de éxito de empresas como Mozilla, Dropbox, AWS y Discord son testimonios contundentes del potencial de Rust para transformar proyectos críticos. Si buscas un lenguaje que combine eficiencia, seguridad y modernidad, Rust es una opción que vale la pena explorar.
+
+Adoptar Rust hoy puede prepararte para enfrentar los desafíos del desarrollo de software del mañana, proporcionando una base sólida para construir aplicaciones robustas y de alto rendimiento. ¡Es el momento perfecto para empezar a explorar todo lo que Rust tiene para ofrecer!

content/1.introduction/2.rust-channels.md

@@ -0,0 +1,57 @@
+---
+title: 'Stable, Beta, Nightly. ¿Que es esto?'
+description: 'Stable, Beta, Nightly. Los canales de distribucion y versiones de Rust'
+draft: true
+data:
+  type: 'custom'
+  topicLevel: 'start'
+  position:
+    x: 620
+    y: 140
+  sourcePosition:
+    introduction: 'left'
+  externalLinks:
+    - name: 'Web Oficial'
+      english: true
+      link: 'https://rust-lang.org'
+    - name: 'Enlace de Referencia'
+      english: true
+      link: 'https://rust-lang.github.io/rustup/concepts/channels.html'
+---
+## Stable, Beta, Nightly. ¿Que es esto?
+
+Rust es conocido por su enfoque en la seguridad, el rendimiento y la confiabilidad, y parte de lo que hace a Rust tan robusto es su cuidadoso ciclo de lanzamiento. Para mantener el equilibrio entre la estabilidad y la innovación, Rust se distribuye a través de tres canales diferentes: Stable, Beta y Nightly. En este post, exploraremos qué significa cada uno de estos canales y cuándo deberías usarlos.
+
+### Canal Stable: Seguridad y Confiabilidad
+
+El canal Stable es la versión más importante de Rust para la mayoría de los desarrolladores. Como su nombre indica, las versiones en este canal son las más estables y han pasado por un riguroso proceso de prueba. Aquí están las características clave del canal Stable:
+
+- **Lanzamientos Regulares:** Las versiones estables de Rust se lanzan cada seis semanas, lo que proporciona un flujo constante de mejoras y correcciones de errores.
+- **Compatibilidad Garantizada:** El canal Stable garantiza la compatibilidad hacia atrás, lo que significa que el código que compila en una versión estable continuará compilando en versiones futuras.
+- **Seguridad y Confiabilidad:** Dado que estas versiones han sido exhaustivamente probadas, son ideales para proyectos de producción donde la estabilidad es crucial.
+
+**Cuándo usar Stable:** Siempre que estés trabajando en un proyecto de producción o necesites asegurarte de que tu código funcione de manera confiable y segura, debes usar el canal Stable.
+
+### Canal Beta: Probando lo Nuevo
+
+El canal Beta de Rust es una vista previa de lo que vendrá en la próxima versión estable. Esta versión se congela dos semanas antes del lanzamiento estable, y se centra en la corrección de errores y la estabilización de nuevas características.
+
+- **Vista Previa de Nuevas Características:** El canal Beta te permite probar las nuevas características que se incluirán en la próxima versión estable.
+- **Corrección de Errores:** Aunque es menos estable que el canal Stable, el canal Beta todavía es bastante fiable y se utiliza para encontrar y corregir errores antes del lanzamiento oficial.
+
+**Cuándo usar Beta:** Si quieres estar al tanto de las próximas características y contribuir a la detección de errores, usar el canal Beta es una excelente opción. Es ideal para pruebas y para preparar tu código para futuros lanzamientos estables.
+
+### Canal Nightly: Innovación y Experimentación
+
+El canal Nightly es la vanguardia del desarrollo de Rust. Las versiones Nightly se generan cada noche con las últimas características y correcciones de errores que aún no están listas para el canal Beta.
+
+- **Acceso a Características Experimentales:** El canal Nightly te da acceso a las características más nuevas y experimentales, incluyendo aquellas que aún están en fase de pruebas.
+- **Sin Garantías de Estabilidad:** Dado que estas versiones son las menos probadas, pueden contener errores y no se garantiza que sean estables.
+
+**Cuándo usar Nightly:** Si eres un desarrollador que quiere experimentar con las últimas innovaciones y no te importa lidiar con posibles inestabilidades, el canal Nightly es para ti. Es especialmente útil para contribuyentes de Rust y aquellos que necesitan características específicas que aún no están disponibles en los canales Beta o Stable.
+
+### Conclusión
+
+El sistema de canales de Rust permite a los desarrolladores elegir el equilibrio adecuado entre estabilidad e innovación para sus necesidades específicas. El canal Stable ofrece seguridad y confiabilidad para proyectos de producción, el canal Beta proporciona una vista previa de las próximas características, y el canal Nightly permite a los desarrolladores experimentar con las últimas novedades del lenguaje.
+
+Al comprender y utilizar estos canales de manera efectiva, puedes maximizar tu productividad y mantener tu códigobase actualizada y segura. ¡Elige el canal que mejor se adapte a tus necesidades y empieza a explorar todo lo que Rust tiene para ofrecer!

content/1.introduction/3.environment.yml

@@ -0,0 +1,11 @@
+title: 'Configura tu Entorno'
+description: ''
+data:
+  type: 'transparent'
+  topicLevel: 'start'
+  position:
+    x: 620
+    y: 200
+  width: 320
+  sourcePosition:
+    introduction: 'left'