informatique C bientôt à vous

03.05.2020 - publication du livre

Sorti ici :
https://www.amazon.fr/dp/2491981009/

informatique C bientôt à vous (Français) Broché – 3 mai 2020

Description :
L'écriture de programmes est une action enthousiasmante dans le domaine de l'informatique, quel que soit le langage utilisé. Le langage C, dont l'empreinte carbone est faible et dont la syntaxe est reprise par d'autres langages, est un excellent choix.

La promesse de ce livre est de vous embarquer le plus rapidement possible, que vous soyez novice ou aguerri en développement informatique, vers des exemples de code que vous serez amenés à lire et relire pour bien en comprendre le fonctionnement, comme si vous deviez démonter des objets mécaniques dont la conception vous laisserait perplexe.

L'auteur, ingénieur passionné, explique avec des mots plutôt qu'avec des maths, s'adresse aux débutants comme aux développeurs confirmés, traite la technique comme s'il racontait une jolie histoire. Il fut d'abord autodidacte, ce n'est qu'après être retourné à l'école qu'il a pu mettre des maths sur les mots.

Ce livre est le premier d'une série mettant en œuvre des compétences en informatique, électronique, automatique, électrotechnique, musique.

Couverture :
Pour contacter l'auteur :
FICHE DE CONTACT

errata

Un grand merci aux lecteurs et lectrices qui ont pris la peine de me signaler les erreurs qu'ils ou elles avaient repérées.


Page 3, vingtième ligne, à 12 cm du haut de la page (corrigé le 24.05.2020) :
Voici comment installer Gygwin sous Windows pour avoir un shell

Voici comment installer Cygwin sous Windows pour avoir un shell


Page 35, quinzième ligne, à 6 cm du haut de la page (corrigé le 24.05.2020) :
Pas de fichier d’en-tête pour ce fichier source puisque qu’il ne va pas

Pas de fichier d’en-tête pour ce fichier source puisqu’il ne va pas


Page 80, vingt-septième ligne, à 15.5 cm du haut de la page (corrigé le 24.05.2020) :
langage, bien que j’ai depuis croisés de nombreux collègues ou copains

langage, même si, depuis, j’ai croisé de nombreux collègues ou copains


Page 114, quarante-sixième ligne, à 18.5 cm du haut de la page (corrigé le 24.05.2020) :
 12        h = fopen(argv[1],"wb") ;  // ouverture "wt" : (w)rite (b)binary

 12        h = fopen(argv[1],"wb") ;  // ouverture "wb" : (w)rite (b)binary

Page 115, avant-dernière ligne, à 3 cm du bas de la page (corrigé le 24.05.2020) :
vilain nom est un joli nom, ça permet de regrouper le tout en une seule

vilain nom et un joli nom, ça permet de regrouper le tout en une seule


Page 116, treizième ligne, à 6.5 cm du haut de la page (corrigé le 24.05.2020) :
rien et qui vaut 0, alors les variables globales sont initialisées à 0, ce qui

rien et qui vaut 0, alors que les variables globales sont initialisées à 0, ce qui


Page 119, trente-et-unième ligne, à 14.5 cm du haut de la page (corrigé le 24.05.2020) :
10│<=    │est inférieur ou égal       │2│G│x=1<=2;y=2<=2;    │x0 y1   ┃

┃10│<=    │est inférieur ou égal       │2│G│x=1<=2;y=2<=2;    │x1 y1   

Page 119, trente-troisième ligne, à 15.5 cm du haut de la page (corrigé le 24.05.2020) :
9│!=    │est différent de            │2│G│x=1==1;y=2==1;    │x0 y1   ┃

┃ 9│!=    │est différent de            │2│G│x=1!=1;y=2!=1;    │x0 y1   

Page 228, vingtième ligne, à 7.5 cm du haut de la page (corrigé le 24.05.2020) :
  42     // ouvrons le fichier audio avec les paramètre par défaut

  42     // ouvrons le fichier audio avec les paramètres par défaut

Page 229, soixante-septième ligne, à 3.3 cm du bas de la page (corrigé le 24.05.2020) :
 140        // nous lisons les échantillons de tous le canaux...

 140        // nous lisons les échantillons de tous les canaux...

