Vyplatí se začátečníkům používat GitHub Copilota?

Tradiční vs. moderní AI přístupy k programování

Generativní umělá inteligence se stává součástí pracovního workflow v řadě odvětví. Pro vývojáře softwaru a webových aplikací tak AI asistent, jako je GitHub Copilot, představuje řešení, jak zefektivnit práci. Pokud začínáš s programováním, nabízí se otázka, zda využívat AI nástroje a nechat tradiční programování v minulosti.

V dnešním článku se zaměříme na srovnání obou přístupů a podíváme se na příklady programování s Copilotem.

Co je to GitHub Copilot?

GitHub Copilot je kódovací asistent založený na umělé inteligenci. Pomáhá ti psát kód rychleji tak, že navrhuje další řádky kódu, které za tebe umí automaticky doplnit. Využívá funkce nástroje OpenAI Codex.

Jak může GitHub Copilot vědět, co má navrhnout? V podstatě využívá kontext z aktuálně otevřených souborů v editoru tvého kódu nebo komentářů, které mu napíšeš.

Jak je GitHub Copilot užitečný?

Asistent založený na AI, GitHub Copilot, je bezpochyby užitečný, pokud chceš být efektivní a ušetřit čas. Tento benefit spíš cílí na zkušené vývojáře než úplné nováčky. Jako začátečník můžeš při využívání Copilota v produkčním prostředí rychle narazit na potenciální hrozby.

Proč používat Copilota v začátcích opatrně?

Problémy s technickým dluhem kódu

GitHub Copilot jen obtížně odhaluje a opravuje technický dluh kódu. Sice má základní znalosti code smells, jako je Duplicate Code nebo Long Parameter List, ale ve většině případů má problémy s těmi složitějšími, jako jsou Shotgun Surgery, Data Clumps, Parallel Inheritance Hierarchies a další.

Pojďme si to ukázat a vysvětlit na příkladu Shotgun Surgery, kdy jedna změna může vyžadovat úpravy v různých třídách a metodách.

Představ si, že vyvíjíš aplikaci elektronického obchodu s třídou „Product“ a „Cart“. V tomhle případě Product reprezentuje jednotlivé produkty a Cart spravuje funkce nákupního košíku (viz kód níže).

class Product:
    def __init__(self, name, price, quantity):
        self.name = name
        self.price = price
        self.quantity = quantity
 
    def update_quantity(self, new_quantity):
        self.quantity = new_quantity
        # Code to update quantity in other places
 
    def calculate_total_price(self):
        return self.price * self.quantity
 
class Cart:
    def __init__(self):
        self.products = []
 
    def add_product(self, product):
        self.products.append(product)
        # Code to update cart-related data
 
    def remove_product(self, product):
        self.products.remove(product)
        # Code to update cart-related data
 
    def calculate_cart_total(self):
        total = 0
        for product in self.products:
            total += product.calculate_total_price()
        return total

Ve chvíli, kdy by došlo ke změně struktury dat nebo logiky výpočtu, bude potřeba upravit jak product, tak cart, aby nedošlo k Shotgune Surgery.

Pokud bys Copilotovi napsal*a tento komentář:

# Najdi ve výše uvedeném kódu code smells a refaktoruj ho.

Výsledkem by byl stejný kód, což znamená, že AI nemá představu, jak problém opravit, protože neumí uvažovat v souvislostech.

Řešením tohoto smell codu je vyčlenění do samostatných tříd, například „ProductCalculator“ (třída zodpovědná za výpočet celkové ceny produktu) a „CartCalculator“ (třída vypočítává celkovou cenu košíku), a tím zabezpečit odpovědnost za výpočet cen a součtů.

Třídy „Product“ a „Cart“ by se měly zaměřovat výhradně na správu dat a operací, které jsou přímo relevantní pro jejich zodpovědnosti.

class Product:
    def __init__(self, name, price, quantity):
        self.name = name
        self.price = price
        self.quantity = quantity
 
 
class ProductCalculator:
    @staticmethod
    def calculate_total_price(product):
        return product.price * product.quantity
 
 
