14 reglas de codificación importantes para aprender de grandes desarrolladores

Si nunca ha codificado, entonces podría estar pensando que el desarrollo de software se trata de escribir un montón de líneas de código en algunos idiomas y luego lanzarlo al nivel de producción cuando esté listo. Bueno, esto es cierto pero parcialmente. 

Pregúntele a un desarrollador qué hace realmente en su trabajo diario. Cómo escriben el código y cuáles son algunas reglas ocultas que deben tener en cuenta cuando están creando algunas funciones. Hay muchas reglas no escritas que un desarrollador debe seguir además de solo escribir el código. Incluso su estado de ánimo puede identificarse por el código que escriben en su aplicación. 

Recuerde que la programación no se trata solo de resolver el problema y hacer que su función funcione. También hay que cuidar muchas cosas. Cómo está nombrando su variable, cómo está usando bucles, declaraciones condicionales, comentarios, etc. Cómo está documentando, depurando y probando su aplicación. Estas son algunas responsabilidades que solo el desarrollador y su equipo conocen. Los clientes o los usuarios finales lo desconocen por completo, pero estos importantes factores importan mucho cuando se trata de lanzar el software con éxito en el mercado.

Ahora tenemos algunas preguntas para ti…

¿Qué sucederá si una aplicación no se prueba correctamente y se rompe cuando un usuario la está usando?

¿Qué sucederá si un nuevo desarrollador tiene que trabajar en un código escrito por otro desarrollador y se confunde solo por la complejidad del código? Evidentemente, tardará más tiempo o no podrá continuar con él.

Alguien que nunca haya codificado antes siempre desconoce estos problemas y la solución. En este blog, discutiremos estos temas y algunos aspectos importantes del desarrollo de software que deben seguir los desarrolladores.

1. Sea consistente

Siga un estándar de codificación consistente en su aplicación. Sea cual sea la estructura o el enfoque que siga, asegúrese de ser coherente con él durante toda la aplicación. Si sigue una forma de hacer algo en un lugar, siga una forma similar en otros lugares. Esto hará que su código sea más legible y fácil de mantener. 

Por ejemplo: si está nombrando una variable como variableOne, variableTwo en su aplicación, siga un camino similar en otros lugares. Para la tercera variable, el nombre debe ser variableTres, no variable_tres. Cuida estas pequeñas cosas. 

El estándar de codificación debe ser tan pequeño como la convención de nomenclatura de su variable. La estructura de su aplicación debe ser lo más simple posible para que otros desarrolladores puedan trabajar fácilmente en ella, agregarle funciones y realizar cambios.

2. Reducir la anidación

Muchas veces, los desarrolladores escriben declaraciones de anidamiento en su código. Por ejemplo… escribir una sentencia if dentro de otra sentencia if o if-else dentro de otra sentencia if-else. Muchas veces se vuelve muy confuso leer y entender el código. Su aplicación se vuelve compleja y desordenada con la estructura de anidamiento de su código. 

Si encuentra que necesita escribir una declaración anidada, siga el enfoque de la cláusula de protección allí. En este enfoque, sale inmediatamente de la función con una declaración de devolución o una excepción. 

// Without a guard clause

if (accountBalance != null)
{
    if (getOrder != null)
    {
        if (getOrder != null.term == Term.Annually)
        {
            // term annually
        }
        else if (getOrder.term == Term.Monthly)
        {
            // term monthly
        }
        else
        {
            throw new InvalidEnumArgumentException(nameof(term));
        }
    }
    else
    {
        throw new ArgumentNullException(nameof(subscription));
    }
}

// With a guard clause
if (accountBalance ! == null)
{
        throw new ArgumentNullException(nameof(account));
}
if (getOrder != == null)
{
    throw new ArgumentNullException(nameof(order));
}
if (getOrder.term == Term.Annually)
{
    // term annually (return here)
}
if (getOrder.term== Term.Monthly)
{
    // term monthly (return here)
}
throw new InvalidEnumArgumentException(nameof(order.term));

3. Alejar y pensar en una imagen más grande

Cada vez que comienza a trabajar en un proyecto, debe alejar la imagen de su software. Piense en el panorama general para analizar los detalles más pequeños de su aplicación. Esto le ayudará a comprender la arquitectura de su software y sus diversos componentes.

4. Nombrar cosas en tu código

Una de las partes más difíciles del desarrollo de software es elegir un nombre relevante para cada pieza de código. Debe prestar mucha atención a los nombres de las variables, clases o métodos. Por ejemplo: si está creando un proyecto en el que está haciendo algunos cálculos para el año bisiesto, puede darle el nombre «año_bisiesto». Alguien que mirará su código definitivamente entenderá que ha hecho algo relacionado con el año bisiesto. 

Una buena convención de nomenclatura es importante para aumentar la legibilidad de su código y también reduce las líneas innecesarias de comentarios.

5. Sobrestimar

Como desarrollador, siempre debes considerar que una tarea lleva más tiempo del que esperas. Siempre sobreestime el tiempo de sus tareas cuando esté trabajando en un proyecto. Subestimar las tareas puede crear una deuda técnica en su aplicación. Tendrá tiempo para hacer que su función funcione, pero no tendrá tiempo para hacer que el código sea limpio y mantenible. 

6. Comentarios sobre la documentación y el código

Muchos desarrolladores evitan comentar el código o documentar las cosas en su aplicación. Piensan que es solo una pérdida de tiempo, pero eso no es cierto. La documentación y los comentarios ayudan mucho a comprender el papel de una parte específica de la aplicación. 

