Karel Kuklík est un photographe tchèque né le 7 mars 1937 à Prague. Il est classé parmi les représentants de l'école « informelle » des Beaux-Arts tchèques ; ses œuvres témoignent de l'influence des surréalistes et beaucoup présentent une forte atmosphère existentialiste. Il est l'un des cofondateurs, en 2000, du groupe photographique "Český dřevák".
Biographie.
Le père de Karel Kuklík était un tailleur, qui fut emprisonné pour activités illégales pendant la 2e guerre mondiale. Le jeune Karel passa une partie du début des années 1940 avec sa famille dans divers endroits, tels que le village de Blaník. À l'age de 6 ans il se lia d'amitié avec František Šmejkal, qui avait le même âge que lui et qui devint plus tard un théoricien de l'art reconnu. À 15 ans il acquit son premier appareil photo, un 6 x 6, et une année plus tard il acheta un appareil à plaques 6 x 9. Sérieusement intéressé par les beaux-arts, il commença à visiter les galeries. Au début des années 1950 il découvrir une exposition de peintures de Jan Zrzavý, qui lui fit forte impression.
Entre 1952 et 1954 il suivit un apprentissage de mécanicien automobile, profession qu'il exerça de 1954 à 1956, puis de 1958 à 1960. De 1956 à à 1958, il fit son service militaire . En 1960 il devint assistant de laboratoire dans le service de conservation des monuments historiques et de protection de l'environnement, à Prague ; il y acquit une grande habileté dans les travaux photographiques. Depuis 1964 il est photographe indépendant.
Œuvres.
Séries photographiques.
Paysages imaginaires.
Ce sont des séries créées entre 1958 et 1964.

Photographie/Sociétés et Organisations/Éditeurs de cartes postales/Vve Proisy

Vve Proisy était une buraliste et éditrice de cartes postales installée à Anor (Nord).

Néerlandais/Dans le secondaire/le cartable/quiz

<quiz display="simple">
 Écoutez et traduisez
 Écoutez et traduisez
 Écoutez et traduisez
 Écoutez et traduisez
 Écoutez et traduisez
 Écoutez et traduisez
"de" ou "het" ?
-+ potlood
+- stift
-+ plakband
+- puntenslijper
</quiz>