addenda


Je pensais naïvement que la plupart des gens étaient sous Linux, ayant bien compris que c'était là leur intérêt, mais il semble qu'il en reste beaucoup d'autres qui utilisent encore Windows (ils ont peut-être été méchants et sont punis).

Mais je ne juge personne et les quelques lignes consacrées à cygwin dans le livre n'étant pas suffisantes, je vous propose un tutoriel d'installation un peu plus détaillé :

INSTALLER CYGWIN

Nicolas Gonzalez, dans le contexte des comparaisons de vitesse entre langages, a testé le langage go :
Le code source (dans lequel je ne peux pas aligner les accolades, grrr...) :
  1  // fichier compterLesReines.go
  2 
  3  package main
  4 
  5  import
  6     (
  7     "fmt"
  8     )
  9 
 10  var
 11     (
 12     echiquier [8][8] int
 13     nombreDeReines int
 14     )
 15 
 16  func marquerEchiquier(x0 int, y0 int, marque int) {
 17     for dy := -1 ; dy <= 1 ; dy ++ {
 18        for dx := -1 ; dx <= 1 ; dx ++ {
 19           if dx != 0 || dy != 0 {
 20              for x, y := x0 + dx, y0 + dy ;
 21                  x >= 0 && x < 8 && y >= 0 && y < 8 ;
 22                  x, y = x + dx, y + dy {
 23                 echiquier[y][x] += marque
 24                 }
 25              }
 26           }
 27        }
 28     echiquier[y0][x0] += 64 * marque
 29     }
 30 
 31  func placerSurEchiquier(n int) {
 32     for y :=0 ; y < 8 ; y ++ {
 33        for x :=0 ; x < 8 ; x ++ {
 34           if echiquier[y][x] == 0 {
 35              marquerEchiquier(x,y,1)
 36              placerSurEchiquier(n+1)
 37 
 38              if nombreDeReines < n {
 39                 nombreDeReines = n
 40                 }
 41 
 42              marquerEchiquier(x,y,-1)
 43              }
 44           }
 45        }
 46     }
 47 
 48  func main() {
 49     placerSurEchiquier(1)
 50     fmt.Println("nombre de reines : ", nombreDeReines)
 51     }
Afin de pouvoir compiler :
sudo apt-get install gccgo
Compiler :
gccgo -Ofast -Wall compterLesReines.go -o compterLesReines
Exécuter :
time ./compterLesReines

   nombre de reines :  8

   real 0m5,826s
   user 0m5,812s
   sys  0m0,013s
Rappel du temps en C :
   real 0m5,094s
   user 0m5,090s
   sys  0m0,000s

echo "5.826 / 5.094" | bc -l

   1.14369846878680800942
Go est ici 1.14 fois plus lent que C.
Bon, je ne renonce pas à mon alignement des accolades, n'en déplaise aux barbus qui ont pondu go :-)
Le code source avec des accolades bien alignées :
  1  // fichier compterLesReines.go
  2 
  3  package main
  4 
  5  import
  6     (
  7     "fmt"
  8     )
  9 
 10  var
 11     (
 12     echiquier [8][8]int
 13     nombreDeReines int
 14     )
 15 
 16  func marquerEchiquier(x0 int, y0 int, marque int)
 17     {
 18     for dy := -1 ; dy <= 1 ; dy ++
 19        {
 20        for dx := -1 ; dx <= 1 ; dx ++
 21           {
 22           if dx != 0 || dy != 0
 23              {
 24              for x, y := x0 + dx, y0 + dy ;
 25                  x >= 0 && x < 8 && y >= 0 && y < 8 ;
 26                  x, y = x + dx, y + dy
 27                 {
 28                 echiquier[y][x] += marque
 29                 }
 30              }
 31           }
 32        }
 33     echiquier[y0][x0] += 64 * marque
 34     }
 35 
 36  func placerSurEchiquier(n int)
 37     {
 38     for y :=0 ; y < 8 ; y ++
 39        {
 40        for x :=0 ; x < 8 ; x ++
 41           {
 42           if echiquier[y][x] == 0
 43              {
 44              marquerEchiquier(x,y,1)
 45              placerSurEchiquier(n+1)
 46 
 47              if nombreDeReines < n
 48                 {
 49                 nombreDeReines = n
 50                 }
 51 
 52              marquerEchiquier(x,y,-1)
 53              }
 54           }
 55        }
 56     }
 57 
 58  func main()
 59     {
 60     placerSurEchiquier(1)
 61     fmt.Println("nombre de reines : ", nombreDeReines)
 62     }
Compiler :
cat compterLesReines.go | LANG=C sed -e :a -e '$!N;s/\n[ \t]*{[ \t]*/ {/;ta' -e 'P;D' | gccgo -Ofast -Wall -o compterLesReines -xgo -
Exécuter :
time ./compterLesReines
C'est l'intention qui compte, ça ne fonctionnerait plus si les accolades se retrouvaient derrière des commentaires, il faudrait alors faire un pré-processeur (heu... en C, bien sûr) plutôt qu'utiliser sed...
Toujours dans le contexte des comparaisons de vitesse entre langages, j'ai testé le langage Pascal :
Le code source :
  1  // fichier compterLesReines.pas
  2  program compterLesReines ;
  3 
  4  var
  5     echiquier : array[0..7,0..7] of Integer ;
  6     nombreDeReines : Integer ;
  7 
  8  // marque : 1 marquer, -1 enlever la marque
  9  procedure marquerEchiquier(x0, y0, marque : Integer) ;
 10     var x,y,dx,dy : Integer ;
 11     begin
 12     for dy := -1 to 1 do          // balayage vertical
 13        begin
 14        for dx := -1 to 1 do        // balayage horizontal
 15           begin
 16           if (dx <> 0) or (dy <> 0) then        // éviter la case de la reine
 17              begin
 18              x := x0 + dx ; y := y0 + dy ;          // premier x y
 19              while (x >= 0) and (x < 8) and (y >= 0) and (y < 8) do  // in échiq ?
 20                 begin
 21                 echiquier[y,x] := echiquier[y,x] + marque ;     // marque normale
 22                 x := x + dx ; y := y + dy ;                  // prochain x y
 23                 end
 24              end
 25           end
 26        end ;
 27     echiquier[y0,x0] := echiquier[y0,x0] + 64 * marque ;        // marque spéciale reine
 28     end ;
 29 
 30  // placer la Nième reine et les suivantes
 31  procedure placerSurEchiquier(n : Integer) ;
 32     var x,y : Integer ;
 33     begin
 34     for y := 0 to 7 do
 35        begin
 36        for x := 0 to 7 do
 37           begin
 38           if echiquier[y,x] = 0 then   // case libre ?
 39              begin
 40              marquerEchiquier(x,y,1) ;  // ajouter une marque
 41              placerSurEchiquier(n+1) ;  // placer les reines suivantes
 42 
 43              if nombreDeReines < n then
 44                 begin
 45                 nombreDeReines := n ;
 46                 end ;
 47 
 48              marquerEchiquier(x,y,-1) ; // enlever une marque
 49              end
 50           end
 51        end
 52     end ;
 53 
 54  begin
 55     placerSurEchiquier(1) ;   // placer toutes les reines
 56     WriteLn('nombre de reines : ',nombreDeReines) ;
 57  end.
Afin de pouvoir compiler :
sudo apt-get install -y lazarus
Compiler :
fpc compterLesReines.pas
Exécuter :
time ./compterLesReines

   nombre de reines : 8

   real	0m14,110s
   user	0m14,098s
   sys	0m0,002s
Rappel du temps en C :
   real 0m5,094s
   user 0m5,090s
   sys  0m0,000s

echo "14.11 / 5.094" | bc -l

   2.76992540243423635649
Pascal est ici 2.77 fois plus lent que C.

Lors des comparaisons de vitesse avec le Raspberry Pi, j'avais utilisé le premier RPi que j'avais sous la main, voici les comparaisons avec différents RPis :
      CPU :                                        N FOIS PLUS LENT :
      Intel(R) Core(TM) i7-4800MQ CPU @ 2.70GHz    1
      Raspberry Pi 2 Model B Rev 1.1               12.37
      Raspberry Pi 3 Model B Plus Rev 1.3          8.94
      Raspberry Pi 4 Model B Rev 1.1               3.76