OpenLLM-France/wikimedia huggingface dataset:
# Wikigreen

Bienvenue sur WikiGreen, le site collaboratif pour développer l'écologie dans la vie de tous les jours !
Pourquoi participer à WikiGreen ? - Comment entrer dans WikiGreen ? - Lien vers l'espace de partage de la communauté

## Participer à Wikigreen

Comment se déroule un atelier ouvert ?
* environ chaque mois, une rencontre Wikigreen est proposée à celles et ceux qui sont inscrits sur la liste.
* l'invitation à la rencontre contient : un thème, une date, une heure de rendez-vous à distance, un lien Zoom pour se réunir à distance, et une heure de fin de rencontre.
* l'objectif de la rencontre est l'échange sur le thème du jour, et la production d'un petit guide des résultats produits, qui sera publié sur le site Wikigreen.
WikiGreen s'efforce de traiter les différents sujets de la façon la plus facile possible. La participation collective permet la multiplicité des points de vue, et les témoignages peuvent aborder les sujets de façon contradictoire. L'addition et la multiplication des idées permettent de faciliter les choix écologiques de chacun.
Prochain Atelier ouvert le 5 février 2022 : nous nous intéresserons au thème de la motivation écologique au quotidien.

### Sujets transversaux

* Entretenir sa motivation écologique
* Le Comptage Carbone
* Engagement des retraités pour le climat

### Alimentation

* Une alimentation bas-carbone
* La déshydratation des aliments

### Mobilité

* Le véhicule électrique

### Logement

* La lessive
* La vaisselle
* Jardinage écologique
* L'électricité verte
* Le compost
* Le compost en ville
* La vie en co-habitat

### Consommation

* Le savon
* Noël écologique

## Pourquoi participer à WikiGreen ?

Être écologique dans sa vie de tous les jours? 🙄 Pas simple😕
Nous sommes bien peu à agir pour que les résultats concrets se voient, et se sentir seul, c'est démotivant.
Pourtant, nous sommes très nombreux à avoir expérimenté de nouvelles façons de faire, plus écologiques, dans notre vie quotidienne !
Ici, nous pouvons partager tous nos "trucs", et les regrouper dans ce site collaboratif, qui témoigne de l'énergie que des femmes et des hommes mettent dans le changement écologique au quotidien.
Nous pouvons nous entraider, nous épauler, maintenir une motivation collective, en parler autour de nous et diffuser les solutions pratiques, économiques, éprouvées, sympas... et utiles à grande échelle.
Lorsque 20% des gens adoptent définitivement un changement, le reste de la société suit. C'est le point de bascule. Il est donc à la portée de tous d'agir au quotidien pour participer à infléchir la courbe du réchauffement climatique et la dégradation des écosystèmes.
Les membres de WikiGreen peuvent participer à un défi commun contre la crise écologique : proposer des sujets, et rassembler toutes les solutions concrètes que l'on peut adopter chez soi, pour les expérimenter et les optimiser 😀😃😄😉🙂🤗
Pour s'inscrire à la liste d'échange WikiGreen : cliquez ici
Lien vers l'espace de partage de Wikigreen
# Wikigreen/Engagement des retraités pour le climat
## Foire aux questions

* Trente, quarante ans et plus possibles en situation de retraite, ce peut être l'opportunité d'une nouvelle carrière choisie, apprise et consacrée aux enjeux du climat ! Qu'en pensez vous ? Voulez vous en discuter ?
* Existe-t-il une notion d'engagement inter-relationnel ? Si oui, pourrait-elle concerner le débat sur le climat ?
* Comment faciliter la sensibilisation à l'environnement entre grands-parents et petits-enfants ? Qui sensibilise qui ?
# Wikigreen/Entretenir sa motivation écologique

Article produit lors de la rencontre Wikigreen du 5 février 2022.

## Les étapes de la motivation

Pour être motivé, il faut :
* un besoin particulier
* une incitation à passer à l'action
* passer à l'action
* Être satisfait de son action
Si une étape manque, il est très difficile de conserver sa motivation.
Voici les sources de motivation que nous avons identifiées lors de la rencontre :

