¿Cómo empiezan ZinjaI, PSeInt y MotoGT el 2017?

Finalmente termina el año, y con él un cuatrimestre de trabajo, y llega un período de pseudo-descanso. El cuatrimestre que acaba de terminar, como todos, fue especialmente difícil: esta vez porque se me juntaron varias materias y terminé dando entre teorías y prácticas 6 clases por semana! Eso me dejo sin tiempo para mis proyectos libres... hasta hace unas semanas. Cuando terminó pude de a poco retomar los desarrollos. Ya leyeron las primeras novedades. Pero hay más en camino, y algunas muy importantes.

Actualizando MinGW

El toolchain que incluía hasta hace 2 días el instalador de ZinjaI para Windows estaba muy desactualizado. En el momento en que lo armé, la versión más reciente de gcc disponible era la 4.8. Actualmente ya está por liberarse la 6.3, aunque las 5.x son las consideradas más estables. Hace rato que quería actualizar lo que uso en ZinjaI, pero en Windows, cada actualización implicaba muchísimos dolores de cabeza.

Cómo "actualizar" la terminal con solo recompilar

Supongamos que estoy dando clases, resolviendo un ejemplo en el proyector. Me gusta armar las soluciones en vivo, para que se vea el proceso, las decisiones, y hasta las equivocaciones. Entonces, supongamos que empiezo a resolver una partecita de un problema y la pruebo. Si anda paso a otra, si falla retoco el código y vuelvo a probar. En cualquier caso, el ejemplo suele requerir unas cuantas ejecuciones de ese mismo código que va evolucionando de a poco. Estaría bueno tener en ZinjaI una facilidad como la PSeInt: que si mantengo la terminal abierta, al cambiar el código el programa se re-ejecuta automáticamente en esa terminal, "actualizando" el resultado.

No quiero algo tan complejo como esto o esto, ni cerca, sino algo bien bien simple, que no requiera nada de instrumentación, y que tampoco agregue ruido a la clase. Con ZinjaI y la ayuda de bash, es posible, hoy, sin esperar a actualizaciones.

El hardware y yo

El hardware y yo usualmente no nos llevamos bien. Se me da mejor con el software. Podría decir que he tenido mala suerte con las tres notebooks que tuve. La tercera, una Samsung, parecía ser la vencida, hasta que la semana pasada decidió tildarse para nunca volver a encender. Y por eso tuve que volver que a la segunda, una Vaio con mil problemas, sobre la cual podía hacerme una hamburguesa con solo apoyarla en el teclado y mandar a compilar un proyecto acorde al tiempo de cocción. Traté de solucionarlo, y pasó algo curioso.

Aplicando cambios sin reiniciar en C/C++ (toma 2 -cont.)

Hace poco les conté cómo usar bibliotecas dinámicas para emular una suerte de "edit and continue" en cierto tipo de programas. La idea es simple: la parte que quería poder editar durante la ejecución (conjunto de clases y funciones) va a parar a una biblioteca dinámica. En lugar de dejar que el compilador la enlace al ejecutable, voy por la vía complicada y realizo la carga de la biblioteca "manualmente". Esto me da la posibilidad de descargarla y volverla a cargar en cualquier momento (cuando cambie). El post detallaba cómo hacerlo en GNU/Linux; pero ahora me di cuenta que en Windows hay cuatro problemas nuevos e interesantes para tener en cuenta.

Los Lunes de Software Libre

A partir de ahora los lunes serán los días en que más movimiento vean relacionado a ZinjaI, PSeInt, o incluso en este foro. Resulta que en este cuatrimestre estoy participando en el dictado de 3 materias en simultáneo, en lugar de 1 o 2 como venía ocurriendo hasta el pasado. Esto consume casi toda mi semana y me deja muy poco tiempo libre para repartir entre estos proyectos y muchas otras actividades personales. Así que decidí asignar un espacio de tiempo mínimo pero fijo para ZinjaI y PSeInt, de modo que al menos le dedique algunas horas cada semana.

Dedicado a ustedes, nuestros futuros pioneros...

Cucarachas Racing es un blog sobre programación, software libre y cosas técnicas, pero también se desliza cada tanto algún post diferente, a veces relacionado a la docencia o a la educación... como este.

Aplicando cambios sin reiniciar en C/C++ (toma 2)

Hace ya un tiempo les mostré en este blog dos trucos interesantes que puede hacer ZinjaI durante la depuración: uno para modificar atributos de objetos mientras el programa corre, y otro para modificar el ejecutable durante una pausa en la depuración y continuar sin reiniciar. Ambos se basan en automatizar y esconder ciertas secuencias de comandos gdb, y ambos tienen serias limitaciones, especialmente el segundo. Hoy les traigo una nueva alternativa, que resulta bastante más flexible, pero a diferencia de las anteriores, se basa en instrumentar el código. Vean primero el resultado en el siguiente video, y después les explico cómo se logra.

Errores más a mano en ZinjaI

