Pues bien parece que las telenovelas de los equipos de desarrollo de software no acaban y cada vez tienen mas dramas y efectos especiales. Hace días comentaba sobre algo al respecto de la productividad, y bien ahora les traigo este post que mas que interesante es real y ya algo cotidiano en la vida de muchos programadores, les recomiendo la lectura de este y una vez que lo hayan hecho, les comento que hay algo que me hizo acordarme de algunas vivencias recientemente.

ACTO I.

• Líder (L): El reporte tiene que tener mas o menos éstos campos.
• Programador (P): ¿Tiene o no tiene que tener el campo “X”?
• L: Y… si hay lugar ponélo.

Ese parte en donde esta el "tiene que tener mas o menos estos campos" es de las frases típicas que escuchamos de los lideres de proyectos o compañeros, entre otras como las de "nada mas tiene que correr un procesillo y mostrar el resultado" (¿ehhh?) .

Me pregunto cuando desarrollaron Officce, el líder de proyecto dijo "Pues hay que hacer Word, tiene que poder hacer que el usuario escriba letras y que se pueda imprimir, algo sencillon", ajam ¿Y el documento de especificaciones? Y les comentaba esto por que recién acabo de migrar unas "pantallitas" (WindowsForms) de una versión a otra, algo sencillo, pero al copiarlo te vas dando cuenta, que se te olvida un color, que un fondo es diferente en una caja de texto que en otra, o que simplemente los tamaños no coinciden, pero vamos para eso me pagan ¿no?, el detalle consiste que es como el juego de "Encuentra las 10 diferencias", solo que aquí eran como 80 diferencias y lo peor, que no vienen las respuestas(especificaciones) al reverso de la caja del cereal.

Así que la cuestión es, ¿Tenemos documentos de especificaciones?, ¿Donde quedo el Issue Tracker o Bug Tracker para hacer un ticket y pedir "con bolitas y palitos" un cambio?

La respuesta es "se necesita comunicación, oral y/o escrito", se necesita, es obligatoria, no hay mas.

Navegando por el blog de mi anterior empleador, me encontré con un post de una fuente que desarrollo un excompañero (Jaime Martínez) y que pueden descargarla desde aquí, el tip consiste en saber que múltiplos usar al darle el tamaño a nuestra fuente, el consejo pueden leerlo en este comentario.

Así que vamos al ejemplo en .Net y el código seria como se ve en la siguiente imagen

Si leyeron el comentario del autor de la fuente, en el comentario se decía que cuando la resolución de la pantalla era de  72 dpi tomaríamos como base  8 píxeles, así que los múltiplos serian (8, 16, 24, 32, 64, …) ahora cuando la resolución sea de 96 tomamos como base 6 y los múltiplos serian (6, 12, 18, 24, ….).

Ahora vamos a ver como queda al pintar texto como lo muestra la siguiente imagen

Como notamos mi pantalla muestra que mi resolución es de 96 dpi y por lo tanto tengo que usar tamaños múltiplos de 6 para que se muestre correctamente. En la imagen notamos que el primer texto tiene el antialias activado y el segundo no, si descargan la imagen o la amplían lo notaran mejor.

Bueno espero les haya sido de utilidad este consejo y gracias a Jaime por la fuente.

Cualquier duda o comentario a djnavi * gmail * com

Normalmente no pongo entradas sobre asuntos personales ya que pocas veces o ninguna vez a la gente le interesa leer sobre si anda enfermo el perro del tipo que anda escribiendo en el blog, pero esta vez tiene algo que ver con el trabajo y tal como lo dice el titulo de esta entrada, estas semanas (aka meses) han sido bajas en cuanto a productividad laboral se refiere y es que haciendo un “recuento de los daños” he decidido hacer un análisis para obtener información sobre el por que he sido improductivo estos últimos meses y en la empresa actual en particular, pues esto no había pasado hasta ahora.

Bien empezamos poniendo las posibilidades que pueden generar este efecto.

No hay disposición y/o ganas para laborar.
El ambiente laboral no permite ejercer un buen trabajo.
La forma de laborar(metodologías, practicas, comunicación, etc…) del equipo de trabajo no es el adecuado.

