Crea una cuenta o inicia sesión

¡Continúa aprendiendo sin ningún costo! Únete y comienza a potenciar tu carrera

Monohilo: implicaciones en diseño y seguridad

4/31
Recursos

Aportes 109

Preguntas 13

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

Me encanta cuando les salen errores a los profesores. Refleja muy bien el flujo de trabajo real. Y aun que hay quienes critican a los profesores por esto, yo creo que es genial que no editen esas partes de la clase. Creo que a la gente que apenas inicia le va a servir mucho darse cuenta que el flujo de trabajo es de esa manera y les ayudará a evitar sentirse frustrados y con sindreome de impostor. Ademas, sin querer aprendes como puedes resolver esos problemitas, como en ete caso con el

console.log('forzamos error');

para asegurarse de que el bloque del if se ejecuta.

Importante: Cuando ocurre un error dentro de alguno de los hilos y no se controla apropiadamente (catch); Node detiene todos los hilos ejecución. Esto puede ser muy peligroso, debido a que es dificil determinar fue el origen del problema y en que punto de ejecución se encontraba cada hilo cuando fue detenido.

RESUMEN :


El hecho de que sea monohilo lo hace delicado en el sentido de que puede ejecutarse algo que corte el código y detenga el programa, como la ausencia de sintaxis o una variable pendiente por definir.

Aquí se pueden ver los problemas de seguridad y los Updates en este tema. Muy interesante leerlo para entender cómo atacan y saltan el código y cómo lo resolvieron.

A continuación dejo el código escrito con algunos comentarios de utilidad:

console.log('Hola mundo');

// SetInterval me permtie ejecutar una función cada n cantidad de tiempo, por lo que quiere que recibe como argumentos: Función a ejecutarse, intervalo de tiempo.
//A tener  en cuenta esta función no se detiene y continúa su ejecución ad infinitum.
// Detener ejecución con ctrl+ alt + m en Run Code, o con Ctrl +c en la terminal.
setInterval(function(){console.log('Voy a contar hasta infinito, detén mi ejecución o consumo tu memoria'),1000}); // Esta instrucción es asíncrona, por lo que se ejecuta en n momento.


let i = 0;
setInterval(function() {
    console.log(i);
    i++;

// Al ser monohilo el peligro recae en que si el código se ejectua y no tenemos cuidado el no asignar una variable de manera correcta me puede arrojar un error.
//Hay que escuchar los errores, es muy imporante de todo lo que pase en el código. Comprobar funciones y revisar lo que posiblmente puede fallar.
//Es clave estar pendiente de todos los errores que pueda cortar la ejecución, lo que se corta corta todo.
// Todo lo que sea asíncono y lo pueda llevar a ello, pues llevarlo, y todo lo que no, revisar que no corte el programa.

    // if (i === 5) {
    //     console.log('forzamos error');
    //     var a = 3 + z;
    // }
}, 1000);


console.log('Segunda instrucción');

MONOHILO

PROCESO DE NODE

    1.- Va a abrirse un proceso, ese proceso es un proceso de node
    2.- Interpreta todo el archivo
    3.- Convertirlo a código maquina
    4.- Prepara todo lo que necesita para ejecutarse
    5.- Se ejecuta
    6.- Se cierra el proceso, y termina

DESVENTAJAS MONOHILO

    - Si no se manejan bien los errores y uno truena, ya no continua con los procesos posteriores
    - Debes estar pendiente de todo el código

Segunda clase del curso, y aparte de los dos cursos que ya tome con Freedy, este maestro es el que siento yo, mejor explica y mejor da a entender las cosas 😄

Si, y si pones un timeout de 0 seguiría ejecutándose primero la “segundo instrucción”, porque hasta que no acabe el hilo principal no empiezan a ejecutarse las instrucciones que has enviado al event loop. Pero si explicara esto ya tendria que meterse a explicar otras cosas como las pilas de eventos etc

Es algo interesante cuando los profesores cometen errores, dan a entender que no estan copiando y pegando codigo de otra parte, si no que enseñan con sus propias lineas 😄

