Les langages de programmation

• Définir et manipuler des données types en mémoire
  • Déclaration de variables
  • Types de données scalaires - int, float, bool , str
  • Types de données aggrégés - list, tuple, dict, set
  • Valeurs littérales
  • Portée de variables - globale, locale
• Les opérateurs
  • Les opérateurs d'affectation
  • Opérateurs arithmétiques
  • Opérateurs relationnels
  • Opérateurs logiques
• Convertir les données - casting ou transtypage
  • Casting et conversion
  • Conversions implicites vs explicites
• Manipulation des chaines de caractères
  • Gestion des chaines
  • Formatage
  • Slicing
  • Expressions régulières
• Manipulation des données structurées - list, dict et set
  • Gestion des listes
  • Gestion des dict
  • Gestion des set
• Les instructions controles
  • Structure conditionnelles if/else/then,match
  • Structure match
  • Boucles - for/else
  • Boucles - while
  • Boucles - avec range
  • Boucles - avec zip
  • Boucles - avec items() pour les dictionnaires
• Les fonctions et passage d'arguments
  • Les fonctions, arguments , passage par valeur, return
  • Arguments et valeurs par défaut
  • Arguments en tant que tuple
  • Arguments avec *args
  • Arguments *kargs
  • Fonction en tant qu'argument (delegate)
• Traiter une masse de données
  • Fonction anonyme Lambda
  • Traitement avec filter
  • Traitement avec map
  • Traitement avec reduce
• Les générateurs
  • Boucle et instruction yield
  • Générateur prédéfinis
• Un code plus robuste en prenant en compte les erreurs
  • Gestion des exceptions : try catch finally et throw
  • Instruction finally
  • Emettre une exception avec throw
• Script python en ligne de commande et passage d'arguments
  • Scripts et __main__
  • Scripts et passage d'arguments
  • Gestion de package - pip
• Gestion des package - import et création
  • librairie et script pip
  • importation de package
  • Contenu d'un package
  • chemin d'accès
  • package standards os, os.path, path et zlib
  • Gestion des répertoires - mkdir, listdir, walk, move, rmdir
  • Gestion des fichiers - open, read, write, seek, tell, zip
  • Automatiser une installation avec gel et requirements.txt
• Envrionnement virtuel adapté à chaque application
  • Création d'un context python isolé avec venv
  • Script activate/deactivate
• Gestion des fichiers et des répertoires
  • Concepts généraux sur les streams et fichiers
  • Créer un fichier text en unicode - ouvrir, ecrire, lire
• Programmation orientée objets
  • Approche de l'orienté objets
  • Composition d'une classe - constructeur, méthodes et données
  • Objet et instance de class - self, super
  • Héritage de classes et redéfinition
  • Packages et imports et classes
• Accès aux bases de données
  • Concepts de base
  • Connexion et paramétrage - connexion, cursor
  • Gestion de la Structure de données - Table DDL
  • Gestion des transactions - commit
  • Manipulation des données - Select/Where DML

• Variables et types de données scalaires
  • Commentaires //, /**/
  • Déclaration de variables avec let, var et const
  • Les entiers et décimaux - number
  • Le boolean - boolean
  • Le type générique - any et never
  • Les chaînes de caractères - string
  • Les multi-types - union
  • Valeurs spéciales - undefined, unknown, null
• Variables typées agrégées
  • l'objet - {} et Map>,<()
  • Tableau et liste - Array[],Array><
  • Tuple - Tuple
  • Ennumération et symbole - enum, Symbol
  • Variables nullable - ? !
  • Types personnalisés - type alias
• Casting et conversion
  • Opérateur as
  • Opérateur ><
• Les Opérateurs |
  • Les opérateurs arithmétiques
  • Les opérateurs relationnels
  • Les opérateurs logiques
  • Les opérateurs d'affectation et ternaire
  • Opérateurs - union |
• Instructions de contrôle
  • Instructions de test - if/else
  • Instructions de test - swith
  • Instructions de boucle - for
  • Instructions de boucle - forEach
  • Instructions de boucle - while
• Les fonctions
  • Valeur de passage d'arguments typés
  • Argument Rest ...
  • Fonction lambda
  • Fonction template/générique
  • Fonction map
  • Fonction filter
  • Fonction reduce
• Gestion des exceptions
  • try, catch
  • finally
  • throw
• Programmation modulaire
  • Créer un module et exportation d'une fonction
  • Créer un module et exportation d'une classe
  • Créer un module et exportation d'un objet {}
  • Notion d'espace de noms - namespaces
• Programmation orientée objets
  • classe, constructeur
  • Données
  • Méthode et surcharge
  • Protection private, public, static
  • instanciation, objet et this
  • Classe abstraite
  • Héritage
  • Classe template/génétrique
  • Notion d'interface et template
  • Notion de mixin
• Programmation asynchrone
  • Appel asynchrone avec async, await
  • Les Promise>T<,resolv,reject,then, catch

• Généralités
  • Commentaires # et =for comment/=cut
  • Bloc d'instruction avec {}, BEGIN{}, END{} et le point-virgule
• Variables et types de données
  • Notion de variable - $v, @v, %v, my
  • Variables locales, globales - $_, @_, $?, $!, $~, $@, $ARG, $NR
  • Types de données scalaires - numérique
  • Types de données scalaires - string
  • Types de données scalaires - expresion booléenne
  • Types de données scalaires - date
  • Types de données agrégées - tableau @(), [], ..
  • Types de données agrégées - dictionnaire %()
  • Types de données référence - \
  • Valeurs littérales et valeur undef
• Les opérateurs
  • Opérateurs arithmétiques
  • Opérateurs relationnels
  • Opérateurs logiques
  • Opérateurs - ternaire
  • Opérateurs - shift, unshift
  • Opérateurs - push, pop
  • Opérateurs - ref(), -<
  • Opérateurs - qw(), qq(),
  • Opérateurs file test ,
• Opérations sur les chaines
  • formatage - sprintf
  • Création - qw(), substr(), lc(), uc(), reverse(), lenght(), regexp
  • Extraire avec substr()
  • Extraire avec chomp(), chop()
  • Extraire regexp //
  • Entrées sorties standards
  • Stdin - STDIN
  • Stdout - STDOUT
  • Stderr - STDErr
  • Redirections
• Les Instructions
  • Instructions de test - if/else/elsif
  • Instructions de test - unless/else
  • Instructions de test - switch/case
  • Boucle avec for
  • Boucle avec while, continue, break
  • Boucle avec until, continue, break
  • Boucle avec do/while
  • Branchemet avec goto,
  • Evaluation avec eval
• Les fonctions
  • Arguments et valeur de retour - sub, return, &
  • Les fonctions prédéfinies
  • Scripts et passage d'arguments
• Gestion des modules
  • Création d'un module
  • Instruction use - strict, warnings, ...
  • Gestion des package/module au moyen CPAN
• Gestion des erreurs et exceptions
  • Sortie - die, warn, unless, || , or die
  • Try::Tiny - try, catch, finaly
• Gestion des fichiers et répertoires
  • Gestion d'un fichier texte - open, close, print,
  • Gestion d'un fichier binaire - seek, tell
  • Redirection des entrées/sorties - select
  • Gestion des repertoires - opendir(),readdir(), mkdir()
  • Commande shell - system()
• Programmation orientée objet
  • Concepts généraux
  • Encapsulation au moyen de package/module
  • Instance de classe ou objet - new, $self, -<
  • Constructeur, destructeur - DESTROY
  • Méthodes et données membres
  • Héritage avec @ISA, qw()
  • Redéfinition de méthodes
• Accès aux bases de données
  • Les API - use DBI
  • Connexion et paramétrage - DBI-<connect()
  • Erreurs - DBI-<errstr
  • Gestion de la structure de données - table,
  • Gestion des transactions - commit(), rollback()
  • Manipulation des données - do(), prepare(), execute(), fetchrow_array()

• Généralités
  • Commentaires - - et - - [[]]
  • Bloc d'instruction avec l'instruction "end"
  • Notion de variable - _, type
  • Portée de variables - globale, local, _ENV, _G
  • Type de données scalaires - boolean, number, string,
  • Type de données agrégés - table {}
  • Type de données agrégés - userdata
  • Types utilisateurs avec linked list {}
  • Valeurs littérales et valeur nil
