apply requested changes

Author: cleophass

src/main/rules/GCI10/python/GCI10.asciidoc

@@ -40,10 +40,33 @@ SVG images generated by common drawing softwares contains unnecessary data: calc
 </svg>
 ----
 
-==== Context
+== Relevance Analysis
+
+The following results were obtained through local experiments.
+
+=== Configuration
+
+* SQLite Database: 5-6 GB
+* Processor: Intel(R) Core(TM) Ultra 5 135U, 2100 MHz, 12 cores, 14 logical processors
+* RAM: 16 GB
+* CO2 Emissions Measurement: Using CodeCarbon
+
+=== Context
 
 For example, by using SVGOMG, a tool for optimizing SVGs, we were able to reduce the file size from 22 KB to 11 KB, a 50% reduction. This is useful for page loading or data storage.
 
 image::image.png[]
 
-We decided to take some measurements using CodeCarbon. The emissions with the non-optimized file are 1.3928360831225074e-08, while the emissions with the optimized file are 9.68571752760373e-09, representing a 30% reduction in emissions.
+=== Test Execution
+
+For this analysis, we simulated a process of manipulating these SVG files. The objective was to measure the impact of file size on CO2 emissions. We used an "optimized" SVG file and a "non-optimized" SVG file. The modification consisted of changing certain parts of the SVG and saving the final result.
+
+=== Impact Analysis
+
+image::output.png[] 
+
+=== Conclusion
+
+The emissions with the non-optimized file are 1.3928360831225074e-08, while the emissions with the optimized file are 9.68571752760373e-09, representing a 30% reduction in emissions.
+
+We recommend incorporating file optimization techniques as part of our standard development practices and exploring additional opportunities to reduce the environmental impact of our digital products.

src/main/rules/GCI10/python/output.png

@@ -84,17 +84,18 @@ Or
 }
 ----
 
-
-==== Our Analysis
+== Relevance Analysis
 
 The following results were obtained through local experiments.
-===== Configuration
+
+=== Configuration
+
 * SQLite Database: 5-6 GB
 * Processor: Intel(R) Core(TM) Ultra 5 135U, 2100 MHz, 12 cores, 14 logical processors
 * RAM: 16 GB
 * CO2 Emissions Measurement: Using CodeCarbon
 
-===== Context
+=== Context
 
 This rule depends heavily on the context. For simple icon, the use of SVG is relevant because they will be lighter than their JPG counterparts. However, for more complex images, such as photographs, SVG will be heavier.
 
@@ -106,6 +107,6 @@ This is because the vector format is not suitable for details, it is suitable fo
 
 image::CNN_architecture.png[]
 
-==== References
+=== References
 https://www.tensorflow.org/tutorials/images/cnn?hl=fr
 https://www.researchgate.net/publication/373715986_Convolutional_Neural_Network_CNN_The_architecture_and_applications

src/main/rules/GCI203/python/GCI203.asciidoc

@@ -21,20 +21,30 @@ for var in (var2 for var2 in range(100)):
     ...
 ----
 
-== Our Analysis
+== Relevance Analysis
 
 The following results were obtained through local experiments.
 
 Credit : https://github.com/AghilesAzzoug
 
-=== Summary
-The use of generator expressions instead of list comprehensions in for-loops declaration can save RAM usage. It has multiple benefits like reducing CO2 emissions as well as releasing memory constraints on the hardware.
+=== Configuration
+
+12th Gen Intel Core I7-12700H
+16 Gb RAM (4800 Mhz)
+Windows 11 OS version 22H2
+Python 3.9.15
+memory_profiler==0.61.0 (for RAM experiments)
+codecarbon==2.1.4 (for CO2 emissions)
 
-=== Why it works?
+=== Context
+
+The use of generator expressions instead of list comprehensions in for-loops declaration can save RAM usage. It has multiple benefits like reducing CO2 emissions as well as releasing memory constraints on the hardware.
 Python generators resemble lazy lists from other programming languages: when iterated over, they compute their values on the fly. They lack some list behaviors (indexing, len method, ...) but are memory-efficient, as they do not store each of their values in memory, unlike lists. Thus, when declared in a for-loop declaration, list comprehensions can be safely replaced with generator expressions.
 For more details on list comprehensions vs generator expressions, see Python documentation.
 
-https://docs.python.org/3/howto/functional.html#generator-expressions-and-list-comprehensions
+
+=== Impact Analysis
+
 
 Local experiments* on list comprehensions vs generator comprehensions gives the following results on:
 