Después de un rato de pensar y analizar el asunto, la conclusión es que no es una en especial sino el conjunto de algunas y que dan como resultado tal efecto, si tuviera que darle un porcentaje sobre que influye más seria de la siguiente manera.

Posibilidad 1: 70%
Posibilidad 2: 15%
Posibilidad 3: 15%

Como notaron lo que mas influye es que no hay disposición y/o ganas de trabajar, así de fácil , asumo la responsabilidad pero (siempre hay un pero) el motivo principal el por cual disminuye las ganas de trabajar y aumenta la frustración es que las posibilidades 2 y 3 generan gradualmente la posibilidad 1.

En resumen y para no hacerla mas enredada, es que en un ambiente laboral pobre y con pocas (casi nulas metodologias, practicas, reuniones, COMUNICACION, etc..) generan gradualmente menos satisfacción al trabajar y por lo tanto una frustración reflejada en improductividad.

Pero no todo termina ahí, y es que no solo es decir sí, tengo y/o tenemos la culpa, si no la cuestión es actuar, y para eso recordé algunos artículos de Joel Spolsk (para variar)  en particular el de “El test de Joel: 12 pasos hacia un mejor código” en el que al final del articulo menciona cuatro formas de usar el test de la siguiente manera.

1. Evalúa a tu propia empresa y dime qué puntuación obtiene, así puedo cotillear un rato.
2. Si eres responsable de un equipo de programación, utilízalo como una guía para asegurarte de que el equipo trabaja lo mejor posible. Cuando obtengas un 12 como puntuación, puedes dejar en paz a tus programadores y dedicarte a tiempo completo a que los comerciales dejen de molestarlos.
3. Si estás intentando decidir si aceptar una oferta de trabajo como programador, pregunta a tu futuro jefe qué puntuación obtendría la empresa en el test. Si te parece una puntuación muy baja, asegúrate de que tendrás autoridad suficiente para solucionar lo necesario. En caso contrario, acabarás frustrándote y siendo poco productivo.
4. Si eres un inversor que quiere evaluar a un equipo de programación, o si tu empresa está considerando la posibilidad de fusionarse con otra, este test puede servir para hacer una evaluación rápida.

Lo interesante de esto es el punto tres el cual la segunda parte dice lo siguiente “Si te parece una puntuación muy baja, asegúrate de que tendrás autoridad suficiente para solucionar lo necesario. En caso contrario, acabarás frustrándote y siendo poco productivo.” y no es que solo Joel lo diga, si no que en efecto lo ando viviendo en carne propia.

Bien como comentaba no solo es cuestión de tirar caña y excusarse, lo siguiente es intentar crear el entorno y para eso haré uso de un articulo mas (por qué no) de Joel que es “Logrando resultados cuando se es peón” y a continuación en listare las estrategias mencionadas en el artículo.

Estrategia 1 Simplemente, hazlo.

Estrategia 2 Explota el Poder del marketing Viral

Estrategia 3 Crea un Repertorio de Excelencia

Estrategia 4 Neutraliza a los tarados

Estrategia 5 Huye de las Interrupciones

Estrategia 6 Vuelvete Invaluable

Para mi las estrategias mas importante son la 1 y la 6, la primera es en la cual se crea un entorno donde uno pueda ser eficiente y productivo y la estrategia 6 es que una vez que uno sea eficiente y productivo estaré un paso adelante de la situación y será mucho mas fácil de ayudar al equipo o cambiar de empresa.

Y mientras sean peras o naranjas este post me ha servido al menos para desestresarme y si mañana les aviso que estoy despedido, ohh es que alguien de la oficina lee mi blog jajaja.

Varias veces he visto que mucha gente se da de topes cuando crea una DLL en C++ y al llamarla se dan cuenta que los nombres de las funciones que exporto fueron cambiadas por nombres raros y que en ocasiones nada tiene que ver con los nombres de las funciones originales.

Bueno vamos a dar una explicación y la solución a este "problema", a este suceso que ocurre se le llama "planchado de nombres", aunque también se le conoce como "decoración de nombres", bien vamos a la explicación técnica.

