Actualmente tengo 2 cursos gratuitos de lenguajes de programación puros, llamados Java para Principiantes y Kotlin para Principiantes, y pienso lanzar algunos otros próximamente, creo que Python será el siguiente.

La forma en que organizo y explico mis cursos parte de la idea que tengo de que la mejor manera de aprender un lenguaje de programación es esta:

1.- Aprende lo básico rápidamente, no te metas a ver cosas complejas o te aburrirás antes de usar el lenguaje en algo práctico.

2.- Usa el lenguaje con un framework (Java -> Android, Python -> Django, Javascript -> NodeJS, etc) para crear algo divertido, una web o app. Sigue el mismo principio aprendiendo solo lo necesario.

3.- Aprende cosas más complejas del lenguaje conforme las vayas necesitando.

4.- Ahora sí poco a poco profundiza más en los detalles y temas avanzados y vuélvete experto(a).

Debido a que en este tipo de cursos he recibido comentarios como «No profundiza lo suficiente» o «Faltan temas por ver» aquí te menciono que vas y que no vas a encontrar en mis cursos donde enseño lenguajes de programación puros para Principiantes ANTES de que avances más, para que sepas de antemano si el curso es para ti y no te lleves una decepción si no es lo que esperas.

Qué encontrarás en estos cursos:

• La sintaxis y partes principales del lenguaje: Cómo implementar variables, métodos, clases, interfaces, etc.
• Principales estructuras de datos para el lenguaje.
• Consejos y prácticas útiles de programación.

Qué NO encontrarás en los cursos:

• Temas teóricos avanzados como patrones de diseño. Este tipo de temas los iré agregando en el canal de Youtube y este blog.
• Implementación del lenguaje en un framework: para implementación de Java en Android está el curso de Android completo con Java.
• Todo lo que no sea absolutamente necesario para empezar a usar el lenguaje cuanto antes.

Los cursos «para Principiantes» son para ti si eres nuevo(a) en el lenguaje y quieres aprender rápidamente lo más importante del lenguaje para empezar a usarlo cuanto antes sin gastar mucho tiempo y abrumarte. Directo y al grano.

Ahora lo contrario, estos cursos NO son para ti si ya sabes usar bien el lenguaje o si lo que quieres es dominar todo hasta un nivel experto y con un enorme detalle.

En resumen, la idea es que aprendas lo más rápido posible, por lo que trato de que los cursos sean 100% prácticos y te enseñen justo lo necesario para especializarte en lo que quieras, evitando que tengas que tomar un curso de 30 horas solo para empezar a usar el lenguaje.

Tal como menciono arriba, en este blog y el canal de Youtube Hackaprende iré añadiendo temas complementarios y/o más avanzados. Todas las ideas y recomendaciones son más que bien recibidas, por ejemplo si crees que debería agregar algún tema que piensas que es esencial y actualmente no incluyo. También si crees que algún tema actual no está claro te agradecería mucho que me lo comunicaras. Por ahora te felicito por iniciar uno de los cursos y ¡Te deseo mucho éxito!

Como nada es perfecto, data binding tiene una desventaja con respecto a findViewById().

Android «pinta» los views en la pantalla cada 16ms en promedio, esta actualización de la pantalla puede suceder en menos tiempo, pero si se hacen procesos pesados en el hilo principal (Main Thread) podría causar que la actualización sea de más de 16ms y empezamos a ver lags en la pantalla. Cuando usamos binding para asignar valores a un view, por ejemplo al asignar un texto a un TextView con binding.myTextView.text = «Some text», el binding no se ejecuta al instante, sino que espera a que pase ese tiempo de 16ms para medir cuanto el área del nuevo texto y luego pintarlo. Es como cuando juegas con tu perro a lanzar la pelota y va por ella pero luego no la suelta hasta que pasas un rato tratando de quitársela (16ms en promedio).

Esto por lo general no nos afecta, por ejemplo cuando abrimos una nueva Activity y pintamos todo con binding, 16ms no son nada. Lanzaste la pelota a tu perro una vez y se la quitas, no pasa nada.

Pero ahora imagina un recyclerView con decenas de elementos, cuando haces scroll rápidamente y viene el siguiente elemento, puede ser que todavía no hayan pasado los 16ms recomendados, pero podría suceder que cuando aparece el siguiente elemento el binding no haya alcanzado a medir y pintar el anterior, entonces podrían verse lags extraños. Es como si quisieras romper un record de lanzar pelotas y ya viene la siguiente pero tu perro todavía no suelta la anterior.

Esto es poco común, y de hecho si no implementas lo que estoy a punto de mencionarte muchas veces no tendrás problemas, pero es mejor prevenir.

La solución para prevenir esto es que después de pintar los views de tu ViewHolder, mandes llamar binding.executePendingBindings(), así:

inner class EqViewHolder(private val binding: ItemBinding): RecyclerView.ViewHolder(binding.root) {
    fun bind(earthquake: Earthquake) {
        binding.myTextView.text = someString
        binding.myImageView.src = someImage
        // Más cosas que hagas con tus views
        ... 
        // JUSTO AQUÍ VA 👇
        binding.executePendingBindings()
    }
}

De esta manera, vas a forzar al binding a que no se espere los 16ms, sino que pinte todo inmediatamente. Sencillo, es solo agregar una linea de código, aunque Android no explica mucho para qué sirve en su documentación oficial y por eso a veces es difícil de recordar.

Espero que los de Android manejen esto automáticamente en el futuro. Mientras tanto te invito a dejar tus comentarios.

