40. C# 6.0 (III) - Dictionary Initializers

Un diccionario es una estructura de datos de gran utilidad, esta estructura representa una colección de datos, en la que se tiene una relación de clave y valor (key,value), la característica principal es que la clave debe ser única, mientras que el valor no necesita serlo.

El objeto es realmente cercano a un diccionario físico, en el que tenemos una palabra con su definición.

Ademas de esto el diccionario es una clase genérica que nos permite asignarle prácticamente cualquier objeto creando una relación entre ellos.

C# 6.0 trae consigo una nueva forma de declarar un diccionario, esta nueva forma logra que su uso sea mas claro, al momento de efectuar la asignación de cada uno de los valores del par de datos que lo componen.

Con un poco de código:

En el código tenemos la definición de 2 diccionarios uno entero cadena y uno cadena cadena, como podemos ver la asignación de la clave valor,. se maneja de manera directa, mostrando una codificación limpia y clara.

Si ejecutamos el programa, obtenemos la salida de los valores solicitados, como se muestra a continuación

Saludos

39. C# 6.0 (II) - Property Initializers

Una de las nuevas características de C# 6.0 es la inicialización automática de propiedades, esta es una característica, que no va a mejorar ni el desempeño ni el uso de recursos de nuestra aplicación, lo que mejora es la legibilidad del código.

Esta característica nos permite definir una propiedad e inicializarla en ese mismo instante.

Como es esto, muy sencillo veamos el siguiente fragmento de código:

Como podemos ver, las propiedades podemos inicializarlas directamente, y dejar que el compilador se encargue de generar el código necesario para hacer este proceso.

Hasta la proxima

38. C# 6.0 (I) – Interpolated Strings

Esta es una de las nuevas funcionalidades de C# 6.0, es una funcionalidad que es muy útil porque busca crear cada vez un código más entendible.

Su uso no repercutirá en mejores tiempos de proceso, o en menor o mayor uso de recursos, ya que nos está ofreciendo es la posibilidad de intercalar variables en una cadena y que el compilador por si solo complemente el código necesario para hacer esto.

Con esta función eliminamos los caracteres extra para concatenar cadenas, creado la cadena desde su origen en una forma limpia, el compilador llamara automáticamente a toString(), del objeto que estemos concatenando y será con el que sustituirá la cadena.

Bueno menos letras y más código, veamos un ejemplo.

Que obtendría de salida al ejecutar el código anterior:

De esto podemos observar que se nos está presentando una manera más legible para lograr concatenar cadenas.

El signo $ es el que le indica al compilador que en la siguiente sentencia se usara la interoperabilidad de cadenas.

Bueno esto solo es una ayuda para que el código se vuelva más legible, pero no se queda hasta ahí.

Esto nos permite también generar tomas de decisiones dentro de la cadena, veamos el siguiente código:

Este es un ejemplo muy interesante, evaluó la variable Amigo, como mi variable amigo es falsa, me debe escribir lo que se encuentre en la cadena adiós.

Al compilar y ejecutar, obtengo lo siguiente:

Otra característica, es que se puede dar formato a las cadenas de una manera más sencilla y legible, tal y como se muestra en este fragmento de código:

Al consultar los datos del objeto, estos son reemplazados en la cadena

Esta nueva característica solo busca facilitarnos las cosas como desarrolladores, para que el software que construyamos pueda ser mantenido más fácilmente.

O una clase, mientras sea un objeto que tenga implementado la función toString, usar la interoperabilidad de cadenas es posible, veamos el siguiente código:

Con el signo: puedo establecer un formato a la cadena, lo que me permite que esta se defina de una forma mucho más sencilla.

Al ejecutar el proceso:

Es importante resaltar que esta funcionalidad se encuentra a partir del .net 4.6.

Felices líneas

Carlos

________________________________________________
"Una vez un ordenador me venció jugando al ajedrez, pero no me opuso resistencia cuando pasamos al kick boxing".
-- Emo Philips

37. Concatenar archivos (Ayuda Rápida VII)

Muchas veces durante el trabajo diario es necesario concatenar grandes cantidades de archivos, desde el sistema operativo teniendo 2 o mas archivos en una carpeta

Empleamos la instrucción type y agregamos la salida de un archivo al final de otro

type x.txt >> y.txt

con >> indicamos que los archivos se concatenaran, si empleamos únicamente > un archivo sobrescribirá a otro.

Bien esto nos soluciona el problema de manera manual. ¿Pero que pasa si lo queremos hacer desde C#? invocar un proceso externo siempre es costoso.

Para ello usaremos la instrucción CopyTo de FileStream, esta instrucción nos permite copiar el contenido de un archivo a otro de una manera muy rápida y sencilla.

El código queda como se muestra a continuación:

Que hace el código, bueno el código de copiado de un archivo a otro se resume en la siguiente linea:

                    using (FileStream strFuente = File.OpenRead(Archivo))

                        strFuente.CopyTo(strArchivo);

en donde abre el archivo y copia su contenido.

felices lineas

36. Patrones de Diseño (IV) - Proxy

Este blog inicio con la idea de construir un código ordenado, de hacer que nuestro código tuviera una mayor calidad, y hacer que el mantenimiento del mismo fuera menos costoso, nació porque hay muchas habilidades que debe tener un arquitecto antes de poder modelar una arquitectura de un sistema.

La sección de patrones de diseño se creó para brindar herramientas para evitar ese código salvaje, la sección sigue vigente, pero el blog ha crecido y junto con él se han incorporado nuevas secciones.

Pero hoy retomaremos los patrones de diseño, vamos a hablar de un patrón, que es muy sencillo porque su uso es muy común, tan común que mucha gente que no es desarrolladora, entiende el concepto o lo han usado principalmente para conectarse a internet, me refiero al patrón Proxy.

