Як я будую програмне забезпечення
Чому я пишу тести на останній раз, і чому це не те, що ви думаєте, що означає
Спірний підхід: Test-Driven Development - це блискуча практика, яка вирішує неправильну проблему для більшості творчих робіт.
Три етапи розробки програмного забезпечення
Ось як я створюю програмне забезпечення: МСК0, МСК1, простий, МSK2, ', ефективний, МКС4, і це змушує ТД-пуристів politely тріщити брови
Зробіть так, щоб це спрацювало. Зробіті так, аби це було гарноM SK1 Заблокуйте тестами.
У такому порядку:
Не тому, що я не люблю тестування ось як творча робота насправді відбувається коли ви досліджуєте проблему, яку ще не розумієте
graph TB
Start[New Feature Request] --> P1[Phase 1: Make It Work]
P1 --> P1_Private[Private Exploration]
P1_Private --> P1_Sketch["Sketch the solution<br/>Messy code OK<br/>No tests yet<br/>Focus on learning"]
P1_Sketch --> P1_Run["Run it manually<br/>Try different inputs<br/>See what breaks<br/>Understand the problem"]
P1_Run --> P1_Decision{Does it work<br/>basically?}
P1_Decision -->|No| P1_Iterate[Try different approach]
P1_Iterate --> P1_Sketch
P1_Decision -->|Yes| P2
P2[Phase 2: Make It Pretty] --> P2_Refine[Private Refinement]
P2_Refine --> P2_Clean["Clean up the code<br/>Better names<br/>Type hints/annotations<br/>Clear structure"]
P2_Clean --> P2_Align["Align with spec<br/>Cover all requirements<br/>Handle edge cases<br/>Polish API surface"]
P2_Align --> P2_Optimise["Optimise<br/>Performance<br/>Readability<br/>Maintainability"]
P2_Optimise --> P3
P3[Phase 3: Lock It Down] --> P3_Share[Public Sharing]
P3_Share --> P3_Tests["Write comprehensive tests<br/>Full coverage<br/>Edge cases<br/>Error conditions"]
P3_Tests --> P3_CI["CI/CD Integration<br/>Automated testing<br/>Code review<br/>Documentation"]
P3_CI --> P3_Deploy["Ready to Share<br/>Commit to main<br/>Deploy to prod<br/>Other devs can use it"]
P3_Deploy --> Done[Well-Tested,<br/>Well-Designed Code]
style P1 stroke:#ff6b6b,stroke-width:3px
style P2 stroke:#4ecdc4,stroke-width:3px
style P3 stroke:#95e1d3,stroke-width:3px
style Done stroke:#38ada9,stroke-width:4px
Не тому, що я не люблю тестування ось як творча робота насправді відбувається коли ви досліджуєте проблему, яку ще не розумієте
Я поясню.
Фаза 1: Робіть так, щоб це спрацювало (Private SketchM SK2
Це хаотична частина. Я не знаю, що роблю.
Я намагаюсь зрозуміти
- Чи працює цей API так, як стверджують Docs?
- Чи можу я навіть розв 'язати цю проблему за допомогою інструментів, які у мене є?
- Що означає "correctM SK1 навіть в цьому контексті
- Чи це проблема на два години або на два тижні?
Це винахід - МСК0, це дослідження - МSK1, це джаз - .
І ви знаєте, що вбиває джаз. someone standing over your shoulder saying "write the test first
Чому ще немає тестів?
Тому що форма досі рідка.
Уявіть собі, що ви - скульптор. У вас кам 'яний блок і неясна ідея
TDD каже: "" МСК0 "", """. Перед тим, як торкатися цього мрамору, "" МСК2 "", назвіть, як виглядає птаха. "" Ми визначаємо її розмах крил "".
Це не те, як птахи викарбуються, а те, що програмне забезпечення пишеться, як виявилось
Справжні скульптори розгадати форму спочатку. Вони роблять макети. Вони відрізають великі шматочки кам 'я, щоб знайти загальну форму. Вони тільки потім переробляють деталі.
Код такий самий.
В фазі 1, IM SK1m написання :
# Ugly, exploratory code
def process_thing(data):
# TODO: This is terrible, fix later
result = []
for item in data:
# Not sure if this is the right approach...
x = item.get('value')
if x: # Is this even the right condition?
result.append(x * 2) # Why multiply by 2? Testing something...
return result
Цей код приватний. Це - розмова з собою. Це - те, як я зрозумів, що означає праця
Пишування тестів на це гірше, ніж непотрібне—itM SK1s активно шкідлива. Тому що кожного разу, коли я усвідомлюю: "" МСК0 "", "" О, почекайте "". ",". Це весь підхід хибний.
Це - не ретельність, це - бюрократія
Свобода швидко невдатися
Фаза 1 - швидкість навчання.
Я мушу спробувати п 'ять різних підходів за годину. Мушу виявити, що третя бібліотека, яку я думав використати - МSK2, МSK3 - не така ж, як рекламована. МSK5 - я мушу усвідомити проблему. повинна розв 'язувати.
Тести сповільнюють це. Не тому, що тести повільніM SK1 а тому, передчасна точність - смерть.
Якщо я пишу тести перед тим, як зрозуміти проблему неправильне. Тоді я - МСК0 - емоційно вкладаю гроші в неправильне. МСК1 - тоді я - ' - захищаю неправильну річ під час перегляду коду.
Краще не впоратися швидко, в приватномуM SK1 без тестів для підтримання і без его для захисту.
Що означає "РаботаM SK1 в фазі МSK2
Це означає:"" МСК0 "", "" МSK1 "". Я запустив його, ".", я дав йому деякі вхідні сигнали, "", . "", він випустив зразки, які здаються цілком обґрунтованими.
Це - МСК0, це - МSK1
Жодних рюкзаків. Жодних помилок в обробціM SK1 Жодної елегантності.
Просто крапка. Доведення концепціїМSK1 СкетчM SK2
Фаза 2: Зроби її гарною МSK1Рефинація МSK2
Гаразд, так що тепер я розумію проблему . у мене є щось, що працює МSK2 принаймні для щасливого шляху
Тепер я можу піклуватися про якість.
Фаза 2 - це місце, де IM SK1
1. Почистити повідомлення
Наприклад, Python:
# Before (Phase 1) - Exploratory code
def process_thing(data):
result = []
for item in data:
x = item.get('value')
if x:
result.append(x * 2)
return result
# After (Phase 2) - Refined code
def extract_doubled_values(items: list[dict]) -> list[int]:
"""Extract 'value' field from items and double each one.
Only includes items where 'value' is present and truthy.
"""
return [
item['value'] * 2
for item in items
if item.get('value')
]
C# До прикладуM SK1
// Before (Phase 1) - Exploratory code
public List<int> ProcessThing(List<Dictionary<string, object>> data)
{
var result = new List<int>();
foreach (var item in data)
{
if (item.ContainsKey("value"))
{
var x = item["value"];
if (x != null)
{
result.Add(Convert.ToInt32(x) * 2);
}
}
}
return result;
}
// After (Phase 2) - Refined code
/// <summary>
/// Extracts 'value' field from items and doubles each one.
/// Only includes items where 'value' is present and non-null.
/// </summary>
public IEnumerable<int> ExtractDoubledValues(IEnumerable<IDictionary<string, object>> items)
{
return items
.Where(item => item.ContainsKey("value") && item["value"] != null)
.Select(item => Convert.ToInt32(item["value"]) * 2);
}
Найкраще ім 'я. Записи на типі . XML-документація МSK2 Втілення кращого LINQ .
2. Порівняйте з спектром
Тепер я знаю, що я будую насправді. Я повертаюсь до оригінальних вимог і переконаний, що праворуч проблема, не тільки а проблема.
Часто це виявляє прогалини
- "OhM SK1 вони хотіли, щоб це працювало з негативними числами по-іншому ."
- "Wait, thereM SK2s an edge case where value could be None vs
- " Спеціальність говорить: МSK1двіхразовий МSK2 але я думаю, що вони означали ' масштаб за налаштуванням фактору
Я виправляю їх. . Іноді я повертаюсь до спеціалізу.
3. Польский інтерфейс API
Ось де я думаю про телефоніст's досвід.
Python:
# Phase 1: Works, but awkward to use
process_thing(data)
# Phase 2: Clear, flexible, composable
extract_doubled_values(
items,
scale_factor=2.0,
include_zeros=False
)
C#:
// Phase 1: Works, but awkward to use
ProcessThing(data);
// Phase 2: Clear, flexible, composable
ExtractDoubledValues(
items,
scaleFactor: 2.0,
includeZeros: false
);
// Or even better with a fluent API
items.ExtractValues()
.Scale(by: 2.0)
.ExcludingZeros()
.ToList();
Краще називати. Розумні початкові варіанти. Конфигурація там, де це важливо
Це корабель. Ось звідки походить хороше програмне забезпечення.
graph LR
subgraph "Phase 2 Refinement Process"
A[Rough Code] --> B[Clean Structure]
B --> C[Add Types]
C --> D[Polish API]
D --> E[Static Analysis]
E --> F{Quality Gates Pass?}
F -->|No| G[Fix Issues]
G --> B
F -->|Yes| H[Ready for Phase 3]
end
style A stroke:#ff6b6b,stroke-width:3px
style H stroke:#95e1d3,stroke-width:3px
Чому досі немає тестів?
ОМСК0 ЯМSK1 я постійно запускаю його. Я маю відкритий REPL . I' я намагаюсь отримати різні вхідні дані МSK2 ЯM SK3 я тренуюся на всіх шляхах
Але я не думаю, записувати ці експерименти як офіційні тести ще
Чому? Я все ще відкриваю, що варто перевірити
У фазі 1, я не знав, що ця функція взагалі існуватиме.
- МСК0 О МSK1 масштабний фактор може ' не бути негативним
- "Якщо список пустийM SK1 ми маємо повернути пустий
- " Потрібно впорядковувати ненумерніM SK1номерні цінності граціозноМSK2
Ці відкриття з 'являються після рефакторування. Вони не очевидні наперед.
Якщо я писатиму тести в фазі 1, Я МSK2 я перепишу їх зараз МSK3 Якщо я їх напишу після Я МСК0 , я досконала implementaцію , ",", вони мСК2 будуть правильними вперше .
Фаза 3: Заблокувати його тестами МSK1Фаза обміну МSK2
Гаразд МСК0 тепер це МSK1 реальне .
Я впевнений у тому, що я збудував
Тепер я пишу тести МСК0 Багато тестів МSK1 Як МСК2 закрити MСК3 до М СК4 повний М СК5 закривати \ М С К6 як \ M С К7 можливі тести \ м С К8 .
Чому тепер?
Тому що тести - це механізм обміну.
Вони більше не для мене. Я вже добре розумію цей код. Я жив у ньому годинами чи днями.
Тести на:
- Майбутнє Я МSK0 хто забуде все за три місяці)
- Мої колеги (хто повинен довіряти тому, що цей код працюєM SK1
- Трубопровод CI (, яка повинна запобігти регресії
- Майбутні підтримувачі (кох потрібно безпечно переробити цеM SK1
Тести - це шар презентації для мого застосування.
Вони документують:
- Що робить цей код
- Які вхідні дані важливі
- Які результати очікувати
- Які крайні випадки я обмірковував
- Які припущення я роблю?
Полне покрытие, Без компромісів
В фазі 3, я дуже стараюсь тестуватиM SK1
def test_extract_doubled_values_basic():
items = [{'value': 5}, {'value': 10}]
assert extract_doubled_values(items) == [10, 20]
def test_extract_doubled_values_skips_missing_values():
items = [{'value': 5}, {'name': 'foo'}, {'value': 3}]
assert extract_doubled_values(items) == [10, 6]
def test_extract_doubled_values_handles_zeros():
items = [{'value': 0}, {'value': 5}]
# By default, zeros are excluded (falsy)
assert extract_doubled_values(items) == [10]
def test_extract_doubled_values_includes_zeros_when_configured():
items = [{'value': 0}, {'value': 5}]
assert extract_doubled_values(items, include_zeros=True) == [0, 10]
def test_extract_doubled_values_custom_scale_factor():
items = [{'value': 5}]
assert extract_doubled_values(items, scale_factor=3.0) == [15.0]
def test_extract_doubled_values_rejects_negative_scale_factor():
with pytest.raises(ValueError):
extract_doubled_values([], scale_factor=-1.0)
def test_extract_doubled_values_handles_empty_list():
assert extract_doubled_values([]) == []
def test_extract_doubled_values_handles_non_numeric_values():
items = [{'value': 'not a number'}]
with pytest.raises(TypeError):
extract_doubled_values(items)
Це безпечна сітка.
Тепер мої колеги можуть
- Змінюйте цю функцію впевнено
- Розумійте крихітні коробки
- Зловити регресії негайно
- Рефактор без страху
Тести як документація
Хороші тести - це краще документування, ніж коментарі:
# This comment will drift from reality:
# Doubles all numeric values, skipping None
# This test will fail if reality changes:
def test_extract_doubled_values_skips_none_values():
items = [{'value': None}, {'value': 5}]
assert extract_doubled_values(items) == [10]
Тести не брешуть.
Те, що здатна до виконання документація. Саме це робить тести цінними
Об 'єднання кордонів
Ось тут найважливіший момент: Фаза 3 відбувається перед тим, як хтось інший торкається коду .
Я не користуюсь кодом без тестів.
Але я також не пишу тести до того, як код готовий поділитися
Фази::
- Приватне дослідження (just me , no testsM SK2
- Приватне перероблення (just me , still no testsM SK2
- Публічне поширення (тести, CIM SK2 перевірка коду , цілих дев 'ять ярдів МSK4
Це захищає мою творчість і мої колеги' здоров 'яM SK1
Чому це захищає творчість
МСК0 тести дають вам впевненість в рефакторе ."
Правда! Але тільки якщо ви вже знаєте, що ви будуєте
Коли I'm в фазі M SK1 Я не мушу Мені потрібно дозволити відкинути все..
Тести спричиняють психологічне занепокоєння.
Відкладаючи випробування до фази 3,, я зберігаю фазу 1 і МSK2 психологічно дешево.
Я можу:
- Попробуйте дивні ідеї
- Відкинути ціле підходи
- Радічно змінювати дизайн
- Відкрийте проблему I'm насправді розв 'язання
Все без вина ", але я написала всі ці тести ..."
Так працює творчість.
Ви робите малюнки повільно спочатку. Ви не робите
Як це працює з Agile і XP? ( І де воно відрізняється?
Давайте пояснимо щось. це не "test пізнішего розвиткуM SK1
Це "тест під час розробки, але в потрібний часM SK2
Час коли додавати тести на одиниці є вирішальним
Практики XP, які я зберігаю
Екстремальна програмування має чудові практики, які варто дотримуватися:
Неперервна інтеграція
- Кожна функція проходить через CI перед поєднанням
- Автоматичний тест запускається на кожному підключенні до основного
- Ніхто не терпить зламаних будівель
Розробка коду для парного програмування /
- Фаза коду 3 перевіряється перед тим, як поділитися
- Тести є частиною рецензējamого артефакту
- Співпраця покращує дизайн
Простій дизайн
- Фаза 2 - про все упрощення
- Позбутись того, чого вам не потрібно
- Зробіть це якомога простішим, не простіше
Переробка
- Фаза 2 - це dedykowanий час рефакторування
- Чисти код до цього зачиняючи його
- Тести захищають рефакторування (в фазі МSK1
Де я відрізняюся від жорсткого TDD
graph TB
subgraph "Traditional TDD (Red-Green-Refactor)"
TDD1[Write Failing Test] --> TDD2[Write Minimal Code to Pass]
TDD2 --> TDD3[Refactor]
TDD3 --> TDD1
end
subgraph "Three-Phase Approach (Explore-Refine-Lock)"
P1[Explore Solution Space] --> P2[Refine Implementation]
P2 --> P3[Write Comprehensive Tests]
P3 --> P4[Share With Team]
end
style TDD1 stroke:#ffaa00,stroke-width:2px
style TDD2 stroke:#ffaa00,stroke-width:2px
style TDD3 stroke:#ffaa00,stroke-width:2px
style P1 stroke:#ff6b6b,stroke-width:3px
style P2 stroke:#4ecdc4,stroke-width:3px
style P3 stroke:#95e1d3,stroke-width:3px
TDD каже: МСК0 . "Насамперед перевіряютьM SK1 Знову ж такиМSK2 Червоний МSK3 Зелений \ - Єдиним способом - рефератором ."
Я кажу: " Тести, коли ви знаєте, що ви тестуєте ' ми тестуємо МSK2 досліджуємо M SK3 ретельно перевіряємо - замок більш природній
Ключева різниця:
| ТД МSK1 Трьох МSK2Phase | |
|---|---|
| Тест визначає інтерфейс | |
| МСК0 ЧервонийМSK1 Зелений- Цикл рефератора M SK3 Досліджувати-Рефійнувати МSK5Заблокувати прогрес | |
| Тести написані перед введенням ділитися | |
| Спробуй все спочатку | Спробуйте в потрібний час для кожного з речей МSK2 |
| Микро--цикли МSK2минітиM SK3 МSK4 Макро-МSK5фази мSK6годиниМ SK7 дні) |
Час є вирішальним
Ось ключовий урок: Це' не M SK1tests last." ЦеМSK3s МSK4 tests before sharingMSC5
Неправильне підрахунку часу (за рано
Hour 1: Write test for API I haven't designed yet
Hour 2: Realize the API is wrong, rewrite test
Hour 3: Discover a better approach, rewrite both
Hour 4: Finally get it working
Hour 5: Rewrite tests to match what actually works
Правильний час (Phase МSK1
Hour 1: Explore 3 different APIs, settle on the best one
Hour 2: Refine the implementation, handle edge cases
Hour 3: Write comprehensive tests for what I built
Hour 4: All tests pass, commit with confidence
Який ж результат? МСК0. Половина вихлопу. МSK1.
Це гнучкий
Аgile каже::". " Відповісти на зміни, які відбуваються за планом ."
ТД може стати своєю формою плану.
Мій підхід захоплює зміну:
- Фаза 1: Швидко змінювати МSK1 знаходити правильне рішення
- Фаза 2: Намірна зміна МSK1 покращення в сторону элегантності
- Фаза 3: Потрібно ретельно змінювати , захищати те, що працює
Це більше гнучкий, ніж жорсткий TDD, тому що він відкладає зобов 'язання до того, як ви отримаєте інформацію
Спротивні підходи: А CM SK1 До прикладу
Strict TDD Approach:
// Test 1: Write test first (but I don't know the right API yet)
[Test]
public void TestProcessData()
{
var processor = new DataProcessor();
var result = processor.Process(new[] { 1, 2, 3 });
Assert.That(result, Is.EqualTo(new[] { 2, 4, 6 }));
}
// Implementation 1: Make it pass
public class DataProcessor
{
public int[] Process(int[] data) => data.Select(x => x * 2).ToArray();
}
// Later: Realize I need configurability, rewrite test
[Test]
public void TestProcessDataWithFactor()
{
var processor = new DataProcessor();
var result = processor.Process(new[] { 1, 2, 3 }, factor: 3);
Assert.That(result, Is.EqualTo(new[] { 3, 6, 9 }));
}
// Later: Realize I should use IEnumerable, rewrite test again
[Test]
public void TestProcessDataEnumerable()
{
var processor = new DataProcessor();
var data = GetLargeDataset(); // This should be lazy
var result = processor.Process(data, factor: 3);
Assert.That(result.Take(3), Is.EqualTo(new[] { 3, 6, 9 }));
}
Зверніть увагу на турбування? Три тести переписуються з еволюцією дизайнуM SK1
ТроєМСК0Пазовий підхідМSK1
// Phase 1: Explore (no tests yet)
public int[] ProcessThing(int[] data)
{
return data.Select(x => x * 2).ToArray();
}
// Try it: var result = ProcessThing(new[] { 1, 2, 3 });
// Hmm, what about configurability? What about lazy evaluation?
// Phase 2: Refine (still no tests)
public static class DataProcessorExtensions
{
public static IEnumerable<int> Scale(
this IEnumerable<int> source,
int factor = 2)
{
return source.Select(x => x * factor);
}
}
// Try it: var result = data.Scale(factor: 3).ToList();
// Much better API!
// Phase 3: Lock it down (NOW write tests, correctly)
[TestFixture]
public class DataProcessorTests
{
[Test]
public void Scale_DefaultFactor_DoublesValues()
{
var result = new[] { 1, 2, 3 }.Scale();
Assert.That(result, Is.EqualTo(new[] { 2, 4, 6 }));
}
[Test]
public void Scale_CustomFactor_ScalesCorrectly()
{
var result = new[] { 1, 2, 3 }.Scale(factor: 3);
Assert.That(result, Is.EqualTo(new[] { 3, 6, 9 }));
}
[Test]
public void Scale_LazyEvaluation_DoesNotEnumerateImmediately()
{
var enumerated = false;
var data = GetTestData(() => enumerated = true);
var scaled = data.Scale(factor: 2);
Assert.That(enumerated, Is.False, "Should not enumerate yet");
scaled.ToList();
Assert.That(enumerated, Is.True, "Should enumerate on materialization");
}
[Test]
public void Scale_EmptySequence_ReturnsEmpty()
{
var result = Enumerable.Empty<int>().Scale();
Assert.That(result, Is.Empty);
}
}
Один комплект тестів. Написали один разM SK1 Corrig the first time. Тому що я знав, що будую
Agile Manifesto Connection
Пам 'ятайте цінності:
"Working software over comprehensive documentation "
- Фаза 1 переходить до програмного забезпечення швидко
- Фаза 3 робить тести комплексною документацією
" Відповідаючи на зміни, які відбуваються за планом "
- Фазы 1-2 приймають зміну
- Фаза замків 3 в кінцевому дизайні
"Individuals and interactions over processes and tools
- Не дозволяйте догмам ДД переважати хороше судження
- Співпрацювати, коли це допомагає
"Кооперація між клієнтами і переговорами по контрактуM SK1
- Фаза 2 відповідає спецификації після зрозуміти проблему
- Краще доставити те, чого вони потребують, ніж те, що вони визначили.
Чому це зменшує непотрібний кур
ТДД' забруднена таємницяМSK1 більшість тестів, написаних перед застосуванням, переписуються або видаляються.
Чому?
- Ви неправильно зрозуміли вимоги
- Ви ще не знали
- Ви відкрили кращий дизайн API
- Ви зрозуміли, що ця функція взагалі не потрібна
Кожен тест, який ви пишете в фазі 1, мабуть, марнується.
Краще писати один набір тестів в фазі 3,, коли ви насправді знаєте, що ви будуєте ' МSK2, аніж писати
Обіцянка TDD проти реальності
TDD обіцяє: " Тести підштовхують ваш дизайн ! Вони допомагають вам виявити хороші API МSK2
ТД реальність: " Я писав тести для API, на мою думку, це було логічно . Потім я реалізував їх і зрозумів, що API було незграбно МSK2 Зараз я МСК3 перезаписую як тести, так і код
Це не дизайн thrashing.
Мій підхід: Проектування шляхом втілення, потім заблокування тестамиM SK1
Врешті-решт, результат такий самий:
Чому це все ще дає дискриміноване програмне забезпечення
Ось що таке цей підхід не:
- "Cowboy кодуванняM SK1
- "Не було тестівM SK1
- "Волшебство і мольбаM SK1
До того часу, як я закінчу фазу ' МSK1 мій код МSK2
- Комплексне тестування
- Руховані cases на краю
- Чиста implementation, читабельна
- Чистий дизайн API
- Документація (за допомогою тестівM SK1
Точно так само, як TDD.
Різниця в тому, коли ці тести були написані.
Дисципліна приходить з кордону
Правило просте: Жоден код не залишає фазу 2 без фази МSK1
Я не знаю
- Виśliти невипробований код
- Відкрити PR без тестів
- Об 'єднати до головної без передачі CI
- Розподіл без звітів про охорону
Дисциплінація полягає в тому, що не ділиться кодом без тестів.
Метафори ремесла
Це не нова ідея, це те, як творче праця завжди працювала.
Скетч → Рефінія МSK1 лак
Художники не починаються з остаточних мазків
Вони:
- Скетч з 'єднання (Phase МSK1
- Смальувати шари (Phase МSK1
- Варніш для захисту та створення (Phase МSK1
Але це не обов 'язково.
Проект → редагувати МSK1 публікувати
Писачі не редагують, як пишуть
Вони:
- Проект безладно (Phase МSK1
- Редактувати безжалостно (Phase МSK1
- Публикація з впевненістю (Phase МSK1
" Письмо п 'яний , редагуємо пильно МSK2 це жахлива порада для життя, але чудова порада на написання
Застекло → Форма МSK1 Glaze
Поттери не мають glazury перед формуванням
Вони:
- Викидати глина (Phase МSK1
- Трим та переробка форма (Phase МSK1
- Стеклі та вогонь для довготривалості (Phase МSK1
Гальзатура має вирішальне значення. Але вона приходить останнєM SK1
Як це поєднується з каналом DiSE Codegen
Ось тут: МСК0 , де це стає цікавим, ":", Я МСК2 . втілення ця філософія в системі DiSE (Directed Synthetic EvolutionM SK1 system.
Кодегенна трубка чітко втілює ці три етапи:
Фаза 1 у DiSEM SK1 Фаза дослідження
Коли ви просите DiSE розв 'язати проблему,
Натомість Генератор (codellama або щось подібне ) отримує чіткий мандат МSK2
"Write code that solves the specification.
Don't worry about perfection yet.
Just get it working."
Система генерує дослідний код:
- Зфокусовані на щасливому шляху
- Minimalне подолання помилок
- Жодна передчасна оптимізація
- Просто достатньо, щоб перевірити підхід
Тоді Керівник запускає його. Не за допомогою офіційних тестів на одиниціM SK1 тільки за допомогою вхідних даних з спецификації.
Якщо це не вдасться? Ніяких проблем навчання.
Система має 6-стаг адаптивної ескалаціїM SK1
- Попробуйте з швидким modeloм (нижча температураM SK1
- Знову спробуй з більшою творчістю (вищою температуроюM SK1
- Перейдете до більш потужної моделі
- Додайте журналування розладів, щоб зрозуміти невдачі
- Дайте повний контекст потужній моделі
- Як останнє рішення, використовуйте модель "god-levelM SK2
Це точно Фаза 1. Система досліджує простір розв 'язання , вчиться, що спрацьовує МSK2 невдачі швидко M SK3 і адаптується .
В цій фазі не написано жодних тестів. Код приватний для процесу генерації.
Фаза 2 у DiSEM SK1 Фаза оптимізації
Як тільки код проходить базову програму, DiSE рухається до оптимізація.
Це етап очистки.
Очистити Implementation
- Removes debug logging that was added during failures
- Полегшує надто складний код
- Поліпшує назву та структуру
Продовжує статичний аналіз
- flake8 (style checking) - pylint (code quality) - mypy (type checking) - black (formatting) - radon (complexity analysis)Ітеративно оптимізує (3 ітерації по замовчуваннюM SK1
for iteration in range(3): # Measure current performance metrics = measure_performance(code) # Generate improved version better_code = optimise(code, metrics) # Keep if better, discard if worse if better_code.score > code.score: code = better_code
Це точно Фаза 2. Код все ще приватний ( ще не в реестрі МSK2 але ми МSK3 поліпшуємо його
- Кращі імена
- Використовуйте вказівки
- Чистіша структура
- Нижча складність
- Кращі результати
Форма більше не є плавною. МСК0. Ми знаємо, що ми будуємо. МSK1. Тепер ми це робимо гарний.
Фаза 3 в DiSEM SK1 Стадія тестування та зберігання
Тільки після оптимізація генерує і запускає DiSE формальні тести на одиниці.
Тут – МСК0 – це ключова частина – МSK1 – тести генеруються з удосконалена спецификація і втілення, не первинне дослідження
# Test generation happens AFTER optimisation
def generate_unit_tests(specification, optimized_code):
"""Generate comprehensive tests for refined code.
This happens in Phase 3, after we know:
- What the code actually does
- What edge cases exist
- What the API surface looks like
"""
return llm.generate(
f"""Generate comprehensive unit tests for this code.
Specification: {specification}
Implementation: {optimized_code}
Include tests for:
- Happy path (from spec examples)
- Edge cases (discovered during optimisation)
- Error conditions (based on actual error handling)
- Performance bounds (based on measured metrics)
"""
)
Тести obejmują::
- Наведу приклади. (правильністьM SK1
- Були виявлені крайні випадки в фазі 2
- Помилка в обробці, яка була добавлена під час рефинування
- Характерні характеристики, які вимірювали
Тоді, тільки якщо тести пройдуть, кодом єM SK1
- Поміщається в RAG пам 'ять (с вбудовамиM SK1
- Добавлено до реєстр вузлів ( як виконовний артефакт
- Доступна для переробка в майбутніх робочих потоках
- Переслідування з балів якості і показники ефективності
Це - faza обміну. Код зараз публічний. ( для системи ). Він має комплексні тести. ВінM SK3 заблокований
Чому це працює в системі генерації коду
Троєfazовий підхід - важливе для генерації коду, керованого штучним інтелектом
Фаза 1: Моделі не розуміють проблему з самого початку
- Вони мають досліджувати простір для вирішення
- Спочатку спроби часто провалюються досить цікавими способами.
- Невдачі дають інформацію для кращої спроби
- Непередбачувана перевірка змушує доволі передбачувані характеристики
Фаза 2: Моделі оптимізуються краще за допомогою зворотнього зв 'язку
- Статичний аналіз виявляє справжні проблеми
- Поліпшення вказівок на показники ефективності
- Оцінки складності показують можливості для спрощення
- Ось тут виникає якість
Фаза 3: Тести документують, що було вивчене
- Тести захоплюють остаточний розуміння
- Вони відображають справжня cases на краю
- Вони кодують відшліфована Дизайн API
- Вони МСК0 виправили вперше ( не переписали 5 разів
Доказка, що це справді працює
Ось реальний приклад системи DiSE:
User: "Calculate fibonacci numbers"
[Phase 1: Exploration - 3 attempts]
Attempt 1: Works for small inputs, explodes on large ones (no safety limit)
Attempt 2: Adds safety limit, but inefficient recursive approach
Attempt 3: Switches to iterative DP (PASS)
[Phase 2: Optimization - 3 iterations]
Iteration 1: Add type hints, improve naming (Score: 1.05)
Iteration 2: Optimize memory usage with generator (Score: 1.10)
Iteration 3: Add input validation (Score: 1.15)
[Phase 3: Testing and Storage]
Generated 8 unit tests covering:
- Basic cases (n=0, n=1, n=5, n=10)
- Edge cases (n=negative, n=100, n=None)
- Type validation
All tests pass ✓
Stored in RAG with quality score: 1.15
Available for reuse: YES
кінцевий код::
- Добре МСК0 перевірено МSK1 тести , всі пройшли )
- Добре- оптимізований M SK1 кращий за початкову версію )
- Добре-документоване (за допомогою тестів та наказів на типиM SK2
- Готовий поділитися (в RejestrіM SK1
Так само, як обіцяє ЦД. Просто через більш природній шлях.
Система оптимізується сама
Ось тут - МСК0, де стає дійсно цікаво - МSK1 DiSE застосовує цей три-фазовий підхід - - до самого себе.
І Рекурсивний оптимізатор системи має рівні 4
- Уровни 0: Оптимизувати кодові артефакти ( зробити їх такими, щоб вони працювали
- Уровни 1: Оптимизувати робочі потоки, які використовують ці артефакти ( ті ж три етапиM SK1
- Уровни 2: Оптимизуйте інструменти і логіку вибору ( ви здогадалися це )
- Уровни 3: Оптимізувати оптимізатор сам по собі (metaM SK1
На кожному рівні
Це мантра: МСК0 . аж донизу.
Справжня причина, чому це працює
Ось неприємна правда. Більшість коду написано людьми, які ще не розуміють проблему
Те, що МСК0 - це не провал ".", те, що реальність.
Требування неоднозначні. Спекти неповні . ТретійM SK2 сторонні API погано задокументовані. Хвильові випадки з 'являються звідкисьMSC4
Ви не можете проектувати ідеальний API з самого початку, тому що у вас не є достатньо інформації
Три етапи підтверджують це.
- Фаза 1: Дізнайтеся, чого ви не знаєте
- Фаза 2: Застосуйте те, що ви вивчили
- Фаза 3: захищайте те, що ви збудували
Відокремивши дослідження від specifikacijи, Я можуM SK1
- Досліджувати вільно (без тестового боргуM SK1
- Упевнено визначити: ( знаючи, що має значення
- Безпечно ділитися (з комплексними тестамиM SK1
Це правда для людей, які пишуть код також true for LLMs generating code. And for systems optimizing themselves.
Коли TDD дійсно має сенс
I'm не протиM SK1TDD. I 'm протиМSK4передчасно TDD.
TDD працює чудово, коли:
1. Проблема в тому, що
Якщо я 'встановлюю відомі алгоритми МSK1сортування МSK2 аналізу , і т.д.
# I know what sort() should do. Tests first? Sure!
def test_sort_empty_list():
assert sort([]) == []
def test_sort_single_element():
assert sort([5]) == [5]
def test_sort_multiple_elements():
assert sort([3, 1, 2]) == [1, 2, 3]
2. ВиM SK1 виправляєте błąd
Якщо у мене регресія, TDD - точно так:
- Написати тест, який відтворює błąd (redM SK1
- Поправити код (greenM SK1
- Якщо необхідно, змінювач ( змінювачM SK1
Чудово
3. ВиM SK1 перетворюєте існуючий код
Якщо у мене вже є інсталяція і я хочу змінити її структуру, тести (не поведінкаM SK1 необхідні до цього Я починаю.
Але те, що МСК0 - це не фаза МСК1 Те, що ' - це faza 4: Утримка
Чесна правда
Ось як я насправді працюю. найбільше розробники насправді працюють, навіть ті, хто стверджує, що роблять жорсткий TDD
Тому що творчість заплутана.
Ви можете не визначити себе з невігластва
Ви повинні побудувати річ, щоб зрозуміти її.
Отже, я будую його: (Phase 1), переробляю, МSK2PhASE МSK3 а потім зачиняю.
У такому порядку:
І ви знаєте, що?
Так само, як обіцяє TDD.
Я тільки-но туди дістався через інший шлях – МСК0, який поважає те, як творча робота насправді відбувається.
Що це за мантра розробки програмного забезпечення? 1. Чи ви все змінюєте? 2. Чи маєте інший підхід? 3. Я дуже люблю чути ваші думки у коментарі. 5.
P.SMSC1 - Якщо виM SK3 ти пуріст ТД, і цей пост змусив вас підняти брови, , відмінно МSK5 Це означає, що ми МSK6 маємо правильне інженерне обговорення M SK7 Я мSK8 помилявся над багатьма речами до того, як я стався до цього. M( просто попросіть мою історію Ґіта МСК10 тож яМСК11 завжди цікавлюся чути різні точки зору М СК12 Можливо, виМ СК13 переконаєте мене в цьому.