DEV Community: devi amaolo

JavaScript Engine (V8)

devi amaolo — Thu, 29 Sep 2022 22:51:42 +0000

Con el nacimiento de las tecnologías web (HTTP, HTML, navegadores primitivos) las páginas web eran muy básicas y estáticas, solo se podia consumir texto e imágenes, nada como lo conocemos hoy en día. Los usuarios del navegador NetScape, dándose cuenta de la necesidad de evolucionar las páginas pidieron una mejora, y que las páginas web fueran dinámicas (que los usuarios pudieran interactuar con la página)

JavaScript fue creado por Brendan Eich, inspirado por otros lenguajes como Java, el propósito de JS fue dar solución a la problemática de las páginas estáticas.

El primer lenguaje (creado por Brendan Eich) que permitía darle un poco de interactividad a las páginas fue Mocha, este fue pensado para el navegador Netscape, que luego fue mejorando con el tiempo y ese mismo año lo sustituyó LiveScript. Luego, a finales del 95 surge de estos dos intentos finalmente JavaScript.

El nombre de JavaScript surge por motivos de marketing, ya que como el lenguaje Java estaba tomando fuerza en ese entonces, decidieron que este lenguaje tendría mejor aceptación si se le colocaba JavaScript (pero no son lo mismo, son dos lenguajes de programación totalmente diferentes.

A medida que JavaScript se hizo popular, surgieron variaciones de este lenguaje, por ejemplo, en 1995 la empresa Microsoft decidió hacer su variación del lenguaje para utilizarlo en su navegador Internet Explorer. Pero la organización de estándares ECMA International (que en ese momento surgió como un comité) decidió que los navegadores solo iban a aceptar como lenguaje JavaScript ya que era muy peligroso que distintos navegadores tuvieran su propio lenguaje de programación, y que esta organización se iba a encargar de ir añadiendo los nuevos cambios que surgieran en el lenguaje y publicar sus estándares.

Motor V8

Primero veamos que es un motor de JavaScript:

Un motor de JavaScript es un programa de computadora que ejecuta código JavaScript

Dicho de otra manera es aquel que se va a encargar de interpretar el código de JavaScript en el navegador.

Las empresas han desarrollado motores de javascript para poder interpretar el codigo en sus navegadores tales como:

JavaScriptCore (Apple) para Safari
Chakra (Microsoft) para Edge hasta 2019, ahora usa V8
SpiderMonkey (Mozilla) para Firefox
V8 (Google) para Chrome

En el año 2008 surge el motor de JavaScript de Google que corre en el navegador, con el nombre V8 JavaScript Engine. Este motor fue un paso crucial en la historia de JavaScript ya que resolvió la problemática de la lentitud del tiempo de interpretación.

La razón detrás de esta mejora tan grande radica principalmente en la combinación de intérprete y compilador. Hoy en día, los cuatro motores utilizan esta técnica. El intérprete ejecuta el código fuente casi de inmediato. El compilador traduce el código fuente en código máquina que el sistema del usuario ejecuta de manera directa.

Node.js es la forma como podemos trabajar JavaScript de lado del servidor y este también corre con el motor V8.

¿Cómo funciona el JavaScript Engine?

Cuando estamos trabajando con JavaScript y queremos que la computadora entienda las instrucciones que va a ejecutar, va a ocurrir un error, ya que la computadora no entiende JavaScript, entonces, tenemos que convertir JavaScript a código binario, que es el lenguaje que entienden las computadoras.

Por fortuna, no tenemos que realizar esto manualmente ya que el motor V8 de JavaScript hace esta tarea por nosotros, convirtiendo JavaScript en código binario.

JavaScript es un lenguaje interpretado, y compilado en tiempo real, esto significa que cuando el motor lo interpreta no tenemos que compilarlo previamente sino que compila el código al momento en que lo estamos ejecutando.

El motor V8 de Google para el navegador Chrome hace que JavaScript sea muchísimo más rápido. El mismo es Open Source, y por esto ciertos navegadores como Edge, Opera y Brave lo han implementado para la construcción de sus motores. También el navegador de Android está basado en V8.

¿Por qué nace V8?

El motor de V8 nace con la finalidad de optimizar el rendimiento de la aplicación Google Maps en los navegadores, ya que la aplicación tenía un mejor o peor rendimiento dependiendo del motor, pero igualmente corría muy lenta.

Para esto, el equipo de Google creó un motor para Chrome que ejecutara muchisimo más rápido Google Maps, permitiendo a los usuarios hacer gran cantidad de cosas. Al probarlo, se dieron cuenta que la rapidez del motor para ejecutar Google Maps permitía además usar JavaScript para hacer aplicaciones con mucha más interacción. Por lo que desarrollaron un motor más robusto para que podamos construir productos web más robustos donde haya mucha interacción.

Entendiendo el proceso de V8

Una vez que el motor corre el archivo de JavaScript, lo primero que hace es generar un entorno global, y procede a realizar 3 pasos.

Dentro de este entorno, crea un objeto global conocido como window (en los navegadores es Window y en Node.js es global)
Genera la variable this, donde en este entorno (scope global) this hace referencia al objeto window.
Después de haber creado el entorno global y el objeto global, crea un contexto de ejecución en donde correrá el código a través de una pila de ejecución. (Call Stack)

Luego, cuando JavaScript empiece a interactuar con el navegador ocurre un parseo (digamos que es una inspeccion) del documento completo para encontrar las keywords y mandarlas al Abstract Syntax Tree (AST), que es una estructura de árbol donde podemos ver como estan estructuradas las keywords (variables, funciones, objetos, todo en si) por dentro.

Ahora que tiene el árbol sintáctico listo con las keywords desestructuradas, comienza a interpretar el código y lo convierte en bytecode (que no es tan bajo como machine code, pero la máquina si puede entenderlo).

Finalmente antes de convertirlo en bytecode, puede ocurrir un paso interior donde si el motor detecta que el código puede ser optimizado (debido a que hayan variables repetidas, funciones declaradas, y errores en el código) por el motor en un intento de ayudarnos a que no ocurran errores, y una vez que lo optimiza, lo compila y lo convierte en bytecode. En este proceso puede ocurrir el Hoisting donde una variable (sucede mas que todo con var y function) es subida y guardada en memoria antes de ejecutar cualquier tipo de código, y puede devolvernos un comportamiento erróneo de nuestro código.

Esta fue una pequeña introducción a que es el motor v8 y su función a la hora de ejecutar código JavaScript.

articulos para profundizar:

Complejidad Algorítmica y Notación Big O

devi amaolo — Fri, 24 Jun 2022 05:46:28 +0000

En este artículo vamos a entender que es un algoritmo y como usar la notación Big O para poder analizar la complejidad temporal del mismo. Esto nos va a ayudar a entender el uso de recursos de cómputo y la eficiencia en velocidad dentro de nuestros programas, además suele ser una forma de evaluar a developers o ingenieros de software.

¿Qué es un algoritmo?

Un algoritmo es un conjunto prescrito de instrucciones o reglas bien definidas, ordenadas y finitas que permite realizar una actividad mediante pasos sucesivos que no generen dudas a quien deba realizar dicha actividad. O sea, una serie de pasos a seguir para completar una tarea.

¿Qué hace bueno a un algoritmo?

Resuelve un problema: Este es el objetivo principal del algoritmo, fue diseñado para eso. Si no cumple el objetivo, no sirve para nada.
Debe ser comprensible: El mejor algoritmo del mundo no te va a servir si es demasiado complicado de implementar.
Hacerlo eficientemente: No sólo queremos tener la respuesta perfecta (o la más cercana), si no que también queremos que lo haga usando la menor cantidad de recursos posibles.

De hecho estas dos condiciones a veces van en contra: encontrar la solución perfecta atenta contra el tiempo que va a tardar, y hacerlo rápido atenta contra la precisión de la respuesta. Vamos a tener que saber qué usamos en cada caso.

¿Cómo medimos la eficienta del un algoritmo?

Lo más fácil y rápido de hacer es contar cuanto tiempo le lleva al algoritmo encontrar la respuesta que buscamos. Pero eso nos diria la eficiencia de ese algoritmo sólamente para la computadora que lo corrió, con los datos que tenia y en el lenguaje que se haya implementado, no? Entonces como hacemos para comparar la eficiencia de distintos algoritmos? Para eso se hace un análisis conocido como Asymptotic Analysis, vamos a entender el concepto mas adelante.

Complejidad de un algoritmo

En general nos interesa conocer qué tan complejos son los algoritmos, o en realidad, lo contrario: que tan eficiente es un algoritmo.
Hay muchos aspectos que afectan la complejidad de un algoritmo:

Tiempo
Espacio
Otros recursos:
- Red
- Gráficos
- Hardware (Impresoras, Cpus, Sensores, etc...)

La mas común, y en la que nos vamos a concentrar mayormento es la complejidad de tiempo, es decir la velocidad algoritmo, o cuanto tarda en correr. Otro tipo de complejidad importante es el espacio, o sea la cantidad de memoria (RAM o disco) que necesitamos para poder corer un algoritmo. De hecho, a veces cambiamos la complejidad de tiempo por la de memoria, un algoritmo va a consumir más espacio en memoria, pero va a correr más rápido.
Otros algoritmos pueden requerir otros recursos, como por ejemplo algún algoritmo que se ejecute distribuido por la red, en ese caso el algoritmo se verá limitado por la velocidad y tamaño de la misma. Otro usarán otros tipos de recursos.

Circunstancias

¿Cómo sabemos cuando un auto es más rápido que otro?

Bueno, si los ponemos en un tramo igual, y tomamos nuestros relojes para medir cuánto tardan, podremos ver que uno llega más rápido que otro a la meta. Que un auto tarda menos que otro. Tal vez unos 10, o 20, o 30 minutos.

Entonces, medir es clave para determinar el mejor. Pero la Complejidad en sí no trata de si un auto llega 10, o 20 o 30 minutos más rápido a la meta. Si no del ritmo con el que aumenta.

La teoría de la complejidad estudia el consumo de recursos (tiempo, espacio) que un algoritmo ocupa. la complejidad algorítmica no se fija en el tiempo de ejecución del algoritmo (segundos, minutos, horas, etc), se fija en el ritmo y que tan eficiente puede ser un algoritmo en base al problema que está resolviendo.

¿Qué es este ritmo con el que aumentan los datos? ( EN CRIOLLO )

Supongamos que tenemos dos algoritmos para ordenar números.
Entonces tenemos un algoritmo A, medimos cuánto se tardará en ordenar diez, veinte y treinta números, y resulta vamos a requerir 10 segundos, 20 segundos y 40 segundos. Luego viene un algoritmo B, medimos otra vez, y requerirá 10 segundos, 10 segundos y 10 segundos. El aumento de tiempo es distinto en ambos. Entonces tenemos un algoritmo A que cada vez se demora más en calcular el ordenamiento (multiplicando cada vez por 2), y un algoritmo B que demora el mismo tiempo (multiplicando cada vez por 1). Este factor es el ritmo:

Cota superior asintótica ( Big O Notation )

Vamos a usar una función que sirve de cota superior de otra función cuando el argumento tiende a infinito.

Definicion formal:

Una función f(x) pertenece a O(g(x)) cuando existe una constante positiva c tal que a partir de un valor x0, f(x) no sobrepasa a cg(x). Quiere decir que la función f es inferior a g a partir de un valor dado salvo por un factor constante.

Puede parecer un poco dificil pero en la practica es mucho más simple que eso. La notación Big O intenta analizar la complejidad de los algoritmos según crece el número de entradas ( n ) que tiene que analizar, en general es el tamaño del dataset que usa como entrada. Y lo que busca es una función que crezca de una forma con respecto a n tal que nuestro algoritmo nunca crezca más rápido que esa función, aunque si puede crecer más lento. Básicamente, estamos buscando algo para poder decir: mirá este algoritmo nunca va a tardar más que esto, capaz tarda menos, pero más no.

Lo que hace a Big-O tan importante es que se destaca en concentrarse en el caso peor de tu algoritmo. En el tope superior de nuestras mediciones. Si nuestro algoritmo empezó con unas mediciones muy buenas, pero de pronto creció mucho en el consumo de un recurso. Big-O tomará en cuenta esto último para determinar qué crecimiento le pertenece.

Buscamos descubrir una función (Constante, Lineal, Polinomial, Logarítmica, Exponencial) la cual sea mayor o igual que la complejidad de un algoritmo

Clases de Big-O

Vamos a intentar crear un algoritmo en el que su ritmo de crecimiento no sea muy elevado.

Comparación Gráfica

Arriba podemos ver una comparación gráfica de las distintas complejidades de los algoritmos.

Si tuvieramos una computadora capaz de ejecutar 1.000.000 instrucciones por segundo, veamos cuanto tiempo tardarían algoritmos de distinta complejidad en terminar de correr con un N de entrada de 1000.

Calculo de Notación Big-O en complejidad temporal

Vamos a ver Las reglas en el codigo para Big-O en calculo de complejida temporal



let bar = 'test' // O(1)

if(){} // O(1)

for(){} // O(n)

while(){} // O(n)

for(){ for(){} } // O(n^2)

Simplificar la notación

Simplificar la notación de la complejidad se lleva a la expresión del elemento con mayor grado.

¿Por qué nos quedamos con el grado mayor al simplificar Big-O?

En Big-O queremos comprender qué tanto recurso (como tiempo o espacio) nos gasta un algoritmo cuándo aumentamos los datos. Y cada grado aumenta a un ritmo totalmente distinto.

Por ejemplo n crece más que 1000:

No es necesario quedarnos con los grados pequeños: Podemos simplificar y quedarnos con lo importante.

Ahora lo podemos poner en práctica analizando los siguientes programas:



// Complejidad Temporal -> O( n + 3 ) -> O(n)

function linearSearch(arreglo, clave) {

  for (let indice = 0; indice < arreglo.length; indice++) { // O(n)

    if (arreglo[indice] === clave) { // O(1)

      return indice; // O(1)

    }

  }

  return -1; // O(1)

}



// Complejidad Temporal -> O( 1 + n * n + 1 + 1 + 1 + 1 + 1 ) -> O(n^2 +6) -> O(n^2)

function bubbleSort(arreglo) {

  let longitud = arreglo.length; // O(1)

  for (let i = 0; i < longitud; i++) { // O(n)

    for (let j = 0; j < longitud; j++) { // O(n)

      if (arreglo[j] > arreglo[j + 1]) { // O(1)

        let temporal = arreglo[j]; // O(1)

        arreglo[j] = arreglo[j + 1]; // O(1)

        arreglo[j + 1] = temporal; // O(1)

      }

    }

  }

  return arreglo; // O(1)

}



//Complejidad Temporal -> O( n^2 )

function selectionSort(arreglo) {

  let longitud = arreglo.length; // O(1)

for (let i = 0; i < longitud; i++) { // O(n)

    let minimo = i; // O(1)

    for (let j = i + 1; j < longitud; j++) { // O(n)

      if (arreglo[j] < arreglo[minimo]) { // O(1)

        minimo = j; // O(1)

      }

    }

    if (minimo != i) { // O(1)

      let temporal = arreglo[i]; // O(1)

      arreglo[i] = arreglo[minimo]; // O(1)

      arreglo[minimo] = temporal; // O(1)

    }

  }

  return arreglo; // O(1)

}

Notas finales sobre algoritmos

Hasta ahora sabes que un algoritmo con O(1) es mejor que uno con O(n). Pero, ¿Y si ese algoritmo con O(1) se ejecuta en 1000 horas?

La complejidad algorítmica es importante, pero dónde se ejecuta tu algoritmo determina qué tan importante es.

Cuando la Complejidad Algorítmica deja de ser relevante, es donde debemos mejorar nuestro algoritmo para alcanzar nuestro objetivo de eficiencia.

Tal vez tengamos el mejor algoritmo jamás visto, pero si lo ejecutamos en una computadora de hace 20 años con Intel Celeron no podemos esperar mucha rapidez

¿Solo hay Big-O para tiempo?

No, también se puede aplicar al cálculo del espacio, por ejemplo en JavaScript es más relevante apuntar al tiempo, que al espacio. Porque en el código JavaScript usualmente no corre en dispositivos con memoria muy limitada a diferencia de dispositivos embebidos donde el espacio que tiene en la memoria es más reducido y por lo tanto más relevante para nuestro análisis.

Esto no significa que no haya casos particulares, o que el espacio siempre sea menos importante que el tiempo, sólo es el ambiente del software con JavaScript. la complejidad es el estudio de los recursos que utilizan los algoritmos. Estos recursos pueden ser cualquier concepto de hardware y software. Como acceso a la memoria, comparaciones de condiciones, o lo que se necesite limitar.

finalmente

Esta lectura fue un resumen a grandes rasgos sobre la complejidad algorítmica. Si te interesa profundizar sobre el tema y su aplicación en estructuras de datos te recomiendo los siguientes recursos gratuitos ofrecidos por Freecodecamp:
Data Structures Easy to Advanced Course
Big O Notation - Full Course