¿Qué hace el patrón proxy?, El patrón proxy juega como un intermediario que permite la creación y acceso de un objeto a otros, es decir me sirve como un puente entre objetos, su aplicación más común es el uso de proxies en internet, para acceder a paginas o para limitar el tráfico a las mismas.

Tratemos de ilustrar el patrón:

Contamos con una interfaz en la que se definen las tareas que se realizaran, esta interfaz se encuentra implementada tanto en el Proxy como en el objeto real.

El cliente consumirá la interfaz, de esta forma el Proxy se podrá agregar como intermediario sin necesidad de efectuar modificaciones en nuestro cliente.

Cuando el cliente efectué una llamada, nuestro cliente primero ira al proxy, en donde se puede agregar funcionalidad, después de eso el proceso se ira al objeto real.

Existen muchos tipos de proxy, entre los más comunes se puede mencionar:

Proxies Virtuales: Manejan la creación de objetos, en muchos casos hay objetos que requieren un tiempo muy elevado para su creación, este tipo de proxies pueden asumir la identidad del objeto como si ya estuviera creado, en lo que el verdadero objeto se genera.

Como es esto, el proxie invoca un objeto, el proxie en este caso es un objeto ligero pero que ya tiene las características del mismo, mientras el proxie crea el verdadero objeto, el proxie actúa como el objeto que se está creando, mostrando propiedades de manera preliminar.

Imaginen una clase de dibujo compleja con la que ya se puede interactuar, pero que varios de sus componentes se muestran con barras de carga, el proxy la clase compleja, que está construyendo los objetos que están en él.

Y como se crea, se construyen los métodos para tener las firmas, pero los datos se cargan conforme se está usando el objeto, estos datos se cargan en un segundo objeto, el objeto real.

Proxies de Autenticación: Muy comunes, su labor es establecer los permisos de acceso a un objeto.

El proxie tiene las mismas firmas que el objeto que se desea controlar, sin embargo analiza el acceso al mismo objeto, y si este no cumple con cierta característica no permite el acceso al mismo.

Proxie remoto: permite enviar información a través de la red comportándose como un objeto local, cuando se implementa el proxy efectúa las tareas de comunicación.

Proxie Inteligente: Puede efectuar cambios en el mensaje con condiciones específicas, por ejemplo una codificación, agregar atributos etc.

Como pueden ver es un objeto muy sencillo porque su función es solo servir de intermediario de mensajes pero que es muy útil en aplicaciones en el mundo real.

Hasta la próxima

35. Buen Software

Mucho se ha hablado de 4 grandes características que debe tener todo software:

·         Mantenibilidad

·         Confiabilidad

·         Eficiencia

·         Usabilidad

Son características que todo arquitecto debe tener en mente al momento de diseñar una solución, vamos a repasarlas un poco.

Ya habíamos hablado de usabilidad en usabilidad estableciendo los 10 principios que menciona Jakob Nielsen

·         Visibilidad del estado del sistema

·         Relación entre el sistema y el mundo real

·         Control y libertad del usuario

·         Consistencia y estándares

·         Prevención de errores

·         Reconocimiento antes que recuerdo

·         Flexibilidad y eficiencia de uso

·         Estética y diseño minimalista

·         Ayuda a los usuarios a reconocer

·         Ayuda y documentación

Mantenernos dentro de estos nos da un gran paso, confianza al usuario, el sistema se convierte en algo que él entiende y que facilitara su trabajo, que es nuestra principal misión.

Eficiencia: Este es otro tema que hemos tocado en este blog, http://carlosamonroy.blogspot.mx/2015/06/mi-codigo-puede-volar.html , que quiere decir usar correctamente los recursos del sistema, hacer consultas rápida, administrar correctamente la memoria, optimizar código, en la actualidad hemos perdido mucho esa capacidad de optimización debido a que al tener hardware cada vez más robusto, dejamos mucho de este trabajo al hardware, desperdiciando una gran cantidad de recursos, el no optimizar nuestro software para lograr la máxima eficiencia, cobra su factura cuando este crece, cuando este sale de un ambiente controlado y empieza a consumir recursos que son por mucho superiores a los que esperamos.

No debemos depender del hardware, debemos buscar siempre hacer las cosas de una manera eficiente, en muchos casos esto ocurre al depender de muchos componentes de terceros, o de componentes que mejoran la interfaz gráfica, estos componentes llegan a ser muy pesados, componentes que en una primera impresión son buenos, peor que causan una gran molestia al enfrentarse a problemas reales.

Confiabilidad: característica de oro, el software debe ser confiable, esto se traduce en que debe hacer correctamente su trabajo todo el tiempo, que debe tener buenas prácticas de seguridad, la información es un bien y es uno de los bienes más valiosos, si el software no es confiable, puede causar resultados que van más allá de una falla en el sistema, un quiebra de una empresa, la muerte de 28 soldados que fue consecuencia de un error en un misil Patriot http://sydney.edu.au/engineering/it/~alum/patriot_bug.html

Mantenibilidad: Todo evoluciona, es necesario adaptarnos al cambio, el software debe nacer para que este pueda evolucionar fácilmente, vivimos en una industria que se mueve a una gran velocidad, los cambios se dan de un día a otro, el tener o no una ventaja competitiva depende de tomar las oportunidades cuando estas aparezcan, que la evolución del software se pueda dar, de una manera en que se puedan satisfacer rápidamente las necesidades del usuario

Hasta la próxima

34. Nuestra Historia (IV) - Kenneth Thompson

Grandes mentes han pavimentado el camino que hoy recorremos, la vez pasada mencionamos a un grande Dennis Ritchie, pero no se puede hablar de Dennis Ritchie sin mencionar a Kenneth Thompson, un científico que también creo las bases de lo que hoy en día tenemos.

Nace en el 4 de Febrero de 1943, egresado de la universidad de California, con un grado de maestría en la universidad de Berkeley.

Premio Turing en 1983 junto con Dennis Richie, creo el lenguaje B precursor directo del lenguaje C, es el creador del sistema operativo UNIX, ha trabajado en google y es co-creador del lenguaje GO.

Cosas que usamos muy comúnmente hoy en día no serían posibles sin él, el desarrollo la codificación UTF-8 junto con Rob Pike, fue de los precursores de las expresiones regulares e implemento varios procesadores de texto que hacen uso de ellas, introdujo las pipes en los sistemas operativos.

Trabajo en los míticos laboratorios Bell, en donde hizo mancuerna con Dennis Ritchie.

Él ha vivido la época de los grandes cambios en esta revolución de la informática, sin el mucho de lo que hoy tenemos no sería posible.

Su lectura de participación al recibir el premio Turing, es especialmente divertida, ya que habla de implantar un virus desde el mismo compilador, les recomiendo su lectura.

Lectura premio turing

33. Distinct en una lista C# (Ayuda Rápida VI)

Hoy toquemos un tema dentro de la categoría ayuda rápida, que es común a la hora de desarrollar, ¿Como obtengo los elementos diferentes que existen en una lista?

Por ejemplo:

Si tuviera la siguiente clase:

Como determino los tipos de animales

Mamífero, Pez, Ave.

La solución es muy sencilla, se emplea la estructura select de la lista, y se indice que seleccione el tipo y todos los que sean distintos.

Que tengo en este código, tengo 2 forma de hacer esta misma operación.

Animales.Select(c=>c.Tipo) ... Me permite decir que es lo que voy a seleccionar, esto haciendo un select sobre mi lista.

Si incluyo el modificador AsParallel, le indico al sistema que el select lo haga en paralelo, esto tendrá una mejora en el tiempo en que se recorre la lista.

Y finalmente la instrucción Distinct, me permite agrupar por el elemento que seleccione.

Cuando usar AsParallel y cuando no, depende principalmente de los recursos disponibles en el equipo, AsParallel sera mas rápido, pero con mayor consumo en el procesador.

En ambos casos la salida es:

Hasta la proxima

32. Build 2016

La tecnología avanza día a día, y es muy importante conocer los nuevos retos y conocer las nuevas herramientas que tenemos para poderla usar a nuestro beneficio.

Microsoft anuncia el día de hoy la fecha del Build 2016, el máximo evento de esa empresa para los desarrolladores.

El evento sea en San Francisco del 30 de Marzo al 1 de Abril, no importa que no puedan asistir en forma presencial, este evento se trasmite en tiempo real por diversos canales, les dejo la pagina de dicho evento.

Build 2016

Felices lineas

31. Ciclo de vida de Internet Explorer

Como desarrolladores, debemos conocer la tecnología y así como debemos de saber cuando hay alguna novedad en nuestro ámbito, también debemos de saber cuando un producto cierra su ciclo de vida, debemos estar preparados para ello, por que estos cambios siempre traen consigo mantenimientos que es mejor hacerlos programados y con tiempo a bajo una contingencia.

Ante esto hay 2 notas muy importantes:

1. El soporte y las actualizaciones de Internet Explorer cambiara y solo se dará soporte a la versión mas reciente del mismo partir del 12 de Enero de 2016, si bien esto se sabia desde 2014 es importante recordarlo por la cercania de las fechas para mayor información revisen: https://support.microsoft.com/es-mx/gp/microsoft-internet-explorer , esto nos deja con lo siguiente: Windows 7,  Windows 8.1 y Windows 10 unicamente tendra soporte Internet Explorer 11, Windows Vista únicamente tendrá soporte Internet Explorer 9
2. .Net Framework 4.6.1 se encuentra ya disponible.NET 4.6.1 , siempre es conveniente tener las ultimas verciones del Framework para los que trabajamos en .Net, esto por que tienen optimizaciones, correccion de errores y parches de seguridad.

Felices lineas

30. Usabilidad

Como técnicos perdemos rápidamente la vista del usuario, a veces pensamos que el sistema debe tener un comportamiento y que el usuario se debe adaptar al sistema.

No debemos perder algo de vista que es muy importante en nuestro trabajo, nos debemos al usuario, somos por el usuario, nuestra principal función es hacer que cualquier actividad sea más rápida y sencilla.

Sea análisis de información, sea automatizar un proceso, o una acceso a una base de datos, todas estas tareas siempre deben ser más fáciles de hacer para el usuario que lo que eran antes de que el sistema se implemente.

Debemos hablar su idioma, acercarnos a él para saber que quiere que busca y darle algo de acuerdo a sus necesidades.

Un error muy común es implementar algo, porque sabemos que es bueno o porque lo conocemos y olvidarnos del como el usuario hace sus actividades en el día a día, muchos de los sistemas impuestos, se convierten en un fracaso, porque la imposición genera resistencia.

Si yo obligo a alguien a hacer algo así este sea el mejor sistema lo va a rechazar de manera automática, lo mejor es buscar que la aceptación sede de manera natural.

Me preguntaran ¿Y cómo logro esto? Hay varias formas, la mejor es observar al usuario para determinar sus necesidades, si yo le pregunto al usuario ¿Qué necesitas? Muchas veces no lo sabe, y ¿Por qué no lo sabe? Porque con los medios con los que dispone en la actualidad ya están cubiertas sus necesidades, puede pedir más cosas, pero siempre es mejor involucrarse con las actividades para detectar los puntos de mejora, y buscar que estos se acepten de manera natural.

¿Pero cómo logro que el usuario se sienta cómodo con mi sistema? Jakob Nielsen es uno de los grandes gurús de la usabilidad, él ha establecido 10 principios que deberíamos considerar en todo sistema, estos principios ayudan a que el usuario se sienta cómodo y seguro dentro del sistema, sus principios son:

1.       Visibilidad del estado del sistema: en este punto normalmente fallamos, olvidamos informar que ocurre en el sistema y dejamos que este opere por sí solo, si bien esto es eficiente, hace que el usuario se desespere, no sabe que está pasando, peor aún puede pensar que está generando errores, que se trabo, el no informar el estado del sistema trae como consecuencia frustración, y como consecuencia nuestro sistema no será exitoso.

2.       Relación entre el sistema y el mundo real: Es muy importante tener el mismo vocabulario, que el sistema hable el vocabulario del usuario en sus términos y conceptos, que todo esté acorde a lo que el usuario conozca, y que el sistema no se convierta en tener un ente que requiera un traductor para su operación.

3.       Control y libertad del usuario: Funciones de deshacer y rehacer, que pasa si el usuario entro a una función a la que no quería por error, su proceso para salir de ella debe ser sencillo, no debería perderse en un mundo de menús, para deshacer un error.

4.       Consistencia y estándares: ¿Cuáles son los estándares del usuario? El debería entender el sistema por que el sistema habla su idioma.

5.       Prevención de errores: Un error común prevenir errores es enviar mensajes de error, esto no es la prevención de errores, un mensaje de error debe ser nuestra última opción, en muchos casos los sistema envían mensajes de error cuando ya no se puede hacer nada, y el proceso para recuperarse de ellos es largo y costoso, los sistemas deben tener un control de errores, para evitarlos, que no sea enviar un mensaje de error.

6.       Reconocimiento antes que recuerdo: El usuario no debe saberse los procesos de memoria, si se depende de la memoria para que estos se ejecuten en un orden correcto, es probable que se induzca error por parte de la misma operación del sistema, el usuario debería reconocer los pasos y actividades a realizar, y estos deben ser accesibles para el usuario todo el tiempo.

7.       Flexibilidad y eficiencia de uso: Hay varios tipos de usuarios, avanzados y básicos se debe brindar al usuario avanzado aceleradores y métodos para que este pueda mejorar la eficiencia de su trabajo, por dar un ejemplo de esto tenemos las combinaciones de teclas.

8.       Estética y diseño minimalista: Cada unidad extra de información irrelevante compite con la información relevante, se debe brindar únicamente la información importante, para que el usuario pueda interpretarla y entenderla.

9.       Ayuda a los usuarios a reconocer: Otro punto muy importante, que en la mayoría de los sistemas no se hace, cuando ocurre un error este se debe presentar en un lenguaje claro y simple, que indique el problema en forma precisa y ayude a construir su solución. El mensaje muy típico en los sistemas “Error fatal, consulte a su administrador del sistema” no es un error que cumpla con estas características, y menos cuando dicho error le da al administrador del sistema.

10.   Ayuda y documentación: Mas vale la más pálida tinta que la más brillante memoria, hoy conocemos el sistema pero que tan en 5 años cuando lo volvemos a ver, lo que para unos es lógico para otros no lo será, debemos dejar de pensar que un sistema se puede emplear con sentido común, dicen que el sentido común es el menos común de todos los sentidos, por esto hay que documentar, crear ayudas ¿Cómo trabaja?, ¿Cuáles son las reglas de negocio?  ¿Cómo se configura?, si soy un nuevo usuario ¿Cómo voy a usar el sistema?, cometemos un error muy grave aquí los desarrolladores, decimos es que el usuario no lee, si no lee los manuales para que los hago, no es lo mismo el que no los lea, pero que en caso de una duda pueda recurrir a ellos, a que en caso de una duda no exista nada a donde recurrir.

Bueno me despido por hoy, felices líneas

Carlos

29. Obtener la diferencia de tiempo entre 2 fechas (Ayuda Rápida V)

El obtener la diferencia que existe entre 2 fechas dadas es un tema muy útil sobre todo en la creación de reportes, para poder obtener la diferencia de tiempo que existe entre una fecha y otra es necesario usar un objeto llamado TimeSpan, este representa un intervalo de tiempo.

Para su uso simplemente restamos las 2 fechas con las que queremos trabajar y su resultado lo almacenamos en este objeto.

TimeSpan ts = HoraActual - HoraCreacion;

Una vez hecho eso, podemos saber cuandos días, horas, minutos, segundos existen entre una fecha y otra.

 int Dias = ts.Days;
 int Horas = ts.Hours;
 int Minutos = ts.Minutes;
 int Segundos = ts.Seconds;

Nos vemos en las próximas lineas.

28. Nuestra historia (III) - Dennis Ritchie

Tal y como lo prometí, mencionare, a los grandes, a los que nos han hecho llegar, si bien en este caso podemos hablar de una pareja de científicos que crearon las bases de la computación moderna, en este escrito me enfocare a uno de ellos, uno que ha dejado este mundo pero que se puede decir que fue de aquellas personas que su existencia estaba destinada a cambiarlo, a mejorarlo.

Dennis Ritchie, ¿Qué hizo?, pues el sembró la semilla de todo lo que tenemos hoy en día, ya que es el creador de uno de los lenguajes más populares  que han existido, un lenguaje que además es base para otros lenguajes, el lenguaje de programación C, además de ser creador del sistema operativo UNIX, siendo este sistema operativo la base de todo lo que hoy conocemos.

Nace el 9 de Septiembre de 1941, graduado de la universidad de Harvard, trabajo en los Laboratorios Bell de AT&T.

Fue un pionero de la informática moderna, y fue reconocido con el premio Turing en 1983 por su desarrollo en la teoría de sistemas operativos genéricos y su implementación en la forma del sistema UNIX.

Murió el 12 de Octubre de 2011, él es uno de los más grandes científicos del siglo XX, y un responsable de la revolución tecnológica que tenemos hoy en día, el maestro que creo las primeras piezas con las que construimos el universo de cómputo.

Dennis Ritchie, tiene un puesto muy especial dentro de la historia de la humanidad.

Felices líneas.

27. Parpadeo en DataGridView (Ayuda Rápida IV)