Programmation Haxe/Haxe.xml
// contenu xml
var xml = Xml.parse("
 <user name='john'>
 <phone>
 <number>0000</number>
 <number>111</number>
 </phone>
 </user>
// encapsuler le xml pour un accès fast
var fast = new haxe.xml.Fast(xml.firstElement());
// accéder les attributs
trace(fast.att.name); // attribute "name"
if( fast.has.age ) trace( fast.att.age ); // optional attribute
// accession de l'enfant de phone
var phone = fast.node.phone;
// boucle pour affichage
for( p in phone.nodes.number ) {
 trace(p.innerData);
ou Exemple 2 : utilisant des propriétés de Xml (à la racine de l’API :)
// le xml
var str = "<hello where=\"world\">Haxe</hello>";
// on parse le xml
var x : Xml = Xml.parse(str).firstElement();
// on fait une requête
var out = x.nodeName + " " + x.get("where")+" "+x.firstChild().nodeValue;
trace(out);
for( child in x ) {
 // itère tous les enfants
 trace(child);
for( elt in x.elements() ) {
 // itère tous les éléments
 trace(elt);
for( user in x.elementsNamed("user") ) {
 // itère tous les éléments avec le nodeName "user" 
 trace(user);
for( att in x.attributes() ) {
 // itérateur sur tous les attributs
 trace(att);
Attaque namespace : Xml (racine-haxe3).
// on met le string xml dans une variable
var str = "<hello where=\"world\">Haxe</hello>";
// on parse le xml -- et on prends le premier élément -- .firstElement() est dans le namespace Xml
var x : Xml = Xml.parse(str).firstElement();
Fields.
nodeName.
var out = x.nodeName;
// retourne -> "hello"
nodeType.
var out = x.nodeType;
// retourne -> "element" -- car hello est de type élément xml
nodeValue.
var out = x.firstChild().nodeValue;
// retourne -> "Haxe"
parent.
var out = x.firstChild().parent;
// retourne -> le nœud "hello" comme parent car il n'y a pas de nœud parent
Methods.
addChild.
En partant de l'exemple 2
var el : Xml = Xml.createElement('tmp');
el.addChild(Xml.createCData("content"));
x.addChild(el);
// on utilise la librairie fast -> on verra cela plus tard
var fast = new haxe.xml.Fast(x);
trace(fast.innerHTML);
// retourne -> "ClaTest.hx:22: Haxe<tmp><![CDATA[content]]></tmp>"
attributes.
En partant de l'exemple 2 
trace(x.attributes());
elements.
package ;
class Main
 static public function main()
 var str = "<hello where=\"world\">Haxe<el>content_1</el><el>content_2</el></hello>";
 // on parse le xml
 var x : Xml = Xml.parse(str);
 for (child in x.firstChild().elements())
 trace(child.firstChild().nodeValue);
 // retourne -> Main.hx:19: content_1
 // Main.hx:19: content_2
elementsNamed.
package ;
class Main
 static public function main()
 var str = "<hello where=\"world\">Haxe<el>content_1</el><el>content_2</el></hello>";
 // on parse le xml
 var x : Xml = Xml.parse(str);
 for (child in x.firstChild().elements())
 trace(child.firstChild().nodeValue);
 // retourne -> Main.hx:19: content_1
 // Main.hx:19: content_2
exists.
avec le XML précédent 
trace(x.firstChild().exists("where"));
// retourne -> Main.hx:20: true
firstChild.
avec le XML de elementsNamed 
trace(x.firstChild().nodeName);
// retourne -> Main.hx:20: hello
firstElement.
avec le XML de elementsNamed 
trace(x.firstChild().firstElement().nodeName);
// retourne -> Main.hx:20: el
get.
avec le XML de elementsNamed 
trace(x.firstChild().get("where"));
// retourne -> Main.hx:20: world
insertChild.
avec le XML de elementsNamed 
x.firstChild().insertChild(x.firstChild().elementsNamed("pl").next(),1);
trace(x.firstChild().toString());
// retourne -> Main.hx:21: <hello where="world">
// <pl>content of pl</pl><el>content_1</el><el>content_2</el>
// </hello>
iterator.
package ;
class Main
 static public function main()
 var str = "<hello where=\"world\">
 <el>content_1
 <sl>one</sl>
 <sl>two</sl>
 </el><el>content_2</el>
 <pl>content of pl</pl>
 </hello>";
 // on parse le xml
 var x : Xml = Xml.parse(str);
 var it = x.firstElement().firstElement().iterator();
 for (child in it)
 trace(child.nodeType);

// retourne -> Main.hx:26: pcdata <-- text avant premier sl
 // Main.hx:26: element <-- premier sl
 // Main.hx:26: pcdata <-- text avant deuxième sl
 // Main.hx:26: element <-- deuxième sl
 // Main.hx:26: pcdata <-- text après deuxième sl
remove.
avec le XML de elementsNamed 
x.firstElement().remove("where");
trace(x.firstChild().toString());
// retourne -> Main.hx:21: <hello>
// <el>content_1</el><el>content_2</el>
// <pl>content of pl</pl>
// </hello>
on voit que l'attribut where a disparu :) 
removeChild.
avec le XML de elementsNamed 
x.firstChild().removeChild(x.firstChild().elementsNamed("pl").next());
trace(x.firstChild().toString());
// retourne -> Main.hx:21: <hello where="world">
// <el>content_1</el><el>content_2</el>
// </hello>
set.
avec le XML de elementsNamed 
x.firstChild().set("where","newValue"); 
trace(x.firstChild().get("where"));
// retourne -> Main.hx:21: newValue
toString.
avec le XML de elementsNamed 
trace(x.firstChild().toString());
// retourne -> Main.hx:20: <hello where="world">
// <el>content_1</el><el>content_2</el>
// <pl>content of pl</pl>
// </hello>

Programmation Haxe
Ce livre se propose d'attaquer par l'exemple l'api de Haxe. Haxe est un langage de programmation haut niveau typé capable de transpiler son code dans différents langages. Il est principalement utilisé pour développer des jeux modernes ou des projets multimédias comme le site web de NickelOdeon ou les jeux comme Northgard de Shiro-Games dont Nicolas Canasse est le fondateur.
La fondation HaxeFoundation fournit le langage en opensource ici : https://github.com/HaxeFoundation
= Namespaces =
= Plateformes =
= Références =

Néerlandais/Dans le secondaire/la météo
En néerlandais on employe surtout des verbes impersonnels en discutant la météo, même plus qu'en français.
Tout comme en français ils prennent seulement un pronom impersonnel "het", comme "il" en français:
"ik regen", comme "je pleuts" n'existe pas.
Tous les verbes impersonnels prennent "hebben" comme verbe auxiliaire du parfait: