ChatGPT, a programowanie. Czy to dobry pomysł?

Cześć kochani, dzisiaj wtrącę moje dwa grosze jakże to hucznym temacie AI ChatGPT, który uznaje się za dosyć rewolucyjnym narzędziem. Jaka jest zatem prawda?

Pozorna prostota

Wystarczy, wpisać tylko kilka słów, a AI zacznie nam generować kod, który na pierwszy rzut oka robi to dobrze. Jeśli założymy, że cały projekt zaczniemy od początku do końca na ChatGPT, to w większości przypadków powinno się obejść bez błędów.

Przykładowe polecenie:

Napisz mi Encję Cat w języku TS. Powinna mieć kilka własności i metod:

class Cat {
    name: string;
    age: number;
    color: string;
    private _weight: number;

    constructor(name: string, age: number, color: string, weight: number) {
        this.name = name;
        this.age = age;
        this.color = color;
        this._weight = weight;
    }

    get weight(): number {
        return this._weight;
    }

    set weight(value: number) {
        this._weight = value;
    }

    meow(): void {
        console.log("Meow!");
    }

    eat(food: string): void {
        console.log(`${this.name} is eating ${food}.`);
    }

    sleep(): void {
        console.log(`${this.name} is sleeping.`);
    }
}

i generalnie nie ma tutaj większej zawiłości, bo kod jest zrozumiały, ale z drugiej strony to ten sam kod można napisać prościej. Osoby, które się znają, od razu zobaczą, że własności można zadeklarować i przypisać za pomocą samego konstruktora, dzięki czemu odpada nam pisanie tego samego aż 3 razy.

Poprawianie AI ChatGPT

Na szczęście dosyć często kod z ChatGPT można łatwo poprawić kolejną prostą komendą.

Zadeklaruj własności za pomocą konstruktora: 

class Cat {
    constructor(
        public name: string,
        public age: number,
        public color: string,
        private _weight: number
    ) {}

    get weight(): number {
        return this._weight;
    }

    set weight(value: number) {
        this._weight = value;
    }

    meow(): void {
        console.log("Meow!");
    }

    eat(food: string): void {
        console.log(`${this.name} is eating ${food}.`);
    }

    sleep(): void {
        console.log(`${this.name} is sleeping.`);
    }
}

W ten oto sposób dostajemy uproszczony kod. Zauważmy jednak, że wszystkie publiczne metody tak na prawdę nic nie robią poza wyświetleniem informacji. Zmieńmy to podając AI kolejne komendy. Zobaczmy najpierw czy się domyśli o co mi chodzi, jeśli nie zda egzaminu to podamy więcej konretów.

Rozszerzanie kodu

app design image

Chciałbym, aby metody zamiast console.log robiły coś więcej. Zrób te metody bardziej funkcjonalne:

class Cat {
    constructor(
        public name: string,
        public age: number,
        public color: string,
        private _weight: number
    ) {}

    get weight(): number {
        return this._weight;
    }

    set weight(value: number) {
        this._weight = value;
    }

    meow(): string {
        return `${this.name} says "Meow!"`;
    }

    eat(food: string): string {
        return `${this.name} is eating ${food}.`;
    }

    sleep(): string {
        return `${this.name} is sleeping.`;
    }
}

const fluffy = new Cat("Fluffy", 2, "white", 5);
console.log(fluffy.meow());
console.log(fluffy.eat("tuna"));
console.log(fluffy.sleep());

Zostawiam to waszej ocenie. Jak dla mnie AI dostało za mało konkretów i moim zdaniem metody nadal są za mało funkcjonalne. Jednak trzeba to przyznać, że jest zdeterminowane, bo faktycznie wywaliło console.log z metod za co jakiś punkt można mu przyznać pomimo tego, że miał to w poleceniu.

Dajmy mu coś teraz bardziej zrozumiałego

