Rule/techno support matrix

Force usage of FetchType LAZY for collections on JPA entities

Avoid N+1 selects problem

Customer data must have end-of-life information

Persistence Java : Avoid Joints on non indexed columns

Calling a Spring repository inside a loop or a stream

The use of Spring repository in a loop or a stream induces unnecessary calculations by the CPU and therefore superfluous energy consumption.

Multiple if-else statements

Using too many conditional if-else statements will impact performance since JVM will have to compare the conditions. Prefer using a switch statement instead of multiple if-else if possible, or refactor your code to reduce conditonnal statements on the same variable. Switch statement has a performance advantage over if – else.

Getting the size of the collection in the loop

When iterating over any collection, fetch the size of the collection in advance to avoid fetching it on each iteration, this saves CPU cycles, and therefore consumes less power.

Use global variables

When using a global variable, the interpretation engine must check: 1) that it exists in the current scope, in the one above, etc. ; 2) the variable has a value; 3) …​ To avoid all these checks, it is often possible to pass the useful variables as arguments of routines, making them local. This process saves computational time (CPU cycles).

cnumr best practices (3rd edition) BP_050 (no longer exists in edition 4)

Usage of preparedStatement instead of Statement

SQL will only commit the query once, whereas if you used only one statement, it would commit the query every time and thus induce unnecessary calculations by the CPU and therefore superfluous energy consumption.

Rewrite native getter/setters

Overloading them lengthens the compilation and execution times of these methods, which are usually much better optimized by the language than by the developer.

cnumr best practices (3rd edition) BP_062 (no longer exists in edition 4)

No import all from library

ESLint key : @ecocode/no-import-all-from-library /// type : Common

Use unoptimized vector images

Less heavy SVG images using less bandwidth

cnumr best practices (3rd edition) BP_036

Call a DOM element multiple times without caching

ESLint key : @ecocode/no-multiple-access-dom-element /// type : Front-end

Modify several CSS properties all at once

ESLint key : @ecocode/no-multiple-style-changes /// type : Front-end

Prefer API collections with pagination

ESLint key : @ecocode/prefer-collections-with-pagination /// type : Back-end

The use of methods for basic operations

Using methods for basic operations consumes additional system resources. The interpreter must in effect and solve the objects and then the methods, just to carry out these simple operations of the language.

cnumr best practices (3rd edition) BP_048 (no longer exists in edition 4)

Limit the number of returns for a SQL query

ESLint key : @ecocode/limit-db-query-results /// type : Back-end

Do not use an image with empty source attribute

ESLint key : @ecocode/no-empty-image-src-attribute /// type : Front-end

Prefer shorthand CSS notations

ESLint key : @ecocode/prefer-shorthand-css-notations /// type : Front-end

Usage of system.arraycopy to copy arrays

Programs spend most of the time in loops. These can be resource consuming, especially when they integrate heavy processing (IO access). Moreover, the size of the data and processing inside the loops will not allow full use of hardware mechanisms such as the cache or compiler optimization mechanisms.

Optimize read file exceptions

Avoid usage of CSS animations

ESLint key : @ecocode/avoid-css-animations /// type : Front-end

Provide a print stylesheet

ESLint key : @ecocode/provide-print-css /// type : Front-end

Prefer lighter formats for image files

ESLint key : …​ /// type : …​

Initialize builder/buffer with the appropriate size

If you know in advance how many characters would be appended, initialize builder/buffer with the appropriate size. They will thus never have to be resized. This saves CPU cycles and therefore consumes less energy.

Using try…​catch calls (on File Not Found error)

When an exception is thrown, a variable (the exception itself) is created in the catch block and destroyed at the end of the block. Creating this variable and destroying it consumes CPU cycles and RAM unnecessarily. That is why it is important not to use this construction and to prefer, as much as possible, a logical test. This new rule replace old EC34 only for a particular use case (FileNotFoundException)

cnumr best practices (3rd edition) BP_047 (no longer exists in edition 4)

Avoid autoplay for videos and audio content

Autoplaying media consumes unnecessary energy, especially when users might not be actively engaging with the content.

cnumr best practices BP_4003