• Les opérateurs
  • Opérateurs arithmétiques
  • Opérateurs relationnels
  • Opérateurs logiques - and, or, not
  • Opérateurs - ternaire
• Les chaines de caractères
  • Opérations, .., ==, ~=, #, len()
  • Formatage - string.format()
• Les I/O
  • Gestion de stdin
  • Gestion stdout - io.read(), io.write()
• Les instructions
  • Les test - if/else/then/end
  • Les boucles - for/do, break
  • Les boucles - pairs, ipairs
  • Les boucles - while/do, break
  • Les boucles - repeat...until loop, break
  • Les boucles - for, pairs, while/do, repeat, break
• Les fonctions
  • Les fonctions, arguments et return
  • Passage d'argument, arguments nommés
  • Modules et gestion de package - require, luarocks
• Gestion des erreurs
  • pcall()
  • xpcall()
  • assert()
• Métaboles et métaméthodes
  • La métaméthode __tostring
  • Les métaméthodes arithmétiques
  • Les métaméthodes __index, __newindex
  • La métaméthode __len
• Gestion des fichiers
  • Présentation du package io
  • Ouvrir/lire/écrire un fichier texte - open, read, write, close
  • Fichiers au format xml - require("xml2lua")
  • Fichiers au format json - require("cjson")

• Généralités
  • Commentaires #, ># #<
  • Bloc d'instruction avec {}, %{}
  • Notion de variable et l'acces au contenu avec $
• Déclaration de variables et types de donnnes scalaires
  • Notion de variable - var, const, _, >- , :=
  • Variables d'environnement et variabls prédéfinies - $$, $*, $^, $_
  • Type entier - byte, int, Int16, Int32, Int64
  • Type décimal - Single, Double
  • Type booléen - bool, Boolean
  • Type caractère et chaine - char, string
  • Valeurs littérales
  • Valeur $null, $true, $false
• Type de données agrégés
  • Les tableaux - Array, @(), int[],int16[],int32[],object[],string[],1..MAX ...
  • Dictionnaire - hashtable, @{;}
  • Types utilisateurs avec type - PSCustomObject/PSTypeName , add- type, new- object, class
  • Types de .NET
  • Connaitre le Type - GetType(), - is, - isnot
• Casting et conversion
  • Cating implicite
  • Cating explicite - [], - as
• Les opérateurs
  • Opérateur de filtrage avec Where, Select
  • Opérateur de formatage - Format- Table, Format- Wide, Format- List, $()
  • Operations de test avec les opérateurs eq lt le gt ge and or not
  • Expression régulière - match notmatch
  • Evaluation d'opérations numérique et de test avec $(()) et (()), let
• Les instructions
  • Test - if/else, switch
  • Boucles - for loop, forEach loop, while loop, do/while/loop, continue, break
  • Commandlet utiles - sort-object, Measure-Command, random
• Le commandlets et alias
  • Commandlet et options communes
  • Commandlet et Pipe
  • Commandlets utiles - get-help
• Les fonctions
  • Passage d'arguments et valeur de retour - CmdletBinding
  • Les arguments de scripts $args[0]
  • Récupération de flux de données depuis le pipe
  • Quelques commandes utiles - alias, Get- *, set- *
  • Commandlets préfinies
• Gestion des processus - *- Process
  • Présentation des commandlets liées aux processus en mémoire
  • Les données et méthodes membres d'un objet processus
  • Commandlets liées aux processus en mémoire
• Gestion des services - *- Service
  • Présentation des commandlets liées aux services en mémoire
  • Les données et méthodes membres d'un objet processus
• Gestion des fichiers et répertoires
  • Instruction d'entrée/sortie : Write- Output, Write- Error, Write- Host, Out- GridView, Out- File , Read- Host
  • Pipe et redirection - | < > <<
  • Manipulation des fichiers et format - csv
  • Manipulation des fichiers et format - json
  • Manipulation des fichiers et format - xml
  • Commandlets utiles
• Accès au système
  • Périphériques matériels - réseaux, disque dur, usb
  • Gestion des utilisateurs et des sessions
  • Utilisateurs du domaine - *- ADUser
  • Gestion des sessions et exécution de commandes à distances
• Gestion des modules - *- Module
  • Créer son propre module et chemin d'accès
  • Importation de modules - Import-module
  • Télécharger les modules extérieurs - install-module, get-Module,
• Gestion des tâches - *- ScheduledTask
  • Concepts et définitions
  • Utiliser une tâche asynchrone locale
  • Travaux automatiques avec - AsJob
  • Création d'une tâche planifiée personnalisée
  • Exécuter et supprimer une tâche planifiée

• Généralités
  • Commentaires #, " "
  • Bloc d'instruction avec {} et le point virgule
• Type de données scalaires
  • Notion de variable et affectation - >- , >>-
  • Portée de variables - globale, locale
  • Les nombres - integer, numeric, complex
  • Les caractères, chaines - character
  • Le boolean - TRUE or FALSE
  • Les dates
• Type de données agrégés
  • Liste - list()
  • Tableau - c(), array()
  • Factor
  • matrice - matrix
  • Dictionnaiore - hash
  • Slice - slice_xx()
  • Données utilisateur - data.frame
  • Valeurs littérales et valeur NULL, NA, NAN, Inf
• Les opérateurs
  • Opérateurs arithmétiques
  • Opérateurs relationnels
  • Opérateurs logiques
• Entrees/sorties standard
  • Stdin - file('stdin'), readLines(input)
  • Stdout - file('stdout'), write(result), print(),
• Les Instructions
  • Les test - if else
  • Les test - switch
  • Les boucles - for/range
  • Les boucles - while, continue,break
  • Les boucles - repeat
  • Les boucles - goto/label
• Les fonctions
  • Arguments et valeurs de retour
  • Fonctions outer, apply, lapply, sapply et mapply.
  • Les fonctions pré- définies et package - install.packages(), library(), import::from()
• Gestion des erreurs et des exceptions
  • Try, tryCatch(), warning, error, finaly , stop
  • Traceback()
  • SuppressWarnings, suppressMessages
  • Libraries - library(testthat)
• Gestion de fichiers et base de données
  • Présentation des API et packages - dir, file.path, fs, utils,
  • Fonctions de bas niveau - sink(), cat(), writeBin(),readBin()
  • Importer, exporter au format csv - read.csv, write.csv, write.table
  • Importer, exporter au format excel - library(xlsx)
  • Importer, exporter au format json - llibrary(jsonlite)
  • Quelques packages utils - dplyr, tidyr , purrr
• Accès aux bases de données
  • Install.packages("RSQLite"), install.packages("devtools")
  • R equêtage SQL - dbSendQuery, dbReadTable, dbClearResult, dbConnect/dbDisconnect
• Calculs statistiques en R
  • Statistiques descriptives retournant une valeur - min, max, median, dispersion
  • Statistiques descriptives retournant plusieurs valeurs - range, quantile, table, ftable,
  • Distribution et probabilité - densité, repartition, quantile,
  • Ajustement de modèles - linéaire, régression, analyse de la variance
• Graphiques et tracé de courbes
  • Définitions et présentation des APIs et paquetages
  • Paramètres graphiques, couleurs et traits - layout, par
  • Axes, légendes et titres - legende,
  • Types de fonctions graphiques - plot, points, lines, curve
  • Graphique avec ggplot - Histogramme, geom_density
  • Types de diagrammes - secteur, barres, boite, batons, nuage de points, Cleveland, dispersion
  • Graphe de la fonction de répartition empirique
  • Polygone des fréquences. Représentations graphiques dans un cadre bivarié.
  • Graphique 3D

infos

titre:Introduction à la programmation VB.NET

sujet:Introduction à la programmation VB.NET

categorie:Langages

prix:5

auteur:BELHADJ Karim

discipline:informatique

niveau:Initiation

version:1.0

Généralités

mots clés du langages

Commentaires // et /**/

Bloc d'instruction avec {} et le point virgule

Déclaration de variables et types de donnnes scalaires

Notion de variable - Const, static,

Type entier - Byte, Boolean, integer, long, short, ULong, Uinteger

Type décimal - Single et double

Type caractère et chaine - char, string, System.String

Type Date - Datetime

Valeurs littérales

Valeur Nothing

Types de donnnes agrégés

Les tableaux - Integer(,), String (,), Redim, ArrayList

Les collections - LinkedList, hashtable, ArrayList, Iterator

Les dictionnaires - hashTable

Les structures - structure

Les templates

Casting et conversion

Connaitre le Type - GetType(), IsInstanceOfType(), TypeOf/Is

Casting implicite

Casting explicite

Fonction .ToString(), CStr(), CType(), DirectCast(), TryCast()

Les opérateurs

Opérateurs - typeof(), GetType ()

Opérateurs arithmétiques

Opérateurs relationnels

Opérateurs logiques

Opérateurs ternaire

Gestion des exceptions

try, catch

finally

throw

Les chaines et formatage

String, System.String et méthodes

Formattage avec format() et $" {} "

StringBuilder,

System.Text.RegularExpressions;

Les entrées/sorties standards

stdin - Console.Read(), Console.ReadLine()

stdout - Console.Write(), Console.WriteLine()

Les instructions

Pour les tests - if/then/elseif/else/end if

Pour les tests - Select/Case

Pour les boucles - for, next, exit for

Pour les boucles - foreach

Pour les boucles - do/while/loop, exit while

Les fonctions et procedures

Fonctions, arguments et valeur de retour - function

Procedures, arguments, valeur de retour, exit sub - Sub

Passage par référence et par valeur des arguments - byval, byref

Fonction anonyme lambda

Les delegates

Gestion des packages

Package et namespace

Imports

Gestion de package avec nuget

Programmation orientée objet

Concepts de base sur l'orienté objets

Class et composition - constructeurs, méthode, Property , Shared

Types de classe - MustInherit, NotInheritable, partial,

Surcharge de méthodes

Protection appliquée aux classes et membres

Héritage de classes

Redéfinition de méthode et de constructeurs

Polymorphisme

Interface

Gestion des fichiers et répertoires

Package System.IO

File et FileStream

StreamReader / StreamWriter

BinaryReader / BinaryWriter

Fichiers et répertoires - My.Computer.FileSystem, StreamWriter, StreamReader

Fichier xml

Fichier json

Accès aux bases de données

Accès aux bases de données avec ADO.NET

SqlConnection, SqlCommand, SqlDataReader

SqlDataAdpater, DataTable

SqlDataAdpater, SqlRecordSet

DML et SqlCommandBuilder

Requetage objet avec Linq

Déclaration avec var

Instruction select

Clause Where

Instruction orderBy

Select et création de nouveaux objets

Clause Take(), Skip()

GroupBy, count(), sum(), average()

Clause Jointure - Join , LetJoin, RightJoin

Expression lambda

Programmation avec une interface graphique

Modèle d'une application GUI

Fenêtre principale, propriété, méthodes et événements

Gestion des événements clavier, souris - MouseEventArgs, KeyEventArgs

Dessiner en 2D - System.Drawing, Graphics

Formulaires - System.Windows.Forms

• Généralités
  • Mots clés du langage
  • Commentaires // et /**/
  • Bloc d'instruction avec {} et le point virgule
• Déclaration de variables et types de données scalaires
  • Notion de variable
  • Type entier - byte, bool, int, long, short,
  • Type décimal - float et double
  • Type caractère et chaîne - char, string, System.String
  • Valeurs littérales
  • Valeur null
• Types de données agrégés
  • Les tableaux - [], ArrayList
  • Les collections - LinkedList, hashtable, ArrayList, Iterator
  • Les dictionnaires - hashTable
  • Les structures - struct
  • Les templates
• Casting et conversion
  • Connaitre le Type - GetType(), isinstanceof()
  • Casting implicite
  • Casting explicite
  • Fonction Convert.toXX (), int.parse()
• Les opérateurs
  • Opérateurs - ternaire, typeof(), GetType ()
  • Opérateurs arithmétiques
  • Opérateurs relationnels
  • Opérateurs logiques
• Gestion des exceptions
  • try, catch
  • finally
  • throw
  • Instruction using
• Les chaines et formatage
  • String, System.String et méthodes
  • Formattage avec format() et $" {} "
  • StringBuffer,
  • System.Text.RegularExpressions;
• Les entrées/sorties standards
  • stdin - Console.in, Console.out, Console.err, Debug.WriteLine()
  • stdout - Console.out
  • stdout - Console.err
  • Debug.WriteLine()
• Les instructions
  • Pour les tests - if/else
  • Pour les tests - switch
  • Pour les boucles - for
  • Pour les boucles - foreach
  • Pour les boucles - while, break, continue
  • Pour les boucles - do/while
• Les fonctions et fonctionnal
  • Fonction arguments et valeur de retour
  • Passage par référence des arguments "ref"
  • Fonction anonyme lambda
  • Les délégués
  • Les fonctionnals avec Func><()
• Gestion des packages
  • Package et namespace
  • using et importation
  • Gestion de package avec nuget
• Programmation orientée objet
  • Concepts de base sur l'orienté objets
  • Class et composition - constructeurs, méthode, setter/getter, static
  • Types de classe - abstract, sealed, templates, partial
  • Surcharge de méthodes
  • Protection appliquée aux classes et membres
  • Héritage de classes
  • Redéfinition de méthode et de constructeurs
  • Polymorphisme
  • Interface
• Gestion des fichiers et répertoires
  • Package System.IO
  • File et FileStream
  • StreamReader / StreamWriter
  • BinaryReader / BinaryWriter
  • Fichiers et répertoires - StreamWriter, StreamReader
  • Fichier xml
  • Fichier json
• Accès aux bases de données
  • Accès aux bases de données avec ADO.NET
  • SqlConnection, SqlCommand, SqlDataReader
  • SqlDataAdpater, DataTable
  • SqlDataAdpater, SqlRecordSet
  • DML et SqlCommandBuilder
• Requetage object avec Linq
  • Déclaration avec var
  • Instruction select
  • Clause Where
  • Instruction orderBy
  • Select et création de nouveaux objets
  • Clause Take(), Skip()
  • GroupBy, count(), sum(), average()
  • Clause Jointure - Join , LetJoin, RightJoin
  • Expression lambda
• Programmation avec une interface graphique
  • Modèle d'une application GUI
  • Fenêtre principale, propriété, méthodes et événements
  • Gestion des événements clavier, souris - MouseEventArgs, KeyEventArgs
  • Dessiner en 2D - System.Drawing, Graphics
  • Formulaires - System.Windows.Forms;

• Généralités
  • Commentaires #
  • Bloc d'instruction avec do, done et ;