Estuve implementando algunos cambios en ZinjaI para poder hacer más cosas de las que hago con la lista de warnings y errores que da el compilador. Hasta hace poco, toda la salida se concentraba en el panel de resultados exclusivamente, pero ahora agregué otra forma de ver los errores que puede ser mucho más cómoda para pequeños programas autocontenidos, como los que hacemos en el aula en las clases de programación.

Otro nuevo mini-proyecto: sinad

Uno de estos días se juntaron algunas condiciones que derivaron en otro nuevo proyecto. Algo pequeño, de escala similar al wxte. Es decir, una herramienta que armé para solucionarme un problema y que publico por si a alguien más le sirve o lo quiere tomar como punto de partida para otra cosa mejor. Se trata de un programita para generar una presentación (slides) en base a un archivo de texto. Lo empecé a usar para las presentaciones que hago para mis clases de programación. El gran objetivo de esta herramienta es independizar el contenido del formato o estilo visual, y creo que lo logra.

Markdown vs HTML

Cuando necesito colocar texto con formato en ZinjaI o en PSeInt uso html. Por ejemplo, en ventanas y paneles de ayuda, o en enunciados de ejercicios autocontenidos. Uso html porque wxWidgets tiene un componente propio e independiente para mostrarlo. Lo de "propio e independiente" es porque no se basa en embeber un navegador real (para eso también hay), sino que la misma wx parsea y renderiza por su cuenta. Obviamente esto limita muchísimo ese html (nada de css, nada de javascript, nada complicado), pero hace que sea mucho más liviano y me evita grandes dependencias. Hasta ahora venía escribiendo "a mano" los htmls, total el html que soporta es tan simple y limitado que es fácilmente manejable. Pero...

Registros en PSeInt: Paso 0

Uno de estos días quise empezar con la implementación de registros en PSeInt. Para esto hay que reestructurar algunas cosas, y quiero aprovechar la volteada para arreglar otras. Entre los principales cambios, está la forma representación interna de una variable (tanto de su tipo, como de su contenido). Un cambio así repercute por tooodas partes. Creyendo que ya tenía un panorama completo de lo que buscaba, mucha experiencia de los diseños anteriores, y una buena batería de tests automáticos, empecé a  escribir desde cero nuevas clases superpoderosas para tipos y datos contemplando las infinitas combinaciones (cosas como una referencia a un arreglo de registros con atributos escalares de tipos todavía sin definir). Después de completar el 90% de unos tres diseños diferentes y no poder cerrarlos y/o integrarlos, empecé a sospechar que así no iba a converger nunca.

Recomendación semi off-topic

Cuando empecé con este blog, me propuse como regla jamás de los jamases hacer cross-posting. Es decir, no publicar aquí contenido que no sea original, generado por mi. No me caen nada bien los blogs que se dedican a copiar y pegar cosas de otros blogs. Así que, si hoy quiero recomendarles la lectura de otro blog, tengo que hacerlo aportando un contexto y una valoración personal, para que esto no sea un copy-paste, sino que diga algo más.

Novedades en PSeInt

Las últimas versiones de PSeInt tienen muchas novedades, que podríamos dividir en dos grupos. Por un lado hay mejoras en la interfaz; por el otro algunos cambios internos en el código. A los primeros, el usuario los puede ver y aprovechar, aunque no son cosas que hagan grandes diferencias, sino en su mayoría detalles. Los segundos, más interesantes a largo plazo, por ahora no generan ningún impacto que pueda percibir directamente el usuario final, pero me sirven a mí como desarrollador del proyecto para ir preparándole el camino a otros cambios mucho más grandes y visibles.

Herramientas mágicas: Gcov

Hoy retomo la serie de "herramientas mágicas" para presentarles GCov. Es una herramienta que yo al principio ni conocía, ni tampoco conocía ninguna de su tipo. Alguien alguna vez en el foro me sugirió que la integre en ZinjaI, y lo hice (de una forma bastante básica) solo porque me costaba poco tomando la integración previa de GProf como base. Pero luego de eso, con el tiempo le fui encontrando usos, empezando por uno no tan obvio y, recientemente, para lo que usualmente se supone que es.

La compilación según ZinjaI (parte I)

Para que al presionar F9 en ZinjaI podamos ver nuestro programa ejecutándose tienen que ocurrir unas cuantas cosas. La más importante de ellas, es la compilación de ese programa. ¿Cómo construye ZinjaI las llamadas a GCC necesarias para compilar un programa? La respuesta varía según el modo de trabajo. Para programas simple (cpp único sin proyecto) pasa una cosa, para un proyecto pasa otra. En ambos casos la respuesta es compleja e involucra información de muchas fuentes diferentes. En esta serie de posts voy a documentar qué ocurre exactamente al presionar F9 para entender de dónde sale cada partecita de cada paso, y especialmente cómo se llega a la llamada final a GCC.

Describiendo los cuadros de diálogo de ZinjaI