Si quieren evitar que un error les corte el programa pueden usar TRY CATCH de la siguiente manera:

let i = 0;
setInterval(function () {
    console.log(i++);
    try {
        if (i === 5) {
            var a = 3 + z;
        }
    } catch (error) {
        console.error(error)
    }
}, 1000)

A todos nos ha pasado más de una vez que se nos olvida guardar y pensamos que fallo algo, para mí funciono el hecho de cambiar el shortcut de Save a teclas que fueran más cómodas. Para acceder a la lista de shotcuts donde pueden editar Ctrl + K + S.

En Node la ejecución de eventos es asíncrona, por lo que retornara los resultados apenas pueda hacerlo en cada evento. Es muy importante saber que si uno de estos eventos fallan, todo va a detenerse, por lo que hay que comprobar rigurosamente nuestro código ante los fallos que puedan suceder.

“Ahhhh… es que no había guardado , muy bien Carlos” , la de veces que me ha pasado eso 😄, lo conseguí solucionar activando el AUTOSAVE en VSCODE, ¿es esto una mala práctica? ¿puede afectar al flujo de trabajo con git, github, gitlab?

var i = 0;
setTimeout( () => {
    console.log(i++);
},1000);

setTimeout solo se ejecuta en cierto tiempo a diferencia de SetInterval que se ejecuta cada cierto tiempo

Monohilo: implicaciones en diseño y seguridad

<console.log("Hello world!!");

let i = 0;

setInterval(function() {
  console.log(i);
  i++;

  if (i === 5) {
    console.log("forzamos error");
    var a = 3 + z;
  }
}, 1000);
>

Importante: debes estar pendiente en todo lo que ocurre en tu código.

Les dejo mis notas hechas con Notion de la clase ^^

En Monohilo, se debe estar pendiente de todo lo que pasa para que no se detenga todo el proceso. Qué hacer? Desarrollo basado en pruebas?

Ley de Murphy: Todo lo que puede salir mal, saldrá mal.

Muy importante haberlo entendido como programadores

let i = 0;

function Increment (seconds) {
    setInterval(() => {
        if(i === 1) {
            console.log(`Pasó ${i} segundo`)
        } else {
            console.log(`Pasaron ${i} segundos`);
        }
        i ++;
    }, seconds);
}

Increment(1000);
//event loop

let count = 10;

//infinite loop con respuesta en 5 y respuesta en -5
setInterval(() => {
    let name = "platzi"
    let course = "curso de nodejs"
    console.log(count--)
    if(count === 5 || count === -5){
        console.log(`estoy aprendiendo en ${name} el ${course}`);
    }
}, 1000);```

Para parar un proceso, es realmente con la señal SIG_TERM que es el CTRL-C en la terminal o desde un monitor de procesos, como ps -fea, ver el PID y mandarle esa señal.

kill -15 $NODE_RUNNING_PROCESS

con la cara que dice que este pendiente de mis programas !!! se nota que lo dice desde la experiencia. Gracias!

Leyendo los comentarios hablan mucho de try/catch. Yo personalmente no los conozco aun. Espero aprenderlos durante esta clase.

Y a mi por qué me nombran? 😛

Me encanta como enseña este maestro, yo recomiendo repasar las clases del curso de asincronismo con JavaScript y el curso de JavaScript Engine (V8) y el Navegador

Como aporte, quisiera aclarar que el setInterval no se ejecuta de último porque dure 1000ms, podemos ponerlo en 0 y va a seguirse empezando a imprimir de último.
La razón de que esto suceda es que el Event Loop no deja que nada asíncrono empiece siquiera a ejecutarse hasta que el CallStack, en donde están todos los procesos síncronos y “normales”, no se quede vacío.
Por eso, aunque le pongamos 0ms, el resultado va a ser el mismo si hay funciones o procesos síncronos a la espera. Desde una funcion super compleja hasta un simple console.log()

“Todo lo que pueda fallar, antes de que falle: compruébalo”!

Ctr + S y estamos guardando o habilitar el autosave. Es buena practica aprender atajos del teclado y configurar otras funcionalidades solo presionando combinacion de teclas.

Con la función setInterval puedes ejecutar acciones cada cierto tiempo, se pasa como parámetro el tiempo (cada cuanto tiempo se ejecutará) en milisegundos:

let i=0;

setInterval(function (){
  console.log("Acción "+i);
  i++;
  
  
  if(i === 5) {
    console.log("Se aproxima un erro D:");
    //Error 
    var error = n + 12;
  }
}, 1000);

console.log('Segúnda instrucción');

Usamos está función para comprobar el comportamiento de hilos en Node.js

Muy Buena Clase .

Mi código de la clase.

//Primera linea que se escribe
console.log('hola mundo');

//como este proceso toma mas tiempo en ejecutar se delega
let i =0;
setInterval(function () {
    console.log(i);
    i++;

    if (i===5) {
        var a =3+z
    }
},1000)

//como el proceso anterior fue delegado se continua con la siguiente linea e codigo.
console.log("segunda intruccion");
console.log("Hola mundo");

let i = 0;

setInterval(function() {
    console.log(i);
    i++;

    if (i === 5) {
        var a = 3 + z;
    }

}, 1000);


console.log("Segunda instruccion");```