## Envie de changer la société

* Imaginer que mes enfants, mes petits-enfants (et arrières...) vivent bien demain
* Être respectueux et responsable
* Être un "bon citoyen"
* Ne faire de mal à personne (humains, animaux, nature)
* Contribuer à décarboner le monde
* se reconnecter aux choses simples et à la terre, retrouver les savoirs de nos ancêtres

## Anticiper dans un monde qui change

* Augmenter son autonomie :énergétique, alimentaire...
* S'adapter au monde futur
* Faire ce que je peux pour limiter la catastrophe

## Être bien et s'occuper de son bien-être

* Prendre plaisir à faire du bien
* Protéger sa santé
* Vivre de façon saine
* Être fier de ce que l'on a fait

## Échanger, partager

* Se mettre en lien avec d'autres personnes pour un objectif commun
* S'organiser avec ses proches pour une vie meilleure
* Parler de ses progrès avec ceux qu’on aime

## Apprécier ses résultats

* Compter ses propres résultats (réduction des kilomètres en voiture, baisse de la consommation énergétique...)
* Avancer concrètement à petit pas pour ne pas se décourager
* Viser la progression, la réussite de son objectif
* S'offrir une petite récompense pour avoir atteint son objectif
# Wikigreen/Espace de partage/Liste des ressources méthodologiques

Les ressources méthodologiques proviennent de Jean-Michel Cornu, spécialiste de l'intelligence collective, et de sa méthode des communautés de projets.
* Pour tous les abonnés à WikiGreen, à quoi sert la liste d'échange : https://www.innovation-pedagogique.fr/article8259.html
* Pour comprendre comment susciter de l'intelligence collective dans les grands groupes : https://www.innovation-pedagogique.fr/article8578.html
* La méthode des "petits pas" : http://cornu.viabloga.com/cgi-bin/display_index.pl
# Wikigreen/Espace de partage WikiGreen

Retour vers la page d'accueil WikiGreen

### Bienvenue dans l'espace de partage de WikiGreen !
## Comment s'inscrire et se désinscrire à la communauté WikiGreen

L'inscription à la liste d'échange WikiGreen est libre et, bien sûr, gratuite.
Votre adresse mail ne sera jamais utilisée pour autre chose que Wikigreen.
S'inscrire permet d'être informé.e des rencontres en ligne, et, si vous le souhaitez, participer à ces rencontres : une fois tous les mois environ, des échanges sur un thème (durée : 1h15) et la production en direct d'un article utile à tous, qui sera publié sur le site.
Pour s'inscrire : https://framalistes.org/sympa/subscribe/wikigreen
Pour se désinscrire : https://framalistes.org/sympa/sigrequest/wikigreen

## Prochaine rencontre Wikigreen :

* La prochaine rencontre Wikigreen aura lieu le samedi 5 février de 11h à 12h15.

## Membres fondateurs de WikiGreen

WikiGreen a été créé le 28 novembre 2020 par un noyau de départ, selon la méthode des communautés de projets diffusée par Jean-Michel Cornu.
Les membres du noyau de départ :
* Dominique Clerc
* Thomas Breniere
* Anne Hétier
* Dorothée Reinhardt
* Anaëlle Rollin
* Gwendoline Marshal-Clerc
* Géraldine Maldera
* François Michel
* Véronique Bailly

## Contact du facilitateur

dominique@solastalgie-merci.fr
Contactez-moi pour toute question sur WikiGreen, à laquelle vous n'auriez pas trouvé de réponse dans cette page.
# Wikigreen/Jardinage écologique
## Foire aux questions

