IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

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é

Le , par Stéphane le calme

4PARTAGES

35  0 
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.

Code Python : Sélectionner tout
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 ?

Code Python : Sélectionner tout
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 !

Code Python : Sélectionner tout
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 !

Code Python : Sélectionner tout
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*? 🎭🙋

Code Python : Sélectionner tout
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.)

Code Python : Sélectionner tout
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.

Code Python : Sélectionner tout
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.

Code Python : Sélectionner tout
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 ?

Une erreur dans cette actualité ? Signalez-nous-la !

Avatar de Aiekick
Membre extrêmement actif https://www.developpez.com
Le 16/12/2023 à 13:43
c'est marrant je crois reconnaitre le style de codage de certain de mes collegues.
1  0