Les Pôles d'éco-citoyenneté dans le Nord-Pas-de-Calais/Les principaux Pôles d'éco-citoyenneté dans le Nord-Pas-de-Calais/Les Parcs Naturels Régionaux/Le PNR Scarpe-Escaut/Maison de la Forêt

La Maison de la Forêt de Raismes est un espace d’initiation aux milieux forestiers et de sensibilisation à l’environnement. Elle fait partie intégrante du Parc Naturel Régional Scarpe-Escaut.
Généralités.
La structure.
Implantation.
La Maison de la Forêt est située dans le PNR Scarpe-Escaut.
Son bâtiment abrite un hall d’accueil et d’information ainsi qu’une exposition permanente sur la forêt et l’histoire du site de Sabatier.
Le site minier et forestier de Sabatier est un lieu naturel du Parc Scarpe-Escaut, chargé de la mémoire du travail des hommes, avec la présence des terrils.
C’est aussi le lieu de nombreuses promenades et randonnées sur des sentiers balisés dans la forêt domaniale de Raismes/Saint-Amand/Wallers.
Cette forêt abrite de nombreuses espèces rares, menacées et protégées. Depuis 2006, elle inclut une RBI, Réserve Biologique domaniale Intégrale.
Gestion du Centre.
La Maison de la Forêt est gérée par l'ADEPSE, l'Association pour le Développement des Équipements du Parc Scarpe-Escaut.
Elle est ouverte toute l’année pour les groupes, sur réservation.
Pour le grand public, la période d’ouverture est d’avril à octobre, les après-midi des mercredis, dimanches et petites vacances scolaires.
Activités.
Aux travers de ses activités qui vont de la simple visite du site jusqu'aux animations encadrées, la Maison de la Forêt traite de trois thèmes : l’histoire, la vie et la protection de la forêt.
Objectifs.
Tout comme le Centre d'Amaury, qui fait partie du PNR, la vocation de la Maison est pédagogique.
Le site de Sabatier comprend mines, forêts et étangs, qui offrent des sujets d’études liés aux programmes scolaires.
La Maison de la Forêt se prête donc bien aux animations des groupes scolaires et des centres de loisirs.

Photographie/Fabricants/Kodak/Kodak EasyShare M580

Le système d'exploitation GNU-Linux/Installation RAID1 logiciel + LVM + XFS

Voici la configuration à obtenir lors de l'installation de Debian :

Programmation en Go/Interfaces
Définition d'une interface.
Une interface est un ensemble de "méthodes", c'est-à-dire des fonctions qu'il est possible d'implémenter pour un type défini.
En voici un exemple, une interface de tri:
 type sort.Interface interface {
 Len() int
 Less(i, j int) bool
 Swap(i, j int)
Cette interface permet de trier n'importe quelle structure de données consécutives. Il suffit de définir les méthode Len(), Less() et Swap() et nous pourrons appeler sort() sur cette structure de données.
Nous pouvons par exemple définir cette interface pour un tableau d'entiers:
 type Sequence []int
 func (s Sequence) Len() int {
 // longueur de s
 return len(s)
 func (s Sequence) Less(i, j int) bool {
 // retourne vrai si l'élément d'indice i est inférieur à l'élément d'indice j
 return s[i] < s[j]
 func (s Sequence) Swap(i, j int) {
 // échange deux éléments
 s[i], s[j] = s[j], s[i]
Ainsi la syntaxe fait précéder le nom de la méthode du type défini entre parenthèses.
Nous pouvons maintenant trier une séquence en faisant:
 var seq Sequence
 sort.Sort(seq)
Note sur les pointeurs.
Lorsque l'on implémente une méthode sur une structure, il est d'usage de déclarer la méthode sur un type pointeur de cette structure, pour éviter le passage par valeur:
Héritage d'interfaces.
En incluant un nom de type précédé d'une étoile dans une structure, sans le nommer, la structure hérite de toutes les interfaces de cette structure en les lui déléguant.
 type Tache struct {
 Commande string
 *log.Logger
Ensuite on appelle
 tache.Log()
qui est délégué au membre log.Logger de la structure.
Héritage multiple.
Il est possible d'hériter de manière multiple comme dans l'exemple suivant:
 type ReaderWriter struct {
 *io.Reader
 *io.Writer
Constructeur.
Il est alors d'usage de définir un constructeur, si nécessaire, pour la structure Tache, que l'on nommera "NewTache":
 func NewTache(commande string, journaliseur *log.Logger) *Tache {

Programmation en Go/Modules
Importer un module.
Pour importer un seul module:
 import "module"
Pour en importer plusieurs:
import (
 "module"
 "module2"
 )
Un nom de module est le chemin relatif du répertoire contenant le module. Par exemple, dans le répertoire de go on trouve "src/pkg/container/vector" qui est importé comme "container/vector". Une fois le module importé, on s'y réfère dans le source comme "vector" tout court.
Il est indispensable de noter le nom des modules entre guillemets.
Il est possible d'importer avec un autre nom un module, notamment si deux modules portent le même nom. Pour ce faire il suffit de mettre ce nouveau nom devant le chemin du module.
import {
 "path/to/module1"
 nouveaunom "path/to/module2"
Dans ce cas le premier module sera chargé avec le nom module1 et le deuxième avec le nom nouveaunom.
Conventions.
Les seuls noms exportés sont les noms commençant par une majuscules: noms de fonctions, de types, de méthodes, de constantes, de variables...
Il est d'usage de ne pas utiliser le tiret de soulignement (underscore) mais de capitaliser les noms à exporter en "CamelCase".
Utiliser des noms simples, notamment pour les interfaces: une interface comportant la méthode Print s'appellera Printer, Write deviendra Writer, Read deviendra Reader, etc...
Enfin, l'utilitaire gofmt permet de formater un code source selon les recommendations des concepteurs du langage Go.

Programmation en Go/Panic et recover
Panic.
Lorsqu'une erreur survient dans un appel de fonction, le meilleur comportement est en général de signaler l'erreur par un code retour.
Mais parfois une erreur est irréversible et doit entraîner l'arrêt du programme. Dans ce cas, il convient d'appeler la fonction panic(). Cette fonction prend un seul argument de type quelconque.
Exemple:
 var user = os.Getenv("USER")
 func init() {
 if user == "" {
 // le programme se termine abruptement
 panic("pas de valeur pour $USER")
Recover.
Cette fonction permet de récupérer une exception lancée par "panic". Elle s'utilise en général avec defer:
 func serveur(canal <-chan *Tache) {
 for tache := range canal {
 go faitEnSecurite(tache)
 func faitEnSecurite(tache *Tache) {
 defer func() {
 if err := recover(); err != nil {
 log.Println("tache echouee:", err)
 }()
 faire(tache)
Ici, la fonction "faitEnSecurite" applique au résultat de "faire()" la fonction déclarée avec defer, qui appelle recover() et vérifie si une erreur a eu lieu. L'exception est à ce moment totalement levée et il n'y a rien d'autre à faire pour continuer l'exécution normale du programme.