Programmation POSIX/Fichiers
Nous allons ici expliquer comment accéder au contenu des fichiers : comment ouvrir et fermer un fichier, lire et écrire dans un fichier, etc. Pour pouvoir manipuler le contenu d'un fichier, il faut utiliser un "descripteur de fichier ouvert". Ce descripteur est un simple entier qui sera obtenu en utilisant la fonction d'ouverture de fichier et qui sera ensuite utilisé par toutes les autres fonctions manipulant les fichiers.
Ouverture.
int open ( const char * chemin_fichier, int options );
int open ( const char * chemin_fichier, int options, mode_t mode );
int creat ( const char * chemin_fichier, mode_t mode );
L'appel système "open" convertit un chemin vers un fichier en descripteur de fichier ouvert. Ce qui revient suivant les "options" fournies à créer un nouveau fichier ou à en ouvrir un existant en lecture et/ou en écriture. Les valeurs possibles pour "options" sont des "ou binaire" entre O_RDONLY, O_WRONLY ou O_RDWR et une ou plusieurs des constantes symboliques suivantes :
L'argument "mode" défini les droits du fichier lorsque celui ci est créé par l'appel à "open". Des constantes symboliques représentant les droits possibles sont définies, il est cependant beaucoup plus simple de les spécifier en utilisant une valeur en octal.
L'appel système "creat" est équivalent à "open" avec les options: O_CREAT | O_WRONLY | O_TRUNC.
Fermeture.
int close( int fd );
L'appel système "close" ferme le descripteur de fichier ouvert "fd".
Exemple ouverture/fermeture.
int main(int argc, char ** argv)
 /* Entier qui servira à récupérer le descripteur de fichier */
 int fd;
 /* Appel à open, ouverture du fichier en lecture seule */
 fd = open("/chemin/vers/mon/fichier", O_RDONLY);
 if (fd == -1)
 /* Quelque chose n'a pas fonctionné comme prévu, nous
 affichons un message d'erreur et nous quittons le
 programme.
 perror("open");
 exit(EXIT_FAILURE);
 /* Nous avons passé le test fd == -1, donc à partir d'ici
 nous sommes sur que fd est bien un descripteur de fichier */
 /* Nous fermons le fichier */
 close(fd);
Lecture.
ssize_t read (int fd, void * buffer, size_t nombre);
L'appel système "read" lit au plus "nombre" octets depuis le descripteur de fichier "fd" et les place dans le "buffer". En cas d'erreur, "read" renvoie -1, sinon le nombre d'octets réellement lus est renvoyé. L'argument "nombre" peut être nul auquel cas rien n'est lu et "read" renvoie 0, par contre il doit être inférieur à SSIZE_MAX.
Remarque : Il est beaucoup plus intéressant, au niveau des performances, de lire de grandes quantités de données et de minimiser le nombre d'appels à "read" que de lire le fichier "petits bouts par petits bouts" (le pire étant de lire le fichier caractère par caractère).
Écriture.
ssize_t write (int fd, const void * buffer, size_t nombre);
L'appel système "write" écrit au plus "nombre" octets dans le descripteur de fichier ouvert "fd". Le nombre d'octets réellement écrit est renvoyé si l'appel réussit, sinon "write" renvoie -1.
Lorsqu'un appel à "read" est effectué après un appel à "write", les données venant d'être écrites sont renvoyées.
Exemple lecture/écriture.
Le programme suivant utilise tout ce que l'on a vu précédemment pour réaliser un programme permettant de copier un fichier (tel l'utilitaire Unix codice_1). Le programme prend deux arguments : le fichier source et le fichier destination et recopie le premier dans le second en utilisant les fonctions "read", "write" et un buffer de 100 octets (en fait de 100 caractères, en supposant que le type caractère correspond bien à un octet).
int main(int argc, char ** argv)
 int source, destination;
 char buffer[100];
 int nb;
 /* test des arguments du programme */
 if (argc < 3)
 fprintf(stderr, "usage: %s source destination\n", argv[0]);
 exit(EXIT_FAILURE);
 /* Ouverture du fichier source en lecture seule */
 source = open(argv[1], O_RDONLY);
 if (source == -1)
 perror("open fichier source");
 exit(EXIT_FAILURE);
 /* Ouverture du fichier destination en écriture (O_WRONLY)
 si le fichier n'existe pas, on le créé (O_CREAT), s'il
 existe, on le vide (O_TRUNC). */
 destination = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC, 0644);
 if (destination == -1)
 perror("open fichier destination");
 exit(EXIT_FAILURE);
 /* Maintenant que nous avons nos deux fichiers ouverts,
 nous effectuons la copie par bloc de 100 octets que
 nous plaçons dans le buffer. Lorsque nous ne pouvons
 plus lire, read renvoie 0 et nous sortons de la boucle. */
 nb = read(source, buffer, 100);
 while (nb > 0)
 write(destination, buffer, nb);
 nb = read(source, buffer, 100);
 /* Fermeture des fichiers et fin du programme */
 close(source);
 close(destination);
 return 0;
Déplacement.
off_t lseek (int fd, off_t quantité, int départ);
L'appel système "lseek" permet de modifier la position courante dans un fichier en la déplaçant d'une certaine "quantité" à partir d'un point de "départ". Ce point de départ peut être :
En particulier codice_2 permet de se positionner au début du fichier et codice_3 à la fin.
La valeur renvoyé par "lseek" est le déplacement réellement effectué en nombre d'octets (ainsi en se positionnant au début puis à la fin du fichier, il est possible de calculer la taille de ce fichier).

Programmation POSIX/Processus légers
Création.
int pthread_create(pthread_t * thread,
 pthread_attr_t * attr,
 void * (*fonction_appelee)(void *),
 void * arg);
La fonction "pthread_create" créée un nouveau thread qui exécute la fonction "fonction_appelee" en lui passant "arg" comme argument. La fonction renvoie 0 en cas de réussite et une valeur différente de 0 sinon.

Apprendre à cuisiner/Techniques
La plupart des techniques sont décrites par un verbe, parfois, par son substantif. La liste suivante en donne une définition.

Programmation Linux
Introduction.
Le but de ce livre est de couvrir toutes les bibliothèques de fonctions C fournie par Linux ne faisant pas partie ni de la bibliothèque standard ni de la norme POSIX.

Programmation Linux/Sockets
Japonais/Hiragana/Leçon 3
= Tableau complet =
Cette troisième leçon permet de terminer l'étude des hiraganas. 
Les leçons suivantes abordent un certain nombre de points importants pour compléter l'étude des hiraganas, mais il n'y aura pas de nouveau symbole à apprendre.
Cette série est incomplète car les sons Yi et Ye n'existent plus en japonais moderne, bien qu'ils aient existé. Un exemple bien connu est Yen qui s'écrit ¥ sur un clavier français. Les Japonais ne disent pas Yen, mais En.
Le son noté "R" en rōmaji est un son proche du "L" français, mais avec un claquement plus important de la langue.
Ordre Alphabétique.
L'astuce pour mémoriser l'ordre des voyelles ce qui est essentiel, car le dictionnaire japonais est organisé dans cet ordre A->O->Ka->Ko->Sa->So... :
= Vocabulaire illustré =
= Vocabulaire supplémentaire =

Japonais/Hiragana/Test
Retranscrire en phonétique :
いろはにほへと
ちりぬるを
わかよたれそ
つねならむ
うゐのおくやま
けふこえて
あさきゆめみし
ゑひもせすん
Le corrigé est ici.