• Variables et types de données
  • Notion de variable et l'accès au contenu avec $
  • Variables d'environnement et variables prédéfinies - $_ $$ $*
  • La chaine de caractères est le seul type de données avec "" et '
  • Définit de tableau avec t=(), ${t[0]), ${#t}
• Expressions numériques
  • Au moyen expr
  • Au moyen de (())
  • Au moyen $(())
  • Au moyen (())
  • Au moyen let
  • Instriction eval
• Opérations de test
  • Test des valeurs entières avec [, [[
  • Test des valeurs de chaines avec [, [[
  • Test des fichier avec [, [[
• Opérations logiques
  • Opération ET avec &&
  • Opération OU avec ||
• Les Instructions
  • Les tests avec if
  • Les tests avec select/in/do/done
  • boucle - for/do/done, continue, break
  • boucle - while/do/done
• Les fonctions
  • Arguments passage par valeur, return - $1, $2, $3
  • Instruction d'entrée/sortie
  • Afficher echo
  • Lire au clavier read
• Les redirections et pipes
  • Les canaux 1 2 3 avec les opérations < > << >>
  • Échanges données et synchronisation en processus moyen de |
  • Script en arrière plan
• Les filtres
  • Filtre grep
  • Filtre wc
  • Filtre wc
  • Filtre cut
  • Filtre head, tail
  • Filtre tee
  • Filtre tr
• Les signaux
  • Envoi d'un signal au moyen de kill
  • Interception d'un signal et traitement avec trap
• Gestion des fichiers
  • Lire une fichier avec cat
  • Lire une fichier avec head, tail
  • Lire une fichier avec read
  • Lire une fichier par redirection >0
  • Écrire/ajouter dans un fichier par redirection 1<
• script AWK
  • Structure d'un script awk BEGIN END {} et TEST
  • Lancement d'un script en ligne de commande et passage de donnéess
  • Variables et variable prédéfinies - ARGV, NF, NR, OFS, OFS
  • Types de données - string numeric []
  • opérateurs arithmétiques, relationnels et logiques
  • Traitement des chaines et les expressions régulières
  • Traitement des tableaux
  • Instructions de contrôle pour les tests avec if/else
  • Instructions de contrôle pour les boucles avec for, while
  • Les fonctions et passage d'arguments
  • Affichage avec printf()

• Généralités
  • Mots clés du langage
  • Commentaires // et /**/
  • Commentaires et bloc d'instruction avec {}
• Déclaration de variables et types de données scalaires
  • Notion de variable
  • Type entier - byte, int, long, short
  • Type décimal - float et double
  • Type caractère et chaîne - char, String
  • Type speciaux - variant, auto, decltype, any
  • Types pointeurs - shared, unique_ptr, weak
  • Valeurs littérales et valeur NULL, nullptr_t, nullptr, initializer
  • Type utilisateur - typedef
• Type de données agrégés
  • Array - []
  • Les collections - struct
  • Les collections - list, iterator, enumeration
  • Les collections - tuple, pair
  • Les collections - vector
  • Les collections - queue
  • Les collections - map
• Casting et conversion
  • implicite
  • explicite
  • Convertions - std::to_string(), std::stoi()
• Les opérateurs
  • Opérateurs - sizeof, typeid(), ::
  • Opérateurs arithmétiques
  • Opérateurs relationnels
  • Opérateurs logiques
  • Opérateur ternaire
• Gestion des exceptions et des erreurs
  • try, catch
  • finally
  • throw, rethrow
  • assertion
• Gestion des chaînes
  • Les opérations sur les string
  • Formatage de chaine
  • RegEx
• Les I/O et les redirections
  • stdin- cin, cerr
  • stdout - cout
  • stderr - cerr
  • redirection
• Les instructions
  • Instructions de test - if, switch
  • Les fonctions de classe, arguments, passage par valeur, passage par référence, passage par pointeur
  • Fonction anonyme lambda
• Importation et namespaces
  • Définition de namespace - namespace
  • Importation - namespace, include
  • Présentation synthétique des librairies standard - std
• Programmation orientée objet
  • Concepts de base sur l'orienté objets
  • Les espaces de noms - namespace
  • Le type class - constructeurs, méthode, données membres, setter/getter
  • Constructeurs et destructeur
  • Classe abstraite - virtual, pur
  • Classe final
  • Utilisation de inline
  • Données et méthode static
  • Classe template
  • Protection appliquée aux classes et membres - public, protected, private
  • Référence implicites - this, super
  • Surcharge de méthodes et arguments par defaut
  • Héritage de classes - base et dérivée
  • Méthodes virtual et polymorphisme
  • Héritage, redéfinition et enchaniment d'appel de constructeurs
  • Polymorphisme et casting - down_cast, dynamic_cast, reinterpret_cast
  • Interface - virtual pure
  • Héritage multiple
• Gestion des fichiers et streams
  • Namespace de stream - stream, fstream, iostream, stringsteam, strstream,
  • Gestion de Fichiers - fstream
  • Gestion des répertoires - filesystem

• Généralités
  • Mots clés du langage
  • Commentaires // et /**/
  • Bloc d'instruction avec {} et le point-virgule
• Déclaration de variables et types de données scalaires
  • Notion de variable
  • Type entier - byte, bool, int, long, short
  • Type décimal - float et double
  • Type caractère et chaîne - char, String
  • Valeurs littérales
  • Valeur null
• Types de données agrégés
  • Les tableaux - [], List><, ArrayList><, Arrays.asList()
  • Les collections - LinkedList><, Set><, HashSet><, Map><, HashMap><
  • Les dictionnaires - Set><, HashSet><, Map><, HashMap><
• Casting et conversion
  • Connaitre le type - .getType(), instanceof
  • Casting implicite
  • Casting explicite
  • String.valueOf(), Integer.parseInt()
• Les opérateurs
  • Opérateurs - ternaire
  • Opérateurs arithmétiques
  • Opérateurs relationnels
  • Opérateurs logiques
• Gestion des exceptions
  • try, catch
  • finally
  • throw
• Les chaînes et formatage
  • String et méthodes
  • Formattage avec format() et "{}"
  • StringBuffer,
  • java.util.regex
• Les entrées/sorties standards
  • stdin - System.in
  • stdout - System.out
  • stderr - System.err
• Les instructions
  • Pour les tests - if/else
  • Pour les tests - switch
  • Pour les boucles - for
  • Pour les boucles - while, break, continue
  • Pour les boucles - do/while
• Les fonctions
  • Fonction arguments et valeur de retour
  • Passage par référence des arguments "ref"
  • Fonction anonyme lambda
  • Les fonctionnels avec java.util.function.Function, apply
  • Les fonctionnels avec java.util.function.BiFunction, apply
  • Package et namespace
  • Importation avec import
  • Constituer un archivage jar - jar
  • Invoquer un jar en tant que libraire en ligne de commande
  • Invoquer un jar en tant que executable en ligne de commande
• Programmation orientée objet
  • Concepts de base sur l'objet
  • Class et composition - constructeurs, méthode, setter/getter, static
  • Types de classe - abstrait, sealed, template, partial
  • Surcharge de méthodes
  • Protection appliquée aux classes et membres
  • Héritage de classes
  • Redéfinition de méthodes et de constructeurs
  • Polymorphisme
  • Interface
• Gestion des fichiers et répertoires
  • Package java.io, File, FileWriter, FileReader
  • FileInputStream / FileOutputStream
  • BufferedReader / BufferedWriter
  • Fichiers et répertoires - FileSystem
• Les streams
  • java.util.stream, stream()
  • map, filter, collect()
  • reduce()
  • distinct(), sorted()
• Accès aux bases de données
  • Accès aux bases de données avec Jdbc
  • DriverManage et connexion
  • Statement et PreparedStatement pour de l'SQL - execute(), executeQuery(), executeUpdate()
  • ResultSet pour les résultats de la requête

• Généralités
  • Mots-clés du langage
  • Commentaires // et /**/
  • Bloc d'instruction avec {} et le point-virgule
• Déclaration de variables et types de données scalaires
  • Notion de variable - var, const, _, >-, :=
  • Portée de variables - globale, locale
  • Type de données scalaires - int, float32, float64, byte, char, string
  • Type entier - byte, int, int8, int16, int32, int64
  • Type décimal - float32, float64
  • Type booléen - bool
  • Type caractère et chaine - string, strings.Builder
  • Valeurs littérales
  • Valeur nil
• Type de données agrégés
  • Les tableaux et slices - make
  • Dictionnaire map
  • Types utilisateurs avec type
  • Types utilisateurs avec struct
  • Type de données spécial - pointeur, defer
• Casting et conversion
  • Connaître le Type - GetType(), isinstanceof()
  • Casting implicite
  • Casting explicite
  • Package strconv, fmt
• Les opérateurs
  • Opérateurs - reflect.TypeOf()
  • Opérateurs arithmétiques
  • Opérateurs relationnels
  • Opérateurs logiques
  • Opérateurs ternaire
  • Opérateurs affectation :=
  • Opérateurs pointeurs - * &
• Gestion des exceptions
  • Package errors
  • Panic, defer, recover()
• Les chaines et formatage
  • Package strings, fmt
  • Package unicode
  • Formattage avec Printf, Sprintf
  • Package regexp pour les expressions régulières
• Les entrées/sorties standards
  • stdin - bufio, ScanIn, fmt, os, io
  • stdout - Printf, os.Stdout, Fprintf
  • stderr - os.Stderr
• Les instructions
  • Pour les tests - if/else
  • Pour les tests - switch
  • Pour les boucles - for/range
  • Pour les boucles - while, break, continue
• Les fonctions
  • Fonction arguments et valeur de retour - func
  • Passage par référence des arguments
  • Paramètres variadiques - ...
  • Fonction anonyme
  • Types utilisateurs avec type pour une fonction
  • Définition d'interface
• Gestion des packages
  • Package, module et namespace
  • Importation de package dans le code
  • Création d'un package et conventions
  • Gestion de package avec go get, go mod
  • Packages standard - math, time, json, text
• Gestion des fichiers et répertoires
  • Package os - Open(), OpenFile(), Close(), Stat()
  • Ecriture dans le fichier - Write
  • Lecture depuis le fichier - Read
  • Position dans le fichier - Seek(), Tell()
  • Droits de fichiers - Chmod()
  • Les scanners, seekers, sections
  • Les pipes
• Accès aux bases de données
  • Package database/sql et drivers
  • Gestion des connexions - sql.Open, DSN, PingContext
  • Créer une structure de table - db.ExecContext()
  • Manipulation des données DML - db.Prepare, Stmt.Exec()
  • Gestion des transactions - Begin(), RollBack(),
• Programmation avec une interface graphique
  • Package gogpu/ui - NewContext
  • Dessin 2D - DrawCircle, DrawRectangle(), SetLineWidth()
  • Couleurs 2D - SetRGB(), Fill()
  • Couleurs Text, Font et Style - widgets(), WithStyle(), SetFontFace()
  • Événements souris - ui.AttachEvents, OnMouseMove()
  • Événements clavier - widgets , OnKeyXX()
  • Formulaires avec widgets et événements

• Généralités
  • Les mots clés
  • Commentaires // et /**/
  • Bloc d'instruction avec {} et le point virgule
• Notion de variable et types scalaires
  • Type de données scalaires - int, long, short, float, char, char*
  • Portée de variables - globale, local , extern, static
  • Valeurs littérales et valeur null, undefined
• Type de données agrégés
  • La liste - list []
  • L'objet - object, {}
  • Une map - map
  • Enumération - enums
• Les opérateurs
  • Opérateurs arithmétiques
  • Opérateurs relationnels
  • Opérateurs logiques
  • Opérateur - ternaire
• Les chaines
  • fonctions relatives à une chaine
  • formatage et interpolation
  • Expression régulière - RegExpr
• Les Instructions
  • Le test - if/else
  • Le test - switch
  • La boucle - for/in, continue, break
  • La boucle - for/of
  • La boucle - while
• Les fonctions
  • Les fonctions, passage arguments, return
  • Fonction anonyme
  • Fonction lambda
• Gestion des exceptions
  • Le bloc try, catch
  • Le bloc finally, throw
• Programmation orientée objets
  • Une classe, attributs et constructeur
  • Types de classes - abstract, sealed, imbriquées
  • Visibilité des membres
  • Data Classes
  • Enum Classes
  • Héritage de classes
  • Polymorphisme
  • Interface
  • Présentation synthétique des classes prédéfinies basiques
  • Packages et imports - require, from/import
• La programmation asynchrone
  • promise, await, async
  • fetch avec GET
  • fetch avec POST

• Installation et Environnement
  • Vérification de l'installation de Node.js et npm (`npm --version`, `node --version`).
  • Installation de l'écosystème Angular via Angular CLI (`npm install -g @angular/cli`, `ng version`).
  • Configuration de TypeScript (`tsconfig.json`) pour les projets Angular.
  • Commandes utiles et options indispensables de npm.
  • Commandes utiles et options indispensables de npx.
• Ma première application avec un seul composant
  • Créer un projet Angular avec options de configuration via le CLI (`ng new`).
  • Explication détaillée de l'organisation et de l'arborescence du projet.
  • Architecture d'un composant : répartition du code (Logique TypeScript, Rendu HTML, Styles CSS/SCSS).
  • Métadonnées du composant (`@Component`, `selector`, `templateUrl`, `styleUrls`, mode Standalone).
  • Cycle de développement d'une application (`ng serve` pour le dev, `ng build` pour la production).
  • Lancement et exécution de l'application locale.
• Structure d'un composant - Création en CLI
  • Générer un composant de manière automatisée avec Angular CLI (`ng generate component`).
  • Configuration du composant : propriétés de classe, méthodes et gestion des importations.
  • Organisation interne du code d'un composant (Logique vs Structure de rendu).
  • Propriétés d'affichage : liaison de données de base (Interpolation avec les doubles accolades `{{ }}`).
  • Liaison de méthodes : exécuter des actions de la classe depuis le template.
• Utilisation et cycle de vie d'un composant
  • Importation et déclaration d'un composant dans un autre composant ou un module.
  • Cycle de vie d'un composant : hooks principaux (`ngOnInit`, `ngOnChanges`, `ngOnDestroy`).
  • Communication entre composants : transmission de paramètres (`@Input()`) et émission d'événements (`@Output()`, `EventEmitter`).
  • Gestion des types de composants : composants fonctionnels légers vs composants lourds avec cycle de vie.
  • Données et comportements complexes : propriétés calculées nativess ou signaux.
  • Approche moderne (Standalone Components) vs Approche classique (NgModule).
• Template et rendu d'un composant
  • Syntaxe des templates Angular et notions de rendu basées sur le HTML.
  • Directives d'instructions logiques et de boucles : syntaxe de contrôle moderne (`@if`, `@else`, `@for`, `@switch`).
  • Directives de liaison et de manipulation des éléments : `[(ngModel)]` (double sens), `[ngStyle]`, `[ngClass]`, directives d'attributs.
  • Événements du composant et liaison avec le template (Property Binding `[]` et Event Binding `()`).
  • Gestion des événements natifs du DOM.
  • Animations et transitions avec le module `@angular/animations`.
• Composants UI et Interaction Utilisateur
  • Architecture de navigation : gestion de menus dynamiques (structure simple vs arborescence imbriquée).
  • Boîtes de dialogue (Modales) : création de fenêtres overlays réutilisables en exploitant la projection de contenu.
  • Projection de contenu : utilisation de `>ng-content<` (les slots d'Angular) pour créer des composants conteneurs flexibles.
• Routage des composants
  • Configuration du routage de l'application : associer des chemins (routes) à des composants spécifiques.
  • Navigation imbriquée : configuration des routes enfants (`children`) et affichage secondaire via `>router-outlet<`.
  • Gardiens de navigation (Guards) : sécuriser et restreindre l'accès à certaines pages selon des conditions.
• Gestion de l'état et réactivité
  • État local vs État partagé : utilisation de `Signal` (réactivité fine) et gestion des valeurs mutables.
  • Introduction à la gestion globale des flux : Services partagés avec RxJS (`BehaviorSubject`) ou gestion d'état centralisée (NgRx / Ngxs).
  • Réaction intelligente aux changements de données : signaux calculés (`computed()`) et effets secondaires (`effect()`).
• Gestion des formulaires et communication API
  • Présentation des formulaires HTML et gestion de la soumission de données.
  • Formulaires Angular : approche par les gabarits (Template-driven) et approche réactive (`FormGroup`, `FormControl`).
  • Soumission, validation des champs et sérialisation des données en JSON.
  • Échanges de données avec un service REST via le module client HTTP (`HttpClient`).
• Qualité et Tests unitaires
  • Démarche générale de validation et cycle en V.
  • Utilisation de l'environnement de test natif (mise en place avec Web Test Runner / Vitest).
  • Comment tester une classe TypeScript simple (services ou modèles).
  • Comment tester un composant graphique (cycles de vie, détection des changements et rendu du DOM).
  • Présentation de l'API de test (assertions et utilitaires de test d'Angular : `TestBed`, `fixture`).

• Les modules
  • Inclusion de modules avec require ou import
  • nodejs avec js
  • nodejs avec ts
  • Définition de modules et résolution des noms, chemins et fichiers
  • Présentation de quelques modules populaires - express, Console, Util, http, net, dns et url, fs
  • commandes de gestion package et projets - npm, npx
  • Nodejs Global objects - process
• Nodejs en tant que serveur d'application Web avec express/ejs
  • Présentation de l'API express - app.set(),app.listen(),app.use()
  • Ajouter de modules complémentaires - bodyParser.urlencoded(), bodyParser.json()
  • Gestion des requetes GET, POST , Routes - server.get()/post()
  • Ressources statiques/reponses - express.static(), res.sendFile()
  • Présentation du moteur de templates EJS - app.set('view engine', 'ejs')
  • Langage EJS >%- include, >%=name%< , >% data.forEach()%< >res.render()
  • Gestion d'erreurs
• Mise en oeuvre de packages standards
  • Variables d'environnement - Dotenv
  • Acces réseaux - net
  • Packages http, https
  • Accès async au système de fichiers - fs, path
  • WebSocket - ws, socket.io
• Services REST
  • Structure d'un service Rest - GET, POST, PUT, DELETE
  • Module de parsing Json
  • Module Cors pour le cross domaine
  • Conception d'un service REST
  • Echange client avec Js/fetch
  • Echange client avec curl
  • Mise en oeuvre de axios
• Accès aux bases de données
  • Concepts de base et ORM relatif à SQL, et noSQL
  • SQL avec l'ORM sequelize - sequelize.define(), Model.User.findAll().then()
  • noSQL avec l'ORM mongoose - mongoose.Schema(), >Model<.find()
• Client pour Nodejs
  • Vue.js client Rest pour afficher une liste de articles
  • React client Rest pour afficher une liste de articles
  • Angular client Rest pour afficher une liste de articles

• Déclaration de variables et types scalaires
  • var, const, final, dynamic, static , ?
  • Les numériques - int, double, num
  • Les chaines (immutable) - String, StringBuffer, runes, """ '''
  • Le type bool
  • Le type DateTime, Duration
  • Le type Enum
  • Le type Symbol
  • type user - typedef
  • Valeurs littérales et valeur Null
  • Connaitre le type .runtimeType
• Types de données aggrégés
  • Object
  • Liste List><, []
  • Dictionnaires Map><, MapEntry><, Set><
  • File d'attente Queue><
  • Extension de types
  • Iterable et Iterator
• Casting et conversion
  • toString()
  • toDouble()
  • toInt()
  • parse()
  • tryParse()
• Les opérateurs
  • Opérateurs arithmétiques
  • Opérateurs relationnels
  • Opérateurs logiques
  • Opérateurs - affectation
  • Opérateurs - ternaire
• Les chaines de caractères
  • Fonction sur les chaines - split(), length, [], replaceAll(), encodage
  • formatage - "${}",
  • Expression reguliere - RegExp, RegExpMatch
• Les instructions
  • Test avec if/then/else
  • Test avec switch
  • Boucles - for, foreach
  • Boucles - while, do/while
• Les fonctions
  • Les arguments , passage par reference, return
  • Fonction extension
  • Fonction Lambda - ()=<{}
• Gestion des erreurs et exceptions
  • try et catch
  • finally et throw
• Programmation asynchrone
  • Futures, async, await
• Programmation orienté objet
  • Classe, constructeur, setter/getter
  • Surcharge de méthode
  • Protection public, private des membres de classe
  • Modificateurs abstract, final, sealed, mixin, base
  • Modificateurs mixin
  • Modificateurs interface
  • Gestion d'une data class - @Data()
  • Héritage et redéfinition - @data, @override
  • Serialisation Json avec json_serializable - @JsonSerializable(), fromJsonn jsonDecode
• Gestion packages
  • pubspec.yaml et les dépendances
  • Importation de packages
  • Commandes - dart pub operation - get, upgrade, outdate
  • Package connus - dart:io, ...

• Introduction
  • Compare SQL, PL/SQL, pgsql, t- sql
  • Concepts et terminologies - bases, schemas, tables, colonnes, index, cle primaire
  • Les groupes de commandes DDL, DML et DCL
  • Requêtes de recherche complexes - jointures, imbriquées
  • Notion de script SQL
• Concevoir une base de données
  • Modèle Conceptuel de données ou MCD : tables et relations
  • Création de la base de données
  • Création des tables et relations : types, contraintes, notions d’index
  • Instructions NOT NULL, UNIQUE, PRIMARY, FOREIN
  • Sécurité et permissions
• Contraintes de tables
  • Contraintes NOT NULL, UNIQUE, CHECK et DEFAULT
  • Gestion des clés étrangères avec ON DELETE, ON UPDATE
  • Règles de gestions : CASCADE, SET NULL et SET DEFAULT
• Gestion des données au moyen de requêtes
  • Insertion de données - INSERT
  • Modification de données - UPDATE
  • Suppression de données - DELETE
  • Instruction select et les options
  • SELECT des colonnes d'une table - colonne, *
  • SELECT et colonnes dynamiques - AS
  • Instructions DISTINCT
  • Clause FROM et alias de tables
  • Prédicats de WHERE - LIKE, BETWEEN, IN, AND, OR et NOT
  • Ordonner le résultat avec ORDER BY
  • Prise en compte des valeurs NULL - IS NULL
  • Instructions OFFSET/FETCH/LIMIT
• Utiliser des fonctions
  • Concept et définition
  • Fonctions de chaine
  • Fonctions mathématiques
  • Manipulation des dates et format
  • Fonctions de conversion
• Les sous requêtes ou requête imbriquées
  • Sous requête dans l'instruction FROM
  • Sous requête dans a clause WHERE
  • Prédicats EXISTS, NOT EXISTS
• Regrouper des résultats avec GROUP BY
  • Création de regroupements sur la base de colonnes - GROUP BY
  • Regrouper et compter - COUNT
  • Regrouper et calculer la somme - SUM
  • Regrouper et calculer la moyenne - AVG
  • Filtre sur regroupements - HAVING
• Requetes sur plusieurs tables avec les jointures
  • Produit cartésien
  • Les Jointures de tables - inner, outer, natural, full
  • Les Jointures avec des sous requetes
  • Instruction With
• Fonctions de ranking et fenêtrage
  • Concepts et définitions
  • Effectuer un classement avec RANK() OVER
  • Effectuer un classement avec DENSE_RANK() OVER
  • Création PARTITION OF/FOR VALUES FROM/TO
  • Clause OVER() et prédicat PARTITION BY - COLUMN, RANGE, LIS, HASH

• Généralités
  • Mots clés du langage
  • Commentaires // et /**
  • Bloc d'instruction avec {} et le point virgule
• Déclaration de variables et types de données
  • Notion de variable - var_dump, print_r, define, const
  • Type de données scalaire : int, boolean, double, string...
  • Type de données agrégé : array, object
  • Valeurs littérales et valeur NULL
  • unset(), isset()
• Les Opérateurs
  • Opérateurs arithmétiques
  • Opérateurs relationnels
  • Opérateurs logiques
  • Opérateurs : list, gettype, del, sizeof, count
• Les Instructions
  • Boucles avec : for, continue, break
  • Boucles avec : foreach
  • Boucles avec : while, do/while
  • Tests avec : if/else
  • Tests avec : switch
  • Tests avec : match
  • Tests avec : opérateur ternaire
• Les fonctions
  • Les arguments et valeur de retour
  • Passer un tableau en argument
  • Lambda - fn
• Gestion Erreurs et des exceptions
  • try, catch
  • finally
  • throw
  • display_errors, error_reporting
• Les chaînes et formatage
  • String, méthodes et caractères spéciaux
  • Formattage "${}", sprintf()
  • Expression régulière - preg_match, preg_match_all, preg_replace
• Gestion des librairies
  • Librairie et namespace
  • Pour les modules - include
  • Pour les modules - require et require_once
  • Pour les namespace - use
• Gestion des fichiers
  • Création et existence - fopen(), fclose(), file_exists()
  • Écrire dans un fichier texte - fwrite(), fputs()
  • Position dans un fichier - fseek(), ftell()
• Les échanges avec HTTP
  • Les verbes http avec $_GET, $_POST
  • Sessions - session_xxx() , SESSION
  • Sessions et cookie, $SESSION, $COOKIE
  • Filtrage sur les entrées http avec filter_xxx ()
  • Envoyer un fichier sur http - readfile()
• Applications front
  • Intégration PHP avec HTML, CSS
  • Intégration PHP avec BOOSTRAP5
  • Gestion des formulaires
  • Formation des échanges avec json - json_encode, json_decode
  • Upload de fichier : FILE
• Accès aux bases de données (Mysql)
  • Gestion de la base Mysql au moyen des API - connexion, insert, select, update, delete
  • Gestion de la base Mysql au moyen des PDO - connexion, insert, select, update, delete
• Programmation orientée objet
  • Classe données et méthodes membres
  • Constructeur et destructeur - parent, __construct, __destruct
  • Setter et getter
  • Instance de classe et objet - new , $this, $self, $parent
  • Protection public, protected, private
  • Surcharge et redéfinition
  • Héritage - extends
  • Interface
  • Namespace dans PHP et use - namespace, use

• Architecture et fondamentaux
  • Rappels sur le système MOC (Meta-Object Compiler) et les macros Qt
  • Gestion fine de la mémoire : `QObject`, hiérarchie parent-enfant et pointeurs intelligents (`QPointer`, `QScopedPointer`)
  • Signaux/Slots : connexions avancées (Lambda expressions, `Qt::QueuedConnection`)
• Application minimale et fenêtre principale
  • Fenêtre principale - `QMainWindow`
  • Propriétés
  • Cycle de vie et événements - `event()`, `eventFilter`, `keyPressEvent`, `mousePressEvent`
  • Menus, icônes et actions- QMenuBar, QIcon, QAction, QMenu
  • Barres d'outils - QToolBar
  • Barre de status - QStatusBar
  • Systèmes de ressources Qt (`.qrc`) pour l'embarquement de fichiers (images, styles)
  • Créer une nouvelle fenêtre et passer des parametres
• Gestion de formulaires et validation de données
  • Gestion de l'agencement - `QLayout`, QFormLayout, QVBoxLayout, QHBoxLayout, QGridLayout
  • Présentation des Widgets - par catégorie
  • Widgets de boutons - QPushButton, QCheckBox, QRadioButton
  • Widgets de Saisie - QLabel, QLineEdit, QPlainTextEdit ,QSpinBox ,QDateEdit, QSlider
  • Widgets de listes - QComboBox, ListView, QTreeView
  • Gestion des widgets de visualisation de données - QTableView et QListView
  • Widgets de listes - QComboBox, ListView, QTreeView
  • Progressbar - QProgressBar
  • Affichage complexes - `QStackedWidget`, `QTabWidget`
• Boîtes de dialogues
  • Coder avec QMessageBox
  • Coder avec QInputDialog
  • Coder avec QProgressDialog
  • Coder avec QFontDialog
  • Coder avec QColorDialog
  • Boite de dialogue personnalisée - QDialog
• Industrialisation avec Qt Designer
  • Workflow Qt Designer - Utilisation de l'outil visuel pour concevoir rapidement des `QMainWindow`.
  • QtDesigner - Chargement dynamique des fichiers `.ui` (via `uic.loadUi`).
  • Génération de code Python à partir des fichiers `.ui` (via `pyuic`) pour une intégration plus poussée.
  • MVC vs Modèle-Vue-Délégant - Comprendre pourquoi Qt sépare la donnée de l'affichage.
• Gestion fichiers et des formats XML JSON
  • Manipulation de fichiers : `QFile`, `QDir`, `QFileInfo` et flux de données (`QDataStream`)
  • Travailler avec Csv
  • Travailler avec XML
  • Travailler avec Json
  • Utilisation des composants - QAbstractTableModel, QAbstractListModel
• Dessin et Graphismes 2D
  • Dessin personnalisé - QWidget/Canvas, QPainter, QPaintEvent, `paintEvent` :
  • Dessiner des formes - drawLine(), drawRect(), drawEllipse()
  • Gestion du texte, font et couleur
  • pen et brush - QPen, QBrush
  • Afficher une image - png, jpeg
  • Graphics View Framework : Scène, Items et transformations (Zoom, Rotation)
• Multithreading et Asynchronisme
  • Différence entre `QThread` et les workers (`moveToThread`)
  • Synchronisation : `QMutex`, `QWaitCondition`, `QReadWriteLock`
  • Programmation asynchrone pour éviter le blocage de l'interface (GUI responsive)
• Communication réseaux
  • Présentation des l'API Socket - QtNetwork, QSocket, QHostAddress
  • Echange avec les Socket Tcp - QTcpServer, QTcpSocket
  • Echange avec les Socket Udp - QUdpSocket
  • Http avec QNetworkAccessManager, QUrl, QNetworkRequest, QNAM.get(), QNAM.post(), QNetworkReply
  • API Rest avec ApiClient et le format json

• Généralités
  • Mots clés du langage
  • Commentaires `#` et `#= =#`
  • Blocs d'instructions (mots-clés `begin` / `end` et absence de point-virgule obligatoire)
• Déclaration de variables et types de données scalaires
  • Notion de variable (`let`, `const`, affectation dynamique)
  • Portée des variables (globale, locale)
  • Type entier (`Int8`, `Int16`, `UInt8`, `UInt16`, `Int64`)
  • Type décimal (`Float32`, `Float64`)
  • Type booléen (`Bool`)
  • Type caractère et chaîne (`Char`, `String`)
  • Valeurs littérales
  • La valeur `nothing` (équivalent de l'absence de valeur / NULL)
  • Gestion de la mémoire (références, mutabilité et ramasse-miettes / Garbage Collector)
• Types de données agrégés
  • Les tableaux et listes (Matrices, Vecteurs, Slices et Tuples)
  • Les structures (`struct` immutables et `mutable struct`)
  • Dictionnaires (`Dict`)
  • Vecteurs dynamiques (`Vector{T}`)
  • Types abstraits (`abstract type`)
  • Énumérations (Macro `@enum`)
• Conversion et typage
  • Conversion explicite (Fonction `convert()`, constructeurs de types)
  • Interpolation de chaînes (Syntaxe `"$variable"`)
  • Analyse de chaînes (Fonction `parse()`)
  • Promotion automatique de types (`promote`)
• Les opérateurs
  • Opérateurs arithmétiques (incluant la multiplication implicite comme `2x`)
  • Opérateurs relationnels et de comparaison
  • Opérateurs logiques (`&&`, `||`, `!`)
  • Opérateurs d'affectation
  • Opérateurs ternaires (Syntaxe `condition ? expression1 : expression2`)
• Gestion des exceptions et erreurs
  • Les types d'exceptions standards (`Exception`, `ArgumentError`, `LoadError`)
  • Blocs de capture (Structures `try`, `catch`, `finally`)
  • Levée d'exceptions (Fonctions `throw()` et `error()`)
• Les chaînes et formatage
  • Opérations sur les chaînes de caractères (Concaténation avec `*`, fonctions de manipulation)
  • Fonctions de formatage (Macro `@printf` du package standard `Printf`)
  • Expressions régulières (Syntaxe native `r"..."` et fonctions `match()`)
• Les entrées/sorties standards
  • Entrée standard (Lecture console avec `readline()`)
  • Sortie standard (Fonctions `print()`, `println()`, `flush()`)
  • Exploration du système (Fonctions standards du système de fichiers comme `readdir()`)
• Les instructions de contrôle
  • Structures conditionnelles (Instructions `if`, `elseif`, `else`)
  • Évaluation à court-circuit
  • Boucles itératives (Instructions `for` / `in`)
  • Boucles conditionnelles (`while`, instructions `break` et `continue`)
  • Introduction aux macros (Syntaxe avec le symbole `@`)
• Les fonctions et le Multiple Dispatch
  • Arguments de fonctions et valeur de retour (Mot-clé `return` optionnel)
  • Passage d'arguments par référence (Mutabilité des objets passés en paramètres)
  • Arguments optionnels, arguments par défaut et arguments nommés (`keyword arguments`)
  • Fonctions génériques et mécanisme central du **Multiple Dispatch*- (Surcharge par les types)
  • Fonctions anonymes et Lambdas (Syntaxe `x -< x - 2`)
• Gestion des modules et des packages
  • Espaces de noms (Déclaration avec `module` et structures internes)
  • Importation de fonctionnalités dans le code (Mots-clés `using` et `import`)
  • Le gestionnaire de packages natif `Pkg` (Commandes de l'environnement REPL : `add`, `activate`, `instantiate`)
• Gestion de la robustesse et types optionnels
  • Gestion des valeurs manquantes (Types `Missing` et `Nothing`)
  • Filtrage et sécurité (Fonctions `coalesce()`, `isnothing()`, `ismissing()`)
  • Assertions de sécurité (Macro `@assert`)
• Programmation orientée objet en Julia
  • Concepts de l'orienté objet appliqué à Julia (Séparation stricte des données et des comportements)
  • Structures de données composites (`struct`) et fonctions associées
  • Organisation des modules et contrôle de l'accès aux membres (`export`)
  • Gestion de la hiérarchie par la composition et l'héritage de types abstraits
  • Polymorphisme natif basé sur le système de types de Julia
• Gestion des fichiers et répertoires
  • Concepts généraux sur les flux de données (*Streams*) et les fichiers
  • Utilisation des fonctions natives d'E/S (Blocs sécurisés `open() do f`)
  • Actions sur les fichiers (Fonctions de lecture et d'écriture `read()`, `write()`, `readsplit()`)
• Accès aux bases de données
  • Concepts généraux sur l'accès aux données permanentes en Julia
  • Utilisation de l'interface unifiée pour les bases relationnelles (`DBInterface.jl`)
  • Connexion et paramétrage (Utilisation de connecteurs dédiés comme `MySQL.jl`, `SQLite.jl`, ou `Mongoc.jl` pour MongoDB)
  • Définition et exécution de requêtes de structures (DDL) et de manipulation de données (DML/SQL)
  • Gestion des transactions de données de manière sécurisée

• Généralités
  • Commenter une ligne //
  • Commenter un bloc de lignes /* */
• Type de données scalaires
  • Notion de variable
  • Les entiers int, long, short et littéraux
  • Nombres à virgule et littéraux
  • Boolean et littéraux
  • Taille en mémoire sizeof
• Casting et conversion
  • implicite
  • explicite
  • atoi(), sprintf("%")
• Type de données agrégés
  • Tableau - []
  • Chaine - type[], ""
  • Donnée structurée - Struct{}
  • Enum
  • Typedef
• Type de données pointeur
  • Type pointeur et variable pointeur
  • Pointeur sur un entier - type *
  • Pointeur sur un nombre à virgule - type *
  • Pointeur sur un tableau ou chaine - type *
  • Pointeur sur un type struct struct *
  • Opérateurs & -<
  • Opérateur sizeof
• Les Opérateurs arithmétiques
  • Opérateurs +, - , ++, --
  • Opérateurs %, , /
  • Affectation a>op<=1 (op=+,-,%...)
  • Opérateurs ternaire ?
• Opérateurs logiques
  • Opérateurs && et ||
  • Opérateurs bitewise & et |
  • Affectation a>op<=1 (op=&,|)
• Opérateurs relationnels
  • Opérateurs < <=
  • Opérateurs > >=
• Instructions de boucles
  • Fin d'instruction et instruction nulle avec ;
  • Notion de bloc d'instruction
  • Boucler avec for
  • Boucler avec while
  • Boucler avec do/while
  • Sortie de boucle avec continue,break
  • Sortie de boucle avec goto
• Instructions de teste
  • Test avec if, else
  • Test avec switch
• Notion de fonction ou bloc d'instructions
  • Déclaration d'un prototype de la fonction
  • Constitution du code de la fonction
  • Passage d'arguments pour une fonction et valeur de retour
  • Pas de valeur de retour avec void
  • Passer des arguments de types scalaires - int, float
  • Passer des arguments types agrégés - chaine, struct
• Portée de variables
  • Variable locale ou globale
  • Durée de vie et visibilité
  • Marqueur static, extern
• Les librairies de fonction
  • stdio, stdlib, string
  • Gestion de stdin, stdout [ scanf(), gets(), puts(), printf()]
  • Gestion de chaines [strcpy, strcmp, strlen]
• Précompilateur `#`
  • Instruction #include
  • Compilation conditionnelle - #ifdef, #ifndef
  • Déclaration avec #define pour une constante
  • Déclaration avec #define pour une fonction/macro
• Gestion de fichiers bufférisés de type FILE
  • Ouvrir et fermer un fichier - fopen(), fclose()
  • Écrire - fprintf(), fputs(), fwrite (), fflush()
  • Lire - fgets(), fscanf(), fwread ()
  • Position dans un fichier - fseek(), ftell(), rewind()
• Allocation dynamique (heap ou tas)
  • Allouer de la mémoire dynamique avec malloc(), calloc(), realloc()
  • Libérer la mémoire avec free()
  • Allouer des quantités scalaires
  • Allouer des quantités agrégées

• Généralités
  • Mots clés du langage
  • Commentaires // et /**/
  • Bloc d'instruction avec {} et le point virgule
• Déclaration de variables et types de données scalaires
  • Notion de variable - const, let, mut, _
  • Portée des variables - globale, locale
  • Type entier - i8, i16, u8, u16,
  • Type décimal - f32, f64
  • Type booléen - Boolean
  • Type caractère et chaine - str
  • Valeurs littérales
  • Valeur NULL
  • Types pointeur, &, Box, référence et propriété
• Type de données agrégés
  • Les tableaux et listes - arrayslices, List, Tuple
  • Les structures - struct
  • Dictionnaire - HashMap
  • Vecteur - Vec
  • Trait - trait
  • Enum
• Casting et conversion
  • Opérateur as
  • Interpolation "{}"
  • .to_int_unchecked::><()
  • std::convert::From - String::from()
  • std::convert::Into - int.into()
• Les opérateurs
  • Opérateurs arithmétiques
  • Opérateurs relationnels
  • Opérateurs logiques
  • Opérateurs d'affectation
  • Opérateurs ternaires - if/else
• Gestion des exceptions et erreurs
  • std::error::Error, Error, Err()
  • match, ok()
  • rust_try_catch::{try_catch, tri};
  • rust_try_catch::throw;
• Les chaines et formatage
  • Opérations sur les string - String::new()
  • String::from_xxx(), {}
  • Expression régulière - Regex()
• Les entrées/sorties standards
  • std::io, stdin.lock().read_line(), BufReader::new(),Cursor::new()
  • stdout - io::stdout(), writeln!(), println!()
  • package std::fs - read_dir()
• Les instructions
  • Pour les tests - if, let, else
  • Pour les tests - match
  • Pour les boucles - for/in
  • Pour les boucles - while/let, break, continue
  • Pour les boucles - loop/label
  • Annotation avec #[] - #[derive(Debug)], #[allow(dead_code)]
• Les fonctions
  • Fonction arguments et valeur de retour
  • Passage par copie et par pointeur des arguments
  • Argument par défaut
  • Fonction et généricité ><
  • Fonction Lambda ||-<{}
• Gestion des packages
  • Package, module et namespace - package
  • Importation de package dans le code - use, mod
  • Outil cargo - run, build
• Gestion des erreurs
  • match/OK()/Err()
  • expect(), panic!()
  • unwrap ()
  • get_or_insert (),Result>T, E< ,OK()
• Programmation orientée objets
  • Concepts de base sur l'objet et encapsulation
  • Structures et composition : constructeurs, méthodes et fonctions associées
  • Protection appliquée aux membres avec la visibilité
  • Gestion de l'héritage par la composition
  • Interfaces et polymorphisme avec les traits
• Gestion des fichiers et répertoires
  • Concepts généraux sur les streams et fichiers
  • Présentation des packages std::fs, std::io, std::path
  • Fichiers et répertoires - open, create, read_lines, read_to_string(), write_all
• Accès aux bases de données
  • Concepts de base
  • Présentation de l'ORM diesel et annotation #[]
  • Présentation de l'ORM sqlx
  • Connexion et parametrage - Mysql, mongoodb
  • Gestion de la Structure de données - Table DDL
  • Gestion des transactions - transaction
  • Manipulation des données - sqlx::query, fetch_one, diesel::dsl::select()