Tengo en ZinjaI muchísimos pequeños y no tan pequeños cuadros de configuración. Estos cuadros suelen representar un conjunto bastante lineal de "valores" configurables. En general estos "valores" se pueden reducir a tres o cuatro tipos básicos, y entonces todos los cuadros y paneles se pueden reducir a una lista ordenada de valores con sus tipos, más unas pocas indicaciones adicionales y opcionales sobre el estilo visual o pequeños agregados. Estuve rediseñando todo el código alrededor de la confección de estos cuadros de diálogo para que reorganizarlos, cambiar los estilos, o agregar y quitar elementos sea mucho más simple, rápido, y a prueba de errores.

ZinjaI en Windows: ¿Qué compilador elegir?

Existen muchos ports a Windows de GCC y de las demás herramientas/bibliotecas afines. En ZinjaI siempre usé MinGW. En su momento, hace unos años, era la opción por defecto casi sin pensarlo, pero la situación ha cambiado. Para empezar, MinGW ha quedado atado por definición a los 32 bits, mientras que la mayoría de las PCs modernas y sus sistemas operativos son de 64. Para seguir, el ritmo de actualización de MinGW se ha ralentizado bastante, o al menos eso parece en comparación con la velocidad a la que han avanzado las demás versiones. El problema es que las alternativas son muchas, hay nuevas decisiones que hacer para elegir una, y desde mi punto de vista no emerge una opción claramente ganadora de todo esto.

El paso a wxWidgets 3.x

Como comenté hace poco, la actualización de la biblioteca wxWidgets (wx) es un cambio interno en ZinjaI y PSeInt que vengo esquivando hace rato. wx es conocida principalmente por permitir generar interfaces (GUIs) de forma portable (entre plataformas). Pero en realidad es un framework completo, que ofrece muchísimas otras abstracciones de distinta índole. Por ejemplo, gestiona el lanzamiento de procesos hijos y las tuberías de entrada/salida para controlarlos, ofrece una interfaz para conexiones TCP/IP, tiene sus propios threads, su propio manejo de cadenas, etc. En ZinjaI y PSeInt uso casi todo eso, lo que es de interfaz, y también lo que no.

Arranca el 2016

El ritmo de desarrollo de ZinjaI y PSeInt empiezan de a poco a volver a la normalidad, después de unos cuantos meses demasiado quietos. En estos días publiqué las primeras versiones de 2016 de ambos proyectos. No hay cambios muy grandes, pero sí muchos detalles, especialmente en ZinjaI. En este post les resumo el estado de ambos y les adelanto algunos planes para 2016.

Lisp vs. C++ (fe de erratas)

Hace unos días publiqué un post comentando que había empezado a leer el SICP y que había tomado como ejercicio adicional armar mi propio intérprete de LISP para probar los ejemplos. Lo hice sin estudiar antes cual es la forma correcta de hacerlo, tratando de ir descubriéndola y corrigiéndola sobre la marcha, y pensando más en un código compacto y prolijo, que en un código eficiente. Como el resultado efectivamente salió rápido y fue conciso, en aquel post comenté a grandes rasgos las ideas principales y compartí el código. Pero resulta que tenía, como era de esperarse, errores importantes.

<sin_titulo_1>

No se me ocurre un buen título para esto, porque ni siquiera se exactamente de qué trata. Acabo de leer un post de Scott Meyers donde anuncia su retiro. Esta noticia disparó un montón de recuerdos y reflexiones de dudosa relación entre sí, que vengo a contarles como para cortar el silencio que se formó en este blog por las vacaciones.

Hace unos pocos días llegué a otro post muchísimo más viejo, de un desconocido como yo, contando que cuando tenía 14 años le había escrito al mismísimo John Carmack para pedirle consejos sobre cómo iniciarse en el mundo de la programación, y John se había tomado el trabajo de responderle con detalle y a consciencia. Me acuerdo que cuando era chico con un amigo quisimos escribirle a Bill Gates (perdón), pero tuvimos problemas para encontrar una dirección adecuada para el envío. Todavía tengo en algún lado un txt con un mensaje preparado bastante tonto y muy mal traducido al Inglés. Si volviera el tiempo atrás, preferiría escribirle a John, o tal vez a Torvalds, o a Stallman, o tantos otros que o quien sabe.

LISP vs. C++

Uno de estos días necesitaba un intérprete de LISP para probar algunos procedimientos bastante simples. Pero resulta que mi conexión a Internet estaba en un mal momento, y por esto el gestor de paquetes decía que instalar el intérprete que tenía disponible iba a requerir más de 50 minutos de descarga. Fue ahí cuando pensé: "puedo escribir mi propio intérprete en menos de 50 minutos". Así que abrí el ZinjaI y lo intenté. 40 minutos y 160 lineas de código C++ después tenía un intérprete para lo mínimo necesario de LISP para los ejercicios que quería probar.

Este post no se trata de comparar las ventajas y desventajas de un lenguaje frente al otro (el título es engañoso). Se trata de responder a preguntas más razonables tales como: "¿cómo entra todo un lenguaje en solo 160 lineas?", "¿cómo se te ocurre ponerte a escribir algo así?", "¿no tenías nada mejor que hacer?", etc.