Un problema muy común al momento de usar un DataGridView dentro de un winForm es el molesto parpadeo que se da cada vez que se cargan los datos, esto ocurre sobre todo en casos en que la información que se encuentra en la tabla se encuentra actualizándose de manera continua.

La solución a este problema es muy sencilla, y analizando el código parecería que nosotros causaríamos parpadeo al implementar esta solución pero esto no es cierto, lo que se debe hace es ocultar el DataGridView, cargar este elemento con la nueva información y volverlo a mostrar.

Al cargar el control sin que este se muestre, la carga de sus columnas es muy rápida, por lo que el parpadeo que provocamos al ocultarlo y mostrar el control se vuelve imperceptible, eliminando de esta forma el molesto parpadeo que se da en este tipo de controles.

 dgVisor.Hide();
 dgVisor.DataSource = [Datos];
 dgVisor.Refresh();
 dgVisor.Show();


Felices lineas

26. Nuestra Historia (II) - Ada Lovelance

Tenemos una historia rica que nos ha forjado y convertido en lo que somos, no quiero marearlos una historia muy larga, pero si quiero que sepamos algo más de historia, ya que IT se ha convertido en un área que desconoce en gran medida sus orígenes.

Este Blog es de programación, y siendo así la primer personalidad de la que hablaremos, es de la primer programadora Ada Lovelance, que vivió en el siglo XIX, en una época en que la computadora como la conocemos ni siquiera era un boceto.

En que trabajo, ella empleo la Maquina Analítica de Babbage, y con ella escribió lo que sería el primer algoritmo de la historia, un algoritmo para calcular los números de Bernoulli.

Sugirió el uso de las tarjetas perforadas como método de entrada

Tuvo visión para ver que esa máquina con la que trabajaba podía hacer mucho más, se le reconoce como la primera persona en describir un lenguaje de programación de carácter general, se puede decir que es la madre de la Programación.

Por eso ella es realmente una de las bases de nuestra Historia, no quiero marearlos con más datos, pero lean un poco sobre ella, y nuestros orígenes.

Felices líneas

25. Nuestra historia (I)

Cada ciencia conoce su historia, creo que solo nosotros no, es decepcionante ver que muy poca gente de TI tenga idea de quienes son los grandes personajes que han dado valor a la industria, que han hecho descubrimientos que nos han permitido llegar a lo que es hoy en día.

Cuando se habla de otras áreas, la gente conoce a sus predecesores, me temo que en TI no los conocemos, sabemos como arreglar un equipo, como hacer un programa, recordamos de nuestras clases que existen generaciones de computadoras, pero la cultura en nuestra área es algo realmente bajo.

Demasiado técnicos para pensar en otra cosa.

Las novedades tecnologías las da la industria, todos saben que surgió un Windows 10, que Apple saco un nuevo dispositivo, que Oracle tiene una nueva base de datos, que hay un nuevo procesador, pero nos olvidamos del quien.

El área se encuentra muy deshumanizada, todos sabemos quien es Steve Jobs y Bill Gates, pero nos olvidamos de todos aquellos que han hecho algún aporte a el área y que nos han llevado a donde estamos.

Peor aun hay quienes escuchan Premios Turing y no saben que es eso, siendo que es el mayor galardón que se puede obtener en ciencias de la computación, un premio al que se le ha llamado el Nobel de la computación.

El premio Turing lo entrega ACM (Association for Computing Machinery)desde 1966 en New York y año con año reconoce a aquellos que han hecho grandes aportaciones a la industria.

Revisaremos en futuros post de Nuestra historia a cada uno de los premiados por eso mismo omito la lista de ellos en este momento, dejando en el aire lo siguiente, sin las contribuciones de este grupo, muchas de las cosas que haces habitualmente no serian posibles, ellos son los verdaderos forjadores de lo que hoy tenemos, los verdaderos revolucionarios, que entendieron el valor de la información.

Felices lineas

24. FileSystemWatcher (Ayuda Rápida III)

FileSystemWatcher, es un componente muy útil de .NET ya que nos permite el monitoreo de directorios para comprobar uso.

Todo programador debe ser curioso, y esa curiosidad implica el saber cómo funcionan las cosas, por eso también es interesante este método, este nos dice en que momento un archivo se escribe en disco esto nos sirve principalmente para 2 cosas, para construir sistemas que se inicien cuando la escritura ocurra, o para dar seguimiento a procesos que realicen escritura en disco pero que para nosotros sean una caja negra, nos ayuda a hacer un poco de ingeniería inversa…

No es un método perfecto ya que cuenta con 2 problemas que debemos tomar en cuenta durante el diseño.

1.       Si estamos observando un archivo que se encuentra en una unidad de red, y por algún motivo tenemos una intermitencia en la misma, en método se detiene y deja de reportar los cambios.

2.       No podemos iniciar libremente una cantidad muy grande de objetos (genera problemas de memoria o que no se ejecuten todos los eventos)

Pero una vez considerando estos puntos es una herramienta realmente útil.

El código en cuestión es el siguiente:

¿Qué es lo que hace?

System.IO.FileSystemWatcher se encarga de observar un directorio para que se dispare el evento

Path Nos indica el directorio base que se estará observando

IncludeSubdirectories se emplea para indicar que se observe el directorio raíz y todos sus directorios

NotifyFilter indica en que casos se notificara el acceso al directorio

Changed, Created y Deleted son 3 eventos que se disparan cuando el objeto cambia, se crea o se borra.

EnableRaisingEvents, activa el FilesystemWatcher.

Saludos

23. C# - HASH - Calculo de digestivo SHA1 para un archivo (Ayuda Rápida II)

Problema: Calcular el digestivo (HASH) SHA1 de un archivo
Proyecto: Genérico

Solución:

Esta función es muy útil por que nos permite obtener el hash de un archivo, por este medio podemos validar la integridad del mismo, una función hash nos entrega una cadena de caracteres que es equivalente a otra que se ha dado como entrada, estas funciones entregan una cadena de un tamaño arbitrario.

Una función hash es muy utilizada en la autenticación de usuarios o en la validación de la integridad de un archivo como es este caso, al ejecutar esta función sobre un archivo se obtiene una cadena especial que la podemos usar para determinar si dicho archivo ha sufrido una modificación.

Bueno la función para calcular el SHA-1 es la siguiente:

Y que hace?

Bueno el proceso que hacemos para obtener este digestivo es el siguiente:

1. Inicializamos el motor de criptografía

System.Security.Cryptography.SHA1CryptoServiceProvider oSHA1 =
            new System.Security.Cryptography.SHA1CryptoServiceProvider();

2. Leemos el archivo como un stream

            System.IO.FileStream fArchivo = new System.IO.FileStream(Archivo, System.IO.FileMode.Open,
                      System.IO.FileAccess.Read, System.IO.FileShare.ReadWrite);

3. Obtenemos el digestivo como un arreglo de datos

byte[] arrbytHashValue = oSHA1.ComputeHash(fArchivo);

4. Cerramos el stream como buena practica

fArchivo.Close();

5. Convertimos el arreglo de bytes a una cadena para que pueda ser visualizado

            string strHashData = System.BitConverter.ToString(arrbytHashValue);
            strHashData = strHashData.Replace("-", "");
            return strHashData;


Continuaremos con esta serie de Ayuda Rápida, sin embargo no he olvidado los pendientes que tengo con ustedes

Felices lineas

22. WinForm - ListBox - Copiar todos los elementos (Ayuda Rápida I)

Problema : Deseo copiar todos los elementos de un listbox
Proyecto: Winform

Solución:
El proceso para hacer esto es realmente sencillo, solo es necesario recorrer cada uno de los items que integra el listbox y agregarlo a un StringBuilder, ¿Por que a un StringBuilder? por que esta es la mejor opción cuando construimos cadenas, tiene un rendimiento mucho mayor a concatenar cadenas, aprovechamos que el StringBuilder nos permite formar una cadena con saltos de pagina, y esto lo enviamos al portapaleles.

Para este ejemplo, mi listbox tiene comonombre lstDetalle

Esta sección del blog incluirá tip sencillos para poder hacer ciertas actividades de desarrollo, en busca de facilitarnos el desarrollo, sin embargo continuare con todas las otras secciones y los temas que tengo pendientes con ustedes,

Saludos

21. Agua en Marte!!!! (noticia)

Hola, esta entrada no tiene que ver nada con desarrollo, sin embargo por la importancia de la noticia, tengo que compartirla 28 de Septiembre de 2015, la NASA ha encontrado que bajo determinadas circunstancias hay agua liquida en Marte, esto abre realmente un universo de posibilidades, para lo que puede ser el futuro, y bueno el software es una parte primordial de ese futuro, así que hoy en un día que debería ser recordado como un logro para la humanidad, es tiempo de hacer un compromiso, para poder ver el futuro que nos espera, con errores y aciertos la humanidad ha crecido, bienvenida una nueva época.

Agua en Marte http://edition.cnn.com/2015/09/28/us/mars-nasa-announcement/

Saludos

20. Métricas (Indice de Mantenibilidad)

Tengo varios temas que retomar con ustedes, temas que he dejado en este blog, pero que continuare escribiendo sobre estos, principalmente los patrones de diseño y el análisis de queries, ambos parte fundamental en el proceso de desarrollo.

Como he comentado en otros Post, Visual Studio, nos proporciona herramientas para poder medir el código, para darle una valoración al mismo, esto es importante ya que el código debe ser sencillo de entender por más de un desarrollador, es decir debe poder dársele mantenimiento de una manera sencilla.

Mientras más especializados son los componentes son más fáciles de controlar, estos se convierten en piezas esenciales de algo más grande.

Hoy vamos a hablar de la última métrica, que se encuentra en Visual Studio, el índice de mantenimiento, ¿Por qué la deje al último? Porque esta es la más sencilla, su nombre nos dice por si sola que es, esta nos dice que tan fácil es modificar  nuestro código, y mejor aún, nos lo indica con una bandera que va de rojo a verde.

Mientras el valor se encuentre más cercano al 100 es mejor, pero entonces me dirá, un índice de mantenimiento de 59 es bueno, la respuesta es sí, para el caso de .NET, como lo veremos a continuación.

Se puede decir que es un resumen de las otras métricas, el índice de mantenimiento  es una métrica creada allá por 1992 por Pau Oman y Jack Hagermeister, esta métrica agrupa varias otras como son el Volumen de Halstead (HV) esta es la única métrica que no hemos tocado en esta serie de post esta se define como el número de operaciones por el logaritmo base dos de operaciones distintas (N log2 n) , la complejidad ciclomatica (CC), las líneas de código (LOC) y la cantidad de comentarios.

Con estos valores se propuso una fórmula que nos da que tan mantenible es el código, la formula propuesta fue:

171-25ln(HV) – 0.23CC – 16.2ln(LOC) + 50.0Sin sqr(2.46*COM)

El paper original se encuentra en esta liga: ColemanPaper.pdf

Visual Studio no implementa en su totalidad esta fórmula, Visual Studio implementa una versión reducida de la misma, esta es:

Indice de Mantenibilidad = MAX(0,171-5.2 * ln(HV) – 0.23(CC) – 16.2*ln(LOC) * 100/171

Como se puede ver el equipo de Visual Studio elimino la parte que corresponde a los comentarios en el código.

Microsoft toma en cuenta estos rangos para limitar la mantenibilidad del código

El índice de mantenimiento cambia a amarillo entre 10 y 19 y a rojo ente 0 y 9, pero que es realmente el índice de mantenimiento.

0 – 9 Índice pobre

10 – 19 Índice Moderado

20 – 100 Índice Alto

Codificar no es solo colocar una instrucción tras otra, es necesario que seamos constructores de código de calidad, para reducir el esfuerzo de construcción, mejorar la calidad, disminuir los errores, mejorar el rendimiento, y lo más importante reducir el stress que se genera por códigos con problemas, que al final repercuten en la salud del desarrollador

Felices líneas

19. Métricas (Numero de lineas)

Número de líneas, esta es una de las métricas clásicas, incluso durante mucho tiempo se medían los programas por la cantidad de líneas de código que hubiera en ellos.

¿Pero que tan útil es?

Cuando hablamos de un desarrollo una operación puede ser por pocas o por muchas líneas de código dependiendo del desarrollador, por lo que una complejidad real de la solución no nos la puede dar.

Medir el trabajo en líneas de código no es una buena idea.

Sin embargo si nos ayuda en algo, nos ayuda a ver que métodos y funciones poseen gran tamaño, cuando un método es de un tamaño elevado, este se vuelve muy complejo, empieza a tener una responsabilidad muy alta, como consecuencia es más difícil de manipular.

Tradicionalmente se ha dicho que un método debe ocupar únicamente el espacio de la pantalla del equipo para ser correcto, esta observación no es del todo correcta, un método debe ser un ente altamente especializado, encargado de una actividad, esto muchas veces se puede lograr con muchas o con pocas líneas de código, el hecho de que un método tenga muchas líneas de código no necesariamente dice que está mal, o el hecho de tener muchos métodos muy pequeños con muy pocas líneas nos dice que es lo mejor. Hay que analizar cada caso, ver en que las operaciones se encuentren agrupadas, si bien divide y vencerás debe ser nuestra política, una división muy alta puede provocar que la complejidad se incremente.

Un método puede tener muchas líneas de código (no es lo deseable) pero si esto es justificado, es correcto.

Felices lineas

18. Métricas (profundidad de herencia)

Continuemos con las métricas que nos proporciona Visual Studio, la siguiente métrica, es útil porque nos ayuda a saber que tan complejo es un código.

Pero antes necesitamos un poco de teoría básica, para determinar que es la herencia, bueno la herencia es una de las principales características de la programación Orientada a Objetos, la herencia nos permita que un objeto sea creado a partir de otro, de esta forma el nuevo objeto toma los métodos y atributos que tenía el original.

Esto nos permite agregar funcionalidad sin reescribir todo el código, por lo que la reutilización del mismo es muy alta.

Bueno que nos indica la métrica de profundidad de la herencia nos indicia que tan grande es este árbol de herencia hasta llegar a la clase base.

¿Por qué nos afecta esto?, si bien el código se puede reutilizar, manejar clases con herencia de la herencia como se diría coloquialmente, hace que los flujos se vuelvan complejos, para seguir un flujo se deben hacer muchos saltos entre las clases ¿Quién la heredo? ¿Quién la modifico la primera vez? ¿Quién lo hizo la segunda vez? Y así sucesivamente.

El resultado el código se torna complejo, y entre mayor sea este número el código se vuelve más difícil de entender.

Manejar este número en valores menores 4 es lo mejor siempre.

Sin embrago no hay que asustarse si este número es alto, muchas características de código autogenerado de Visual Studio, nacen con este número en valores mayores a 4, así que analicen en que caso es su código y en qué caso es Visual Studio el que genero este número.

Y como la obtengo, siguiendo el mismo procedimiento que hemos discutido en artículos anteriores.

Las métricas son útiles porque nos ayudan a tener un mejor código, hasta la próxima.

Saludos

17. ¿Qué nos hace programadores?

Hay características muy especiales que todo programador debe tener, que si bien no son indispensables nos ayudan día a día en nuestro trabajo, he hecho esta lista basado en lo que he observado, es mi propia lista espero día a día complementarla, para saber qué es lo que hay en el ADN del programador.

 Capacidad de abstracción: Convertir una idea que muchas veces el cliente no puede visualizar en código y hacer que eso sea exitoso es una de las principales habilidades que debe tener el programador, ¿Cuántas veces un cliente ha dicho necesito algo que haga algo?, es decir el mismo cliente no sabe que es lo que quiere pero sabe que existe ese algo que lo va ayudar a mejorar sus procesos, a controlar su información, a hacer aquella tarea que siempre ha hecho de una forma pero que puede ser mejorada.

Aprendizaje rápido: El programador puede entrar en cualquier área, y debe entenderla rápidamente para poder desarrollar su trabajo, entenderla, y prácticamente hacerse un experto en ella, y no solo eso tener la capacidad de eliminar la ceguera de taller de todos aquellos que día a día realizaron esa actividad, debe tener la visión de mejorar los procesos, todo lo creado por el ser humano es mejorable, esa debe ser su máxima

Reacciones rápidas: Los sistemas son rápidos, y cada día son más rápidos y manejan más información, un programador debe ser capaz de tomar toda esa información que está fluyendo y encontrar soluciones muchas veces al instante en el que ocurre el problema, muchos de los problemas que llegan a ocurrir en un proceso productivo se dan por variables no consideradas en el flujo, y en muchos casos se requieren soluciones en periodos muy cortos de tiempo.

Capacidad de trabajar bajo presión: Todas las metodologías hablan de que existen tiempos para hacer las cosas, pero el mercado no da dichos tiempo, el tiempo es clave para ganar o perder un negocio, el tiempo siempre juega en nuestra contra

  Creatividad: Las soluciones planteadas no siempre están escritas, gran parte del trabajo de desarrollo es artesanal, el programador debe poder armar todas las piezas que tiene en un gran rompecabezas y darle vida, debe ser creativo e inteligente en cómo poner esas piezas para que interactúen de la manera correcta entre ellas.

Auto-aprendizaje: En una ciencia hay leyes que no cambian a través del tiempo, nosotros tenemos tendencias (lenguajes que surgen, nuevas características) que cambian todo el tiempo, lo peor lo que nosotros tenemos esta hecho por humanos que cambian de parecer de un momento a otro, así el lenguaje evoluciona, y de un año a otro puede cambiar completamente, debemos afrontar que hay que aprender todo el tiempo, y lo peor debemos afrontar que hay casos en que hay que desechar conocimientos.

 Obsesivos – Detallistas: Esto puede traducirse en calidad, los procesos tienen muchas entradas, salidas, variables, todo aquello que les da vida, debemos tener esa obsesión de mejorarlos de ser parte de ellos de entenderlos para que hagan aquello para lo que fueron hechos

 Capacidad de comunicación (hablar y escuchar): El usuario se comunica con nosotros y nos narra algo que no existe, nosotros narramos algo que tampoco existe, pero que en las dos cabezas debe formar un nuevo ser que cumpla con una expectativa.

 Memoria: recordar un dato de manera rápida, una regla casi olvidada que si bien esta en el diseño, debe estar en tu memoria, recordar mil funciones y cuando usarlas todo eso está en tu memoria Seguridad (No temer equivocarse): Tu eres el experto, el que lo construyo y dio vida, debes tener seguridad para caminar con pasos firmes, ya que si el constructor duda se genera desconfianza en el cliente, si el cliente no confía en ti, un éxito se convertirá irrevocablemente en un fracaso.

Todo cambio es bueno: En nuestro mundo todo cambia constantemente

Felices líneas

16. Metricas (Cohesión y Acoplamiento)

Cuántas veces hemos escuchado, un buen diseño tiene alta cohesión y bajo acoplamiento, en cuantos documentos hemos leído… una de las características de este diseño es su alta cohesión.

¿Qué es eso?

Ambas son características de la programación orientada a objetos características que son muy importantes durante la etapa de diseño que pueden ser definidas de la siguiente forma:

Cohesión: Lo podemos entender como que cada uno de nuestros módulos sea altamente especializado en sus características o componentes, dicho en un lenguaje más coloquial, hablar siempre del mismo tema, esto nos facilita el diseño, la programación, las pruebas y el mantenimiento, así mientras mayor sea la cohesión mejor es el resultado en el sistema.

Sin embargo este es un concepto abstracto, que no puede ser fácilmente evaluado por una máquina, para determinar el grado de cohesión de un sistema es necesario validar el diseño, y ver que cada módulo sea un módulo especializado.

Y que pasa con el acoplamiento, bueno este es el grado en que una clase conoce a otras, las clases no son independientes, pese a que se recomienda un acoplamiento bajo, las clases requieren conocer a otras, este grado de conocimiento entre las clases genera el acoplamiento, de tal forma que una clase con alto acoplamiento tiene acceso a muchos métodos de diferentes clases, como consecuencia la clase es más compleja, y esta complejidad es la que debemos cuidar cuando tenemos un acoplamiento muy alto.

Mientras más compleja sea una clase, más difícil será el mantenimiento, mayor cantidad y complejidad de pruebas tendrá y será más propensa a errores.

Pero también hay que considerar algo, clases sin acoplamiento no son útiles, porque ningún ente vive aislado en este mundo.

A diferencia de la coherencia, para el acoplamiento, Visual Studio si nos permite obtener por medio de una herramienta el acoplamiento, para ello debemos ir al menú analizar y solicitar las métricas de la solución.

 “Calcular métricas de código para la solución”

Visual Studio inicia con la compilación del código y posteriormente, obtenemos los resultados.

¿Qué valor es óptimo? Este número siempre se debe encontrar en un valor inferior a 9, que incluso puede ser validado por medio de la herramienta de Code análisis de Visual Studio.

Hasta pronto

15. Métricas (Complejidad Ciclomatica)

¿Qué es eso?

Cuando hablamos de arquitectura, empezamos a buscar medidas que nos indiquen la calidad de nuestros diseños, una medida que es ampliamente usada es la complejidad ciclomatica, en palabras sencillas esta nos indica que tan compleja es una función o una clase, es decir la cantidad de rutas que existen para ella. ¿Y en que no ayuda esto? Nos enseña la cantidad de casos de prueba que se necesitan para que este componente se pueda probar al 100%.

Una declaración como esta lo hace muy importante, si bien es prácticamente imposible probar un software al 100%, mientras más complejas sean las pruebas, es más difícil garantizar la calidad del software.

Esta es una de las métricas más importantes en la ingeniería de software, principalmente por 2 características:

1.       Da una visión general de la calidad de la solución

2.       Es independiente del lenguaje

Ahora bien para nosotros como programadores de .NET Visual Studio es capaz de calcular esta métrica, para que nosotros la verifiquemos.

¿Y cómo lo interpretamos? Esto es algo que es importante de esta medida, se interpreta de una forma muy sencilla, mientras en número sea menor es mejor.

Entonces, ¿Qué valores se recomiendan? , Los valores de la complejidad ciclomatica dependen de la organización, pero es recomendable seguir la siguiente tabla:

Mínimo	Máximo	Descripción
1	10	Riesgo pequeño
11	20	Riesgo Moderado
21	50	Alto Riesgo
50		Muy alto riesgo

Bueno ya que entendemos esto, ¿Cómo lo usamos en Visual Studio?

Realmente es muy sencillo, el menú de Visual Studio, nos da una opción que es analizar

Y en esta opción tenemos un menú que dice “Calcular métricas de código para la solución”, simplemente lo seleccionamos, Visual Studio inicia con la compilación del código y posteriormente, obtenemos los resultados.

Pero entonces me dirán, ese código que les muestro tiene una complejidad ciclomatica de 173, es muy alta, sí y no.

Estoy mostrando la complejidad de toda una solución, cada uno de los métodos que da vida a la solución es evaluado, de tal forma que un método solo por el hecho de existir sube en uno dicha complejidad.

¿En qué casos se enciende una alarma? Cuando un método tiene una complejidad ciclomatica alta, es decir hace demasiadas cosa tiene muchas posibilidades, el método ya no es controlable.

Saludos