Para empezar diremos que esto solo ocurre en los compiladores de C++, cuando el compilador preprocesa el código (en realidad lo hace el preprocesador), los identificadores originales son cambiados por versiones generadas por su nombre, tipo y numero de argumentos, esto es por que C++ es un lenguaje orientado a objetos y por lo tanto permite la sobrecarga de funciones, si el traductor no cambiara el nombre de las funciones seria difícil distinguir a que función queremos accesar (aun cuando cada función tiene diferentes parámetros), gracias a esto el compilador sabe distinguir las versiones de una función sobrecargada.

Veamos un ejemplo de una DLL creada con Visual C++, el código seria como lo muestra la siguiente imagen

Así es como exportamos una función de nuestra DLL, lo compilamos y para conocer los símbolos que exporta haremos uso de la herramienta de dumpbin que acompaña a Visual C++ y ejecutaremos dumpbin como lo muestra la siguiente imagen

Como notamos nuestra función tiene el nombre "?fnDLLExample@@YAHXZ" .

Bien, ¿como podemos evitar el planchado?, para evitar esto usamos una directiva de enlazado la cual es extern "C", este especificador de tipo de enlazado puede ser usado para un prototipo de función, para un bloque de prototipos o para un fichero de cabecera, con esto le diremos al compilador que esas funciones no deben ser planchadas, veamoslo en la siguiente imagen

Compilamos y veamos como lo muestra dumpbin en la siguiente imagen

Como resultado tenemos el nombre original de nuestra función.
En el caso de Visual C++ podemos hacer uso de un archivo de definición (.def) y escribir las funciones que queremos exportar y que no queremos que sean planchadas.

Les recomiendo leer este artículo el cual muestra algunas buenas practicas de como podemos crear una interfaz portable de nuestra DLL.

Espero esto les sea de utilidad y cualquier duda o comentario a djnavi=at=gmail=com

Como comentaba en post anteriores, hay ocasiones que ejecutamos código que requiere un periodo de procesamiento largo, vimos una solución usando delegados, esta vez ampliare la solución y mejor aun estará en una DLL para que puedan usarlo todos.

Bien antes de todo hablemos de una clase que es usada por la DLL y que es base de la librería, esta clase es SynchronizationContext, veamos una descripción del MSDN Library.

La clase SynchronizationContext es una clase base que proporciona un contexto de subprocesamientos libres sin sincronización.

Bien cuando realizamos una operación asíncrona por ejemplo cuando tenemos un botón en un formulario y este botón manda a llamar a un método que convierte una serie de archivos mp3 a un formato y queremos mostrar en una etiqueta con un progressbar el seguimiento de esta operación, bien en este escenario no es posible modificar la interfaz de usuario desde otro hilo (ajam eso ya lo dijiste varias veces HardBit) ¿por que?, bien por que los controles de WindowsForms no son "Thread-Safe" esto quiere decir que no son seguros para los procesos, ya que si varios hilos modifican al control este podría tener un comportamiento extraño o peor aun cambiar a un estado incoherente, para esto hablemos algo que se conoce como RaceCondition y que es usado por varios hackers/crackers para ejecutar código malicioso, bien el "RaceCondition" consiste en querer accesar a una variable, etc.. cuando esta aun no esta inicializando, o aun no tiene el valor que esperaba la instrucción que intenta usar creando un problema que muchas veces no es fácil de manejar. Ok, continuemos, decíamos que los controles no son "Thread-Safe", la definición de Thread-Safe a veces suele ser confusa intentare dar una que espero se entienda, cuando una porción de código es Thread-Safe es cuando este funciona de manera correcta en un ambiente multiprocesos asegurando el acceso simultáneo exclusivo a un recurso compartido por múltiples hilos, ahora ¿como hacemos esto en .Net?.

Bien para poder hacer eso haremos uso de la clase antes mencionada, lo que haremos es usar este contexto de sincronización y de hay poder enviar mensajes (Eventos) desde subprocesos (hilos).

Les dejo la DLL aquí y la documentación aquí, en la documentación se encuentran los ejemplos y la referencia de las clases, la clase ThreadingSyncContext en la documentación contiene los ejemplos.

Espero seguir escribiendo artículos sobre Hilos/Subprocesamiento y hablar de problemas que surgen al entrar en este ámbito, como los interbloqueos o "RaceCondition", etc… también intentare lo posible no poner palabras en ingles y buscarle una traducción a las palabras.

El tema de los hilos es muy amplio y se requiere de muchos post o mejor aun artículos para poder entrar en detalle de ciertos aspectos.