* Comment réussir a harmoniser toutes les démarches
* Comment Concilier travail et jardinage quand on a pas de temps
* Comment faire un bon compost (car tout n'est pas encore parfait)
* Quelle est la meilleure méthode de culture bio pour chaque région
* Quelles sont les bonnes associations afin d'éviter les nuisibles
* Doit on garder les mauvaises herbes et lesquelles
* Quelles sont les plantes que l'on pense nuisibles et comment les utiliser
* Comment traiter naturellement les maladies des arbres fruitiers , agrumes, légumes...etc
* Comment se faire aider par les auxiliaires ( coccinelles, plantes...)?
* Choix des plantations ( herbes aromatiques près de la maison par exemple)
* Échanges de graines, de cultures à partager

## L'utilisation du compost

Un chapitre Wikigreen est consacré au compost : Wikigreen/le-compost
# Programmation VBScript/Objets

* Introduction
* Opérateurs
* Fonctions
* Objets
* Constantes
* Codes d'erreur
* Application
* Introduction
* Opérateurs
* Fonctions
* Objets
* Constantes
* Codes d'erreur
* Application
[ Modifier le sommaire ]
       Description
       Helpcontext
       Helpfile
       Number
       Source
       Clear
       Raise(nbr,src,desc,hlpf,hlpcontext)
       Global
       IgnoreCase
       Pattern
       Execute(string)
       Replace(string1,string2)
       Test(string)
       FirstIndex
       Length
       Value
       Count
       Item(key)
       Count
       Item(key)
# Programmation Visual Basic .NET

Visual Basic .NET est un langage de programmation inspiré de Visual Basic 6 et utilisant le framework .Net.
* La lecture préalable de Programmation VBA est conseillée.
* La lecture préalable de Programmation orientée objet est conseillée.
    Terminé
* Une version imprimable du livre « Programmation Visual Basic .NET » est disponible. (voir/ modifier)
* Une version PDF de ce livre est disponible.

## Sommaire

* Introduction
* Visual Studio
* Premier script

### Bases du langage

* Variables
* Tableaux
* Conditions
* Boucles

### Opérateurs

* Assignation et comparaison
* Arithmétique
* Chaines de caractères
* Logique
* Gestion d'exception

### Programmation orientée objet

* Classes
* Namespaces
* Héritage
* Interfaces
** L'interface IDisposable

### Structure de données avancée

* Contrôles
* Énumérations
* Collections
* GDI+
# Programmation VBScript/Introduction

* Introduction
* Opérateurs
* Fonctions
* Objets
* Constantes
* Codes d'erreur
* Application
* Introduction
* Opérateurs
* Fonctions
* Objets
* Constantes
* Codes d'erreur
* Application
[ Modifier le sommaire ]
Le langage VBScript ou VBS (pour Visual Basic Script) est un langage de programmation de la famille (visual) basic, destiné à être interprété. Il est dépendant du logiciel Windows Script Host (WSH) exclusivement fourni par Microsoft.
On donne aux scripts logiciels écrits dans ce langage, par convention, un nom qui se termine par .vbs. Le fait que le langage est un langage de script exécuté par un interpréteur signifie que le programme est exécuté sans compilation manuelle en fichier binaire. Le fait que l’interpréteur soit associé au suffixe vbs dans Windows rend le fichier directement exécutable sur double-clic depuis l'explorateur de Windows.
Comme le logiciel supporte plusieurs langages de programmation, il est utile d'indiquer sur une ligne le langage de programmation utilisé. Configuration HTML :
* Sur client : < script langage="VBScript" />
* Sur serveur : <% script langage="VBScript" %>
# Programmation VBScript/Opérateurs

* Introduction
* Opérateurs
* Fonctions
* Objets
* Constantes
* Codes d'erreur
* Application
* Introduction
* Opérateurs
* Fonctions
* Objets
* Constantes
* Codes d'erreur
* Application
[ Modifier le sommaire ]
| + | addition |
| - | soustraction |
| * | multiplication |
| ^ | puissance |
| / | division à float |
| \ | division entière |
| mod | modulo - reste de la division entière |
| < | plus petit |
| <= | plus petit ou égal |
| > | plus grand |
| >= | plus grand ou égal |
| <> | différent |
| not | non logique |
| and | et logique |
| or | ou logique |
| xor | xor logique |
| eqv | equivalence |
| imp | implication |
| & | concaténation |

## Déclarations

* LÉGENDE
    src - source
    nm - nom
    var - variable
    expr - expression
    ins - instruction
    arg - argument
    cond - condition
* Déclaration
    option explicit - force déclaration de toutes variables dans scr
    dim nm(src) - variable
    redim [preserve] var(src)
    const nm=expr - constante
* Procédure - execute instructions
    sub nm(arg1,arg2,...)
       [ins]
       [exit sub]
       [ins]
    end sub
* Fonction - retourne une valeur en sortie à nm
    function nm(arg1,arg2,...)
       [ins]
       [nm=expr]
       [exit function]
       [ins]
       [nm=expr]
    end function
* Get - comme fonction simple
    property get nm(arg1,arg2,...) as [type]
       [ins]
       [nm=expr]
    end property
* Let - comme fonction simple
    property let nm(arg1,arg2,...)
       [ins]
    end property
* Set - comme fonction simple
    property set nm(arg1,arg2,...)
       [ins]
    end property
* Classe - retourne initialize || terminate
    class ClassName
          [var]
       Private Sub Class_Initialize
          [ins]
       End Sub
       Private Sub Class_Terminate
          [ins]
       End Sub
       Public Function NomMethode([arg])
          [ins]
       End Function
    end Class
nota : const/sub/function/property sont déclarables en [public [default] | private]
Exemple 1
Exemple 2

## Instructions de contrôle

* TEST
* BOUCLE
* APPELS
* ERREURS
* REMARQUES
* AFFECTATION DE REFERENCES
* ASSOCIATION DE REFERENCE
# Programmation VBScript/Sommaire

* Introduction
* Opérateurs
* Fonctions
* Objets
* Constantes
* Codes d'erreur
* Application
# Programmation Visual Basic .NET/Arithmétique

* Introduction
* Visual Studio
* Premier script

## Bases du langage

* Variables
* Tableaux
* Conditions
* Boucles

## Opérateurs

* Assignation et comparaison
* Arithmétique
* Chaines de caractères
* Logique
* Gestion d'exception

## Programmation orientée objet

* Classes
* Namespaces
* Héritage
* Interfaces
** L'interface IDisposable

## Structure de données avancée

* Contrôles
* Énumérations
* Collections
* GDI+
* Introduction
* Visual Studio
* Premier script

## Bases du langage

* Variables
* Tableaux
* Conditions
* Boucles

## Opérateurs

* Assignation et comparaison
* Arithmétique
* Chaines de caractères
* Logique
* Gestion d'exception

## Programmation orientée objet

* Classes
* Namespaces
* Héritage
* Interfaces
** L'interface IDisposable

## Structure de données avancée

* Contrôles
* Énumérations
* Collections
* GDI+
[ Modifier le sommaire ]

## Opérateurs arithmétiques

Visual Basic .NET fournit différent opérateurs arithmétiques :
Exemple (le séparateur décimal est le point contrairement en français où on utilise la virgule) :
Remarque : ces symboles sont les mêmes que dans la calculatrice scientifique Windows.

### Addition

L'opérateur "+=" incrémente la variable d'une valeur donnée :
Il fonctionne aussi en concaténation :

### Soustraction

"-" soustrait deux nombres :

### Multiplication

Le symbole est l'étoile :

### Division

Il existe plusieurs types de divisions.

#### Division standard

Opérateur "/" :

#### Division entière

Si le type ne le permet pas, l'opérateur "/" arrondit à l'inférieur : il fournir le résultat de la division sans le reste :

#### Modulo

Cet opérateur fourni le reste de la division :

### Exponentiation

L'opérateur "^" élève un nombre à une puissance :
Si la puissance est de 0,5 il peut aussi servir à calculer la racine carré d'un nombre :
Attention aux types des variables :
La racine Nième se calcule donc généralement ainsi :
Car $x^{\frac {1}{n}}={\sqrt[{n}]{x}}$.

## Arrondis

* Round : arrondit à l'entier le plus proche.
* Floor : arrondit à l'inférieur.
* Ceiling : arrondit au supérieur.
* Truncate : tronque les chiffres décimaux.
* isNaN : not a number, si ce n'est pas un nombre.
Remarque : avec Imports Math, plus besoin d'appeler ces fonctions avec ce préfixe.

## Comparaisons

* Max
* Min

## Autres

* Abs : valeur absolue.
* Pow : puissance.
* Sqrt : racine carrée (square root).
# Programmation Visual Basic .NET/Assignation et comparaison

* Introduction
* Visual Studio
* Premier script

## Bases du langage

* Variables
* Tableaux
* Conditions
* Boucles

## Opérateurs

* Assignation et comparaison
* Arithmétique
* Chaines de caractères
* Logique
* Gestion d'exception

## Programmation orientée objet

* Classes
* Namespaces
* Héritage
* Interfaces
** L'interface IDisposable

## Structure de données avancée

* Contrôles
* Énumérations
* Collections
* GDI+
* Introduction
* Visual Studio
* Premier script

## Bases du langage

* Variables
* Tableaux
* Conditions
* Boucles

## Opérateurs

* Assignation et comparaison
* Arithmétique
* Chaines de caractères
* Logique
* Gestion d'exception

## Programmation orientée objet

* Classes
* Namespaces
* Héritage
* Interfaces
** L'interface IDisposable

## Structure de données avancée

* Contrôles
* Énumérations
* Collections
* GDI+
[ Modifier le sommaire ]

## Assignation

L'opérateur "=" sert pour l'affectation et la comparaison.
Pour définir une variable :

## Comparaison

Pour comparer deux valeurs (constantes ou variables) :
Cas particulier : plusieurs signes égaux consécutifs :
Le second opérateur sera exécuté en premier, renvoyant False, puis l'assignation de x à False.
# Programmation Visual Basic .NET/Boucles

* Introduction
* Visual Studio
* Premier script

## Bases du langage

* Variables
* Tableaux
* Conditions
* Boucles

## Opérateurs

* Assignation et comparaison
* Arithmétique
* Chaines de caractères
* Logique
* Gestion d'exception

## Programmation orientée objet

* Classes
* Namespaces
* Héritage
* Interfaces
** L'interface IDisposable

## Structure de données avancée

* Contrôles
* Énumérations
* Collections
* GDI+
* Introduction
* Visual Studio
* Premier script

## Bases du langage

* Variables
* Tableaux
* Conditions
* Boucles

## Opérateurs

* Assignation et comparaison
* Arithmétique
* Chaines de caractères
* Logique
* Gestion d'exception

## Programmation orientée objet

* Classes
* Namespaces
* Héritage
* Interfaces
** L'interface IDisposable

## Structure de données avancée

* Contrôles
* Énumérations
* Collections
* GDI+
[ Modifier le sommaire ]
Il existe plusieurs structures de boucles en VB.NET.

## Boucle Do...Loop Until

Un Do...Loop Until est une boucle qui itère tant que sa condition de sortie est fausse, cette dernière est testée à chaque fin de boucle, donc le programme y passe forcément au moins une fois.

## Boucle Do...Loop While

Une boucle Do...Loop While tourne tant que sa condition d'itération est vraie, cette dernière est testée à chaque fin de boucle, donc le programme y passe forcément au moins une fois.

## Boucle Do Until...Loop

Un Do Until...Loop est une boucle qui itère tant que sa condition de sortie est fausse (comme Do Until...Loop), cette dernière est testée à chaque début de boucle, donc le programme n'y passe pas forcément.

## Boucle Do While...Loop

De la même manière, Do While...Loop tourne tant que sa condition d'itération est vraie (comme Do Until...Loop) et la teste en amont de chaque boucle.

## Boucle For

Une boucle For s'exécute un certain nombre de fois, relativement prédéfinie car la valeur du compteur peut changer en cours de route.
Cet exemple s'exécute 10 fois, a = 1, puis 2... puis 10.
Pour changer le sens du compteur :
S'exécute aussi 10 fois, mais a = 10, puis 9... puis 1.
Remarque : à tout moment il est possible de sortir de la boucle sans attendre sa fin avec Exit for.

## Boucle For Each

Une boucle For Each itère pour chaque entrée d'un tableau ou autre objet itérable, qui doit implémenter les interfaces IEnumerable ou IEnumerator. L'implémentation de IList par Array autorise un tableau à être utilisé comme un objet, car IList hérite de IEnumerable.
# Programmation POSIX/Ressources

Processus
* Processus
* Processus légers
* Signaux
Fichiers
* Lecture et écriture
* Verrouillage
* Tubes
* Opérations sur les fichiers
Annexes
* Index
* Ressources
Processus
* Processus
* Processus légers
* Signaux
Fichiers
* Lecture et écriture
* Verrouillage
* Tubes
* Opérations sur les fichiers
Annexes
* Index
* Ressources
Livre
[ Modifier le sommaire ]

## Livres

* Programmation C

## Liens

* The Open Group Base Specifications Issue 8 - IEEE Std 1003.1™-2024 Edition - IEEE and The Open Group
# Programmation POSIX/Signaux

Processus
* Processus
* Processus légers
* Signaux
Fichiers
* Lecture et écriture
* Verrouillage
* Tubes
* Opérations sur les fichiers
Annexes
* Index
* Ressources
Processus
* Processus
* Processus légers
* Signaux
Fichiers
* Lecture et écriture
* Verrouillage
* Tubes
* Opérations sur les fichiers
Annexes
* Index
* Ressources
Livre
[ Modifier le sommaire ]
POSIX complète la gestion des signaux du C en définissant principalement deux fonctions en plus de signal et raise:
* kill pour envoyer un signal à un autre processus ;
* pause pour attendre un signal.
Ces deux fonctions sont déclarées dans l'en-tête signal.h.

## Envoi d'un signal à un autre processus

L'en-tête signal.h nous fournit la fonction
Le paramètre pid permet d'identifier le ou les processus qui recevront le signal :
* pid > 0 : identifiant d'un processus ;
* pid == 0 : le signal sera envoyé à tous les processus du groupe du processus courant ;
* pid == -1 : le signal sera envoyé à tous les processus de l'utilisateur. En super-utilisateur (uid=0), tous les processus (sauf système) reçoivent le signal.

### Exemple

Par exemple, un processus fils envoie le signal SIGFPE a son père qui a pour fonction d'afficher dix fois le message "Pere". Le processus fils enverra le signal SIGFPE (floating point exception, exception de virgule flottante) :
Une sortie possible est :
Ici, le processus père n'a pas eu le temps d'afficher le message avant l'exécution du fils que celui-ci a généré une exception de virgule flottante. Le traitement par défaut de ce signal étant l'arrêt du processus, le père s'est terminé.
Il est possible, suivant la manière dont les processus sont synchronisés, que le processus père affiche une ou plusieurs lignes avant d'être interrompu par le signal.
# Programmation POSIX/Tubes

Processus
* Processus
* Processus légers
* Signaux
Fichiers
* Lecture et écriture
* Verrouillage
* Tubes
* Opérations sur les fichiers
Annexes
* Index
* Ressources
Processus
* Processus
* Processus légers
* Signaux
Fichiers
* Lecture et écriture
* Verrouillage
* Tubes
* Opérations sur les fichiers
Annexes
* Index
* Ressources
Livre
[ Modifier le sommaire ]
# Programmation Pascal

Le langage de programmation Pascal (dont le nom vient du mathématicien français Blaise Pascal) a été inventé par Niklaus Wirth dans les années 1970, conçu pour servir à l'enseignement de la programmation de manière rigoureuse mais simple. Ce livre s'intéresse à l'implémentation d'algorithmes impératifs en Pascal pour ensuite l'exécuter sur une machine.
* Une version imprimable du livre « Programmation Pascal » est disponible. (voir/ modifier)
* Introduction
* Environnement de développement
* Un premier programme
* Structure d'un programme
* Les variables
* Procédures et fonctions
* Dépendances mutuelles et références circulaires
* Créer de nouveaux types
* Exercices