miércoles, 23 de diciembre de 2015

Sobre la GUI de ZinjaI (anexo)

Más novedades en este boletín... O más pequeñas mejoras en ZinjaI para esta próxima release. Siguiendo con el tema de la interfaz, hoy les cuento otro detalle que agregué, y lo aprovecho como excusa para asentar algunas explicaciones de cómo funciona el proceso mediante el cual la interfaz "evoluciona".

viernes, 11 de diciembre de 2015

Sobre la GUI de ZinjaI

Siempre digo que ZinjaI está pensado para dos tipos de usuarios muy diferentes: para el alumno que recién empieza y necesita algo simple; y para el programador avanzado que desarrolla un proyecto de tamaño considerable y necesita algo potente. Estos dos objetivos son a todas luces contradictorios e incompatibles entre sí... ¿o no? ¿Cómo es que sigo sosteniendo semejante contradicción? ¿cuál es la estrategia para justificarlo? He aquí algunos criterios y tips sobre porqué es cómo es, y cómo ajustarlo a gustos particulares.

lunes, 30 de noviembre de 2015

Cuando el backtrace no dice nada...

Una nueva versión de ZinjaI se aproxima. En realidad, las vacaciones se aproximan, y eso probablemente haga que se aproximen nuevas versiones de todo. Pero hoy les cuento de ZinjaI. No hay grandes super-novedades en esta versión. Al menos no hasta el momento. Sí hay un millón de pequeños cambios y correcciones que juntos suman. Pero entre lo poco destacable hay tres "pequeñas" mejoras en la interfaz de depuración que pueden ser muy útiles.

jueves, 12 de noviembre de 2015

ZinjaI y PSeInt "portables" (para llevar)

Pongo "portables" entre comillas porque me voy a referir a una definición de "portable" que no me gusta. En mis tiempos (como diría el abuelo Simpson) "portable" significaba que podía ejecutarse en diferentes plataformas (GNU/Linux, Windows, Mac OSX, Android, etc). En algún momento el mundo cambió y para cuando yo me di cuenta en Internet se hablaba de "portable" como sinónimo de "no tenés que instalarlo" o "te copias la carpeta en el pendrive y lo corrés desde ahí". Bien, les vengo a contar cómo conseguir esa "portabilidad" [trucha] para ZinjaI y PSeInt. No es mucho trabajo, pero hay un detalle que no estaba documentado y que viene muy bien para el caso. Por si alguno llegó pensando en la otra "portabilidad" (la buena :), de esa ya había hablado en este post.

lunes, 26 de octubre de 2015

...se encienden las ilusiones

Si realmente te gustan las carreras de motos, ya sabías cómo se iba a titular este segundo post. Se nos pone la piel de gallina cada vez que Martín Urruty pronuncia estas palabras un domingo a la mañana. Pero más allá del pequeño homenaje al relator (y extiendo mi simpatía también a su genial compañero Gustavo Morea), la idea es seguir hablando de cómo avanza MotoGT 2. En el post anterior comentaba que la escena principal (la carrera) ya empezaba a tomar forma, con varios cambios en el Game, y ya casi sin trabajo del lado del Engine y su Bridge. Sin embargo, sí hubo otro pequeño trabajo en el Engine, y queda por hacer uno más grande en el bridge. Hoy les cuento de qué se trata y de paso les traigo otro video.

martes, 20 de octubre de 2015

Se apaga el semáforo...

Hoy toca otra actualización del estado de MotoGT2 (video incluido!). Está avanzando relativamente rápido. El tiempo inicial invertido en el diseño del motor está pagando y con creces. La base ya está sólida, todo lo que tenga que ver con gestión de recursos, despliegue de gráficos, gestión de escenas, lógica interna del juego, y entradas ya está modelado y tiene al menos una primer implementación funcional. El único sistema grande en el cual aún no avancé nada es el de sonido, pero habiendo resuelto los otros, no es algo que me preocupe.

lunes, 12 de octubre de 2015

"Compilando" circuitos en MotoGT

