Utiliza ChatGPT-4 como herramienta de programación
Cómo la inteligencia artificial puede mejorar tu flujo de trabajo como programador.
La inteligencia artificial (IA) ha avanzado rápidamente en las últimas décadas, y la tecnología de procesamiento del lenguaje natural (PLN) es una de las más emocionantes y útiles aplicaciones de la IA. ChatGPT es una herramienta de PLN basada en el modelo GPT-3.5 de OpenAI, que puede ser utilizada para mejorar el flujo de trabajo de los programadores. Sin embargo, el próximo lanzamiento del modelo GPT-4, promete llevar las capacidades de procesamiento del lenguaje natural a un nivel completamente nuevo. En este artículo, se explorará cómo se puede utilizar ChatGPT-4 como una herramienta de programación.
¿Qué es ChatGPT?
ChatGPT es un modelo de procesamiento del lenguaje natural (PLN) desarrollado por OpenAI. Utiliza el modelo GPT-3.5, que tiene 175 mil millones de parámetros. A través del aprendizaje profundo, ChatGPT puede generar texto que se asemeja al lenguaje humano. Esto hace que ChatGPT sea útil para una amplia gama de aplicaciones, incluyendo chatbots, redacción de textos y resolución de problemas complejos.
¿Qué es GPT-4?
GPT-4 es el próximo modelo de procesamiento del lenguaje natural que tine más parámetros que GPT-3 y una mejor capacidad de procesamiento del lenguaje natural. Se espera que GPT-4 sea capaz de producir un texto que sea indistinguible del texto humano, lo que abrirá muchas posibilidades para el procesamiento del lenguaje natural.
¿Cómo puede ChatGPT-4 ser utilizado como una herramienta de programación?
Desde hace un tiempo se ha hablado en la red sobre las capacidades de las inteligencias artificiales para reemplazar el trabajo de los programadores.
Retomando el concepto de “artesanía del software”, el uso de la inteligencia artificial para la creación de código puede compararse a un proceso similar al que ocurrió con la llegada de la industrialización en la creación de ropa, en el que se entrega el producto de forma automatizada y en serie, pero sin grarantias de que esté libre de errores.
Poco a poco, nos acercamos a lo que en 2011 parecia una broma, el poder comunicarnos con la computadora en lenguaje natural para especificarle lo que queriamos que hiciera, cosa que en la presentacion de ChatGPT-4 se realizo un ademostracion de la capacidad de la IA para interpretar un imagen y apartir de ella construir un sitio web con funcionalidad limitada.
La capacidad de ChatGPT-4 para comprender y procesar imágenes abre la posibilidad de utilizarlo en la creación de interfaces de usuario. Sin embargo, es importante tener en cuenta que aunque ChatGPT-4 puede ayudar en el proceso de programación y reducir el trabajo tedioso y repetitivo, todavía se necesitará la experiencia humana para garantizar que el código final sea de alta calidad y esté libre de errores.
Hay varias formas en las que ChatGPT-4 puede ser utilizado como herramienta de programación.
Escritura de código.
ChatGPT-4 puede generar código a partir de descripciones en lenguaje natural, lo que puede ahorrar tiempo y esfuerzo al escribir código, especialmente para tareas repetitivas que no requieren una gran cantidad de habilidades.
Documentación de código
ChatGPT-4 puede ser entrenado en la documentación de código, lo que lo hace ideal para escribir documentación detallada del mismo. Puede generar documentación de código en lenguaje natural, lo que puede ser útil para aquellos que no están familiarizados con el código en sí.
agrega comentarios y stringsdocs al siguiente codigo:
import hashlib
import os
# Definimos la ruta a la carpeta donde se encuentran los archivos
ruta_carpeta = '/ruta/a/la/carpeta/'
def getsha(ruta_carpeta):
# Iteramos sobre los archivos en la carpeta
for archivo in os.listdir(ruta_carpeta):
# Creamos un objeto hash SHA-1
sha1 = hashlib.sha1()
# Abrimos el archivo en modo lectura en modo binario
with open(os.path.join(ruta_carpeta, archivo), 'rb') as f:
# Leemos el archivo en bloques de 4KB para no consumir mucha memoria
for bloque in iter(lambda: f.read(4096), b""):
# Actualizamos el objeto hash con el bloque leído
sha1.update(bloque)
# Imprimimos el hash SHA-1 del archivo
print(f"El hash SHA-1 del archivo {archivo} es: {sha1.hexdigest()}")¡Claro que sí! Aquí te dejo el código con los comentarios y docstrings agregados:
python
Copy code
import hashlib
import os
def getsha(ruta_carpeta: str) -> None:
"""Calcula el hash SHA-1 de todos los archivos en la carpeta especificada.
Args:
ruta_carpeta (str): La ruta a la carpeta donde se encuentran los archivos.
Returns:
None
"""
# Iteramos sobre los archivos en la carpeta
for archivo in os.listdir(ruta_carpeta):
# Creamos un objeto hash SHA-1
sha1 = hashlib.sha1()
# Abrimos el archivo en modo lectura en modo binario
with open(os.path.join(ruta_carpeta, archivo), 'rb') as f:
# Leemos el archivo en bloques de 4KB para no consumir mucha memoria
for bloque in iter(lambda: f.read(4096), b""):
# Actualizamos el objeto hash con el bloque leído
sha1.update(bloque)
# Imprimimos el hash SHA-1 del archivo
print(f"El hash SHA-1 del archivo {archivo} es: {sha1.hexdigest()}")
En este ejemplo, hemos agregado una docstring para la función getsha() que describe lo que hace la función, los argumentos que recibe y lo que devuelve. Además, hemos agregado comentarios en cada sección del código para explicar lo que se está haciendo en cada paso.
La función getsha() toma la ruta de una carpeta como argumento y calcula el hash SHA-1 de todos los archivos en la carpeta. Dentro de la función, usamos os.listdir() para obtener una lista de los nombres de los archivos en la carpeta, y luego iteramos sobre esta lista. Para cada archivo, creamos un objeto hash SHA-1 utilizando hashlib.sha1(), abrimos el archivo en modo lectura en modo binario utilizando open(), y usamos un bucle for para leer el archivo en bloques de 4KB y actualizar el objeto hash utilizando sha1.update(). Finalmente, imprimimos el hash SHA-1 del archivo utilizando sha1.hexdigest().Escritura de pruebas
Es posible pedirle a ChatGPT-4 que escriba la prueba de una pieza de código.
agrega tests al siguiente codigo:
import hashlib
import os
def getsha(ruta_carpeta: str) -> None:
"""Calcula el hash SHA-1 de todos los archivos en la carpeta especificada.
Args:
ruta_carpeta (str): La ruta a la carpeta donde se encuentran los archivos.
Returns:
None
"""
# Iteramos sobre los archivos en la carpeta
for archivo in os.listdir(ruta_carpeta):
# Creamos un objeto hash SHA-1
sha1 = hashlib.sha1()
# Abrimos el archivo en modo lectura en modo binario
with open(os.path.join(ruta_carpeta, archivo), 'rb') as f:
# Leemos el archivo en bloques de 4KB para no consumir mucha memoria
for bloque in iter(lambda: f.read(4096), b""):
# Actualizamos el objeto hash con el bloque leído
sha1.update(bloque)
# Imprimimos el hash SHA-1 del archivo
print(f"El hash SHA-1 del archivo {archivo} es: {sha1.hexdigest()}")¡Claro que sí! Aquí te dejo un conjunto de tests para esta función:
python
Copy code
import unittest
import hashlib
import os
import tempfile
from contextlib import redirect_stdout
from io import StringIO
from getsha import getsha
class GetShaTestCase(unittest.TestCase):
def setUp(self):
self.test_dir = tempfile.mkdtemp()
self.test_file = os.path.join(self.test_dir, 'test.txt')
with open(self.test_file, 'w') as f:
f.write('test file')
def tearDown(self):
os.remove(self.test_file)
os.rmdir(self.test_dir)
def test_getsha(self):
expected_output = f"El hash SHA-1 del archivo test.txt es: {hashlib.sha1(b'test file').hexdigest()}\n"
with StringIO() as buffer, redirect_stdout(buffer):
getsha(self.test_dir)
output = buffer.getvalue()
self.assertEqual(output, expected_output)
if __name__ == '__main__':
unittest.main()
En estos tests, estamos creando una carpeta temporal y un archivo temporal en el directorio temporal. Luego, escribimos algunos datos en el archivo y calculamos manualmente el hash SHA-1 del archivo utilizando la biblioteca hashlib. Ejecutamos la función getsha() en la carpeta temporal y comparamos la salida con el hash SHA-1 que hemos calculado manualmente.
Para hacer esto, estamos utilizando la biblioteca unittest de Python para definir una clase de prueba llamada GetShaTestCase. En el método setUp(), estamos creando la carpeta y el archivo temporal. En el método tearDown(), estamos eliminando el archivo y la carpeta temporal. En el método test_getsha(), estamos redirigiendo la salida estándar a un objeto StringIO para que podamos capturar la salida de la función getsha(). Luego, estamos comparando la salida con el hash SHA-1 que hemos calculado manualmente. Si la salida es igual al hash SHA-1, el test pasa. De lo contrario, el test falla. Finalmente, estamos ejecutando unittest.main() para ejecutar los tests.Depuración de código
ChatGPT-4 también puede ser entrenado en la detección de errores de código. Puede identificar los errores y sugerir soluciones, lo que puede ahorrar tiempo a los programadores al evitar que tengan que buscar errores manualmente.
encuentra bugs en el siguiente codigo :
import hashlib
import os
def getsha(ruta_carpeta: str) -> None:
"""Calcula el hash SHA-1 de todos los archivos en la carpeta especificada.
Args:
ruta_carpeta (str): La ruta a la carpeta donde se encuentran los archivos.
Returns:
None
"""
# Iteramos sobre los archivos en la carpeta
for archivo in os.listdir(ruta_carpeta):
# Creamos un objeto hash SHA-1
sha1 = hashlib.sha1()
# Abrimos el archivo en modo lectura en modo binario
with open(os.path.join(ruta_carpeta, archivo), 'rb') as f:
# Leemos el archivo en bloques de 4KB para no consumir mucha memoria
for bloque in iter(lambda: f.read(4096), b""):
# Actualizamos el objeto hash con el bloque leído
sha1.update(bloque)
# Imprimimos el hash SHA-1 del archivo
print(f"El hash SHA-1 del archivo {archivo} es: {sha1.hexdigest()}")No se identifican errores en el código presentado.Optimización de código
Es posible pedirle a ChatGPT-4 que busque mejoras en el código y escriba una versión mejorada del mismo.
Escribe la version optimizada del siguiente codigo:
import hashlib
import os
def getsha(ruta_carpeta: str) -> None:
"""Calcula el hash SHA-1 de todos los archivos en la carpeta especificada.
Args:
ruta_carpeta (str): La ruta a la carpeta donde se encuentran los archivos.
Returns:
None
"""
# Iteramos sobre los archivos en la carpeta
for archivo in os.listdir(ruta_carpeta):
# Creamos un objeto hash SHA-1
sha1 = hashlib.sha1()
# Abrimos el archivo en modo lectura en modo binario
with open(os.path.join(ruta_carpeta, archivo), 'rb') as f:
# Leemos el archivo en bloques de 4KB para no consumir mucha memoria
for bloque in iter(lambda: f.read(4096), b""):
# Actualizamos el objeto hash con el bloque leído
sha1.update(bloque)
# Imprimimos el hash SHA-1 del archivo
print(f"El hash SHA-1 del archivo {archivo} es: {sha1.hexdigest()}")El código presentado ya es bastante eficiente y no hay mucho espacio para optimización. Una posible mejora sería imprimir los resultados en un archivo de texto en lugar de en la consola, ya que esto podría ser útil si se necesita analizar los resultados posteriormente. Aquí hay una versión que realiza esta mejora:
python
Copy code
import hashlib
import os
def getsha(ruta_carpeta: str, ruta_archivo: str) -> None:
"""Calcula el hash SHA-1 de todos los archivos en la carpeta especificada y los escribe en un archivo de texto.
Args:
ruta_carpeta (str): La ruta a la carpeta donde se encuentran los archivos.
ruta_archivo (str): La ruta del archivo de texto donde se escribirán los resultados.
Returns:
None
"""
# Abrimos el archivo de texto en modo escritura
with open(ruta_archivo, 'w') as archivo_salida:
# Iteramos sobre los archivos en la carpeta
for archivo in os.listdir(ruta_carpeta):
# Creamos un objeto hash SHA-1
sha1 = hashlib.sha1()
# Abrimos el archivo en modo lectura en modo binario
with open(os.path.join(ruta_carpeta, archivo), 'rb') as f:
# Leemos el archivo en bloques de 4KB para no consumir mucha memoria
for bloque in iter(lambda: f.read(4096), b""):
# Actualizamos el objeto hash con el bloque leído
sha1.update(bloque)
# Escribimos el hash SHA-1 del archivo en el archivo de texto
archivo_salida.write(f"El hash SHA-1 del archivo {archivo} es: {sha1.hexdigest()}\n")
Esta versión escribe los resultados en un archivo de texto especificado por ruta_archivo, en lugar de imprimirlos en la consola.Explicación de codigó
También es posible pedirle a la IA que explique cómo funciona una pieza de código, algo útil si estamos revisando el código de alguien más.
explica lo que hace el siguiente codigo:
import hashlib
import os
def getsha(ruta_carpeta: str) -> None:
"""Calcula el hash SHA-1 de todos los archivos en la carpeta especificada.
Args:
ruta_carpeta (str): La ruta a la carpeta donde se encuentran los archivos.
Returns:
None
"""
# Iteramos sobre los archivos en la carpeta
for archivo in os.listdir(ruta_carpeta):
# Creamos un objeto hash SHA-1
sha1 = hashlib.sha1()
# Abrimos el archivo en modo lectura en modo binario
with open(os.path.join(ruta_carpeta, archivo), 'rb') as f:
# Leemos el archivo en bloques de 4KB para no consumir mucha memoria
for bloque in iter(lambda: f.read(4096), b""):
# Actualizamos el objeto hash con el bloque leído
sha1.update(bloque)
# Imprimimos el hash SHA-1 del archivo
print(f"El hash SHA-1 del archivo {archivo} es: {sha1.hexdigest()}")Este código en Python define una función llamada getsha que calcula el hash SHA-1 de todos los archivos en una carpeta especificada y escribe los resultados en un archivo de texto. La función toma dos argumentos de cadena: ruta_carpeta, que especifica la ruta de la carpeta donde se encuentran los archivos, y ruta_archivo, que especifica la ruta del archivo de texto donde se escribirán los resultados.
La función comienza abriendo el archivo de texto especificado en modo escritura usando la declaración with. Luego, la función itera sobre los archivos en la carpeta especificada utilizando la función os.listdir. Para cada archivo, se crea un objeto hash SHA-1 utilizando la biblioteca hashlib. A continuación, se abre el archivo en modo lectura en modo binario y se lee el archivo en bloques de 4KB utilizando la función iter. Para cada bloque leído, se actualiza el objeto hash SHA-1 con el método update. Después de que se lee todo el archivo, se escribe el hash SHA-1 del archivo en el archivo de texto utilizando el método write del archivo de salida.
En resumen, la función getsha se utiliza para calcular y escribir el hash SHA-1 de todos los archivos en una carpeta especificada en un archivo de texto. Este tipo de función es útil para verificar la integridad de los archivos y para detectar cambios no autorizados en los mismos.Formateo de codigó
Podemos pedirle a ChatGPT-4 que escriba nuestro código bajo ciertas reglas de sintaxis, como PEP 8 para Python, algo que puede resultar útil si necesitamos una herramienta de este tipo.
Escribe en la guia de estilo PEP 8 el siguiente codigo:
import hashlib
import os
def getsha(ruta_carpeta: str) -> None:
"""Calcula el hash SHA-1 de todos los archivos en la carpeta especificada.
Args:
ruta_carpeta (str): La ruta a la carpeta donde se encuentran los archivos.
Returns:
None
"""
# Iteramos sobre los archivos en la carpeta
for archivo in os.listdir(ruta_carpeta):
# Creamos un objeto hash SHA-1
sha1 = hashlib.sha1()
# Abrimos el archivo en modo lectura en modo binario
with open(os.path.join(ruta_carpeta, archivo), 'rb') as f:
# Leemos el archivo en bloques de 4KB para no consumir mucha memoria
for bloque in iter(lambda: f.read(4096), b""):
# Actualizamos el objeto hash con el bloque leído
sha1.update(bloque)
# Imprimimos el hash SHA-1 del archivo
print(f"El hash SHA-1 del archivo {archivo} es: {sha1.hexdigest()}")Aquí está el código revisado de acuerdo con las convenciones de estilo de PEP 8:
python
Copy code
import hashlib
import os
def get_sha(ruta_carpeta: str) -> None:
"""Calcula el hash SHA-1 de todos los archivos en la carpeta especificada.
Args:
ruta_carpeta (str): La ruta a la carpeta donde se encuentran los archivos.
Returns:
None
"""
# Iteramos sobre los archivos en la carpeta
for archivo in os.listdir(ruta_carpeta):
# Creamos un objeto hash SHA-1
sha1 = hashlib.sha1()
# Abrimos el archivo en modo lectura en modo binario
with open(os.path.join(ruta_carpeta, archivo), 'rb') as f:
# Leemos el archivo en bloques de 4KB para no consumir mucha memoria
for bloque in iter(lambda: f.read(4096), b""):
# Actualizamos el objeto hash con el bloque leído
sha1.update(bloque)
# Imprimimos el hash SHA-1 del archivo
print(f"El hash SHA-1 del archivo {archivo} es: {sha1.hexdigest()}")
Los cambios que hice fueron los siguientes:
El nombre de la función getsha se cambió a get_sha para seguir la convención de nombres de Python, que es usar snake_case para nombres de funciones y variables.
Se agregaron dos líneas en blanco entre la definición de la función y el primer comentario para mejorar la legibilidad.
El comentario para la función se ajustó para que la primera letra de cada palabra esté en mayúscula y haya un punto al final de la oración.
El primer comentario dentro de la función se ajustó de la misma manera.
Se agregó un espacio después de cada coma en la lista de argumentos de la función.
Se agregó un espacio después de cada signo de igual en la definición de argumentos con valores predeterminados (ninguno en este caso).
Se agregó un espacio después del signo de hash en los comentarios dentro de la función.
El código dentro de la función se ajustó para que cada comentario comience con una letra mayúscula y haya un espacio después del signo de hash.
El código dentro de la función se ajustó para que haya dos líneas en blanco entre cada bloque de código para mejorar la legibilidad.Complejidad en el tiempo y en el espacio en notación O
Podemos pedirle a ChatGPT que realice el análisis del costo en tiempo y espacio de una función o trozo de código dado.
Escribe la complejidad en tiempo y espacio en notacion O del siguiente codigo:
def foo(n, k):
accum = 0
for i in range(n):
for l in range(k):
accum += i
return accumLa complejidad temporal de este código es O(nk), ya que hay dos ciclos anidados que dependen de los valores de n y k. La operación más costosa en este caso es la suma acumulativa, que se realiza k veces en cada iteración del ciclo exterior, lo que resulta en un total de nk sumas.
La complejidad espacial es O(1), ya que sólo se utiliza una variable acumuladora para almacenar el resultado de la suma, independientemente de los valores de n y k.SQL
ChatGPT-4 puede crear sentencias SQL a partir del lenguaje natural de la misma manera que el código.
### Postgres SQL tables, with their properties:
#
# Employee(id, name, department_id)
# Department(id, name, address)
# Salary_Payments(id, employee_id, amount, date)
#
### A query to list the names of the departments which employed more than 10 employees in the last 3 months
SELECTDepartment.name
FROM Department
WHERE Department.id IN
(SELECT Employee.department_id
FROM Employee
WHERE Employee.id IN
(SELECT Salary_Payments.employee_id
FROM Salary_Payments
WHERE date >= NOW() - INTERVAL '3 months'
GROUP BY Salary_Payments.employee_id
HAVING COUNT(*) > 10)
)Mermaid.js
Podemos pedirle a ChatGPT que cree diagramas escribiendo código en la sintaxis de la librería Mermaid.js, retomando el ejemplo de las tablas de Postgresql.
Escribe el diagrama de clases en Mermaid.js de las siguientes tablas Postgres SQL:
Employee(id, name, department_id)
Department(id, name, address)
Salary_Payments(id, employee_id, amount, date)classDiagram
class Employee {
id: integer
name: string
department_id: integer
}
class Department {
id: integer
name: string
address: string
}
class Salary_Payments {
id: integer
employee_id: integer
amount: decimal
date: date
}
Employee "1" *-- "many" Department : works in
Employee "1" *-- "many" Salary_Payments : receives payment
Salary_Payments "1" -- "1" Employee : payment belongs toAl colocar este código en Mermaid.live, obtenemos el diagrama correspondiente.
Además, también le podemos pedir que realice modificaciones al diagrama.
Agrega "Edificio" al diagramaAquí está el diagrama actualizado que incluye la clase "Edificio":
classDiagram
class Employee{
+id: int
+name: string
+department_id: int
}
class Department{
+id: int
+name: string
+address: string
}
class Salary_Payments{
+id: int
+employee_id: int
+amount: float
+date: date
}
class Edificio{
+id: int
+name: string
+address: string
}
Employee "1" *-- "1..*" Department
Employee "1" *-- "0..*" Salary_Payments
Department "1" *-- "1..*" Employee
Edificio "1" *-- "1..*" Department
Más información sobre Mermaid se encuentra en su documentación oficial.
Utilidades
Crear tablas en Markdown que extraen informacion de un texto.
A table in markdown summarizing the fruits from Goocrux:
There are many fruits that were found on the recently discovered planet Goocrux. There are neoskizzles that grow there, which are purple and taste like candy. There are also loheckles, which are a grayish blue fruit and are very tart, a little bit like a lemon. Pounits are a bright green color and are more savory than sweet. There are also plenty of loopnovas which are a neon pink flavor and taste like cotton candy. Finally, there are fruits called glowls, which have a very sour and bitter taste which is acidic and caustic, and a pale orange tinge to them.
| Fruit | Color | Flavor ||-------|-------|--------|
| Neoskizzles | Purple | Candy-like |
| Loheckles | Grayish blue | Tart (like a lemon) |
| Pounits | Bright green | Savory |
| Loopnovas | Neon pink | Cotton candy-like |
| Glowls | Pale orange | Sour and bitter |Conversión de código de un lenguaje a otro.
Convierte el siguiente codigo de python a javascript:
def foo(n, k):
accum = 0
for i in range(n):
for l in range(k):
accum += i
return accumfunction foo(n, k) {
let accum = 0;
for (let i = 0; i < n; i++) {
for (let l = 0; l < k; l++) {
accum += i;
}
}
return accum;
}ChatGPT como plugin
Existen distintos paquetes que permiten emplear las características de ChatGPT de forma integrada a los editores más populares, como es el caso de Visual Studio Code o Sublime Text 3 y Sublime Text 4, los cuales se listan a continuación.
Visual Studio Code:
Sublime Text 3:
Sublime Text 4:
Conclusión
ChatGPT-4 es una herramienta de programación muy versátil que puede ser utilizada en diversas tareas secundarias de un programador. Además, existen paquetes que permiten integrar las características de ChatGPT-4 en editores populares como Visual Studio Code o Sublime Text, lo que hace que su uso sea aún más accesible.
En resumen, ChatGPT-4 es una herramienta valiosa para los programadores y puede ayudar a mejorar la eficiencia y la precisión en el desarrollo de software.
P.D. Este artículo fue escrito en colaboración con ChatGPT-4.
Josue Acevedo Maldonado is a software engineer, currently working as a consultant.
Connect in LinkedIn.
Thank you for being part of the community!
You can find related content on linktr.ee, besides the book Ensamblador X86.
