martes, 8 de abril de 2014

¡Estreno en Facebook!


Para que podáis estar al día vía Facebook, estreno una nueva página en la red social para llegar a más gente!!!

Podéis acceder por medio del siguiente enlace:
https://www.facebook.com/pages/Los-vericuetos-NET/537146749667471

Info

viernes, 4 de abril de 2014

La importancia de los comentarios en el código fuente

Artículo para: Programadores de C#

Comentarios

Los comentarios son vitales en nuestro trabajo diario, sobre todo porque como ya habréis observado crear código que uno mismo entiende es sencillo; leer el código de otro programador y entenderlo suele ser  un infierno. Además, el valor añadido de los comentarios XML de los que Visual Studio nos provee: se muestran en el IntelliSense y ayudan a otros programadores a entender qué hacen ciertos métodos, para qué sirven ciertas propiedades, etc…

Por favor, tenedlo muy presente antes de poneros a meter código a lo loco. En ocasiones hacemos cosas tan confusas (bien sea por falta de análisis, o porque no queda más remedio) que es totalmente necesario el comentarlo para que otro, o incluso tú mismo dentro de algún tiempo, lo pueda llegar a entender.

Para ello disponemos de los comentarios de una sola línea…   
public void CorkBreadMethod(bool entry)
{
     if (entry)
     {
          //Code if entry is true
     }
}

…útiles para dar una descripción rápida de lo que estamos haciendo.
También tenemos comentarios de múltiples líneas…
public void CorkBreadMethod(bool entry)
{
     if (entry)
     {
     /* Code if entry is true and loren ipsum when the sun goes
     * down and the moon is dark */

     }
}
… que son de gran utilidad cuando la línea es muy larga y es completamente necesario todo el texto que hemos introducido. Es muy importante tener esto en cuenta, que el texto sea realmente necesario; si no lo es estaremos empantanando el código para el próximo lector. Ver sección al respecto de longitud de línea.

Comentarios XML

Mención especial merecen los comentarios XML ya que son ellos los que permitirán al usuario comprender mejor nuestras clases y métodos. Para utilizarlos, Visual Studio nos provee de una automatización: antes de la clase, propiedad o método (en la línea previa) escribiremos tres veces la barra /// y automáticamente se crearán los encabezados necesarios para el comentario XML:
/// <summary>
/// Class in charge of beign an example
/// </summary>

class CorkBreadClass
{

}


El anterior es un ejemplo de cómo identificar a una clase por medio de un comentario XML. Después de hacerlo, desde fuera de la clase ésta se vería como sigue:


/// <summary>
/// Method inside CorkBreadClass
/// </summary>
/// <param name="entry">A boolean that represents the entry</param>
/// <returns>5 if entry is true, 0 elsewhere...</returns>

public int CorkBreadMethod(bool entry)
{
     return entry ? 5 : 0;
}

Con los anteriores comentarios XML, tendríamos el siguiente resultado:



Como podemos ver en la anterior captura, nos devuelve toda la información que previamente hemos escrito en los comentarios XML, con lo que conseguimos que una persona que no conozca nuestro código o no tenga acceso directo al fuente del mismo; pueda entender qué sucede dentro de nuestras clases.

C# y Programación

jueves, 3 de abril de 2014

Reto de programación 1

Artículo para: Programadores de C#

Hoy me gustaría compartir con vosotros un trozo de código que casualmente me he encontrado en uno de los proyectos en los que trabajo.

Si bien es cierto que todos metemos la pata, y me confieso que yo soy el primero; esta metedura de gamba es tan llamativa que bien merece estar como post-reto en mi blog.

Os pongo en contexto: la función que váis a ver nos da el html de una página web que hemos automatizado previamente.

Ahora el reto: ¿Qué hace el siguiente fragmento de código? ¿Qué devuelve la función?


Por favor, responded en el blog, en el apartado de comentarios.


¡Muchas gracias a todos!
C# y Programación

martes, 21 de enero de 2014

Generalidades sobre usabilidad y el diseño de aplicaciones

Artículo para: Programadores de todas las plataformas

La usabilidad y el diseño de una aplicación es un factor que solemos dejar para el final porque la mayoría de programadores consideramos una parte accesoria de nuestro trabajo (este no es mi caso). Debido a los tiempos que corren, en la mayoría de empresas españolas (que es lo que yo conozco) los analistas/programadores somos, además de arquitectos de nuestras aplicaciones (da igual senior que junior), diseñadores de interfaces de usuario y analistas de la usabilidad de nuestras propias aplicaciones; además de ser el personal de pruebas.


Esto en los 90 era revolucionario! Ahora...

Por escandaloso que parezca, sobre todo en grandes empresas donde hay departamentos para todas estas áreas de un proyecto, en la mayoría de ocasiones nos enfrentamos solos a todas estas áreas; es lo que hay. Para las pruebas suele comprenderse que la misma persona que programa (en mayor o menor medida), no es la más indicada para hacer pruebas de usuario sobre su propia aplicación: está claro que uno mismo no ve sus propios fallos hasta que otro se lo dice. Si esto es así, ¿por qué no se entiende exactamente igual este hecho cuando hacemos interfaces de usuario?