Metoda meow powinna włączać dźwięk maiuczenia kota. Metoda eat powinna zwiększać sytość oraz wagę jeśli kot jest przekarmiany – należy wprowadzić jakiś system metabolizmu. Metoda sleep powinna regenerować energię kota:

class Cat {
    private _hunger: number;
    private _energy: number;
    private _metabolism: number;

    constructor(
        public name: string,
        public age: number,
        public color: string,
        private _weight: number
    ) {
        this._hunger = 0;
        this._energy = 100;
        this._metabolism = 10;
    }

    get weight(): number {
        return this._weight;
    }

    set weight(value: number) {
        this._weight = value;
    }

    meow(): void {
        new Audio("cat-meow.mp3").play();
    }

    eat(food: string): void {
        this._hunger -= 10;
        if(this._hunger < 0) {
            this._hunger = 0;
        }
        this._weight += this._metabolism;
        console.log(`${this.name} is eating ${food}. Hunger level: ${this._hunger}%. Weight: ${this._weight}kg`);
    }

    sleep(): void {
        this._energy += 10;
        if(this._energy > 100) {
            this._energy = 100;
        }
        console.log(`${this.name} is sleeping. Energy level: ${this._energy}%`);
    }
}

const fluffy = new Cat("Fluffy", 2, "white", 5);
fluffy.meow();
fluffy.eat("tuna");
fluffy.sleep();

This is an example of how you can make the methods more functional as you described. The meow() method now plays an audio file of a cat meowing. The eat() method now decreases the cat’s hunger level and increases its weight based on the cat’s metabolism rate. The sleep() method increases the cat’s energy level. You can also see that there are some private properties like _hunger, _energy, _metabolism and _weight which are updated in the methods and if needed have a limit.

Please note that the audio file and the path to it must exist and be accessible in the code in order for this code to work as expected.

Jak dla mnie średnio, bo wracamy do tego, że znowu trzeba poprawić AI z tym kontruktorem, ale poza tym to myślę że dał radę pomimo tego, że wrócił z tymi console.log-ami.

Poważne zadanie

Jako iż bardzo ważne jest skonfigurowanie środowiska potrzebnego do pracy, poproszę AI o to, aby wygenerowało mi konfigurację Dockera potrzebną do uruchomienia ww. kodu.

Wygeneruj konfigurację Docker dla nodejs tak, aby można było bez problemu uruchomić ww. kod:

Here is an example of a Dockerfile that can be used to run a Node.js application, including the code you provided:

FROM node:14-alpine

WORKDIR /usr/src/app

COPY package*.json ./
RUN npm install
COPY . .

CMD [ "node", "index.js" ]

This Dockerfile uses the official Node.js Alpine image as the base image and sets the working directory to /usr/src/app. It then copies the package.json and package-lock.json files and runs npm install to install the dependencies. After that it copies all the files to the container and CMD instruction runs node index.js command, to start the application.

You will also need to have a file named index.js in the same directory as your Dockerfile that contains the code you want to run.

After that you can build your image using:

docker build -t my-node-app .

And then start the container using:

docker run -p 3000:3000 my-node-app

This will start a container with your Node.js application running on port 3000 and the container will be accesible on localhost:3000.

Please note that this is just an example and you might need to adjust the Dockerfile or the command depending on your specific needs and requirements.

Widzę tutaj małe niedociągnięcie w Dockerfile, bo po co kopiować package*.json, a potem drugą komendą tak na prawdę wszystko, skoro można skopiować od razu wszystko i potem wykonać npm install? Z drugiej strony jak na nasz wygenerowany programik nie powinno się nic złego stać.

Drugą wadą jest to, że nasz kod ani trochę nie jest serwerowy, a tu nam karze go tak uruchamiać. Zatem nie domyślił się, że chodzi o CLI pomimo tego, że tak powinno wyjść z kontekstu. Zatem poproszę go o wygenerowanie drugiej konfiguracji.

Wygeneruj konfigurację Docker dla CLI nodejs