Los que hayan jugado MotoGT sabrán que la primera vez corren en un circuito deben esperar buen rato hasta que cargue. Luego, las siguientes veces carga mucho mucho más rápido. Esto se debe a que cuando descargan MotoGT no descargan todas las imágenes que necesita para montar el circuito en pantalla. En su lugar, descargan otro conjunto de imágenes, a partir de las cuales se puede obtener el primero. Digamos que serían como los "fuentes" de los gráficos del circuito. Esto es así por varios motivos interesantes que vengo a comentar. Y como en estos días estuve reimplementando todo ese sistema para MotoGT2, también traigo novedades y algunas capturas para que vean cómo está mejorando el juego.

lunes, 5 de octubre de 2015

El control del tiempo en MotoGT2 (parte 2)

Hace unos días hablaba de qué es esto del "framerate" en un juego, cómo se puede relacionar con la física del mismo, y cuál era la solución simple que había usado en MotoGT 1. Si ya entendieron eso, ahora toca mostrar la solución un poco más complicada que estoy usando en MotoGT 2.

martes, 29 de septiembre de 2015

El control del tiempo en MotoGT2 (parte 1)

La gestión de los FPS en un juego es mucho más compleja de lo que parece a primera vista. Para MotoGT 1 usé la técnica más simple y menos elegante: framerate constante. Para MotoGT 2 empezé tratando de independizar la velocidad de la física de la del rendering, usando para lo primero un velocidad constante, pero implementando el código de forma tal que esa constante pudiera ser ajustada luego. Pero ahora la cosa mutó, y resulta que al final el framerate ya no es constante, para ninguna de las dos. Hubo que resolver algunos conflictos, pero la inversión pagó, la diferencia se nota mucho más de lo que había imaginado.

miércoles, 16 de septiembre de 2015

Nuevos atajos en ZinjaI (parte 2/2)

En el post anterior les comentaba que la última release de ZinjaI traía algunas funcionalidades nuevas que no están tan a la vista pero que pueden ser muy útiles para acelerar nuestra codificación. Y les conté de lo nuevo en el menú "Generación de código" (si no lo leyeron, empiecen por ahí antes de seguir con este). Lo que quedó para la segunda parte son los cambios en los autocódigos y una nueva forma de edición múltiple.

jueves, 10 de septiembre de 2015

Nuevos atajos en ZinjaI (parte 1/2)

Las versiones de agosto de ZinjaI traen unas pocas novedades, pero creo que a pesar de ser pocas tendrán un gran impacto, ya que parecen muy útiles. Son algunos atajos para escribir más rápido. Por ahora están algo verdes, pero hay muchos escenarios en los que ya se pueden utilizar. Particularmente les vengo a comentar de tres cosas: las nuevas opciones en el submenú "Generación de código" del menú "Herramientas"; una mejora interesante en el mecanismo de autocódigos; y una nueva forma de editar varios lugares al mismo tiempo. La primera en este artículo, las otras dos quedarán para la segunda parte.

En lo personal, para mí son las tres cosas que no sabía que quería, pero que ahora que las probé las uso cada dos minutos y ya no puedo programar sin ellas. El objetivo de todo esto es como siempre escribir el código muy rápidamente. Y con acento en el "escribir". En un mundo ideal, el tiempo lo tenemos que invertir en "pensar" y no en "escribir". Entonces, mejor aprender a sacarle provecho a todo lo que el IDE nos ofrezca para el "escribir", para que consuma mucho tiempo menos que el "pensar". Sin más preámbulos, he aquí los nuevos trucos.

lunes, 7 de septiembre de 2015

And the winner is... (II)

Todas las semanas alguien del staff de SourceForge elige 10 proyectos para destacar, con algún criterio que no estoy seguro cual es, pero que por suerte le da iguales oportunidades a proyectos chicos y grandes. Luego, a fin de mes, de entre todos los destacados de ese mes, se elige un subgrupo de 9 o 10 proyectos y se somete a votación para determinar cual es el próximo "Community Choice Project Of The Month" (proyecto del mes (POTM) elegido por la comunidad). El ganador ostenta el título durante un mes. A veces, los editores eligen uno más como "Staff Choice POTM". Si entran al home de SF, lo primero que verán serán los proyectos destacados del mes, y lo segundo, los de la semana. Para cada proyecto destacado del mes, además, SF publica una entrevista con alguno de los desarrolladores en su blog. Pues bien, este mes (Septiembre 2015) el "Community Choice POTM" es nada más ni nada menos que PSeInt!!!

viernes, 28 de agosto de 2015

¿Dónde consigo un anti-antivirus?