Es un hecho constatado que los programadores tenemos tendencia innata a las interfaces tediosas y que solo nosotros entendemos; es por ello por lo que hay que romper con esta tendencia y empezar a hacer las cosas como a los usuarios finales les gustaría que fueran: esta y solo esta es la clave del éxito. Podemos hacer una aplicación cuyo rendimiento sea descomunal, que optimice por diez los resultados de la competencia y que nos permita trabajar con un rendimiento un 80% mejor que las anteriores herramientas conocidas que hacían lo mismo: si el usuario no comprende o no se siente cómodo usándola será un total fracaso.


La tendencia a enfado del usuario tiene que estar presente siempre en nuestro trabajo

Dicho todo esto vienen los dogmas que, a mi entender (y como siempre todo es discutible), hay que tener presente antes de abordar una interfaz gráfica de usuario, ya sea escritorio o web:

  1. Ponerse siempre en el lugar del usuario final que va a usar nuestra aplicación. Para realizar esta tarea no se puede hacer una generalización, porque depende en gran medida del tipo de usuario al que se está enfocando dicha aplicación: no será idéntica una aplicación enfocada a un entorno de defensa, que a uno de banca o que un usuario desarrollador como podemos ser nosotros mismos. ¿Os imagináis que Visual Studio hubiera sido diseñado de igual manera que un software bancario?... yo me hago una idea y... ¡Qué horror!
  2. Esforzarse y poner énfasis en que nuestra aplicación se entienda, principalmente por gente que nada tiene que ver con nuestro entorno ni negocio (porque nuestro negocio son todos). Entender esto es vital. No todo el mundo posee nuestro conocimiento de la informática y las ciencias de la computación y lo más importante: no tiene por qué tenerlo. Nuestras aplicaciones deben poder ser utilizadas por aquellas personas a las que van destinadas: almacenistas, secretarias, banqueros, militares, etc... y habrá personas que tengan conocimientos avanzados sobre la informática pero la inmensa mayoría no.
  3. Diseñar los controles en pantalla con cierto criterio: poner cosas en cascada con cierta lógica, mantener la misma lógica de botones a lo largo y ancho de la aplicación. Si no seguimos la lógica en toda la aplicación, la tendencia a fallar durante su uso será muy alta; lo que conllevará a frases típicas de usuario como: -¡Esto es una mierda!- y similares.
  4. Por último en esta serie de consejos básicos, pero no menos importante: un diseño elegante y funcional. De nada sirve que una aplicación sea buena si su diseño no refleja que efectivamente lo es. La tecnología evoluciona y las aplicaciones y las interfaces de usuario también: de nada sirven ya las obsoletas interfaces del Windows 3.11...
Aquí os he dejado los principios básicos en los que yo me muevo a la hora de trabajar las interfaces. En los sucesivos artículos explicaré algunos de mis secretos para hacer aplicaciones "elegantes" que lleguen a los usuarios, y hasta ahora mi experiencia me ha sido muy útil en las empresas en las que he trabajado; espero que a vosotros también os sea de utilidad.
C# y Programación

jueves, 5 de diciembre de 2013

Windows 8.1 - El sistema operativo del buen gusto


Artículo para: Todo tipo de usuarios

Como ya viene siendo habitual, Microsoft nos ha deleitado con un sistema operativo sencillo, bonito y sobre todo optimizado para realizar nuestras tareas diarias.

Es cierto que con Windows Vista nos quedó un amargo gusto que recordó a aquella versión maravillosa llamada Millenium y que duró menos de un año (porque era una auténtica mierda), dando paso a XP. De hecho el rendimiento de Windows Vista quedó en entredicho cuando la interfaz aero se comía nuestras máquinas (que la verdad, no eran tan potentes como las que ahora podemos tener).

Mucho tiempo ha pasado desde entonces y ya nuestro querido Windows 7 nos dejó muchísimo mejor cuerpo. Todo funcionaba como un reloj, mucho más optimizado y con el mismo aspecto que el Vista, pero bien hecho.

Ahora, además de optimizar mucho mejor todos los recursos, tenemos un Windows 8.1 aún más enfocado a los usuarios finales de todas las tipologías y colores; habiendo retomado el Menú Inicio (acierto supremo, que en la versión 8 no habían añadido), han enfocado la interfaz a botones grandes y no muy numerosos y con pocos textos. La curva de aprendizaje si vienes de un Windows anterior es cierto que es grande para usuarios poco experimentados y los menúes están pensados totalmente para pantallas táctiles, pero es una gozada ver cómo lo han hecho.

Por mi parte deciros que muy recomendable, yo ya lo tengo en casa (totalmente legal) y estoy encantado de la vida; ¡vosotros mismos si aún no le habéis dado la oportunidad a los chicos de Redmond!!