¿Por que no se ejecuta almenos una vez la funcion setInterval y luego el 2do log. Ejemplo:

Output:
Hola mundo
0
Segunda instruccion
1
2
3
4…
¿Por que pasa de una al segundo log?

Monohilo: implicaciones en diseño y seguridad


Para ejecutar un archivo con Node.js, tenemos que escribir en la terminal:

node file.js

⚠ Los archivos node-js su extensión es .js

Lo malo de que Node.js sea monohilo, es que cuando tengas un error, Node va parar todo y dejar de ejecutarse.

Código de la clase:

console.log('HolaMundo!!');

let i = 0;
setInterval(function()
{
  console.log(i);
  i++;
  if(i === 5 ){
    var a = 3 + z; 
  }
  //console.log('corta una cabeza, salen dos!!');
},1000);

Ejecución:

node nombre.js

![](

hay que estar atentos a los errores que puedan cortar la ejecución

Al ser monohilo, si se detecta un error detiene por completo la aplicación.

Todo lo que pueda fallar antes de que falle hay que comprobarlo.

-setInterval: EventLoop abierto y escuchando todo el tiempo

-Lo malo del Monohilo es que si no tienes cuidado cuando se ejecute un error se para por completo el proceso

ctrl + C = Parar el proceso.

La verdad estoy muy contento con el curso, que calidad tan buena tiene el profesor de explicar. La verdad se le entiende todo muy claro. Esperamos seguir aprendiendo.

El monohilo es como una cinta de producción en un fábrica de cajas, cada proceso es una caja bien hecha pero un error es una caja enorme… mal hecha. Cuando la caja va a salir para su venta atasca el mecanismo ya que es muy grande. Por lo que las cajas que vienen detrás nunca llegan a “salir” (procesarse en el caso del código).

Monohilo: implicaciones en diseño y seguridad

console.log('Hola mundo')

let i = 0
setInterval(function () {
  console.log(i)
  i++

  /* if (i === 5) {
    var a = 3 + z
  } */
}, 1000)

console.log('Segunda instrucción')

Se debe tener un cuidado muy grande al ejecutar sin tener las precauciones necesarias como: asignar las variables de forma adecuada, utilizar una sintaxis correcta, debido a que Node para todo si no se tiene un manejador de errores establecido y esto puede ocasionar problemas.

<h3>Monohilo</h3>
console.log("Hola Mundo")
//
let i = 0
setInterval(function() {
	console.log(i)
	i++
	
	if(i===5) {
	var a = 3 + z
	}
	console.log("sigo activo")
}, 1000)

console.log("segunda instrucción")

Si no tienes pendientes de tus parámetros tu hilo principal puede detenerse

node no funciona en la terminal.

Hola, acá les comparto un foro en Stack Overflow por si no les funciona el comando “node” en la terminal 😃

https://es.stackoverflow.com/questions/136407/node-no-se-reconoce-como-un-comando-interno-o-externo-programa-o-archivo-por

//Monohilo: implicaciones en diseño y seguridad

/*PROCESO DE NODE

    1.- Va a abrirse un proceso, ese proceso es un proceso de node
    2.- Interpreta todo el archivo
    3.- Convertirlo a código maquina
    4.- Prepara todo lo que necesita para ejecutarse
    5.- Se ejecuta
    6.- Se cierra el proceso, y termina

DESVENTAJAS MONOHILO

    - Si no se manejan bien los errores y uno truena, ya no continua con los procesos posteriores
    - Debes estar pendiente de todo el código
    El hecho de que sea monohilo lo hace delicado en el sentido de que puede ejecutarse algo que corte el código y
    detenga el programa, como la ausencia de sintaxis o una variable pendiente por definir
*/

console.log('Hola mundo');

let i = 0;

setInterval(function() {
    console.log(i);
    i++;

    // if (i === 5) {
    //     console.log('forzamos error');
    //     var a = 3 + z;
    // }
}, 1000);

console.log('Segunda instrucción');

Si les sale por defecto powershell en su consola de VS code para ponerle el bash (que por cierto les servirá mucho en este y varios cursos) solo tienen que seguir lo siguiente

  1. Instala Git from https://git-scm.com/download/win (Si ya lo tienes instalado pasa al paso 4)

  2. Abre VS code y presiona Ctrl + ` para abrir el terminal.

  3. Se mostrará en la parte inferior tu consola

  4. Abre el comando usando Ctrl + Shift + P.

  5. Escribe -> Select Default Shell

  6. Selecciona Git Bash

  7. Click en el ícono + en ventana del terminal

El nuevo terminal será un Git Bash terminal.

Es interesante ver como el profesor utiliza

console.log("forzamos error")

para saber si su bloque if se está ejecutando.

Puedes diferenciar entre un programador con experiencia y uno sin experiencia, viendo la cantidad de console logs en su código.

El programador sin experiencia casi no lo usa y por lo tanto, al momento de debuggear, se rompe la cabeza y tarda horas en resolver un problema.

El programador con más experiencia suele utilizar más loggear y además sabe cuando y donde ponerlos, de manera que la consola no se sature visualmente y sepa exactamente en donde está el problema.

Esta es simple y sencillamente, una forma de conocer el comportamiento de tu código y es súper importante.

La forma “normal” o “común” de loggear es así

console.log("tu mensaje")

Sin embargo, el método log de console, puede aceptar más de un parámetro, lo que te permite loggear información con un mejor formato.

Por ejemplo, si tienes una variable “x” que cambia de valor mientras el código se está ejecutando, y tu quieres conocer el valor de esta variable en diferentes etapas, lo puedes hacer con

console.log(x)

y esto como resultado te va a dar algo como

5

Ok perfecto, pero, si estuvieras loggeando más elementos ¿Como sabrías cual de todos ellos es realmente “x”?
Una forma es la siguiente:

console.log("x es igual a: ", x)

lo cual como resultado te va a dar:

x es igual a: 5

De esta forma le estamos pasando más de un parámetro al método log, y así estás loggeando de una manera más descriptiva que te va a facilitar mucho las cosas en un futuro.

Otra forma es la siguiente:

console.log({x})

Si te das cuenta aquí estamos loggeando a “x” dentro de dos paréntesis de llave, lo cual genera un “objeto” con “x” como key y el valor de “x” como value. Por lo tanto el resultado será el siguiente:

{x: 5}

lo cual también es bastante descriptivo.

Espero que a alguien le haya servido este comentario y puedan de ahora en adelante debuggear mejor utilizando bien el método log

¿Que sucede?
Se habre un proceso de node, interpreta el archivo a codigo maquina, para ejecutarse, se ejecuta, y muestra en la consola el hola mundo , luego se cierra el proceso.
Ahora puede aver un problema al ser monohila, que si no andas con cuidado suficiente cuando se ejecute un error, para por completo nuestro proceso, andar pendientes de lo que pasa

Monohilo: implicaciones en diseño y seguridad

Node al ejecutar o procesar código en un solo hilo es una ventaja y una fuente de problemas.

Buenas practicas

cuando estamos en la consola y ejecutamos un archivos js con node como por ejemplo node ejemplo.js primero se abrirá un nuevo proceso y es un proceso de node que va interpretar el archivo, lo convierte a código maquina, prepara todo lo necesario para ejecutar el código, luego se va ejecutar, muestra en pantalla el resultado y por ultimo el proceso se cerrara ocasionando que node termine.

Existe la opción de ejecutar algo que este siempre activo y lo podremos lograr de la siguiente manera:

setInterval(() => {
  console.log("Estoy activo"), 1000;
});

// 0
// 1
// 2
// 3
// 4...

En el código anterior le estamos diciendo a node que cada un segundo muestre en consola el texto ‘Estoy activo’, esto se ejecutara infinitamente. Pero si llegara a fallará algo, inmediatamente mostrara el error y node va para todos los procesos.

let contadorDeNumeros = 0;

setInterval(() => {
  console.log(contadorDeNumeros);
  
  if(contadorDeNumeros === 5) {
    console.log(contadorDeNumeros + numeroNoexistente);
  }
  contadorDeNumeros+=1;
}, 1000);

console.log(contadorDeNumeros);

// 0
// 1
// 2
// 3
// 4
// 5
// /home/mooenz/mis-apuntes/Curso-de-Fundamentos-de-Node-js/tempCodeRunnerFile.js:7
//     console.log(contadorDeNumeros + numeroNoexistente);
//                                     ^

// ReferenceError: numeroNoexistente is not defined
//     at Timeout._onTimeout (/home/mooenz/mis-apuntes/Curso-de-Fundamentos-de-Node-js/tempCodeRunnerFile.js:7:37)
//     at listOnTimeout (internal/timers.js:555:17)
//     at processTimers (internal/timers.js:498:7)

Es importante estar pendiente todo lo que sucede en nuestras aplicación o programa y si algo tiene una probabilidad de fallar, fallará.

También debemos tener presente que se pueden mitigar estos errores o controlar pues node al detectar un error lo que va a hacer es para todos los hilos que se están ejecutando dando por finalizado nuestro programa y no sabremos en que estado quedo cada hilo de ejecución, por eso será muy clave tener un plan cuando suceda por que estaríamos evitando la finalización de todo el programa.

Conclusión, cuidar nuestro programa e hilo principal, todo lo que se puede ejecutar en asíncrono, ejecútemelo. Frase del día ‘si algo tiene una probabilidad de fallar, fallará’.

Como la mayoría de mis compañeros ya dijo, es interesante ver como los profesores reaccionan a los errores.

Es una lección de como debemos actuar, calmados y entender que sucede.

Estuve corriendo tres procesos en mi Mac hasta que llegué al minuto 9:10". Para parar un proceso Control + C.

ESTAR MUY MUY MUY PENDIENTES DE AQUELLAS FUNCIONES O PROCESOS QUE PUEDAN LANZAR UN ERROR QUE NO ESTE MANJEADO Y SE DETENGA TODA LA EJECUCIÓN!.

Ahhh es que no había guardado, muy bien Carlos…
Debemos estar muy pendientes de la revisión de nuestro código y cuidar el único hilo de ejecución del que disponemos.

RECORDEMOS, si crees que algo no puede fallar, pues lo hará.

Al ser monohilo, si se detecta un error detiene por completo la aplicación.

Los ejemplos sencillos, para enfocarnos el punto de explicación, genial

Es muy interesante si campuras el error y lo mandas a la consola, no se detiene el hilo

//Manejo de errores NO se detiene la ejecición
setInterval(() => {
  console.log(i);
  i++;

  if (i === 5) {
    try {
      let a = i + z;
    } catch (err) {
      console.log(err);
    }
  }
}, 1000);```

A todos en algún momento nos pasa que NO GUARDAMOS EL CÓDIGO y nos asusta que algo haya salido mal, pero no siempre es eso.

Si usas VS Code te recomiendo poner el autoguardado después de cada edición de línea, será un segundo que te ahorrarás por cada ejecución de código.

Monohilo= Si no tenemos cuidado suficiente cuando se ejecute un error eso va a parar por completo todo nuestro codigo, tenemos estar atentos con cada detalle!

Muy buena clase, muy buen profesor

hay que tener claro que las funciones asíncronas no se ejecutaran hasta que el callstack se encuentre vació

Esto se pondrá bueno cada vez que se rompa el código… Que Node se apiade de nosotros.

EStar oendiente en el codigo y controlar las validaciones

setInterval(function, milliseconds)
ejecuta la funcion en un tiempo especifico en milisegundos repitiendo continuamente.

Es algo muy bueno a tener en cuenta

Muy valiosa la forma de solucionar o encontrar la falla con el console.log también me quedo con si algo puede salir mal, saldrá mal, Excelente clase

Una pregunta:
Pero no seria algo bueno, es decir si hay un error en el threat pool entonces sabemos que es ahi y no en el task stack?
Significa que el proceso se irrumpe cuando se ejecutan las tareas en la “piscina de hilos”?

He probado en la consola del browser y el error se ejecuta infinitamente lol

Cuando el profe da consejos sin parpadear, es que la cosa es seria jejeje 😮

Hola aca les dejo mi repositorio 😄
https://github.com/Juangr1803/Fundamentos-nodejs

Node js es monohilo, por eso tenemos que tener cuidado con los errores, ya que un error que no se ha tratado puede botar toda nuestra app!

👌

Traten a sus procesos como a una figura de porcelana

Me gusta como explica, se le entiende muy bien.

Te ganaste un fan Carlos! Me encanta la manera que tiene de explicar este profesor!!! Super entendible

entendido 😃 tener ojo con los errores

Muy amena la explicación

Lo podemos controlar con un trycatch así:

let i = 0;
setInterval(function () {
  try {
    console.log(i)
    i++;

    if (i === 5) var a = 3 + z;
  } catch (error) {
    console.error(error);
  }
}, 1000);

Muy buena explicación.

jaja si algo puede salir mal, seguramente saldrá mal xd

Genial.

Esta clase me hizo dar mucho miedo! Jajaja

Muy buena explicación

uy super la información de esta clase

hasta ahora las clases tiene un ritmo y los conceptos quedan bien explicados.

Para los que están viendo la clase y no saben como detener la ejecución del setinterval, este se hace con ctrl + c, y el profe lo dice al final del video 😛

vamos bien ready

Muy buen curso!!! Todo muy claro!!!

Interesante, esto tiene bastante importancia cuando se usa en producción

volvi a ver esta leccion y me quedo mas claro los conceptos!!! seguimos!

Súper interesante el saber cómo funciona la asíncronia en JS y node a diferencia de otros lenguajes

Valga la aclaración
hilos = threads

Y esto es literal mente la base para asegurar que los desarrollos esten al 100 y poder evitar muchos problemas futuros

Vaya!! Es importante que, los profesores tengan errores en “tiempo real”; considero que, le agrega un valor extra (nos puede pasar).

Buena base y buen manejo, me entusiasma aprender más

Tremendo crack el profe, creo que este curso debería estar o o si ya lo esta al inicio del curso de desarrollador web, ya que te ayuda a entender muchísimo mejor lo que pasa en js

un debugger en su máxima expresión Ajajaj

done!

Me alegra saber que no soy el único al que se le olvida guardar y luego no sabe por qué el código no hace lo que se espera 😅

El principal problema de ser Monohilo es que cuando ejecute un error eso va a parar por completo nuestro proceso.