This is a viewer only at the moment see the article on how this works.
To update the preview hit Ctrl-Alt-R (or ⌘-Alt-R on Mac) or Enter to refresh. The Save icon lets you save the markdown file to disk
This is a preview from the server running through my markdig pipeline
Wednesday, 19 November 2025
क्यों मैं पिछले परीक्षण लिख रहा हूँ, और क्यों आप इसका मतलब नहीं है कि
**कनवर्सेसन ले लो:**टेस्ट- अप विकास एक शानदार अभ्यास है जो सबसे सृजनात्मक कार्य के लिए गलत समस्या को हल करता है.
सॉफ्टवेयर बनाने के तीन चरण (कि वास्तव में काम करता है)
यह है कि मैं सॉफ्टवेयर का निर्माण कैसे है.
यह सरल है, यह प्रभावी है, और यह TDDED DDEDC को उनके buds को अनुकूल बनाता है:
काम करो.*बहुत सुंदर बनाओ.*जांच के साथ नीचे लॉक करें.
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
उस क्रम में.*हमेशा.*नहीं क्योंकि मैं आलसी हूँ.
नहीं क्योंकि मैं परीक्षण मूल्य नहीं है.
यह कैसे सृजनात्मक कार्य है वास्तव में होता है
जब आप एक समस्या स्थान की जाँच कर रहे हैं... ... आप अभी तक पूरी तरह से समझ नहीं आता.
जब आप एक समस्या स्थान की जाँच कर रहे हैं... ... आप अभी तक पूरी तरह से समझ नहीं आता.
आइए मैं आपको बताऊँ ।
यह गंदगी हिस्सा है.हिस्सा जहाँ मुझे पता नहीं है मैं क्या कर रहा हूँ.
मैं समझने की कोशिश कर रहा हूँ:
क्या यह एपीआई वास्तव में उस प्रकार काम करती है जिस प्रकार का दावा करता है?
क्या मैं भी मेरे पास औज़ारों के साथ इस समस्या को हल कर सकता हूँ?
"सही" इस संदर्भ में भी क्या मतलब है?*क्या यह दो घंटे की समस्या है या दो सप्ताह की समस्या है?*यह आविष्कार किया जाता है.
यह खोज रहा है.
यह ज़ैज है.
# 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
और तुम्हें पता है कि ज़ैज को क्या मारता है?**"पहले परीक्षण" अपने कंधे के ऊपर खड़ा किसी ने कहा.**क्यों कोई परीक्षण फिर भी नहीं?
क्योंकि*आकार अभी - भी द्रव होता है ।*कल्पना कीजिए कि आप एक सलाहकार हैं।
"मैं एक पक्षी को तराशना चाहता हूँ।"
अपने पंख की पंखियों को पारिभाषित करें.पंखों का कोण निर्दिष्ट करें.
"और ऐ अपराधियों! आज तुम छँटकर अलग हो जाओ*(या सॉफ्टवेयर लिखा जाता है, के रूप में यह जाता है.)*वास्तविक निर्माता
सबसे पहले रूप को किसी भी तरह से बाहर.वे चित्रित करते हैं.
वे लकीर बना देते हैं.*वे आम आकार खोजने के लिए पत्थर के बड़े टुकड़े दूर चिप.*केवल बाद में ही वे विवरणों को शुद्ध करते हैं ।
कोड वही है.
यह कोड है
निजी।
यह अपने आप के साथ एक बातचीत है.
यह मैं कैसे पता चला है कि "काम" का मतलब भी क्या है।
एक - दूसरे से हद - से - ज़्यादा की उम्मीद मत कीजिए ।
क्योंकि हर बार जब मैं जानता हूँ कि "रुको, यह पूरा तरीका गलत है," मुझे जाँच भी करनी होगी.
कि निराशर नहीं है.
उपवास न करने की स्वतंत्रता
# 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')
]
फेस 1 के बारे में है
// 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);
}
गति सीखना.
मुझे पता लगाने की जरूरत है कि तीसरी विशेष लाइब्रेरी मैंने सोचा था कि मैं इस्तेमाल करेंगे ... विज्ञापन के रूप में काफी नहीं है.मैं मैं हल कर रहा हूँ समस्या मैं नहीं है समस्या है पता करने की जरूरत हैकोना चाहिए*हल किया जा रहा है.*परीक्षण इस धीमी गति से.
इसलिये नहीं कि परखे जाने में धीमा है, परन्तु इसलिये कि
तो फिर मैं भावात्मक रूप से गलत बात में निवेश कर रहा हूँ.
सबसे अच्छा है तेजी से, अकेले में, किसी भी परीक्षण को बनाए रखने के लिए और कोई अहंकार की रक्षा करने के लिए नहीं."कार्य" का मतलब क्या है PROW1 में 1इसका मतलब है: "मैं भाग गया.
मैं यह कुछ इनपुट दिया.
# 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
)
इसमें ऐसे आउटपुट उत्पन्न हुए जो तर्कसंगत प्रतीत होते हैं ।
// 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();
मुझे लगता है 60% मुझे यकीन है कि अब समस्या समझ में आ गया है।"
यह बात है.**कोई किनारा मामलों.**कोई त्रुटि संभाल नहीं.
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
*बस एक जाल.*संकल्प का एक सबूत.
एक छवि।PRT 2: इसे सुंदर बनाते हैं (पुष्टि)
ठीक है, तो अब मैं समस्या को समझते हैं.मेरे पास कुछ है जो काम करता है, कम से कम खुश पथ के लिए.
अब मैं गुणवत्ता के बारे में परवाह शुरू कर सकते हैं.
पायथन उदाहरण:*C# उदाहरण:*बेहतर नाम.
एनोटेशन टाइप करें.*एक्सएमएल दस्तावेज़.*साफ LNONEQ.
आयत पर निशान लगाइए
अब मुझे पता है कि मैं वास्तव में इमारत क्या कर रहा हूँ पता है, मैं मूल आवश्यकताओं के लिए वापस जाना और सुनिश्चित करें कि मैं हल कर रहा हूँ
दाहिना
एकसमस्या.
अक्सर यह बिन्दुओं को प्रकट करता है:
"ओह, वे यह चाहता था नकारात्मक संख्या को अलग तरीके से संभालने के लिए."
अनुभव ।**पायथन:**C#:
बेहतर नामकरण।
क्यों फिर भी कोई परीक्षण नहीं?
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]
मैं अभी भी जाँच के लायक क्या है पता चला हूँ.
1, मैं नहीं जानता था कि यह समारोह भी अस्तित्व में होगा.फेस 2 में, मैं खोज रहा हूँ:"ओह, स्केल कारक नकारात्मक नहीं हो सकता.
"यदि सूची रिक्त है, हम खाली वापस करना चाहिए, कुछ नहीं."हम गैर-मेरिक मूल्यों को हल करने की जरूरत है।"
ये अन्तर्दृष्टिएँ
फिर उस वक्त (दुश्मन के) दिल में घुस जाते हैं
वे स्पष्ट नहीं कर रहे हैं.
कोड साफ है.*एपीआई समझ में आता है.*मैंने किनारे के मामलों को कवर किया है.
अब मैं जांच लिखता हूँ.
परीक्षणों के बहुत.
पूर्ण-रूप जांच के रूप में।क्यों?
क्योंकि
जाँच एक साझा यांत्रिकी है.वे अब मेरे लिए नहीं कर रहे हैं.
मैं पहले से ही इस कोड को अच्छी तरह से समझते हैं.
सीआई पाइपलाइन
(किस को रीग्रेसन को रोकने की जरूरत है)
भविष्य मेंटेनर
परीक्षण कर रहे हैंप्रस्तुतीकरणName
मेरे कार्यान्वयन के लिए.वे दस्तावेज़:
यह कोड क्या करता हैक्या इनपुट वैध हैंकौन - से आउटपुट की अपेक्षा करते हैं
मैं क्या यकीन कर रहा हूँ मैं कर रहा हूँ
पूर्ण आवरण, कोई समझौता नहीं
इस फ़ंक्शन को विश्वसनीय रूप से परिवर्धित करें
दस्तावेज़ीकरण के रूप में परीक्षण
एक्जीक्यूटेबल दस्तावेज.
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
**लेकिन मैं कोड साझा करने के लिए तैयार है पहले परीक्षण भी नहीं लिखते हैं.**चरण हैं:
निजी खोज(सिर्फ मुझे, कोई जांच नहीं)
निजी सुधार
(सिर्फ मुझे, अब भी कोई जांच नहीं) |-----|-------------| सार्वजनिक साझेदारी ( प्रमाणपत्र, सीआई, कोड समीक्षा, पूरी नौ गज की दूरी) यह दोनों मेरे सृजनात्मकता की रक्षा करता हैऔर | मेरी टीम की विवेक. क्यों यह बनाने की प्रवृत्ति की रक्षा करता है
सच है!लेकिन अगर आप पहले से ही जानते हैं कि आप क्या निर्माण कर रहे हैं।
जब मैं Pacent 1, में हूँ मैं रीफ्रेक्टर के लिए विश्वास की जरूरत नहीं है.
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
मैं सब कुछ दूर फेंक करने के लिए अनुमति की जरूरत है.
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
परीक्षण मनोवैज्ञानिक ऋण बनाने.
यहां तक कि अगर वे गलत बात की जाँच कर रहे हैं।जब तक जाँच खत्म नहीं हो जाती, तब तक 3, मैं 1 और 2 खड़े रहता हूँ
मनोवैज्ञानिक.
मैं कर सकते हैं:
समस्या का पता चला मैं हूँअसल मेंहल करना
यह कैसे सृजनात्मक काम करता है.
// 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 }));
}
तुम पहली बार अनुचित रूप से रंगका रंग.
आप विवरण के साथ शुरू नहीं है.
// 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);
}
}
यह किस तरह एग और एक्सपी के अनुरूप है (और जहाँ यह अश्वेत है)
यह ‘ बाद में विकास ’ नहीं है.
यह है
इकाई जाँच को जोड़ने के लिए गंभीर है.
एक्सपी अभ्यास मैं बनाए रखता है
हर सुविधा CI के माध्यम से जाता है इससे पहले कि
कोलाबरेशन सुधार डिजाइन को बेहतर बनाता हैसरल डिज़ाइन
फेस 2 है
रीफ्रेक्टरिंग
फेस 2 समर्पित रीफ्रेक्टिंग समय हैकोड साफ करेंपहले
**जाँच रीफ्रेक्टिंग की रक्षा करते हैं (पास 3+ में)**सख्त टी. वी.
टीडी कहता है:"पहले जाँच.
हमेशा.रेड-हर-पुंजर ही एकमात्र रास्ता है।
मैं कहता हूँ:" जाँच करो जब तुम्हें पता है कि तुम क्या परीक्षण कर रहे हैं.
Sep-R-R-RP- लॉक और अधिक प्राकृतिक है."
DBDB- 3-PapaparaphoreSTAREGTERTEARTEARYEARTEAL को पारिभाषित करता है
हर चीज के लिए अच्छी जांच पहली बार जाँच हर चीज के लिए सही समय पर जाँच करें
उचित समय (eeee) 3):
वही गुण परिणाम ।*आधा टुकड़ा.*यह मुस्कुराता है
"एक योजना के बाद परिवर्तन करने के लिए फिर. "टी. वी.
एक बार आप लिखित जाँच की है, आप मनोवैज्ञानिक रूप से उस डिजाइन के लिए सौंपा गया है.
यह हैअधिक
अलग - अलग जवाब: C# उदाहरण
ध्यान दीजिए?
तीन जाँच डिजाइन विकास के रूप में पुनः लिखना शुरू करते हैं ।
मान याद रखें:
फेस 1 सॉफ्टवेयर को काम करने के लिए हो जाता है
तेज
जब यह मदद करता है (पीव 2-3), अकेले में पता लगाइए जब यह नहीं होता (Peeep 1)
स्पेस के साथ फेस 2 संरेखित करता है
पश्चात
क्योंकि:
आप अभी तक किनारे के मामलों को नहीं पता थाआपने एक बेहतर एपीआई डिजाइन खोजाआप सुविधा की आवश्यकता नहीं थी
हर जाँच आप PRF1 में लिखते हैं संभवतः प्रयास बेकार है.
एक
3, जब आप वास्तव में जानते हैं कि आप क्या निर्माण कर रहे हैं के रूप में जाँच 3 में सेट, जांच के दौरान लिखने के लिए पहले से ही लिखें.**और सच मुच होने वाली (क़यामत)**टीडी वायदा:
"Write code that solves the specification.
Don't worry about perfection yet.
Just get it working."
" जाँच अपने डिजाइन ड्राइव!
अब मैं जांच और कोड दोनों फिर से लोड कर रहा हूँ."**यही कारण है कि डिजाइन नहीं है।**यही कारण है कि
गिलना.मेरा तरीका:
कार्यान्वयन के माध्यम से डिजाइन करें, तब इसे जाँच के साथ बंद करें.
"कोई परीक्षण नहीं"*" जहाज और प्रार्थना"*जब तक मैं Crat 3 के साथ काम कर रहा हूँ, मेरे कोड है:
चूके गए जाँच विस्तारकिनारा मामलों को हैंडल करें
एपीआई डिजाइन साफ करेंदस्तावेज़ीकरण (क्रिया जांच)
बिलकुल वैसी ही टीडी.
फर्क है
नियम सरल है:
- flake8 (style checking)
- pylint (code quality)
- mypy (type checking)
- black (formatting)
- radon (complexity analysis)
**कोई कोड 2 मुखंवर 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
कमिट कोडबिना जाँच के राजकुमार खोलेंCITo के बिना मुख्य में सम्मिलित करें
यह नया विचार नहीं है.यह कैसे सृष्टि कार्य हमेशा काम किया है:
पेंटर अंतिम ब्रश ब्रश के साथ शुरू नहीं करते।*वे:*स्केल्सस्वर (पावरी)
पेंट*परतों (पावरी 2)*वेनिशName
# 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)
"""
)
संरक्षित करने और वर्तमान (पीएसी) की रक्षा करने के लिए
वे:मसौदाMARIG (अथास १)
**Adrrices के लिए (पी. 3)**खुशी की बात है ।
किस तरह इस नक्शे को प्रिंट कोड पाइप में बदला जा सकता हैयहाँ है जहां यह दिलचस्प हो जाता है: मैं वास्तव में हैलागू किया
दिमाग में इस तत्त्वज्ञान (प्रयोगिक विकास) प्रणाली में।
सामान्य
समयबद्ध नहीं
उच्च सृजनात्मकता के साथ फिर से कोशिश करें (बड़ा तापमान)
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
एक और शक्तिशाली मॉडल की मिसाल पर गौर कीजिए
ठीक हैफेस 1.
इस चरण में कोई जाँच लिखी नहीं गयी है.कोड पीढ़ी प्रक्रिया में निजी है.
Rance में 2 चरण: निराशा की घड़ीएक बार जब कोड मूल चलाने के लिए चला जाता है, डिथरिंग की ओर चला जाता हैअनुकूलन.
(डिफ़ॉल्ट से दिखाता है)
यह हैठीक है
कोड अभी तक निजी नहीं है (जो अब तक रजिस्ट्री में नहीं है), लेकिन हम इसे तराश रहे हैं:बेहतर नाम
टाइप संकेतसाफ स्ट्रक्चर
निचला जटिलता
बेहतर प्रदर्शनइस आकार में अब पानी नहीं है ।
हम हम निर्माण क्या कर रहे हैं पता है.
इकाई जाँच.
जाँच कवरः*विशिष्ट उदाहरण (सहीता)*शीट 2 के दौरान किनारा मामलों का पता चला
परफ़ॉर्मेंस विशेषताएँ निर्धारित की गईं*तब,*सिर्फ तभी जब जांच हो
कोड है:
RAG मेमोरी
# 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]
जोड़ा गयानोड रजिस्ट्री:
भविष्य में काम करते वक्त
गुण अंक
© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.