Finalmente después de tanto planear, grabar, editar, corregir y revisar, el nuevo curso de Android Completo con Kotlin ya está listo.

Este curso incluye todos los temas necesarios e importantes para empezar a trabajar como desarrollador Android, usando las mejores prácticas recomendadas por Google. Traté de hacer el curso lo más ameno posible, incluyendo solo los temas importantes, como siempre yendo directo al grano y dejando fuera todo lo que no sea esencial para que puedas aprender en el menor tiempo posible, como rayo ⚡️.

Sin más te invito a que le des un vistazo, aquí encontrarás más información sobre el curso, lo que incluye y lo que necesitas para empezar.

https://hackaprende.com/pagina-de-inicio/cursos/android-completo-con-kotlin/

¡Para los suscriptores del blog hay un súper descuento del 60%!, envíame un correo a hackaprende@gmail.com y si eres suscriptor te mandaré el super cupón.

¡Saludos y mucho éxito!

Recientemente me di a la tarea de documentar el código de una aplicación que estoy desarrollando y seamos sinceros, documentar código es aburrido, tal vez por esto no pude encontrar muy buena información, en particular en la parte de cómo comentarlo. Incluso en la página oficial de Kotlin no vienen ejemplo claros de cómo comentar el código. Después de un buen rato de prueba y error descubrí algunas cosas que creo que vale la pena compartir.

Vamos a verlo con el ejemplo de un método que obtenga el subtotal de una lista del supermercado donde cada elemento tiene un precio, una cantidad y un posible descuento. Además al final le vamos a agregar un impuesto 😭 al ticket. El método podría ser el siguiente.

private fun getTicketTotal(productList: MutableList<Product>, 
taxPercentage: Double): Double {
    var total = 0.0
    for (product in productList) {
        val subtotal = (product.quantity * product.price)
        total += subtotal * ((100 - discount)/100)
    }

    val taxAmount = (total * taxPercentage)/100
    total -= taxAmount

    return total
}

Empecemos por lo más básico, un simple comentario en Kotlin se inserta con dos lineas diagonales // así:

private fun getTicketTotal(productList: MutableList<Product>, 
taxPercentage: Double): Double {
    // Creamos total en 0
    var total = 0.0
    for (product in productList) {
        // Subtotal es el la multiplicación de cantidad por precio
        val subtotal = (product.quantity * product.price)
        total += subtotal * ((100 - discount)/100)
    }

    // Sumamos el impuesto al total
    val taxAmount = (total * taxPercentage)/100
    total -= taxAmount

    return total
}

Para comentarios más largos que ocupen varios renglones podemos insertarlos con
/* ... */, aunque también podríamos tener simplemente varios renglones con //:

private fun getTicketTotal(productList: MutableList<Product>, 
taxPercentage: Double): Double {
    // Creamos total en 0
    var total = 0.0
    for (product in productList) {
        // Subtotal es el la multiplicación de cantidad por precio
        val subtotal = (product.quantity * product.price)
        /* Restamos el posible descuento al subtotal, por ejemplo si 
           el subtotal es de $150 el descuento es de 30%, el total 
           será de 150 * ((100 - 30)/100) = 150 * 0.7 = 105 */
        total += subtotal * ((100 - discount)/100)
    }

    // Obtenemos el monto de impuestos, por ejemplo si el total es 
    // 150 y el impuesto es 15%: 
    // taxAmount = (150 * 15)/100 = 22.5
    val taxAmount = (total * taxPercentage)/100
    total -= taxAmount

    return total
}

Finalmente, para comentar un método completo podemos utilizar /** ... */, aquí podemos indicar también cuales son los parámetros que necesita el método y qué es lo que regresa, así:

/**
* Este método obtiene el total de una lista de [Productos] teniendo
* en cuenta [Producto.precio], [Producto.cantidad], 
* [Producto.descuento] y un posible impuesto.
*
* @param productList La lista de productos de la cual se obtiene el * total
* @param taxPercentage El porcentaje, el cual puede ir de 0 a 100
*
* @return El total después de impuestos.
**/
private fun getTicketTotal(productList: MutableList<Product>, 
taxPercentage: Double): Double {
    // Creamos total en 0
    var total = 0.0
    for (product in productList) {
        // Subtotal es el la multiplicación de cantidad por precio
        val subtotal = (product.quantity * product.price)
        /* Restamos el posible descuento al subtotal, por ejemplo si 
           el subtotal es de $150 el descuento es de 30%, el total 
           será de 150 * ((100 - 30)/100) = 150 * 0.7 = 105 */
        total += subtotal * ((100 - discount)/100)
    }

    // Obtenemos el monto de impuestos, por ejemplo si el total es 
    // 150 y el impuesto es 15%: 
    // taxAmount = (150 * 15)/100 = 22.5
    val taxAmount = (total * taxPercentage)/100
    total -= taxAmount

    return total
}

Como puedes observar hay palabras que encerré entre [] esto es para que puedas dar option + clic en esa clase o incluso en un método o campo dentro de la clase y te lleve directamente a ella. Ahora es mucho más claro lo que hace el método, sí es aburrido, pero tus compañeros (y tu yo del futuro) te lo agradecerán.

NOTA: No todos los métodos e instrucciones necesitan comentarios, hay unos que son auto explicativos.

Si te gustó el artículo compártelo suscríbete y sígueme en mis redes sociales o donde quieras. También te invito a dejar tus comentarios. ¡Saludos y mucho éxito!