Ingeniería Software y LLMs: refactorización de código

¿Podría un LLM leer todo un repositorio Git y sugerir mejoras? ¿Podría soportar el LLM, con su limitación del tamaño de contexto un repositorio Git de un proyecto de Ingeniería Software de un curso de grado?

Vamos a probarlo. Empecemos con una herramienta que captura los ficheros de un repositorio Git y los convierte en un único string que podemos usar en nuestro super-prompt: https://github.com/mpoon/gpt-repository-loader [1]

Tomemos ahora un proyecto del curso de Ingeniería Software que imparto en la UPV/EHU: https://github.com/juananpe/facultyproject

Ejecutamos el script:

$ python gpt_repository_loader.py  /opt/facultyproject/src/main/java/faculty/project  -o /tmp/faculty.txt

Repository contents written to /tmp/faculty.txt.

Si echamos un vistazo a /tmp/faculty.txt veremos lo siguiente:

$ head -20 /tmp/faculty.txt
The following text is a Git repository with code. The structure of the text are sections that begin with ----, followed by a single line containing the file path and file name, followed by a variable amount of lines containing the file contents. The text representing the Git repository ends when the symbols --END-- are encounted. Any further text beyond --END-- are meant to be interpreted as instructions using the aforementioned Git repository as context.
----
ui/ApplicationLauncher.java
package faculty.project.ui;

import faculty.project.businessLogic.BlFacade;
import faculty.project.businessLogic.BlFacadeImplementation;

import java.util.Locale;

public class ApplicationLauncher {