Por cierto, Microsoft NO me tiene en nómina, ¡malpensados!
Windows

viernes, 22 de noviembre de 2013

Delegados y Expresiones Lambda… perdiendo el miedo

Artículo para: Desarrolladores .NET con nivel intermedio

Delegados

Antes de empezar a entrar en el detalle sobre este tema indicar que el presente documento no es un libro, por lo que no nos extenderemos mucho. Lo cierto es que suele dar bastante miedo al programador porque son conceptos que no se entienden bien ni con un libro, por lo que trataremos de explicarlo sin que sea excesivamente técnico, ni exhaustivo.

Un delegado es la definición de una función que sirve para pasarla como parámetro a otra. Así de sencillo y claro. Quizá se encuentren otras definiciones mejor redactadas y mucho más confusas, pero esta se entiende tal cual.

public delegate bool DelegateFunction(int parameter1, int parameter2);

Así se declara un delegado, no requiere más que esto y sirve como carcasa para pasar por parámetro a otra función una con este mismo tipo de declaración: dos números enteros de entrada y un booleano de salida.

Ahora viene el crear una función que utilice el delegado como parámetro:

public string ExampleFunctionWithParameterDelegate(DelegateFunction df, int p1, int p2)
{
if (df(p1, p2))
{
return String.Format("Se cumple la condición de la función df usando {0} y {1}",
                    p1,
                    p2);
}
return String.Format("NO se cumple la condición de la función df usando {0} y {1}",
                    p1,
                    p2);
}


Esto nos lleva a empezar a entender cómo funcionan los delegados. Ahora nos bastará con crear funciones que cumplan los parámetros de entrada (dos enteros) y salida (un booleano) como las que siguen:

public bool DelegateExampleFunctionP1IsLessThanP2(int parameter1, int parameter2)
{
return parameter1 < parameter2;
}

public bool DelegateExampleFunctionP1IsMoreThanP2(int parameter1, int parameter2)
{
return parameter1 > parameter2;
}

Bueno, ahora lo hilamos todo realizando llamadas como las que siguen:

var p1 = 5;
var p2 = 2;
var returned1 = ExampleFunctionWithParameterDelegate(
DelegateExampleFunctionP1IsLessThanP2, p1, p2);
var returned2 = ExampleFunctionWithParameterDelegate(
DelegateExampleFunctionP1IsMoreThanP2, p1, p2);


¿Podéis adivinar los valores de las variables returned1 y returned2 después de la ejecución del juego de instrucciones? Pues son los siguientes:

returned1 = "NO se cumple la condición de la función df usando 5 y 2"
returned2 = "Se cumple la condición de la función df usando 5 y 2"

Como podemos observar, esto nos permite hacer funciones mucho más flexibles, incluso “mutantes”. Ahora pasaremos a explicar las expresiones Lambda, utilizando el mismo ejemplo para los delegados.

Expresiones Lambda





Siguiendo la estela anterior y sin más dilación, aporto un ejemplo de expresión Lambda que servirá para comprender a la perfección cómo funcionan, comparándolo con el anterior desarrollo de ejemplo, marcamos en amarillo la expresión lambda:


var returned1 = ExampleFunctionWithParameterDelegate(
DelegateExampleFunctionP1IsLessThanP2, p1, p2);
var lambdaReturned1 = ExampleFunctionWithParameterDelegate(
(parameter1, parameter2) => { return parameter1 < parameter2; }, 
         p1, p2);

var returned2 = ExampleFunctionWithParameterDelegate(
DelegateExampleFunctionP1IsMoreThanP2, p1, p2);
var lambdaReturned2 = ExampleFunctionWithParameterDelegate(
(parameter1, parameter2) => { return parameter1 > parameter2; },
p1, p2);


Se empieza a vislumbrar que la única diferencia con el código anterior de delegados es que ahora ya no necesito las funciones auxiliares creadas, las creo “al vuelo” y sin definición directamente dentro de los parámetros de llamada de la función principal con el delegado.

Como imaginaréis, el resultado será el siguiente, exactamente idéntico a su predecesor ejemplo de delegados:

returned1 = "NO se cumple la condición de la función df usando 5 y 2"
lambdaReturned1 = "NO se cumple la condición de la función df usando 5 y 2"
returned2 = "Se cumple la condición de la función df usando 5 y 2"
lambdaReturned2 = "Se cumple la condición de la función df usando 5 y 2"


Las expresiones lambda y los delegados se encuentran implementados en multitud de funcionalidades de los objetos del framework. Uno de los sitios más usuales donde encontrarlas es en los objetos de la clase System.Collections.Generic , por ejemplo en las listas y nos será de gran utilidad su buen empleo para realizar consultas sobre dichas colecciones.
C# y Programación

 

Webs amigas:

  • Copyright © Los vericuetos .NET 2015
    Distributed By My Blogger Themes | Designed By Templateism