La IA generativa requiere muchos recursos y un equipo potente. Necesitas comprar tarjetas Nvidia para poder ejecutar con éxito Stable Diffusion u otro modelo. Si eres como yo, puedes buscar soluciones accesibles como AWS. En este tutorial, te voy a mostrar cómo instalar ComfyUI + Flux para generar imágenes increíbles en Ubuntu.

Lo primero que necesitas hacer es iniciar sesión en la consola de Amazon AWS. En la barra de búsqueda superior, escribe 

 y selecciona la primera opción en los resultados. Verás algo como esto:

A continuación, debes hacer clic en el botón naranja 

 para configurar el hardware que necesitamos para ejecutar Flux y generar imágenes.

Completa el formulario con los siguientes valores:

: Selecciona una clave existente o crea una nueva, asegúrate de guardar la nueva clave en un lugar seguro, ya que la usaremos más tarde para conectarnos a la instancia.

Todos los demás valores pueden configurarse con los valores predeterminados. Una vez que termines, haz clic en el botón amarillento 

Después de recibir un mensaje de éxito, vuelve a la lista de instancias, haz clic en la nueva instancia y verás la 

 en la columna central. Copia esta IP ya que la utilizaremos para conectarnos vía SSH.

Abre tu terminal favorita o un cliente SSH y conéctate a la instancia que acabamos de crear. Podemos hacerlo ejecutando el siguiente comando.

$ ssh -i ~/.ssh/[YOUR-KEY-FILE-NAME].cer ubuntu@[YOUR-API_ADDRESS]

Asegúrate de establecer el certificado correcto, de lo contrario, no te autenticarás correctamente. Después de iniciar sesión, deberíamos actualizar nuestro sistema ejecutando los siguientes comandos:

A continuación, necesitamos instalar el controlador NVidia para poder usar las GPUs. He probado otras AMIs que incluían los drivers y todo estaba instalado, pero hubo varios errores al instalar los modelos. Me di cuenta que es más fácil instalar manualmente los controladores y todo lo que necesitamos; toma un poco más de tiempo, pero menos errores. Simplemente ejecuta el siguiente comando:

Luego necesitamos Python, primero debemos agregar el repositorio donde se encuentra la distribución oficial y luego instalar el paquete usando apt:

$ sudo add-apt-repository ppa:deadsnakes/ppa
$ sudo apt install python3.10

Es importante establecer el Python predeterminado al ejecutar comandos 

 en la terminal, así que vamos a crear el alias a continuación:

$ sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.10 2

Para verificar si todo está instalado, podemos imprimir la versión de Python:

AUTOMATIC1111 requiere ejecutar entornos virtuales, por lo tanto, necesitamos instalar 

¡Hemos terminado con las dependecias! Todo lo que necesitamos hacer es reiniciar la instancia y deberíamos poder usar las GPUs NVidia para ejecutar los modelos. Abre la consola de AWS, selecciona la instancia y haz clic en la opción 

Vuelve a iniciar sesión en tu instancia y clona el repositorio de stable diffusion web ui.

$ git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui

 para habilitar la conexión a A1111 desde cualquier computadora, usar el flash attention más rápido cuando utilices modelos y permitir que instalar extensiones cuando te conectes de forma remota.

$ cd stable-diffusion-webui
$ vim nano webui-user.sh

En este archivo, necesitamos encontrar la línea donde se define 

, descomentar la línea y establecer el siguiente valor.

export COMMANDLINE_ARGS="--listen --opt-sdp-attention --enable-insecure-extension-access"

El último paso es instalar y ejecutar A1111, lo hacemos ejecutando el siguiente comando:

, ahora necesitamos abrir ese puerto en nuestra instancia para poder abrirlo en nuestro navegador.

Ve a la consola de AWS y haz clic en la instancia, luego en la pestaña 

. Esto evitará que otras personas usen tus modelos. Si tu IP cambia, tendrás que volver aquí y nuevamente agregar tu nueva IP.

