Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Raġunar għall-Kodiċi u d-Debugging

Lezzjoni 10 / 12 Aġġornat 2 ta’ Novembru 2026 Zviluppatur
F'din il-paġna
  1. Debugging: Problema ta’ Raġunar
  2. Debugging Klassiku
  3. Analiżi ta’ Kodiċi Kumplikat
  4. Debugging ta’ Żbalji Speċifiċi
  5. Arkitettura u Refactoring
  6. Mudell: Assistent għar-Reviżjoni tal-Kodiċi
  7. Small 4 jew Large 4 għall-Kodiċi?
  8. Punti Ewlenin

Lezzjoni aġġornata fit-2 ta’ Novembru, 2026. L-eżempji oriġinali kienu jużaw Magistral, li ġie rtirat fil-31 ta’ Lulju, 2026. Issa jsejħu lil Mistral Small 4 (mistral-small-2603) jew Mistral Large 4 (mistral-large-4-0) b’reasoning_effort="high", u jipproċessaw ir-risposta bl-użu tal-funzjoni separer mil-Lezzjoni 3. Sors: Reasoning (Dokumentazzjoni ta’ Mistral).

Debugging: Problema ta’ Raġunar

Għaliex il-debugging jibbenefika aktar mir-raġunar milli l-ġenerazzjoni tal-kodiċi? Għax il-ġenerazzjoni tal-kodiċi hija eżerċizzju ta’ rkupru—il-mudell ra miljuni ta’ funzjonijiet tas-sorting—filwaqt li d-debugging huwa eżerċizzju ta’ konfrontazzjoni. Trid iżżomm żewġ affarijiet f’moħħok fl-istess ħin: x’għandu jagħmel il-kodiċi u x’qed jagħmel attwalment, imbagħad issib id-differenza. Dan huwa eżattament it-tip ta’ kompitu fejn il-ħsieb qabel ma tweġib ibiddel ir-riżultat.

Insib bug huwa fundamentalment eżerċizzju ta’ raġunar. Trid tifhem l-intenzjoni, issegwi l-eżekuzzjoni, tidentifika d-diverġenza bejn l-imġiba mistennija u dik attwali, u tifformula soluzzjoni. Dan huwa preċiżament fejn ir-raġunar jagħmel id-differenza.

Debugging Klassiku

Innota l-forma tat-talba f’dan l-eżempju. Ma ngħidux “irranġa dan il-kodiċi”. Minflok, niddeskrivu s-sintomu—x’kien suppost jiġri kontra x’qed jiġri. Din hija l-istess dixxiplina li tuża ma’ kollega uman: dijanjożi li tibda mis-sintomu ssib il-kawża, filwaqt li “irranġa dan” mingħajr kuntest spiss tipproduċi riscrittura li tgħatti l-bug minflok ma ssolvih.

from mistralai.client import Mistral

client = Mistral(api_key="YOUR_API_KEY")

buggy_code = """
def merge_sorted_lists(list1, list2):
    result = []
    i = j = 0
    while i < len(list1) and j < len(list2):
        if list1[i] <= list2[j]:
            result.append(list1[i])
            i += 1
        else:
            result.append(list2[j])
            j += 1
    return result

# Test: merge_sorted_lists([1, 3, 5], [2, 4, 6])
# Expected result: [1, 2, 3, 4, 5, 6]
# Actual result: [1, 2, 3, 4, 5]
"""

response = client.chat.complete(
    model="mistral-small-2603",
    reasoning_effort="high",
    messages=[
        {"role": "system", "content": """Python debugging expert.
Method:
1. Trace execution mentally
2. Identify where behavior diverges
3. Explain the root cause
4. Propose a fix with a test"""},
        {"role": "user", "content": f"This code has a bug. Diagnose and fix it:\n\n{buggy_code}"}
    ],
)

Il-mudell se jidentifika li l-funzjoni tonqos milli tittratta l-elementi li jifdal wara ċ-ċiklu while (tonqos iż-żieda tad-denb list1[i:] u list2[j:]).

Analiżi ta’ Kodiċi Kumplikat

Il-fehim tal-kodiċi legacy huwa t-tieni każ ta’ użu ewlieni, u għandu proprjetà interessanti: it-traċċa tar-raġunar hija daqshekk prezzjuża kemm it-tweġiba. Billi taqra kif il-mudell rikostruwixxa l-loġika—liema ipoteżi għamel, liema verifiki wettaq—tikseb mappa tal-qari tal-kodiċi li spjegazzjoni finali sempliċi ma tistax tipprovdi.

complex_code = """
def process(data):
    cache = {}
    def helper(n, memo=cache):
        if n in memo:
            return memo[n]
        if n < 2:
            memo[n] = n
            return n
        result = helper(n-1) + helper(n-2)
        memo[n] = result
        return result

    return [helper(x) for x in data if isinstance(x, int) and x >= 0]
"""

response = client.chat.complete(
    model="mistral-small-2603",
    reasoning_effort="high",
    messages=[
        {"role": "user", "content": f"""Analyze this code in depth:
1. What exactly does it do?
2. Are there any potential issues?
3. How can it be improved?

{complex_code}"""}
    ]
)