Les recomiendo leer este articulo de un integrante del equipo del .Net Runtime
http://msdn.microsoft.com/es-mx/magazine/cc163744(en-us).aspx

Cualquier comentario o sugerencia aqui o a djnavi * gmail  * com

En algunas ocasiones queremos instalar o adjuntar una base de datos o simplemente hacer un cambio en alguna base de datos como una actualización de una vista o procedimiento almacenado durante la instalación de una aplicación.

Bien, en esta ocasión les traigo una extensión para Inno Setup con el cual podremos hacer esto, lo que haremos es incluir el archivo de código en nuestro script e iniciar nuestra pagina (Page) en determinados eventos del instalador como lo muestra la siguiente figura

Imagen

Lo siguiente será crear la pagina al iniciar el asistente, en el evento que lanza el botón siguiente del asistente verificaremos si la pagina actual es la de sql server y en caso de que haya una conexión satisfactoria ejecutaremos un procedimiento.

Imagen

Como notamos es realmente fácil, en el procedimiento SQLExec podremos realizar cualquier operación, en la siguiente versión de la extensión escribiré procedimientos para la base de datos como:
AdjuntarBD
CrearBD
EjecutarScript

Esta extensión hace uso de los objetos COM de SQL-DMO, así que necesitaran que este instalado en donde se ejecute el instalador para poder usar estas funciones, no se preocupen si no esta instalada, pueden usar un redistribuible e instalarlo justo antes de usar estas funciones, este se llama "MS SQL Server Backward Compatibility" y lo pueden descargar del sitio de Microsoft.

Las siguientes figura muestra la pagina durante la instalación.

Capturas de pantalla 1, 2 y 3

Como notamos es realmente fácil y de mucha ayuda, en las siguientes entradas del blog veremos mas extensiones que he escrito para InnoSetup y espero tener un pack para las semanas siguientes.

Espero que esto les sea de ayuda y recuerden dejar su comentario y/o dudas aquí o a djnavi + gmail + com.

Descargar extensión aquí

He estado estos días pensando que estaría bien tener un depurador de Inno Setup para poder seguir las variables, etc… y espero un día de estos empezarlo,  mientras tanto les dejo esta extensión que he escrito para poder mostrar información durante el ciclo de vida del instalador.

La extensión consiste en 3 funciones:

OpenConsole: Muestra la consola.
WriteLn: Escribe una cadena de caracteres en la consola que es pasada como parámetro.
CloseConsole: Cierra la consola.

Lo que haremos es incluir la extensión, en un post anterior indique la forma de hacerlo, después abriremos la consola al inicia el instalador y la cerraremos al finalizar, el siguiente ejemplo muestra como usar las funciones.

Imagen de código

No olviden agregar la DLL que contiene las funciones, que es IsUtilHb.dll.

La siguiente imagen muestra el proceso de instalación.

Imagen de instalación

Cualquier comentario, duda o sugerencia a djnavi - gmail - com

Descargar aquí extensión de Inno Setup.
Descargar aquí DLL.

Ha pasado que muchas veces queremos probar una clase y recurrimos a crear un proyecto, aunque esta puede ser una solución viable, existe en Visual Studio una herramienta llamada "herramienta de prueba de objetos", esta está diseñada para realizar pruebas de clases sencillas a nivel de objeto, con esta herramienta podemos crear instancias de las clases invocar métodos y evaluar los resultados, VS incluye una ventana donde podemos interactuar y manipular los objetos creados desde el Visor de clase (o Vista de clases) y/o el diseñador de clases.

El MSDN library recomienda el uso para las siguientes tareas

• Enseñar conceptos de la programación orientada a objetos sin entrar en la sintaxis del lenguaje.

• Proporcionar una herramienta de pruebas ágil diseñada para los programadores aficionados y del mundo educativo, que pueden utilizar en proyectos sencillos y de pequeño tamaño.

• Reducir el ciclo escribir-depurar-reescribir.

• Probar clases simples y sus métodos.

• Descubrir rápidamente el comportamiento de una biblioteca API.

Algo muy importante es que la HPO solo funciona en el proyecto StartUp en la solución, si tiene diferentes proyecto en la solución hay que establecer como proyecto de inicio al proyecto del cual vamos a probar nuestras clases.

