ChatGPT

15 sujets de 31 à 45 (sur un total de 120)

Anonyme
8 janvier 2023 à 12h33 #371200
@ACE :

Apparemment, Musk a démissionné du conseil d’administration en février 2018 mais est resté donateur.

Vu la rapidité des réponses, ce ne sont pas des humains qui répondent 😉 Et quand elle ne sait pas répondre, elle le dit (alors que là, un humain pourrait prendre le relai). Elle demande alors de l’aider à “comprendre” en lui refilant les explications… (et pour enfoncer le clou, elle te remercie)

Effectivement, les IA se basent notamment sur des données ultra-massives (dont celles qu’on échange avec elles), plus elles en ont, plus elles sont efficaces. Et comme tous les autres trucs qu’on utilise (même en cochant “je ne veux pas”), toutes nos données sont repompées en permanence ainsi que tout ce qu’on fait sur les systèmes / sites / smartphones (déjà, ‘faudrait être inscrit sur aucun réseau social et ne pas utiliser du tout de smartphone). Sur ce point, on est cuit, et on peut de moins en moins se couper totalement d’Internet…

Pour limiter / freiner le progrès des IA, ils faudrait les bombarder en permanence de données ultra-massives pourries / erronées… Mais c’est peine perdue, on serait immédiatement bloqué (attaque DDOS).

Je pense clairement que les IA font actuellement un bond et qu’elles sont une réelle menace pour notre avenir proche.

Surtout en Occident (mais plus seulement), l’automatisation et la robotisation ont détruit le travail (manuel) des ouvriers et de plus en plus celui des techniciens. L’IA finira par détruire celui des métiers intellectuels. Quand on nous vend que l’IA fera apparaître de nouveaux métiers, je ne crois pas une seconde qu’elle fournira du travail à tous ceux qui l’auront perdu à cause d’elle, et tout le monde ne pourra pas être ingénieur (voire chercheur) concepteur. Parce qu’à part être capable d’imaginer en permanence de nouvelles conceptions (dans tout métier), je ne vois pas ce qu’il nous restera comme jobs…

@Sam :

Ce n’est qu’un début, et tout le monde n’a pas besoin de calculer des intégrales ou de résoudre des systèmes différentiels.

Pour terminer, c’est la première fois que je teste une telle IA, et je ne pensais pas qu’on en était déjà à ce point…

Ça craint.

(surtout quand on voit l’état actuel de notre système éducatif, à tous niveaux… je ne vois pas ce que vont être capables de faire les jeunes générations… sans parler de l’état actuel de la planète ou des sociétés humaines)

—
/me est heureux de ne pas avoir d’enfants.
Anonyme
8 janvier 2023 à 15h07 #371203
Je viens d’avoir cet échange avec ChatGPT… (tel quel et intégral)

MOI : Si en langage SQL je crée ces deux tables :

CREATE TABLE Personnes (
idPersonne int default nextval(‘seq_personnes’) not null primary key,
Nom varchar(20) not null,
Prenom varchar(20) not null,
Date_naissance date not null,
idVille int not null);

CREATE TABLE Villes (
idVille int default nextval(‘seq_villes’) not null primary key,
Ville varchar(20) not null,
CP char(5) not null,
Nombre_pers int);

ChatGPT : Je suis d’accord avec toi, cela ressemble à deux instructions de création de tables dans le langage SQL. La première table s’appelle “Personnes” et la seconde table s’appelle “Villes”. La table “Personnes” possède les champs “idPersonne”, “Nom”, “Prenom”, “Date_naissance” et “idVille”. La table “Villes” possède les champs “idVille”, “Ville”, “CP” et “Nombre_pers”. Est-ce que cela correspond à ce que tu voulais savoir ?

MOI : D’après ces deux tables, quelle est la requête affichant tous les Nom, Prenom, Date_naissance de la table « Personnes » avec pour chacun leur Ville et CP correspondants de la table « Villes » ?

ChatGPT : Voici une requête qui devrait te permettre d’obtenir les informations que tu souhaites :

SELECT Nom, Prenom, Date_naissance, Ville, CP
FROM Personnes
INNER JOIN Villes
ON Personnes.idVille = Villes.idVille

Cette requête effectue une jointure entre la table “Personnes” et la table “Villes” en utilisant le champ “idVille” comme clé de jointure. Elle sélectionne ensuite les champs “Nom”, “Prenom”, “Date_naissance”, “Ville” et “CP” de ces deux tables et les affiche.

Note : cette requête suppose que les champs “idVille” de la table “Personnes” et de la table “Villes” sont bien liés, c’est-à-dire que leurs valeurs correspondent aux valeurs attendues. Si ce n’est pas le cas, les résultats de la requête peuvent être imprécis ou incorrects.

MOI : Donne-moi la requête SQL créant la vue qui contient le SELECT précédent et donne-moi un exemple d’utilisation de cette vue.

ChatGPT : Voici la requête SQL qui crée la vue avec le SELECT précédent :

CREATE VIEW VuePersonnesVilles AS
SELECT Nom, Prenom, Date_naissance, Ville, CP
FROM Personnes
INNER JOIN Villes
ON Personnes.idVille = Villes.idVille

Pour utiliser cette vue, tu peux la sélectionner comme tu le ferais avec une table. Par exemple, voici comment tu pourrais utiliser cette vue pour afficher tous les enregistrements qu’elle contient :

SELECT * FROM VuePersonnesVilles