  public static void main(String[] args) {

    System.out.println("Locale: " + Locale.getDefault());

    BlFacade businessLogic = new BlFacadeImplementation();

    new MainGUI(businessLogic);

Ahí vemos que le ha metido una cabecera («El siguiente texto representa un repositorio Git con código. La estructura del texto son secciones que empiezan con —, seguido por una línea con la ruta al fichero y sus contenidos…)

Al final del fichero (tras el –END–), meteremos la siguiente línea:
Can you suggest how to improve the code?

Y probemos ahora a pasarle el super prompt a un LLM que soporte un gran tamaño de contexto (Gemini Pro 1.5 es un gran candidato):

$ cat /tmp/faculty.txt | llm -m gemini-1.5-pro-latest

Y el resultado es muy interesante:

Potential Improvements for the Provided Code:

General:

  • Dependency Injection: The code currently uses manual object creation, leading to tight coupling. Consider using a dependency injection framework like Spring or Guice to manage object creation and dependencies, improving flexibility and testability.
  • Exception Handling: The current exception handling is minimal and sometimes throws runtime exceptions. Implement a more robust exception handling strategy, catching specific exceptions and handling them gracefully with informative messages or logging.
  • Logging: Integrate a logging framework like Log4j or SLF4j to track application behavior, debug issues, and monitor performance.
  • Testing: Implement unit and integration tests to ensure code quality and prevent regressions. Frameworks like JUnit and Mockito can be helpful.

DataAccess:

  • Data Access Object (DAO) Pattern: Instead of having all data access logic directly in DataAccess, consider creating separate DAO classes for each entity (User, Student, Subject, etc.) to improve modularity and maintainability.
  • Named Queries: Utilize named queries in JPQL for frequently used queries to improve readability and maintainability.
  • Optimistic Locking: Implement optimistic locking to prevent data inconsistencies when multiple users access the same data concurrently.

(puedes ver aquí el resultado completo: https://gist.github.com/juananpe/9ca627a13ca0e1927dfa2c40c86a2af8)

[1]Hay otros proyectos git2txt que hacen lo mismo que gpt_repository_loader:

https://github.com/JeremiahPetersen/RepoToText

https://github.com/ableinc/git2txt

Ingeniería Software y LLMs

El mundo ha cambiado. No somos conscientes de cuánto. Especialmente el mundo de la educación. Y más en concreto el de la ingeniería software. Ese cambio me afecta de lleno. Desde su introducción el 30 de noviembre de 2022, ChatGPT ha puesto patas arriba el sistema. A GPT3.5 le siguieron otros LLMs (Large Language Models): LLama, Gemini, Claude, Mistral… Y este es sólo el comienzo. Llevamos sólo 1 año y pico, pero las clases de ingeniería han cambiado radicalmente. O tal vez debería de decir que tienen que cambiar. Aún hay profesorado que se niega a que los alumnos usen LLMs en sus clases. Entiendo sus razones, aunque no las comparto. Creo que deberíamos de promover el uso racional de herramientas de IA en el aula. Este año pedí a mis alumnos que instalaran GitHub Copilot (gracias a la licencia que conseguimos a través de GitHub Student Pack). Copilot junto con el IDE IntelliJ es una maravilla. Ahorra horas de trabajo cada día. Unamos a esto el uso de un LLM para múltiples tareas de ingeniería software: análisis de requisitos (creación de diagramas de casos de uso, modelos de dominio), diseño (diagramas de secuencia, diagramas de clases), implementación (por supuesto), testing, depuración, ayuda para el despliegue, creación de scripts, creación de templates para comienzo de proyectos, guías paso a paso para cualquier tecnología… Y repito, piensa que esto es sólo el comienzo. Como decía recientemente Sam Altman, GPT4 será el peor LLM con el que trabajemos: a partir de hoy cualquier otro nuevo LLM (de OpenAI, Anthropic, Google…) será mejor que GPT4.

Diagrama de modelo de dominio, realizado en PlantUML a partir de una descripción del dominio en lenguage natural, creado por GPT-4 y visualizado en planttext.com

Hace un año creé el repositorio Generative AI Prompts for Teaching Software Engineering, que muestra ejemplos concretos de prompts que podemos usar en múltiples áreas relacionadas con la enseñanza de la ingeniería software: https://github.com/juananpe/gen-ai-in-softeng. Creo que es una muy buena herramienta para tomar ideas y aplicarlas directamente en tus clases. Debería retomar el proyecto y añadirle nuevas ideas.

Custom JavaFX components in SceneBuilder

So you want to open a JavaFXML with a custom component in SceneBuilder?

This week I have been playing with this project: https://github.com/Vuzi/twitter-c 

an implementation of a Twitter Client in JavaFX. 

The application uses different JavaFX views, being the main one TweetListView: https://github.com/Vuzi/twitter-c/blob/master/src/main/resources/fr/esgi/twitterc/view/TweetListView.fxml

When running, the TweetListView displays a lot of elements (look at those pretty buttons, they are using the FontAwesomeFX library)

I wanted to open the FXML in SceneBuilder and inspect it. But on first try, it failed with a ClassNotFoundException:

That view.component.Icon is a custom component:

https://github.com/Vuzi/twitter-c/blob/master/src/main/resources/fr/esgi/twitterc/view/component/icon.fxml

used by TweetListView.fxml here:

https://github.com/Vuzi/twitter-c/blob/master/src/main/resources/fr/esgi/twitterc/view/TweetListView.fxml#L20

So, going through GitHub I found that, in order to edit that FXML in SB first we need to import a JAR file with the component in the Jar Manager of SB

https://stackoverflow.com/questions/29444698/how-to-create-an-fxml-file-for-an-already-created-new-component-in-java-than-add

But wait, how do we create the JAR file? I’m using IntelliJ so my explanations will be based on this IDE.

First, I isolated the component into a single repository:

https://github.com/juananpe/IconComponentFX

Let’s create a JAR of the IconComponent. In IntelliJ:

  1. Open Module Settings ⌘ ⬇️
  2. Click Artifacts
  3. Click the + Add button, point to JAR
  4. Select: From modules with dependencies…

In the next Window, Just click OK 

To generate the JAR, click on Build / Build artifacts / Build

IntelliJ will generate the jar file and place it in the out/artifacts folder

Now, let’s import the JAR of the IconComponent in  SceneBuilder

Open the JAR/FXML Manager

Click on Add Library from FileSystem

Click on Import Components.

And finally, we will be able to open without errors the TweeListView FXML in SceneBuilder:

See these references for more info:

SolveIt / Level 3 / EE30

Y con este SolveIt3 llegamos al final de los hackits y solveits que conseguimos resolver… fuera de tiempo, la mayoría, pero hey! No se puede tener todo… 🙂

Como suele ser habitual, el título de la prueba nos da una pista sobre lo que nos encontraremos: Frankly, an Antique Troll (FAT)

Se trata de una imagen de un disco formateado con un sistema de archivos FAT.

# fdisk -l disk.img.gz
Disk disk.img.gz: 146.5 MiB, 153600000 bytes, 300000 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0xb24b8602

Device       Boot Start    End Sectors   Size Id Type
disk.img.gz1       2048 299999  297952 145.5M  c W95 FAT32 (LBA)

Podemos montar la imagen (renombrar primero para añadirle la extensión .dmg si estás en macOS):

➜ hdiutil attach disk.img.gz.dmg
/dev/disk2          	FDisk_partition_scheme
/dev/disk2s1        	Windows_FAT_32                 	/Volumes/NO NAME

Es curioso, en macOS monta la imagen sin problema, pero Linux se queja de que la imagen tiene algún error:

# fsck.vfat disk.img.gz
fsck.fat 4.1 (2017-01-24)
Logical sector size is zero.

# mount -o loop -t vfat disk.img.gz /tmp/q/
mount: /tmp/q: wrong fs type, bad option, bad superblock on /dev/loop10, missing codepage or helper program, or other error.

En macOS la imagen se monta por defecto en /Volumes/NO NAME. Si pedimos un listado de ese directorio:

$ ls -al
total 218505
drwxrwxrwx@ 1 juanan  staff        512 Aug  7 21:53 .
drwxr-xr-x  4 root    wheel        128 Aug  7 21:53 ..
drwxrwxrwx  1 juanan  staff        512 Aug  7 21:53 .fseventsd
-rwxrwxrwx  1 juanan  staff  111873298 Jul 22 10:00 video.avi

El .fseventsd es un artefacto de macOS. Y el vídeo, bueno… no hacía falta ni abrirlo para saber de qué se trataba:

Podía ser este o el trololó… 🙂

Desmontamos la unidad con umount /Volumes/NO\ NAME. Y empezamos a analizar el contenido de las particiones de esa imagen.

fdisk  disk.img.gz.dmg
Disk: disk.img.gz.dmg	geometry: 595/8/63 [300000 sectors]
Signature: 0xAA55
         Starting       Ending
 #: id  cyl  hd sec -  cyl  hd sec [     start -       size]
------------------------------------------------------------------------
 1: 0C    0  32  33 -   18 171  57 [      2048 -     297952] Win95 FAT32L
 2: 00    0   0   0 -    0   0   0 [         0 -          0] unused
 3: 00    0   0   0 -    0   0   0 [         0 -          0] unused
 4: 00    0   0   0 -    0   0   0 [         0 -          0] unused

Eliminamos los primeros 2048 bloques y extraemos el resto:

dd if=disk.img.gz.dmg of=/tmp/cabecera3 bs=512 skip=2048 count=297952

Probamos algo típico en un binario (ya hicimos pruebas con binwalk y no salió nada)… abrirlo con Gimp en modo raw 🙂

Hay que jugar con el ancho hasta que veamos algo parecido a la imagen…

Si le damos un poco de zoom, veremos lo que estábamos buscando (saludos a Cuartango, que fue el primero en encontrar la medida exacta)

Un S3ct0rde4Tb…

SolveIt / Level2 / EE30

El level 2 del SolveIt se nos hacía conocido. Surgió en alguna otra ocasión, no recuerdo exactamente… tal vez en la Gipuzkoa Encounter de 2019. El autor (@imobilis) dibujó las pistas para solucionarlo en un papel que luego troceó y revolvió en múltiples pedazos. Verdaderamente es un buen rompecabezas.

Solve It 2: Rompecabezas. Inicialmente la imagen era de baja calidad. A lo largo del torneo el autor proporcionó nuevas imágenes donde podía observarse mejor cada una de las piezas.

Conocíamos el procedimiento de resolución: recortar cada una de las piezas e intentar recomponer la imagen original. Un trabajo de chinos. Kotxerra se puso a ello y estuvo dándole al Photoshop durante horas. Al final consiguió una buena imagen:

Completar el puzle nos llevó más horas de las que hubiéramos querido meter en este level, pero el esfuerzo mereció la pena.

@ochoto retocó la imagen para hacerla más legible:

Aunque se ve mejor, te reto a que busques ahora la solución…. Hint1: la primera palabra de la solución se lee bastante bien: «Repeated».

Hint2: Los solveits repetidos no son un pecado… 😉