[PROGRAMMATION] Je code ce que vous voulez

Écris prout sur 1 000 000 lignes et envoie le txt stp

code moi un bot de trading binecoin pour devenir très riche

Tu tombes bien l'auteur. J'aimerais que tu me fasses un script bash qui me retourne la descripion d'une commande (tirée du manuel de la commande - man).

Par exemple :

monscript ls list directory contents
monscript cp copy files and directories

Aussi, un autre problème est que si c'est utilisé, GitHub va se mettre à apprendre grâce à du code de merde déjà généré par copilot. Sauf s'ils ont une autre IA pour détecter le code de merde, mais dans ce cas ils devraient GANer un peu plus.https://image.noelshack.com/fichiers/2017/02/1484039097-jesussssss.png

un algo qui resort la liste de tous les palindrome dans un STRING

exemple : ABABA
Sotie : ABA , ABABA, BAB

Le 30 mai 2022 à 20:44:12 :

Le 30 mai 2022 à 20:31:19 :

Le 30 mai 2022 à 20:24:03 :

Le 30 mai 2022 à 20:17:55 :

Le 30 mai 2022 à 20:12:19 :

• Médiane de 2 listes triées,
• Résolution du consensus (modèle de ton choix),
• Un adaptateur qui, prenant en compte le théorème CAP, implémente pour un système répliqué donné la méthode execute(request: String, strong_consistency: bool) -> Maybe<Response>.

# median of two sorted list