Use single quote (') instead of quotation mark (")

The shape using the quotation marks allows the developer to insert variables that will be substituted at run time. But if the string does not have a variable, use quotes instead. Thus, language will not look for variables to subtituture, which will reduce the consumption of CPU cycles.

cnumr best practices (3rd edition) BP_066 (no longer exists in edition 4)

Use the $i++ variable during an iteration

The $i form has the disadvantage of generating a tem-porary variable during incrementation, which is not the case with the $i form.

cnumr best practices (3rd edition) BP_067 (no longer exists in edition 4)

Calling a loop invariant function in a loop condition

Avoid calling loop invariant functions in loop conditions.

cnumr best practices (3rd edition) BP_069 (no longer exists in edition 4)

Perform an SQL query inside a loop

Servers are optimized to process multiple selections, insertions, or changes in a single query or transaction. consume CPU cycles, RAM, and bandwidth unnecessarily.

cnumr best practices (3rd edition) BP_072

Write SELECT * FROM

The database server must resolve the fields based on the schema. If you are familiar with the diagram, it is strongly recommended to name the fields.

cnumr best practices (3rd edition) BP_074 (no longer exists in edition 4)

Don’t concatenate strings in loops

Avoid repeated string allocations and consider using a StringBuilder instead.

Usage of static collections

Avoid usage of static collections. If you want to use static collections make them final and create for example a singleton if needed containing the collections. The static fields are more complicated for the Garbage Collector to manage and can lead to memory leaks.

Usage Pattern.compile() in a non-static context

Avoid using Pattern.compile() in a non-static context. This operation requires a non negligible amount of computational power, Using a single match saves CPU cycles and RAM consumption.

Const parameter in batch update

Don’t set const parameter in batch update ⇒ Put its in query. Creating this parameter and destroying it consumes CPU cycles and RAM unnecessarily.

Free resources

try-with-resources Statement needs to be implemented for any object that implements the AutoCloseable interface, it save computer resources.

Specify struct layouts

When possible, specify struct layouts to optimize their memory footprint

Make variable constant

A variable is never reassigned and can be made constant

Replace Enum ToString() with nameof

When no string format is applied, use nameof instead of ToString() for performance

Avoid async void methods

Use async Task methods instead, for performance, stability and testability

Make type sealed

Seal types that don’t need inheritance for performance reasons

GC.Collect should not be called

In most cases, the cost of calling GC.Collect far outweighs the benefits

Use collection indexer

Collection indexers should be used instead of Linq, when available

Dispose resource asynchronously

Resources that implement IAsyncDisposable should be disposed asynchronously

Avoid using function cache without limit

If a function has decorators without max size cache, the program will store unlimited data

Use Where before OrderBy

Filter elements before sorting them for improved efficiency

Use string.Length instead of comparison with empty string

Comparing a string to an empty string is unnecessary and can be replaced by a call to string.Length which is more performant and more readable.

Return Task directly

Consider returning a Task directly instead of a single await

Use orElseGet instead of orElse

Parameter of orElse() is evaluated, even when having a non-empty Optional. Supplier method of orElseGet passed as an argument is only executed when an Optional value isn’t present. Therefore, using orElseGet() will save computing time.

cnumr best practices (3rd edition) BP_042

Detect unoptimized file formats

When it is possible, to use svg format image over other image format

Avoid list comprehension in iterations

Use generator comprehension instead of list comprehension in for loop declaration

Use official social media sharing buttons

These JavaScript plugins are very resource-intensive: to work, they require a large number of requests and download heavy files. It is better to prefer direct links.

cnumr best practices (3rd edition) BP_019

Non-grouped similar CSS declarations

When multiple Document Object Model (DOM) elements have common CSS properties, declare them together in the same style sheet. This method reduces the weight of CSS.

cnumr best practices (3rd edition) BP_025

Non-standard fonts used

Prefer standard fonts, as they are already present on the user’s computer, so they do not need to download them. This saves bandwidth, while speeding up the display of the site.

cnumr best practices (3rd edition) BP_029

Non-outsourced CSS and Javascript

If you include CSS or JavaScript code in the body of the HTML file, while the HTML file is used by several pages (or even the entire site), this code must be transferred for each page requested by the user, which increases the volume of data transmitted.

cnumr best practices (3rd edition) BP_032

Resize images browser-side

Do not resize images using the HEIGHT and WIDTH attributes of the HTML code. This approach requires transferring these images to their original size, wasting bandwidth and CPU cycles.

cnumr best practices (3rd edition) BP_034

Modify the DOM when traversing it

Modifying the DOM (Document Object Model) as you traverse it can lead to situations where the loop becomes very resource-intensive, especially CPU cycles.

cnumr best practices (3rd edition) BP_041

Edit DOM elements to make it invisible

When an element of the Document Object Model (DOM) needs to be modified by several properties, each change in style or content will generate a repaint or reflow.

cnumr best practices (3rd edition) BP_042