Hoy planeaba a publicar otra cosa, pero necesito hacer catarsis. Ayer recibí dos quejas consecutivas sobre que el instalador del último ZinjaI parecía contener algo malicioso a ojos de algunos antivirus. Es muy poco probable que tal afirmación sea verdad, más abajo les cuento por qué. Y efectivamente no lo era, el antivirus estaba confundido. Pero me resultó muy alarmante descubrir dónde estaba la confusión. Y para colmo la experiencia de uso de un antivirus me pareció inverosímil. Como programador, entiendo el trabajo de locos que requieren y las concesiones que se deben hacer. Pero creo que pasaron la raya, y por mucho. Lo que vi no tiene justificación, prefiero mi PC llena de bichos antes que trabajar así. Ahora les cuento.

viernes, 21 de agosto de 2015

La zona del programador

Soy de esa clase de personas que les gusta mucho perder invertir tiempo buscaaando y probaaaando herramientas, o peor aún, haciéndose las propias. Y no es raro que se me valla más tiempo y esfuerzo en esa búsqueda o construcción, del que llevaría resolver el problema particular para cuya resolución quiero esa herramienta. Sin ir más lejos, hace muy poquito les conté sobre un error tonto que me llevó a programar dos nuevas funciones en ZinjaI, y que encima al final ni las necesitaba. Este tipo de cosas (el desviarme para buscar, hacer y/o automatizar herramientas y procesos) me ocurre todo el tiempo, y creo que es común en muchísimos programadores. El problema es que cuando uno desarrolla estas herramientas no-indispensables uno tiende a sentirse algo culpable por no trabajar directamente en la solución del problema, sino posponerla por una deformación profesional propia. Si esto también te pasa a vos, mi valioso lector, este post viene a darte algunas excusas para que dejes de sentirte culpable y valores ese trabajo.

lunes, 10 de agosto de 2015

Preguntas frecuentes sobre PSeInt

Hay tres preguntas acerca de las funcionalidades o el futuro de PSeInt que recibo periódicamente una y otra vez, ya sea en los foros, en mi correo, o a veces hasta en persona. Básicamente, sobre PSeInt para Android, sobre PSeInt en otros lenguajes, y sobre el uso de registros/structs en el pseudolenguaje. Les adelanto que son tres cosas que actualmente no están disponibles en PSeInt, pero si siguen leyendo les cuento mejor por qué no, y qué podemos puede hacer al respecto.

jueves, 30 de julio de 2015

ASM caliente para el alma del programador

Depurar programas paralelos es terriblemente complicado. Y cuando uno le suma a eso su propia idiotez el combo se torna mortal. Esta semana perdí dos días completos por culpa de un error de tipeo. Pero, como toda historia para que merezca ser contada debe tener algún lado bueno, en este caso, mis dos días de caza incluyeron el desarrollo de un par de funcionalidades nuevas en ZinjaI. Funcionalidades que al final de cuentas no necesitaba en absoluto para resolver ese problema, pero que en algún momento pensé que sí, y supongo que a futuro ya les daré mejor uso. Se trata de un par de paneles para inspeccionar el código de máquina generado por el compilador, y el estado de los registros internos del procesador durante la depuración. He aquí la anécdota completa y el resultado.

jueves, 23 de julio de 2015

La escencia de la programación de computadores

El gran Brian Kernighan escribió una vez, hace como mil años (circa 1976), la siguiente frase:

"Controlling complexity is the essence of computer programming."

Una posible traducción sería: "El control de la complejidad es la esencia de la programación de computadoras." Debo haber leído esta cita por primera vez hace al menos 10 años. En su momento me pareció una más. No eran palabras rimbombantes, ni conceptos extraños. Parecía más bien un punto de vista, una opinión, con algo de cierto, algo de exagerado, como tantas otras. Otras frases me impactaron/gustaron mucho más cuando las leí por primera vez. Sin embargo, con esta pasó algo muy especial. Con el tiempo, muuuy lentamente, a medida que cometía mis propios errores e iba aprendiendo con cada uno de ellos a programar un poquito mejor, me fui dando cuenta de que esa no es una frase más, sino una de las verdades más profundas e indiscutibles que podemos enunciar sobre la programación.

miércoles, 8 de julio de 2015

El Para y los diagramas de flujo: ese pequeño gran detalle

Una pregunta en el foro de PSeInt trajo consecuencias inesperadas. La versión corta de la historia: hace más de 10 años que cometo sistemáticamente un error en mis diagramas de flujo (y entonces el error está en los diagramas de PSeInt). Es un detalle, pero según cómo se mire, puede no ser menor. Antes de revelar cuál es y contar la historia, hagamos una prueba. Solo voy a decir que el error está relacionado a la estructura repetitiva Para (el "for"). Antes de seguir avanzando en la lectura de este post, intente adivinar qué tiene "mal" el siguiente dibujo:

jueves, 2 de julio de 2015

Mientras tanto, en... (III)

Van dos meses sin novedades visibles en PSeInt: sin publicar versiones nuevas, sin hacer comentarios en el blog y sin terminar de ponerme al día con el foro. Por el lado de ZinjaI, pasa algo similar (no hay versiones desde hace 4 meses), aunque es más común dado que los cambios en ZinjaI usualmente requieren más tiempo y más pruebas. Y para completar, hace casi un mes que no escribo nada en el blog. En ambos proyectos hemos visto períodos mucho más largos sin novedades, pero no quiere decir que esa situación me simpatice. Me gusta que siempre haya algún movimiento, por mínimo que sea. Y en verdad lo hubo. Tratando de seguir la filosofía "release erale, release often", en breve lanzaré un par de actualizaciones para compartirlos. Mientras tanto, les cuento por dónde pasan los cambios y les adelanto un "trailer" de la próxima release.

viernes, 5 de junio de 2015

std::function: Ya tengo mi (nuevo) martillo

Todos conocen la frase "si solo tienes un martillo, todo te parece un clavo" o alguna variación con la misma idea. A mi, con la programación me pasa algo curioso. Tengo una caja repleta de herramientas de todo tipo, pero cada vez que agrego a la caja un martillo nuevo, todo lo demás se me convierte en clavo. Mi caja está mayormente llena de C++. Diría que casi todo C++03 está en la caja, y que gradualmente he ido agregando herramientas de C++11/14. En algún punto me pasó con eso de SFINAE y los trucos que se podían hacer, y los apliqué por todos lados. En otro momento, agregé a la caja las maravillosas "Variadic Templates" y grité "I have a hammer!", y variadic templates para todos.

Ahora, la funcionalidad de C++11 que se está tornando increíblemente "martillosa", es la aparición de las funciones lambda, y como yapa de la clase auxiliar std::function. Es decir, la posibilidad de crear funciones y clausuras "al vuelo", sin siquiera ponerles tipo ni nombre, y la facilidad que provee la clase std::function para apuntarle a esos pequeños monstruitos sin que nos importen ni preocupen sus especies. En MotoGT 2 están martillando cuanto clavo (y tornillo) se les cruza. Y el resultado es una delicia. Un buen motor puede dar muchas más libertades sin agregar ruido cuando hace uso de estas cosas, y permite al programador ser mucho más productivo.

domingo, 31 de mayo de 2015

Las bases de MotoGT 2: overview

Hace un tiempo les comenté que pienso reescribir MotoGT desde cero. Llamo a este proyecto MotoGT 2. Aunque por fuera, al principio será un clon del primer MotoGT con apenas unos pocos detalles nuevos visibles, por dentro la historia es totalmente diferente. El objetivo es obtener una base de código más sólida con la cual experimentar fácilmente agregando y quitando cosas al juego, para que lo que limite su desarrollo sea mi creatividad y mi poca idea de game-design, y no un código complicado y difícil de modificar o mantener.

Entonces, tengo que escribir un pequeño motor de juego. Lo suficientemente general como para que me provea esa flexibilidad. No tan general como para renegar con cosas que no necesito. Con una interfaz de alto nivel para no lidiar con detalles finos de implementación al concetrarme en la lógica del juego. Con capas o subsistemas desacoplados para que, por ejemplo, la biblioteca que use para gráficos y sonido no me condicione la forma de programar esa lógica del juego. Y más, como para que un imprevisto no tire abajo el proyecto.

martes, 26 de mayo de 2015

Constructores privados y std::shared_ptr

Tuve un problema de diseño/implementación con una clase en particular mientras escribía algunas cosas básicas para el nuevo MotoGT, que me resultó muy interesante por lo simple que es el planteo, y por los caminos rebuscados que puede tomar la respuesta. Básicamente quería garantizar que las instancias de una clase particular solo se pudiesen crear por medio de una función auxiliar. La solución habitual es poner el constructor de la clase como privado/protegido y hacer a la clase amiga de la función. Pero esto no es 100% seguro desde algún punto de vista y, por sobretodo, se complica cuando queremos usar std::shared_ptr y std::make_shared con esa clase. Si no se van, les cuento mejor dónde aparece el problema, para qué sirve, y a qué solución llegué.

martes, 19 de mayo de 2015

Problemas con la terminal y el depurador (parte 2)

Empecé el artículo anterior diciendo que iba a mencionar dos problemas con las terminales y la depuración en ZinjaI, pero como se hizo largo describí solo uno. Pues aquí viene el segundo. Es un problema levemente relacionado, muy molesto, pero generalmente inofensivo. Es el mensaje "&warning: GDB failed to set controlling terminal: Operation not permited" que se muestra al comenzar la depuración en GNU/Linux. Desde la versión 7.0 de gdb, muchos IDEs sufren este mensaje, que asusta al usuario inexperto y genera consultas de lo más variadas. Hay miles de hilos al respecto en foros varios en Internet, pero absolutamente ninguna solución. Yo tampoco pude solucionarlo, pero al menos llegué a entenderlo y me convencí de por qué en general no se puede, y qué consecuencias puede traer. Vengo a documentarlo porque leí miles de respuestas, y la mayoría no están ni remotamente cerca de la verdadera causa, y sus consecuencias.

miércoles, 13 de mayo de 2015

Problemas con la terminal y el depurador (parte 1)

Estuve analizando dos diferencias en el comportamiento de la terminal que usa ZinjaI para ejecutar un programa o proyecto entre la ejecución normal y la ejecución para depuración. La primera es que hasta ahora, la terminal donde se ejecuta la depuración se cierra al finalizar el programa, pase lo que pase, y no le hace caso a las opciones de ejecución que pueden decir que espere una tecla, o que no se cierre si el código de salida no es 0. Esto implica que en la mayoría de los casos, si una ejecución en el depurador finaliza como debe, no llegamos a ver los resultados, a menos que nos tomemos el trabajo de poner algún breakpoint al final del main. Tengo solo la mitad de este problema resuelto.

martes, 5 de mayo de 2015

Variables globales otra vez

Ya comenté que pensaba reescribir desde cero MotoGT. También que el no poder predecir/controlar el orden en que se construyen y destruyen las variables globales me trajo serios problemas. Pues bien, dado que en el nuevo MotoGT voy a volver a usar una buena cantidad de variables globales, me vi forzado a repensar el problema. Y finalmente, encontré una buena solución, con la que puedo tener mis queridas y odiadas variables globales, pero puedo además asegurarme de que se creen y destruyan en un orden correcto.

martes, 14 de abril de 2015

La terminal en blanco y una historia de variables globales

En marzo publiqué una actualización de PSeInt, y tardé como 20 días (mayormente por mi culpa, por mi delay con los foros) en notar que a varios usuarios no les funcionaba ni la ejecución básica. Cuando querían ejecutar un algoritmo, la terminal quedaba en blanco; y si querían editar el diagrama de flujo, estaba vacío. Y así algunos problemas más, pero todas cosas gruesas, importantes, absolutamente impresentables.... Y entonces ¿cómo es que subí eso y no me di cuenta? He aquí una historia de variables globales y estáticas en C++, con moraleja conocida: evitarlas a toda costa.

jueves, 9 de abril de 2015

MinGW64 y otras variantes para ZinjaI en Windows

Se supone que ZinjaI está preparado para configurar fácilmente más de un posible compilador. En GNU/Linux, suelo alternar entre gcc y llvm-clang sin problemas. Pero en Windows, el cambio es un poquito más delicado, porque el compilador y demás herramientas afines que están como parte de ZinjaI, y no del sistema. Si bien se suponía que era posible hacerlo de todas formas, y que teóricamente el cambio debía ser simple y directo, de la teoría a la práctica suele haber un buen trecho, y por eso no le tenía plena confianza a esta funcionalidad. Pero hace unos días finalmente lo probé y verifiqué que (muy sorprendentemente) funciona justo como esperaba. Y esto es algo muy bueno, porque ya es hora de empezar a utilizar 64bits. En este post les cuento cómo configurar otro MinGW que no sea el que trae ZinjaI, tomando una versión alternativa de 64bits como ejemplo, qué tiene esto de bueno, y cuáles son por ahora las limitaciones.

