Merge pull request #389 from cleophass/StringConcatenation

GCI105 StringConcatenation #Python #DLG #RulesSpecifications

Author: dedece35

CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- [#389](https://github.com/green-code-initiative/creedengo-rules-specifications/pull/389) Add a rule on Python String Concatenation
 - [#388](https://github.com/green-code-initiative/creedengo-rules-specifications/pull/388) Added rule GCI104 on Torch Tensor types
 - [#387](https://github.com/green-code-initiative/creedengo-rules-specifications/pull/387) Add rule GCI103, add specifications for a new rule on iteration method for dict in Python
 - [#386](https://github.com/green-code-initiative/creedengo-rules-specifications/pull/386) Add rule GCI102, recommending the use of pinned memory for the dataloader when transferring data from the CPU to the GPU.

RULES.md

@@ -81,6 +81,7 @@ Some are applicable for different technologies.
 | GCI102   | Use pinned memory on DataLoader when using GPU                                      | This rule applies to PyTorch data loading, where the use of pinned memory can significantly optimize data transfer between CPU and GPU.                                                                                                                                                                                                                                                                                       |                                                                                                                                                                                                                                               | 🚫   | 🚫  | 🚫 | 🚀     | 🚫   | 🚫 | 🚫   |
 | GCI103   | Don't use .items() to iterate over a dictionary when only keys or values are needed | Avoid using `.items()` if you only use the key or the value, as this creates an unnecessary tuple, leading to increased memory allocation and slower execution.                                                                                                                                                                                                                                                               |                                                                                                                                                                                                                                               | ❓    | ❓   | ❓  | 🚀     | ❓    | ❓  | ❓    |
 | GCI104   | DATA/AI PyTorch - Create tensors directly from Torch                                | In PyTorch, prefer creating tensors directly using `torch.rand`, `torch.tensor`, or other Torch methods instead of converting from NumPy arrays. Avoid using `torch.tensor(np.random.rand(...))` or similar patterns when the same result can be achieved directly with PyTorch.                                                                                                                                              |                                                                                                                                                                                                                                               | 🚫   | 🚫  | 🚫 | 🚀     | 🚫   | 🚫 | 🚫   |
+| GCI105   | Python String Concatenation                               | Python String Concatenation - Use Join Instead or f-Strings instead of +=                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                                                                         | 🚫   | 🚫  | 🚫 | 🚀   | 🚫  | 🚫 | 🚫   |
 | GCI203   | Detect unoptimized file formats                                                     | When it is possible, to use svg format image over other image format                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                               | 🚧   | 🚀  | 🚀 | ✅      | 🚀   | 🚀 | 🚫   |
 | GCI404   | Avoid list comprehension in iterations                                              | Use generator comprehension instead of list comprehension in for loop declaration                                                                                                                                                                                                                                                                                                                                             |                                                                                                                                                                                                                                               | 🚫   | 🚫  | 🚫 | ✅      | 🚫   | 🚫 | 🚫   |
 | GCI522   | Sobriety: Brightness Override                                                       | To avoid draining the battery, iOS and Android devices adapt the brightness of the screen depending on the environment light.                                                                                                                                                                                                                                                                                                 |                                                                                                                                                                                                                                               | 🚫   | 🚫  | ✅  | 🚫     | 🚫   | 🚫 | 🚫   |

src/main/rules/GCI105/GCI105.json

@@ -0,0 +1,17 @@
+{
+    "title": "Python String Concatenation - Use Join Instead or f-Strings instead of +=",
+    "type": "CODE_SMELL",
+    "status": "ready",
+    "remediation": {
+      "func": "Constant\/Issue",
+      "constantCost": "1min"
+    },
+    "tags": [
+      "creedengo",
+      "eco-design",
+      "performance",
+      "python",
+      "string"
+    ],
+    "defaultSeverity": "Minor"
+  }

src/main/rules/GCI105/python/GCI105.asciidoc

@@ -0,0 +1,69 @@
+With Python, concatenating strings with `+=` in a loop creates many intermediate strings, leading to high memory usage and performance degradation. Prefer using f-strings (formatted string literals) or `str.join()` for better performance and lower environmental impact.
+
+== Non Compliant Code Example
+
+[source,python]
+----
+city = "New York"
+street = "5th Avenue"
+zip_code = "10001"
+address = ""
+address += city + ", " + street + ", " + zip_code  # Noncompliant: inefficient string concatenation
+----
+
+In this example, the `+=` operation creates a new string object for each concatenation. When done repeatedly (e.g., in loops), this leads to excessive memory allocations and slower performance.
+
+== Compliant Solution
+
+[source,python]
+----
+# Using f-string for readability and performance
+city = "New York"
+street = "5th Avenue"
+zip_code = "10001"
+address = f"{city}, {street}, {zip_code}"  
+# or using str.join() for multiple string concatenations
+parts = ["New York", "5th Avenue", "10001"]
+address = ", ".join(parts)
+----
+
+These approaches avoid the repeated creation of new string objects. `str.join()` builds the final string in a single operation, and f-strings are compiled into efficient bytecode.
+
+== Relevance Analysis
+
+This rule applies to any Python application performing repeated or large-scale string concatenation (e.g., log generation, data serialization, HTML template generation).
+
+=== Configuration
+
+* Processor: Intel(R) Core(TM) Ultra 5 135U, 2100 MHz, 12 cores, 14 logical processors
+* RAM: 16 GB
+* CO2 Emissions Measurement: Using CodeCarbon
+
+=== Context
+
+Two string-building techniques were benchmarked:
+- **Non-compliant:** `+=` string concatenation in a loop
+- **Compliant:** `str.join()` or f-string formatting
+
+Metrics assessed:
+- Execution time
+- Carbon emissions
+
+=== Impact Analysis
+
+image::concat.png[]
+
+- *CO₂ Emissions:* Reduced by over **10×** when using `str.join()` instead of `+=`
+- *Energy Efficiency:* Significantly improved due to lower memory allocations and faster execution
+
+These results demonstrate that even small code patterns, like string concatenation, can have a measurable impact when scaled in production environments.
+
+== Conclusion
+
+Replacing `+=` in string concatenation with `f-strings` or `str.join()`:
+- Reduces memory overhead
+- Improves runtime performance
+- Decreases CO₂ emissions
+
+== References
+- https://wiki.python.org/moin/PythonSpeed/PerformanceTips