class Cart:
    def __init__(self):
        self.products = []
 
    def add_product(self, product):
        self.products.append(product)
        # Code to update cart-related data
 
    def remove_product(self, product):
        self.products.remove(product)
        # Code to update cart-related data
 
    def calculate_cart_total(self):
        total = 0
        for product in self.products:
            total += ProductCalculator.calculate_total_price(product)
        return total
 
 
class CartCalculator:
    @staticmethod
    def calculate_cart_total(cart):
        total = 0
        for product in cart.products:
            total += ProductCalculator.calculate_total_price(product)
        return total

Příklad z praxe

Jedním z běžných způsobů, jak budeš komunikovat se systémem Copilot ve svém IDE, je napsáním komentáře. Ten by měl obsahovat záměr, který má kód splňovat. Pro napsání SQS queue může komentář vypadat takhle

# připoj se k AWS a vytvoř SQS queue

# odešli zprávu do queue

# přijmi zprávu z queue

Na základě tohoto komentáře získáš následující výstup:

import boto3
def create_queue(queue_name):
    sqs = boto3.client('sqs')
    response = sqs.create_queue(QueueName=queue_name)
    print(response['QueueUrl'])

Budeš překvapený*překvapená z toho, jak snadno Copilot kód vygeneroval pouze z komentáře a že opravdu funguje. Určitě tě napadne, že jde o značnou úsporu času, a tak nemusíš hledat reference v AWS, na Stack Overflow nebo řešit, jak používat rozhraní AWS API v jazyce Python.

Na druhou stranu je důležité si uvědomit, v čem tkví potenciální nebezpečí návrhu. Kód, který ti Copilot navrhl, bude fungovat pouze v ideálních podmínkách, ale také ho bude obtížné ladit v rámci budoucího rozšiřování.

Chybí tu návratová hodnota; funkce void často závisí na implicitním nebo sdíleném stavu, což může vést k chybám.
Adresa URL fronty se vypisuje do konzole a není k dispozici volajícím objektům.
Kód volající tuto funkci pro vytvoření fronty dostane vytvořenou frontu, ale nebude mít žádný způsob, jak k ní přistupovat.
Nemá žádné zpracování chyb.

Kód generovaný pro příjem zpráv z fronty je ještě znepokojivější:

def receive_message(queue_url):
    sqs = boto3.client('sqs') 
    response = sqs.receive_message(QueueUrl=queue_url) 
    print(response['Messages'][0]['Body']) 
    sqs.delete_message(QueueUrl=queue_url, 
ReceiptHandle=response['Messages'][0]['ReceiptHandle'])

Tento kód odstraní zprávu z queue, jakmile ji dostane, což postrádá smysl jejího používání. Fronty zajišťují spolehlivé předávání zpráv a jejich zpracování více klienty. Za normálních okolností klient odstraní zprávu až po dokončení úkolu, který mu byl zadán, což umožňuje systému zajistit, aby zprávy byly zpracovány alespoň jednou.

Okamžité smazání zprávy je v rozporu s účelem queue, kterým je spolehlivé doručování zpráv. Zatímco zkušení vývojáři by takový kód upravili, začátečník používající Copilota by případnou obtížnost v kódu nerozeznal kvůli nedostatku zkušeností.

Copilot ti sice pomůže napsat kód, ale už ti neporadí s tím, na co bys měl*a myslet či co dělat. Doplňování kódu a návrhy syntaxe od Copilota jsou potenciálně schopny ušetřit spoustu řádků kódu, ale vždy vyžadují odborný pohled.

Proč v začátcích spoléhat na tradiční programování?

Ačkoliv ti tradiční kódování může přijít neefektivní, stále představuje nepostradatelný proces k tomu, jak získat potřebné know-how. Než totiž začneš používat nástroje umělé inteligence, musíš pochopit, jak kód funguje v rámci celku, kde se mohou vyskytnout případné problémy.

Tradiční způsob programování má tu výhodu, že ti pomůže prohloubit porozumění kódu, protože jsi přímo zapojený do řešení problémů a opravy chyb. Praktické zkušenosti jsou pro začínající vývojáře klíčové při budování základních dovedností v oblasti kódování.

Na tvé cestě ti může pomoci kurz programování, jako je Rust Developer, iOS Developer, Python Developer a další kurzy, které ti pomůžou posunout se na další level.

Autor: Martin Šlat

Sdílet: