¿ChatGPT pronto reemplazará a los desarrolladores de software? ¿Sí o no?

Si hay algo que llamó la atención del mundo de la tecnología en las últimas semanas, es ChatGPT. Los medios de comunicación predicen que será la próxima gran cosa después del motor de búsqueda de Google, y los expertos compiten para predecir su impacto en la sociedad. Este artículo intenta echar un vistazo a ChatGPT desde la perspectiva de un desarrollador de software.. Intentaremos entender si ChatGPT reemplazará los trabajos.

ChatGPT es un chatbot basado en inteligencia artificial. Fue desarrollado por OpenAI, con sede en San Francisco, y presentado al mundo en noviembre de 2022.

En palabras de ChatGPT, es un asistente de IA capacitado para ayudar a responder preguntas y proporcionar información sobre una amplia gama de temas, incluidos conocimientos generales, historia, ciencias, matemáticas, idiomas y muchos otros. ¿Suena familiar? ¿Los motores de búsqueda ya no están haciendo este trabajo? ¡Hay una diferencia!

Según OpenAI, ChatGPT ha sido entrenado para interactuar de manera conversacional. El formato de diálogo permite que ChatGPT responda preguntas de seguimiento, admita errores, cuestione premisas falsas y rechace solicitudes inapropiadas.

Probemos ChatGPT

Bueno, ¡vamos a experimentarlo! Lo primero que debe hacer es iniciar sesión en ChatGPT. Visita la URL https://chat.openai.com/auth/login en cualquier navegador moderno para abrir la página de inicio de sesión. Se ve como en la figura 1.

Como aún no hemos iniciado sesión, haga clic en el botón Iniciar sesión. El cuadro de diálogo se abre y ofrece varias opciones para iniciar sesión.

En mi caso, opté por seguir con Google. Después de ingresar las credenciales de Google, se le solicitó un nombre y un número de teléfono para iniciar el proceso de verificación. Después de ingresar la OTP recibida, el ChatGPT se abrió en la URL https://chat.openai.com/chatcomo en la figura 2.

ChatGPT establece claramente que la versión actual es solo una vista previa de investigación gratuita. El objetivo es obtener retroalimentación externa para mejorar los sistemas y hacerlos más seguros. Asimismo, se advierte que, a pesar de las medidas de seguridad implantadas, el sistema puede generar ocasionalmente información falsa o engañosa y contenidos ofensivos o tendenciosos.

Debido a que los capacitadores de IA pueden revisar las conversaciones de ChatGPT para mejorar los sistemas, no podemos compartir información confidencial en nuestras conversaciones.

Juguemos con ChatGPT

La programación es una de las áreas en las que ChatGPT demuestra ser una ayuda útil. Por ejemplo, escriba la siguiente pregunta en el símbolo del sistema y vea la respuesta:

java command to compile a file

Además de preguntas tan simples, incluso podemos pedirle a ChatGPT que escriba código para nosotros. ¿Qué tal un poco de ayuda para escribir el código de Python? Inicié una nueva conversación con el siguiente aviso:

sort numbers using bubble sort in python

El asistente generó el siguiente código:

def bubble_sort(numbers):
n = len(numbers)
for i in range(n):
for j in range(0, n - i - 1):
if numbers[j] > numbers[j + 1]:
numbers[j], numbers[j + 1] = numbers[j + 1], numbers[j]
test the function
numbers = [3, 4, 1, 2, 5]
bubble_sort(numbers)
print(numbers) # [1, 2, 3, 4, 5]

Puede verificar el código con solo revisarlo si es un desarrollador de Python. O copie el código en un archivo fuente e intente ejecutarlo en un entorno de Python. ¡Funciona!

Pero eso no es todo. Sabemos que hay más de una forma de escribir código de clasificación de burbuja. ChatGPT está de acuerdo. Le pedí que lo intentara de nuevo.

Esta vez se generó el siguiente código:

def bubble_sort(numbers):
# Set the flag to True to start the sorting
flag = True
# Keep looping until the flag is False
while flag:
    # Set the flag to False
    flag = False
    # Loop through the numbers
    for i in range(len(numbers) - 1):
        # Check if the current number is greater than the 
        next number
        if numbers[i] > numbers[i + 1]:
            # If it is, swap the numbers
            numbers[i], numbers[i + 1] = numbers[i + 1], 
            numbers[i]
            # Set the flag to True to indicate that a swap 
            has occurred
            flag = True
# Return the sorted list
return numbers
sorted_numbers = bubble_sort([3, 5, 2, 1, 4])
print(sorted_numbers) # Output: [1, 2, 3, 4, 5]

Puedes pedirle que lo intente tantas veces como quieras. En mi caso, la tercera iteración sugirió lo siguiente:

def bubble_sort(numbers):
# We set swapped to True so the loop looks runs at least
once
swapped = True
while swapped:
swapped = False
for i in range(len(numbers) - 1):
if numbers[i] > numbers[i + 1]:
# Swap the elements
numbers[i], numbers[i + 1] = numbers[i + 1],
numbers[i]
# Set the flag to True so we’ll loop again
swapped = True
#Verify it works
numbers = [3, 7, 4, 9, 1, 6]
bubble_sort(numbers)
print(numbers) # Should print [1, 3, 4, 6, 7, 9]