Debugging ta’ Żbalji Speċifiċi

Żbalji fit-Tip (Type Errors)

type_error = """
TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'

Code:
def calculate_total(items):
    total = None
    for item in items:
        price = item.get('price')
        total = total + price
    return total
"""

response = client.chat.complete(
    model="mistral-small-2603",
    reasoning_effort="high",
    messages=[
        {"role": "user", "content": f"Explain this error and fix the code:\n\n{type_error}"}
    ]
)

Problemi tal-Prestazzjoni

slow_code = """
def find_duplicates(lst):
    duplicates = []
    for i in range(len(lst)):
        for j in range(i + 1, len(lst)):
            if lst[i] == lst[j] and lst[i] not in duplicates:
                duplicates.append(lst[i])
    return duplicates

# This code is very slow on large lists (100,000+ elements)
"""

response = client.chat.complete(
    model="mistral-small-2603",
    reasoning_effort="high",
    messages=[
        {"role": "system", "content": "Analyze the algorithmic complexity and propose an optimized version."},
        {"role": "user", "content": f"Optimize this code:\n\n{slow_code}"}
    ]
)

Arkitettura u Refactoring

Ir-raġunar japplika wkoll għall-għażliet arkitettoniċi:

architecture = """My Flask application has this structure:

app.py (2000 lines):
- API routes (20 endpoints)
- Business logic
- Database access
- Data validation
- Error handling

How should I restructure this application?"""

response = client.chat.complete(
    model="mistral-small-2603",
    reasoning_effort="high",
    messages=[
        {"role": "system", "content": """Senior software architect.
Reason through SOLID principles, separation of concerns,
and long-term maintainability."""},
        {"role": "user", "content": architecture}
    ],
)

Mudell: Assistent għar-Reviżjoni tal-Kodiċi

Għaqqad ir-raġunar ma’ analiżi sistematika:

def code_review(client, code, language="python"):
    """Performs an in-depth code review with reasoning."""

    review_prompt = f"""Perform a detailed code review of this {language} code.

Systematically analyze:
1. **Correctness**: Does the code do what it is supposed to do?
2. **Edge cases**: Are edge cases handled (None, empty, negative)?
3. **Performance**: What is the complexity? Is it optimal?
4. **Readability**: Is the code clear and well-named?
5. **Security**: Are there vulnerabilities (injection, XSS, etc.)?

For each issue found, indicate:
- The line number
- The severity (critical / major / minor)
- The recommended fix

Code to review:
```{language}
{code}
```"""

    response = client.chat.complete(
        model="mistral-small-2603",
        reasoning_effort="high",
        messages=[{"role": "user", "content": review_prompt}]
    )

    return separer(response.choices[0].message.content)[1]  # the answer, without the reasoning

Small 4 jew Large 4 għall-Kodiċi?

Għad-debugging u l-analiżi tal-kodiċi, l-għażla bejn iż-żewġ approċċi tiddependi fuq il-fond tal-problema. Bug sempliċi—żball fis-sintassi, eċċezzjoni espliċita, ottimizzazzjoni ovvja—jiġi ttrattat tajjeb ħafna minn Mistral Small 4 (mistral-small-2603) b’reasoning_effort="high" b’kost modest ta’ tokens. Iżżomm lil Mistral Large 4 (mistral-large-4-0, f’Public Preview) għal każijiet fejn il-kawża mhix viżibbli fil-kodiċi nnifsu: analiżi arkitettoniċi, bugs sottili bħal kundizzjonijiet ta’ tiġrija (race conditions) jew tnixxijiet tal-memorja li jidhru biss fil-produzzjoni, u reviżjonijiet kumplessi tal-kodiċi fejn trid tibbilanċja l-korrettezza, il-prestazzjoni u s-sigurtà.

# Simple bug: Small is sufficient
simple_bug = "why does 'hello'.split('')[0] raise an error?"
response = client.chat.complete(
    model="mistral-small-2603",
    messages=[{"role": "user", "content": simple_bug}],
    reasoning_effort="high"
)

# Complex bug: Large 4, evaluate on your own cases
complex_bug = "My Django application has a memory leak in production that does not appear in dev..."
response = client.chat.complete(
    model="mistral-large-4-0",
    reasoning_effort="high",
    messages=[{"role": "user", "content": complex_bug}]
)

Punti Ewlenin

  • Id-debugging huwa eżerċizzju ta’ raġunar ideali għal reasoning_effort="high"
  • Iggwida lill-mudell b’prompt tas-sistema li jistruttura l-metodu dijanjostiku
  • Ir-raġunar jispikka fuq bugs sottili, analiżi tal-prestazzjoni, u arkitettura
  • Small 4 fil-modalità high huwa biżżejjed għal bugs komuni; evalwa Large 4 fuq bugs sottili u arkitettura
  • Għaqqad ir-raġunar ma’ reviżjoni sistematika tal-kodiċi biex timmassimizza l-kwalità
  • Dejjem itlob test ta’ verifika mas-soluzzjoni proposta