Clean-Code

CLEAN CODE

1. Usa nombres con significado
2. Usa nombres fáciles de pronunciar
3. Usa nombres que puedan buscarse
4. Nombres de clases (sustantivos) y métodos o funciones (Verbos)
5. Elige una sola palabra por concepto: tarea similar = mismo nombre
6. Las funciones deben ser pequeñas
7. Haz una única cosa por función
8. No abuses de los switch/when.
9. De 0 - 3 argumentos por función.
10. Evita los "flag arguments": Boolean de true false
11. No generes "Side Effects": una función hace o devuelve algo nunca las dos.
12. No te repitas (DRY)
13. Los comentarios mienten: actualiza los comentarios.
14. Usa código autoexplicativo.
15. A veces los comentarios son necesarios
16. Los comentarios dicen qué hace el código, no cómo lo hace.
17. Diferencias entre objetos y estructuras de datos: Los objetos encapsulan datos y operaciones relacionadas, mientras que las estructuras de datos exponen sus datos y no tienen lógica asociada.
18. La Ley de Demeter.
19. Usa excepciones en lugar de código de retorno
20. Escribe primero el try-catch-finally
21. Usa excepciones unchecked.
22. No devuelvas Null

MARKDOWN

Para iniciar una nueva línea debes agregar dos espacios en blanco al final de la línea, pulsar INTRO o usar una barra invertida , según el editor que uses. Para crear un nuevo párrafo sencillamente debes dejar una línea en blanco.

GUÍA
Elemento	Sintaxis
Encabezados	# H1 - ## H2 - ### H3
Negrita	**texto** __texto__
Cursiva	*texto*
Negrita	***texto***
Citas	> cita
Listas ordenadas	1. Lista
Listas no ordenadas

• Primer elemento

• Primer elemento

• Primer elemento | | Código | `código` | | Línea horizontal | --- | | Enlaces | anchor | | Imágenes | | | Tablas | | Color | Código | | ----------- | ----------- | | Rojo | #FF0000 | | Azul | #0000FF | | Texto tachado | Texto tachado | | Listas de tareas | - [x] Primera tarea
  - [ ] Segunda tarea | | Enlaces automáticos | https://www.neoguias.com |

Documentación

Para abrir y cerrar documentación:

/**

*

/*

@author → Autor de la Función

@param → Explica los parámetros usados @return → Que devuelve la función

@see → “Ver Tambien”

@version → Version de software que se programo @property → Explica parámetros solo de clases @constructor → Explica constructor primario class @esception → Lanza ‘x’ exception y lanza ‘y’

Refactorización

La optimización y refactorización son dos prácticas importantes en el desarrollo de software que buscan mejorar la calidad, mantenibilidad y eficiencia del código.

La refactorización es el proceso de reestructurar el código existente sin cambiar su comportamiento externo para mejorar la calidad interna del código, haciéndolo más legible, comprensible, mantenible y eficiente, sin alterar su funcionalidad.

"Rename": Cambia el nombre de una variable, método, clase u otro elemento del código sin cambiar su funcionalidad.

"Change Signature": Permite cambiar los parámetros de un método, incluyendo tipos y orden.

"Introduce Variable": Crea una nueva variable y asigna el valor de una expresión para simplificar el código.

"Introduce Constant": Similar al anterior, pero para la creación de constantes.

"Property": Convierte un método getter o setter en una propiedad para un acceso más sencillo. "Introduce Parameter": Añade un nuevo parámetro a un método y lo utiliza en su cuerpo.

"Introduce Functional Parameter": Similar al anterior, pero específico para métodos lambda o expresiones lambda.

"Function...": Convierte un bloque de código en una función separada para su reutilización.

"Function to Scope...": Transforma un método en una función anónima o expresión lambda asignada a una variable.

"Type Parameter...": Convierte un tipo de variable en un parámetro de tipo genérico para mayor flexibilidad.

"Type Alias...": Crea un alias para un tipo de variable o genérico.

"Extract Interface...": Extrae métodos de una clase para formar una interfaz y organizar el código.

"Extract Superclass...": Combina atributos y métodos de dos o más clases en una superclase para evitar duplicación de código.

"Move Instance Variable to Another Class...": Transfiere un atributo de instancia de una clase a otra relacionada.

"Move Static Method to Another Class...": Mueve un método estático de una clase a otra relacionada.

"Change Class Signature...": Modifica atributos y métodos de una clase, incluyendo tipos y modificadores de acceso.

"Encapsulate Fields...": Crea métodos getter y setter para los atributos de una clase. "Change Visibility Modifier...": Altera el modificador de acceso de un método o atributo.

"Introduce Polymorphic Call...": Reemplaza una llamada a un método concreto por una llamada a un método polimórfico.

"Inline Local Variable...": Elimina una variable local y reemplaza sus referencias por el valor asignado.

"Replace Type Code with Class...": Sustituye un tipo de variable codificado con clases.

"Move to Subclass...": Mueve un método o grupo de métodos de una clase a una de sus subclases.

"Pull Up...": Traslada un método o atributo de una subclase a su superclase.

"Introduce Indirection...": Introduce un nivel de indirección en el acceso a un método o atributo.

La Optimización es el proceso de mejorar el rendimiento de un programa o sistema. Puede abordar aspectos como el tiempo de ejecución, la eficiencia del uso de memoria o la velocidad de respuesta.

• Algoritmos eficientes: Escoger estructuras de datos y algoritmos óptimos.\
  • Optimización de bucles y operaciones: Evitar bucles innecesarios y usar operaciones eficientes.
    • Uso eficiente de memoria: Minimizar el uso y evitar fugas.
      • Índices y estructuras de datos específicas: Aprovechar índices y estructuras adecuadas.
        • Eliminación de código redundante: Revisar y eliminar código innecesario.
          • Optimización de carga de módulos/bibliotecas: Cargar solo lo necesario.
            • Compilación y flags de optimización: Utilizar opciones de compilación y flags adecuados.

pr incipios S.O.L.I.D.

Los principios SOLID son un conjunto de cinco principios de diseño de software que promueven la creación de código modular, flexible y mantenible.

S - Principio de Responsabilidad Única (Single Responsibility Principle):

Una clase debe tener solo una razón para cambiar, es decir, debe tener una única responsabilidad.

O - Principio de Abierto/Cerrado (Open/Closed Principle):

Las entidades de software (clases, módulos, funciones, etc.) deben ser abiertas para la extensión pero cerradas para la modificación.

L - Principio de Sustitución de Liskov (Liskov Substitution Principle):

Los objetos de una superclase deben ser sustituibles por objetos de sus subclases sin afectar la corrección del programa.

I - Principio de Segregación de Interfaces (Interface Segregation Principle):

Un cliente no debe verse obligado a depender de interfaces que no utiliza. En otras palabras, los clientes no deben verse afectados por interfaces que no necesitan.

D - Principio de Inversión de Dependencias (Dependency Inversion Principle):

Las dependencias deben estar dirigidas hacia abstracciones, no hacia implementaciones. Los módulos de alto nivel no deben depender de módulos de bajo nivel; ambos deben depender de abstracciones.

GRADLE

JAR

1. Creamos un nuevo proyecto seleccionando kotlin-Gradle-kotlin.
2. Entramos en build.gradle.κts.
3. All final introducimos el siguiente código:

tasks.jar {

manifest {

attributes["Main-Class"] = "MainKt"

}

configurations ["compileClasspath"].forEach { file: File ->

from (zipTree (file.absoluteFile) )

}

duplicatesStrategy = DuplicatesStrategy.INCLUDE

}

4. Descargamos Gradle
5. A la izquierda build-tmp-jar podemos ver como se creo jas.
6. A la derecha gradle-Tasks-build-jar ejecutamos el jar.

DOKKA

3. Escribimos en plugins, debajo de applications

id ("org.jetbrains.dokka") version "1.9.10"

5. A la izquierda build-dokka podemos ver cano se creo ex dokka
6. A la derecha gradle - Tasks - documentarion - dokkaHml cargamos el dokka