Cuando estás comentando tu código, explica por qué hiciste algo. Cuando otros desarrolladores comienzan a trabajar en él, inmediatamente entienden las funciones, los módulos o los componentes. Les resulta fácil entender su código, trabajar en él y cambiarlo.

7. Eliminar código innecesario

En el desarrollo, la mayoría de las veces los desarrolladores escriben algún código y luego comentan ese bloque masivo de comentarios solo porque tienen menos confianza al respecto. Los dejan allí pensando que en el futuro quizás tengan que usar ese código. Los grandes desarrolladores saben muy bien qué parte específica del código no es importante en el código base. El control de versiones tiene un propósito y los grandes desarrolladores confían en eliminar las partes defectuosas de la aplicación. 

8. Dedique algo de tiempo a las revisiones de código

No subestime la importancia de las revisiones de código en el desarrollo de software. Un gran desarrollador siempre pasa un buen rato revisando el código y sabe cómo puede ayudar a construir una buena aplicación. A continuación hay algunas cosas buenas sobre la revisión de código…

• Puede detectar errores antes de que generen algunos problemas importantes en el software
• Ahorrarás tiempo, mejorarás tus habilidades y aprenderás algunas buenas prácticas.
• El intercambio de conocimientos.
• El diseño y la implementación del software serán consistentes.

Para el mejor proceso de revisión de código, puede seguir algunos consejos prácticos que se detallan a continuación…

• Si tiene una tarea pequeña con menos riesgo involucrado, entonces 1 desarrollador es suficiente para revisar el código.
• Si tiene tareas medianas con más riesgo o más cambios involucrados, entre 3 y 5 desarrolladores pueden revisar el código, pero uno de ellos debe ser un desarrollador senior.
• Si está trabajando en una tarea/cambio más arriesgado, organice una reunión y comuníquese con al menos 3 desarrolladores. Además, uno de ellos debe ser un desarrollador principal que revise cada línea juntos y verifique los puntos.

9. Pruebas

Muchos desarrolladores evitan las pruebas porque consideran que es un proceso que requiere mucho tiempo, pero los buenos desarrolladores nunca huyen de las pruebas. Se toman el tiempo de escribir una buena prueba y les ayuda a escalar la aplicación con más confianza. Además, te evitas introducir muchos errores en el software.

10. Concéntrese en los fundamentos y no en la sintaxis

Esta es una de las cosas más importantes para aprender en el desarrollo de software. Los buenos desarrolladores saben que tener un buen conocimiento de los fundamentos es más importante que centrarse demasiado en la sintaxis del lenguaje. Podrás detectar los problemas de manera efectiva. 

Comprenderá mejor los problemas y el software cuando comprenda el concepto fundamental. Esto ayuda a buscar en Google sus problemas y detectar errores fácilmente en el futuro. 

11. Toma la Ayuda de Google

Buscar un problema en Google no es señal de un mal desarrollador. Es inteligente y también aumenta la productividad de un desarrollador. Los buenos desarrolladores son expertos en buscar cosas en Google y resolver problemas. Lea los consejos número 4 una vez más. Un desarrollador que tiene una buena comprensión del concepto fundamental sabe qué

No te obsesiones con aprender la sintaxis. Haga de Google su mejor amigo, concéntrese en los fundamentos y ayuda mucho a buscar en Google las cosas y obtener la solución requerida.

12. Haz que funcione y luego hazlo perfecto

Muchas veces los desarrolladores prestan demasiada atención a hacer las cosas más bonitas. Su enfoque se desplaza más hacia él en lugar de verificar si su código se está ejecutando o no. Dedican mucho tiempo a hacer las cosas perfectas y luego, cuando ejecutan su código, descubren que no funciona.

Al ser un desarrollador, cuanto más tiempo dedica a hacer que las cosas sean perfectas, más encuentra que las cosas son imperfectas en su software. Cuando esté trabajando en algunas tareas, primero concéntrese en hacer que las cosas funcionen correctamente. Una vez hecho esto, puede concentrarse en hacer las cosas perfectas. 

Este enfoque ahorra mucho tiempo y puede identificar problemas temprano antes de hacer las cosas perfectas. No tiene sentido hacer las cosas demasiado perfectas si su código o función no funciona. 

13. Haz preguntas

Los grandes desarrolladores no dudan en hacer preguntas. Hacen preguntas cada vez que no saben algo, incluso la pregunta es la más simple. Hacer preguntas no es vergonzoso para ellos. Confían en su capacidad y no se asustan al hacer preguntas. Estas preguntas pueden estar relacionadas con una pregunta técnica o comercial. 

Hacer preguntas aclara toda la confusión y es una señal de curiosidad más que de incapacidad para hacer algo. 

14. BESO (Mantenlo Simple Estúpido)

Muchos desarrolladores escriben el código complicado solo para mostrar lo inteligentes que son. Las cosas son en realidad todo lo contrario. Los grandes desarrolladores creen en hacer las cosas simples en lugar de complicadas. Escriben código simple para que otros desarrolladores puedan entenderlo, modificarlo y trabajar en él. Además, mantener las cosas simples en su código hace que su aplicación sea más legible y fácil de mantener. 

Pensamiento final

Después de leer todos los puntos anteriores, es posible que se haya dado cuenta de que el desarrollo de software no se trata solo de escribir el código y hacer que las cosas funcionen. Hay muchas cosas que recordar cuando trabaja en algunas aplicaciones. Tenga en cuenta todos los puntos clave anteriores y sígalos en su viaje de desarrollo. Seguramente progresarás en tu carrera.