Aun cuando el MSDN es claro que esto es para clases relativamente simples, no quita el mérito de ser una herramienta útil, sin embargo debemos considerar en que escenarios usarlos, no obstante les invito a leer el MSDN para conocer todas las opciones del HPO.

Les dejo un webcast sobre el uso de esta herramienta aquí.

Espero les sea de utilidad, dejen comentarios y/o dudas aquí o a djnavi <> gmail <> com

Muchas veces ejecutamos procesos que requieren tiempo para procesar y por lo tanto si usamos interfaz gráfica muchas veces estas se "cuelgan" puesto que las operaciones son ejecutadas sobre el mismo hilo, así que cada operación entra en la pila del mismo hilo por lo tanto tiene que esperar su turno para poder procesar la información, una forma de resolver esto es usando hilos (Threads) haciendo uso de la clase Thread de System.Threading. Pero en esta ocasión veamos una forma mas fácil y en mi punto de vista un poco mas agradable, para esto haremos uso de los delegados, a estas alturas la mayoría de los programadores de .Net ya saben que es un delegado, en caso contrario veamos una definición del MSDN:

Un delegado es un tipo que hace referencia a un método. Cuando se asigna un método a un delegado, éste se comporta exactamente como el método. El método delegado se puede utilizar como cualquier otro método, con parámetros y un valor devuelto.

En otros términos un delegado es un puntero a función, bien una vez que sabemos esto, les dejo el ejemplo de como usar los delegados para ejecutar los siguientes escenarios.

Método sin parámetros.
Método con parámetros.
Método con parámetros y lanzando eventos.

En el ultimo escenario se actualiza la UI, puesto que la operación asíncrona es ejecutada sobre un hilo diferente, no se puede actualizar objetos de la UI directamente así que tenemos que ejecutar el método sobre el mismo hilo usando el método Invoke del formulario, aunque este método es síncrono no detiene ni "congela" la UI, en el ejemplo uso un ciclo para actualizar una etiqueta, usando Invoke la actualización se ve un poco afectada actualizando un poco lento la UI, si actualizamos controles de usuario solo cuando termina el método esto no será inconveniente, aun así pueden usar el método BeginInvoke del formulario para ejecutar el método asíncrono, esto actualizara mas rápido la UI en ciclos como en el ejemplo pero afectara al rendimiento de la CPU, pueden probar usando Invoke y BeginInvoke y viendo en el ‘administrador de tareas’ el consumo de CPU usando las 2 opciones y así ustedes podrán decidir que usar.

Cabe aclarar que esto no reemplaza a los hilos (y que al final de cuentas usa hilos los delegados), ustedes tienen que decidir en que escenario es mejor usar esta forma, usar Threads o alguna otra.

Espero les sea de utilidad y recuerden darse una vuelta por el MSDN Library para conocer las características avanzadas de las clases y así decidir cuando es conveniente usar que cosa.

Cualquier comentario o error en código o los conceptos dejen comentarios aquí o a djnavi - gmail - com

Descargar ejemplo aquí

Pues bien, después de mucho tiempo sin “postear”(spanglish) tengo para ustedes una clase para poder usarla dentro de un ListView, esta clase es un progressbar que se mostrara dentro de los items de un listview, es muy sencilla de usar y a mas de uno le será de utilidad.

Veamos un ejemplo de como usarla
ProgressBarSubItem pbs = new ProgressBarSubItem();

pbs.Minimum = 0;
pbs.Maximum = 100:
pbs.Value = 0;

pbs.ColorGradientInit = Color.SteelBlue;
pbs.ColorGradientEnd = Color.Navy;

pbs.BackColor = Color.Black;
pbs.ForeColor = Color.WhiteSmoke;

pbs.ColorBorder = Color.WhiteSmoke;

Ya que tenemos nuestro objeto creado, lo agregamos a un ListViewItem de nuestro ListView, y usamos la propiedad Value para aumentar nuestro progreso, debemos refrescar el ListView, espero tener pronta una versión para que la clase refresque el ListView y no el programador.

Les dejo el ejemplo junto con las clases, espero les sea de ayuda, cualquier comentario pueden dejarlo aquí o enviarme un correo a djnavi [a-t] gmail [dot] com

Descargar aquí código fuente