::: illustration ![](https://code-garage-strapi-bucket-production.cellar-c2.services.clever-cloud.com/nicolasbrondinbernard_A_computer_keyboard_in_a_forest_100_whit_468ee57d_c29a_4676_b15c_1aa2c10a96b8_9454acb348.png) ::: Let's start the practice with some good news: you already know how to make software more eco-responsible. !!! well Indeed, all it takes is **clean, simple, and efficient code.** !!! **Clean** code is code that is: - easy to **read** - easy to **understand** - easy to **maintain** > You can, for example, use **[a style guide](https://code-garage.fr/blog/guides-de-style-pour-javascript-incluant-google-github-airbnb)** combined with a *linter* to help you! But you can also familiarize yourself with concepts such as [AHA Programming](https://code-garage.fr/blog/decouvrir-le-concept-du-aha-programming) (Avoid Hasty Abstractions), which helps avoid the pitfalls of making code needlessly complex! In summary, eco-designed code is code **that follows good software development practices**, but what else is there? ### Algorithmic complexity We can also evaluate **the complexity of an algorithm** using **big-O** notation. **We won't go into the details** of calculating algorithmic complexity, but we have prepared [a dedicated article](https://code-garage.com/blog/comprendre-la-complexite-algorithmique) on the subject so you can fully understand it! Complexity allows us to **evaluate how the number of operations performed changes** based on the number of input elements in an algorithm. > This will influence the execution time and therefore the resources used. !!! well ![Change in the number of operations based on the number of elements (n)](https://code-garage-strapi-bucket-production.cellar-c2.services.clever-cloud.com/screen_bigocheatsheet_com_9c295ffcbc.jpg) Source of the chart !!! For example, let's take a function that must return the last element of a list, in two versions: * an implementation in **O(1)**, where **only one operation** is needed * an implementation in **O(n)**, where **as many operations are needed** as there are elements in the list !!! well Optimized version: ```js function getLastElement(list){ const lastIndex = list.length - 1; return list[lastIndex]; } ``` Unnecessarily complex version: ```js function getLastElement(list){ for(let i = 0 ; i < list.length ; i++){ if(i == list.length - 1){ return list[i]; } } } ``` !!! > The complex *O(n)* version means that a list of 100,000 elements **could result in up to 100,000 operations!** More complex code uses more resources, for a longer time, and **therefore causes more negative impacts on the environment.** To illustrate this, here are the results obtained with *[node-carbon](https://www.npmjs.com/package/node-carbon)* for these two functions, **with an array of one million values:** ``` ==== O(1) Function ==== ┌────────────────────────────────┬───────────────────┐ │ (index) │ Values │ ├────────────────────────────────┼───────────────────┤ │ CPU Usage (watts) │ 0 │ │ Total Time (s) │ 1 │ │ RSS Delta (Mb) │ 0 │ │ Heap Total Delta (Mb) │ 0 │ │ Heap Used Delta (Mb) │ 0.001007080078125 │ │ Carbon Consumption (gCO2e/kWh) │ 0 │ └────────────────────────────────┴───────────────────┘ ==== O(n) Function ==== ┌────────────────────────────────┬───────────────────────┐ │ (index) │ Values │ ├────────────────────────────────┼───────────────────────┤ │ CPU Usage (watts) │ 0 │ │ Total Time (s) │ 23 │ │ RSS Delta (Mb) │ 3.04296875 │ │ Heap Total Delta (Mb) │ 2.75 │ │ Heap Used Delta (Mb) │ 1.4202651977539062 │ │ Carbon Consumption (gCO2e/kWh) │ 0.0039304252278645835 │ └────────────────────────────────┴───────────────────────┘ ``` > We can clearly see that the O(1) function uses so few resources in such a short time **that the measurements are zero**. Which is not the case for its twin! ### The consumption of different languages There's one question that might still be on your mind: **which programming language should you use**? As shown by a 2017 study, **not all technologies consume the same amount of energy**: ![Comparison of the energy consumption of the C language compared to 26 others.](https://code-garage-strapi-bucket-production.cellar-c2.services.clever-cloud.com/resultat_etude_performance_energetique_langages_cdc22c16b9.jpg) (Source of the table) > Low-level, compiled languages clearly stand out in terms of performance. #### So should everything be done in C? That would mean forgetting a point mentioned earlier: **developing also pollutes!** So, **if you spend 10 times longer developing in C than in Java**, it probably won't be worth it from an eco-design perspective. Moreover, these languages require manual memory management, which leaves room for errors and sub-optimizations. This will *ultimately* consume more resources. > In summary, this is an interesting point to keep in mind But in practice, **prefer the language that fits the needs of the project** and that you are proficient in.