Durante el evento sobre malas prácticas de código realicé una encuesta entre los asistentes para que estos pudieran elegir que consideran más importante al momento de definir una buena práctica.
Los resultados fueron los siguientes:
Estoy dejando la encuesta abierta por unos días para que, si quieres votar, lo puedas hacer :).
Para votar, click aquí.
Otra charla ha pasado y como es costumbre, la presentación está subida en Slideshare.
Como se está haciendo costumbre… al final de mes estaré dando una charla gratuita online gracias a la comunidad MUG IT de Argentina.
En esta oportunidad voy a hablar de malas prácticas de código con C# pero con una pequeña modificación: No hablaremos de los clásicos como patrones de diseño o arquitectura que nunca se terminan aplicando… no!
Lo que trataré de hacer es sentar algunas bases para que los asistentes puedan detectar estas malas prácticas aplicando algún que otro método de deducción, aplicando cambios incluso si estos cambios no son los más destacados por la comunidad elitista de programadores :D.
Para inscribirse: https://mug-it.org.ar/event.aspx?event=558
En el post anterior hablábamos sobre cómo era posible saber si un array estaba ordenado y veíamos una forma para reducir la cantidad de iteraciones y así tardar menos tiempo al momento de recorrer el array.
Al final del post dejaba una pregunta: Y si intentamos generar pequeños compartimientos y reducir aún más las iteraciones?
Hay muchas formas de hacer esto. Podríamos probar con pura matemática, bucles anidados o… creando código dinámicamente.
Posiblemente no necesitemos hacer nada de esto en la gran mayoría de escenarios, pero siempre es interesante ver hasta dónde un lenguaje puede llegar. Y JavaScript es uno de esos lenguajes que nos deja volar la imaginación y hacer cosas que en otros lenguajes sería muy complicado (O imposible).
Entonces, veamos una solución dinámica.
const constructFunction = (steps) => {
let s = "return ";
for (let index = 0; index < steps; index++) {
s += `(arr[i * ${index * steps}] > arr[(i * ${index * steps}) + 1]) || `;
}
s = s.substr(0, s.lastIndexOf(" ||")) + ";";
return new Function("i", "arr", s);
};
Lo primero que necesitamos es una función que nos permita crear código en tiempo de ejecución. Esta función genera estos pseudo compartimientos en base a la cantidad de los mismos y haciendo que el “cursor” del array “salte” las distancias de los compartimientos en cada iteración. El constructor “Function” nos permite crear una función en JavaScript basándose en el texto pasado por parámetros. Esto funciona de forma similar a “eval” con la diferencia que es ligeramente más seguro.
El siguiente paso es modificar el cuerpo de la función que valida el ordenamiento para que pueda crear y usar esta función.
const isSorted = (a, steps) => {
if (a.length <= 1) return true;
const partitions = constructFunction(steps);
for (let index = 0; index < steps; index++) {
if (partitions(index, a) === true) return false;
}
return true;
};
La navegación del array ahora se limita a la cantidad de compartimientos y no a todo el array. Por lo tanto, mientras más compartimientos tengamos menos iteraciones. Por supuesto, habrá más condiciones de comprobación (Todo tiene sus pros y sus contras). Por último, la ejecución.
const number_array = [1, 2, 3, 6, 9, 10, 30, 31, 88];
console.log(isSorted(number_array, number_array.length / 3));
Es importante aclarar que el código anterior es solo para ejercitarnos pero no debe ser usado directamente salvo que le hagamos modificaciones importantes. Por ejemplo, el cálculo de los compartimientos no es correcto y es necesario calcular de forma específica cuando el array no genera compartimientos enteros. De cualquier manera, y como decía al principio, es interesante para pensar una solución desde una mirada diferente.
Ayer respondía una consulta de un subscriptor del canal de YouTube donde se planteaba, entre otros ejercicios, cómo saber si un array está ordenado o no?
Si bien, como en todo lo que hacemos cuando escribimos código, pueden haber múltiples formas de encararlo, el código resultante para una “primera versión” es más o menos así:
const isSorted = (a) => {
const length = a.length;
if (length <= 1) return true;
for (let index = 0; index < length - 1; index++) {
if (a[index] > a[index + 1]) return false;
}
return true;
};
En resumen, se recorría todo el array en busca de que pares consecutivos de números sea, el primero, menor que el segundo (Esto si el array está ordenado de forma ascendente).
Y si bien esto funciona sin problemas, es necesario recorrer todo el array para verificar cada uno de los elementos. Esto quiere decir que mientras más grande sea el array, más tiempo necesitará para procesar todos los elementos.
Por lo tanto necesitamos buscar otra opción que pueda reducir la cantidad de iteraciones sobre los elementos del array.
Una forma de hacer esto puede ser analizando los elementos desde dos direcciones.
const isSorted = (a) => {
const length = a.length;
if (length <= 1) return true;
let l = 0;
let r = length - 1;
for (; l < r;) {
if (a[l] > a[l + 1] || a[r] < a[r - 1]) return false;
l++;
r--;
}
return true;
};
En este caso, el array es recorrido hasta la mitad del mismo y, al mismo tiempo, es recorrido desde el final hasta la mitad. Esto reduciría la cantidad de iteraciones a la mitad obteniendo un resultado de forma más rápida.
De cualquier manera, siempre se puede hacer de mejores formas y reducir mucho más la cantidad de iteraciones. En el ejemplo recorremos desde el inicio del array hasta la mitad del mismo y desde el final hasta la mitad retrocediendo en vez de avanzar. Pero sería posible que, en base a la cantidad de elementos del array, creemos compartimientos virtuales que recorran todo el array pero en un bucle corto… tal vez? 🙂
Este mes, al final del mismo, estaré hablando sobre Blazor en un evento online gratuito.
Ya en el canal de YouTube he hablado sobre Blazor, pero antes de que saliese la primera versión. Ahora que Microsoft ha oficializado Blazor (Hace ya un tiempo), es hora de verlo más en profundidad.
Para incribirse: https://mug-it.org.ar/555-Blazor-La-nueva-web-GRATIS.event.aspx
En el último streaming del canal me pidieron hacer videos sobre diferentes algoritmos. Hoy toca la serie de Fibonacci, un clásico de toda entidad educativa.
Pero lo más importante: Recursividad.
En el post amterior les comentaba que estaría dando una charla sobre lo nuevo que trae C# 9.
La charla sucedió ayer y, si no pudieron asistir pero quieren verla, pueden hacerlo a continuación:
El viernes 30 de Octubre estaré dando una charla sobre las nuevas características de C# 9. Esto preparándonos para el lanzamiento de esta versión y .Net 5.
El evento es gratuito y esta organizado por el Grupo de Usuarios Microsoft de Buenos Aires, Argentina.
Para registrarse, pueden hacerlo en el siguiente link: https://mug-it.org.ar/541–distancia-Un-paseo-por-C-9.event.aspx
Hoy me adelanté un poco y subí la presentación que daré en unas horas sobre Unit Test y TDD en la vOpen 2020.
