为什么我写测试 上,,为什么你认为它的意思不是

争议性攻势 @:# 测试-#Driven Development 是解决最有创意的工作错误问题的绝佳实践

建筑软件的三个阶段 “(”“实际有效”,“)”

这就是我如何构建软件“. @ it' @ssimple@,}它有效的#' @s

让它正常运转 让它漂亮一点 用测试来锁定它

按此顺序, . $ always#. _BAR_按此顺序

不是因为I'@m lassi不是因为我不做I'_t 值测试>.}但是因为 这就是创造性工作是如何发生的 当您在探索一个问题空间时 您还没有完全理解您对 '@

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

不是因为I'@m lassi不是因为我不做I'_t 值测试>.}但是因为 这就是创造性工作是如何发生的 当您在探索一个问题空间时 您还没有完全理解您对 '@

让我解释一下 .

阶段1:让它正常运转 (私人的Sketch)"

这是乱七八糟的部分 . 我完全不知道自己在做什么

我试图理解 :

• 这个API是否真的像医生说的那样有效?
• 我能用我拥有的工具来解决这个问题吗?
• 在此情况下,“"”更正“MS K1”甚至意味着什么? “?”
• 这是两个时间问题还是两周问题?

这是发明 . 这是探索 这是爵士乐

你知道什么能杀死爵士乐吗 ? 有人站在你的肩膀上说

为什么没有测试呢?

因为 形状仍为流体@. @%

想象一下你是一个雕塑家 你有一个大理石块 一个模糊的想法

TDD说“: @"之前,你触摸大理石*,准确地写下鸟的长相。 ”定义它的翅膀。 “. 指定每根羽毛的角度。” “.现在切入这些规格吧?” “MS K6

@(_Or 软体会被写成@,}因为事实证明是#.)

真正的雕塑家 粗略地列出表单, 首先@. @ 他们画的.,他们制作了 maquettes.}它们挖出一大块石头来寻找一般形状....

代码是相同的@. @%

在“1, I' 写入” “:”阶段

# 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

这个代码是 私人 . 它和我自己的谈话 . I' 我如何知道什么?

此功能的写作测试比无用的更糟糕@ — @ it' @%s 积极危害性 因为每次我意识到""Ooh 等待"MS K1 这整个方法都是错误的","I' 不得不重写测试 too.

{\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}那又怎样?

" 快速失败的自由 "

阶段1是约 学习速度@. @%

我需要尝试五种不同的方法 在一个小时内.}我需要发现 第三家<->党立图书馆 我认为I'QD使用是'QT 应: 正在解决@. @%

测试减慢此速度@ . @ 不是因为检测缓慢, 而是因为 过早指定为死亡@. @%

如果我在读懂问题前写测试, 错误的事情". 然后,我在情感上投资 在错误的事情"." 之后在代码审查中为错误的事辩护

最好不要在私人场合... ...",...

阶段1意味着什么?

意思是": "I运行它" "我提供了一些投入" ". 它产生的产出似乎合理"

万岁,万岁

没有边缘案例@.没有错误处理 @ .没有电子文本 @ MPK2

只是个小插曲 一个概念的证明 草图

阶段2: 让它看起来更漂亮 ( 改进"MSSK2"

OKMSKO}所以现在我明白问题所在了 我有一些东西至少能为幸福的旅程效劳

现在我可以开始关心质量了 .

阶段2是I:的地方

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#例 MS K1

// 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);
}

更好的名称@ . type untroduction @ MS K1 XML 文件 *\ . 清洁 LINQ 执行@.

2. 和灰尘对齐

现在我知道我在建造什么了 , 我回到原来的要求 确保I'解决 右对右 不仅如此 a a/ 问题:.

这往往揭示出差距 :

• 他们想用这个来处理负数 不同的是."
• " @wait@, @ there @'}在边框中, 值可能是无的 vs.} @ MS K4}
• @"@Thespec says {'}双'}(但我想它们是指按可配置因素的 ' 标度_.'"}

我修了这些. 有时我推倒在 spec: {"} },}我们该做X,因为YMS K4\ }

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();

更好地命名“. 感官默认”@. 配置, 酌情指定“ . 流利的API ” @.

这是 . 这是很好的软件来源于 @.#

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

为什么还是没有测试?

Oh, I' 不停地运行它 . 我有一个 REPL 打开. I'}尝试不同的输入 *."I'"我运行了所有路径\ .}