Here is an example of a Dockerfile that can be used to run a Node.js command-line application:

FROM node:14-alpine

WORKDIR /usr/src/app

COPY package*.json ./
RUN npm install
COPY . .

ENTRYPOINT [ "npm", "start" ]

This Dockerfile uses the official Node.js Alpine image as the base image and sets the working directory to /usr/src/app. It then copies the package.json and package-lock.json files and runs npm install to install the dependencies. After that it copies all the files to the container and ENTRYPOINT instruction runs npm start command, to start the command line application.

You will also need to have a file named package.json in the same directory as your Dockerfile that contains the command you want to run, for example:

"scripts": {
    "start": "node index.js --arg1 --arg2"
  },

After that you can build your image using:

docker build -t my-node-cli-app .

And then start the container using:

docker run -it my-node-cli-app --arg1 --arg2

This will start a container with your Node.js command-line application running, and the arguments passed in the command line after run command will be passed to the npm start command

Please note that this is just an example and you might need to adjust the Dockerfile or the command depending on your specific needs and requirements.

Teraz jest znacznie lepiej, bo mamy możliwość odpalania aplikacji za pomocą prostej dockerowej komendy. Oczywiście dla tego przykładu przesadą jest stosowanie argumentów, ponieważ żaden nie jest nam potrzebny.

Fajnie jednak by było, gdyśmy jednak nie musieli ciągle wpisywać tego długiego ciągu znaków za każdym razem, aby uruchamiać aplikację, na to już rozwiązanie mamy: poprosimy AI 😁

Utwórz plik wsadowy zawierający docker run -it my-node-cli-app –arg1 –arg2, aby uprosić uruchamianie:

You can create a shell script file with the docker run command to simplify running your Node.js command-line application in a container. Here is an example of a shell script file named run-app.sh:

#!/bin/bash
docker run -it my-node-cli-app --arg1 --arg2

This script file can be placed in the same directory as your Dockerfile and can be executed by running ./run-app.sh in the terminal.

You can also make the script file executable by running

chmod +x run-app.sh

and then you can run it directly with

./run-app.sh

You can also pass parameters to the script file and then use them as arguments for the docker run command. For example, you can modify the script file to accept parameters and use them as arguments for the command

#!/bin/bash
docker run -it my-node-cli-app $1 $2

and then you can run the script passing parameters

./run-app.sh --arg1 --arg2

ChatGPT dał nam ciekawy wybór, bo możemy zrobić plik sh z możliwością luźnego lub sztywnego parametryzowania. Jednak to co mnie zadziwiło to to że to wcześniej pisał o CMD, który jest Windowsowy, a plik wsadowy zrobił na Linux 😂

Podsumowanie

OpenAI stworzyło na prawdę bardzo pomocne narzędzie, które przydaje się w wielu dziedzinach. W tym artykule skupiliśmy się na programowaniu i krok po kroku pokazałem jak wygląda wytwarzanie bardzo prostego kodu za pomocą ChatGPT.

W mojej opinii osobom bez większej wiedzy specjalistycznej czasami będzie trudno odróżnić co za zabobony ten AI pisze, a dobre ku temu dowody dostarczyłem w tym artykule.

Uważam, że AI najlepiej precyzyjnie określać to co od niego oczekujemy i z jakich standardów ma korzystać. Gdy już swoje wiemy, to narzędzie może nam bardzo pomóc w wytwarzaniu oprogramowania, bo będziemy wiedzieć co jest do podmianki, co trzeba dopowiedzieć itd.

Dziękuję bardzo za uwagę, i kochani, widzimy się w kolejnym artykule 😃

Subscribe
Powiadom o
guest
1 Komentarz
najstarszy
najnowszy oceniany
Inline Feedbacks
View all comments
Angry
Angry
1 rok temu

Fajny wpis 😀

1
Odpowiedz

Podobne wpisy

Włączyć powiadomienia? Bardzo pragnę Dam sobie radę