Principio KISS

**KISS **

• Keep It Simple Stupid
• Keep It Short and Simple(forma elegante).

KISS

KISS: es un acrónimo de Keep It Simple Stupid o Keep It Short and Simple y a rasgos generales se puede traducir como Mantenlo simple!.

Este principio establece que la mayoría de sistemas funcionan mejor si se mantienen simples o sencillos a diferencia de aquellos que se hacen complejos de manera innecesaria. Es decir, que desde el incio del proyecto la sencillez tiene que ser una meta en el desarrollo y que la complejidad innecesaria debe ser eliminada cada vez que sea detectada. Muchas veces esta complejidad ocurre cuando se diseñan grandes soluciones para objetivos simples.

Tratemos de utilizar la mejor solución dependiendo de la complejidad de lo que estemos trabajando. Cuando algo es muy complejo o muy grande, es recomendable buscar soluciones más complejas o avanzadas que se ajusten, pero si algo es más simple, pequeño o sencillo, lo ideal es darle una solución acorde a sus características.

Es bueno tener presente que:

Si ya no comprendes tu propio código después de un breve período de tiempo, las campanas de alarma deberían sonar. Porque cuanto más complicado es o se presenta, más difícil es para todos los involucrados trabajar con él.

Algunos ejemplos de complejidad innecesaria son:

• Incluir bibliotecas enormes en el proyecto cuando solo se necesitan un par de funciones de ellas.
• Abstracción excesiva en el código.
• Funciones que resultan enormes por por la lógica que contienen.
• Anidación de condicionales que solo cumplen una función.

Utilizar en el ForEach para recorrer el TaskList; se esta usando una variable de nombre p; pero esto se podria mejorar su nombramiento como task

public static void ShowTaskList()
        {
            var indexTask = 1;
            Console.WriteLine("----------------------------------------");
            TaskList.ForEach(task => Console.WriteLine((indexTask++) + ". " + task ));
            Console.WriteLine("----------------------------------------");
        }

No estoy completamente de acuerdo con la refactorización del for. Aún así me parece mucho mejor que como estaba.

La razón es que no me da buena espina el código imperativo como el operador ++ o la función WriteLine dentro de una función anonima que es usada dentro de otra función. Esto porque rompe con el esquema de las funciones puras.

Sin embargo creo es una especie de code smell personal, no tiene que ser necesariamente siempre así, siempre hay que juzgar por la situación.

Yo con tal de evitar mezclar funcional e imperativo llegué a esto:

foreach (var (task, i) in taskList.WithIndex())
{
    Console.WriteLine($"{i + 1}. {task}");
}

Y claro, primero es más largo, y segundo tuve que poner más abajo otro pedazo de código que encontré en internet para definir WithIndex, por lo que no necesariamente mi solución es mejor pero quería compartir esto por si a alguien le parece interesante y encuentra más del tema.

Esa frase es poética

“No debemos usar una bazuka para matar una mosca” que excelente.

Eliminé los Console.WriteLine por un forEach

 List<string> MenuOptionsList=new List<string>{"----------------------------------------","Ingrese la opción a realizar:","1. Nueva tarea","2. Remover tarea","3. Tareas pendientes","4. Salir"};
            MenuOptionsList.ForEach(menuOption=>Console.WriteLine(menuOption));

yo al empezar la clase: “vamos, dilo, dilooo”

Tasks.ForEach((task) =>
 {
	Console.WriteLine($"{Tasks.IndexOf(task) + 1} .  {task}");
});

todo esta perfecto en el curso, pero creo que fue una mala idea no haberlo hecho en visual studio, por que las personas que llegan a este curso normalmente estan usando IDE para programar, la mayoria que podemos pagar la plataforma tenemos una computadora que sin problema corre visual studio exagero de mas profe, pero pues ya que a darle

Algunas consideraciones sobre Linq que nos pueden ayudar en un futuro:

https://medium.com/swlh/is-using-linq-in-c-bad-for-performance-318a1e71a732

https://markheath.net/post/linq-performance#:~:text=It is slightly slower&text=LINQ syntax is typically less,like BenchmarkDotNet to do so.

Es bueno aprender desde cero

using System;
using System.Collections.Generic;

namespace ToDo
{
    internal class Program
    {
        private static List<string> taskList { get; set; }

        public static List<string> GetTaskList()
        {
            return taskList;
        }

        public static void SetTaskList(List<string> value)
        {
            taskList = value;
        }

        // Función para mostrar la lista de tareas
        public static void ShowTaskList()
        {
            Console.WriteLine("----------------------------------------");
            //Mejorar en una linea de codigo para compilar un codigo
            var taskIndex = 1;
            GetTaskList().ForEach(task => Console.WriteLine(taskIndex++ + ". " + task));
            Console.WriteLine("----------------------------------------");
        }

        static void Main(string[] args)
        {
            SetTaskList(new List<string>());
            int menuSelected = 0;
            do
            {
                menuSelected = ShowMainMenu();
                if ((Menu)menuSelected == Menu.add)
                {
                    ShowMenuAdd();
                }
                else if ((Menu)menuSelected == Menu.remove)
                {
                    ShowMenuRemove();
                }
                else if ((Menu)menuSelected == Menu.List)
                {
                    ShowTaskList();  // Llamada al método ShowTaskList en lugar de ShowMenuTaskList
                }
            } while ((Menu)menuSelected != Menu.Exit);
        }

        public static int ShowMainMenu()
        {
            List<string> MenuOptionsList = new List<string> { "----------------------------------------", "Ingrese la opción a realizar:", "1. Nueva tarea", "2. Remover tarea", "3. Tareas pendientes", "4. Salir", "----------------------------------------" };
            MenuOptionsList.ForEach(menuOption => Console.WriteLine(menuOption));
            string taskIndex = Console.ReadLine();
            Console.WriteLine("----------------------------------------");
            return Convert.ToInt32(taskIndex);

        }

        public static void ShowMenuRemove()
        {
            try
            {
                Console.WriteLine("Ingrese el número de la tarea a remover: ");
                //Llamo a la funcion de la lista
                ShowTaskList();
                string taskIndex = Console.ReadLine();
                // Remove one position
                int indexToRemove = Convert.ToInt32(taskIndex) - 1;
                if (indexToRemove > -1 && GetTaskList().Count > 0)
                {
                    string taskToRemove = GetTaskList()     [indexToRemove];
                    GetTaskList().RemoveAt(indexToRemove);
                    Console.WriteLine("Tarea " + taskToRemove + " eliminada");
                }
            }
            catch (Exception)
            {
            }
        }

        public static void ShowMenuAdd()
        {
            try
            {
                Console.WriteLine("Ingrese el nombre de la tarea: ");
                string task = Console.ReadLine();
                GetTaskList().Add(task);
                Console.WriteLine("----------------------------------------", "Tarea registrada");
            }
            catch (Exception)
            {
            }
        }

        public static void ShowMenuTaskList()
        {
            if (GetTaskList() == null || GetTaskList().Count == 0)
            {
                Console.WriteLine("No hay tareas por realizar");
            }
            else
            {
                ShowTaskList();
            }
        }
    }

    public enum Menu
    {
        add = 1,
        remove = 2,
        List = 3,
        Exit = 4
    }
}

 private static void ShowMenuOptions()
        {
            TaskList.ForEach(p => Console.WriteLine(p.IndexOf(p) + 1 + ". " + p));
            Console.WriteLine("----------------------------------------");
        }

Sobre Arquitectura: es cuando diseñamos nuestra aplicacion demasiado compleja para algo que es demasiado simple

En este ejemplo no estamos usando LinQ