但我没有 将实验写成正式测试,

为什么?因为 I'#m 仍然在发现什么是'}值得测试的东西 200)}.}

在“1,”阶段,我曾知道这个函数是否存在? “. ” 。

• 校对:Soup
• @ "_ {如果列表是空的@ MS K1} , 我们应该返回空的\ ,} 而不是无." {
• " @% 我们需要处理非 - 数字值的优雅@."}

这些深刻见解 正在从重构中产生@. @% {\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}他们并不明显

如果在“1,”阶段的 I'd 书面测试中 之后 I'@ve 完善了执行@, @他们#'}第一次会更正的_.

阶段=3: 锁定它下来与测试\ ( 分享阶段_)

OKMSKO现在它~'}真实的#.

代码是干净的#. API可以理解到 @.~I'已经覆盖了边缘情况@. I'对 I'建立什么有信心_.

*现在,我写了很多测试 . 很多测试 作为-\close-Qto @--}覆盖@-as-}可能的测试 .}

为什么现在?

因为 测试是共享机制@. @%

他们不再适合我了 我已经理解了这个代码 亲密的. -I'

测试是用于“:”的测试

1. 未来我 三个月后就会忘记一切的人
2. 我的队友们 需要信任这个代码的人
3. CI 管道 需要防止回归的(
4. 未来维护者 需要安全重构这个)的人

测试是 演示演示文图层 执行@. @%

他们的文件 :

• 这个代码做什么
• 哪些输入有效
• 期望产出
• I' 考虑过的边缘案例
• 什么假设? 我做的

完整覆盖@, @ no confromis

在“3,”阶段,我努力进行测试 “:”

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]

如果行为改变 @, 测试中断@.

那个M' 可执行的文档@. @% 使测试变得有价值的东西

共有边界

在这里,'是关键点 : 片段 @3在其他人接触代码前发生

我不分享代码 没有测试 . 永远. *

但我在代码准备共享 .前也写测试

阶段是::

1. 私人私人私人勘探 "M(" "只是我 ," 没有测试"
2. 私人装修 还没有测试吗?
3. 公共分享 -=YTET -伊甸园字幕组=- 翻译:

这保护我的创造力 和 我的队友 ' 精神正常 . *

为何保护创意

TDD提倡者说"测试能让你有信心重构."

但前提是你已经知道 你正在建造什么

当I'm在阶段\ 1,I don}'T需要信任才能重构@.} 我需要许可才能扔掉一切 .

测试产生心理债务@. 一旦 IQ'写了它们 @,I'm 不愿删除它们#.}即使他们检测错了东西_'re

将测试推迟至阶段@3, @I 保留阶段 @1}和Q2 低廉的心理治疗

我可以让:

• 尝试野生想法
• 丢弃全部方法
• 彻底改变设计
• 发现问题 I'm 实际 解答

但我写了所有那些测试 ..." *

这就是创造力是如何运作的 .

您先草草地画下您的素描 .}您不做'}请从细节开始 *.}

如何与 Agile 和 XP 匹配? @ ( @ 以及它在哪里被拆卸?

让'来澄清一些事情吧 : 这不是@ " @ test later development+."

这是 @"_Test 正在开发@,}但时间恰到好处 ."

时间的时间安排 何时 添加单位测试为关键@. @% 时间太早, 您正在指定未知的 @ .# 日期已晚, 而您在没有安全网情况下的航运\ MS K4}

保存的 XP 惯例

极端的编程方法非常有才华,

连续整合

• 每个功能在合并前都通过 CI
• 自动测试运行于向主
• 没有破碎的建筑被容忍

配对编程@ / @ 代码审查

• @3_ 代码在共享前被审查
• 测试是可审查的艺术品的一部分
• 协作完善改进设计

简单设计

• 阶段=2是 全部约 简化简化
• 删除您需要的东西@ ' @ t
• 让它尽可能简单,}不是简单的

重构

• 阶段 *2 专门重构时间
• 清除代码 之前 锁定它
• 测试保护重构中的 @ ( @ in section *\ 3+)} NAME OF TRANSLATORS