@@ -51,13 +61,12 @@ image::carbone.png[]
 
 For both metrics, the bigger the list, the greater is the gain is.
 
-*Specs for experimentations:*
+=== Conclusion
 
-12th Gen Intel Core I7-12700H
-16 Gb RAM (4800 Mhz)
-Windows 11 OS version 22H2
-Python 3.9.15
-memory_profiler==0.61.0 (for RAM experiments)
-codecarbon==2.1.4 (for CO2 emissions)
+Our analysis clearly demonstrates that replacing list comprehensions with generator expressions in Python for-loops offers substantial benefits in terms of both memory efficiency and environmental impact. As the data size increases, the advantages become increasingly significant.
+
+=== References
+
+Source: https://github.com/green-code-initiative/creedengo-rules-specifications/pull/152
 
-Source: https://github.com/green-code-initiative/creedengo-rules-specifications/pull/152
+https://docs.python.org/3/howto/functional.html#generator-expressions-and-list-comprehensions

src/main/rules/GCI404/python/GCI404.asciidoc

@@ -34,7 +34,7 @@ client.age # Récupérer l'attribut age
 client.age = 26 # Modifier l'attribut age
 ----
 
-== Our Analysis
+== Relevance Analysis
 
 The following results were obtained through local experiments.
 
@@ -67,9 +67,7 @@ class WithGetter():
 
 === Results
 image::tracking_1.png[]  
-Another representation of the results is shown below:
 
-image::tracking_2.png[]
 
 For 100,000,000 iterations, the difference in CO2 equivalent emissions is 3.7*10^-6, which corresponds to 17 mm in equivalent emissions of a thermal car (see converter).
 
@@ -82,6 +80,6 @@ Based on the results, we can conclude that using getters and setters in a class
 
 It is important to keep in mind that for security or control reasons, the use of getters and setters may be necessary. In such cases, using the @property decorator can be a good alternative to traditional getters and setters. It allows restricting access to the attribute and adding logic when the attribute is accessed or modified. Performance is better than recreating getter and setter methods but not as good as direct attribute access.
 
-== References
+=== References
 :hide-uri-scheme: 
 https://www.datacamp.com/tutorial/property-getters-setters

src/main/rules/GCI7/python/GCI7.asciidoc

@@ -23,44 +23,42 @@ def foo():
     ...
 
 ----
-==== Our Analysis
+== Relevance Analysis
 
 The following results were obtained through local experiments.
 
-===== Configuration
+=== Configuration
 * SQLite Database: 5-6 GB
 * Processor: Intel(R) Core(TM) Ultra 5 135U, 2100 MHz, 12 cores, 14 logical processors
 * RAM: 16 GB
 * CO2 Emissions Measurement: Using CodeCarbon
 
-===== Context
+=== Context
 
 This practice can significantly degrade performance, especially when processing large datasets or making repetitive database calls. By opting for batch processing instead of executing queries in loops, developers can improve overall system efficiency and reduce the carbon footprint of their applications.
 
-===== Test Execution
+=== Test Execution
 
 The performance analysis was conducted by executing 1000 queries for both the non-compliant and compliant solutions. For the non-compliant solution, each query was executed individually within a loop. For the compliant solution, a batch query with the same 1000 queries was executed.
 
-===== Impact Analysis
+=== Impact Analysis
 
 [cols="1,1,1", options="header"]
 |===
 |Metric |Compliant Solution |Non-compliant Solution
 |Execution Time (seconds) |0.13391780853271484 |124.80779719352722
 |Carbon Emissions (kg CO2 eq) |6.0358009465562945e-06 |9.932707807019985e-05
-|Car Equivalent (mm) |27 |414
+|Car Equivalent (mm)* |27 |414
 |===
-(see converter).
 
-:hide-uri-scheme: 
-https://impactco2.fr/outils/comparateur
+*Converter: https://impactco2.fr/outils/comparateur
 
-==== Conclusion
+=== Conclusion
 
 The performance analysis conducted in this study only measures the execution time and carbon emissions of the Python code executing the queries. It does not include emissions due to database processing. 
 
 The results show that the compliant solution, which avoids SQL queries in loops, is more efficient in terms of execution time and carbon emissions. By adopting batch query processing and avoiding queries in loops, developers can improve application performance and reduce their carbon footprint. Developers are encouraged to use batch query processing whenever possible to improve application performance.
 
-==== References
+=== References
 :hide-uri-scheme: 
 https://blogs.oracle.com/sql/post/avoid-writing-sql-inside-loops