Trolldi : découvrez Spaghettify, l'extension Visual Studio Code qui s'appuie sur l'IA pour dégrader votre code.
Vous avez la possibilité d'utiliser différents modes suivant l'objectif recherché
Vous êtes-vous déjà demandé comment rendre votre code plus illisible, plus complexe et plus difficile à maintenir ? Si oui, vous allez adorer Spaghettify, une extension pour Visual Studio Code qui utilise la puissance de l’IA pour dégrader votre code.
Spaghettify est une extension développée par un individu répondant au pseudonyme BCAD, sans doute un développeur qui s’amuse à faire des expériences avec l’API d’OpenAI. Spaghettify s'en sert pour transformer votre code en utilisant différents modes.
Tenez par exemple du code Python qui trouve des voisins dans un tableau 2D.
1
2
3
4
5
6
7
8
9
10
| def neighbors(arr, x, y, n):
result = []
row_start = max(0, x-n)
row_end = min(len(arr)-1, x+n)
col_start = max(0, y-n)
col_end = min(len(arr[0])-1, y+n)
for i in range(row_start, row_end+1):
for j in range(col_start, col_end+1):
result.append((i, j))
return result |
Qu'est-ce que cela donnerait si l'on employait l'un des modes de Spaghettify ?
Introduire un bogue
Ajoutez un changement subtil qui brisera le code, laissant vos collègues se gratter la tête pendant des heures. Ajoutez facilement un +1 parasite, une itération supplémentaire ou une liste imbriquée*! Pouvez-vous repérer le bogue ?
1
2
3
4
5
6
7
8
9
10
| def neighbors(arr, x, y, n):
result = []
row_start = max(0, x-n)
row_end = min(len(arr)-1, x+n)
col_start = max(0, y-n)
col_end = min(len(arr[0])-1, y+n-1)
for i in range(row_start, row_end+1):
for j in range(col_start, col_end):
result.append((i, j))
return result |
Code obscur
Le code était-il trop lisible ? Trop élégant ? Vos collègues pourraient-ils comprendre ce qu’il a fait d’un simple coup d’œil ? Eh bien, plus maintenant !
def neighbors(arr,x,y,n): r=[] ; rS=max(0,x-n); rE=min(len(arr)-1,x+n); cS=max(0,y-n); cE=min(len(arr[0])-1,y+n); [r.append((i,j)) for i in range(rS,rE+1) for j in range(cS,cE+1)]; return r
Ajouter des commentaires non pertinents
Avez-vous déjà regardé du code et pensé : « Cette fonction de tri pourrait certainement nécessiter un questionnement existentiel sur la raison pour laquelle elle est là ». Maintenant, c'est facile !
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| # Définition de la fonction de recherche de voisin
# 🤔 quelle chose bizarre. Je me demande pourquoi ils ont besoin de ça.
def neighbors(arr, x, y, n): # 👋 Hello!
result = [] # résultat initialisé
row_start = max(0, x-n) # définition du début de la ligne
row_end = min(len(arr)-1, x+n) # définition de la fin de la ligne
col_start = max(0, y-n) # réglage du début du col
col_end = min(len(arr[0])-1, y+n) # réglage de la fin de la colonne
# Maintenant, j'itère pour trouver des correspondances 🤔 ??
for i in range(row_start, row_end+1): # Bah !! 😒
for j in range(col_start, col_end+1): # Marche encore
result.append((i, j)) # Coo doodly doo! :)
return result # Renvoyer le résultat
# 🤷*♂️ Tellement de logique 😱 |
Documenter avec Emoji
Pendant que nous ✍️ écrivons des commentaires, que diriez-vous 👏 de documenter le 👏 code 😤 entièrement avec des 🐺 emoji*? 🎭🙋
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| """
🌐🕵️*♂️🔍👀📍👨*👩*👧*👦
"""
def neighbors(arr, x, y, n):
"""
📊🎯🎖️
"""
result = [] # 🔍
row_start = max(0, x-n)
row_end = min(len(arr)-1, x+n)
col_start = max(0, y-n) # 💯
col_end = min(len(arr[0])-1, y+n)
for i in range(row_start, row_end+1): # 🔃
for j in range(col_start, col_end+1):
result.append((i, j)) # 🤝
return result # 🛩️ |
Noms trop descriptifs
Rendez votre code un peu plus explicite sur ce qu'il fait. (Nous vous voyons, développeurs Objective-C.)
1
2
3
4
5
6
7
8
9
10
| def neighboring_locationFinder_routine(matrix_of_cells, x_index_coordinate, y_index_coordinate, adjacency_boundaries_bracket):
list_of_neighbor_locs = []
vertical_axis_start_index = max(0, x_index_coordinate-adjacency_boundaries_bracket)
vertical_axis_end_index = min(len(matrix_of_cells)-1, x_index_coordinate+adjacency_boundaries_bracket)
horizontal_axis_start_index = max(0, y_index_coordinate-adjacency_boundaries_bracket)
horizontal_axis_end_index = min(len(matrix_of_cells[0])-1, y_index_coordinate+adjacency_boundaries_bracket)
for horizontal_index in range(vertical_axis_start_index, vertical_axis_end_index+1):
for vertical_index in range(horizontal_axis_start_index, horizontal_axis_end_index+1):
list_of_neighbor_locs.append((horizontal_index, vertical_index))
return list_of_neighbor_locs |
Espaces aléatoires
Gagnez la course à l'espace en ajoutant des espaces aléatoires et incohérents tout au long de votre code autrefois symétrique.
def neighbors (arr ,x, y , n): result =[]; row_start= max ( 0 , x-n ); row_end =min(len(arr)-1 , x + n );col_start = max (0, y - n); col_end =min ( len (arr[ 0 ]) -1 , y +n ); for i in range ( row_start , row_end +1 ): for j in range ( col_start , col_end + 1):result.append( (i , j ) ) ;return result ;
Docstring fantaisie
Documentez automatiquement votre code en utilisant n'importe quel caractère ou style. Des paroles de rap ? Sale limerick ? Un gangster des années 30 qui parle vite ? Un pirate sous acide ? Tout ce dont vous avez besoin, Spaghettify en tient compte.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| """
Returns a list full of points
From given matrix, they anoints
Up to n away
Each row and column they sway
'Til each neighbor is accounted for joint
"""
def neighbors(arr, x, y, n):
result = []
row_start = max(0, x-n)
row_end = min(len(arr)-1, x+n)
col_start = max(0, y-n)
col_end = min(len(arr[0])-1, y+n)
for i in range(row_start, row_end+1):
for j in range(col_start, col_end+1):
result.append((i, j))
return result |
Ces modes ont pour but de rendre votre code plus difficile à lire, à comprendre et à modifier, ce qui peut être utile pour :
- Vous amuser à tester vos compétences de débogage.
- Vous défouler après une journée de travail frustrante.
- Vous venger d’un collègue qui vous a laissé du code mal écrit.
- Vous protéger contre le plagiat ou la réutilisation de votre code.
Comment utiliser Spaghettify ?
Pour utiliser Spaghettify, vous devez d’abord installer l’extension depuis le Visual Studio Marketplace. Ensuite, vous devez exécuter la commande Spaghettify - Setup, qui vous demandera une clé API d’OpenAI. Vous pouvez obtenir une clé API en vous inscrivant sur le site d’OpenAI. Une fois que vous avez entré votre clé API, vous pouvez sélectionner le code que vous voulez Spaghettify et exécuter l’une des commandes Spaghettify magic brushes pour le transformer automatiquement.
Spaghettify est une extension amusante et originale qui vous permet de jouer avec votre code et de voir ce que l’IA peut en faire. Attention toutefois à ne pas l’utiliser sur du code important ou sensible, car vous risquez de le rendre irrécupérable. Spaghettify est à utiliser avec modération et à vos risques et périls.
La réaction du public
Les réactions des internautes ont été diverses et variées :
Les vrais développeurs peuvent écrire du code merdique sans aide machine.
C'est génial pour générer des exercices de débogage, merci
Ceci est un excellent outil pour tricher sur les devoirs de programmation universitaire
C’est à cela que devrait servir l’IA
Source : Spaghettify
Et vous ?
Qu’avez-vous pensé de Spaghettify ? Avez-vous essayé de l’utiliser sur votre code ?
Quel mode de Spaghettify vous a le plus amusé ou surpris ? Pourquoi ?
Quels sont les avantages et les inconvénients de rendre votre code plus mauvais avec l’IA ?
Quelles autres applications ludiques ou créatives de l’IA connaissez-vous ou aimeriez-vous découvrir ?
Quelles sont les limites de l’utilisation de l’IA pour modifier du code ?
Trolldi : découvrez Spaghettify, l'extension Visual Studio Code qui s'appuie sur l'IA pour dégrader votre code
Répondre avec citation
Partager