sábado, 4 de abril de 2015

La venganza de MotoGT (parte 2/2)

Les comenté hace poco que llegué a la inevitable conclusión de que tengo que reescribir MotoGT. A pesar de algunas ideas nuevas que mencioné para el diseño del juego, lo más importante es que en realidad ya no puedo seguir trabajando sobre el mismo proyecto. Y esto se debe a cuestiones técnicas, cuestiones de programación. Y como programar es lo que me gusta, muy probablemente me divierta más re-escribiendo el juego que jugandolo una vez "terminado".

lunes, 30 de marzo de 2015

La venganza de MotoGT (parte 1/2)

Hace unos días, cuando tuve algo más de tiempo libre de lo habitual, gracias a un fin de semana largo, intenté retomar algunas viejas cuestiones pendientes de MotoGT. Mi principal problema era (y es) migrar todo a SFML 2.x. Además, de eso, el juego estaba incompleto, y tenía algunas pocas ideas para mejorarlo. Pero al final no llegué a migrar ni implementar nada nuevo, sino que "solamente" (no es poca cosa) llegué a algunas conclusiones importantes al respecto. Resumiendo: tengo que escribir MotoGT 2, de cero. Los motivos son mayormente técnicos, pero en el medio de todo esto, hay lugar para muchas mejoras en el diseño del juego.

viernes, 20 de marzo de 2015

El boom de la Programación Funcional (parte 3/3)

Después de contar cómo fue mi primer acercamiento con la programación funcional y lo importante que me parece aprender algo al respecto (parte 1), y por qué siendo un paradigma tan viejo ha tomado nueva fuerza en los últimos años gracias al auge de la programación paralela principalmente (parte 2), hoy cierro contando muy básicamente cómo se lleva esto a mi lenguaje favorito, C++, que desde 2011 ha facilitado mucho las cosas en este sentido.

sábado, 14 de marzo de 2015

El boom de la Programación Funcional (parte 2/3)

Esta es la segunda parte de una trilogía de posts con desvarios propios y ajenos relacionados a la programación funcional. En la primera, hice una pequeña introducción intentando convencerlos de lo útil e interesante que es esto, pero sin decir nada en realidad. Y conté luego cual fue mi primer acercamiento casual a la misma, remontándome gracias a la Internet 30 años atrás. En esta segunda parte, volvemos a la actualidad, y les cuento cómo es que en estos últimos años se ha vuelto más importante.

lunes, 2 de marzo de 2015

El boom de la Programación Funcional (parte 1/3)

Desde hace relativamente pocos años, el paradigma de la programación funcional ha tomado un nuevo auge, hasta el punto en que hoy en día podríamos considerarlo como una especie de "trending topic" en el mundillo de la programación en general. Podría decir que los conceptos esenciales son más viejos que la programación misma. Pero, para alguien como yo, que tuve toda mi formación inicial en lenguajes estructurados y procedurales, que luego pasé a la "moderna" orientación a objetos, y que desde hace años C++ es mi herramienta de trabajo en el día a día, esto es nuevo. Es algo que empezó a hacerme ruido con la estandarización de C++11, y que por lo que veo, gracias al auge del paralelismo, llegó para quedarse.

Hay muchos programadores sueltos que han tenido una formación similar a la mía, y que aún no descubren lo enriquecedor que es el mundo de la programación funcional. A esos colegas les estoy escribiendo. Por que si bien, es muy probable que yo nunca use de verdad un lenguaje realmente funcional, las ideas que me va implantando el aprender sobre este paradigma sí repercuten en mi forma de pensar los problemas y analizar las implementaciones. Creo que todo informático debería tener una formación básica en programación funcional, con el solo objetivo de abrirle la cabeza a otra forma de analizar un programa y de entender la programación.

martes, 24 de febrero de 2015

Mientras tanto, en PSeInt... (II)