¿Cansado de diferentes versiones de código para el mismo problema? En cambio, ¿qué tal pedirle al asistente que optimice el código? Acabo de escribir lo siguiente en el símbolo del sistema:

optimize

El siguiente es el resultado…

There are several ways you can optimize the bubble sort algorithm to make it run faster. Here are a few ideas: Use a flag to keep track of whether any swaps were made on
the last iteration of the loop. If no swaps were made, it means the list is already sorted and we can exit the loop early.
Only iterate up to the last element that has already been sorted. On each pass, the largest element will “bubble” up to the end of the list, so there’s no need to compare it to any other elements on the next pass. 
Use a different sorting algorithm altogether, such as quick sort or merge sort, which have better average-case time complexity than bubble sort. 
I hope these suggestions are helpful! Let me know if you have any questions.

Es posible que haya notado que el asistente recuerda toda la conversación y responde las preguntas en contexto.

Desarrollo con ChatGPT

La conversación anterior simplemente ilustra cómo el asistente puede ayudarnos a escribir código para problemas menores. Sin embargo, el desarrollo de software no se trata solo de escribir código. Supongamos que no sabemos mucho sobre el desarrollo de aplicaciones Spring Boot y veamos cuánto nos ayuda el asistente.

Empecé con la siguiente pregunta:

difference between log4j and slf4j

Había mucha información. Pruébelo usted mismo y descubra lo útil que es.

Entonces hice la siguiente pregunta:

spring program with slf4j

Se generó el siguiente código:

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.
SpringBootApplication;
@SpringBootApplication
public class MySpringApp {
private static final Logger logger = LoggerFactory.
getLogger(MySpringApp.class);
public static void main(String[] args) {
SpringApplication.run(MySpringApp.class, args);
logger.info(“Spring application started!”);
}
}

El asistente no se limpia solo con código. También hay muchas notas. Por ejemplo, la siguiente es la nota generada junto con el código anterior.

In this example, we use the LoggerFactory class from slf4j
to create a logger for the MySpringApp class. We can then use
the logger object to output log statements at different
levels (e.g., info, debug, error).
To use slf4j in a Spring application, you will need to
include the slf4j-api library as a dependency in your
project. You will also need to include a concrete
implementation of slf4j, such as log4j, logback, or java.
util.logging.
For example, to use log4j as the underlying logging
implementation, you will need to include the log4j library
as a dependency in your project. You can then configure log4j
to output log statements to the desired destination (e.g.,
console, file).

Como hay algunas dependencias involucradas, fingí que no sabía cómo hacerlo. Así que hice esta pregunta de seguimiento:

pom file for spring with slf4j

Aquí está la sugerencia resultante:

<project>
  <!-- Other project configuration -->
  <dependencies>
    <!-- Other dependencies -->
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>1.7.30</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>1.7.30</version>
    </dependency>
  </dependencies>
</project>

Nuevamente, las notas indicaron una dependencia de log4j. Le pedí al asistente que agregara eso también y generó la siguiente configuración refinada.

<project>
  <!-- Other project configuration -->
  <dependencies>
    <!-- Other dependencies -->
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>1.7.30</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>1.7.30</version>
    </dependency>
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>
  </dependencies>
</project>
You will also need to include a log4j.properties file in your 
project to configure log4j to output log statements to the 
desired destination (e.g., console, file).

La historia no termina aquí. Le pedí al asistente que me ayudara con el archivo log4j.properties:

log4j.properties for spring with slf4j

era obligatorio

# Root logger
log4j.rootLogger=INFO, stdout, file
# Console appender
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd 
HH:mm:ss} %-5p %c{1}:%L - %m%n
# File appender
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=app.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd 
HH:mm:ss} %-5p %c{1}:%L - %m%n

Yo estaba emocionado. No es que no podamos obtener esta ayuda de un motor de búsqueda en Internet. Pero la experiencia de chatear con ChatGPT fue genial.

Probemos ChatGPT por última vez y obtengamos ayuda para desarrollar e implementar la API REST. Empecé una nueva conversación con una simple pregunta:

design rest api to add a customer

Respondió con la siguiente declaración:

To design a REST API to add a customer, you will need to
define the endpoints and the request/response payloads for
the API.
Here is an example of how you could design the API:
Endpoint:
POST /customers
Request payload:
{
“name”: “John Smith”,
“email”: “[email protected]”,
“phone”: “555-555-5555”
}

¡Bastante útil! Por lo general, usamos Swagger para documentar la API REST. Hay un montón de repeticiones allí. ChatGPT es perfecto en tales casos. Pregunté lo siguiente en la misma conversación:

swagger doc for adding a new customer

Aquí está la documentación de Swagger para el punto final POST /customers que describí anteriormente:

