Печалби:
- Възможност за писане на функции, класове и модули за AI с ясни входно-изходни дефиниции и ограничения
- Възможност за използване на AI като партньор за програмиране на двойки и напредък стъпка по стъпка, на малки, проверими парчета
- Възможност за улавяне на логически и крайни грешки чрез компилиране на кода, генериран от AI и стартирането му с малки примери
Програмирането по двойки е, когато двама разработчици работят по един и същ проблем, като единият пише, а другият преработва. Кодирането с AI е цифровата версия на самата тази връзка: вие задавате посоката, ограниченията и критериите за приемане; AI произвежда бърза чернова; Вие проверявате всяка стъпка, като я компилирате и тествате. Най-големият капан тук е да кажете на AI "напишете ми това приложение от началото до края" и сляпо да приемете блок от 200 реда. Доброто програмиране на двойки протича на малки стъпки: всяка стъпка трябва да бъде разбираема, тествана и обратима.
В този модул ще научите как да отпечатвате функции, класове и модули с ясен входно-изходен договор; Как да ръководите AI стъпка по стъпка; и ще видим как да улавяме логически и крайни грешки, като стартираме кода, който произвежда с малки примери. Целта не е скорост, а проверена скорост.
Концепции: Договор за вход-изход: Ясна дефиниция на това какви входни данни приема дадена функция и какъв изход и поведение при грешки обещава. Edge case: Вход, който не е обикновен, но може действително да се появи (празен, нула, отрицателен, много голям, нулев). Постепенно развитие: Продължаване с малки работни части и валидиране на всяка стъпка.
Отпечатване на код с нетен договор
Основата на кода за качество е да определите точно "какво искате" преди да започнете работа. Когато пишете функция на AI, дайте й пет неща: език и версия, типове и значения на входа, изход, условия за грешка и ограничения (производителност, забрана на външна библиотека, стил). Това не позволява на AI да гадае.
- Напишете договора. Вход, изход, грешка, ограничение.
- Поискайте малка единица. Функция с една отговорност; Не е огромен модул.
- Поискайте тестов блок. Добавете няколко примерни изпълнения/тестове до кода.
- Компилирайте и стартирайте. Опитайте с крайни случаи, проверете изхода на око.
- Преминете към следващата стъпка. След като дадено парче бъде потвърдено, надграждайте върху него.
Подкана за договорена функция: "Напишете функция за TypeScript 5. Цел: изчисляване на общото количество артикули в количка за пазаруване. Вход: { цена: число, количество: число [] масив. Изход: число (общо). Правила: хвърляне на грешка, ако количеството или цената са отрицателни; връщане на 0 за празен масив; закръглете сумата до 2 знака след десетичната запетая за десетична грешка. Не използвайте външна библиотека. Добавете 5 тестови случая под функцията (нормално, празно, отрицателно количество, десетична цена, единичен артикул).“
Насочване на AI като двойка
Добрият напредък в програмирането по двойки е по-скоро диалог, отколкото една голяма молба. Първо поискайте скелета и го стартирайте; след това добавете крайно състояние; след това поправете грешка. Този подход поддържа кода разбираем и ви дава контрол на всяка стъпка.
Подкана за постепенен напредък: "Ще напишем четец, който чете CSV файл и преобразува редовете в обект. Да вървим СТЪПКА ПО СТЪПКА, преминавайки към следващата стъпка, без да потвърждавам всяка стъпка. Стъпка 1: просто напишете скелета, който разделя файла на редове и разделя заглавния ред. Все още не добавяйте преобразуване на тип или обработка на грешки. Бъдете кратки, обяснете."
Обяснете и обосновете подканата на кода: „Обяснете функцията, която току-що написахте, не ред по ред, а решение по решение: кое дизайнерско решение сте взели и защо, кой ръбов случай сте обработили и как, кои случаи сте изключили умишлено? Избройте 3 допускания в кода, които не трябва да пропускам.“
Съвет: Не приемайте кода, генериран от AI, без да го разберете. „Обяснете ми това, какви предположения направихте?“ Въпросът едновременно разкрива скрити грешки и ви позволява да защитите този код, тъй като кодът остава ваша отговорност. Поставянето на код, който не разбирате, в производство е като да изпратите договор, без да го подпишете.
Слаба подкана / Силна подкана
СЛАБ: "Напишете функция за сортиране." (Резултат: кой език, какво се сортира, стабилен ли е, какво е ограничението за производителност, код, който е неясен и вероятно не отговаря на изискването.) СИЛЕН: "За Java 17, напишете метод, който сортира обект List<Employee> първо по отдел (по азбучен ред), след това по заплата (низходящ). НЕ ЗАМЕНЯЙТЕ оригиналния списък, върнете новия списък. Нека нулев отдел обяснете сложността на метода в реда за коментар, добавете основен тестов блок с 4 проби.
Мощна подсказка; Включва критерий за сортиране (на две нива), правило за страничен ефект (замяна на оригинала), нулево поведение и тестово очакване. Без тези подробности AI произвежда правдоподобно, но неправилно решение; например може да повреди оригиналния списък и това ще доведе до тиха грешка на друго място.
Валидиране с крайни случаи и малки проби
Кодът, който работи в щастливия сценарий, не е правилният код. Съзнателно принуждавайте всяка произведена функция:
Edge тип кутия
примерен вход
очаквано поведение
празен вход
Празен масив/низ
Не е грешка, логичен празен резултат
Нула/отрицателно
0, -1
Определено и правилно поведение
голяма стойност
Милиони записи
Препълване/контрол на производителността
нулев/недефиниран
липсващо пространство
Контролирана грешка или по подразбиране
Дублиран/необичаен
повтарящ се, обратен ред
правилен резултат
Мини калъфи
Случай 1 — Тиха грешка при закръгляване. AI пише функция, която събира пари с десетични (float) типове; 0,1 + 0,2 дава 0,3000000000000004. Грешката е разрешена, когато инженерът добави правилото „Закръглете до 2 цифри и използвайте цели стотинки“. Правилото за 3 реда предотвратява отклонение от хиляди стотинки в месечното съгласуване.
Случай 2 — Капан за странични ефекти. AI пише метод, който „сортира“ списък, но променя оригиналния списък на място. Възниква неочаквано поведение, защото друг модул използва същия списък. Ако ограничението „промяна на оригинала“ беше в подканата, грешката никога нямаше да възникне; се хваща при преглед на код и предотвратява 2 часа отстраняване на грешки.
Случай 3 — Печалби стъпка по стъпка. Разработчик отпечатва 150-редов модул за импортиране наведнъж; Когато открие грешка, не може да открие откъде е дошла. Друг разработчик разделя същата работа на 5 малки стъпки, тества всяка стъпка за 2 минути и улавя грешката веднага в 3-тата стъпка.
Често срещани грешки
- Печат на големи блокове в една заявка. Ражда се рисков код, който е труден за разбиране и отстраняване на грешки.
- Искане на код без даване на договор. Ако входно-изходната грешка е двусмислена, AI ще познае и ще сгреши.
- Просто тествам щастливия сценарий. Ако празен, нулев, отрицателен и голям вход не се опита, грешката се оставя на производството.
- Приемане без разбиране. Кодът, който не разкривате, е дълг, който не можете да защитите.
- Игнориране на чувствителни типове като странични ефекти и пари/среща. Плаващите пари с вечна история са класически източник на грешки.
В обобщение
Писането на код с AI е дисциплинирано програмиране по двойки: ясен договор, малки стъпки, изграждане и тестване на всяка стъпка. Предоставянето на квартета вход-изход-грешка-ограничение от самото начало определя качеството на кода. Обясняването на кода, който произвежда, и принуждаването му с крайни случаи изважда на повърхността грешките, скрити под щастливия сценарий. Източникът на скоростта не е сляпото приемане; е бърза чернова плюс бърза проверка.
Задача за приложение
Изберете малка, но реална функция (напр. обща сума в кошницата, разлика в датата, разбор на текст). Отпечатайте, като използвате подканата за договорена функция; Добавете поне 5 тестови сценария до него. Стартирайте кода и опитайте съзнателно 5 крайни случая, като използвате таблицата като ръководство. Намерете грешка в поне един граничен случай (ако не, проектирайте нов вход, за да принудите функцията), поправете я с AI и проверете чрез повторен тест дали корекцията работи.
контролен списък
- [ ] Написах договор, който включва вход, изход, грешки и ограничения.
- [ ] Генерирах кода на малки стъпки вместо един голям блок.
- [] Добавих блок за изпълнение на тест/проба до кода.
- [ ] Съзнателно съм тествал поне 5 крайни случая.
- [ ] Обясних кода на AI и прегледах неговите предположения.
- [ ] Коригирах откритата грешка и потвърдих корекцията чрез повторно тестване.