Después de guardar, deberías poder abrir A1111 en tu navegador favorito. Simplemente escribe la IP de tu instancia seguida del puerto, por ejemplo: 

Si todo salió bien, deberías poder ver la consola de A1111. ¡Adelante y pruébalo! Deberías ver algo como esto:

Como puedes ver, las imágenes generadas no se ven muy bien. ¡Necesitamos instalar Flux! Pero antes de eso, vamos a instalar ConfyUI, una herramienta con una mejor interfaz que crea flujos para generar imágenes.

Vuelve a la carpeta de inicio y clona el proyecto ComfyUI desde GitHub.

$ cd ~
$ git clone https://github.com/comfyanonymous/ComfyUI

Ahora vamos a compartir modelos con A1111 duplicando el archivo 

 y estableciendo la ruta a los modelos en A1111. Esto lo hacemos para no descargar los modelos dos veces, es mejor tenerlos compartidos y así ahorramos espacio en el disco duro.

$ cd ComfyUI
$ cp extra_model_paths.yaml.example extra_model_paths.yaml
$ vim extra_model_paths.yaml

Dentro de este archivo, necesitamos localizar la línea donde se define el 

base_path: /home/ubuntu/stable-diffusion-webui

Finalmente, ejecuta ComfyUI con este comando:

Instalar ComfyUI para generar imágenes con Flux

Hace un par de semanas actualicé el diseño de este sitio, decidí usar Next.JS para generar todos los archivos HTML y CSS de manera estática, para luego ponerlos en GitHub pages. Todo mi contenido ahora está en Notion y soy muy feliz escribiendo.

En este tutorial te voy a mostrar como automatizar el deployment, la idea es usar GH Actions para hacer el build y correr los scripts que sacan la información de Notion. Tuve algunos problemas que me gustaría documentar por si le sirven a alguien más.

Lo primero es crear un archivo para el nuevo workflow en tu repositorio, este archivo lo vas a crear dentro del directorio  

, si este directorio no existe lo puedes crear. Puedes nombrar el archivo como 

Dentro de este archivo vas a definir tres secciones, el nombre (

) del workflow, el evento que lo inicializa (

Aquí está la configuración que yo he usado para mi proyecto. Es importante mencionar que los pasos van a variar dependiendo de cada proyecto.

name: Deploy to GitHub Pages
on:
  push:
    branches:
      - main
jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2
      - name: Set up Node.js
        uses: actions/setup-node@v2
        with:
          node-version: '14.x'
      - name: Install dependencies
        run: npm install

La configuración anterior define un job llamado 

 que se ejecuta en una máquina Ubuntu con la última versión disponible.

Los pasos definidos son secuenciales y lo primero que hace es descargar el código de GitHub haciendo un checkout con git. Luego instala Node.js con la versión indicada, en este caso la versión 14. Por último instala las dependencias del proyecto.

Como ya mencioné antes, toda mi información de este blog está en Notion, por lo tanto cree dos scripts que se conectan al API Rest de Notion y descargan todos los posts publicados, también van descargando las imágenes asociadas a cada post y generando thumbnails para los posts.

Antes de generar el sitio estático con Next.js, necesito descargar la información y guardarla en archivos JSON que voy a usar en el build, para eso simplemente agrego los dos scripts al job que se definió en el paso anterior.

name: Deploy to GitHub Pages
on:
  push:
    branches:
      - main
jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2
      - name: Set up Node.js
        uses: actions/setup-node@v2
        with:
          node-version: '14.x'
      - name: Install dependencies
        run: npm install
      - name: Download posts
        run: npm run blog
      - name: Download projects
        run: npm run projects

He definido estos scripts dentro del archivo 

 en mi proyecto, por lo tanto puedo usar 

Una vez que ya tengo toda la información en archivos JSON y las imágenes descargadas a la máquina Ubuntu donde estoy haciendo el build, ya puedo pasar al siguiente paso que es generar todos los archivos  HTML y CSS.

name: Deploy to GitHub Pages
on:
  push:
    branches:
      - main
jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2
      - name: Set up Node.js
        uses: actions/setup-node@v2
        with:
          node-version: '14.x'
      - name: Install dependencies
        run: npm install
      - name: Download posts
        run: npm run blog
      - name: Download projects
        run: npm run projects
      - name: Build
        run: npm run build
      - name: Export
        run: npm run export

Next.JS provee dos comandos para generar sitios estáticos, 

. Así que simplemente agrego estos dos pasos al job y listo.

El último paso es deployar el build a GitHub pages, lo único que tenemos que hacer es agregar este paso a la lista de jobs.

name: Deploy to GitHub Pages
on:
  push:
    branches:
      - main
jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2
      - name: Set up Node.js
        uses: actions/setup-node@v2
        with:
          node-version: '14.x'
      - name: Install dependencies
        run: npm install
      - name: Download posts
        run: npm run blog
      - name: Download projects
        run: npm run projects
      - name: Build
        run: npm run build
      - name: Export
        run: npm run export
      - name: Deploy to GitHub Pages
        uses: peaceiris/actions-gh-pages@v3
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          publish_dir: ./out

nos permite acceder al build, generar un nuevo commit y hacer un push al 

 branch, esto hará que el sitio sea actualizado.

Para poder hacer push, es necesario que le demos el token de github, esta es la llave del repositorio y se puede acceder mediante la variable de entorno 

Otra cosa a considerar en esta configuración es el 

, aquí tenemos que indicarle el directorio dónde está el build, en este caso Next.js pone todos los archivos generados dentro del folder 

Dentro del código fuente, accedo a algunas variables de entorno, ahí tengo el Secret Key para el API de Notion, el número de posts por página y otras cosas más.

Las llaves de Notion no las quiero agregar al repositorio, por lo tanto debo usar variables de ambiente. GitHub te provee una manera de definir environments, cada uno puede tener diferentes valores, por ejemplo, podrías tener uno para 

. En mi caso no requiero tener varios ambientes, así que solo voy a definir uno que se llama 

 de tu repositorio, podrás manejar estos ambientes. Una vez que crees tu ambiente, asegúrate de darle acceso al branch 

 para que se puedan usar estos valores en el build.

Aquí puedes definir todos tus llaves secretas en la sección 

, con esto estamos listos para usar estas llaves en nuestro workflow.

Una vez que has definido tus valores secretos, queda solamente agregarlos a la configuración, aquí vamos a usar la propiedad 

 para indicarle el nombre del ambiente que acabamos de crear con nuestros valores secretos.

Con esto el script podrá acceder a estas variables de entorno, pero estas variables realmente las necesitamos en el código fuente, por lo tanto debemos agregarlas al ambiente del build. Para esto usamos la propiedad 

, aquí podemos acceder a los valores secretos y también definir valores de configuración para nuestros proyecto, por ejemplo aquí puse el número de posts por página, información que no es secreta.

El script final quedaría de la siguiente manera.

name: Deploy to GitHub Pages
on:
  push:
    branches:
      - main
jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    environment: github-pages
    env:
      NOTION_PK: ${{ secrets.NOTION_PK }}
      NOTION_DB_ID: ${{ secrets.NOTION_DB_ID }}
      NEXT_PUBLIC_GA_MEASUREMENT_ID: "UA-12345-1"
      POST_PER_PAGE: "6"
    steps:
      - name: Checkout code
        uses: actions/checkout@v2
      - name: Set up Node.js
        uses: actions/setup-node@v2
        with:
          node-version: '16.x'
      - name: Install dependencies
        run: npm install
      - name: Blog Data
        run: npm run blog
      - name: Projects Data
        run: npm run projects
      - name: Build
        run: npm run build
      - name: Export
        run: npm run export
      - name: Deploy to GitHub Pages
        uses: peaceiris/actions-gh-pages@v3
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          publish_dir: ./out

¡Eso es todo! Cada vez que hagas un push al repositorio o merge a un PR al branch main, la acción se ejecutará de manera automática, haciendo que tu flujo de trabajo sea mucho más efectivo y automatizado.

, te recomiendo el curso de mi amigo Armando, es un curso bastante completo donde vas a aprender cosas como integrar Stripe para recibir pagos, autenticación y manejo de sesiones, acceso a base de datos y muchas cosas más, en verdad que te lo recomiendo mucho.

Puedes usar mi cupón para tener un 20% de descuento en la compra del curso: 

también puedes dar click en el siguiente link: 

Como automatizar el deployment de Next.JS en Github Pages 

Comencé a usar Notion hace casi un año (en el 2021) para manejar mi contenido de Youtube, me ha gustado mucho el producto y la manera tan sencilla de organizar mis ideas, scripts, diario personal, etc. Así que decidí usarlo también para mi blog personal.

Uno de los retos fue lograr mostrar la información de Notion a mi página web, pero afortunadamente Notion cuenta con una API Rest que te da acceso a todo el contenido que tengas. En este tutorial voy a mostrar los pasos necesarios para que tú también puedas hacerlo si gustas.

Durante años mi blog ha sido un Wordpress sencillo, así que ya tenía varios posts publicados y era necesario traerlos a Notion, lo cual no fue del todo sencillo porque lo intenté de varias maneras sin tener éxito. 

Afortunadamente encontré un plugin para Wordpress que se llama 

. Este plugin nos permite exportar todos nuestros posts en formato CSV dando click a un botón. 

Una vez que descargué mi contenido a mi local, importarlo en Notion es bastante sencillo. Solo basta ir a la colección donde lo quieres importar y dar click sobre la opción 

 que se encuentra en el menu superior derecho, se abre una ventana modal donde vienen varias opciones, entre ellas la opción de CSV.

Algunos posts que importé tenían imágenes o porciones de código, el plugin exportador solamente me generó el CVS con HTML en el campo de contenido, por lo tanto algunos posts no se veían del todo bien. Una de las características de Notion es que permite usar markdown, así que usé una herramienta para convertir 

Sólo tenía unos pocos posts, de tener cientos habría automatizado el proceso, muy probablemente haciendo un script y usando el API de Notion para insertar cada registro.

Una vez listo el contenido ¡es hora de comenzar a programar! Para este proyecto decidí usar 

En primer lugar porque quería aprender a usar este framework. 

Está basado en React, así que no tenía que aprender esa parte.

Permite generar sitios estáticos que se pueden deployar a Github Pages, esto es importante para el SEO, además de que no quería mantener un servidor web.

Es bastante popular y con buena documentación, importante para cuando es necesario buscar ayuda.

. Ya he usado Gatsby, pero la verdad es que no tenía claro como integrar el API de Notion con GraphQL, además de que mis ganas por aprender Nextjs fueron más. 

AstroJS se ve bastante interesante, pero adicionalmente a aprender el framework, no usa React, así que tenía que aprender su propia manera de hacer componentes, y la verdad es que tampoco le quería dedicar mucho tiempo a este proyecto.

Iniciarte con NextJS es bastante sencillo, yo decidí usar Typescript y solamente tuve que 

Siempre que es mi decisión, decido usar Tailwind CSS para la parte de los estilos. 

 es bastante sencillo, solo me bastó con seguir la documentación y en cuestión de minutos tenía Tailwind funcionando correctamente.

Lo siguiente es sacar la información de Notion usando el API disponible, para esto es necesario 

 en tu cuenta de Notion. Yo le di acceso de solo lectura porque no voy a escribir nada, esta integración es para mi blog. Una vez que creaste la integración te van a dar un Secret Key, este lo vas a usar en todos tus requests para autenticarte y acceder a tu información.

Una vez que tienes tu integración es necesario asignarla a una 

, Notion así les llama a las colecciones/folders que tienes para organizar tu información. Lo que tienes que hacer aquí es ir a la colección y en el menú superior derecho, hay una opción que se llama 

, en esta sección hay una opción que dice 

, te aparece un submenu con varias opciones, entre una de ellas estará la integración que creaste, selecciona esa y listo.

Por último necesitar el ID de la base de datos. Este lo vas a usar en cada request que hagas al API. La documentación no dice nada al respecto de cómo obtener este ID, yo estuve un buen rato buscándolo y jalándome los pelos. Pero lo puedes sacar de la URL de la colección, por ejemplo, la URL de la colección de mi blog es la siguiente:

https://www.notion.so/crysfel/4b751e1cdfe1471b97912bceee115156?v=38bb03c48f0a42c79b8c84ea4a7c2800

. Ese es el ID que vamos a necesitar más adelante para sacar todos los artículos publicados.

Ya que tenemos el Secret Key y el Database ID, estamos listos para comenzar a llamar el API. Te recomiendo usar Postman para probar que tus peticiones funcionen bien.

En cada post, he creado una propiedad llamada 

, esta propiedad tiene varios valores, por ejemplo: Idea, Draft, Review y Publish. Tengo un lindo board donde voy moviendo las tarjetas en entre estas columnas.

Ahora bien, quiero leer solamente aquellos posts que estén con 

. Además los quiere ordenados por lo últimos que he publicado.

Aquí tuve un problema porque la documentación de Notion no es muy clara, tiene varios endpoints pero no vi por ningún lado como sacar justo la información que necesitaba, así que me puse a probar todos. Resulta que se debe usar 

, y tiene sentido una vez que sabes que Notion le llama database a las colección, pero en ese momento no lo sabía y si me tardé un buen rato.

Bueno, la petición para este ejemplo sería la siguiente.

POST https://api.notion.com/v1/databases/[DATABASE_ID]/query

Body Payload:
  {
    "page_size": 20,
    "filter": {
        "and": [
            {
                "property": "Status",
                "select": {
                    "equals": "publish"
                }
            },
            {
                "property": "Type",
                "select": {
                    "equals": "post"
                }
            }
        ]
    },
    "sorts": [
        {
            "property": "Date",
            "direction": "descending"
        }
    ]
}

Como se puede observar, se puede definir el número de posts que quieres traer por cada consulta, así como filtros. En mi caso tengo varios tipos de posts, proyectos, books, etc. Así que para el blog solamente quiere traer los de tipo 

No olvidar mandar el Secret Key en la cabecera 

 del request, también es necesario mandar el 

 como parte de los headers, de lo contrario vas a recibir un error. En la 

Esa petición trae todos los post con la mayoría de información, pero falta lo más importante, el contenido principal. Para traer el contenido tienes que hacer otra petición por cada post al siguiente endpoint.

GET https://api.notion.com/v1/blocks/[POST_ID]/children

. La respuesta de este endpoint será un JSON con todo el contenido, cada párrafo es un bloque que a su vez puede tener otros bloques, dependiendo como has formateado el contenido.

El siguiente problema que me encontré fue como hacer para guardar la información en local, ya que la voy a usar en varios lugares y además solo la voy a usar al momento de generar todos los HTML estáticos, ya que no voy a usar un servidor web con Node, todo será HTML y CSS para que mi sitio vuele.

Decidí hacer un script que consultara la API de notion, sacara toda la información y me guardara un archivo JSON en mi local, de esta manera al desarrollar solamente leería el archivo JSON desde Nextjs y listo, todo mi contenido estaría disponible y listo para ser usado.

El script es bastante sencillo, solo hace una petición inicial a Notion para traer todos los posts publicados, luego itero esa lista para hacer una petición individual por cada post y traer el contenido principal. 

Para hacer las peticiones a Notion se puede usar cualquier cliente HTTP, pero yo decidí usar el SDK de notion, así que instale el paquete 

. La petición petición inicial queda así:

const Notion = require('@notionhq/client')

const notion = new Notion.Client({ auth: process.env.NOTION_PK })

const response = await notion.databases.query({
    database_id: process.env.NOTION_DB_ID,
    page_size: PAGE_SIZE,
    filter: {
      and: [
        {
          property: 'Status',
          select: {
            equals: 'publish'
          }
        },
        {
          property: 'Type',
          select: {
            equals: 'post'
          }
        }
      ]
    },
    sorts: [
      {
        property: 'Date',
        direction: 'descending'
      }
    ]
  })

Una vez que responde y tengo todos los post disponibles, itero la lista y hago la siguiente petición por cada item, con esto me traigo el contenido principal de cada post.

const postResponse = await notion.blocks.children.list({
  block_id: node.id,
})

const post = {
  id: node.id,
  title: node.properties.Content.title[0].plain_text,
  content: postResponse.results,
  createdAt: node.created_time,
  publishedAt: node.properties.Date.date.start,
  slug: node.properties.Slug?.rich_text[0].plain_text || node.id,
  permalink: node.properties.Permalink.url,
  tags: node.properties.Tags.multi_select.map(tag => tag.name.toLowerCase()),
  image, // <--- TODO: Download this image!!
}

Y listo, ya tengo todo la información. Simplemente creo un nuevo arreglo de posts con los fields que necesito y guardo el JSON en un archivo de texto para poder usarlo después.

Otro de los problemas es que tengo definidas imágenes para cada post, esta imagen la selecciono directamente en Notion, ya sea subiendo una que yo tenga en mi disco duro o bien usando el widget de UnSplash.

Estas imágenes son privadas, y el API de Notion te regresa la URL donde están almacenadas en Amazon S3. Pero, al ser privadas expiran en 30 minutos, así que es necesario descargarlas para que las puedas mostrar desde el servidor donde vas a deployar este sitio, en mi caso Github Pages.

Descargar imágenes o archivos en Node, no es complicado, yo lo hice de la siguiente manera:

Como se puede observer descargo las imágenes en el folder público del proyecto, cuando se hace el build, todos los archivos en este folder serán parte del resultado final, así que es importante poner las imágenes aquí para que pueda ser servidas cuando se deploye este sitio a producción.

Otro problema que me encontré es que las imágenes que vienen de UnSplash estás muy grandes, esto hace que el sitio se ponga lento en la carga inicial. Para optimizar esto es necesario redimensionar las imágenes para crear versiones más pequeñas.

Para redimensionar las imágenes, decidí usar una librería llamada 

, es bastante rápido y las imágenes quedan con buena calidad.

Una vez las imágenes ya estaban descargadas y redimensionadas, simplemente guardé la URL correcta en el JSON que tengo en mi local.

const remoteImage = node.cover?.type === 'external'
	? node.cover?.external?.url 
	: node.cover?.file?.url

if (remoteImage) {
  const sizes = [
    { name: 'tiny', width: 10 },
    { name: 'tns', width: 500 },
    { name: 'large', width: 1200 },
  ];
  const imageName = `${node.id}.${getImageFormat(node)}`

  await downloadImage(remoteImage, imageName)
  await resizeImageToMultipleSizes(imageName, sizes)

  image = {
    original: `/images/original/${imageName}`,
    large: `/images/large/${imageName}`,
    tns: `/images/tns/${imageName}`,
    tiny: `/images/tiny/${imageName}`,
  }
}

const post = {
  id: node.id,
  title: node.properties.Content.title[0].plain_text,
  content: postResponse.results,
  createdAt: node.created_time,
  publishedAt: node.properties.Date.date.start,
  slug: node.properties.Slug?.rich_text[0].plain_text || node.id,
  permalink: node.properties.Permalink.url,
  tags: node.properties.Tags.multi_select.map(tag => tag.name.toLowerCase()),
  image,
}

¡Listo! Eso es toda la integración con Notion, ya tenemos en nuestro local los posts, así como las imágenes de cada uno.

Como migrar de Wordpress a Notion

Al día de hoy JavaScript es el lenguaje más importante de la web, si vamos a GitHub (la red social de los desarrolladores) veremos que JavaScript es el 

 en los proyectos Open Source, superando a Ruby, Python, Java, PHP, etc.

Actualmente existen muchos servicios en la web hechos con PHP, Ruby, Java, .Net, Python, etc. del lado del servidor, pero todos ellos coinciden al usar JavaScript para el lado de las interfaces, no importa la tecnología que esté por detras todos ellos usan JavaScript para hacer Ajax, agregar interacción y mejorar la experiencia del usuario. Existen muchas librarías para desarrollar aplicaciones web, siendo 

 la más popular de todas por su facilidad y rapides para hacer las cosas, en lo personal yo usaría jQuery para sitios webs, portales sencillos, cosas pequeñas y medianes, jQuery es genial manejando el DOM, existe una gran comunidad detras de la librería e infinidad de plugins, pero cuando se trata de una aplicación grande para prefiero 

 ya que contiene una mejor arquitectura y muchos componentes listos para usarse ni siquiera 

 u otros plugins se asemejan al poder y flexibilidad que tenemos con Ext JS.

 es un excelente proyecto para llevar JavaScript del lado del servidor, tiene una excelente integración con WebSockets para lograr una comunicación permanente con el cliente y poder hacer "push" con información al cliente. Existen varios projectos como 

 que es un framework semejante a Sinatra para desarrollar aplicaciones de una manera ordenada y sencilla, Node.js utiliza el motor de Google Chrome llamado V8 para ejecutar y compilar el código JavaScript directamente en el servidor. Un proyecto muy prometedor y que vale la pena seguir de cerca.

El desarrollo para dispositivos móviles también es algo que ha evolucionado mucho, hoy en día existen herramientas que nos permiten desarrollar aplicaciones para móviles usando JavaScript, una de las ventajas de esto es que podemos escribirlas en JavaScript y compilarlas para diferentes plataformas usando Titanium por ejemplo o bien usar algún "wraper" como PhoneGap y desarrollar con 

. Ahora bien, varias personas me han llegado a preguntar si usar jQuery Mobile o Sencha Touch en sus proyectos, mi respuesta es simple, si quieres hacer algo sencillo como un sitio web o una app simple usa jQtouch, por el contrario si deseas hacer algo más completo y robusto utiliza Sencha Touch que esta pensado para aplicaciones más grandes.

Hay varios experimentos y pruebas de conceptos alrededor de JavaScript, uno de los últimos experimentos que me llamo mucho la atención fue una 

Java Virtual Machine corriendo en JavaScript

, aseguran que corre un 60% del bytecode! es algo realmente alucinante, no tengo palabras para expresar el asombro. También he visto otro experimento para 

 directamente desde JavaScript sin necesidad de plugins de terceros, suena muy interesante este proyecto. 

 es otro experimento muy interesante, permite interpretar texto por voz usando JavaScript y HTML5.

JavaScript era un lenguaje menospreciado hace algunos años, pero hoy en día es el más importante en la web y viene con mucha fuerza para los dispositivos móviles y el servidor, hoy es el momento ideal para subirse al barco y aprender estas tecnologías, esto apenas inicia así que no pierdas más el tiempo y 

El Blog

Últimas publicaciones

Instalar ComfyUI para generar imágenes con Flux

Como automatizar el deployment de Next.JS en Github Pages

Como migrar de Wordpress a Notion

Hoy es el momento ideal para aprender JavaScript

Conecta conmigo!

Tags

Te ayudo a mejorar al entrevistar, únete a mi lista de correo.

También estoy en Youtube