Es tiempo de volver a hablar de PSeInt. Hace no mucho escribí un artículo que empezaba con "Hace ya un buen rato que no vemos versiones nuevas de PSeInt. En buena parte se debe a que..." y continuaba con una serie de excusas y pseudo-promesas. La mayoría de las excusas siguen siendo muy ciertas, y algunas hasta se agravaron, pero como dije aquella vez, esto no significa que en el desarrollo de PSeInt no ocurra nada. A solo dos días de aquel post publiqué una actualización con esos pocos cambios que había comentado. Esta vez no van a ser dos días, pero sí otra vez muy pocos hasta que publique oficialmente una nueva versión. Este post es más o menos un informe de situación para actualizar esa lista de excusas y pseudo-promesas, comentando otra vez qué fue lo poco que estuvo ocurriendo, y qué esperar para el futuro.

martes, 10 de febrero de 2015

Herramientas personalizadas en ZinjaI

Desde hace algunas versiones, ZinjaI permite definir hasta 20 herramientas personalizadas. Esto es, hay items en el menú de herramientas (y opcionalmente sus correspondientes botones en la barra de herramientas, y/o sus atajos de teclado) para los cuales el usuario puede configurar acciones a gusto. En la última versión, hay mejoras que las hacen más flexibles y fáciles de usar que antes. Esto está pensado para cosas que requieren ejecutar programas externos a ZinjaI, como puede ser abrir una referencia de una biblioteca en un navegador, ejecutar scripts de mantenimiento, o ejecutar un proyecto de forma alternativas. Pueden configurarse herramientas "globales" (para esa instalación de ZinjaI, siempre disponibles), y por proyecto (disponibles en cualquier ZinjaI solo para ese proyecto). En este post pongo algunos ejemplos de uso para mostrar qué cosas se pueden hacer y presentar algunas de las opciones nuevas que pueden resultarles útiles.

martes, 3 de febrero de 2015

Aprendiendo a programar... otra vez

Durante el año pasado aprendí muchísimo sobre C++. Leí cuanto blog especializado me pasó cerca, y miré cuanta charla encontré en Internet de gente que está en la cresta de la ola. Entendí detalles muy finos que desconocía de C++03, traté de incorporar todo lo que pude del nuevo C++11, y hasta algunas cosas muy frescas de C++14. Y mi forma de encarar este nuevo contenido fue variando hasta dar un giro de 180 grados. Empecé pensando que sabía programar (con el viejo C++, y también hablando en general) y que el proceso consistiría en aprender solo otro lenguaje. Pero terminé dándome cuenta que en realidad aprendí a programar "otra vez". O mejor dicho, que recién ahora estoy aprendiendo a programar como se debe.

viernes, 16 de enero de 2015

Herramientas Mágicas: Doxygen

Siguiendo con la vieja serie de post sobre Herramientas Mágicas, hoy voy a comentar la tercera y última herramienta del grupo que inicialmente tenía en mente cuando empecé con esta serie. Esta la menos mágica, pero no es menos útil que las otras dos. Hay varias herramientas más para comentar, ya lo haré más adelante, pero estas primeras tres son las que me resultaron más útiles en general. La herramienta en cuestión es Doxygen, y sirve para generar documentación acerca de un código fuente. Es ideal para documentar las interfaces de nuestras bibliotecas. A esta altura deberíamos suponer que la mayoría de ustedes ya la conoce o conoce alguna otra similar. Pero... (no le digan a nadie) yo me gradué de informático sin haber usado nada que se le parezca. Para ayudar a que eso no le vuelva a ocurrir a otros, voy a escribir un poco contando de qué se trata, presentar un ejemplo, mostrar que ZinjaI puede facilitar su uso, etc.

martes, 6 de enero de 2015

¿Soy un programador o un depurador?

De las múltiples actividades de las que consta el día día de un programador, en mi caso (y en el de muchos) tipear código o dibujar diagramas de clases (por dar un par de ejemplos de actividades "estereotípicas") no es lo que más me ocupa. La mayor parte de mi tiempo como programador se me va "depurando". No es que le reste importancia a las etapas previas (todo lo contrario, cada vez las valoro más), ni que sea tan animal que por cada linea de código que escriba cometa tres errores. Pero es así. Y esto se contradice un poco bastante con lo que a uno le enseñan en la universidad, sobre primero pensar, diseñar, analizar, bosquejar en papel, y solo luego sentarse a codificar. Se puede argumentar que tanto depurar es consecuencia de saltarse o apurarse en las etapas previas. Entonces: ¿es una muy mala señal pasar más tiempo depurando prototipos erróneos o incompletos, que pensando primero y escribiendo luego las cosas bien, sin tantos defectos? Creo que no necesariamente.