def median(a, b):

    if len(a) == 0:

        return b[len(b) // 2]

    if len(b) == 0:

        return a[len(a) // 2]

    if len(a) == 1:

        return (a[0] + b[len(b) // 2]) / 2

    if len(b) == 1:

        return (a[len(a) // 2] + b[0]) / 2

    return (a[len(a) // 2] + b[len(b) // 2]) / 2

J'ai du sélectionner manuellement dans les 10 solutions proposées. J'avoue je suis pas 100% confiant que la solution est correct

Consensus trop vague
Le 3 il me génère que des commentaires où il me raconte sa vie ce fdp

Il fait la moyenne des médianes malheureusement, mais, pour sa défense, il y a un rapport avec la question et c'est chaud. La vraie solution devrait faire un binary search, etc.

Disons Paxos pour le consensus. Genre
# solve consensus using paxos
def propose(proposal):

Et pour le pavé qu'il envoie en 3, balance, ça m'intéresse.

Ah j'avoue pour la 1

# compute the median of two sorted list. Use binary search

def median(a, b):

    if len(a) == 0:

        return b[len(b)//2]

    if len(b) == 0:

        return a[len(a)//2]

    if len(a) == 1 and len(b) == 1:

        return (a[0] + b[0]) / 2

    if len(a) == 1:

        return (a[0] + b[len(b)//2]) / 2

    if len(b) == 1:

        return (a[len(a)//2] + b[0]) / 2

    if len(a) == 2 and len(b) == 2:

        return (max(a[0], b[0]) + min(a[1], b[1])) / 2

    if len(a) == 2:

        return (max(a[0], b[len(b)//2]) + min(a[1], b[len(b)//2+1])) / 2

    if len(b) == 2:

        return (max(a[len(a)//2], b[0]) + min(a[len(a)//2+1], b[1])) / 2

    if a[len(a)//2] == b[len(b)//2]:

        return a[len(a)//2]

    if a[len(a)//2] > b[len(b)//2]:

        return median(a[:len(a)//2+1], b[len(b)//2:])

    else:

        return median(a[len(a)//2:], b[:len(b)//2+1])

C'est trop long pour juger rapidement si c'est juste isse

Malaise le paxos isse

# solve consensus using paxos

def propose(proposal):

    # send proposal to all nodes

    for node in nodes:

        node.propose(proposal)

    # wait for consensus

    for node in nodes:

        node.wait_for_consensus()

    # return the proposal

    return proposal  

En forçant un peu pour le 3 j'ai ça (mais la plupart des outputs c'est le même commentaire en boucle c'est bof. L'ai j'ai 2 outputs. D'abord les 2 premiers commentaires, puis je re-query pour avoir le code)

# Un adaptateur qui, prenant en compte le théorème CAP, implémente pour un système répliqué donné la méthode execute(request: String, strong_consistency: bool) -> Maybe<Response>.

# Si strong_consistency est vrai, alors la réponse est la même pour tous les serveurs du système.

# Si strong_consistency est faux, alors la réponse est la même pour un seul serveur du système.

class ReplicatedSystem:

    def __init__(self, servers):

        self.servers = servers



    def execute(self, request, strong_consistency):

        if strong_consistency:

            return self.execute_strong(request)

        else:

            return self.execute_weak(request)



    def execute_strong(self, request):

        responses = []

        for server in self.servers:

            response = server.execute(request, True)

            responses.append(response)

        return responses



    def execute_weak(self, request):

        responses = []

        for server in self.servers:

            response = server.execute(request, False)

            responses.append(response)

        return responses

Cimer, c'est pas demain qu'on l'utilisera pour coder quoi que ce soit d'utile, mais ça a le mérite d'être rigolo.
Plus sérieusement, je ne vois pas à quel moment une telle assistance peut être utile. Peut-être pour ceux qui font 0 algorithmique et qui écrivent du CRUD... et encore, le truc doit introduire de sales bugs. Le problème étant qu'on on pourra jamais lui faire confiance, et qu'utiliser le code (maintenu et testé) de quelqu'un d'autre ça s'appelle utiliser une bibliothèque. :/

Je pensais ça aussi. Et j'ai testé sur un "projet" (< 1k LOC, c'était un ptit truc d'un weekend), et c'est vraiment surprenant
En fait ça t'aide dans tous les trucs répétitifs, genre c'est plus rapide de faire "entrer" et d'attendre copilot que de c/c la ligne d'avant et de modifier les champs (genre les trucs position.x += vitesse.x)

J'ai pas encore trop testé, et je suis pas un crack, mais je pense que si t'es bon ça peut t'aider. (Et si t'es un nul tu te feras piéger par les mauvaises complexité, le code faux, etc...)
Mais vraiment le tester et voir que c'est de l'autocomplete en 100x mieux ça m'a retourné le cerveau. Surtout python bof ça met n'imp, mais sur golang c'est dément. T'as une loop de 10 instructions que tu fais sur un tableau, tu mets juste "entrer" et ça te génère la même boucle avec un autre tableau lié. Vraiment c'est dingue. Et ça t'évite de chercher sur google comment faire des trucs quand tu connais pas le langage (genre trier un tableau ce genre de merde)

Pour les sales bugs par contre j'avoue 100%, faut être vigileant et ça a l'air ok donc tu fais moins gaffe

Le 30 mai 2022 à 20:50:46 :

Le 30 mai 2022 à 20:44:12 :

Le 30 mai 2022 à 20:31:19 :

Le 30 mai 2022 à 20:24:03 :

Le 30 mai 2022 à 20:17:55 :

Le 30 mai 2022 à 20:12:19 :

• Médiane de 2 listes triées,
• Résolution du consensus (modèle de ton choix),
• Un adaptateur qui, prenant en compte le théorème CAP, implémente pour un système répliqué donné la méthode execute(request: String, strong_consistency: bool) -> Maybe<Response>.

# median of two sorted list

def median(a, b):

    if len(a) == 0:

        return b[len(b) // 2]

    if len(b) == 0:

        return a[len(a) // 2]

    if len(a) == 1:

        return (a[0] + b[len(b) // 2]) / 2

    if len(b) == 1:

        return (a[len(a) // 2] + b[0]) / 2

    return (a[len(a) // 2] + b[len(b) // 2]) / 2

J'ai du sélectionner manuellement dans les 10 solutions proposées. J'avoue je suis pas 100% confiant que la solution est correct

Consensus trop vague
Le 3 il me génère que des commentaires où il me raconte sa vie ce fdp

Il fait la moyenne des médianes malheureusement, mais, pour sa défense, il y a un rapport avec la question et c'est chaud. La vraie solution devrait faire un binary search, etc.

Disons Paxos pour le consensus. Genre
# solve consensus using paxos
def propose(proposal):

Et pour le pavé qu'il envoie en 3, balance, ça m'intéresse.

Ah j'avoue pour la 1

# compute the median of two sorted list. Use binary search

def median(a, b):

    if len(a) == 0:

        return b[len(b)//2]

    if len(b) == 0:

        return a[len(a)//2]

    if len(a) == 1 and len(b) == 1:

        return (a[0] + b[0]) / 2

    if len(a) == 1:

        return (a[0] + b[len(b)//2]) / 2

    if len(b) == 1:

        return (a[len(a)//2] + b[0]) / 2

    if len(a) == 2 and len(b) == 2:

        return (max(a[0], b[0]) + min(a[1], b[1])) / 2

    if len(a) == 2:

        return (max(a[0], b[len(b)//2]) + min(a[1], b[len(b)//2+1])) / 2

    if len(b) == 2:

        return (max(a[len(a)//2], b[0]) + min(a[len(a)//2+1], b[1])) / 2

    if a[len(a)//2] == b[len(b)//2]:

        return a[len(a)//2]

    if a[len(a)//2] > b[len(b)//2]:

        return median(a[:len(a)//2+1], b[len(b)//2:])

    else:

        return median(a[len(a)//2:], b[:len(b)//2+1])

C'est trop long pour juger rapidement si c'est juste isse

Malaise le paxos isse

# solve consensus using paxos

def propose(proposal):

    # send proposal to all nodes

    for node in nodes:

        node.propose(proposal)

    # wait for consensus

    for node in nodes:

        node.wait_for_consensus()

    # return the proposal

    return proposal  

En forçant un peu pour le 3 j'ai ça (mais la plupart des outputs c'est le même commentaire en boucle c'est bof. L'ai j'ai 2 outputs. D'abord les 2 premiers commentaires, puis je re-query pour avoir le code)

# Un adaptateur qui, prenant en compte le théorème CAP, implémente pour un système répliqué donné la méthode execute(request: String, strong_consistency: bool) -> Maybe<Response>.

# Si strong_consistency est vrai, alors la réponse est la même pour tous les serveurs du système.

# Si strong_consistency est faux, alors la réponse est la même pour un seul serveur du système.

class ReplicatedSystem:

    def __init__(self, servers):

        self.servers = servers



    def execute(self, request, strong_consistency):

        if strong_consistency:

            return self.execute_strong(request)

        else:

            return self.execute_weak(request)



    def execute_strong(self, request):

        responses = []

        for server in self.servers:

            response = server.execute(request, True)

            responses.append(response)

        return responses



    def execute_weak(self, request):

        responses = []

        for server in self.servers:

            response = server.execute(request, False)

            responses.append(response)

        return responses

Cimer, c'est pas demain qu'on l'utilisera pour coder quoi que ce soit d'utile, mais ça a le mérite d'être rigolo.
Plus sérieusement, je ne vois pas à quel moment une telle assistance peut être utile. Peut-être pour ceux qui font 0 algorithmique et qui écrivent du CRUD... et encore, le truc doit introduire de sales bugs. Le problème étant qu'on on pourra jamais lui faire confiance, et qu'utiliser le code (maintenu et testé) de quelqu'un d'autre ça s'appelle utiliser une bibliothèque. :/

Je pensais ça aussi. Et j'ai testé sur un "projet" (< 1k LOC, c'était un ptit truc d'un weekend), et c'est vraiment surprenant
En fait ça t'aide dans tous les trucs répétitifs, genre c'est plus rapide de faire "entrer" et d'attendre copilot que de c/c la ligne d'avant et de modifier les champs (genre les trucs position.x += vitesse.x)

Sauf que ce genre de truc est inutile.
On perd pas notre temps sur le code (un bon dev maîtrise son IDE, les raccourcis, sait coder sur plusieurs lignes en même temps, a configuré ses propres live templates..) mais sur la conception et le refactoring.

Copilot c'est bien pour faire du code de merde pour les projets étudiants. Si tu veux faire du clean code t'oublies ça.

Le 30 mai 2022 à 20:47:35 :
Tu tombes bien l'auteur. J'aimerais que tu me fasses un script bash qui me retourne la descripion d'une commande (tirée du manuel de la commande - man).

Par exemple :

monscript ls list directory contents
monscript cp copy files and directories

Oh ça j'aime. Je test

Malaise j'ai du query 10 fois et malaise le résultat

# create a command that takes as input a unix command like ls and output a description of what it does

# it should be able to be called as follows

# $ ./command_description.py ls

# ls is a unix command that lists the files in the current directory

# it should print something like the following

# ls is a unix command that lists the files in the current directory



import sys

import subprocess



# get the command name from the command line arguments

command = sys.argv[1]



# get the help from the command

output = subprocess.run(["help", command], capture_output=True)



# print the output

print(f"{command} is a unix command that {output.stdout.decode('utf-8')}")

La ya 3 query bordelent chaque fois je devais selectionner dans les 10 outputs
Et tes exemples aidaient 0. Ca faisait générer à copilot ces mêmes exemples pour d'autres commandes isse

Le 30 mai 2022 à 20:49:33 :
un algo qui resort la liste de tous les palindrome dans un STRING

exemple : ABABA
Sotie : ABA , ABABA, BAB

J'ai testé sur ton exemple ça a output ['BAB', 'ABA']

# print all palyondroms of a string 

# example : ABABA

# output : ABA , ABABA, BAB





# function : palyondrom

# input : string

# output : list of palyondroms

def palyondrom(string):

    pal = []

    for i in range(len(string)):

        for j in range(i+1,len(string)):

            if string[i:j+1] == string[j:i-1:-1]:

                pal.append(string[i:j+1])

    return pal

Le 30 mai 2022 à 20:53:38 :

Le 30 mai 2022 à 20:50:46 :

Le 30 mai 2022 à 20:44:12 :

Le 30 mai 2022 à 20:31:19 :

Le 30 mai 2022 à 20:24:03 :

Le 30 mai 2022 à 20:17:55 :

Le 30 mai 2022 à 20:12:19 :

• Médiane de 2 listes triées,
• Résolution du consensus (modèle de ton choix),
• Un adaptateur qui, prenant en compte le théorème CAP, implémente pour un système répliqué donné la méthode execute(request: String, strong_consistency: bool) -> Maybe<Response>.

# median of two sorted list

def median(a, b):

    if len(a) == 0:

        return b[len(b) // 2]

    if len(b) == 0:

        return a[len(a) // 2]

    if len(a) == 1:

        return (a[0] + b[len(b) // 2]) / 2

    if len(b) == 1:

        return (a[len(a) // 2] + b[0]) / 2

    return (a[len(a) // 2] + b[len(b) // 2]) / 2

J'ai du sélectionner manuellement dans les 10 solutions proposées. J'avoue je suis pas 100% confiant que la solution est correct

Consensus trop vague
Le 3 il me génère que des commentaires où il me raconte sa vie ce fdp

Il fait la moyenne des médianes malheureusement, mais, pour sa défense, il y a un rapport avec la question et c'est chaud. La vraie solution devrait faire un binary search, etc.

Disons Paxos pour le consensus. Genre
# solve consensus using paxos
def propose(proposal):

Et pour le pavé qu'il envoie en 3, balance, ça m'intéresse.

Ah j'avoue pour la 1

# compute the median of two sorted list. Use binary search

def median(a, b):

    if len(a) == 0:

        return b[len(b)//2]

    if len(b) == 0:

        return a[len(a)//2]

    if len(a) == 1 and len(b) == 1:

        return (a[0] + b[0]) / 2

    if len(a) == 1:

        return (a[0] + b[len(b)//2]) / 2

    if len(b) == 1:

        return (a[len(a)//2] + b[0]) / 2

    if len(a) == 2 and len(b) == 2:

        return (max(a[0], b[0]) + min(a[1], b[1])) / 2

    if len(a) == 2:

        return (max(a[0], b[len(b)//2]) + min(a[1], b[len(b)//2+1])) / 2

    if len(b) == 2:

        return (max(a[len(a)//2], b[0]) + min(a[len(a)//2+1], b[1])) / 2

    if a[len(a)//2] == b[len(b)//2]:

        return a[len(a)//2]

    if a[len(a)//2] > b[len(b)//2]:

        return median(a[:len(a)//2+1], b[len(b)//2:])

    else:

        return median(a[len(a)//2:], b[:len(b)//2+1])

C'est trop long pour juger rapidement si c'est juste isse

Malaise le paxos isse

# solve consensus using paxos

def propose(proposal):

    # send proposal to all nodes

    for node in nodes:

        node.propose(proposal)

    # wait for consensus

    for node in nodes:

        node.wait_for_consensus()

    # return the proposal

    return proposal  

En forçant un peu pour le 3 j'ai ça (mais la plupart des outputs c'est le même commentaire en boucle c'est bof. L'ai j'ai 2 outputs. D'abord les 2 premiers commentaires, puis je re-query pour avoir le code)

# Un adaptateur qui, prenant en compte le théorème CAP, implémente pour un système répliqué donné la méthode execute(request: String, strong_consistency: bool) -> Maybe<Response>.

# Si strong_consistency est vrai, alors la réponse est la même pour tous les serveurs du système.

# Si strong_consistency est faux, alors la réponse est la même pour un seul serveur du système.

class ReplicatedSystem:

    def __init__(self, servers):

        self.servers = servers



    def execute(self, request, strong_consistency):

        if strong_consistency:

            return self.execute_strong(request)

        else:

            return self.execute_weak(request)



    def execute_strong(self, request):

        responses = []

        for server in self.servers:

            response = server.execute(request, True)

            responses.append(response)

        return responses



    def execute_weak(self, request):

        responses = []

        for server in self.servers:

            response = server.execute(request, False)

            responses.append(response)

        return responses

Cimer, c'est pas demain qu'on l'utilisera pour coder quoi que ce soit d'utile, mais ça a le mérite d'être rigolo.
Plus sérieusement, je ne vois pas à quel moment une telle assistance peut être utile. Peut-être pour ceux qui font 0 algorithmique et qui écrivent du CRUD... et encore, le truc doit introduire de sales bugs. Le problème étant qu'on on pourra jamais lui faire confiance, et qu'utiliser le code (maintenu et testé) de quelqu'un d'autre ça s'appelle utiliser une bibliothèque. :/

Je pensais ça aussi. Et j'ai testé sur un "projet" (< 1k LOC, c'était un ptit truc d'un weekend), et c'est vraiment surprenant
En fait ça t'aide dans tous les trucs répétitifs, genre c'est plus rapide de faire "entrer" et d'attendre copilot que de c/c la ligne d'avant et de modifier les champs (genre les trucs position.x += vitesse.x)

Sauf que ce genre de truc est inutile.
On perd pas notre temps sur le code (un bon dev maîtrise son IDE, les raccourcis, sait coder sur plusieurs lignes en même temps, a configuré ses propres live templates..) mais sur la conception et le refactoring.

Copilot c'est bien pour faire du code de merde pour les projets étudiants. Si tu veux faire du clean code t'oublies ça.

Jsais pas jsais pas. En vrai c'est moins trivial que ce que tu penses, je pense
Après t'es ptet senior et moi j'ai <30ans, mais j'utilise des IDE (pour goland j'utilise goland de jetbrains et le refactoring est sympa ouais) mais la c'est vraiment adapté à ton code et pas un truc générique genre "remplacer un symbole"

Ce que génère copilot c'est vraiment non trivial. Après peut être t'es crack et dans ce cas ignore mon message bg. Mais vraiment c'est non trivial

Le 30 mai 2022 à 20:59:49 :

Le 30 mai 2022 à 20:47:35 :
Tu tombes bien l'auteur. J'aimerais que tu me fasses un script bash qui me retourne la descripion d'une commande (tirée du manuel de la commande - man).

Par exemple :

monscript ls list directory contents
monscript cp copy files and directories

Oh ça j'aime. Je test

Malaise j'ai du query 10 fois et malaise le résultat

# create a command that takes as input a unix command like ls and output a description of what it does

# it should be able to be called as follows

# $ ./command_description.py ls

# ls is a unix command that lists the files in the current directory

# it should print something like the following

# ls is a unix command that lists the files in the current directory



import sys

import subprocess



# get the command name from the command line arguments

command = sys.argv[1]



# get the help from the command

output = subprocess.run(["help", command], capture_output=True)



# print the output

print(f"{command} is a unix command that {output.stdout.decode('utf-8')}")

La ya 3 query bordelent chaque fois je devais selectionner dans les 10 outputs
Et tes exemples aidaient 0. Ca faisait générer à copilot ces mêmes exemples pour d'autres commandes isse

J'ai cherché une solution, je viens de voir qu'on peut utiliser la commande unix apropos ls

Merci quand même clé

Le 30 mai 2022 à 21:05:22 :

Le 30 mai 2022 à 20:53:38 :

Le 30 mai 2022 à 20:50:46 :

Le 30 mai 2022 à 20:44:12 :

Le 30 mai 2022 à 20:31:19 :

Le 30 mai 2022 à 20:24:03 :

Le 30 mai 2022 à 20:17:55 :

Le 30 mai 2022 à 20:12:19 :

• Médiane de 2 listes triées,
• Résolution du consensus (modèle de ton choix),
• Un adaptateur qui, prenant en compte le théorème CAP, implémente pour un système répliqué donné la méthode execute(request: String, strong_consistency: bool) -> Maybe<Response>.

# median of two sorted list

def median(a, b):

    if len(a) == 0:

        return b[len(b) // 2]

    if len(b) == 0:

        return a[len(a) // 2]

    if len(a) == 1:

        return (a[0] + b[len(b) // 2]) / 2

    if len(b) == 1:

        return (a[len(a) // 2] + b[0]) / 2

    return (a[len(a) // 2] + b[len(b) // 2]) / 2

J'ai du sélectionner manuellement dans les 10 solutions proposées. J'avoue je suis pas 100% confiant que la solution est correct

Consensus trop vague
Le 3 il me génère que des commentaires où il me raconte sa vie ce fdp

Il fait la moyenne des médianes malheureusement, mais, pour sa défense, il y a un rapport avec la question et c'est chaud. La vraie solution devrait faire un binary search, etc.

Disons Paxos pour le consensus. Genre
# solve consensus using paxos
def propose(proposal):

Et pour le pavé qu'il envoie en 3, balance, ça m'intéresse.

Ah j'avoue pour la 1

# compute the median of two sorted list. Use binary search

def median(a, b):

    if len(a) == 0:

        return b[len(b)//2]

    if len(b) == 0:

        return a[len(a)//2]

    if len(a) == 1 and len(b) == 1:

        return (a[0] + b[0]) / 2

    if len(a) == 1:

        return (a[0] + b[len(b)//2]) / 2

    if len(b) == 1:

        return (a[len(a)//2] + b[0]) / 2

    if len(a) == 2 and len(b) == 2:

        return (max(a[0], b[0]) + min(a[1], b[1])) / 2

    if len(a) == 2:

        return (max(a[0], b[len(b)//2]) + min(a[1], b[len(b)//2+1])) / 2

    if len(b) == 2:

        return (max(a[len(a)//2], b[0]) + min(a[len(a)//2+1], b[1])) / 2

    if a[len(a)//2] == b[len(b)//2]:

        return a[len(a)//2]

    if a[len(a)//2] > b[len(b)//2]:

        return median(a[:len(a)//2+1], b[len(b)//2:])

    else:

        return median(a[len(a)//2:], b[:len(b)//2+1])

C'est trop long pour juger rapidement si c'est juste isse

Malaise le paxos isse

# solve consensus using paxos

def propose(proposal):

    # send proposal to all nodes

    for node in nodes:

        node.propose(proposal)

    # wait for consensus

    for node in nodes:

        node.wait_for_consensus()

    # return the proposal

    return proposal  

En forçant un peu pour le 3 j'ai ça (mais la plupart des outputs c'est le même commentaire en boucle c'est bof. L'ai j'ai 2 outputs. D'abord les 2 premiers commentaires, puis je re-query pour avoir le code)

# Un adaptateur qui, prenant en compte le théorème CAP, implémente pour un système répliqué donné la méthode execute(request: String, strong_consistency: bool) -> Maybe<Response>.

# Si strong_consistency est vrai, alors la réponse est la même pour tous les serveurs du système.

# Si strong_consistency est faux, alors la réponse est la même pour un seul serveur du système.

class ReplicatedSystem:

    def __init__(self, servers):

        self.servers = servers



    def execute(self, request, strong_consistency):

        if strong_consistency:

            return self.execute_strong(request)

        else:

            return self.execute_weak(request)



    def execute_strong(self, request):

        responses = []

        for server in self.servers:

            response = server.execute(request, True)

            responses.append(response)

        return responses



    def execute_weak(self, request):

        responses = []

        for server in self.servers:

            response = server.execute(request, False)

            responses.append(response)

        return responses

Cimer, c'est pas demain qu'on l'utilisera pour coder quoi que ce soit d'utile, mais ça a le mérite d'être rigolo.
Plus sérieusement, je ne vois pas à quel moment une telle assistance peut être utile. Peut-être pour ceux qui font 0 algorithmique et qui écrivent du CRUD... et encore, le truc doit introduire de sales bugs. Le problème étant qu'on on pourra jamais lui faire confiance, et qu'utiliser le code (maintenu et testé) de quelqu'un d'autre ça s'appelle utiliser une bibliothèque. :/

Je pensais ça aussi. Et j'ai testé sur un "projet" (< 1k LOC, c'était un ptit truc d'un weekend), et c'est vraiment surprenant
En fait ça t'aide dans tous les trucs répétitifs, genre c'est plus rapide de faire "entrer" et d'attendre copilot que de c/c la ligne d'avant et de modifier les champs (genre les trucs position.x += vitesse.x)

Sauf que ce genre de truc est inutile.
On perd pas notre temps sur le code (un bon dev maîtrise son IDE, les raccourcis, sait coder sur plusieurs lignes en même temps, a configuré ses propres live templates..) mais sur la conception et le refactoring.

Copilot c'est bien pour faire du code de merde pour les projets étudiants. Si tu veux faire du clean code t'oublies ça.

Jsais pas jsais pas. En vrai c'est moins trivial que ce que tu penses, je pense
Après t'es ptet senior et moi j'ai <30ans, mais j'utilise des IDE (pour goland j'utilise goland de jetbrains et le refactoring est sympa ouais) mais la c'est vraiment adapté à ton code et pas un truc générique genre "remplacer un symbole"

Ce que génère copilot c'est vraiment non trivial. Après peut être t'es crack et dans ce cas ignore mon message bg. Mais vraiment c'est non trivial

Non je code en prog fonctionnelle + clean code, et ce que génère copilot c'est vraiment pas ouf

Et comme je l'ai dit une bonne partie de notre travail consiste à concevoir le code et le rendre propre. Aujourd'hui j'aurais pu bêtement faire un c/c d'un code existant dans le projet. Sauf que j'ai souhaité refactorer cela avec pas mal de générécité, ce qui permettra dans le futur de gagner beaucoup de temps (on a beaucoup de code similaire à venir) tout en ayant une logique métier centralisée et donc un code unique à maintenir.

Copilot est incapable de faire ça.

Tic tac toc stp

Le 30 mai 2022 à 21:07:57 :

Le 30 mai 2022 à 21:05:22 :

Le 30 mai 2022 à 20:53:38 :

Le 30 mai 2022 à 20:50:46 :

Le 30 mai 2022 à 20:44:12 :

Le 30 mai 2022 à 20:31:19 :

Le 30 mai 2022 à 20:24:03 :

Le 30 mai 2022 à 20:17:55 :

Le 30 mai 2022 à 20:12:19 :

• Médiane de 2 listes triées,
• Résolution du consensus (modèle de ton choix),
• Un adaptateur qui, prenant en compte le théorème CAP, implémente pour un système répliqué donné la méthode execute(request: String, strong_consistency: bool) -> Maybe<Response>.

# median of two sorted list

def median(a, b):

    if len(a) == 0:

        return b[len(b) // 2]

    if len(b) == 0:

        return a[len(a) // 2]

    if len(a) == 1:

        return (a[0] + b[len(b) // 2]) / 2

    if len(b) == 1:

        return (a[len(a) // 2] + b[0]) / 2

    return (a[len(a) // 2] + b[len(b) // 2]) / 2

J'ai du sélectionner manuellement dans les 10 solutions proposées. J'avoue je suis pas 100% confiant que la solution est correct

Consensus trop vague
Le 3 il me génère que des commentaires où il me raconte sa vie ce fdp

Il fait la moyenne des médianes malheureusement, mais, pour sa défense, il y a un rapport avec la question et c'est chaud. La vraie solution devrait faire un binary search, etc.

Disons Paxos pour le consensus. Genre
# solve consensus using paxos
def propose(proposal):

Et pour le pavé qu'il envoie en 3, balance, ça m'intéresse.

Ah j'avoue pour la 1

# compute the median of two sorted list. Use binary search

def median(a, b):

    if len(a) == 0:

        return b[len(b)//2]

    if len(b) == 0:

        return a[len(a)//2]

    if len(a) == 1 and len(b) == 1:

        return (a[0] + b[0]) / 2

    if len(a) == 1:

        return (a[0] + b[len(b)//2]) / 2

    if len(b) == 1:

        return (a[len(a)//2] + b[0]) / 2

    if len(a) == 2 and len(b) == 2:

        return (max(a[0], b[0]) + min(a[1], b[1])) / 2

    if len(a) == 2:

        return (max(a[0], b[len(b)//2]) + min(a[1], b[len(b)//2+1])) / 2

    if len(b) == 2:

        return (max(a[len(a)//2], b[0]) + min(a[len(a)//2+1], b[1])) / 2

    if a[len(a)//2] == b[len(b)//2]:

        return a[len(a)//2]

    if a[len(a)//2] > b[len(b)//2]:

        return median(a[:len(a)//2+1], b[len(b)//2:])

    else:

        return median(a[len(a)//2:], b[:len(b)//2+1])

C'est trop long pour juger rapidement si c'est juste isse

Malaise le paxos isse

# solve consensus using paxos

def propose(proposal):

    # send proposal to all nodes

    for node in nodes:

        node.propose(proposal)

    # wait for consensus

    for node in nodes:

        node.wait_for_consensus()

    # return the proposal

    return proposal  

En forçant un peu pour le 3 j'ai ça (mais la plupart des outputs c'est le même commentaire en boucle c'est bof. L'ai j'ai 2 outputs. D'abord les 2 premiers commentaires, puis je re-query pour avoir le code)

# Un adaptateur qui, prenant en compte le théorème CAP, implémente pour un système répliqué donné la méthode execute(request: String, strong_consistency: bool) -> Maybe<Response>.

# Si strong_consistency est vrai, alors la réponse est la même pour tous les serveurs du système.

# Si strong_consistency est faux, alors la réponse est la même pour un seul serveur du système.

class ReplicatedSystem:

    def __init__(self, servers):

        self.servers = servers



    def execute(self, request, strong_consistency):

        if strong_consistency:

            return self.execute_strong(request)

        else:

            return self.execute_weak(request)



    def execute_strong(self, request):

        responses = []

        for server in self.servers:

            response = server.execute(request, True)

            responses.append(response)

        return responses



    def execute_weak(self, request):

        responses = []

        for server in self.servers:

            response = server.execute(request, False)

            responses.append(response)

        return responses

Cimer, c'est pas demain qu'on l'utilisera pour coder quoi que ce soit d'utile, mais ça a le mérite d'être rigolo.
Plus sérieusement, je ne vois pas à quel moment une telle assistance peut être utile. Peut-être pour ceux qui font 0 algorithmique et qui écrivent du CRUD... et encore, le truc doit introduire de sales bugs. Le problème étant qu'on on pourra jamais lui faire confiance, et qu'utiliser le code (maintenu et testé) de quelqu'un d'autre ça s'appelle utiliser une bibliothèque. :/

Je pensais ça aussi. Et j'ai testé sur un "projet" (< 1k LOC, c'était un ptit truc d'un weekend), et c'est vraiment surprenant
En fait ça t'aide dans tous les trucs répétitifs, genre c'est plus rapide de faire "entrer" et d'attendre copilot que de c/c la ligne d'avant et de modifier les champs (genre les trucs position.x += vitesse.x)

Sauf que ce genre de truc est inutile.
On perd pas notre temps sur le code (un bon dev maîtrise son IDE, les raccourcis, sait coder sur plusieurs lignes en même temps, a configuré ses propres live templates..) mais sur la conception et le refactoring.

Copilot c'est bien pour faire du code de merde pour les projets étudiants. Si tu veux faire du clean code t'oublies ça.

Jsais pas jsais pas. En vrai c'est moins trivial que ce que tu penses, je pense
Après t'es ptet senior et moi j'ai <30ans, mais j'utilise des IDE (pour goland j'utilise goland de jetbrains et le refactoring est sympa ouais) mais la c'est vraiment adapté à ton code et pas un truc générique genre "remplacer un symbole"

Ce que génère copilot c'est vraiment non trivial. Après peut être t'es crack et dans ce cas ignore mon message bg. Mais vraiment c'est non trivial

Non je code en prog fonctionnelle + clean code, et ce que génère copilot c'est vraiment pas ouf

Et comme je l'ai dit une bonne partie de notre travail consiste à concevoir le code et le rendre propre. Aujourd'hui j'aurais pu bêtement faire un c/c d'un code existant dans le projet. Sauf que j'ai souhaité refactorer cela avec pas mal de générécité, ce qui permettra dans le futur de gagner beaucoup de temps (on a beaucoup de code similaire à venir) tout en ayant une logique métier centralisée et donc un code unique à maintenir.

Copilot est incapable de faire ça.

Tu fais quoi? Haskell?
Ton message est ultra générique en vrai je peux juste pas répondre le "xxx d'IA est incapable de faire ça" on a vu ça encore et encore sur pleins de sujets et chaque fois c'était faux bg

Après je suis moi même adepte des langages moins singesque que c++/go/python. J'ai testé copilot dessus et c'était ultra nul. Mais probablement parcequ'il y a pas assez de donnée d'entrainement et pas parceque le principe d'avoir de l'ia est nul

Code une fonction qui prend comme entrée une description d'un programme informatique et un paramètre et qui, grâce à la seule analyse de ce code, répond VRAI si le programme s'arrête sur son paramètre et FAUX sinon.

Le 30 mai 2022 à 21:12:09 :

Le 30 mai 2022 à 21:07:57 :

Le 30 mai 2022 à 21:05:22 :

Le 30 mai 2022 à 20:53:38 :

Le 30 mai 2022 à 20:50:46 :

Le 30 mai 2022 à 20:44:12 :

Le 30 mai 2022 à 20:31:19 :

Le 30 mai 2022 à 20:24:03 :

Le 30 mai 2022 à 20:17:55 :

Le 30 mai 2022 à 20:12:19 :

• Médiane de 2 listes triées,
• Résolution du consensus (modèle de ton choix),
• Un adaptateur qui, prenant en compte le théorème CAP, implémente pour un système répliqué donné la méthode execute(request: String, strong_consistency: bool) -> Maybe<Response>.

# median of two sorted list

def median(a, b):

    if len(a) == 0:

        return b[len(b) // 2]

    if len(b) == 0:

        return a[len(a) // 2]

    if len(a) == 1:

        return (a[0] + b[len(b) // 2]) / 2

    if len(b) == 1:

        return (a[len(a) // 2] + b[0]) / 2

    return (a[len(a) // 2] + b[len(b) // 2]) / 2

J'ai du sélectionner manuellement dans les 10 solutions proposées. J'avoue je suis pas 100% confiant que la solution est correct

Consensus trop vague
Le 3 il me génère que des commentaires où il me raconte sa vie ce fdp

Il fait la moyenne des médianes malheureusement, mais, pour sa défense, il y a un rapport avec la question et c'est chaud. La vraie solution devrait faire un binary search, etc.

Disons Paxos pour le consensus. Genre
# solve consensus using paxos
def propose(proposal):

Et pour le pavé qu'il envoie en 3, balance, ça m'intéresse.

Ah j'avoue pour la 1

# compute the median of two sorted list. Use binary search

def median(a, b):

    if len(a) == 0:

        return b[len(b)//2]

    if len(b) == 0:

        return a[len(a)//2]

    if len(a) == 1 and len(b) == 1:

        return (a[0] + b[0]) / 2

    if len(a) == 1:

        return (a[0] + b[len(b)//2]) / 2

    if len(b) == 1:

        return (a[len(a)//2] + b[0]) / 2

    if len(a) == 2 and len(b) == 2:

        return (max(a[0], b[0]) + min(a[1], b[1])) / 2

    if len(a) == 2:

        return (max(a[0], b[len(b)//2]) + min(a[1], b[len(b)//2+1])) / 2

    if len(b) == 2:

        return (max(a[len(a)//2], b[0]) + min(a[len(a)//2+1], b[1])) / 2

    if a[len(a)//2] == b[len(b)//2]:

        return a[len(a)//2]

    if a[len(a)//2] > b[len(b)//2]:

        return median(a[:len(a)//2+1], b[len(b)//2:])

    else:

        return median(a[len(a)//2:], b[:len(b)//2+1])

C'est trop long pour juger rapidement si c'est juste isse

Malaise le paxos isse

# solve consensus using paxos

def propose(proposal):

    # send proposal to all nodes

    for node in nodes:

        node.propose(proposal)

    # wait for consensus

    for node in nodes:

        node.wait_for_consensus()

    # return the proposal

    return proposal  

En forçant un peu pour le 3 j'ai ça (mais la plupart des outputs c'est le même commentaire en boucle c'est bof. L'ai j'ai 2 outputs. D'abord les 2 premiers commentaires, puis je re-query pour avoir le code)

# Un adaptateur qui, prenant en compte le théorème CAP, implémente pour un système répliqué donné la méthode execute(request: String, strong_consistency: bool) -> Maybe<Response>.

# Si strong_consistency est vrai, alors la réponse est la même pour tous les serveurs du système.

# Si strong_consistency est faux, alors la réponse est la même pour un seul serveur du système.

class ReplicatedSystem:

    def __init__(self, servers):

        self.servers = servers



    def execute(self, request, strong_consistency):

        if strong_consistency:

            return self.execute_strong(request)

        else:

            return self.execute_weak(request)



    def execute_strong(self, request):

        responses = []

        for server in self.servers:

            response = server.execute(request, True)

            responses.append(response)

        return responses



    def execute_weak(self, request):

        responses = []

        for server in self.servers:

            response = server.execute(request, False)

            responses.append(response)

        return responses

Cimer, c'est pas demain qu'on l'utilisera pour coder quoi que ce soit d'utile, mais ça a le mérite d'être rigolo.
Plus sérieusement, je ne vois pas à quel moment une telle assistance peut être utile. Peut-être pour ceux qui font 0 algorithmique et qui écrivent du CRUD... et encore, le truc doit introduire de sales bugs. Le problème étant qu'on on pourra jamais lui faire confiance, et qu'utiliser le code (maintenu et testé) de quelqu'un d'autre ça s'appelle utiliser une bibliothèque. :/

Je pensais ça aussi. Et j'ai testé sur un "projet" (< 1k LOC, c'était un ptit truc d'un weekend), et c'est vraiment surprenant
En fait ça t'aide dans tous les trucs répétitifs, genre c'est plus rapide de faire "entrer" et d'attendre copilot que de c/c la ligne d'avant et de modifier les champs (genre les trucs position.x += vitesse.x)

Sauf que ce genre de truc est inutile.
On perd pas notre temps sur le code (un bon dev maîtrise son IDE, les raccourcis, sait coder sur plusieurs lignes en même temps, a configuré ses propres live templates..) mais sur la conception et le refactoring.

Copilot c'est bien pour faire du code de merde pour les projets étudiants. Si tu veux faire du clean code t'oublies ça.

Jsais pas jsais pas. En vrai c'est moins trivial que ce que tu penses, je pense
Après t'es ptet senior et moi j'ai <30ans, mais j'utilise des IDE (pour goland j'utilise goland de jetbrains et le refactoring est sympa ouais) mais la c'est vraiment adapté à ton code et pas un truc générique genre "remplacer un symbole"

Ce que génère copilot c'est vraiment non trivial. Après peut être t'es crack et dans ce cas ignore mon message bg. Mais vraiment c'est non trivial

Non je code en prog fonctionnelle + clean code, et ce que génère copilot c'est vraiment pas ouf

Et comme je l'ai dit une bonne partie de notre travail consiste à concevoir le code et le rendre propre. Aujourd'hui j'aurais pu bêtement faire un c/c d'un code existant dans le projet. Sauf que j'ai souhaité refactorer cela avec pas mal de générécité, ce qui permettra dans le futur de gagner beaucoup de temps (on a beaucoup de code similaire à venir) tout en ayant une logique métier centralisée et donc un code unique à maintenir.

Copilot est incapable de faire ça.

Tu fais quoi? Haskell?
Ton message est ultra générique en vrai je peux juste pas répondre le "xxx d'IA est incapable de faire ça" on a vu ça encore et encore sur pleins de sujets et chaque fois c'était faux bg

Après je suis moi même adepte des langages moins singesque que c++/go/python. J'ai testé copilot dessus et c'était ultra nul. Mais probablement parcequ'il y a pas assez de donnée d'entrainement et pas parceque le principe d'avoir de l'ia est nul

Non en kotlin avec des libs fonctionnelles.

Mais qu'importe, là ça demandait de la réflexion autour de la programmation OO, de la prog fonctionnelle et autour de l'archi hexa (utilisée dans le projet). Copilot est complètement inutile là-dessus.

Le 30 mai 2022 à 21:12:55 :
Code une fonction qui prend comme entrée une description d'un programme informatique et un paramètre et qui, grâce à la seule analyse de ce code, répond VRAI si le programme s'arrête sur son paramètre et FAUX sinon.

J'ai testé ça bégaye et répond rien

Le 30 mai 2022 à 21:14:23 :

Le 30 mai 2022 à 21:12:09 :

Le 30 mai 2022 à 21:07:57 :

Le 30 mai 2022 à 21:05:22 :

Le 30 mai 2022 à 20:53:38 :

Le 30 mai 2022 à 20:50:46 :

Le 30 mai 2022 à 20:44:12 :

Le 30 mai 2022 à 20:31:19 :

Le 30 mai 2022 à 20:24:03 :

Le 30 mai 2022 à 20:17:55 :

Le 30 mai 2022 à 20:12:19 :

• Médiane de 2 listes triées,
• Résolution du consensus (modèle de ton choix),
• Un adaptateur qui, prenant en compte le théorème CAP, implémente pour un système répliqué donné la méthode execute(request: String, strong_consistency: bool) -> Maybe<Response>.

# median of two sorted list

def median(a, b):

    if len(a) == 0:

        return b[len(b) // 2]

    if len(b) == 0:

        return a[len(a) // 2]

    if len(a) == 1:

        return (a[0] + b[len(b) // 2]) / 2

    if len(b) == 1:

        return (a[len(a) // 2] + b[0]) / 2

    return (a[len(a) // 2] + b[len(b) // 2]) / 2

J'ai du sélectionner manuellement dans les 10 solutions proposées. J'avoue je suis pas 100% confiant que la solution est correct

Consensus trop vague
Le 3 il me génère que des commentaires où il me raconte sa vie ce fdp

Il fait la moyenne des médianes malheureusement, mais, pour sa défense, il y a un rapport avec la question et c'est chaud. La vraie solution devrait faire un binary search, etc.

Disons Paxos pour le consensus. Genre
# solve consensus using paxos
def propose(proposal):

Et pour le pavé qu'il envoie en 3, balance, ça m'intéresse.

Ah j'avoue pour la 1

# compute the median of two sorted list. Use binary search

def median(a, b):

    if len(a) == 0:

        return b[len(b)//2]

    if len(b) == 0:

        return a[len(a)//2]

    if len(a) == 1 and len(b) == 1:

        return (a[0] + b[0]) / 2

    if len(a) == 1:

        return (a[0] + b[len(b)//2]) / 2

    if len(b) == 1:

        return (a[len(a)//2] + b[0]) / 2

    if len(a) == 2 and len(b) == 2:

        return (max(a[0], b[0]) + min(a[1], b[1])) / 2

    if len(a) == 2:

        return (max(a[0], b[len(b)//2]) + min(a[1], b[len(b)//2+1])) / 2

    if len(b) == 2:

        return (max(a[len(a)//2], b[0]) + min(a[len(a)//2+1], b[1])) / 2

    if a[len(a)//2] == b[len(b)//2]:

        return a[len(a)//2]

    if a[len(a)//2] > b[len(b)//2]:

        return median(a[:len(a)//2+1], b[len(b)//2:])

    else:

        return median(a[len(a)//2:], b[:len(b)//2+1])

C'est trop long pour juger rapidement si c'est juste isse

Malaise le paxos isse

# solve consensus using paxos

def propose(proposal):

    # send proposal to all nodes

    for node in nodes:

        node.propose(proposal)

    # wait for consensus

    for node in nodes:

        node.wait_for_consensus()

    # return the proposal

    return proposal  

En forçant un peu pour le 3 j'ai ça (mais la plupart des outputs c'est le même commentaire en boucle c'est bof. L'ai j'ai 2 outputs. D'abord les 2 premiers commentaires, puis je re-query pour avoir le code)

# Un adaptateur qui, prenant en compte le théorème CAP, implémente pour un système répliqué donné la méthode execute(request: String, strong_consistency: bool) -> Maybe<Response>.

# Si strong_consistency est vrai, alors la réponse est la même pour tous les serveurs du système.

# Si strong_consistency est faux, alors la réponse est la même pour un seul serveur du système.

class ReplicatedSystem:

    def __init__(self, servers):

        self.servers = servers



    def execute(self, request, strong_consistency):

        if strong_consistency:

            return self.execute_strong(request)

        else:

            return self.execute_weak(request)



    def execute_strong(self, request):

        responses = []

        for server in self.servers:

            response = server.execute(request, True)

            responses.append(response)

        return responses



    def execute_weak(self, request):

        responses = []

        for server in self.servers:

            response = server.execute(request, False)

            responses.append(response)

        return responses

Cimer, c'est pas demain qu'on l'utilisera pour coder quoi que ce soit d'utile, mais ça a le mérite d'être rigolo.
Plus sérieusement, je ne vois pas à quel moment une telle assistance peut être utile. Peut-être pour ceux qui font 0 algorithmique et qui écrivent du CRUD... et encore, le truc doit introduire de sales bugs. Le problème étant qu'on on pourra jamais lui faire confiance, et qu'utiliser le code (maintenu et testé) de quelqu'un d'autre ça s'appelle utiliser une bibliothèque. :/

Je pensais ça aussi. Et j'ai testé sur un "projet" (< 1k LOC, c'était un ptit truc d'un weekend), et c'est vraiment surprenant
En fait ça t'aide dans tous les trucs répétitifs, genre c'est plus rapide de faire "entrer" et d'attendre copilot que de c/c la ligne d'avant et de modifier les champs (genre les trucs position.x += vitesse.x)

Sauf que ce genre de truc est inutile.
On perd pas notre temps sur le code (un bon dev maîtrise son IDE, les raccourcis, sait coder sur plusieurs lignes en même temps, a configuré ses propres live templates..) mais sur la conception et le refactoring.

Copilot c'est bien pour faire du code de merde pour les projets étudiants. Si tu veux faire du clean code t'oublies ça.

Jsais pas jsais pas. En vrai c'est moins trivial que ce que tu penses, je pense
Après t'es ptet senior et moi j'ai <30ans, mais j'utilise des IDE (pour goland j'utilise goland de jetbrains et le refactoring est sympa ouais) mais la c'est vraiment adapté à ton code et pas un truc générique genre "remplacer un symbole"

Ce que génère copilot c'est vraiment non trivial. Après peut être t'es crack et dans ce cas ignore mon message bg. Mais vraiment c'est non trivial

Non je code en prog fonctionnelle + clean code, et ce que génère copilot c'est vraiment pas ouf

Et comme je l'ai dit une bonne partie de notre travail consiste à concevoir le code et le rendre propre. Aujourd'hui j'aurais pu bêtement faire un c/c d'un code existant dans le projet. Sauf que j'ai souhaité refactorer cela avec pas mal de générécité, ce qui permettra dans le futur de gagner beaucoup de temps (on a beaucoup de code similaire à venir) tout en ayant une logique métier centralisée et donc un code unique à maintenir.

Copilot est incapable de faire ça.

Tu fais quoi? Haskell?
Ton message est ultra générique en vrai je peux juste pas répondre le "xxx d'IA est incapable de faire ça" on a vu ça encore et encore sur pleins de sujets et chaque fois c'était faux bg

Après je suis moi même adepte des langages moins singesque que c++/go/python. J'ai testé copilot dessus et c'était ultra nul. Mais probablement parcequ'il y a pas assez de donnée d'entrainement et pas parceque le principe d'avoir de l'ia est nul

Non en kotlin avec des libs fonctionnelles.

Mais qu'importe, là ça demandait de la réflexion autour de la programmation OO, de la prog fonctionnelle et autour de l'archi hexa (utilisée dans le projet). Copilot est complètement inutile là-dessus.

Je connais pas kotlin. Mais il y a probablement énormément d'open source dessus donc copilot peut générer du code
Test quand t'as l'occas bg. J'ai été agréablement surpris perso

Le 30 mai 2022 à 21:16:11 :

Le 30 mai 2022 à 21:12:55 :
Code une fonction qui prend comme entrée une description d'un programme informatique et un paramètre et qui, grâce à la seule analyse de ce code, répond VRAI si le programme s'arrête sur son paramètre et FAUX sinon.

J'ai testé ça bégaye et répond rien

C'est normal que copilot bégaye

https://en.wikipedia.org/wiki/Halting_problem

Le 30 mai 2022 à 21:17:54 :

Le 30 mai 2022 à 21:14:23 :

Le 30 mai 2022 à 21:12:09 :

Le 30 mai 2022 à 21:07:57 :

Le 30 mai 2022 à 21:05:22 :

Le 30 mai 2022 à 20:53:38 :

Le 30 mai 2022 à 20:50:46 :

Le 30 mai 2022 à 20:44:12 :

Le 30 mai 2022 à 20:31:19 :

Le 30 mai 2022 à 20:24:03 :

Le 30 mai 2022 à 20:17:55 :

Le 30 mai 2022 à 20:12:19 :

• Médiane de 2 listes triées,
• Résolution du consensus (modèle de ton choix),
• Un adaptateur qui, prenant en compte le théorème CAP, implémente pour un système répliqué donné la méthode execute(request: String, strong_consistency: bool) -> Maybe<Response>.

# median of two sorted list

def median(a, b):

    if len(a) == 0:

        return b[len(b) // 2]

    if len(b) == 0:

        return a[len(a) // 2]

    if len(a) == 1:

        return (a[0] + b[len(b) // 2]) / 2

    if len(b) == 1:

        return (a[len(a) // 2] + b[0]) / 2

    return (a[len(a) // 2] + b[len(b) // 2]) / 2

J'ai du sélectionner manuellement dans les 10 solutions proposées. J'avoue je suis pas 100% confiant que la solution est correct

Consensus trop vague
Le 3 il me génère que des commentaires où il me raconte sa vie ce fdp

Il fait la moyenne des médianes malheureusement, mais, pour sa défense, il y a un rapport avec la question et c'est chaud. La vraie solution devrait faire un binary search, etc.

Disons Paxos pour le consensus. Genre
# solve consensus using paxos
def propose(proposal):

Et pour le pavé qu'il envoie en 3, balance, ça m'intéresse.

Ah j'avoue pour la 1

# compute the median of two sorted list. Use binary search

def median(a, b):

    if len(a) == 0:

        return b[len(b)//2]

    if len(b) == 0:

        return a[len(a)//2]

    if len(a) == 1 and len(b) == 1:

        return (a[0] + b[0]) / 2

    if len(a) == 1:

        return (a[0] + b[len(b)//2]) / 2

    if len(b) == 1:

        return (a[len(a)//2] + b[0]) / 2

    if len(a) == 2 and len(b) == 2:

        return (max(a[0], b[0]) + min(a[1], b[1])) / 2

    if len(a) == 2:

        return (max(a[0], b[len(b)//2]) + min(a[1], b[len(b)//2+1])) / 2

    if len(b) == 2:

        return (max(a[len(a)//2], b[0]) + min(a[len(a)//2+1], b[1])) / 2

    if a[len(a)//2] == b[len(b)//2]:

        return a[len(a)//2]

    if a[len(a)//2] > b[len(b)//2]:

        return median(a[:len(a)//2+1], b[len(b)//2:])

    else:

        return median(a[len(a)//2:], b[:len(b)//2+1])

C'est trop long pour juger rapidement si c'est juste isse

Malaise le paxos isse

# solve consensus using paxos

def propose(proposal):

    # send proposal to all nodes

    for node in nodes:

        node.propose(proposal)

    # wait for consensus

    for node in nodes:

        node.wait_for_consensus()

    # return the proposal

    return proposal  

En forçant un peu pour le 3 j'ai ça (mais la plupart des outputs c'est le même commentaire en boucle c'est bof. L'ai j'ai 2 outputs. D'abord les 2 premiers commentaires, puis je re-query pour avoir le code)

# Un adaptateur qui, prenant en compte le théorème CAP, implémente pour un système répliqué donné la méthode execute(request: String, strong_consistency: bool) -> Maybe<Response>.

# Si strong_consistency est vrai, alors la réponse est la même pour tous les serveurs du système.

# Si strong_consistency est faux, alors la réponse est la même pour un seul serveur du système.

class ReplicatedSystem:

    def __init__(self, servers):

        self.servers = servers



    def execute(self, request, strong_consistency):

        if strong_consistency:

            return self.execute_strong(request)

        else:

            return self.execute_weak(request)



    def execute_strong(self, request):

        responses = []

        for server in self.servers:

            response = server.execute(request, True)

            responses.append(response)

        return responses



    def execute_weak(self, request):

        responses = []

        for server in self.servers:

            response = server.execute(request, False)

            responses.append(response)

        return responses

Cimer, c'est pas demain qu'on l'utilisera pour coder quoi que ce soit d'utile, mais ça a le mérite d'être rigolo.
Plus sérieusement, je ne vois pas à quel moment une telle assistance peut être utile. Peut-être pour ceux qui font 0 algorithmique et qui écrivent du CRUD... et encore, le truc doit introduire de sales bugs. Le problème étant qu'on on pourra jamais lui faire confiance, et qu'utiliser le code (maintenu et testé) de quelqu'un d'autre ça s'appelle utiliser une bibliothèque. :/

Je pensais ça aussi. Et j'ai testé sur un "projet" (< 1k LOC, c'était un ptit truc d'un weekend), et c'est vraiment surprenant
En fait ça t'aide dans tous les trucs répétitifs, genre c'est plus rapide de faire "entrer" et d'attendre copilot que de c/c la ligne d'avant et de modifier les champs (genre les trucs position.x += vitesse.x)

Sauf que ce genre de truc est inutile.
On perd pas notre temps sur le code (un bon dev maîtrise son IDE, les raccourcis, sait coder sur plusieurs lignes en même temps, a configuré ses propres live templates..) mais sur la conception et le refactoring.

Copilot c'est bien pour faire du code de merde pour les projets étudiants. Si tu veux faire du clean code t'oublies ça.

Jsais pas jsais pas. En vrai c'est moins trivial que ce que tu penses, je pense
Après t'es ptet senior et moi j'ai <30ans, mais j'utilise des IDE (pour goland j'utilise goland de jetbrains et le refactoring est sympa ouais) mais la c'est vraiment adapté à ton code et pas un truc générique genre "remplacer un symbole"

Ce que génère copilot c'est vraiment non trivial. Après peut être t'es crack et dans ce cas ignore mon message bg. Mais vraiment c'est non trivial

Non je code en prog fonctionnelle + clean code, et ce que génère copilot c'est vraiment pas ouf

Et comme je l'ai dit une bonne partie de notre travail consiste à concevoir le code et le rendre propre. Aujourd'hui j'aurais pu bêtement faire un c/c d'un code existant dans le projet. Sauf que j'ai souhaité refactorer cela avec pas mal de générécité, ce qui permettra dans le futur de gagner beaucoup de temps (on a beaucoup de code similaire à venir) tout en ayant une logique métier centralisée et donc un code unique à maintenir.

Copilot est incapable de faire ça.

Tu fais quoi? Haskell?
Ton message est ultra générique en vrai je peux juste pas répondre le "xxx d'IA est incapable de faire ça" on a vu ça encore et encore sur pleins de sujets et chaque fois c'était faux bg

Après je suis moi même adepte des langages moins singesque que c++/go/python. J'ai testé copilot dessus et c'était ultra nul. Mais probablement parcequ'il y a pas assez de donnée d'entrainement et pas parceque le principe d'avoir de l'ia est nul

Non en kotlin avec des libs fonctionnelles.

Mais qu'importe, là ça demandait de la réflexion autour de la programmation OO, de la prog fonctionnelle et autour de l'archi hexa (utilisée dans le projet). Copilot est complètement inutile là-dessus.

Je connais pas kotlin. Mais il y a probablement énormément d'open source dessus donc copilot peut générer du code
Test quand t'as l'occas bg. J'ai été agréablement surpris perso

Ce que tu comprends pas c'est que le code open source c'est caca.