/customers:
post:
summary: Add a new customer
requestBody:
content:
application/json:
schema:
type: object
required:
- name
- email
- address
properties:
name:
type: string
email:
type: string
format: email
address:
type: string
responses:
201:
description: The customer was successfully created
content:
application/json:
schema:
type: object
properties:
id:
type: integer
format: int64
name:
type: string
email:
type: string
format: email
address:
type: string
400:
description: The request body is invalid
409:
description: A customer with the same email already
exists

¿Qué más podría pedir? La versión final de la documentación puede no parecer tan simple. Aún así, es un buen punto de partida.

Tenía curiosidad si ChatGPT podría darme un código para publicar la API REST anterior usando Spring Boot. ¡Lo hizo! La pregunta era esta:

spring controller for the above endpoint

Y la respuesta fue:

@RestController
@RequestMapping(“/customers”)
public class CustomerController {
@PostMapping
public ResponseEntity<Customer> createCustomer(@Valid @
RequestBody Customer customer) {
    // save the customer and return it
    Customer savedCustomer = customerRepository.
    save(customer);
    return ResponseEntity.status(HttpStatus.CREATED).
    body(savedCustomer);
}
}

Este es el resorte imperativo. Hoy en día preferimos el paradigma reactivo. Yo me hice lo mismo con esta pregunta:

i want it with spring reactive

ChatGPT anunció el código de inicio.

@RestController
@RequestMapping(“/customers”)
public class CustomerController {
@PostMapping
public Mono<ResponseEntity<Customer>> createCustomer(@
Valid @RequestBody Mono<Customer> customer) {
    // save the customer and return it
    return customer.flatMap(customer -> customer
    Repository.save(customer))
       .map(savedCustomer -> ResponseEntity.status
       (HttpStatus.CREATED).body(savedCustomer));
}
}

Ningún desarrollo moderno está completo sin crear una imagen de Docker. Solicité la ayuda de ChatGPT para generar un Dockerfile para el código anterior con esta pregunta:

dockerfile for the above application

Y obtuve la siguiente respuesta, que es suficiente para empezar:

FROM openjdk:11-jdk-slim
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} app.jar
EXPOSE 8080
ENTRYPOINT [“java”, “-jar”, “app.jar”]

En lugar de pedir ayuda específica, probé lo siguiente para animar la conversación:

¿Cuál es el próximo paso?

Esta respuesta me sorprendió:

Once you have written the code for your application and created a Dockerfile, the next step is to build a Docker image and run a Docker container.
To build the Docker image, open a terminal and navigate to the directory containing the Dockerfile. Then, run the following command:
docker build -t my-app .
This will build a Docker image with the name “my-app” using the instructions in the Dockerfile.
To run a Docker container, use the following command:docker run -p 8080:8080 my-app
This will start a Docker container from the “my-app” image, and map the container’s 8080 port to the host’s 8080 port.
Is there anything else I can help with?

¡Ver! ChatGPT mantiene el contexto de la conversación. Responde en el contexto dado y no solo en resultados estáticos secos. Y eso es asombroso. ¿Que más puedo decir? Yo dije:

thanks

Y el asistente tuvo la amabilidad de reconocerlo.

You’re welcome! I’m glad I could help. If you have any other
questions, feel free to ask. I’ll do my best to assist you.

¿ChatGPT reemplazará los trabajos?

Recuerdo a personas discutiendo sobre los pros y los contras de informatizar los bancos en la década de 1990 y los vehículos autónomos en la década de 2020. Cada tecnología disruptiva plantea esta pregunta. Lo mismo ocurre con ChatGPT también.

La pregunta exacta relevante para la comunidad de desarrollo de software es: ¿ChatGPT reemplazará a los desarrolladores?

En este punto, la respuesta es claramente “no”. La tecnología siempre destruye algunos puestos de trabajo y crea otros nuevos. Sin embargo, reemplazar un revelador requiere mucho esfuerzo. El desarrollo de software no es solo programación. ChatGPT ciertamente puede ayudar a escribir código al igual que IDE ayuda a completar, compilar, depurar, etc.

Pero al igual que IDE, no puede reemplazar la participación humana en el desarrollo de extremo a extremo. Como desarrolladores, usamos editores de texto para escribir el código en los 80 e IDE en los 90.

Copiamos el código de los resultados de búsqueda de Google y usamos soluciones de StackOverflow. Todo esto se hizo para mejorar la productividad. Y, sin embargo, ninguno de ellos podría reemplazar realmente al desarrollador. Lo mismo sucederá con ChatGPT también. Es una herramienta productiva innovadora para los programadores. Pero no te convierte en programador, ni te quita el trabajo de programador. ¡Por ahora!

Este artículo se publicó por primera vez en la edición de febrero de 2023 de la revista Open Source For You.

El autor Krishna Mohan Koya es el fundador y asesor principal de Glarimy Technology Services, Bangalore. Ha asesorado y capacitado a más de 250 equipos técnicos en arquitectura, diseño y desarrollo de aplicaciones empresariales, tanto locales como en la nube.