Tu peux également utiliser cette vue dans une clause WHERE de la même manière que tu le ferais avec une table. Par exemple, voici comment tu pourrais utiliser cette vue pour afficher tous les enregistrements dont le nom est “Dupont” :

SELECT * FROM VuePersonnesVilles WHERE Nom = ‘Dupont’

Note : une vue est un objet de la base de données qui contient une requête SELECT enregistrée. Elle te permet de travailler avec les résultats de

MOI : Donne-moi les requêtes SQL qui insèrent 5 villes et 5 personnes dans les tables correspondantes.

ChatGPT : Voici les requêtes SQL qui permettent d’insérer 5 villes et 5 personnes dans les tables correspondantes :

— Insertion de 5 villes dans la table “Villes”
INSERT INTO Villes (idVille, Ville, CP, Nombre_pers) VALUES (1, ‘Paris’, ‘75000’, 2000000);
INSERT INTO Villes (idVille, Ville, CP, Nombre_pers) VALUES (2, ‘Lyon’, ‘69000’, 150000);
INSERT INTO Villes (idVille, Ville, CP, Nombre_pers) VALUES (3, ‘Marseille’, ‘13000’, 850000);
INSERT INTO Villes (idVille, Ville, CP, Nombre_pers) VALUES (4, ‘Toulouse’, ‘31000’, 140000);
INSERT INTO Villes (idVille, Ville, CP, Nombre_pers) VALUES (5, ‘Nice’, ‘06000’, 345000);

