[Python] Invalidation of rule GCI75 (String concatenation in loops): Massive memory overhead of .join()

[harag7810]

Context:
Rule GCI75 (Don't concatenate strings in loops) is currently pending analysis for Python in the RULES.md file.
The description of this rule recommends avoiding repeated memory allocations by using a StringBuilder object. Since a StringBuilder does not exist natively in Python, we simulated its behavior using the standard equivalent best practice: accumulating text chunks in a list (mutable array), followed by a final assembly using "".join().
Our team (Les Buzz du decollage permanent) conducted a comprehensive benchmark to verify if this alternative provided a real ecological benefit (CPU and RAM) compared to the += operator.

Test Protocol:
We scripted a stress-test comparing += and our StringBuilder simulator (.join()) on loops of different sizes (10k, 100k, and 1 million iterations).
Speed (timeit): Execution time measurement (Garbage Collector disabled to isolate raw compute time).
Memory (tracemalloc): Measurement of the peak allocated RAM.

Benchmark Results:

Analysis:
While our alternative using .join() is indeed slightly faster (marginal CPU gain), it results in a RAM overconsumption of nearly 300% compared to +=.

Conclusion & Recommendation:
Just as this rule was rejected for Java (JDK 8 optimizations making it obsolete), CPython's internal optimizations make it counterproductive in Python regarding RAM sobriety.

Required Action:
I propose changing the status of rule GCI75 from pending to Not applicable for Python in the RULES.md file and closing any related implementations.

[B3ND3L]

Hi @harag7810, thanks for the suggestion.

I'm not sure to agree with you about this point. Can you give me your code ? I did the measurement with : https://github.com/green-code-initiative/EnergyTracer and I don't have the same results.

Energy Report

984 samples (with smell) vs 966 samples (without smell) — α = 0.05

Instance Info

• os: Linux 6.17.0-35-generic
• machine: x86_64
• chip: Intel(R) Core(TM) Ultra 7 255H

Code :

Code with smell

  def text():
    text = ""
    for i in range(1000000):
        text += "code-smell-"
    return text

text()

Code without smell

def text():
    chunk = []
    for i in range(100000):
        chunk.append("code-smell-")
    return "".join(chunk)
text()

Global Consumption

Metric	With smell	Without smell
Execution Time	24.18 ms	0.95 ms
Average Power	27.018 W	52.373 W
Total Energy	642.82 J	48.28 J

The total energy is the sum of measurements across all iterations, converted to joules (J). If you ran the ./run_experiment.sh script, this reflects the cumulative energy of all 30 iterations of the process.

Statistical Analysis

Metric	Δ mean	p-value	Cohen’s d	Effect	Sig.
cpu_mj	+92.23%	0.00e+00	+28.113	large	✅
co2_eq	+92.15%	0.00e+00	+28.090	large	✅
dram_mj	+92.13%	0.00e+00	+28.083	large	✅
time_s	+95.95%	0.00e+00	+29.281	large	✅

Verdict

Removing the code smell leads to measurable energy differences:

• cpu_mj: 92.2% lower energy (Cohen’s d = +28.113, large)
• co2_eq: 92.2% lower energy (Cohen’s d = +28.090, large)
• dram_mj: 92.1% lower energy (Cohen’s d = +28.083, large)
• time_s: 96.0% lower time (Cohen’s d = +29.281, large)

Δ mean = (mean_with − mean_without) / mean_with × 100. Positive → the smell consumes more energy.