在那里我从严格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 Says: @"_Tests first@.}总在.Red{-}格林•-Refactor is the only way ." 唯一的方法就是:

我说: : "#Tests 当你知道自己在测试什么时... ...

关键区别@: @%

-=YTET -伊甸园字幕组=- 翻译: |-----|-------------| |Test 定义了界面@|探索定义了接口 @| |+Red@-+Green @-+Resactor 周期 |+Sexploree_-+Refine}-=Lock process *|# 执行前写入的测试 @ |}% 1 共享共享 | 万事俱备的|测试 在正确的时间进行每件东西的测试 |+微米-+圆圈 @+分钟 @MS K3+ |_MOR-#站点 @(+Hours=/})+~|#

时机是关键

在这里,' 关键洞察力 在分享."之前,它不是 "Tests last @."}它在共享前是"STes

错误的计时@ ( @ 太早了 @ MS K1 @

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

右转计时@ ( @ 阶段 @ MS K1} @

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

同一质量结果@. 一半的jurn.

这是 IS Agile

阿吉勒说:: @" 响应改变 根据一个计划_."#

TDD可以变成它自己的计划形式 一旦你写了测试书 ' -,

我的方法包括改变 :

• @1: @ 改变快速@,# 发现正确的解决方案
• 阶段: “2: 有意改变”“, 完善为优雅。
• 3:э跑 ,玂臔ぐ或琌Θ

这是 更多 比严格的 TDD,的敏捷, 因为它会推迟承诺直到您得到信息@.

对比方法@: A C#例

严格TD 近似 :

// 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 }));
}

请注意 churn? 3个测试重写器随着设计进化而修改@.

3- 阶段接近 □:

// 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);
    }
}

一组测试@ . 编写过一次 MS K1 校正了第一次\ MPK2 因为我知道我正在建造什么 @ .

Agile 宣言连接

记住值@: @%

"#工作软件与综合文件

• 阶段1得到工作软件 快速快
• “3”阶段测试综合文件。

" 响应一个计划后的变化*

• 阶段 *1-2 包含变化
• “3”阶段锁定最终设计

有关过程和工具的个体与互动

• 让TDD教条压倒良好的判断力
• 当合作帮助“(”阶段 “2-3),” 时, 当它帮助了“MSk0” 阶段“ 1)” 进行单独探索的时候, 当它在做“MS K2” “t” “MSSK3” 级“ @ MSC4”)

在合同谈判方面海关合作 "

• 阶段 *2 和标准一致 之后 了解问题
• 更好地交付他们需要的东西,而不是具体指明的

为何会减少无用之春

{\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}DTD'}肮脏的秘密 : * 执行前写的大多数测试被重写或删除@. @%

为什么? 因为

• 你误会了要求
• 你当时还不知道有边缘病例呢
• 你发现了更好的API设计
• 你意识到这个功能根本不需要

您在“ 1” 阶段撰写的每次测试都可能白费力气,

写得更好 1个 在“ 3,” 阶段, 当您实际知道在勘探期间您正在构建什么 “ '”re building @ MS K2” 比写入“ O- restrite@ -” 重写更清楚

TDD承诺与现实

TDD的诺言#: "#Tests驱动您的设计@!}它们帮助您发现好的APIS!"}

TDD现实 : @"_I写了对API的测试, 我认为这很有意义@.}然后我应用它 发现API是尴尬的#.现在 IQ'M重写测试和代码=."}

这不是设计... . {\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}哈哈哈

我的方法#: 设计通过执行@,然后用测试#.锁定

最后的结果是相同的“—”和“-”测试“MS K2” 。好的“-”设计了代码@.” 但我得到了一半的"I."

为什么这个仍然提供有纪律的软件

这里#' @%_sthis 这个方法是什么? 不是:

• 牛仔编码 "
• @"No 测试"}#MSK1_
• {\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}

当I'完成阶段 3,时 我的代码有:

• 全面测试覆盖率
• 处理的边缘案件
• 可读执行
• 清除 API 设计
• 文档 @(_via 测试@)

与TDD.}完全相同

区别在于 何时 这些测试是写作的 .

纪律来自边界

规则是简单的@: @% 没有任何代码会离开“2”阶段, 而没有“MPK1”阶段的“MSC0” 阶段

我不做' ~T:

• 未测试的代码
• 不加测试的开放PRP
• 合并到主控面而不经过 CI
• 部署无覆盖面报告

该学科在早期写作测试中是 '_t 没有测试, 不共享代码@ . @

手工艺符号

这不是一个新想法吗? .* It'}创意工作如何一直有效

拼图 @ → @ refine @ I→_ 彩色

绘画家们从最后的刷新开始

他们叫"他们"

1. 书样 @ (_ 阶段 @ I1)}% 1 complete
2. 油漆绘画 @ _ 阶段@ MS K1_ 层的平面
3. 配色 来保护并展示 & M( @ 阶段 @ 3)}

清漆不是可选的吗?

编辑 → 出版

Writers don't 编辑他们的草稿\MS K1

他们叫"他们"

1. 草案草案草稿草案 @( 阶段#1)
2. 编辑编辑编辑 残酷无情的“(”阶段 “2)”
3. 出版 充满信心的“(”阶段 “3)”

@" @Write drunk@,}编辑清醒点 "#是可怕的生活建议 但写作忠告很棒

Clay → 表格 @ → 玻璃

波特在形状前不闪亮@. @%

他们叫"他们"

1. 丢弃 粘土 阶段 MSC1
2. 修整和精细 窗体“%(”-“阶段”、“2)” -“阶段”
3. 冰川和火灾 用于耐久性 & M( @ 阶段 @ 3) @

玻璃是关键 . 但它终于来了

此图如何映射到 DISE 代码元管道

这里的' @% 有趣的地方Name 已执行已执行 此哲学在 DISE 的 disreced 合成进化\ )\ 系统@.\

代码管道明确体现了这三个阶段:

勘探阶段 DISE的“1”阶段

当您要求 DISE 解决一个问题时@, @ it doesn't\ '}直接跳到写完@ ,_ 测试代码@ MPK3}

取代, 发电机发电机 @(_codellama 或类似的@)}得到明确的任务 :

"Write code that solves the specification.
Don't worry about perfection yet.
Just get it working."

系统生成探索代码=:}

• 关注幸福的道路
• 最小错误处理
• 不过早优化
• 仅足以测试这一方法

然后 执行器 没有正式的单位测试吗? —?

如果它失败了... ... . 学习@.

这个系统有一个阶段适应性升级 :

1. 尝试使用快速型号 @ (@ low world_ MS K1 @
2. 用更高的创造力再试一次 @ (# 高温@ MS K1 @
3. 升格为更强大的模型
4. 添加调试记录来理解失败
5. 赋予强势模式以充分背景
6. 使用“"@god @-”模式作为最后手段

这是 精确 系统正在探索解决方案空间@,学习什么能成功,但无法快速 @,和调整#.。

此阶段没有写入测试@ . @ 代码是生成过程的私人代码 @. @%

优化阶段 DISE=:}的“2”阶段

一旦代码通过基本处决 ,DSE移动到 优化@. @%

这是改进阶段 . 系统:

1. 清理执行过程

   • 删除失败时添加的调试记录
   • 简化过于复杂的代码
   • 改进命名和结构

2. 运行静态分析

   - flake8 (style checking)
   - pylint (code quality)
   - mypy (type checking)
   - black (formatting)
   - radon (complexity analysis)
   

3. 顺势选择性 (3 默认的迭代@)

   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
   

这是 精确 此代码仍为私有的 (}未在登记册中 *),}但是我们正在擦亮它_:}

• 更好的名称
• 类型提示
• 洁净结构
• 低复杂程度
• 改善业绩

形状不再是流体=. 我们知道我们正在建造什么 不错的.

测试和储存阶段

仅 之后 优化 DISE 生成和运行 正式单位测试@. @%

这里“'”是关键部分 “:” 测试来自 完善的规格规定和执行-=YTET -伊甸园字幕组=- 翻译:

# 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)
"""
    )

测试覆盖@: @

• 具体示例@(}校正性 @)
• 在“2”阶段发现的边缘病例
• 改进过程中添加的错误处理
• 测量的性能特征

然后 , 仅在测试通过密码是:

1. 存储于 RAG 内存 与嵌入的)
2. 添加到 节点登记册 ( 做为可执行的工艺品 @)
3. 可供用于 再利用 未来工作流程
4. 与 质量分数 和 业绩计量

这是共享阶段 . 该代码现为公开的 ( @to the system @).}它有全面测试@._It'}锁定了%.#

为什么这在代码生成系统中起作用

三个阶段的方法是: 必要 自动生成代码,因为“:”

阶段 @1:+# Models don'@ t理解问题在前方

• 他们需要探索解决空间
• 最初尝试往往以有趣的方式失败
• 失灵为更好的尝试提供信息
• 过早测试将强制过早规定

阶段 @2: 模型使用反馈更好地优化

• 静态分析揭示了真正的问题
• 业绩计量改进指南
• 复杂程度分数突出简化机会
• 这就是质量出现的地方

阶段 @3:_ 测试记录所学到的东西

• 测试捕捉 期末 理解
• 它们反映了: 实际数 边缘情况
• 他们把 精细 APIP 设计
• {\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}

证据': 它实际上有效

下面是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

最终代码是:

• {\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}好的MSK
• 更优于最初版本@) @
• {\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}好的- 记录下来的(测试和输入提示
• 准备在注册簿中共享“(”

完全像TDD承诺 顺着更自然的路径 .

系统自我优化

在这里, ' @%s 在其中变得非常有趣@ MS K1_ DISE 应用了这三种“ -” 相位法 {\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}自己

缩略 递归系统优化器 具有“4”级别@:

1. 级别 @0: 最优化代码手工艺品 @(#让他们工作 #,}让它们变得漂亮#,#
2. 级别 @1: 优化使用这些文物的工作流程@( @same 三阶段_)}
3. 级别 @2: 优化工具及选择逻辑@( @你猜到的#)}
4. 级别 @3: 优化最佳优化器本身@( @meta @!) @%

在每个级别上 : 探究#→ 精细修补 #→ 测试>.

这是咒语 , 一路往下走... ..."MSKO

这样做的真正原因

在这里,' 不舒服的真相 : 大部分代码都是由那些不理解问题的人来撰写的。

{\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}这不算失败... 现实的.

要求模棱两可 .Specs是不完整的.III}-Party API 没有很好的文件记录吗?

您可以先设计一个完美的API, 因为 **你没有足够的信息 . ***

这三个阶段承认了这一点。

1. 阶段1: 学习你所不知道的
2. 阶段2: 应用你学到的东西
3. 阶段3: 保护你建造的建筑

通过将勘探与规格分隔开来 我就能把勘探和规格区分开来

• 自由探索@( @ 不测试债务)}
• 满怀信心地仔细思考 ( 知道什么重要吗?
• 使用全面测试安全共享 @(@ )#

人类写代码的确是如此。 也 LLMs 生成代码=.}和系统自我优化的系统_.

当 TDD 实际上让感知

I'm not against @-TDD.I'm antMS K4早产 TD.

当":"时, TDD的作品很棒。

问题在于

如果I'm 实施已知的算法 @(sorting@,passing},et我确切知道什么是""rrack}"}意谓前端_.}

# 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. 你'正在修补臭虫

如果我有回归的话 ,#TDD就是 完全正确:

1. 写入一个复制臭虫\ ( red)\ \ 的测试
2. 固定代码“(”和“绿”
3. 需要时重构器 @ ( @ refactor@ MS K1}

完美万岁

3. 你' 重塑现有代码

如果我已经执行并想改变结构, 之前 我开始 .

但'不是阶段 1. 那"MS K2"的阶段

真实真相

我就是这样工作的,我怀疑它是如何的 多数 开发者实际上正在工作#,}甚至连那些声称严格执行 DTD. 的人也工作过

因为创造力是乱七八糟的 . 学习是迭代的 . 理解源自于

你可以用无知来说明自己... .......

你必须造出东西来理解它

所以,我建造了它“(”阶段 “1),” 完善了它的“MS K2”阶段“MSC3” 然后关闭了“(”阶段(“3).”)

按此顺序,每时每刻 .

你知道什么? ?吗? 我船上的代码是很好的?

就像TDD的承诺 .

我刚经过另一条路到达那里 尊重创意工作如何真正发生

---

@I'}真心希望听到您在评论中的想法 @.}

这篇文章让你升起眉毛 , 非常好的! 意思是我们有适当的工程讨论