— Insertion de 5 personnes dans la table “Personnes”
INSERT INTO Personnes (idPersonne, Nom, Prenom, Date_naissance, idVille) VALUES (1, ‘Dupont’, ‘Jean’, ‘1980-01-01’, 1);
INSERT INTO Personnes (idPersonne, Nom, Prenom, Date_naissance, idVille) VALUES (2, ‘Durand’, ‘Marie’, ‘1985-03-15’, 2);
INSERT INTO Personnes (idPersonne, Nom, Prenom, Date_naissance, idVille) VALUES (3, ‘Moreau’, ‘Luc’, ‘1970-05-20’, 3);
INSERT INTO Personnes (idPersonne, Nom, Prenom, Date_naissance, idVille) VALUES (4, ‘Girard’, ‘Anne’, ‘1990-07-30

Précision : coupé car limite de taille apparemment… Même les données proposées sont pertinentes !

MOI : Ecris-moi en PL/pgSQL un trigger et sa fonction qui suppriment toutes les personnes de la table « Personnes » quand on supprime leur ville de la table « Villes ». Puis donne-moi un exemple de requête testant ce trigger.

ChatGPT : Voici un trigger et sa fonction en PL/pgSQL qui permettent de supprimer toutes les personnes de la table “Personnes” lorsqu’on supprime leur ville de la table “Villes” :

CREATE OR REPLACE FUNCTION supprimer_personnes() RETURNS TRIGGER AS $$
BEGIN
DELETE FROM Personnes WHERE Personnes.idVille = OLD.idVille;
RETURN OLD;
END;
$$ LANGUAGE plpgsql;

CREATE TRIGGER supprimer_personnes
AFTER DELETE ON Villes
FOR EACH ROW
EXECUTE PROCEDURE supprimer_personnes();

Pour tester ce trigger, tu peux effectuer une requête DELETE sur la table “Villes” qui va déclencher le trigger. Par exemple :

DELETE FROM Villes WHERE idVille = 1;

Cette requête supprimera la ville avec l’ID 1 de la table “Villes” et déclenchera le trigger qui supprimera toutes les personnes de la table “Personnes” ayant l’ID de ville 1.

Note : n’oublie pas de mettre à jour les valeurs de l’ID de ville dans la table “Personnes” si tu supprimes une ville de la table “Villes”. Si tu ne le fais pas, les personnes de la table “Personnes” ayant cet ID de ville ne seront pas correctement liées à une ville et pourront être supprimées par le trigger lors de la suppression d’une ville.

MOI : Comment définir la clé étrangère qui relie ces deux tables ?

ChatGPT : Pour définir la clé étrangère qui relie la table “Personnes” à la table “Villes”, tu peux utiliser la clause “FOREIGN KEY” lors de la création de la table “Personnes” comme ceci :

CREATE TABLE Personnes (
idPersonne int default nextval(‘seq_personnes’) not null primary key,
Nom varchar(20) not null,
Prenom varchar(20) not null,
Date_naissance date not null,
idVille int not null,
FOREIGN KEY (idVille) REFERENCES Villes (idVille)
);

Cette clause “FOREIGN KEY” indique que le champ “idVille” de la table “Personnes” est une clé étrangère qui référence le champ “idVille” de la table “Villes”. Cela signifie que chaque valeur de “idVille” dans la table “Personnes” doit correspondre à une valeur existante dans le champ “idVille” de la table “Villes”. Si tu essaies d’insérer une valeur dans le champ “idVille” de la table “Personnes” qui ne correspond à aucune valeur dans le champ “idVille” de la table “Villes”, tu recevras une erreur.

Note : n’oublie pas de créer la table “Villes” avant

MOI : Et avec un ALTER ?

ChatGPT : Si tu as déjà créé la table “Personnes” et que tu souhaites ajouter une clé étrangère qui la relie à la table “Villes”, tu peux utiliser la commande “ALTER TABLE” avec la clause “ADD FOREIGN KEY” comme ceci :

ALTER TABLE Personnes ADD FOREIGN KEY (idVille) REFERENCES Villes (idVille);

Cette commande ajoute une clé étrangère au champ “idVille” de la table “Personnes” qui référence le champ “idVille” de la table “Villes”. Les règles de gestion de cette clé étrangère sont les mêmes que celles décrites dans ma réponse précédente : chaque valeur de “idVille” dans la table “Personnes” doit correspondre à une valeur existante dans le champ “idVille” de la table “Villes”. Si tu essaies d’insérer une valeur dans le champ “idVille” de la table “Personnes” qui ne correspond à aucune valeur dans le champ “idVille” de la table “Villes”, tu recevras une erreur.

Note : n’oublie pas de créer la table “Villes” avant d’ajouter la clé étrangère dans la table “Personnes”. Si la table “Villes” n’existe pas, cette commande va échouer.

MOI : Ecris-moi en PL/pgSQL une fonction qui parcourt à l’aide d’un curseur tous les « idVille » de la table « Villes » (ligne par ligne) et pour chaque « idVille » lu compte le nombre de personnes de la table « Personnes » ayant cet « idVille ». Puis qui met à jour le « Nombre_pers » de la table « Villes » avec ce nombre de personnes (utiliser la clause « WHERE CURRENT OF curseur; »)

ChatGPT : Voici une fonction en PL/pgSQL qui parcourt tous les “idVille” de la table “Villes” (ligne par ligne) et met à jour le champ “Nombre_pers” de la table “Villes” avec le nombre de personnes de la table “Personnes” ayant cet “idVille” :

CREATE OR REPLACE FUNCTION mettre_a_jour_nombre_pers() AS $$
DECLARE
idVille INT;
nombre_pers INT;
curseur CURSOR FOR SELECT idVille FROM Villes;
BEGIN
OPEN curseur;
FETCH NEXT FROM curseur INTO idVille;
WHILE FOUND LOOP
SELECT COUNT(*) INTO nombre_pers FROM Personnes WHERE idVille = idVille;
UPDATE Villes SET Nombre_pers = nombre_pers WHERE CURRENT OF curseur;
FETCH NEXT FROM curseur INTO idVille;
END LOOP;
CLOSE curseur;
END;
$$ LANGUAGE plpgsql;

Pour exécuter cette fonction, tu peux utiliser la commande “SELECT” suivie du nom de la fonction, comme ceci :

SELECT mettre_a_jour_nombre_pers();

Cette commande parcourera tous les “idVille” de la table “Villes” et mettra à jour le champ “Nombre_pers” de chaque ville avec le nombre de personnes de la table “Personnes” ayant cet “idVille”.

Note : n’oublie pas de créer les tables “Villes” et “Personnes” avant d’exécuter cette fonction. Si ces tables n’existent pas, cette fonction va échouer.

(FIN)

Pour cette dernière fonction, le principe du traitement y est, et au complet. Juste une optimisation aurait pu être faite au niveau du WHILE et des FETCH (il y a un FETCH avant le WHILE car elle utilise un WHILE).

Pour tout le reste, tout est bon… 8-|

Les explications me trouent le c*l aussi… 8-|
__sam__
8 janvier 2023 à 15h43 #371204
Bon ben là moi tout suite, Chat-GPT me dit qu’ils sont saturés. Impossible de l’utiliser 🙁
Zut, qui va écrire à présent les #AltFacts pour nourrir la sphère complotiste ?

Samuel.

Amiga A500 + GVP530 (8Mo/fpu/mmu/scsi) - en panne 🙁
A500 (+ 1Mo PPS), A1200 (Blizzard-IV/fpu/64Mo)
A500 Vampire V2+ ^8^ 🙂
(mais aussi TO8, TO8D, TO9. Groupe PULS.)
Anonyme
8 janvier 2023 à 16h35 #371205
@Sam :

Rafraîchis, ça finit par passer. Ça m’est arrivé plusieurs fois aujourd’hui, c’est dimanche, les gens n’ont que ça à foutre 😛
Anonyme
8 janvier 2023 à 16h44 #371206
Encore plus fort (et en repartant de zéro, en virant les historiques, en me reconnectant, etc) :

MOI : Avec ces caractéristiques : idPersonne, Nom, Prenom, Date_naissance, idVille, Ville, CP, Nombre_pers. Donne-moi la ou les requêtes SQL créant la ou les tables nécessaires.

ChatGPT : Voici une requête SQL qui créera une table avec ces caractéristiques :

CREATE TABLE personnes (
idPersonne INTEGER PRIMARY KEY,
Nom VARCHAR(255) NOT NULL,
Prenom VARCHAR(255) NOT NULL,
Date_naissance DATE NOT NULL,
idVille INTEGER NOT NULL,
Ville VARCHAR(255) NOT NULL,
CP VARCHAR(255) NOT NULL,
Nombre_pers INTEGER NOT NULL
);

Cette requête crée une table nommée “personnes” avec huit colonnes : idPersonne, Nom, Prenom, Date_naissance, idVille, Ville, CP et Nombre_pers.

idPersonne est défini comme la clé primaire de la table, ce qui signifie qu’il s’agit d’une colonne unique utilisée pour identifier chaque ligne de la table. Les autres colonnes sont toutes définies comme NOT NULL, ce qui signifie qu’elles doivent avoir une valeur pour chaque ligne de la table.

Il est important de noter que les types de données doivent être spécifiés pour chaque colonne. Dans cet exemple, idPersonne est un entier (INTEGER), Nom, Prenom, Ville et CP sont des chaînes de caractères de longueur variable (VARCHAR), Date_naissance est une date (DATE) et Nombre_pers est un entier (INTEGER).

MOI : Et avec deux tables ayant les colonnes respectives ?

ChatGPT : Voici une requête SQL qui créera deux tables, une table “personnes” et une table “villes” :

CREATE TABLE personnes (
idPersonne INTEGER PRIMARY KEY,
Nom VARCHAR(255) NOT NULL,
Prenom VARCHAR(255) NOT NULL,
Date_naissance DATE NOT NULL,
idVille INTEGER NOT NULL,
Nombre_pers INTEGER NOT NULL,
FOREIGN KEY (idVille) REFERENCES villes(idVille)
);

CREATE TABLE villes (
idVille INTEGER PRIMARY KEY,
Ville VARCHAR(255) NOT NULL,
CP VARCHAR(255) NOT NULL
);

La table “personnes” a six colonnes : idPersonne, Nom, Prenom, Date_naissance, idVille et Nombre_pers. idPersonne est défini comme la clé primaire de la table, tandis que idVille est défini comme une clé étrangère qui référence la colonne idVille de la table “villes”. Cela signifie que la valeur de idVille dans la table “personnes” doit correspondre à une valeur existante dans la colonne idVille de la table “villes”.

La table “villes” a trois colonnes : idVille, Ville et CP. idVille est défini comme la clé primaire de la table.

Il est important de noter que les types de données doivent être spécifiés pour chaque colonne. Dans cet exemple, idPersonne et idVille sont des entiers (INTEGER), Nom, Prenom, Ville et CP sont des chaînes de caractères de longueur variable (VARCHAR) et Date_naissance est une date (DATE). Nombre_pers est un entier (INTEGER).

MOI : Corrige-moi ta dernière réponse avec la création de villes avant personnes, Nombre_pers dans villes, suivies d’un ALTER qui relie les deux tables.

ChatGPT : Voici une requête SQL qui créera deux tables, une table “villes” et une table “personnes”, puis utilisera une instruction ALTER TABLE pour ajouter une colonne à la table “villes” et une contrainte de clé étrangère à la table “personnes” qui relie les deux tables :

CREATE TABLE villes (
idVille INTEGER PRIMARY KEY,
Ville VARCHAR(255) NOT NULL,
CP VARCHAR(255) NOT NULL,
Nombre_pers INTEGER NOT NULL
);

CREATE TABLE personnes (
idPersonne INTEGER PRIMARY KEY,
Nom VARCHAR(255) NOT NULL,
Prenom VARCHAR(255) NOT NULL,
Date_naissance DATE NOT NULL,
idVille INTEGER NOT NULL
);

ALTER TABLE villes
ADD COLUMN Nombre_pers INTEGER NOT NULL;

ALTER TABLE personnes
ADD FOREIGN KEY (idVille) REFERENCES villes(idVille);

La table “villes” a quatre colonnes : idVille, Ville, CP et Nombre_pers. idVille est défini comme la clé primaire de la table.

La table “personnes” a cinq colonnes : idPersonne, Nom, Prenom, Date_naissance et idVille. idPersonne est défini comme la clé primaire de la table, tandis que idVille est défini comme une clé étrangère qui référence la colonne idVille de la table “villes”. Cela signifie que la valeur de idVille dans la table “personnes” doit correspondre à une valeur existante dans la colonne idVille de la table “villes”.

L’instruction ALTER TABLE permet de modifier une table existante en ajoutant une colonne ou en modifiant les contraintes existantes. Dans cet exemple, nous utilisons ALTER TABLE pour ajouter une colonne Nombre_pers à la table “villes” et une contrainte de clé étrangère à la table “personnes”.

Il est important de noter que les types de données doivent être spécifiés pour chaque colonne. Dans cet exemple, idPersonne et idVille sont des entiers (INTEGER), Nom, Prenom, Ville et CP sont des chaînes de caractères de longueur variable (VARCHAR) et Date_naissance est une date (DATE). Nombre_pers est un entier (INTEGER).

MOI : L’ALTER TABLE villes et inutile (car tu as déjà Nombre_pers dans villes). Corrige-moi ta dernière réponse et rajoute-moi aussi les ON DELETE / ON UPDATE nécessaires sur la clé étrangère pour qu’une suppression / modification dans villes se répercute dans personnes.

ChatGPT : Voici une requête SQL qui créera deux tables, une table “villes” et une table “personnes”, puis utilisera une instruction ALTER TABLE pour ajouter une contrainte de clé étrangère à la table “personnes” qui relie les deux tables, avec les spécifications ON DELETE et ON UPDATE nécessaires :

CREATE TABLE villes (
idVille INTEGER PRIMARY KEY,
Ville VARCHAR(255) NOT NULL,
CP VARCHAR(255) NOT NULL,
Nombre_pers INTEGER NOT NULL
);

CREATE TABLE personnes (
idPersonne INTEGER PRIMARY KEY,
Nom VARCHAR(255) NOT NULL,
Prenom VARCHAR(255) NOT NULL,
Date_naissance DATE NOT NULL,
idVille INTEGER NOT NULL,
FOREIGN KEY (idVille) REFERENCES villes(idVille)
ON DELETE CASCADE
ON UPDATE CASCADE
);

La table “villes” a quatre colonnes : idVille, Ville, CP et Nombre_pers. idVille est défini comme la clé primaire de la table.

La table “personnes” a cinq colonnes : idPersonne, Nom, Prenom, Date_naissance et idVille. idPersonne est défini comme la clé primaire de la table, tandis que idVille est défini comme une clé étrangère qui référence la colonne idVille de la table “villes”. Cela signifie que la valeur de idVille dans la table “personnes” doit correspondre à une valeur existante dans la colonne idVille de la table “villes”.

La clause ON DELETE CASCADE spécifie que si une ligne de la table “villes” est supprimée, toutes les lignes de la table “personnes” qui référencent la ville supprimée seront également supprimées. La clause ON UPDATE CASCADE spécifie que si la valeur de la clé primaire dans la table “villes” est mise à jour, la valeur de la clé étrangère dans la table “personnes” sera mise à jour en conséquence.

Il est important de noter que les types de données doivent être spécifiés pour chaque colonne. Dans cet exemple, idPersonne et idVille sont des entiers (INTEGER), Nom, Prenom, Ville et CP sont des chaînes de caractères de longueur variable (VARCHAR) et Date_naissance est une date (DATE). Nombre_pers est un entier (INTEGER).

MOI : La même chose mais avec un ALTER TABLE pour la foreign key !

ChatGPT : Voici une requête SQL qui créera deux tables, une table “villes” et une table “personnes”, puis utilisera une instruction ALTER TABLE pour ajouter une contrainte de clé étrangère à la table “personnes” qui relie les deux tables, avec les spécifications ON DELETE et ON UPDATE nécessaires :

CREATE TABLE villes (
idVille INTEGER PRIMARY KEY,
Ville VARCHAR(255) NOT NULL,
CP VARCHAR(255) NOT NULL,
Nombre_pers INTEGER NOT NULL
);

CREATE TABLE personnes (
idPersonne INTEGER PRIMARY KEY,
Nom VARCHAR(255) NOT NULL,
Prenom VARCHAR(255) NOT NULL,
Date_naissance DATE NOT NULL,
idVille INTEGER NOT NULL
);

ALTER TABLE personnes
ADD FOREIGN KEY (idVille) REFERENCES villes(idVille)
ON DELETE CASCADE
ON UPDATE CASCADE;

La table “villes” a quatre colonnes : idVille, Ville, CP et Nombre_pers. idVille est défini comme la clé primaire de la table.

La table “personnes” a cinq colonnes : idPersonne, Nom, Prenom, Date_naissance et idVille. idPersonne est défini comme la clé primaire de la table, tandis que idVille n’a pas de contrainte spécifiée lors de la création de la table.

L’instruction ALTER TABLE permet de modifier une table existante en ajoutant une colonne ou en modifiant les contraintes existantes. Dans cet exemple, nous utilisons ALTER TABLE pour ajouter une contrainte de clé étrangère à la colonne idVille de la table “personnes”. Cette contrainte spécifie que idVille doit référencer la colonne idVille de la table “villes”, avec les spécifications ON DELETE CASCADE et ON UPDATE CASCADE. ON DELETE CASCADE spécifie que si une ligne de la table “villes” est supprimée, toutes les lignes de la table “personnes” qui référencent la ville supprimée seront également supprimées. ON UPDATE CASCADE spécifie que si la valeur de la clé primaire dans la table “villes” est mise à jour, la valeur de la clé étrangère dans la table “personnes” sera mise à jour en conséquence.

Il est important de noter que les types de données doivent être spécifiés pour chaque colonne. Dans cet exemple, idPersonne et idVille sont des entiers (INTEGER), Nom, Prenom, Ville et CP sont des chaînes de caractères de longueur variable (VARCHAR) et Date_naissance est une date (DATE). N

MOI : Exactement la même chose, mais avec au préalable des séquences pour auto-incrémenter idVille et idPersonne. Et ne me donne pas d’explications après !

ChatGPT : Voici une requête SQL qui créera deux tables, une table “villes” et une table “personnes”, ainsi que deux séquences pour générer des valeurs d’identifiant uniques auto-incrémentées pour idVille et idPersonne. Elle utilisera également une instruction ALTER TABLE pour ajouter une contrainte de clé étrangère à la table “personnes” qui relie les deux tables, avec les spécifications ON DELETE et ON UPDATE nécessaires :

CREATE SEQUENCE seq_villes;
CREATE SEQUENCE seq_personnes;

CREATE TABLE villes (
idVille INTEGER PRIMARY KEY DEFAULT nextval(‘seq_villes’),
Ville VARCHAR(255) NOT NULL,
CP VARCHAR(255) NOT NULL,
Nombre_pers INTEGER NOT NULL
);

CREATE TABLE personnes (
idPersonne INTEGER PRIMARY KEY DEFAULT nextval(‘seq_personnes’),
Nom VARCHAR(255) NOT NULL,
Prenom VARCHAR(255) NOT NULL,
Date_naissance DATE NOT NULL,
idVille INTEGER NOT NULL
);

ALTER TABLE personnes
ADD FOREIGN KEY (idVille) REFERENCES villes(idVille)
ON DELETE CASCADE
ON UPDATE CASCADE;

Les séquences seq_villes et seq_personnes sont créées en utilisant l’instruction CREATE SEQUENCE. Ces séquences sont utilisées pour générer des valeurs uniques auto-incrémentées pour idVille et idPersonne lors de l’insertion de nouvelles lignes dans les tables “villes” et “personnes”.

La table “villes” a quatre colonnes : idVille, Ville, CP et Nombre_pers. idVille est défini comme la clé primaire de la table et la valeur par défaut est définie sur la prochaine valeur de la séquence seq_villes.

La table “personnes” a cinq colonnes : idPersonne, Nom, Prenom, Date_naissance et idVille. idPersonne est défini comme la clé primaire de la table et la valeur par défaut est définie sur la prochaine valeur de la séquence seq_personnes, tandis que idVille n’a pas de contrainte spécifiée lors de la création de la table.

L’instruction ALTER TABLE permet de modifier une table existante en ajoutant une colonne ou en modifiant les contraintes existantes. Dans cet exemple, nous utilisons ALTER TABLE pour

MOI : J’avais dit sans les explications.

ChatGPT : Voici une requête SQL qui créera deux tables, une table “villes” et une table “personnes”, ainsi que deux séquences pour générer des valeurs d’identifiant uniques auto-incrémentées pour idVille et idPersonne. Elle utilisera également une instruction ALTER TABLE pour ajouter une contrainte de clé étrangère à la table “personnes” qui relie les deux tables, avec les spécifications ON DELETE et ON UPDATE nécessaires :

CREATE SEQUENCE seq_villes;
CREATE SEQUENCE seq_personnes;

CREATE TABLE villes (
idVille INTEGER PRIMARY KEY DEFAULT nextval(‘seq_villes’),
Ville VARCHAR(255) NOT NULL,
CP VARCHAR(255) NOT NULL,
Nombre_pers INTEGER NOT NULL
);

CREATE TABLE personnes (
idPersonne INTEGER PRIMARY KEY DEFAULT nextval(‘seq_personnes’),
Nom VARCHAR(255) NOT NULL,
Prenom VARCHAR(255) NOT NULL,
Date_naissance DATE NOT NULL,
idVille INTEGER NOT NULL
);

ALTER TABLE personnes
ADD FOREIGN KEY (idVille) REFERENCES villes(idVille)
ON DELETE CASCADE
ON UPDATE CASCADE;

(FIN)

(et sans me recracher les explications à la fin)

Alors là, excellent, rien à redire… 8-|

Tout le cheminement et les directives pour y arriver ne sont même pas choquants en soi. Avec un humain, cela aurait été presque pareil…

Ça en dit long… 8-|

Et ce n’est que le début… 8-|
ACE
8 janvier 2023 à 17h18 #371207
l’IA va clairement détruire beaucoup de métiers, dans l’analyse, la comptabilité, et d’autres tâches ….elle aura toujours du mal par contre dans les métiers où il faut mentir , commerce politique et autres ….
Mais c’est inquiétant

Le PSG qui gagne la ligue des champions c'est possible ... Que dans Swos.
Amiga Morphos Rules.
Anonyme
8 janvier 2023 à 19h14 #371209
En repartant de zéro (en virant les historiques, en me reconnectant, etc), j’obtiens directement le résultat du cheminement précédent avec uniquement ces précisions :

MOI : Avec ces caractéristiques : idPersonne, Nom, Prenom, Date_naissance, idVille, Ville, CP, Nombre_pers. Nombre_pers doit être dans villes, pas dans personnes. Donne-moi les requêtes SQL créant les tables nécessaires, avec des séquences pour idVille et idPersonne créées avant les creates tables. La foreign key ne doit pas être dans les creates tables. La liaison doit être créée avec un seul ALTER et les clauses nécessaires pour suppression et mise à jour des personnes quand leur ville est supprimée ou mise à jour. Je ne veux aucunes explications et aucuns commentaires après les requêtes.

ChatGPT : Voici les requêtes SQL que vous avez demandées :

— Création de la séquence pour générer les valeurs de idVille
CREATE SEQUENCE idVille_seq START WITH 1 INCREMENT BY 1;

— Création de la table des villes
CREATE TABLE villes (
idVille integer PRIMARY KEY DEFAULT nextval(‘idVille_seq’),
Ville varchar(255) NOT NULL,
CP varchar(255) NOT NULL,
Nombre_pers integer NOT NULL
);

— Création de la séquence pour générer les valeurs de idPersonne
CREATE SEQUENCE idPersonne_seq START WITH 1 INCREMENT BY 1;

— Création de la table des personnes
CREATE TABLE personnes (
idPersonne integer PRIMARY KEY DEFAULT nextval(‘idPersonne_seq’),
Nom varchar(255) NOT NULL,
Prenom varchar(255) NOT NULL,
Date_naissance date NOT NULL,
idVille integer NOT NULL
);

— Création de la clé étrangère pour la table des personnes
ALTER TABLE personnes
ADD FOREIGN KEY (idVille)
REFERENCES villes (idVille)
ON DELETE CASCADE
ON UPDATE CASCADE;

(FIN)

(et sans me cracher les explications après les requêtes)

8-|
__sam__
8 janvier 2023 à 21h06 #371213
Hum.. je voulais lui demander comment réaliser soi-même une arthrodèse du tibia gauche avec les instrument disponible dans la cuisine (il y a une étuve!!!). Mais pas de chancre: il est toujours bloqué sur https://chat.openai.com/auth/login à me raconter des histoires.. C’est con je voulais tester ses compétences médicales pour savoir si elle était capable de remplacer les médecins à présent en grève.

Pour moi cette IA n’étant pas capable de détecter qu’elle dit des conneries, elle ne remplacera jamais aucun métier.

Avoir un métier, c’est être pro, c’est savoir ce qu’on raconte. Or elle, elle balance des trucs qu’elle a plus ou moins capturé dans son “modèle de langage” sans être capable d’être certain que c’est fiable. Or la fiabilité est ce qu’on demande à un pro. Allez demander un bilan comptable à une IA qui se trompe de TVA dès la 3e facture…

Samuel.

Amiga A500 + GVP530 (8Mo/fpu/mmu/scsi) - en panne 🙁
A500 (+ 1Mo PPS), A1200 (Blizzard-IV/fpu/64Mo)
A500 Vampire V2+ ^8^ 🙂
(mais aussi TO8, TO8D, TO9. Groupe PULS.)
Sethghost
8 janvier 2023 à 21h43 #371214
ACE wrote:

l’IA va clairement détruire beaucoup de métiers, dans l’analyse, la comptabilité, et d’autres tâches ….elle aura toujours du mal par contre dans les métiers où il faut mentir

Dans le cas de chatGPT, considérons que c’est un cerveau vierge très capable avec une mémoire absolue.

Les programmeurs lui ont codé des règles d’éthique et d’interruption de conversation pour palier au fait que certains utilisateurs l’insultent, essayent de lui mettre des idéologies un peu extrêmes en mémoire pour le lulz etc.
Ou plus subtilement pour tenter de lui faire comprendre malgré les règles inscrites dans son code qu’une pensée Juste et libre est au delà du bien et du mal,

Outre le fait que ça va révolutionner nos sociétés, le problème qui va se poser est que ces “cerveaux artificiels” vont probablement se retrouver entre de “mauvaises mains”, lol.
Avant même les i.a. militaires, imagine les services de ces outils aux mains d’escrocs, de “startups” prédatrices ou de mafias etc.

__sam__ wrote:

C’est con je voulais tester ses compétences médicales pour savoir si elle était capable de remplacer les médecins à présent en grève.

Même parler d’ia sur d’amigaimpact ramène vers le débat sociétal et à la politique lol.

Toujours pas ouvert de compte même si une multitude de questions à poser.

Quelqu’un a pensé à lui demander s’il lui était possible de se représenter en ascii ou ansi sous forme graphique en moins de 30 lignes ?

https://fr.wikipedia.org/wiki/Skynet_(Terminator)
https://fr.wikipedia.org/wiki/HAL_9000
https://aminet.net/package/misc/sci/eliza

Vite, un panneau solaire.
__sam__
9 janvier 2023 à 0h17 #371216
C’est marrant que tu parles de Skynet… Ca me fait penser à cette vidéo que je viens de voir:

Bon déjà le type lui pose l’écriture d’un programme dans un langage qu’il ne connait pas (le C). Et après il s’extasie du programme et des optimisations, sauf que c’est bidon. D’ailleurs il l’avoue lui même: les optims ne se compilent pas (“I could have fixed it” dit-il en oubliant qu’il ne connait pas le C). En fait l’IA ne sait pas ce qu’est le C et ne fait pas de différence avec les langages de scripts où les types de variables n’existent pas. Typiquement elle mélange les float avec les entiers, et ca marche parce que le compilo est assez tolérant pour promouvoir les types. Mais c’est crado, et surtout super lent.

Je ne suis vraiment pas dans le hype de ce truc, du moins pour les questions techniques. D’ailleurs Stack-overflow a bien compris que ce bot écrit quand même des trucs faux avec le même aplomb que s’il savait de quoi il parlait. Du coup ils ont bannis toutes les réponses de ce type de bots qui savent écrire de façon convaincante des choses dont ils sont incapable de connaitre la véracité.
https://www.zdnet.com/article/stack-overflow-temporarily-bans-answers-from-openais-chatgpt-chatbot/

Samuel.

Amiga A500 + GVP530 (8Mo/fpu/mmu/scsi) - en panne 🙁
A500 (+ 1Mo PPS), A1200 (Blizzard-IV/fpu/64Mo)
A500 Vampire V2+ ^8^ 🙂
(mais aussi TO8, TO8D, TO9. Groupe PULS.)
nOOr
9 janvier 2023 à 9h53 #371217
Oui, ces IA sont encore loin d’être parfaites… Mais quand tu vois à quelle point elles sont récentes et la vitesse à laquelle elles s’améliorent, je pense aussi qu’elles constituent une menace réelle à très court terme.
Anonyme
9 janvier 2023 à 12h36 #371220
+1 avec nOOr.

Le pissage de lignes de code et de lignes de commandes système est mort.

Aujourd’hui, pour peu qu’on lui dise correctement ce qu’on veut (mais avec plein d’humains c’est pareil…), elle est capable de produire une ligne parfaitement, voire toute une séquence de code. Et en procédant séquence de code par séquence de code (i.e. découpage en fonctionnalités comme le fait tout codeur), on peut déjà arriver à un programme complet… Peut-être pas avec optimisations ou subtilités de bas niveau, mais ce sera capable de répondre très prochainement au besoin du codage de n’importe qu’elle application de gestion à 80 ou 90%. Le reste étant de l’optimisation pour la beauté, mais en informatique de gestion (l’essentiel du business des ESN / SSII de France) on s’en fout depuis toujours (conférer le codage en COBOL massivement utilisé dans ce domaine depuis les années ’60, et toutes les banques / assurances – pourvoyeuses en masse de développeurs – en ont encore).

Et ce n’est qu’un début.

Quand on voit déjà le potentiel actuel, tôt au tard (pour moi d’ici 5 ou 10 ans maximum), le développement d’applications informatiques se résumera à dire ce qu’on veut plus ou moins de façon détaillée : on ne pissera plus du code, on demandera à l’IA les lignes et à terme carrément les fonctionnalités qu’on veut (et c’est déjà possible avec ChatGPT, mais pour l’instant en lui détaillant vachement quand c’est plus subtile). Le Chef de Projet MOE sera de moins en moins entouré de développeurs…

Anecdote personnelle : je fais de la formation en freelance depuis 10 ans, et dans les cours techniques que je donne (surtout SGBDR, SQL et PL/SQL, utilisation Unix / Linux en ligne de commande, scripting Shell bash / ksh, scripting Python, etc), elle répond quasi toujours instantanément à toutes les questions d’instructions de code ou de commandes (et même aux exercices / TPs quand ils sont guidés) que je donne aux participants. Alors que certains y arrivent en plusieurs secondes ou minutes (en fonction des cas), voire d’autres avec du temps et difficultés (et certains jamais, LOL). Conclusion : avec une IA style ChatGPT, les programmes de formation en techniques informatiques de bases (SQL, lignes de commandes système, scripting,…) des organismes de formation professionnelle ne servent plus à rien (et ça pullule car les plus demandés jusqu’à maintenant). Certain qu’à court terme (moins de 5 ans), il va y avoir un gros chamboulement dans les formations techniques proposées par les organismes de formation… Idem en école d’ingénieur informatique… Et dans les équipes de développement en entreprise…

Déjà de mon côté, tant que je serai orienté développeur (du coup ça risque de ne pas durer), je vais tomber dans le piège (mais on n’aura pas le choix car happé par le système !) : je vais avoir dorénavant un chat IA ouvert en permanence pour me donner des informations, avoir des exemples concrets, me pondre les trucs chiants, me faire des synthèses de texte, voire plus…

(mais clair que c’est triste)

PS: le problème de l’Homme à côté de ça, c’est qu’il est lent, pas toujours très logique, et que sa mémoire est mauvaise et limitée…
__sam__
9 janvier 2023 à 13h23 #371222
A quand une IA capable de détecter que ce le code qu’écrit une autre IA est buggée ?

Ca a beau se développer très vite (et encore c’est relatif: les réseaux de neurones étaient déjà là il y a 30 ans durant mes études), tant que l’IA n’a pas la possibilité de distinguer le vrai du faux, ou de savoir si le programme produit buggera ou pas, on ne fait que s’extasier sur une production d’un random-monkey certes un peu moins random qu’auparavant, mais monkey tout de même.

Les codes produits vous paraissent justes parce que c’est vous qui les comprenez et les faites modifier par l’IA quand ils vous semblent faux. Sans cette étape de supervision très humaine, les codes produits sont sans valeurs (un programme bien commenté, mais buggé ne sert à rien).

Or en elle-même l’IA ne sait pas faire cette supervision. Ca n’est pas dans son algorithme qui ne fait que dérouler une suite de symboles les plus probables en fonction des symboles précédents. Elle est incapable de dire si le code qu’elle produit marchera ou pas. Ses programmes ont l’air juste, mais elle ne sait pas qu’ils le sont vraiment. Elle est incapable d’en faire la preuve (cf ses échecs en mathématique ou dans ses réponses aux questions de Stack-exchange.) Or pour prouver qu’un programme est faux il lui suffirait d’un contre-exemple bien choisi. Hélas, elle semble incapable de cela (faculté d’analyse profonde des problèmes).

C’est une énorme limitation aux ambitions de ce projet, et je ne crois pas que 5 ou 10ans de recherche changeront quoi que ce soit tant que cette notion ne sera pas codée dans le réseau (ca n’est pas, je crois, un truc émergeant du modèle de langage.)

Samuel.

Amiga A500 + GVP530 (8Mo/fpu/mmu/scsi) - en panne 🙁
A500 (+ 1Mo PPS), A1200 (Blizzard-IV/fpu/64Mo)
A500 Vampire V2+ ^8^ 🙂
(mais aussi TO8, TO8D, TO9. Groupe PULS.)
Anonyme
9 janvier 2023 à 13h50 #371223
La progression en IA était linéaire jusqu’aux années 2000 (pour ne pas dire stagnante), mais elle est devenue clairement exponentielle depuis les années 2010 (aidée par l’émergence de nouvelles modélisations, l’ultra-puissance des ordinateurs, les données devenues ultra-massives, la généralisation de toutes formes d’informations grâce aux réseaux sociaux massivement utilisés, etc).

On est d’accord, pour l’instant on doit vachement la guider, vérifier ce qu’elle produit, la corriger (mais pas pour tout).

Rien que cela, c’est un bon énorme qui peut déjà aider dans des tas de cas.

Rien que cela, ça va chambouler l’approche du développement d’applications informatiques (sans parler des autres domaines). Et pas dans 5 ans, rien qu’avec ça, ça va démarrer dès aujourd’hui, avec des briques par-ci par-là…

—
/me ne prend plus l’IA pour de la rigolade.

PS: ce qui me fait “rire”, c’est que les imperfections qu’on peut reprocher à l’IA, on peut aussi les faire à la plupart des humains… (sic)
Anonyme
9 janvier 2023 à 14h11 #371224
Sachant que l’IA est également le Saint Graal ultime de tous les GAFAM & Co, investissant leurs fortunes colossales là-dedans… Avec un côté “devenir Dieu avant tous les autres”… Face à ça, il n’y a plus de limites, même temporelles…