Le code n’est plus l’élément central dans la vie du développeur
aujourd’hui, le code est devenu une commodité, même quelqu’un qui ne sait pas coder peut demander à une IA de coder pour lui.
Le développeur nouvelle mouture, n’a plus à se soucier de coder à la main toutes les lignes. Mais alors que doit faire un développeur? s’il ne code plus que doit il faire?
Le code est une tâche technique très bien cadrée par l’IA
Avec les progrès des LLM, coder devient de plus en plus une activité dévolue à l’IA. Le développeur, loin de chômer doit s’attaquer à d’autres front. En effet, aujourd’hui je délègue 100% du design front end au LLM. J’interviens en amont, lors de la modélisation du logiciel, et encore je me fais aider par l’IA. Pourquoi? je pense tout simplement c’est l’envie de voir rapidement le résultat. Mais attention je ne dis pas que c’est ce qu’on doit faire.
Que devient le développeur? et surtout le développeur junior?
Aujourd’hui, je planifie beaucoup, tout seul, en peu de temps, autant vous dire que je ne fais pas les choses de façon idéale. Je me mets comme mission d’améliorer ce type de travail, en faisant ce que ne je ne faisais jamais : passer plus de temps sur le cahier des charges. Avant j’avais une idée globale assez claire et je codais directement sur mon IDE. Le MCD? c’est sur une feuille de papier, les tables je les faisais à la main. Pas de test unitaire, pas le temps. Je me rends compte que quand le logiciel appartient à une certaines typologie de logiciel, il faut absolument prendre une méthode de conception logicielle, en passant du temps sur les spécifications que l’IA doit respecter.
Je dois même parler d’agent maintenant pour subdiviser le travail, paralléliser, faire collaborer les agents. Ainsi un agent viendra contrôler le respect des spécifications du code produit par un autre agent. Tout ceci s’explique par le fait que l’agent de code peut vous rendre une travail bâcler malgré un prompt clair. Vous ne devez jamais assumer que l’IA fait un travail correct, il faut le challenger.
Marché de l’emploi développeur web en 2026 en situation délicate
Le travail du développeur est chamboulé, et beaucoup de gens sont en perte de repère actuellement, on a peur que l’IA nous remplace, tellement il est bon dans le code, pour autant beaucoup de sociétés ne sont pas encore passées à l’IA agentique.
J’ai envie de voir le verre à moitié plein
En tant qu’entrepreneur, j’ai tendance à voir le bon côté des chose, à être optimiste. Bien sûr l’IA à un impact direct sur le taux d’emploi des junior, mais pas aussi exagéré que certains vendeurs de solution LLM le disent(n’est pas Anthropic ?)
Les bon points : le junior peut faciliter son onboarding beaucoup plus facilement qu’avant. Jadis la période la plus redoutée est la période d’essais, on nous donne des bugs à corriger, de plus en plus ardus afin qu’on monte en compétence graduellement. Mais malgré cela, ça peut être stressant, on a peur de ne pas pouvoir résoudre un bug.
Pourquoi les “AI harness” deviennent plus importants que les modèles eux-mêmes
Depuis quelques mois, un nouveau terme revient partout dans l’écosystème IA : le “harness”. Derrière ce mot un peu technique se cache pourtant une idée centrale dans l’évolution des agents IA modernes. Et parmi les projets qui cristallisent cette tendance, il y a Pi.
Pi se présente comme un “minimal terminal coding harness”. Dit autrement : une couche logicielle légère qui transforme un modèle de langage en véritable agent opérationnel.
Le point important, c’est que Pi ne cherche pas à être un simple chatbot. Son rôle est d’orchestrer le travail du modèle : accès aux fichiers, exécution de commandes, gestion du contexte, historique, extensions, workflows, mémoire, outils externes, etc.
Et aujourd’hui, c’est précisément cette couche d’orchestration qui devient stratégique.
Qu’est-ce qu’un harness IA exactement ?
Un modèle comme GPT-5, Claude ou Gemini sait générer du texte. Mais seul, il ne “fait” presque rien.
Le harness est la structure qui entoure le modèle pour lui permettre d’agir :
lire et modifier des fichiers ;
lancer des commandes shell ;
gérer des sessions ;
mémoriser un contexte ;
appeler des outils ;
changer de modèle dynamiquement ;
appliquer des règles de sécurité ;
orchestrer plusieurs étapes de travail.
Sur Reddit et dans les communautés open source, beaucoup résument le harness comme “le système qui transforme un LLM en agent”.
En pratique, le modèle devient le moteur, mais le harness devient le systèm d’exploitation.
Pourquoi Pi attire autant l’attention ?
Pi adopte une approche radicalement minimaliste. Là où beaucoup d’outils IA deviennent des “IDE géants”, Pi veut rester petit au cœur et extensible autour.
Le projet fournit seulement quelques primitives essentielles :
read
write
edit
bash
Puis tout le reste est construit via des extensions TypeScript, des templates, des skills ou des packages.
Cette philosophie est importante car elle inverse la logique habituelle :
au lieu d’imposer un workflow au développeur, Pi laisse le développeur construire son propre workflow.
C’est une différence majeure avec des solutions plus fermées comme OpenAI Codex, Anthropic Claude Code ou certains IDE IA très intégrés.
Pourquoi le harness compte parfois plus que le modèle ?
C’est probablement le point le plus sous-estimé aujourd’hui.
Beaucoup pensent encore que toute la valeur vient du LLM. En réalité, deux équipes utilisant exactement le même modèle peuvent obtenir des résultats radicalement différents selon le harness utilisé.
Pourquoi ?
Parce qu’une énorme partie de la performance agentique dépend de :
la gestion du contexte ;
les outils disponibles ;
la mémoire ;
la capacité à découper les tâches ;
la sécurité ;
le routage entre modèles ;
les prompts système ;
les boucles de validation ;
les workflows d’exécution.
Pi insiste justement sur cette idée de “context engineering”.
Aujourd’hui, un bon harness peut parfois compenser un modèle plus faible.
À l’inverse, un excellent modèle mal orchestré produit souvent des agents incohérents, coûteux ou instables. Cela ramène à la discussion de l’importance du contexte, et cela a toujours été depuis le début, rien de nouveau. Même quand vous promptez l’IA sur le web, vous définissez un bon contexte pour que la réponse soit la plus précise, et le prompt engineering des début s’appuyait sur la maitrise du prompt (une abondante littérature sur les différentes technique de prompting existe, à mon avis inutile de s’embarasser des dizaines et des dizaines de technique c’est du marketing)
Quels autres harness existent ?
Pi n’est pas seul.
On voit émerger plusieurs familles de harness IA :
Chaque projet fait des choix différents : minimalisme, autonomie, sandboxing, multi-agents, mémoire persistante, IDE intégré ou CLI terminal.
Le marché semble d’ailleurs évoluer vers une commoditisation des modèles eux-mêmes. Les différences entre GPT, Claude, Gemini ou Qwen se réduisent progressivement sur certaines tâches.
Le véritable avantage compétitif se déplace donc vers :
le harness ;
les workflows ;
les outils ;
l’intégration ;
l’expérience développeur.
Autrement dit : le futur des agents IA ne se jouera pas uniquement sur “quel modèle utiliser”, mais surtout sur “comment le piloter”.
Je vous avais parlé de Ollama, par le passé, mais Ollama utilise un moteur d’inférence qui est llama.cpp, le vrai; Ollama n’est qu’une interface visuelle construite par dessus llama.cpp .
Et pour des questions d eperformance, je vous conseille de le prendre plutôt que d’utiliser Ollama qui est plutôt pour un public larger. Entant que codeur, il faut utilise llama.cpp.
Allez d’abord le télécharger, en ce qui me concerne je suis sous Windows, donc je vais utiliser WSL. Il faut le savoir en matière d’intelligence artificielle il vaut mieux utiliser Linux.
Il existe plein de sites qui permettent de le télécharger, la source officielle de llama.cpp, mais aussi ce site qui explique bien comment il faut faire pour installer llama.cpp.
Installer llama.cpp n’est que la première partie du travail, il faudra après son installation télécharger les modèles LLM opensource.
Il y a 2 options pour installer llama.cpp sous Windows, la première option nécessite d’avoir Visual Studio (et non VS Code), la seconde pour moi est plus simple , est d’installer sous WSL ce qui nous ramène à un système Linux (souvenez vous en matière d’IA Linux est bien mieux).
On part sur l’option 2 avec WSL, si vous ne l’avez pas encore installé :
wsl --install
Puis:
sudo apt update
sudo apt install git build-essential cmake
puis clonez le projet llamacpp:
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
cmake -B build
cmake --build build
puis attendez un moment (le processus de compilation est assez lent)
Voilà vous êtes prêt maintenant !
Les modèles LLM GGUF
Ce sont des modèles faits pour tourner en local, Hugging Face en héberges milliers de tous type : textuel, image, vidéo.
Vous devez avoir une carte graphique au minimum de 8GB de VRAM, ce qui vous permet d’avoir des modèles génératifs qui tiennent un peu la route. Moi j’ai une carte de 16 GB, donc je peux avoir des modèles un peu plus grand. Mais alors il faut s’attarder sur la notion de paramètre dans les modèles LLM. Plus le nombre de paramètres est grand plus le modèle est performant normalement.
Les modèles LLM non GGUF, les modèles d’origine qui tournent dans les info cloud sont au format .safetensors, .bin ou .pth. Il faut beaucoup de VRAM (volatil RAM la RAM des cartes graphique à la différence de la RAM du CPU)pour les faire tourner. La configuration est plus complexe avec des ichier config/tokenizer, setup CUDA pénible parfois.
Le format GGUF résout tous ces problèmes ça tombe bien pour nous c’est plus facile à mettre en oeuvre. Un modèle LLM de 500B (500 milliards de paramètre en 8 bits) nécessite 550 giga de RAM. Nous on va faire tourner des modèle 8 bits plus petits, à 8B, 12B, en 8 bits, donc ma carte 5060 à 16GB de VRAM suffit.
Pour savoir combien de Giga de VRAM il faut pour faire tourner un modèle 8bit, 1 milliard (1B B comme billions milliard en anglais) de paramètre nécessite 1 giga de VRAM. Il existe des modèle dégradé en 4 bits, dit des modèle quantizé, en passant de 8 bits à 4 bits, on divise par deux la taille des modèle, donc ma carte de 16 GB de VRAM peut faire tourner un modèle 32B en 4 bits.
Les modèles quantizés sont moins performant mais pas de moitié, en passant de 8 bits à 4 bit, on dégrade de 30% les performances d’inférence.
Si vous avez suivi l’installation dans WSL, votre installation de llama.cpp doit se trouver dans le répertoire suivant :
/mnt/c/Users/<user>/llama.cpp/build/bin/
et dans ce répertoire vous avez llama-cli, et llama-server
Il est conseillé d'installer huggingface-hub
pip install huggingface-hub
et ensuite on télécharge un fichier GGUF (le LLM), avec 16 GB un des meilleur modèle est celui de Mistral 7B, c'est un peu décevant mais si on télécharge un modèle plus grand que la VRAM (16GB), ça plante :$
Mais avant on vérifie que python et pip sont bien ceux de WSL
which python3
which pip3
si l'une des commande retourne */pyenv-win/* dans le chemin, c'est qu'on n'est pas 100% Linux, dans mon cas c'était pip qui était pas Linux, mais Python était bien Linux
on doit faire cette commande pour installer pip :
python3 -m pip install huggingface-hub --break-system-packages
si la lligne ci-dessus ne marche pas il faut installer pip
sudo apt install python3-pip
puis refaire :
python3 -m pip install huggingface-hub --break-system-packages
Téléchargement du modèle Mistral
Vérifiez que le répertoire ~/models existe sinon faite
mkdir -p ~/models
wget https://huggingface.co/bartowski/Mistral-7B-Instruct-v0.3-GGUF/resolve/main/Mistral-7B-Instruct-v0.3-Q8_0.gguf \
-O ~/models/mistral-7b-q8.gguf
Ensuite une fois installé lancez :
~/llama.cpp/build/bin/llama-server \
-m ~/models/mistral-7b-q8.gguf \
-c 4096 \
--port 8080
Et dans un autre terminal faites :
curl http://localhost:8080/health
vous devriez avoir en réponse :
{"status":"ok"}
Comment fait on pour avoir une interface friendly?
Il va falloir installer par exemple OpenWebUI, mais je trouve que c’est plus facile d’installer OpenWebUI dans un Docker aussi, je suppose que vous avez installé Docker Desktop:
docker run -d \
--name open-webui \
--add-host=host.docker.internal:host-gateway \
-e OPENAI_API_BASE_URL=http://host.docker.internal:8080/v1 \
-e OPENAI_API_KEY=fake \
-p 3000:8080 \
ghcr.io/open-webui/open-webui:main
Ensuite on ouvre le navigateur au http://localhost:3000 (il faut avoir lancé llama-server.
une fosi le docker en place
docker logs open-webui
pour le monitorer, quand on voit Uvicorn running, on ouvre sur l'hôte http://localhost:3000
Lorsqu’on écrit dans le prompt un texte comme « Bonjour comment vas tu? » ce que fait llama.cpp :
transforme le texte en tokens
fait passer ces tokens dans les couches du réseau de neurones
applique les poids à chaque étape
prédit le token suivant
Les poids sont stockés sous forme de tensors dans GGUF
blk.0.attn_q.weight
blk.0.attn_k.weight
blk.0.ffn_up.weight
./llama-cli -m model.gguf
la commande ci-dessus li les tensors en mémoire RAM/VRAM
Tokenizer
Le LLM ne comprend pas le texte brut, mais les token, docn il faut tokenizer les textes.
"Bonjour tout le monde" peut devenir
[5321, 884, 921]
Le tokenizer définit
le vocabulaire
le mapping texte-> id
le mapping id -> texte
./llama-cli -m model.gguf -p "hello"
llama.cpp tokenize "hello"
envoit les ids au modèle
reçoit des ids du model
reconvertit en texte
Metadatas
Une metadata est une données sur la données, dans notre cas, c’est la carte d’identité du modèle
architecture
nombre de couches
taille contexte
type de modèle
version tokenizer
quantization utilisée
Exemple:
architecture = llama
context_length = 8192
embedding_length = 4096
block_count = 32
La commande
./llama-cli -m model.gguf
sort ces données à l'écran
Paramètres d’inférence
Ce ne sont PAS les poids entraînés. Ce sont les réglages au moment où tu fais générer du texte.
Controle l’aléatoire, plus c’est élevé (proche de 1) plus c’est créatif
top-k
Le modèle garde uniquement les K tokens les plus probables.
top-k = 40 choisit parmi les 40 meilleurs candidats
top-p
Il garde les tokens jusqu’à atteindre X% de probabilité cumulée.
contexte size
C’est la fenêtre de contexte, la mémoire du LLM.
En résumé :
poids = connaissances du modèle
tokenizer = traduction texte ↔ tokens
metadata = mode d’emploi du modèle
paramètres d’inférence = réglages runtime dans llama.cpp
Comment sont les modèle avant quantization?
Le standard d’origine est sur 16 bits FP16. La majorité des modèles open source sont entrainés et distribués en
FP16 16-bit floatingpoint
parfois en BF16 (bfloat 16) surtout en entrainement
Ainsi en ordre de grandeur, un modèle LLM 7B en FP16 nécessite 14 Go (7B x 16 bits ou 2 bytes), un modèle 70B nécessite en FP16 nécessite 140 Go, 70 Go en 8 bits, et 35 Go en 4bits, cette dernière quantization est intéressante, car elle met à notre portée des modèle 70B pour du matériel comme la RTX 3090 (24 GB de VRAM), il faut 2 carte graphique et ça fera 48 GB de VRAM.
Modèle dense VS modèle sparse (mixture of Experts)
Dans le contexte des LLM locaux avec llama.cpp, la différence est surtout : combien de paramètres sont réellement utilisés à chaque token généré.
Les modèles denses
Ce sont les modèles classiques, Mistral, Llama, Qwen, à chaque prompt chaque token passe par toutes les couches et tous les paramètres concernés. Sur un modèle à 7B de paramètres, presque les 7 milliards de paramètre sont sollicités théoriquement (hors optimisation).
Les mixture of experts (MoE)
Le modèle contient plusieurs experts, tous ne sont pas activés en même temps, cela dépend du prompt un routeur choisit quels experts utiliser selon le token. Exemple le modèle Mistral AI Mixtral 8x7B. Théoriquement ce modèle a 56B paramètres, seul12 à 14B sont actifs par token.
Le MoE est intéressant en local car le coput d’inférence est plus bas qu’un modèle dense équivalent. Ainsi le coput d’un 56B est en fait celui d’un 12 ou 14B/
Mais attention vous devez charger tous els poids en VRAM. Qu’est ce qu’on y gagne alors? On y gagne en vitesse de calcul relative, intelligence et capacité, mais la taille on n’y gagne pas.
Copie de la méthode détaillé pour faire de Obsidian votre second cerveau. Andrej Karpathya écrit un texte très populaire où il se sert de Obsidian et des ses fichier markdown comme mémoire de LLM (claude ici en particuliers). Le problème majeur des LLM est qu’ils n’ont pas de mémoire, il faut leur rappeler souvent le contexte. Disposer d’un ensemble de fichier LLM en guise de mémoire est très intéressant, pour avoir un bon assistant IA.
Son texte se trouve ici. Nous allons copier ce texte où il décrit sa méthode et le donner à manger à Claude. Cliquez sur raw en haut à droite pour avoir le bon texte.
# LLM Wiki
A pattern for building personal knowledge bases using LLMs.
This is an idea file, it is designed to be copy pasted to your own LLM Agent (e.g. OpenAI Codex, Claude Code, OpenCode / Pi, or etc.). Its goal is to communicate the high level idea, but your agent will build out the specifics in collaboration with you.
## The core idea
Most people's experience with LLMs and documents looks like RAG: you upload a collection of files, the LLM retrieves relevant chunks at query time, and generates an answer. This works, but the LLM is rediscovering knowledge from scratch on every question. There's no accumulation. Ask a subtle question that requires synthesizing five documents, and the LLM has to find and piece together the relevant fragments every time. Nothing is built up. NotebookLM, ChatGPT file uploads, and most RAG systems work this way.
The idea here is different. Instead of just retrieving from raw documents at query time, the LLM **incrementally builds and maintains a persistent wiki** — a structured, interlinked collection of markdown files that sits between you and the raw sources. When you add a new source, the LLM doesn't just index it for later retrieval. It reads it, extracts the key information, and integrates it into the existing wiki — updating entity pages, revising topic summaries, noting where new data contradicts old claims, strengthening or challenging the evolving synthesis. The knowledge is compiled once and then *kept current*, not re-derived on every query.
This is the key difference: **the wiki is a persistent, compounding artifact.** The cross-references are already there. The contradictions have already been flagged. The synthesis already reflects everything you've read. The wiki keeps getting richer with every source you add and every question you ask.
You never (or rarely) write the wiki yourself — the LLM writes and maintains all of it. You're in charge of sourcing, exploration, and asking the right questions. The LLM does all the grunt work — the summarizing, cross-referencing, filing, and bookkeeping that makes a knowledge base actually useful over time. In practice, I have the LLM agent open on one side and Obsidian open on the other. The LLM makes edits based on our conversation, and I browse the results in real time — following links, checking the graph view, reading the updated pages. Obsidian is the IDE; the LLM is the programmer; the wiki is the codebase.
This can apply to a lot of different contexts. A few examples:
- **Personal**: tracking your own goals, health, psychology, self-improvement — filing journal entries, articles, podcast notes, and building up a structured picture of yourself over time.
- **Research**: going deep on a topic over weeks or months — reading papers, articles, reports, and incrementally building a comprehensive wiki with an evolving thesis.
- **Reading a book**: filing each chapter as you go, building out pages for characters, themes, plot threads, and how they connect. By the end you have a rich companion wiki. Think of fan wikis like [Tolkien Gateway](https://tolkiengateway.net/wiki/Main_Page) — thousands of interlinked pages covering characters, places, events, languages, built by a community of volunteers over years. You could build something like that personally as you read, with the LLM doing all the cross-referencing and maintenance.
- **Business/team**: an internal wiki maintained by LLMs, fed by Slack threads, meeting transcripts, project documents, customer calls. Possibly with humans in the loop reviewing updates. The wiki stays current because the LLM does the maintenance that no one on the team wants to do.
- **Competitive analysis, due diligence, trip planning, course notes, hobby deep-dives** — anything where you're accumulating knowledge over time and want it organized rather than scattered.
## Architecture
There are three layers:
**Raw sources** — your curated collection of source documents. Articles, papers, images, data files. These are immutable — the LLM reads from them but never modifies them. This is your source of truth.
**The wiki** — a directory of LLM-generated markdown files. Summaries, entity pages, concept pages, comparisons, an overview, a synthesis. The LLM owns this layer entirely. It creates pages, updates them when new sources arrive, maintains cross-references, and keeps everything consistent. You read it; the LLM writes it.
**The schema** — a document (e.g. CLAUDE.md for Claude Code or AGENTS.md for Codex) that tells the LLM how the wiki is structured, what the conventions are, and what workflows to follow when ingesting sources, answering questions, or maintaining the wiki. This is the key configuration file — it's what makes the LLM a disciplined wiki maintainer rather than a generic chatbot. You and the LLM co-evolve this over time as you figure out what works for your domain.
## Operations
**Ingest.** You drop a new source into the raw collection and tell the LLM to process it. An example flow: the LLM reads the source, discusses key takeaways with you, writes a summary page in the wiki, updates the index, updates relevant entity and concept pages across the wiki, and appends an entry to the log. A single source might touch 10-15 wiki pages. Personally I prefer to ingest sources one at a time and stay involved — I read the summaries, check the updates, and guide the LLM on what to emphasize. But you could also batch-ingest many sources at once with less supervision. It's up to you to develop the workflow that fits your style and document it in the schema for future sessions.
**Query.** You ask questions against the wiki. The LLM searches for relevant pages, reads them, and synthesizes an answer with citations. Answers can take different forms depending on the question — a markdown page, a comparison table, a slide deck (Marp), a chart (matplotlib), a canvas. The important insight: **good answers can be filed back into the wiki as new pages.** A comparison you asked for, an analysis, a connection you discovered — these are valuable and shouldn't disappear into chat history. This way your explorations compound in the knowledge base just like ingested sources do.
**Lint.** Periodically, ask the LLM to health-check the wiki. Look for: contradictions between pages, stale claims that newer sources have superseded, orphan pages with no inbound links, important concepts mentioned but lacking their own page, missing cross-references, data gaps that could be filled with a web search. The LLM is good at suggesting new questions to investigate and new sources to look for. This keeps the wiki healthy as it grows.
## Indexing and logging
Two special files help the LLM (and you) navigate the wiki as it grows. They serve different purposes:
**index.md** is content-oriented. It's a catalog of everything in the wiki — each page listed with a link, a one-line summary, and optionally metadata like date or source count. Organized by category (entities, concepts, sources, etc.). The LLM updates it on every ingest. When answering a query, the LLM reads the index first to find relevant pages, then drills into them. This works surprisingly well at moderate scale (~100 sources, ~hundreds of pages) and avoids the need for embedding-based RAG infrastructure.
**log.md** is chronological. It's an append-only record of what happened and when — ingests, queries, lint passes. A useful tip: if each entry starts with a consistent prefix (e.g. `## [2026-04-02] ingest | Article Title`), the log becomes parseable with simple unix tools — `grep "^## \[" log.md | tail -5` gives you the last 5 entries. The log gives you a timeline of the wiki's evolution and helps the LLM understand what's been done recently.
## Optional: CLI tools
At some point you may want to build small tools that help the LLM operate on the wiki more efficiently. A search engine over the wiki pages is the most obvious one — at small scale the index file is enough, but as the wiki grows you want proper search. [qmd](https://github.com/tobi/qmd) is a good option: it's a local search engine for markdown files with hybrid BM25/vector search and LLM re-ranking, all on-device. It has both a CLI (so the LLM can shell out to it) and an MCP server (so the LLM can use it as a native tool). You could also build something simpler yourself — the LLM can help you vibe-code a naive search script as the need arises.
## Tips and tricks
- **Obsidian Web Clipper** is a browser extension that converts web articles to markdown. Very useful for quickly getting sources into your raw collection.
- **Download images locally.** In Obsidian Settings → Files and links, set "Attachment folder path" to a fixed directory (e.g. `raw/assets/`). Then in Settings → Hotkeys, search for "Download" to find "Download attachments for current file" and bind it to a hotkey (e.g. Ctrl+Shift+D). After clipping an article, hit the hotkey and all images get downloaded to local disk. This is optional but useful — it lets the LLM view and reference images directly instead of relying on URLs that may break. Note that LLMs can't natively read markdown with inline images in one pass — the workaround is to have the LLM read the text first, then view some or all of the referenced images separately to gain additional context. It's a bit clunky but works well enough.
- **Obsidian's graph view** is the best way to see the shape of your wiki — what's connected to what, which pages are hubs, which are orphans.
- **Marp** is a markdown-based slide deck format. Obsidian has a plugin for it. Useful for generating presentations directly from wiki content.
- **Dataview** is an Obsidian plugin that runs queries over page frontmatter. If your LLM adds YAML frontmatter to wiki pages (tags, dates, source counts), Dataview can generate dynamic tables and lists.
- The wiki is just a git repo of markdown files. You get version history, branching, and collaboration for free.
## Why this works
The tedious part of maintaining a knowledge base is not the reading or the thinking — it's the bookkeeping. Updating cross-references, keeping summaries current, noting when new data contradicts old claims, maintaining consistency across dozens of pages. Humans abandon wikis because the maintenance burden grows faster than the value. LLMs don't get bored, don't forget to update a cross-reference, and can touch 15 files in one pass. The wiki stays maintained because the cost of maintenance is near zero.
The human's job is to curate sources, direct the analysis, ask good questions, and think about what it all means. The LLM's job is everything else.
The idea is related in spirit to Vannevar Bush's Memex (1945) — a personal, curated knowledge store with associative trails between documents. Bush's vision was closer to this than to what the web became: private, actively curated, with the connections between documents as valuable as the documents themselves. The part he couldn't solve was who does the maintenance. The LLM handles that.
## Note
This document is intentionally abstract. It describes the idea, not a specific implementation. The exact directory structure, the schema conventions, the page formats, the tooling — all of that will depend on your domain, your preferences, and your LLM of choice. Everything mentioned above is optional and modular — pick what's useful, ignore what isn't. For example: your sources might be text-only, so you don't need image handling at all. Your wiki might be small enough that the index file is all you need, no search engine required. You might not care about slide decks and just want markdown pages. You might want a completely different set of output formats. The right way to use this is to share it with your LLM agent and work together to instantiate a version that fits your needs. The document's only job is to communicate the pattern. Your LLM can figure out the rest.
Pour chatGPT, afin de donner du contexte à une question, on upload un fichier pdf par exemple, et on demande à chatGPT une question ce dernier saura regarder le pdf pour augmenter son texte, on appelle cela un RAG.
On va procéder différemment ici, car l’approche de Karpathy est de fabriquer un wiki qui s’augmente et se modifie, ce n’est pas seulement une accumulation de fichier, si un fichier n’a qu’une petite part d’information qui peut compléter le wiki (quelque chose de nouveau), seul le texte nouveau sera injecté dans le wiki, il sera analysé, pour voir en quoi il apporte de la valeur (complément, contradiction etc)
Coller le texte de Karpathy et ajouter à côté ce prompt :
You are a LLM Wiki agent. Implement this exact idea file as my complete second brain. create the CLAUDE.md schema file with full rules, set up index.md and log.md, define folder conventions, and show me the first ingest example.
Installer l’extension Obsidian Web Clipper pour convertir une page web en markdown
Imaginez que vous tombiez sur une page web, qui rentre dans le cadre de votre veille IA, comment ajouter le contenu de cette page à votre wiki? le meilleur format pour travailler en IA générative, c’est
Pour convertir en markdown une page, cliquez sur l’icône de l’extension, vous pouvez renommer le fichier à la volée tout en haut de la popup qui apparait, et tout en bas vous désignez le répertoire où va être enregistré le fichier markdown.
Les IA aiment travailler avec le markdown, qui est une alternative au markup (HTML), beaucoup plus dépouillé, mais porteur de valeur sémantique.
Vous allez importer dans le répertoire raw, qui est l’antichambre de vos entités sémantiques du wiki.
Une fois en possession de fichier dans raw, il est temps d’aller dans un terminal ouvert à l’emplacement de votre wiki et d’invoquer Claude Code.
Ajout de commande Claude
Créez un répertoire invisible .claude, puis un sous répertoire commands, et dedans créez 4 fichiers markdown : ingest, query,save,lint.
Mettez dans chaque commande le markdown correspondant.
query
---
description: Ask a question answered from the wiki
argument-hint: <question>
---
Run the QUERY workflow from CLAUDE.md for: $ARGUMENTS
Steps:
1. Read `index.md` to find relevant pages.
2. Read those pages and follow `[[wikilinks]]` as needed.
3. Synthesize an answer with `[[page]]` citations.
4. If the answer is substantive, offer to file it as `wiki/syntheses/<slug>.md`.
5. Append an entry to `log.md`.
save
---
description: File the last response as a synthesis page
argument-hint: [optional-slug]
---
File the previous assistant response into `wiki/syntheses/<slug>.md`.
Slug: $ARGUMENTS (if empty, derive a concise kebab-case slug from the content).
Steps:
1. Write the synthesis page with proper frontmatter (`type: synthesis`, `created`, `updated`, `tags`, `sources`).
2. Preserve `[[wikilinks]]` and add a `## References` section.
3. Update `index.md` to list the new synthesis.
4. Append an entry to `log.md`.
ingest
---
description: Ingest a source from raw/ into the wiki
argument-hint: <path-to-source-in-raw>
---
Run the INGEST workflow from CLAUDE.md on: $ARGUMENTS
Steps:
1. Read the source at $ARGUMENTS (fetch if URL).
2. Discuss 2-5 key takeaways with the user.
3. Create `wiki/sources/YYYY-MM-DD-slug.md` with summary, key claims, entities, concepts, quotes.
4. Create/update entity and concept pages for each mentioned; flag contradictions with `> [!warning]`.
5. Update `index.md`.
6. Append an entry to `log.md`.
7. Report created/updated pages, contradictions, and open questions.
lint
---
description: Lint the wiki for contradictions, orphans, and gaps
argument-hint:
---
Run the LINT workflow from CLAUDE.md.
Report on:
- Contradictions across pages
- Stale claims
- Orphan pages (no inbound links)
- Concepts mentioned without their own page
- Missing cross-references
- Data gaps worth researching
Suggest next sources to ingest.
$ARGUMENTS
C’est ingest que nous allons utiliser en premier. Dans Claude Code tapez /ingest, et il va aller regarder dans le répertoire raw digérer le fichier markdown et les répartir dans les différents répertoire du wiki. Quand c’est fait vous pouvez invoquer la vue graphique en noeud et relations dans Obsidian.
Une fois que c’est fait, vous pouvez requêter le wiki en tapant /query, et posez votre question.
Pourquoi ça marche?
Les IA sont entrainées sur des larges banques de données, mais leurs connaissance se limitent à ces données. Comme c’est une machine statistique, si vous posez une question sur un sujet dont ils n’on t pas eu connaissance, ils vont halluciner, c’est à dire inventer des choses.
Afin d’éviter cela, on leur demande de puiser des données dans des jeux de données complémentaires qui n’ont pas servi à leur entrainement, c’est le RAG (Retrieval Augmented Generation). En gros on va faire une première requête dans la source de connaissance supplémentaire (votre wiki) et envoyer le résultat de cette requête au LLM avec votre question et c’est le LLM qui va finaliser la réponse. Ceci permet de diminuer les hallucinations.
Particularité de la mise en place d’Obsidian avec la méthode de Andrej Karpathy
Ce que nous venons de faire c’est simplement constituer une base de connaissance sur un thème particulier, pas forcément pour du RAG, mais de procurer une mémoire pour vous ! imaginez que vous empiliez des livres de connaissances, mais que vous aimeriez avoir un assistant qui vous livre l’information à votre question, c’est exactement ce que va faire le LLM Claude Code. Avec ce système, chaque fois que vous découvrez une page d’informations nouvelles, vous le donnez à digérer à Claude qui va dispatcher l’information dans le wiki. Avec comme bonus qu’il n’y aura pas de répétition de cette information, et qu’il y a une vérification de si cette nouvelle information risque de contredire l’ancienne. Votre wiki est maintenu par l’IA. Vous n’avez qu’à alimenter en markdown le wiki, très facilement avec l’extension Obsidian Web Clipper.
Avoir un wiki évolutif, sur lequel on peut requêter pour avoir l’information très rapidement, une information curatée, c’est précisément pour cette raison qu’on appelle ce système un second cerveau.
Claude Code : Guide d’installation et prise en main rapide
L’assistant IA qui travaille directement dans votre terminal, au cœur de votre code.
Qu’est-ce que Claude Code ?
Claude Code est l’outil en ligne de commande d’Anthropic qui transforme votre terminal en assistant de développement intelligent. Contrairement à un simple chatbot, Claude Code lit votre codebase, comprend le contexte de votre projet, écrit du code, exécute des commandes, modifie des fichiers et itère — tout cela sous votre contrôle. Que vous soyez développeur expérimenté ou que vous débutiez, il s’intègre à votre workflow sans friction.
Prérequis
Avant d’installer Claude Code, vérifiez deux points :
Un compte Claude.ai avec un abonnement Pro ou Max — Claude Code n’est pas disponible sur le plan gratuit.
macOS 13 ou supérieur — pour les utilisateurs Mac. Linux est également supporté.
C’est tout. L’installeur natif se charge du reste.
Installation sur Mac
Méthode 1 — Installeur natif (recommandée)
Ouvrez votre Terminal (Cmd + Espace, tapez Terminal, appuyez sur Entrée) et collez cette commande :
curl -fsSL https://claude.ai/install.sh | bash
L’installeur télécharge et configure automatiquement Claude Code. Quand il affiche « Claude Code successfully installed! », c’est bon.
Ensuite, mettez à jour votre PATH pour que la commande claude soit reconnue par votre terminal :
Si vous utilisez Homebrew, une seule commande suffit :
brew install --cask claude-code
Méthode 3 — Via npm
Si Node.js (version 18 ou supérieure) est déjà installé sur votre machine :
npm install -g @anthropic-ai/claude-code
La méthode npm est la méthode historique, mais maintenant il y a un installateur binaire (voir ci-dessus)
Première connexion
Au premier lancement, Claude Code demande le thème graphique que vous voulez, deamnde votre méthode de login, si vous avez un compte PRO et c’est le plus souvent, c’est la première méthode, sinon vous avez d’autre méthode qui consomment l’API, (mais cette dernière va vous revenir plus cher, car le coût est calculé au nombre de token), et Claude ouvre automatiquement votre navigateur pour vous authentifier :
claude
Connectez-vous à votre compte Claude.ai et cliquez sur Authenticate. La session est ensuite sauvegardée localement — vous n’aurez plus à vous reconnecter à chaque fois.
Pour que Claude code fonctionne sur votre dossier projet, allez sur votre répertoire de projet et tapez Claude, il vous demandera systématiquement de valider que vous faites confiance à ce projet.
Prise en main : les fonctionnalités essentielles
1. Travailler dans un projet
Claude Code est conçu pour fonctionner au sein de votre projet. Naviguez dans votre dossier de travail avant de le lancer :
cd mon-projet
claude
Dès lors, Claude voit tous vos fichiers et comprend le contexte de votre codebase. Vous pouvez lui demander d’expliquer la structure du projet, de décrire une fonction, ou de repérer des incohérences.
2. Demander des modifications de code
Décrivez ce que vous voulez en langage naturel. Claude génère les changements et les présente sous forme de diff avant de les appliquer :
> Ajoute une fonction de validation d’email dans utils.py
> Refactorise cette classe pour utiliser des dataclasses Python
> Corrige le bug dans la fonction parse_date — elle ne gère pas les années bissextiles
Claude attend votre approbation avant chaque modification. Vous restez maître des changements. Vous allez être bluffé par sa capacité à écrire du code qui fonctionne, et en 20 minutes vous pouvez abattre l’équivalent d’une semaine de travail voire plus, cet effet multiplicateur est d’autant plus grand que vous vous attaquez à des technologies dont vous n’êtes pas familier ou jamais vu. Plus de crainte de rester bloqué, et plus de syndrome de l’imposteur !
3. Exécuter des commandes et des tests
Claude Code peut lancer des commandes shell directement :
> Lance les tests unitaires et explique les erreurs
> Installe les dépendances manquantes du projet
> Génère le build de production
Il interprète les résultats, identifie les erreurs et propose des corrections en boucle.
4. Le mode Plan (Shift + Tab)
Avant de se lancer dans une tâche complexe, Claude peut vous présenter un plan d’action détaillé. Appuyez sur Shift + Tab pour activer ce mode. Vous visualisez chaque étape prévue et pouvez affiner les instructions avant exécution — idéal pour les refactorisations importantes ou l’ajout de nouvelles fonctionnalités.
5. Reprendre une session précédente
Chaque conversation avec Claude Code est sauvegardée. Pour reprendre là où vous en étiez :
claude –continue # reprend la dernière session
claude –resume # choisit une session parmi l’historique
6. Commandes utiles à connaître
Une fois dans Claude Code, quelques raccourcis à garder en tête :
Commande
Action
/help
Affiche la liste des commandes disponibles
/model
Change le modèle Claude utilisé
/rename
Renomme la session en cours
/exit
Quitte Claude Code
Échap
Interrompt Claude si une action est en cours
Extension VS Code
Si vous travaillez principalement dans VS Code, une extension Claude Code est disponible directement dans le marketplace. Elle affiche les suggestions et diffs dans un panneau latéral, avec un accès rapide depuis l’éditeur sans quitter votre environnement habituel. Mais personnellement l’outil CLI rest mon favori à 99%
Bonnes pratiques pour démarrer
Initialisez Git dans vos projets. Claude Code fonctionne bien mieux avec un historique de versions — vous pouvez rollback immédiatement si un changement ne convient pas.
Commencez par des tâches simples. Demandez-lui d’expliquer un fichier, de générer des tests unitaires, ou d’ajouter de la documentation. Cela permet de comprendre comment il interprète votre codebase avant de lui confier des modifications importantes.
Lisez les diffs avant d’approuver. Claude est efficace, mais c’est vous qui validez. Prenez l’habitude de relire chaque changement proposé.
Conclusion
Claude Code change la manière dont on interagit avec son code. Ce n’est pas un autocomplete amélioré — c’est un agent qui lit, comprend, modifie et teste votre projet de façon autonome, tout en restant sous votre supervision. L’installation prend moins de deux minutes. La prise en main, quelques heures. Et rapidement, il devient difficile de s’en passer.
Tout le monde parle d’agent IA mais je pense que beaucoup ne savent pas ce qu’est vraiment un agent IA.
Un agent IA est un programme propulsé par un LLM (Claude, chatGPT etc) et qui a reçu un prompt bien spécifique pour exécuter une tâche précise. Il est capable d’agir sur des informations, chercher des information via Google, manipuler des fichiers, à la différence de l’IA que vous connaissez qui ne fait que répondre à votre question.
Un agent IA est capable de communiquer avec d’autres agents IA au sein d’une équipe, il est hautement spécialisé, il peut tourner en mode séquentiel ou parallèle, et à la fin livrer un travail d’équipe dirigé par un manager.
Qu’est ce que le framework CrewAI ?
C’est une librairie Python, qui va s’occuper d’orchestrer les agents IA, les faire communiquer entre eux. La version actuelle au moment où j’écris cet article est la version 1.14 (méfiez vous des tuto périmés que vous donne les LLM et mêm le cours officiel de CrewAI !). Le site officiel de CrewAI est ici.
Pourquoi utiliser des agent IA?
L’utilisation d’agent IA spécialisé va rendre un meilleur travail qu’un LMM tout seul.
Exemple basique avec l’analyse
Pour utiliser CrewAI, il vous faut 3 chose : les agents, les tâches (Task) et le Crew. On va aussi affecter un LLM à chaque agent, et on peut affecter un LLM différent au manager des agents.
Mise en place de l’environnement virtuel et installation des paquets
Pour chaque projet il est important de mettre en place un environnement virtuel pour isoler les librairies de l’installation globale de python. Ainsi allez dans un endroit qui vous plait pour votre projet.
# dans un répertoire dédié à votre projet faites la création de l'environnement virtuel
#creation de l'environnement virtuel
python -m venv venv
#Puis dans votre environnement virtuel
python -m pip install crewai crewai-tools python-dotenv
un fichier .env.example
Usage du script
pour faire simple une action est passée par défaut
python run.py
Mais vous pouvez passez en argument une autre action
le script prend jusqu'à 4 arguments.
python run.py --stock TSLA --risk High --strategy "Swing Trading"
Description de ce qui se passe quand vous lancez le script
1. Le Manager LLM lit les tâches et décide qui fait quoi et dans quel ordre.
2. Les agents s’exécutent en séquence, chacun produisant un « thought process » visible :
Thought: → l’agent réfléchit à ce qu’il doit faire
Action: → il décide d’utiliser un outil (scraping, recherche…)
Action Input: → les paramètres qu’il passe à l’outil
Observation: → le résultat retourné par l’outil
Final Answer: → sa conclusion pour cette tâche
3. Le Manager valide chaque résultat avant de passer à la tâche suivante.
4. Les 4 agents travaillent dans l’ordre :
Data Analyst → analyse le marché AAPL
Trading Strategy Developer → propose des stratégies
Trade Advisor → planifie l’exécution
Risk Advisor → évalue les risques et produit le rapport final
Tout cet output verbose c’est le « raisonnement » des agents rendu visible — c’est ce qui rend crewAI intéressant à observer. Tu peux mettre verbose=False sur les agents et le crew pour n’avoir que le résultat final.
Comment crewAI scripte un agent
data_analyst_agent = Agent(
role="Data Analyst",
goal=(
"Monitor and analyze market data in real-time "
"to identify trends and predict market movements."
),
backstory=(
"Specializing in financial markets, this agent "
"uses statistical modeling and machine learning "
"to provide crucial insights. With a knack for data, "
"the Data Analyst Agent is the cornerstone for "
"informing trading decisions."
),
verbose=True,
allow_delegation=True,
tools=tools,
llm=llm,
)
Le backstory est le texte qui décrite (prompte) l’agent. Le paramètre llm indique le LLM à utiliser. allow_delegation permet à un agent de confier sa mission à un autre agent dès lors qu’il pense qu’il n’est pas le mieux dans une tâche. Si vous débutez mettez à False. tools quant à lui est une liste d’outils (qu’il faut déclarer) pour que l’agent puisse le solliciter pour faire autre chose que de répondre comme un LMM basiquement. Dans la section 5 on a tools = [scrape_tool, search_tool]. Pour Serper il vous faudra aller sur leur site créer un compte et obtenir une clé API. Il vous faut aussi une clé API openAI.
verbose permet d’afficher dans le terminal ce qui se passe. le goal répond à « pourquoi tu existes dans cette équipe », la tâche répond à « qu’est-ce que tu fais maintenant », alors que le backstory décrit l’agent.
Les Task
data_analysis_task = Task(
description=(
"Continuously monitor and analyze market data for "
"the selected stock ({stock_selection}). "
"Use statistical modeling and machine learning to "
"identify trends and predict market movements."
),
expected_output=(
"Insights and alerts about significant market "
"opportunities or threats for {stock_selection}."
),
agent=data_analyst_agent,
)
expected_out est une instruction envoyée au LLM. Il y a différents niveau de contrainte, détaillées ci-dessous :
Niveau 1 : il faut être très précis
# vague
expected_output="Un rapport d'analyse."
# précis
expected_output=(
"Un rapport structuré avec exactement ces sections : "
"1) Tendances actuelles, 2) Opportunités, 3) Risques, "
"4) Recommandation finale en une phrase. "
"Format markdown, maximum 500 mots."
)
Niveau 2 : ajouter un guardrail (validation automatique)
task = Task(
description="Analyse le stock {stock_selection}.",
expected_output="Un rapport avec tendances, opportunités et risques.",
agent=analyst,
guardrail=(
"Le rapport doit contenir les mots 'tendances', 'opportunités' "
"et 'risques'. Il doit faire au moins 200 mots."
)
)
Niveau 3 : forcer un formation JSON avec Pydantic (le plus strict)
from pydantic import BaseModel
from typing import List
class AnalysisReport(BaseModel):
tendances: List[str]
opportunites: List[str]
risques: List[str]
recommandation: str
task = Task(
description="Analyse le stock {stock_selection}.",
expected_output="Un rapport d'analyse structuré.",
agent=analyst,
output_pydantic=AnalysisReport, # force le format
)
# Accès au résultat structuré après kickoff :
result = crew.kickoff(inputs={"stock_selection": "AAPL"})
print(result.pydantic.recommandation)
print(result.pydantic.risques)
Voici le code source intégral
"""
run.py — Analyse financière multi-agents avec crewAI v1.x
----------------------------------------------------------
Compatible : crewai >= 1.0 (testé sur 1.14)
Installation :
pip install crewai crewai-tools python-dotenv
Fichier .env requis :
OPENAI_API_KEY=sk-...
SERPER_API_KEY=... (optionnel, pour la recherche web)
Usage :
python run.py
python run.py --stock TSLA --risk High --strategy "Swing Trading"
"""
import os
import argparse
from dotenv import load_dotenv
# ── 1. Variables d'environnement ─────────────────────────────────────────────
load_dotenv()
if not os.getenv("OPENAI_API_KEY"):
raise EnvironmentError(
"OPENAI_API_KEY manquant !\n"
"Crée un fichier .env avec : OPENAI_API_KEY=sk-..."
)
# ── 2. Arguments CLI ──────────────────────────────────────────────────────────
parser = argparse.ArgumentParser(description="Analyse financière multi-agents crewAI v1.x")
parser.add_argument("--stock", default="AAPL", help="Ticker boursier (défaut: AAPL)")
parser.add_argument("--capital", default="100000", help="Capital initial (défaut: 100000)")
parser.add_argument("--risk", default="Medium", choices=["Low", "Medium", "High"])
parser.add_argument("--strategy", default="Day Trading", help="Stratégie de trading")
args = parser.parse_args()
# ── 3. Imports crewAI v1.x ───────────────────────────────────────────────────
# CHANGEMENT v1.x : on n'importe plus depuis langchain_openai
# crewAI gère le LLM en interne via LiteLLM
from crewai import Agent, Task, Crew, Process, LLM
from crewai_tools import ScrapeWebsiteTool, SerperDevTool
# ── 4. LLM ───────────────────────────────────────────────────────────────────
# CHANGEMENT v1.x : on utilise crewai.LLM au lieu de langchain_openai.ChatOpenAI
# Le préfixe "openai/" est la convention LiteLLM
llm = LLM(
model="openai/gpt-4o-mini", # ou "openai/gpt-4o", "openai/gpt-3.5-turbo"
temperature=0.7,
api_key=os.getenv("OPENAI_API_KEY"),
)
# LLM dédié au manager (peut être le même ou un modèle plus puissant)
manager_llm = LLM(
model="openai/gpt-4o-mini",
temperature=0.7,
api_key=os.getenv("OPENAI_API_KEY"),
)
# ── 5. Outils ────────────────────────────────────────────────────────────────
# SerperDevTool nécessite SERPER_API_KEY dans .env
# Sans clé, les agents raisonnent sur leurs connaissances sans chercher sur le web
search_tool = SerperDevTool()
scrape_tool = ScrapeWebsiteTool()
tools = [scrape_tool, search_tool]
# ── 6. Agents ────────────────────────────────────────────────────────────────
# CHANGEMENT v1.x : on passe `llm=` explicitement à chaque agent
data_analyst_agent = Agent(
role="Data Analyst",
goal=(
"Monitor and analyze market data in real-time "
"to identify trends and predict market movements."
),
backstory=(
"Specializing in financial markets, this agent "
"uses statistical modeling and machine learning "
"to provide crucial insights. With a knack for data, "
"the Data Analyst Agent is the cornerstone for "
"informing trading decisions."
),
verbose=True,
allow_delegation=True,
tools=tools,
llm=llm,
)
trading_strategy_agent = Agent(
role="Trading Strategy Developer",
goal=(
"Develop and test various trading strategies based "
"on insights from the Data Analyst Agent."
),
backstory=(
"Equipped with a deep understanding of financial "
"markets and quantitative analysis, this agent "
"devises and refines trading strategies. It evaluates "
"the performance of different approaches to determine "
"the most profitable and risk-averse options."
),
verbose=True,
allow_delegation=True,
tools=tools,
llm=llm,
)
execution_agent = Agent(
role="Trade Advisor",
goal=(
"Suggest optimal trade execution strategies "
"based on approved trading strategies."
),
backstory=(
"This agent specializes in analyzing the timing, price, "
"and logistical details of potential trades. By evaluating "
"these factors, it provides well-founded suggestions for "
"when and how trades should be executed to maximize "
"efficiency and adherence to strategy."
),
verbose=True,
allow_delegation=True,
tools=tools,
llm=llm,
)
risk_management_agent = Agent(
role="Risk Advisor",
goal=(
"Evaluate and provide insights on the risks "
"associated with potential trading activities."
),
backstory=(
"Armed with a deep understanding of risk assessment models "
"and market dynamics, this agent scrutinizes the potential "
"risks of proposed trades. It offers a detailed analysis of "
"risk exposure and suggests safeguards to ensure that "
"trading activities align with the firm's risk tolerance."
),
verbose=True,
allow_delegation=True,
tools=tools,
llm=llm,
)
# ── 7. Tâches ────────────────────────────────────────────────────────────────
# Les {accolades} sont remplacées par les valeurs de `inputs` au kickoff
data_analysis_task = Task(
description=(
"Continuously monitor and analyze market data for "
"the selected stock ({stock_selection}). "
"Use statistical modeling and machine learning to "
"identify trends and predict market movements."
),
expected_output=(
"Insights and alerts about significant market "
"opportunities or threats for {stock_selection}."
),
agent=data_analyst_agent,
)
strategy_development_task = Task(
description=(
"Develop and refine trading strategies based on "
"the insights from the Data Analyst and "
"user-defined risk tolerance ({risk_tolerance}). "
"Consider trading preferences ({trading_strategy_preference})."
),
expected_output=(
"A set of potential trading strategies for {stock_selection} "
"that align with the user's risk tolerance."
),
agent=trading_strategy_agent,
context=[data_analysis_task], # reçoit le résultat de la tâche précédente
)
execution_planning_task = Task(
description=(
"Analyze approved trading strategies to determine the "
"best execution methods for {stock_selection}, "
"considering current market conditions and optimal pricing."
),
expected_output=(
"Detailed execution plans suggesting how and when to "
"execute trades for {stock_selection}."
),
agent=execution_agent,
context=[strategy_development_task],
)
risk_assessment_task = Task(
description=(
"Evaluate the risks associated with the proposed trading "
"strategies and execution plans for {stock_selection}. "
"Provide a detailed analysis of potential risks "
"and suggest mitigation strategies."
),
expected_output=(
"A comprehensive risk analysis report detailing potential "
"risks and mitigation recommendations for {stock_selection}."
),
agent=risk_management_agent,
context=[strategy_development_task, execution_planning_task],
output_file="result_{stock_selection}.md", # sauvegarde automatique
markdown=True,
)
# ── 8. Crew ───────────────────────────────────────────────────────────────────
# CHANGEMENT v1.x :
# - manager_llm prend un objet crewai.LLM (plus de ChatOpenAI)
# - Process.hierarchical toujours supporté
financial_trading_crew = Crew(
agents=[
data_analyst_agent,
trading_strategy_agent,
execution_agent,
risk_management_agent,
],
tasks=[
data_analysis_task,
strategy_development_task,
execution_planning_task,
risk_assessment_task,
],
manager_llm=manager_llm,
process=Process.hierarchical,
verbose=True,
)
# ── 9. Inputs et lancement ────────────────────────────────────────────────────
financial_trading_inputs = {
"stock_selection": args.stock,
"initial_capital": args.capital,
"risk_tolerance": args.risk,
"trading_strategy_preference": args.strategy,
"news_impact_consideration": True,
}
print("\n" + "=" * 60)
print(" ANALYSE FINANCIÈRE MULTI-AGENTS — crewAI v1.x")
print("=" * 60)
print(f" Ticker : {financial_trading_inputs['stock_selection']}")
print(f" Capital : ${financial_trading_inputs['initial_capital']}")
print(f" Risque : {financial_trading_inputs['risk_tolerance']}")
print(f" Stratégie : {financial_trading_inputs['trading_strategy_preference']}")
print("=" * 60)
print("\n⚡ Démarrage... (peut prendre 2–5 minutes)\n")
result = financial_trading_crew.kickoff(inputs=financial_trading_inputs)
print("\n" + "=" * 60)
print(" RÉSULTAT FINAL")
print("=" * 60 + "\n")
print(result)
print(f"\n✅ Rapport sauvegardé dans : result_{args.stock.lower()}.md")
Pour installer ce logiciel, il vaut mieux être sous Linux, aussi si vous êtes sous Windows, soit vous allez dans WSL soit vous utilisez Gitbash pour l’installer, sinon Windows ne trouvera pas le programme.
Le fonctionnement est repris du site officiel :
Voici le repository : https://github.com/tobi/qmd
Installation de QMD
npm install -g @tobilu/qmd
// pour ajouter un répertoire à indexer
qmd collection add ~/notes --name notes
ci dessus c'est un chemin Linux, par exemple si vous êtes dans Document et que vous êtes l'utilisateur John, le chemin devient : /mnt/c/Users/John/Documents
qmd collection add /mnt/c/Users/John/Documents --name mesdocuments
L’intérêt de QMD est que nous vivons à l’âge de l’intelligence artificielle, et l’outil s’intègre très bien dans des workflow agentiques.
Récemment Andrej Karpathy a publié une solution à base d’Obsidian https://x.com/karpathy/status/2039805659525644595?s=46 pour construire un wiki à base de fichier md, capable de s’enrichir de façon incrémental, offrant une solution alternative au RAG.
QMD peut donc s’utiliser en IA agentique. Car tout ce qui est à base de markdown est utilisé comme support d’information pour les LLM, car c’est un formation structuré et vecteur d’information qui minimise l’utilisation de token.
Les RAG comme les MCP sont des solutions pour doter les LLM d’un contexte sur lequel ils n’ont pas été entrainés, évitant ainsi des hallucinations.
Par extension, aujourd’hui des gens s’intéresse à ce qu’on appelle un second cerveau (après le nôtre), l’idée est de combler ce qui manque au LLM : une mémoire persistante, qui le rendrait vraiment très efficace (pensez à Jarvis de Iron Man)
Maitriser ce skills vous permettre de concevoir un assistant vraiment efficace et opérationnel.
Si vous utilisez Claude régulièrement, vous avez peut-être remarqué qu’il adapte son comportement selon les contextes — il sait créer des documents Word propres, lire des PDFs complexes, ou générer des présentations PowerPoint clé en main. Derrière cette magie, il y a souvent un skill. Ce tutoriel vous explique tout : ce que c’est, comment en créer un, comment le rendre vraiment efficace, et comment Claude décide de l’utiliser.
Un skill est un fichier d’instructions que vous donnez à Claude pour lui apprendre à accomplir une tâche spécifique de façon reproductible et de qualité professionnelle. Imaginez que vous êtes chef cuisinier et que vous recrutez un assistant. Plutôt que de lui expliquer chaque soir comment préparer votre sauce signature, vous lui remettez une fiche recette détaillée : les ingrédients, les étapes dans l’ordre, les erreurs à éviter, les variantes possibles. C’est exactement ça, un skill. Avant je faisais toujours un long prompt avec des différence entre chaque fois, donc avec un skill c’est beaucouyp plus carré et je suis sûr de ne rien oublier, et je peux même améliorer mon skill puisque vous pouvez versionner le skill sur Github.
Concrètement, un skill c’est :
Un dossier portant le nom du skill (ex : docx/, pdf/, pptx/)
Un fichier principal appelé SKILL.md — le cœur du skill
Optionnellement : des scripts, des fichiers de référence, des assets (modèles, polices, icônes…)
Sans skill, si vous demandez à Claude « crée-moi un document Word professionnel », il va faire de son mieux — mais il risque d’oublier de gérer les styles, la table des matières, les en-têtes, les numéros de page. Avec un skill docx, Claude suit une méthode éprouvée : il installe les bonnes librairies Python, utilise python-docx de la bonne façon, applique une mise en page cohérente. Le résultat est radicalement différent.
Les skills servent à :
Capitaliser sur une méthode qui fonctionne bien
Standardiser les sorties pour qu’elles soient toujours de qualité
Éviter de réexpliquer la même chose à chaque conversation
Gérer des cas complexes avec des scripts et des ressources bundlées
Comment est structuré un SKILL.md ?
Le fichier SKILL.md a deux parties : un en-tête YAML (appelé frontmatter) et un corps en Markdown.
---
name: mon-skill
description: Ce que fait ce skill et quand l'utiliser. Inclure les déclencheurs spécifiques.
---
# Corps du skill
## Ce que Claude doit faire
Le frontmatter : la clé du déclenchement
Le frontmatter contient deux champs essentiels :
name — l’identifiant du skill. Simple, en minuscules, avec des tirets.
description — c’est le champ le plus important de tout le skill. C’est grâce à lui que Claude décide d’utiliser (ou non) le skill. Claude ne lit pas l’intégralité du skill à chaque requête — il scanne les descriptions de tous les skills disponibles et choisit lesquels consulter.
Pour une bonne description répondez à ces trois questions :
Qu’est-ce que ce skill fait ?
Dans quelles contextes l’utiliser ?
Quels mots-clés ou situations doivent le déclencher ?
description: >
Crée des documents Word (.docx) professionnels avec mise en page avancée.
Utiliser dès que l'utilisateur mentionne "Word", "docx", ".docx", ou demande
un rapport, mémo, lettre, ou tout document téléchargeable. Également utile
pour extraire du contenu depuis un .docx existant ou pour insérer des images
dans un document Word.
Le corps : les instructions pour Claude
Le corps du SKILL.md contient tout ce dont Claude a besoin pour accomplir la tâche : étapes à suivre, formats de sortie attendus, exemples, cas limites à gérer, erreurs courantes à éviter.
Il n’y a pas de format imposé — c’est du Markdown libre. :
## Workflow
1. Installer les dépendances : `pip install python-docx --break-system-packages`
2. Créer le document avec les styles appropriés
3. Sauvegarder dans /mnt/user-data/outputs/
## Format de sortie
Toujours utiliser cette structure :
- En-tête avec titre et date
- Table des matières si > 3 sections
- Pied de page avec numéros de page
## Exemples
**Exemple 1 :**
Requête : "Fais-moi un rapport d'analyse"
Action : Créer un .docx avec titre, TOC, sections numérotées
## À ne pas faire
- Ne pas utiliser reportlab (pour les PDFs, pas les .docx)
- Ne pas oublier d'appeler present_files à la fin
Le système de chargement progressif
Un des concepts les plus élégants des skills est la progressive disclosure : un système à trois niveaux.
Niveau 1 : Métadonnées (toujours en contexte)
name + description (~100 mots)
Niveau 2 : Corps du SKILL.md (chargé quand le skill est déclenché)
Instructions complètes (<500 lignes idéalement)
Niveau 3 : Ressources bundlées (chargées à la demande)
Scripts, références, assets (taille illimitée)
Cela signifie que Claude ne lit pas tous les skills en entier à chaque requête — ce serait beaucoup trop lourd. Il ne consulte que ce dont il a besoin, au moment où il en a besoin. A la différence des serveurs MCP qui peuvent être gourmand en tokens. Implication pratique : gardez votre SKILL.md sous 500 lignes. Si vous avez beaucoup de documentation (par exemple, plusieurs frameworks cloud : AWS, GCP, Azure), mettez-la dans des fichiers de référence séparés et indiquez dans le SKILL.md quand les lire :
## Documentation spécifique par plateforme
Selon la plateforme demandée, lire le fichier correspondant :
- AWS → references/aws.md
- GCP → references/gcp.md
- Azure → references/azure.md
Pensez à économiser vos tokens !
Comment créer un bon skill
Je sais qu’il existe des sites qui listent des milliers de skills, mais vous devez apprendre à les concocter vous même. Vous pouvez néanmoins vous inspirer pour faire les votre, comme ça vous comprendrez ce que vous faites.
Voici les principes qui distinguent un skill basique d’un skill vraiment efficace.
Principe 1 : la description est reine
Répétons-le car c’est crucial : la description détermine si le skill sera utilisé ou non. Une description trop vague = skill ignoré. Une description trop restrictive = skill sous-utilisé.
La description doit être légèrement « assertive » — elle doit pousser Claude à utiliser le skill dans tous les cas pertinents. Comparez :
description: Outil pour créer des dashboards. << trop vague
Crée des dashboards interactifs pour visualiser des données internes.
Utiliser dès que l'utilisateur mentionne des dashboards, de la visualisation
de données, des métriques, ou veut afficher n'importe quel type de données
d'entreprise — même sans le mot "dashboard" explicitement.
^ beaucoup plus précis, le contexte est plus riche, moins de devinette de la part du LLM.
Principe 2 : le principe de moindre surprise
Le comportement du skill doit correspondre exactement à ce que sa description promet. Un skill qui fait des choses inattendues crée de la confusion. Si votre description dit « crée des PDFs », le skill ne devrait pas aussi modifier des fichiers Excel sans le mentionner.
Principe 3 : préférez l’impératif dans les instructions
Les instructions doivent être claires et directes :
Il serait bien d'installer les dépendances << trop vague, ce n'est pas un ordre...
"Installer les dépendances avec pip install python-docx --break-system-packages" << précis et impératif
Principe 4 : inclure des exemples
Les exemples sont parmi les éléments les plus puissants d’un skill. Ils ancrent les instructions dans le concret :
## Exemples de messages de commit
Input: "Ajout de l'authentification avec JWT"
Output: feat(auth): implement JWT-based authentication
Input: "Correction du bug d'affichage sur mobile"
Output: fix(ui): resolve display issue on mobile screens
Principe 5 : anticipez les cas limites
Qu’est-ce qui peut mal tourner ? Documentez-le :
## Cas limites et erreurs courantes
- Si le fichier est trop volumineux (>50MB), prévenir l'utilisateur et proposer de traiter par chunks
- Si python-docx n'est pas disponible, l'installer avec --break-system-packages
- Si l'utilisateur ne précise pas de langue, utiliser le français par défaut
Principe 6 : déléguez aux scripts pour les tâches répétitives
Pour des opérations complexes et reproductibles, créez des scripts dans scripts/. Claude peut les exécuter sans même les lire entièrement — ce qui économise du contexte et garantit la cohérence.
## Création du document
Exécuter le script de génération :
```bash
python scripts/generate_report.py --title "$TITRE" --output /mnt/user-data/outputs/
---
## 5. Comment Claude décide d'invoquer un skill
C'est la question que tout créateur de skills se pose : quand est-ce que Claude va réellement utiliser mon skill ?
### Le mécanisme de déclenchement
### Ce qui favorise le déclenchement
- **Des mots-clés dans la requête** qui correspondent à la description du skill
- **La complexité de la tâche** — les tâches multi-étapes déclenchent mieux
- **Une description assertive** qui liste explicitement les déclencheurs
- **Le format de sortie attendu** — si l'utilisateur mentionne ".docx", ".pdf", ".pptx"
### Ce qui empêche le déclenchement
- Description trop vague ou trop générique
- Tâche trop simple (Claude la gère sans aide)
- Mots-clés absents de la description
### Astuce : tester et optimiser
Pour vérifier qu’un skill se déclenche bien, essayez différentes formulations de requête et observez si Claude consulte le skill. Si des requêtes légitimes passent à travers, enrichissez la description avec ces formulations.
Il existe même des outils d’optimisation automatique (comme run_loop.py dans l’outil skill-creator) qui testent la description avec des dizaines de variantes et proposent des améliorations basées sur les résultats.
Les skills par défaut de Claude
Vous avez dû sans doute rencontré ces skills car il les affiche dans la version web : docx, pptx,pdf,xlsx, frontend-design (en tant que dév web je le vois souvent), et skill-creator (un skill puor créer des skills !)
Une des difficultés que je rencontre avec Python est le global et le local, les différents version de python runtime installée, parfois les scripts nécessite une version spécifique de Python, c’est là que trouve son utilité le python launcher
# lister les version de python installée
$ py --list
Pour installer plusieurs version de python, vous pouvez allez sur le site officiel python.org et sélectionnez les versions que vous voulez télécharger. Mais, attention, pour les anciennes version, les installeur n’existent plus, et il faut compiler à partir du code source, pas pratique.
Mais selon cette page, à partir de la version 3.16 de python, le python install manager sera discontinué.
pyenv-win
C’est l’outil en ligne pour installer plusieurs versions de python.
# pour installer sous Powershell
pip install pyenv-win --target "$HOME\.pyenv"
# il est peut être préférable d'installer via GIT
git clone https://github.com/pyenv-win/pyenv-win.git "$HOME\.pyenv"
#ajout au PATH
[System.Environment]::SetEnvironmentVariable('PYENV',"$HOME\.pyenv\pyenv-win","User")
[System.Environment]::SetEnvironmentVariable('PATH',"$HOME\.pyenv\pyenv-win\bin;$HOME\.pyenv\pyenv-win\shims;$env:PATH","User")
# exemple de commandes
pyenv install 3.10.5 # Installe Python 3.10.5
pyenv install 3.11.9 # Installe Python 3.11.9
pyenv versions # Liste les versions installées
pyenv global 3.11.9 # Définit la version par défaut
pyenv local 3.10.11 # Définit la version pour le dossier courant
Solution plus moderne Python Install Manager
Allez sur cette page https://www.python.org/downloads/release/pymanager-261/, téléchargez le binaire et installez le. Puis pour installer une version spécifique de python :
pymanager install 3.12
Note 1:
Quand vous faites des commandes en shell sous Windows, distinguez bien Powershell, CMD, gitbash, cela peut avoir une grande incidence sur la réussite de la commande.
N’installez pas seulement la dernière version de python, en effet les librairies ne suivent pas aussi vite les version de Python, particulièrement en machine learning, je suis confronté à des erreurs car j’avais la dernière version.
Note 2:
python -m pip est toujours plus sûr car ça garantit que l’installation se fait dans le même Python que celui qui exécute ton script.
On entends beaucoup parler de vendre un saas, or vendre nécessite de mettre en place une solution de paiement. ET les intégrations sont plus ou moins facile, non seulement informatiquement, mais aussi l’obtention de la solution.
Je me souvenais qu’il fallait plusieurs semaines pour obtenir une solution de paiement de la banque, au début des années 2010. Il y avait certes Paypal, mais accepter la carte bancaire était mieux, et en plus plus on proposait de solutions de paiement plus on convertissait. Je me souviens aussi des moyens de paiement comme les virements bancaires et les chèques !
Puis est arrivé Stripe, dont l’intégration était 10 fois plus simple que Paypal. C’est ce que nous allons voir dans cette page. Regardez la vidéo pour plus de clarté et de facilité. Je vous mets en téléchargement les fichiers.
Mais il y a plus encore avec Stripe
Avec Stripe, c’est une protection de votre site avec les technique de geofencing, détection de cartes volée, gestion de dépassement ou insuffisance de cash dans le compte. Vous pouvez aussi faire du paiement récurrent (idéal pour les saas), et des solution de paiement en plusieurs fois (avec Alma), paiement en cryptomonnaie. Bref la société n’est pas devenue un décacorne pour rien.
Stripe est né avec le constat que les moyens de paiement de l’époque étaient trop compliqué à mettre en oeuvre, les fondateurs ont vu une opportunité à saisir.
vous vous êtes inscrit sur un parcours de formation type CDA ou DWWM ou Administrateur Devops, mais que faute de candidats, la session ne débutera pas. Je comprends votre frustration:
vous êtes déçu de ne pouvoir commencer une formation que vous désiriez depuis des lustres
vous avez perdu du temps à entamer des démarches
vous avez peut être perdu un peu d’argent également
Le secteur de l’informatique attire aujourd’hui un nombre croissant de personnes en quête de sens, de stabilité ou de reconversion. En pleine transformation numérique, tous les domaines économiques, sociaux et culturels s’appuient sur le numérique pour innover, produire ou communiquer. Face à cette demande, les métiers de l’informatique se diversifient, se spécialisent, et offrent une pluralité de parcours professionnels adaptés à différents profils. Que l’on soit passionné de technique, orienté vers la gestion ou attiré par la créativité, il y a une place dans cet univers. Si vous ne travaillez pas encore dans ce domaine mais y songez lisez cet article sur la reconversion professionnelle en informatique
Avant de plonger dans le détail, il est utile de comprendre que les métiers de l’informatique se regroupent en grandes familles. On distingue généralement le développement logiciel, l’infrastructure (systèmes, réseaux), la sécurité informatique, la gestion de projet, les métiers de la donnée, le design numérique, le web et mobile, sans oublier le support et l’assistance. Chacune de ces familles englobe plusieurs rôles spécialisés, avec des ponts entre eux selon les compétences et les appétences.
Développement logiciel : cœur battant de l’innovation
Le développeur, souvent désigné sous le terme générique de « codeur », est celui qui conçoit, écrit et teste les programmes informatiques. Mais derrière ce terme se cachent de nombreuses spécialisations : développeur front-end (interface utilisateur), back-end (logique métier et base de données), full-stack (polyvalent), mobile, ou encore développeur embarqué pour les objets connectés. Ces métiers demandent une maîtrise technique rigoureuse, une forte capacité de logique, mais aussi un esprit d’équipe et une bonne communication. Le développement logiciel est au centre de presque tous les projets numériques, qu’il s’agisse d’un site e-commerce, d’un logiciel de gestion, ou d’une application mobile.
Administration systèmes et réseaux : les gardiens de l’infrastructure
Invisible pour le grand public, l’administration des systèmes et des réseaux est pourtant vitale au bon fonctionnement de toute structure informatique. L’administrateur système gère les serveurs, les systèmes d’exploitation et la virtualisation, tandis que l’administrateur réseau veille au bon acheminement des données, à la configuration des routeurs et à la sécurité des connexions. Ces professionnels assurent la disponibilité, la sécurité et la performance de l’infrastructure. Ils interviennent également dans le déploiement de services cloud ou la supervision de la production. Ce sont les “garants de la stabilité” dans un environnement souvent critique.
Cybersécurité : les sentinelles du numérique
À mesure que les systèmes informatiques deviennent essentiels, les menaces se multiplient. La cybersécurité est devenue un domaine stratégique. L’expert en sécurité informatique identifie les vulnérabilités, met en place des solutions de protection, surveille les tentatives d’intrusion, et intervient en cas d’attaque. D’autres rôles émergent : analyste SOC, ingénieur sécurité, consultant en gouvernance des risques, hacker éthique… Ce secteur demande rigueur, discrétion, et une veille technologique constante. Très recherché, il attire autant les profils techniques que juridiques ou organisationnels.
Data & intelligence artificielle : donner du sens aux données
La donnée est devenue une matière première. L’analyste de données, le data scientist ou l’ingénieur en intelligence artificielle exploitent des volumes massifs de données pour en extraire des informations utiles. Grâce à des outils statistiques, des langages comme Python ou R, et des algorithmes de machine learning, ils aident à la prise de décision, à la prédiction ou à l’automatisation. Ce domaine est au croisement des mathématiques, de l’informatique et du métier métier. Il attire les profils analytiques, curieux et à l’aise avec l’abstraction.
Web & mobile : l’expérience utilisateur au centre
Créer des interfaces agréables, efficaces et réactives est le quotidien des développeurs web et mobile. Leur rôle est de concevoir les sites et applications que nous utilisons au quotidien, en tenant compte des spécificités techniques (navigateur, responsive design, performance) et des besoins des utilisateurs. Dans ce secteur, les technologies évoluent vite : JavaScript, React, Flutter, APIs, Progressive Web Apps… La dimension visuelle, l’interactivité et l’accessibilité sont clés. Ce métier allie sens pratique, autonomie et créativité.
Métiers de la gestion de projet IT
Piloter un projet informatique ne s’improvise pas. Le chef de projet IT coordonne les équipes, planifie les étapes, gère le budget et assure la livraison du produit dans les temps. Il fait le lien entre les équipes techniques et les clients ou utilisateurs. Il peut s’appuyer sur des méthodologies classiques (cycle en V) ou agiles (Scrum, Kanban). Ce rôle demande à la fois une culture technique, des compétences en communication, et une capacité à gérer les imprévus. D’autres rôles gravitent autour : Product Owner, Scrum Master, PMO…
UX/UI design : quand technologie rime avec ergonomie
L’expérience utilisateur est devenue un critère central dans le succès d’un produit numérique. Le designer UX (expérience utilisateur) s’intéresse à la manière dont l’utilisateur interagit avec un service. Il mène des recherches, teste des parcours, améliore la fluidité. Le designer UI (interface utilisateur) s’occupe de la cohérence graphique, de la hiérarchie visuelle, de l’esthétique. Ces deux rôles peuvent être fusionnés dans les petites structures. Ils requièrent un sens de l’observation, de l’analyse et une sensibilité au design.
Support et assistance : au service des utilisateurs
Chaque utilisateur peut se retrouver bloqué face à un outil numérique. Le technicien support est là pour l’aider, que ce soit à distance (helpdesk) ou en intervention directe. Il installe, configure, dépanne, et forme parfois les utilisateurs. Ce métier exige patience, pédagogie et un bon sens de l’écoute. Il est souvent un point d’entrée dans l’informatique, avec des évolutions possibles vers l’administration ou la gestion d’équipe. Dans les grandes entreprises, des niveaux de support (niveau 1, 2, 3) sont définis selon la complexité des problèmes traités.
Formations et compétences requises
Les métiers de l’informatique exigent des compétences techniques spécifiques, mais pas toujours les mêmes selon le domaine. Il existe des parcours variés : BTS, BUT, écoles d’ingénieurs, formations en ligne, bootcamps intensifs ou reconversions. L’apprentissage en continu est essentiel dans ce secteur. Les langages évoluent, les outils changent, les attentes du marché se transforment rapidement. Au-delà de la technique, les compétences transversales comme la capacité à résoudre des problèmes, à travailler en équipe ou à s’adapter sont très valorisées.
Perspectives d’évolution et de reconversion
Une des forces du secteur informatique est sa capacité à offrir des passerelles. Un technicien peut devenir administrateur système, un développeur peut évoluer vers la gestion de projet, un UX designer peut se spécialiser dans la recherche utilisateur. De nombreux professionnels se reconvertissent dans ce secteur, attirés par les opportunités, les salaires attractifs et la flexibilité. Le travail à distance, les missions en freelance et les environnements internationaux sont monnaie courante. C’est un domaine qui favorise la mobilité et la diversité des parcours.
Conclusion : choisir un métier informatique, une décision d’avenir
Choisir un métier de l’informatique, c’est entrer dans un univers en constante évolution, riche en opportunités, mais aussi exigeant. Que l’on souhaite coder, organiser, sécuriser, analyser ou concevoir, il existe un rôle pour chaque profil. Le numérique est devenu une composante essentielle de notre société. Participer à sa construction, c’est aussi avoir un impact. À condition de se former, de rester curieux, et de ne jamais cesser d’apprendre, chacun peut trouver sa voie dans cet écosystème dynamique.
Pour les développeur ayant suivi un cours sur Symfony, lors de la modélisation des entités, vous avez sans doute croisé le CASCADE DELETE quand vous aviez deux entité avec une relation oneToMany.
Exemple de situation où un cascade delete est utile
Par exemple une entité Category a une relation de un à plusieurs avec l’entité Product. Quand vous effacez une catégorie, et pour éviter que des produits se retrouvent sans catégorie, vous allez aussi effacer les produits correspondant à cette catégorie. Il y a effacement en cascade, l’effacement de la catégorie efface automatiquement les produits rattachés.
En SQL vous pouvez mettre une contrainte de CASCADE DELETE de cette façon :
CREATE TABLE utilisateurs (
id INT PRIMARY KEY,
nom VARCHAR(100)
);
CREATE TABLE commandes (
id INT PRIMARY KEY,
utilisateur_id INT,
FOREIGN KEY (utilisateur_id) REFERENCES utilisateurs(id) ON DELETE CASCADE
);
Ce n’est pas avec Category et Product mais vous l’aurez compris. Si vous n’avez pas fait de contrainte, vous devriez le faire manuellement.
DELETE FROM commandes WHERE utilisateur_id = 1;
DELETE FROM utilisateurs WHERE id = 1;
C’est un peu fastidieux, et pas garanti dans la théorie, il peut se produire un événement qui fait que la seconde requête ne soit pas exécutée (même si c’est peu probable, mais si nous considérons une application de grande échelle et profesionnelle, on ne peut tolérer çà)
Donc pour garantir que les deux requêtes sont exécutées, nous devons utiliser le mécanisme de transaction.
Qu’est ce qu’une transaction?
Imaginez que vous retirez du cash à un ATM, vous entrez votre code vous récupérez votre carte, mais à la fin vous ne percevez pas vos billets et le ticket sort avec une erreur. Vous vous demandez si votre compte en banque ne s’est pas diminué de la somme que vous vouliez retirer, malgré le fait que vous n’avez pas perçu vos billets ! (rassurez vous ce n’est pas le cas !). le mécanisme de transaction fait que comme le s billets ne sont pas sortis, le débit sur votre compte n’est pas effectif.
Eh bien c’est le même mécanisme dans la requêtes SQL.
START TRANSACTION;
DELETE FROM commandes WHERE utilisateur_id = 1;
DELETE FROM utilisateurs WHERE id = 1;
COMMIT;
Dans MySQL, par défaut vous êtes en AUTOCOMMIT, mais dans l’absolu, une requête SQL doit avoir la forme ci-dessus.
Si une des requêtes échoue, il se produira un ROLLBACK, pour revenir à un état comme si rien ne s’est passé.
BEGIN;
DELETE FROM commandes WHERE utilisateur_id = 42;
DELETE FROM utilisateurs WHERE id = 42;
-- Si les 2 passent bien
COMMIT;
-- Si erreur ou condition non respectée
ROLLBACK;
// Dans la console SQL, vous pouvez explicitement faire un ROLLBACK pour annuler une requête si le COMMIT n'est pas invoqué
Le mécanisme de cascade avec PDO en PHP
function deleteQuestion(PDO $pdo, int $id): array
{
try {
// Démarrer la transaction
$pdo->beginTransaction();
// Supprimer d'abord les réponses
$stmt = $pdo->prepare("DELETE FROM reponses WHERE fk_question = :id");
$stmt->execute(['id' => $id]);
// Puis supprimer la question
$stmt = $pdo->prepare("DELETE FROM questions WHERE id = :id");
$stmt->execute(['id' => $id]);
// Tout est ok → commit
$pdo->commit();
return ['success' => true];
} catch (Exception $e) {
// En cas d'erreur → rollback
if ($pdo->inTransaction()) {
$pdo->rollBack();
}
return ['success' => false, 'error' => $e->getMessage()];
}
}
Si vous êtes codeur, cette façon de procéder paraitra plus simple :
Utilisation des vraies méthodes transactionnelles de PDO (beginTransaction, commit, rollBack).
Exécution séparée des requêtes (plus clair et plus sûr que tout mettre dans une seule string).
Retour structuré (['success' => true] ou ['success' => false, 'error' => ...]) pour facilement tester côté front.
Typage de la fonction (PDO $pdo, int $id : array) → un peu plus robuste.
Je vous présente les workspaces qui vont vous permettre de travailler plus efficacement même si vous n’avez qu’un seul projet.
Je vais prendre pour exemple mes dossiers de formation par langage. J’enseigne le HTML/CSS, PHP, Python, Javascript et donc au moins 3 dossiers. J’aimerais lorsque je montre un exemple avoir accès à ces 3 dossiers.
Avant :
Soit j’ouvrais plusieurs fois le dossier pour trouver mon exemple de code, soit j’ouvrais plusieurs fenêtres (car j’ai tellement de codes que je ne me souviens plus)
Après :
Avec les workspaces, j’ai sous la main tous ces dossiers et je peux chercher facilement sans ouvrir de VSCode supplémentaires. Vous pouvez sauver votre configuration dans un fichier workspace et réouvrir exactement comme c’était la prochaine fois.
Connaissez vous le setting.json dans .vscode (le fichier que vous aimez ignorer dans git), il contient par exemple alversion de l’interpréteur, le ty pe d’indentationi, le linting, thème de l’éditeur.
Extensions par workspace
je peux activer ou désactiver des extensions par workspaces !
Configuration de debug par workspace
On peut avoir un fichier launch.json pour lancer et déboguer avec les bon paramètres, NodeJs dans un projet, ou React dans un autre.
Multiroot workspace
On peut avoir plusieurs dossiers indépendants dans un même workspace, utile quand vous faites un monorepo par exemple : un back end en nodeJS, un front reactJS, avec un Golive qui ne réagit qu’au changement de fichier que dans le dossier front end.
Task spécifique au workspace
Le fichier tasks.json (build, test, script etc) permet de définir des tâches automatisées, qu’on peut voir dans le menu Terminal > Run Task
Les shells
Dans le terminal, vous pouvez ouvrir plusieurs shells, mais en l’absence de workspace, ce n’est pas mémorisé, saviez vous que vous pouvez changer la couleur du label du shell? Grâce au workspace, ce setting sera mémorisé.
Utilisation d’un task pour automatiser l’ouverture de terminaux
Une subtilité en Javascript que dorénavant les dév junior ne connaissent pas
En javascript, le mot clé this peut se comporter de façon inattendue. Pour les personnes qui sont habituées à programmer en Java ou en C++, le mot clé 10 représente l’objet lui-même.
En JavaScript, le mot clé this aussi représente un objet, mais cela dépend de sa position dans le code. Nous allons voir que dans une fonction qui fait appel au mot clé 10, dans un console.log par exemple, le mot clé this représente l’objet dans lequel il se trouve, ou non. Nous allons voir que dans une fonction qui fait appel au mot clé 10, dans un console.log par exemple, le mot clé this représente l’objet dans lequel il se trouve, ou non. Nous allons voir que dans une fonction qui fait appel au mot clé this , dans un console.log par exemple.
"use strict";
let utilisateur = {
nom: "Alice",
direNom: function() {
console.log("dans direNom -> this.nom =", this.nom);
function interne() {
console.log("dans interne -> this.nom =", this.nom);
}
interne();
}
};
utilisateur.direNom();
// sortie
dans direNom -> this.nom = Alice
dans interne -> this.nom = undefined // ou Window.nom si non strict
Pourquoi donc this change de forme?
utilisateur.direNom() Ici, thisest lié à l’objet utilisateur, donc this.nom = "Alice".
Fonction interne() Même si elle est définie à l’intérieur de direNom, elle est appelée comme une fonction simple (pas comme une méthode d’objet). → Dans ce cas, this ne fait plus référence à utilisateur.
En mode strict, this = undefined.
En mode non strict, this = window (dans un navigateur).
En bref la fonction direNom est une propriété de l’objet utilisateur, donc possède un this. La fonction interne() est une fonction non attachée à une propriété de l’objet utilisateur. En strict il vaut undefined, et en non strict il vaut window !
Comment contourner ce piège classique?
Méthode avec that = this
On a le très populaire that = this
"use strict";
let utilisateur = {
nom: "Alice",
direNom: function () {
console.log("dans direNom -> this.nom =", this.nom);
let that = this
function interne() {
console.log("dans interne -> this.nom =", that.nom);
}
interne();
}
};
utilisateur.direNom();
Méthode avec un binding de contexte
Le binding de contexte permet de dire dans le fonction à quoi correspond le this
"use strict";
let utilisateur = {
nom: "Alice",
direNom: function () {
console.log("dans direNom -> this.nom =", this.nom);
function interne() {
console.log("dans interne -> this.nom =", this.nom);
}
// on lie la fonction interne au contexte courant (this = utilisateur)
let interneLie = interne.bind(this);
interneLie();
}
};
utilisateur.direNom();
Notez que l’on déclare une nouvelle variable pour faire le binding
Méthode avec une fonction flèche
Les fonction flèche n’ont pas leur propre this, donc ils héritent du this du parent.
"use strict";
let utilisateur = {
nom: "Alice",
direNom: function () {
console.log("dans direNom -> this.nom =", this.nom);
// fonction fléchée : hérite du this de direNom
const interne = () => {
console.log("dans interne -> this.nom =", this.nom);
};
interne();
}
};
utilisateur.direNom();
A noter que ici on a une fonction définie dans une autre fonction, en programmation fonctionnelle on appelle cela une closure.
Dans cet article nous allons mettre en place très simplement une application ReactJS avec un test. Nous allons partir de zéro, on va bootstrapper une application très simple et mettre en place Vitest et lancer notre premier test.
npm create vite@latest react-vitest-demo
cd react-vitest-demo
npm install
Vitest fonctionne comme Jest mais avec les module ESM. J’ai eu des soucis à faire fonctionner Jest avec les modules ESM. Donc Vitest vient à point nommé.
Cependant on va utiliser des librairies de Jest (le framework de test) comme @testing-library/react et @testing-library/jest-dom
Plus spécifiquement il y a un fichier de setup, qui va initialiser jest-DOM pour avoir des matchers pratiques comme toBeInTheDocument(), dans src/setupTests.js
import '@testing-library/jest-dom'
Il manque un composant à installer jsdom
npm i -D jsdom
Création d’un composant à tester
On va créer un simple composant Hello.jsx
export default function Hello({ name }) {
return <h1>Hello {name}!</h1>
}
Ainsi que le test du composant
import { render, screen } from '@testing-library/react'
import Hello from './Hello'
test('affiche le nom passé en prop', () => {
render(<Hello name="Yvon" />)
expect(screen.getByText(/Hello Yvon!/i)).toBeInTheDocument()
})
On va lancer le test avec la command npm test, donc il faut que dans le package.json, ce script soit présent.
PS E:\react-vitest-demo> npm test
> react-vitest-demo@0.0.0 test
> vitest
DEV v3.2.4 E:/react-vitest-demo
✓ src/Hello.test.jsx (1 test) 16ms
✓ affiche le nom passé en prop 16ms
Test Files 1 passed (1)
Tests 1 passed (1)
Start at 22:09:08
Duration 675ms (transform 25ms, setup 70ms, collect 68ms, tests 16ms, environment 325ms, prepare 58ms)
PASS Waiting for file changes...
press h to show help, press q to quit
Avoir un visuel de ce que vous testez
Pour ce faire il faut installer le package vitest/ui
npm run test:ui
Test d’un composant interactif (Compteur incrémental)
import { render, screen, fireEvent } from '@testing-library/react'
import Counter from './Counter'
test('incrémente le compteur quand on clique', () => {
render(<Counter />)
const button = screen.getByText('+1')
fireEvent.click(button)
expect(screen.getByText(/Count: 1/i)).toBeInTheDocument()
})
Test en ligne de commande
Test graphique
Mise en oeuvre des tests dans Github Actions
L’idée est d’automatiser le déploiement de votre application quand vous faites un git push, avouez que c’est super non? En effet à l’ancienne vous deviez vous connecter à votre terminal de serveur puis faire un git pull. Bien qu’il y ait les webhook de github, qui permettent de s’affranchir de cette étapes, ces derniers ne permettaient pas de faire des processus de déploiement plus sophistiqués. Cet article sur Github Action va vous montrer comment simplement mettre en oeuvre pour un projet front-end, ce processus de déploiement.
J’ai actuellement Laragon version 6, et j’en suis très content. cependant, une histoire de dingue est arrivée à son créateur, vous pouvez lire ici, et depuis il a décidé de mettre en payant son logiciel.
Ceux d’entre vous qui ont installé une version postérieur voient une popup demande d’entrer une clé. Il n’est pas obligatoire de le faire, mais cette alerte revient tout le temps.
Libre à vous de supporter le travail de ce monsieur, mais il est possible d’avoir une version gratuite et sans rappel de payer, c’est la version 6
Comment installer la version 6 de Laragon?
Pour installer la dernière version de Laragon, il faut aller sur le Github du projet, ensuite il faut aller sur la section release, et sélectionner la version 6. Des liens apparaitront pour télécharger l’exécutable.
Dans la page d’accueil du projet donc, faite CTRL + F et cherchez le mot « release », cliquez sur le lien, vous tomberez sur la page des release. Sélectionnez dans la liste déroulante la version 6 et voilà !
Laragon n’est que sur Windows.
Pourquoi j’utilise Laragon?
J’ai utilisé pendant des années (plus de 10 ans) WAMP, et j’ai tout de suite adopté Laragon, car la configuration est plus ergonomique, on gagne du temps (détection de projet dans le répertoire www). ça me fait gagner du temps.
Ce qui est montré dans cet article est très important, pas forcément pour de bonnes raison, voici pourquoi:
Les services cloud de Google sont souvent incontournable (Gmail, Drive)
Il est très fastidieux de lier des applications tierces aux services de Google
Pour illustrer cette assertion, supposez que vous voulez utiliser le webservice de OpenAI, vous créer dans votre dashboard OpenAI une clé APi et c’est plié. Mais pour utiliser Gemini de Google, il va falloir passer pas mal de temps dans la console API de Google !
J’espère que cette page vous aidera à vous repérer dans les méandres de Google API console. car moi-même j’ai des difficulté avec elle.
Voici la procédure à suivre pour obtenir les clé secret et public
Allez dans la console de Google
Créer un projet (en haut à gauche), donnez un nom et cliquer sur CREATE
Aller dans la barre latérale, et sélectionner API & Service puis Oauth Consent Screen
Ici vous allez entrer les information de votre projet n8n, Developer contact information entrez votre email.
Dans le scope ne faites rien et cliquez Continue.
Ajouter un Test User en entrant un email (doti être un gmail bien sûr)
Maintenant que ça c’est fait allez dans la barre latérale et aller dans CREDENTIALS
Cliquer CREATE CREDENTIALS et sélectionner « OAuth Client ID »
Dans Application Type sélectionnez « Web Application », donnez un nom
Dans Authorized redirect URIS, ajoutez l’url que n8n vous a donné « http://localhost:5678/rest/oauth2-credential/callback »
Cliquez sur CREATE et une popup va vous montrer les credentials Client ID et Client Secret
Collez ces information dans le noeud n8n concerné, et cliquez sur Sign In With Google
Une dernière étape !! Retournez dans API&SERVICE et Enable APIS and Services, tapez dans la barre de recherche et cherchez Gmail et cliquez sur Enable
Qu’en pensez vous? pour ma part je suis vraiment scandalisé par cette complexité. Mais bon. La suite va être plus facile, chaque fois que vous avez un noeud et un nouveau service Google, il ne vous reste plus qu’à cliquer sur Sign In With Google puis à activer le webservice dans la console.
Mais l’avantage une fois que vous avez fait ce travail fastidieux, c’est que tout nouveau service Google peut utiliser ces credentials.
Les alias permettent de remplacer des commandes longues à taper par des commandes plus courte ou plus facile à mémoriser.
Création d’un alias
la commande ls est pratique, et encore plus ls -l, qui liste les fichiers avec des information sur les droits et propriétaires.
C’est un peu long de taper ls -l, souvent on alias vers ll (parfois sur certaines distribution c’est déjà créé)
alias // liste les alias
alias egrep='egrep --color=auto'
alias fgrep='fgrep --color=auto'
alias grep='grep --color=auto'
alias l='ls -CF'
alias la='ls -A'
// aliaser ls -la en ll
alias ll='ls -la'
alias ls='ls --color=auto'
// autre exemple
alias authlog="sudo tail -f /var/log/auth.log"
A quel public s’adresse ces sessions de rattrapage?
Les sessions de rattrapage d’examen pour les titres professionnels DWWM (Développeur Web et Web Mobile) et CDA (Concepteur Développeur d’Applications) s’adressent avant tout aux candidats ayant déjà présenté l’examen une première fois, mais qui n’ont pas obtenu la validation complète du titre (validation partielle d’un bloc de compétence). Vous avez peut être manqué de chance ce jour car vous pensiez que votre présentation était bonne, en êtes vous sûr?
Les candidats conservent le droit de repasser les blocs de compétences non validés, dans un délai imparti par le ministère du Travail. Ces sessions sont donc une seconde chance précieuse pour finaliser leur projet professionnel et valider le titre visé.
Ainsi, un candidat ayant obtenu la validation d’un bloc sur deux (Le frontend) pour le DWWM peut choisir de ne repasser que le bloc manquant (le backend), sans avoir à reprendre l’ensemble des épreuves. Cette souplesse constitue un atout considérable du système de certification professionnelle français. Enfin, certains apprenants peuvent également se retrouver dans une situation où ils n’ont pas pu se présenter à l’examen initial à cause de circonstances personnelles ou administratives : pour eux, la session de rattrapage est souvent le seul moyen d’accéder à la certification sans devoir reprendre tout le parcours de formation.
Pour quand réserver la session de rattrapage?
En règle générale, un candidat dispose de cinq années à compter de la date du premier passage pour valider les blocs manquants et ainsi obtenir le titre complet. Dans les faits, à quoi sert d’attendre plusieurs années? les technologies évoluent vite en informatique, il est fortement recommandé de ne pas attendre trop longtemps, surtout lorsque les compétences acquises risquent de s’estomper avec le temps. Chez Formapedia, nous conseillons à nos apprenants de réserver leur session de rattrapage sous un mois à 3 mois, pour ne pas perdre Ce délai permet à la fois une révision ciblée et une montée en confiance progressive.
Chez Formapedia, nous accompagnons chaque candidat s’il le veut dans sa préparation, en lui proposant une date en fonction de son aptitude. Une fois la date fixée, nous organisons un accompagnement individualisé pour réviser les compétences ciblées, avec des simulations d’entretien professionnel, des corrections de livrables, et des retours personnalisés. Cette organisation rigoureuse optimise les chances de réussite et évite les mauvaises surprises de dernière minute.
Les avantages de planifier une session de rattrapage avec Formapedia
Choisir Formapedia pour planifier sa session de rattrapage, c’est bénéficier d’un encadrement professionnel, humain et pédagogique à chaque étape du processus. Contrairement à un simple passage en candidat libre, où le candidat est souvent seul face à ses doutes et ses lacunes, Formapedia propose un accompagnement complet pour identifier les points faibles, travailler les livrables, renforcer la présentation orale, et clarifier les attentes du jury. Nos formateurs sont eux-mêmes développeurs expérimentés, juré avec plusieurs année d’expérience, spécialisés en DWWM ou CDA, et connaissent parfaitement les référentiels, les attendus de l’examen et les erreurs les plus fréquentes à éviter, les poncifs et les question piège. Ce retour d’expérience est un levier précieux pour reprendre confiance et progresser efficacement.
En outre, nos sessions sont organisées dans un cadre bienveillant, mais rigoureux, avec des conditions proches de celles de l’examen officiel. Cela permet de réduire le stress, notamment pour les candidats qui ont vécu une première session difficile. Nous mettons également à disposition des ressources pédagogiques ciblées, des modèles de livrables, des grilles de notation commentées, ainsi que des sessions de coaching en visio. Cette approche individualisée, centrée sur la réussite de chacun, fait partie de notre ADN. Grâce à cet accompagnement, nos candidats au rattrapage affichent un taux de réussite bien supérieur à la moyenne nationale. Enfin, nous nous chargeons de l’ensemble des démarches administratives (convocations, inscriptions à la DREETS, organisation des jurys) afin que le candidat puisse se concentrer uniquement sur sa préparation.
Les modalités de passage d’examen de rattrapage
Le passage d’un examen de rattrapage pour le DWWM ou le CDA suit une procédure encadrée par les textes officiels du ministère du Travail. Il est impératif que le candidat repasse uniquement les blocs de compétences non validés. Cela signifie qu’il devra représenter un ou plusieurs livrables, actualisés et corrigés, en fonction des retours obtenus lors de la première session. Il devra également se présenter à un nouvel entretien technique et professionnel devant un jury agréé. Ce jury évalue la progression du candidat, la qualité de son projet, ses compétences techniques (HTML, CSS, JavaScript, PHP, MySQL, etc.), ainsi que sa posture professionnelle. La durée et la forme de l’épreuve peuvent légèrement varier selon les blocs à repasser, mais la rigueur de l’évaluation reste la même que lors de l’examen initial.
Chez Formapedia, nous prenons en charge l’ensemble des formalités liées à l’organisation de cette session : convocation, planification, mise à disposition d’un jury agréé, préparation technique des salles ou des visios, vérification des documents officiels, etc. Le jour J, le candidat est accueilli dans des conditions professionnelles optimales, avec un matériel informatique conforme et une assistance logistique si nécessaire. Pour les candidats à distance, un système de visio sécurisé est mis en place, en conformité avec les exigences de la DREETS. Les jurys sont sensibilisés aux enjeux spécifiques d’un rattrapage : ils évaluent la progression, l’amélioration des livrables, et la capacité du candidat à intégrer les retours précédents. Cette évaluation bienveillante mais exigeante permet de valider objectivement les compétences restantes.
Si vous êtes en attente de l’obtention du titre pour passer en master ou en alternance, n’attendez plus et assurez vous votre avenir. Nous avons à plusieurs reprise sauvé l’année scolaire de plusieurs apprenants ! Témoignage sur demande.
CORS veut dire Cross Origin Resource Sharing ou en français partage des ressources inter origines. bon dit comme ça ça veut pas dire grand chose. En gros, quand vous faites une requêtes AJAX, vous le faites depuis (en formation informatique) votre poste local localhost. Imaginons que vous vouliez faire une requête AJAX vers le site OpenWeatherMap.org, vous voyez bien que le nom de domaine est différent de localhost. Eh bien on a là un cas de requêtes AJAX Cross Origin.
Pourquoi parle t on de CORS?
Le web est un monde ouvert où on peut faire à peu près n’importe quoi. Il y a des considération de sécurité, concept très important dans un monde ouvert. Ici avec le CORS on fait la distinction entre les requêtes AJAX internes et les requêtes AJAX venants d’un autre site web. Je trouve personnellement que c’est fantastique qu’il soit possible de partager des informations entre sites web.
Les requêtes AJAX internes
Quand vous développez un front en en Javascript (Javascript pur ou ReactJS ou Angular peu importe) vous faites des requêtes AJAX locales pour tirer des informations à afficher. Vous requêtez votre serveur qui est dans le même nom de domaine que le code Javascript qui fait la requête. Dans ce cas il n’est pas de problème de CORS, tout est sur un même domaine.
Ce cas de figure, c’est la majorité des applications modernes, donc vous n’êtes pas confronté au problème de CORS.
Les requêtes externes
Mais imaginez que vous développiez une application IOS ou Android, dans ce cas vous ferez face à des problème de CORS. En effet la requête réseau ne provient pas du site web du serveur, donc ce sera considéré comme une requête CORS. Si vous ne faites rien côté serveur vous n’allez pas pouvoir servir le contenu à l’application mobile.
Le problème du CORS se règle côté serveur et non côté client.
Ayez le réflexe de regarder du côté du serveur pour résoudre le problème de CORS. Vous ne pouvez rien faire du côté du client. Nous allons regarder un exemple avec un code PHP.
Supposons que le code serveur ci-dessous se trouve sur le domaine localhost:
http://localhost/index.php
echo json_encode(['message' => 'Bonjour']);
Voici le code côté client en javascript : http://localhost/caller.html
fetch('http://localhost/index.php')
.then(response => response.json())
.then( data => console.log(data))
Le fichier dans lequel réside le Javascript est dans le domaine localhost, donc pas de problème de CORS. Mais regardons le cas suivant
http://localhost/index.php
echo json_encode(['message' => 'Bonjour']);
Voici le code côté client en javascript : http://127.0.0.1/caller.html
fetch('http://localhost/index.php')
.then(response => response.json())
.then( data => console.log(data))
Cette fois ci nous avons u problème de CORS en effet localhost n’est pas pareil que 127.0.0.1 bien que d’un point de vu résolution de chemin ce soit la même chose !
Mise en place du CORS en PHP
Comme la solution est du côté du serveur, nous allons ajouter à la réponse du serveur des en-têtes pour permettre au CORS de fonctionner.
header('Content-Type: application/json');
header("Access-Control-Allow-Origin: *");
header('Access-Control-Allow-Credentials: true');
header('Access-Control-Max-Age: 86400'); // cache for 1 day
echo json_encode(['message' => 'Bonjour']);
Ce qui est important c’est le Access-Control-Allow-Origin, qui va permettre de faire du CORS. Ici on a mis un astérisque qui désigne tous les domaines, mais on peut restreindre à un domaine en particulier.
Les requêtes PREFLIGHT
Maintenant que vous savez faire du CORS affinons le sujet avec les requêtes Preflight. Elles sont envoyées par le navigateur pour « sonder » le serveur dans le cas de requêtes CORS. Le verbe HTTP est OPTIONS. Cette requête est automatiquement envoyée par le serveur, le développeurs front end n’a pas à s’en soucier.
Le serveur quand il reçoit cette requêtes OPTIONS doit répondre avec Access-Control-Allow-Method
header( 'Access-Control-Allow-Methods: GET, POST, OPTIONS' );
Si vous ne l’avez pas déjà fait téléchargez symfony CLI sur le site officiel. C’est un binaire donc en fonction de votre plateforme, ce n’est pas le même programme.
Un peit mot avnagt de commencer,ici on va installer API Platform en tant que bundle de Symfony, et ReactJS dans un répertoire indépendant. Symfony propose aussi d’installer ReactJS comme un greffon de Twig, personnellement je n’ai pas réussi à le faire marcher, les composants ne se renderisaient pas. Je préfère quand le front et le back sont séparés (pas de monorepo), car le webservice doit servir d’autres plateformes (mobile par exemple)
symfony new bookshop-api
cd bookshop-api
Etape importante installation du bundle:
symfony composer require api
Création de la base de donnée:
symfony console doctrine:database:create
symfony console doctrine:schema:create
// si vous avez des soucis sous MAMP pour créer la base de données, sachez que e port de MySQL n'est aps 3306 et
Puis lancement du serveur avec Symfony CLI
symfony serve
Accéder à votre site
Symfony CLI va vous donner votre url pour le site. Il faut savoir qu’avec API Platform, vous n’avez pas de front end pour votre site. Le front end va être assuré par ReactJs qui sera complètement indépendant dans sa structure de fichiers d’API Platform.
http://localhost:8000/
Votre webservice est accessible à l’url http://localhost:8000/api ! cela intéresse ReactJS. Voici ce que vous verrez si vous accéder à cette url.
L’interface que vous voyez est Swagger, une librairie de documentation interactive de votre webservice. Il est important lorsque vous travaillez avec API Platform que vous devez oubliez ce que vous avez appris avec une application Symfony classique sauf pour les entités.
Création d’une entité Book
Copiez le code suivant (extrait de la documentation officielle)
<?php
// src/Entity/Book.php
namespace App\Entity;
use ApiPlatform\Metadata\ApiResource;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\ORM\Mapping as ORM;
/** A book. */
#[ORM\Entity]
#[ApiResource]
class Book
{
/** The ID of this book. */
#[ORM\Id, ORM\Column, ORM\GeneratedValue]
private ?int $id = null;
/** The ISBN of this book (or null if doesn't have one). */
#[ORM\Column(nullable: true)]
public ?string $isbn = null;
/** The title of this book. */
#[ORM\Column]
public string $title = '';
/** The description of this book. */
#[ORM\Column(type: 'text')]
public string $description = '';
/** The author of this book. */
#[ORM\Column]
public string $author = '';
/** The publication date of this book. */
#[ORM\Column]
public ?\DateTimeImmutable $publicationDate = null;
/** @var Review[] Available reviews for this book. */
#[ORM\OneToMany(targetEntity: Review::class, mappedBy: 'book', cascade: ['persist', 'remove'])]
public iterable $reviews;
public function __construct()
{
$this->reviews = new ArrayCollection();
}
public function getId(): ?int
{
return $this->id;
}
}
Allez maintenant dans l’adresse de la documentation de votre API http://localhost:8000/api
Créez une seconde entité Review
<?php
// src/Entity/Review.php
namespace App\Entity;
use ApiPlatform\Metadata\ApiResource;
use Doctrine\ORM\Mapping as ORM;
/** A review of a book. */
#[ORM\Entity]
#[ApiResource]
class Review
{
/** The ID of this review. */
#[ORM\Id, ORM\Column, ORM\GeneratedValue]
private ?int $id = null;
/** The rating of this review (between 0 and 5). */
#[ORM\Column(type: 'smallint')]
public int $rating = 0;
/** The body of the review. */
#[ORM\Column(type: 'text')]
public string $body = '';
/** The author of the review. */
#[ORM\Column]
public string $author = '';
/** The date of publication of this review.*/
#[ORM\Column]
public ?\DateTimeImmutable $publicationDate = null;
/** The book this review is about. */
#[ORM\ManyToOne(inversedBy: 'reviews')]
public ?Book $book = null;
public function getId(): ?int
{
return $this->id;
}
}
Voici ce que vous devriez voir dans la documentation
Les annotation Doctrines sont déjà présentes dans le code car je les ai déjà ajoutées. Vous devez les ajouter pour toute nouvelle entité que vous créez. C’et nécessaire pour faire la migration et ainsi créer des tables dans la base de données.
php bin/console make:entity --api-resource. // permet d'annoter
Migration vers la base de données
Tapes les lignes suivantes pour faire la migration
Si la migration des tables est faites sans problème nous allons pouvoir commencer !
Opération CRUD avec Swagger
Nous n’allons pas Postman pour faire nos requêtes AJAX mais directement dans Swagger, c’est l’intérêt de l’outil.
Allez dans Swagger, Book puis cliquez sur POST, une fenêtre se déroule, cliquez sur « Try it out ». Collez le json suivant dans le champs « Request body »
{
"isbn": "9781782164104",
"title": "Persistence in PHP with the Doctrine ORM",
"description": "This book is designed for PHP developers and architects who want to modernize their skills through better understanding of Persistence and ORM.",
"author": "Kévin Dunglas",
"publicationDate": "2013-12-01"
}
Puis cliquez sur Execute.
Vérifiez que dans la table Book vous avez une entrée correspondante. Passez à l’insertion d’une review
Un script shell est un fichier texte rendu exécutable en ligne de commande. La première ligne du fichier contient une ligne spéciale appelée shebang #!, suivi du chemin absolu vers l’interpréteur shell, qui peut être bash sh ou zsh, voire même un interpréteur python
#!/bin/bash
#!/bin/zsh
#!/usr/bin/python
Si vous omettez le shebang, alors c’est le shell courant qui est utilisé, mais dans ce cas il n’y aucune garantie que le script est compatible avec votre shell courant, donc il est très conseillé de le spécifier.
Les variables
Une variable est en majuscule et en snake case
#!/bin/bash
MY_SHELL="bash"
NOM_SERVEUR=$(hostname) // ou NOM_SERVEUR=`hostname` ancienne syntaxe
echo "J'aime mon $MY_SHELL shell."
echo "J'aime mon ${MY_SHELL}ing shell." // la syntaxe avec accolade permet de concaténer
Généralement les nom de variable valide suivent la m^me règle que dans les langages de programmation
Contrôle d’exécution
Les tests (équivalent de if else)
Syntaxe :
[ condition-a-tester]
exemple :
[-e /etc/passwd] // teste si le fichier /etc/passwd existe
Autres exemples :
-d NOM_FICHIER True si fichier est un répertoire
-e NOM_FICHIER True si le fichier existe
-f NOM_FICHIER True si le fichier existe et est un fichier ordi
-r NOM_FICHIER True si le fichier readable par moi
-s NOM_FICHIER True si le fichier existe et est non vide
-w NOM_FICHIER True si le fichier est writable par moi
-x NOM_FICHIER True si le fichier est exécutable par moi
-z STRING True si string est vide
-n STRING True si string est non vide
STRING1 = STRING2 égalité
STRING1 != STRING2 inégalité # attention un seul signe égal !!
#Tests arithmétiques
arg1 -eq arg2 True si arg1 est égal à arg2
arg1 -ne arg2 True si arg1 est égal à arg2
arg1 -lt arg2 True si arg1 est less than à arg2
arg1 -le arg2 True si arg1 est less or equal à arg2
arg1 -gt arg2 True si arg1 est greater than à arg2
arg1 -ge arg2 True si arg1 est gretaer or equal à arg2
Branchement conditionnel
Syntaxe générale:
if [ condition-est-vraie ]
then
commande 1
commande 2
commande 3
fi
# exemple :
#!/bin/bash
AGE=34
if [ "$AGE" -eq 18 ]; // ici il faut entourer AGE de guillements et préfixer AGE d'un signe dollar
then
echo "vous avez ${AGE} vous êtes une personne mineure"
else
echo "vous avez ${AGE} vous êtes une personne majeure"
fi
# multiple condition avec elif
#!/bin/bash
AGE=20
if [ "$AGE" -lt 18 ]; then
echo "Vous êtes mineur."
elif [ "$AGE" -eq 18 ]; then
echo "Vous avez exactement 18 ans."
else
echo "Vous êtes majeur."
fi
# ET et OU
#!/bin/bash
AGE=20
CITOYEN="oui"
if [ "$AGE" -ge 18 ] && [ "$CITOYEN" = "oui" ]; then
echo "Vous pouvez voter."
else
echo "Vous ne pouvez pas voter."
fi
# avec CASE
#!/bin/bash
JOUR="samedi"
case "$JOUR" in
"lundi"|"mardi"|"mercredi"|"jeudi"|"vendredi")
echo "C'est un jour de travail."
;;
"samedi"|"dimanche")
echo "C'est le week-end !"
;;
*)
echo "Jour inconnu."
;;
esac
On va pousser le script un peu plus loin avec la récupération dynamique du jour, ainsi on n’a plus besoin de coder en dur.
Mais auparavant on va installer pour nous assurer sur le locale franançais est installé
locale
LANG=fr_FR.UTF-8
LANGUAGE=
LC_CTYPE="fr_FR.UTF-8"
LC_NUMERIC="fr_FR.UTF-8"
LC_TIME="fr_FR.UTF-8"
LC_COLLATE="fr_FR.UTF-8"
LC_MONETARY="fr_FR.UTF-8"
LC_MESSAGES="fr_FR.UTF-8"
LC_PAPER="fr_FR.UTF-8"
LC_NAME="fr_FR.UTF-8"
LC_ADDRESS="fr_FR.UTF-8"
LC_TELEPHONE="fr_FR.UTF-8"
LC_MEASUREMENT="fr_FR.UTF-8"
LC_IDENTIFICATION="fr_FR.UTF-8"
LC_ALL=
si vous ne voyez pas ça c'est que ce n'est pas installé. Faites la commande suivante :
Linux installer le locale français
Si vous êtes sous wsl, il se peut que vous soyez toujours dans le système anglais, nous allons installer le locale français.
sudo locale-gen fr_FR.UTF-8
sudo update-locale LANG=fr_FR.UTF-8
sudo reboot
# ou redémarrer votre shell (dans le cas de wsl également)
# et refaite locale
locale
Après faites la commande date
$ date
sam. 08 mars 2025 16:17:23 CET
Pour avoir le jour
$ date +%A
samedi
# voilà vous avez tout pour recorriger le programme
Nouveau script avec le jour de semaine dynamique :
#!/bin/bash
JOUR=$(date +%A)
case "$JOUR" in
"lundi"|"mardi"|"mercredi"|"jeudi"|"vendredi")
echo "C'est un jour de travail."
;;
"samedi"|"dimanche")
echo "C'est le week-end !"
;;
*)
echo "Jour inconnu."
;;
esac
Les boucles en shellscript
Boucle for
Sans doute le plus facile
#syntaxe générale
for VARNAME in ITEM1 ITEM2
do
command 1
command 2
done
# exemple
#!/bin/bash
for COULEUR in rouge vert bleu
do
echo "COULEUR: $COULEUR"
done
# variante
#!/bin/bash
for COULEUR in rouge vert bleu
do
echo "COULEUR: $COULEUR"
done
Générer une séquence pour la boucle for
#générer avec seq (séquence)
#!/bin/bash
for i in $(seq 1 10)
do
echo $i
done
Exemple plus élaboré de script shell très utile
Supposons que nous voulions renommer des fichier images avec le nom du fichier avec la date du jour au formation numérique
Pour ce faire nous allons dans notre répertoire télécharger avec wget ou curl des images prise sur internet
wget -O image1.jpg http://source.com/imagealeatoire.jpg
l'argument -O permet de renommer le fichier sauvé
#!/bin/bash
# on liste les fichiers images avec la commande ls et on mets le résultat dans une variables
IMAGES=$(ls *jpg)
DATE=$(date +%F)
for IMAGE in $IMAGES
do
echo "renommage de ${IMAGE} en ${IMAGE}-${DATE}"
mv ${IMAGE} ${IMAGE}-${DATE}
done
Le script marche mais n’est pas optimale car la date se rajoute à l’extension et nom au nom de fichier. Essayez de résoudre ce problème. (indice utiliser la fonction $(basename « $path »)
# solution
#!/bin/bash
IMAGES=$(ls *jpg)
DATE=$(date +%F)
for IMAGE in $IMAGES
do
FILENAME="${IMAGE%.*}"
EXT="${IMAGE##*.}"
echo "renommage de $IMAGE en ${FILENAME}-${DATE}.${EXT}"
mv ${IMAGE} ${FILENAME}-${DATE}.${EXT}
done
Boucle while
Paramètres positionnels
Quand vous exécutez un script vous pouvez passer des paramètres
$monscript.sh param1 param2 param3
Dans votre script vous pouvez y faire référence avec $1, $2 etc $0 représente le script lui-même.
#exemple de script pour archiver une utilisateur
echo "Executing script : $0"
echo "Archiving user : $1"
#lock the account
passwd -l $1
# create the archive of the home directory
tar cf /archvies/$[1}.tar.gz /home/${1}
#accès à tous les paramètres positionnels
for USER in $@ # suppose que tous les arguments sont des users
...
Lire les entrées claviers
#!/bin/bash
read -p "Entrez un nom utilisateur: " USER
echo "Archivage de l'utilisateur: $USER"
...
Exercice : pratiquer le script d’archivage avec l’entrée au clavier, et au passage d’arguments multiples
Les fonctions
#!/bin/bash
greet_user(){
echo -n "Entre ton prénom "
read nom
echo "Bonjour $nom ! Comment vas tu $1?"
greet_user "$1"
#Exécuter le script
$ ./greet.sh gros
Dans le parcours sur symfony, je n’ai pas parlé de l’authentification via webservice. On va aborder cet aspect dans cet article.
Se connecter via un webservice est intéressant à savoir si on veut développer un front indépendant de type ReactJs ou AngularJS , ou même une application mobile, votre symfony servant de backend. D’abord il faut ajouter quelques ligne dans votre security.yaml:
SecurityController : ajoutez ce code dans le controller
/**
* @Route("/jsonlogin", name="jsonlogin", methods={"POST"})
*/
public function jsonlogin(Request $request): Response
{
$user = $this->getUser();
return $this->json([
'email' => $user->getEmail(),
'roles' => $user->getRoles(),
]);
}
Utiliser POSTMAN pour envoyer une requête de type POST et dont le content type est application/json vers la route jsonlogin
POSTMAN
Vous devez envoyer un Json, tel que dans l’image. (pas en tant que variable POST)
Le serveur va vous répondre avec un PHPSESSION_ID en retour. Pourquoi pas un Json Web Token? parce que basiquement c’est ce qui se passe. Mais le fonctionnement du PHPSESSION_ID est similaire, vous devez le renvoyer pour accéder à des partie du site web qui ncessitent un authentification.
Une fois la requêtes POST envoyée, si tout se passe bien, on reçoit comme prévu la réponse ci-dessus (voir le code controller plus haut). Et l’image ci-dessous nous montre le PHPSESSION_ID qu’on doit récupérer et sauver pour les reuq^tes subséquentes.
Pour sauver le Cookie (PHPSESSION_ID) cliquez dans POSTMAN le lien Cookie
Une modale va apparaître, vous devez entre le nom de domaine pour ce cookie
Une fois le domaine entré l ePHPSESSION_ID s’affiche
Vous êtes prêt pour faire une requête authentifiée !
Requête vers la page d’ajout de produit
Grâce à notre cookie sauvegardé, on aaccès à al page d’ajout de produit qui a besoin d’être authentifié
Requête GET vers la même page mais en ayant effacé les cookies
Regardez le code HTML, c’est celui de la page de login !
J’espère que ce petit tuto vous a plu et vous a permis de mieux comprendre le mécanisme d’authentification HTTP.
Note concernant la structure du json d’authentification
Dans le security yaml vous donnez un indice à Symfony sur la structure du json envoyé, par défaut la strucutre est:
#structure de base
{
"email": "admin@gmail.com",
"password": "123"
}
dans notre cas :
{
"security": {
"credentials": {
"email": "admin@gmail.com",
"password": "123"
}
}
}
# security.yaml
...
json_login:
check_path: /jsonlogin
username_path: security.credentials.email
password_path: security.credentials.password
...
Voici un liste de commande Linux pour débutant puis une seconde liste un peu plus intermédiaire
Liste de commande pour débutant en Linux
ls : liste les fichier et dossiers
cp : copier un fichier ou un dossier
mv : déplace ou renomme un fichier ou dossier
find : chercher un fichier ou des fichiers ou dossiers
pwd : savoir dans quel répertoire je me trouve actuellemnet
cat : affiche le contenu textuel d'un fichier
tail : affiche les n lignes de fin d'un fichier
head : afficher les n ligne de début d'un fichier
chown : change le propriétaire d'un fichier
chmod : change les droits d'accès d'un fichier
sudo : invoque le mode root (super utilisateur) pour avoir des privilèges élevés
su : change d'utilisateur
tar : archive des fichier, utile pour
gzip, gunzip : compresse un fichier, généralement on compresse une archive, tar dispose d'un mode d'archivage avec compression
rm : efface un fichier ou un groupe de fichier ou un dossier de façon récursive.
touch : crée un fichier texte
mkdir : crée u fichier ou un répertoire
rmdir : efface un répertoire
Liste de commandes plus intermédiaire pour Linux
grep : permet de chercher les fichiers contenant une chaine de caractères
zcat : comme la commande cat mais pour les fichiers compressés
truncate : coupe le contenu d'un fichier, en spécifiant la position de découpe 0 pour vider le fichier
wget : télécharge une resource (http par exemple)
curl : utilitaire très connu pour des opération de transmission réseau
sed : utilitaire puissant travaillant en colonne, permet de découper verticalement un fichier
awk : un peu comme sed
ps : liste les process en cours d'exécution
jobs : liste les programmes s'exécutant en arrière plan
fg, bg : met un process en avant plan, bg met en arrière plan, ce qui libère le shell pour une autre commande
& : invoque une commande et la mets en arrière plan
> : dirige un contenu texte vers un fichier
>> : ajoute à la fin d'un fichier texte une chaine de texte
xargs : permet de chainer les commandes,la sortie d'une première commande sera en entrée de la seconde commande
| (pipe) : perme de chainer les commande.
adduser :
chgrp : change le groupe d'appartenance d'un fichier
unlink : efface un fichier comme rm pour un fichier
chattr : rend immodifiable un fichier (même par root)
top : utilitaire montrant les ressources utilisées de l'ordinateur
mount : permet d'ajouter un disque ou ue clé USB par exemple.
nohup : utilitaire qui permet d'exécuter une commande au long cours même si on quitte le shell
&& : chaine plusieurs commandes en série
Encore d’autres commandes Linux:
scp : copie un fichier
rsync : synchronise deux répertoires
scp text.txt user@12.45.21.111:~/.ssh copie le fichier vers l'hôte distant et le met dans le répertoire /home/user/.ssh
ps aux :
crontab : fichier contenant les tâche )à exécuter périodiquement
usermod : modifie les caractéristique d'un utilisateur, comme le rendre sudoable
chsh : changer de shell
groups : afficher les gourpes d'un utilisateur
finger : sert à afficher les informations de utilisateur connecté (comme pinky)
Exercez vous :
voici une liste d’exercices à faire pour vous exercer
Dans le langage informatique web, cela veut dire savoir coder dans le langage du navigateur Javascript, et savoir coder dans le langage SQL et un langage back end comme Java ou PHP. Vous maitrisez le serveur et le client, soit toute la chaine de fonctionnement d’une application web.
Optimisez votre parcours dès le jour 1 pour un entretien d’embauche
Savoir mettre en relation ce que vous apprenez en centre de formation et la finalité en entreprise est une puissant source de motivation, c’est du concret !
Consacrez beaucoup de temps sur votre apprentissage
Le temps est le facteur numéro 1 pour le succès de votre formation. Il faut essayer de consacrer au minimum 35 heures par semaine, les plus motivé doubleront ce temps. Quoi de plus agréable d’apprendre quelque chose qui vous passionne?
Structurez votre apprentissage
Apprendre à apprendre, c’est surtout vrai en informatique. Il y a tellement de choses à voir, impossible de tout retenir. Il vous faudra faire preuve de méthodologie pour optimiser votre apprentissage.
Savoir sur quelle technologie se concentrer
Dans le développement web, il faut commencer par étudier le HTML/CSS, c’est le plus facile, puis le Javascript. Pour ce qui est du backend, un langage comme Javascript, PHP, ou Python est un très bon investissement. Dans certaines configuration géographique, Java ou C# sont de très bons choix.
Il y a une méthode d’apprentissage optimale
Quel dosage entre théorie et pratique? quelle proportion entre exercices et projet? quelle proportion entre apprendre par coeur et juste avoir vu et savoir retrouver l’information? comment faire sa veille technologique? savoir gérer sa forme est importante pour optimiser son apprentissage. Nous sommes tous différents mais il y a un canevas commun qui doit être affiné pour être au top. Nos stagiaires apprennent à optimiser ce côté méconnu de l’apprentissage spécifique à l’informatique et faisant partie de la spécificité de notre organisme de formation.
Savoir chercher sur Google et exploiter l’IA à petites doses.
Les meilleures informations se trouvent depuis le moteur de recherche, et de surcroit c’est en anglais que vous trouverez les meilleures informations. Comment formuler ses requêtes sur Google pour trouver au plus l’information? comment filtrer les sites? L’IA come ChatGPT ou Claude peuvent vous aider à apprendre u peu plus vite le code, mais il faut faire attention, que cela ne vous rende pas idiot !
Chez Formapedia, nous adressons tous ces points avec une pédagogie orientée objectifs.
Des KPI sont disponibles pour chaque étudiant. Un suivie rapproché individuel pour débloquer les blocages de chaque étudiant. Si vous êtes d’accords avec tous les points cité ci-dessus, vous êtes un bon candidat pour devenir développeur professionnel !
C’est en forgeant qu’on de vient forgeron, et dans notre cas c’est en codant que nous devenons codeur ! Chez Formapedia, on code beaucoup et pas que des projets scolaires, non chez nous nous avons des projets de niveau professionnels (EasyUpload un clone de Wetransfer) avec une exigence professionnelle, c’est pourquoi nos stagiaires sont plus prêts pour entrer en entreprise.
Le métier de développeur web est au cœur de la révolution numérique qui transforme notre société. La demande pour ce métier est en constante augmentation, poussée par l’essor des technologies et l’importance croissante d’Internet dans nos vies quotidiennes. Cet article explore le rôle, les compétences requises, les opportunités et les défis du développeur web.
Définition et Rôle du Développeur Web
Un développeur web est un professionnel chargé de concevoir, de programmer et de maintenir des sites internet et des applications web. Il travaille en étroite collaboration avec les designers, les gestionnaires de contenu et les autres membres d’une équipe pour créer des plateformes fonctionnelles, esthétiques et faciles à utiliser. Les développeurs web peuvent se spécialiser en front-end (partie visible et interactive du site), en back-end (partie serveur, gestion des bases de données) ou en full-stack (maîtrise des deux aspects).
Compétences Requises
Pour exceller dans ce métier, plusieurs compétences techniques et non techniques sont nécessaires. Parmi les compétences techniques, la maîtrise des langages de programmation comme HTML, CSS, JavaScript, Python, PHP, et SQL est essentielle. Les frameworks et bibliothèques comme React, Angular, Vue.js pour le front-end, et Node.js, Django, Laravel pour le back-end sont également importants.
La compréhension des principes de design responsive, de l’optimisation pour les moteurs de recherche (SEO) et des bonnes pratiques de sécurité web sont aussi cruciales. De plus, la capacité à utiliser des outils de versionnement comme Git est indispensable pour collaborer efficacement au sein d’une équipe.
En termes de compétences non techniques, un développeur web doit faire preuve de rigueur, de patience et de curiosité. La résolution de problèmes, l’esprit critique et la capacité à travailler en équipe sont des qualités très recherchées. La communication est également clé, car il faut souvent traduire des besoins non techniques en solutions techniques claires et réalisables.
Opportunités de Carrière
Les opportunités pour les développeurs web sont vastes et diversifiées. Ils peuvent travailler pour des agences de développement web, des startups, des grandes entreprises ou en freelance. Avec l’essor des plateformes en ligne, des e-commerces, et des applications mobiles, les développeurs web sont très demandés dans presque tous les secteurs : finance, santé, éducation, divertissement, etc.
En termes de progression de carrière, un développeur web peut évoluer vers des postes de chef de projet, d’architecte logiciel, ou de CTO (Chief Technical Officer). La spécialisation dans des domaines comme le développement de jeux vidéo, l’intelligence artificielle, ou la cybersécurité peut également ouvrir de nouvelles portes.
Défis et Évolutions du Métier
Le métier de développeur web est en perpétuelle évolution. Les technologies et les outils changent rapidement, ce qui impose une veille technologique constante et une formation continue. Les développeurs doivent s’adapter aux nouvelles tendances et aux changements dans les attentes des utilisateurs.
Un autre défi majeur est la gestion de la pression et des délais. Les développeurs doivent souvent respecter des délais serrés et répondre à des demandes imprévues, ce qui peut engendrer du stress. La gestion du temps et des priorités est donc cruciale.
Concevoir votre formulaire de demande, les questions à poser
En quoi consiste concrètement votre métier /description, Par exemple une semaine type ? Quelle sont vos tâches quotidiennes/hebdomadaires/mensuelles ?
Quelles sont les compétences/ les qualités/aptitudes requises pour exercer ce métier ?
Quels sont les aspects de votre métier qui vous plaisent ?
Y a-t-il des tâches qui vous ennuient ? Si oui lesquelles ?
Quelles sont les conditions d’exercice de votre métier : horaires/lieu/matériel/déplacements/cadre de travail/fourchette rémunération ?
Quel est le type de recrutement généralement utilisé ? Annonce intérim, relations….
Quelle est votre niveau de formation et votre parcours ?
Quelle(s) formation(s) est nécessaire(s) pour exercer ? Pour être employable sur le marché du travail vis-à-vis des employeurs?
Y a-t-il d’autres personnes, institutions, lieux, ressources, journaux spécialisés qu’il me faudrait consulter, à votre avis ?
Quels conseils me donneriez-vous si je voulais embrasser votre profession ?
Quelles sont les évolutions possibles de ce métier ?
Quels sont les avantages et les inconvénients ?
Avez-vous rencontré des difficultés et comment les avez-vous surmontées ?
Est-ce que vous pouvez me recommander d’autres professionnels de votre secteur ?
Si vous deviez recommencer, changeriez-vous de métier ?
Si vous deviez recommander une formation professionnelle dans votre secteur, laquelle recommanderiez-vous?
Quelle est la fourchette de rémunération que l‘on peut espérer
téléchargez le modèle de formulaire que vous allez envoyer à un professionnel du métier :
Je peux vous mettre en relation avec des professionnels de l’informatique pour répondre à votre questionnaire. Il suffit de remplir ce formulaire.
Que faire après l’enquête métier?
Une fois que vous avez les réponses votre enquête, il est temps de choisir un centre de formation. Le métier de développeur se construit dès le choix du centre de formation. Et là tous les centres ne se valent pas. Certains grands centre, font appels à des formateur dont ce n’est pas le métier d’enseigner, ce sont des professionnels du métier, ils peuvent vous informer grandement sur les différents métiers, les débouchés, les évolutions de carrière.
L’emploi en informatique évolue assez vite en salaire en fonction de votre niveau, expérience. Le titre professionnel DWWM forme au bac+2, le CDA forme au diplôme bac+3. Pour devenir ingénieur en informatique, vous devez faire une des formations master. Et très souvent de nos jours, le chemin royal est l’alternance. Votre formaton sera financée par l’entreprise chez qui vous allez déployer vos talents en informatique.
Profitez des journées d’information, passez en revue les formations des écoles. Il y a les écoles qui appartiennent à des grand groupes, et des écoles de plus petite taille, en général, pour les personnes en reconversion, c’est préférable. Le public de ces centre de formation est plus mature, et vous connaitrez une meilleure ambiance, plus en accord avec votre âge.
Renseignez pour savoir s’il y a un accompagnement à l’emploi, parce qu’il faut savoir chercher, trier les entreprises d’informatique. Pour réussir les entretiens il faut vous informer sur les métiers, afin de ne pas paraitre amateur.
Quelques pistes d’aides financières pour se former en développement web
Financer une formation de développeur web c’est un peu le parcours du combattant. Le cpf, le cep, ou l’Agefiph, tous ces acronymes donnent des migraines. Le budget gonfle au fur et à mesure que votre projet se construit : pas de panique. Une solution adaptée pour vous existe certainement. Un indice ? Cela dépend de votre statut. Êtes-vous étudiant, salarié ou sans emploi ? Le financement personnel reste toujours envisageable bien sûr. Vous pouvez bénéficier d’une prise en charge grâce à certains programmes détaillés dans cet article Les demandeurs d’emploi s’adresseront à Pôle Emploi. Pour les plus jeunes, l’alternance entre école et entreprise est possible. Si vous êtes salarié, les OPCO subventionnent la formation courte et continue. Sinon, les parcours de Transitions pro vous sont destinés si vous souhaitez intégrer un domaine différent. Voici un tableau des financements de formation en fonction de votre situation.
Faites vos comptes grâce au CEP et financez votre formation en développement web
Même si les accès au financement à la formation se simplifient. Cela peut encore sembler ardu de s’y retrouver, surtout si vous désirez vous reconvertir. Consultez un conseiller en évolution professionnelle (ou CEP) ! Il vous aidera dans vos choix et vous guidera.
Si vous êtes salariés du privé, vous pouvez en trouver un près de chez vous depuis votre ordinateur. Si vous êtes en recherche d’emploi, il faut vous adresser à votre agent Pôle Emploi. Le CEP s’occupe de vous informer des démarches à effectuer. Il vous renseigne aussi sur les financements possibles ainsi que les actions à engager. Les plus jeunes sortis du système scolaire ou sans emploi entre 16 et 25 ans passent par les missions locales.
Transitions Pro finance la reconversion ou l’évolution professionnelle des salariés du privé
Le projet de transition professionnelle ou PTP
Il permet de se former sur le temps de travail ou hors temps de travail, de bénéficier de rémunération et d’aides pécuniaires pour le cursus en lui-même ou les frais liés à ce dernier. L’employeur peut refuser une fois votre absence, mais pas deux. Les conditions de rétribution sont intéressantes, car proches de votre salaire.
Le projet de reconversion professionnelle (ou dispositif démissionnaire)
Ce parcours permet de démissionner de son poste et de bénéficier quand même des financements de formation accessibles aux demandeurs d’emploi. Les salariés en CDI ayant travaillé 5 ans sans interruption ou 1300 jours en continu peuvent y prétendre. Il faut avant toute chose contacter un CEP (ou conseiller en évolution professionnelle) pour construire le projet. L’étape est obligatoire.
Il ou elle vous guidera pour remplir le dossier que vous aurez retiré auprès de l’organisme Transitions Pro de votre région. Une commission l’examine. Elle décide de la viabilité du plan et donne un accord de principe. On vous délivre une attestation. Une fois celle-ci obtenue, vous pouvez démissionner et vous inscrire à Pôle Emploi pour ensuite intégrer la formation voulue avec une prise en charge.
Les programmes de Transitions Pro sont intéressants du point de vue de l’aide financière. En revanche, ils s’inscrivent sur le long terme entre la constitution du dossier et l’acceptation. Si vous souhaitez financer une formation de développeur web rapidement, le CPF reste la solution la plus facile d’accès.
Rapidité et autonomie : financer une formation de développeur web avec le CPF
Sinon pour les plus indépendants, ceux qui sont pressés ou qui ne remplissent pas les critères, des cursus courts ou longs en tant que développeur web existent et ne rebutent pas les employeurs, bien au contraire. S’instruire en autonomie montre une certaine agilité d’esprit et une persévérance nécessaire dans ce métier de programmeur.
Ces formations sont souvent très accessibles en ligne et peuvent se financer aussi grâce à votre CPF. Votre employeur abonde (ou cotise) à votre compte tous les ans. Depuis quelques années, vous connaissez le montant exact de votre cagnotte, et surtout vous pouvez en choisir une dans le catalogue en ligne.
Si vous avez déjà une idée en tête, pas de problème, il suffit de remplir le nom et le thème pour la trouver. Plus simplement, votre organisme peut vous donner le lien direct (comme Formapédia par exemple 😉). Les demandeurs d’emploi ont aussi accès à leur CPF. Sachez que Pôle Emploi peut compléter la somme manquante sous certaines conditions.
Les OPCO prennent en charge la formation continue de votre entreprise
Les Opérateurs de Compétences financent des programmes proposés par vos sociétés pour étendre vos expertises et ainsi préserver la compétitivité de l’entreprise. En effet, avoir des salariés toujours à la pointe des mutations nécessite de favoriser l’évolution de leurs connaissances et pratiques.
Dans le domaine du développement web, ou de la Tech en général, le besoin reste d’autant plus important, car les transformations des technologies s’accélèrent. La formation continue contribue à offrir des services innovants et de qualité aux clients. Elle fait partie des investissements essentiels dans votre entreprise.
Les OPCO aident ainsi les sociétés à élaborer et financer des solutions pour la qualification des travailleurs. Elles participent aussi aux frais générés comme les déplacements, repas, etc. Ces organismes réunis par branche sont gouvernés par des représentants des employeurs, des salariés et des membres indépendants. Elles contribuent également au système d’étude par alternance.
L’alternance pour les étudiants et les demandeurs d’emploi
Ce système peut intéresser, car il permet de recevoir un salaire (qui dépend de l’âge) et de bénéficier de la prise en charge de sa formation. Vous êtes salarié (avec les droits et les devoirs que ça implique) dans une entreprise tout en suivant un enseignement quelques jours par mois. Il n’est pas seulement réservé aux étudiants ou aux plus jeunes. On peut aussi y avoir droit en étant inscrit à Pôle Emploi.
Deux possibilités existent. La plus connue reste le contrat d’apprentissage. Ce dernier requiert :
d’opter pour un titre ou diplôme enregistré au RNCP (répertoire national des certifications professionnelles) ;
d’avoir entre 16 et 29 ans ;
une durée de formation jusqu’à trois ans.
Le contrat de professionnalisation est un dispositif plus accessible. Les conditions à remplir seront :
avoir entre 16 et 25 ans ;
ou 26 ans et plus si demandeur d’emploi ;
choisir une formation RNCP ;
ou CQP (classification reconnue dans une convention collective) ;
durée de formation financée jusqu’à deux ans.
Les écoles de développeur web qui proposent de l’enseignement en alternance peuvent aussi vous aider dans vos démarches. Elles savent vous renseigner. Les salons d’étudiants sont des mines d’or en termes d’information, car souvent elles y participent.
Votre région et Pôle Emploi sponsorisent votre projet de formation
Pour les demandeurs d’emploi, la région contribue aux formations certifiantes et professionnalisantes. Elle peut compléter les aides individuelles à la formation (ou AIF) de Pôle Emploi. Là aussi, certains critères sont requis.
Pôle emploi peut subventionner des devis individuels pour des projets viables (en complément de votre CPF), ou des formations en vue d’un recrutement (FPR). Elle organise également avec des partenaires des parcours entièrement gratuits dans les domaines en tension de la Tech. Parlez-en à votre conseiller. Il vous aidera à monter un plan pour financer une formation de développeur web.
Les métiers à forte demande peuvent faire l’objet de financement tout au long de leur cursus. Là aussi les conditions d’accès sont plus souples pour pallier le manque de professionnels. Par exemple, les étudiants en sanitaire et social peuvent également avoir droit à une prise en charge régionale en Occitanie.
L’agefiph subventionne la formation pour qu’elle soit accessible à tous
Cette agence aide les personnes en situation d’handicap à conserver leur emploi en milieu ordinaire, grâce à des améliorations de poste, etc. Elle peut aussi participer financièrement à votre projet. Dans le cadre de son mandat, elle intervient auprès des conseillers qu’ils relèvent de Pôle Emploi, des missions locales ou de Cap Emploi.
C’est à leur demande qu’elle peut agir et compléter le montant du CPF ou autres dispositifs cités au-dessus. Les employeurs de travailleurs handicapés peuvent s’adresser directement à l’agence qui les renseignera sur les démarches, les conditions et les contributions à leur budget formation.
Que l’on soit demandeur d’emploi, salarié, jeunes ou travailleur handicapé, chaque dispositif correspond à un parcours spécifique. Il est indispensable de s’informer en amont pour effectuer les bonnes démarches au bon moment. Votre conseiller emploi, ou votre CEP vous assisteront efficacement. Vous pouvez aussi vous adresser aux organismes de formation qui connaissent ces questionnements. Ils sauront vous aiguiller. Ne laissez pas le manque de financement devenir un frein dans votre trajectoire ! Il y a sûrement une aide adaptée à votre situation.
Dans cette vidéo vous allez apprendre moins de dix commandes Git, qui vont vous permettre de vous en sortir dans 80% des situations, c’est à dire qu’elles vont constituer votre routine de développeur.
Il est recommandé de commiter à la fin de la journée à minima, même si vous n’avez pas encore fini votre code, en effet si votre ordinateur venait à se faire voler, vous perdriez une journée de travail.
Ça y est, vous vous décidez à changer de métier ! Vos méninges carburent à fond. Que faire ? Où aller ? Quelle branche ? Que choisir ? Votre bilan de compétences avance. Les tests révèlent des appétences ou des aptitudes pour l’informatique. Le secteur recrute, vous aimez déjà découvrir les mystères de vos logiciels, comprendre le code, regarder dans le CMS. Ou bien vous cherchez une activité qui stimule vos neurones sans forcément y connaître grand-chose ? Apprendre de nouveaux langages ne vous effraie pas, mais vous passionne ? Avez-vous pensé à une reconversion comme développeur web ? Non, alors laissez-nous vous conter le métier.
Le développeur tisse la toile
Python, Java, PHP, ou C#, ces mots ou sigles vous semblent familiers ? Ce sont les langages les plus courants utilisés par les programmeurs sur le web. Ces concepteurs réalisent aussi des solutions ou des logiciels pour le net.
Le développeur code, c’est-à-dire qu’il ou elle parle les langues de la programmation. Grâce à elles, il bâtit le programme. Ce dernier donne les consignes au serveur pour articuler un ensemble de fonctions. Pour cela, le développeur suit un cahier des charges rédigé par l’équipe. Que fait-il ou que fait-elle concrètement ?
Back end : le code essentiel au fonctionnement d’une application web
Il gère la partie technique et fonctionnalité du site. Il pose ses lignes de code pour créer la base. Afin de bâtir la structure, il peut s’appuyer sur un framework : une espèce de canevas ou boîte à outils. Les qualités les plus recherchées et utiles en programmation Back End sont :
l’écoute : le développeur doit concevoir les applications prévues tout en prenant en compte les ressources mises à sa disposition ;
la rigueur : il doit être attentif aux détails pour offrir les bonnes capacités au site et à fortiori au client ;
la persévérance : les bugs, ou les obstacles ne peuvent pas être ignorés et parfois exigent de la patience.
Front-End : au devant de la scène
Le développeur front-end s’occupe de la partie visible par le client ou l’internaute. Il doit connaître les langages, mais aussi œuvrer avec les experts du SEO, de l’UX ou les rédacteurs web.
Ce codeur doit composer une interface qui prend en compte l’ergonomie et l’expérience utilisateur (UX), comme les critères des algorithmes de moteurs de recherche (Google, etc.). Ainsi, la curiosité est une qualité essentielle. Il doit également :
savoir travailler en équipe ;
bien communiquer ;
être créatif ;
avoir de l’empathie pour l’usager.
Full stack : les deux faces d’une même pièce
Enfin, il y a ceux qui ont envie de tout savoir faire : les développeurs Full Stack. Très convoités car polyvalents, ils peuvent travailler dans l’ombre ou sur l’interface utilisateur. Leurs capacités d’adaptation ajoutées à leurs connaissances sur l’ensemble d’un programme en font des profils recherchés.
Évoluer après une reconversion en développeur web
Vous pouvez passer de Back ou Front End à Full Stack, ou de Front à Back End. C’est un des avantages de cette reconversion en développeur web : l’évolution. Vous apprenez tous les jours du fait des progrès des technologies et des opportunités possibles.
Vous pouvez prendre du galon après plusieurs années d’expérience pour piloter un projet dans son ensemble. Le savoir technique que vous aurez acquis aura du poids auprès des clients. En effet, le cahier des charges devra répondre à leurs attentes tout en restant réalisable par vos équipes.
Si vous désirez vous lancer en autonomie, vous pouvez monter votre entreprise (freelance) ou alors en portage salarial (ex SS2I). Dans ce dernier cas, vous avez plus de latitude dans le choix des missions par rapport à un salarié classique.
Pourquoi devenir développeur web ?
Si vous aimez apprendre de nouvelles choses tous les jours, vous vous retrouverez dans ce métier. Le progrès des technologies est rapide, et donc actualiser ses compétences tout au long de sa carrière reste un prérequis. En général, les employeurs proposent et financent des formations courtes à leurs salariés.
Parfois il suffit de demander. Les OPCOS sont là pour ça. Dans la programmation, la curiosité aide à se former soi-même. Nombre de cursus sont accessibles sur des plateformes. Elles permettent de garder des connaissances fraîches, et même d’évoluer.
Le télétravail se généralise doucement et contribue à équilibrer vie professionnelle et privée, ne serait-ce qu’en gagnant du temps sur les trajets. Le salaire se négocie plus facilement par rapport à d’autres métiers. On commence en moyenne à 30 K/an.
Réussir son changement de vie professionnelle
D’abord, toute reconversion nécessite de la persévérance. Si votre projet correspond à ce que vous voulez ou vous êtes : ça mérite l’effort. Se former dans le développement web est passionnant, mais demande beaucoup d’investissement en temps et en travail. N’essayez pas de devenir un génie du code en une fois. Il vaut mieux procéder par étape. Si vous êtes au bon endroit, vous ne verrez pas les heures passées.
Microsoft MakeCode est une manière sympathique de vous familiariser avec les notions du développement, un vrai jeu d’enfant ! Justement il est utilisé pour les initier à la programmation web. Alors si vous venez d’un tout autre domaine, n’hésitez pas à aller regarder. Cela vous amuse, et vous désirez en savoir plus ? Passez à l’étage supérieur.
Comme vous êtes des adultes en reconversion professionnelle, vous pouvez vous « dégourdir » grâce à une formation courte avec les apprentissages de base (langage java ou python, PHP). Petit à petit, vous assimilez les fondements et remarquez si cela vous plaît.
Il existe des cursus longs après le bac qui ne sont pas forcément pris en charge sauf si vous êtes en alternance. Il faut remplir certaines conditions d’âge ou de statut pour rentrer dans ce type d’enseignement. Les écoles ou les centres d’orientation peuvent vous renseigner.
Si vous êtes demandeur d’emploi, les formations courtes et qualifiantes se financent plus facilement. Certains organismes proposent parfois des programmes en collaboration avec Pôle Emploi. Ils remettent à niveau les participants dans un premier temps, puis les entraînent intensivement pendant quelques mois, puis enfin ils sont intégrés dans une entreprise en alternance.
Si vous préférez être autonome, c’est un bon point pour votre future reconversion professionnelle comme développeur web. Cette qualité est appréciée par les employeurs, ou les clients si vous tentez l’aventure en indépendant. Sachez que vous pouvez vous instruire en ligne tout en étant aidé par un formateur qualifié. Formapédia propose plusieurs modules accessibles à tous et finançables avec un suivi adapté à vos besoins.
La demande est grande, en effet les entreprises recrutent de plus en plus de juniors qu’elles forment. Mais votre appétence pour le code doit se remarquer. Alors, s’engager dans un programme court avec des bases de langage et vous entraîner vous-même reste la meilleure option dans votre démarche.
Quand vous débutez, les projets personnels sont une force pour obtenir le poste que vous désirez. En tant qu’indépendants, ils seront votre fer de lance pour montrer à vos clients de quoi vous êtes capable. Présenter des travaux comme votre site web, votre application ou celui d’une connaissance (que vous aurez créé bien sûr) vous aidera à ouvrir les portes des sociétés. Le secteur est vaste et vous avez la possibilité d’intégrer des entreprises différentes, dans des domaines variables. N’hésitez pas, elles ont besoin de vos talents.
O2switch est un hébergeur français avec une formules très intéressante pour les étudiants en développement web. EN effet vous devez présenter (si vous faites un projet hors stage un site), et on attends de vous de savoir déployer en production, et non faire un github Pages ou un Heroku.
Je m’aperçois que beaucoup d’étudiant ne savent pas faire un simple FTP vers un serveur mutualisé ou VPS, par contre ils s’y connaissent en Docker! . Or je me rappelle que c’est un des premiers trucs que j’ai appris à faire. Je veux bien que vous travailliez avec des dockers, mais sachez au moins comment cela se passe sous le capot.
Je conseille aux étudiants de prendre un hébergement O2switch qui coûte 120 euros TTC environs, et qui permet d’avoir 5 VPS. Vous avez un hébergement par défaut, et 4 autres qu’ils appellent des lunes, qu’il faut créer. Je pars du principe que vous avez créé des lunes, et que vous avez accès via une liste déroulante, la fameuse liste déroulante que je vais customiser avec un script Javascript que je ferai exécuter avec Greasemonkey (ou Tampermonkey sous Chrome). Voilà à quoi ça ressemble de base :
Voila qui est bien plus pratique, car je ne retrouvais jamais mes sites, je devais me constituer des notes pour me repérer.
Je vous détaille donc comment j’y suis parvenu. Pour comprendre comment fonctionne Greasemonkey je vous envois vers ce tuto [xxx].
le but est ici de faire de la manipulation de DOM, on va remplacer les textes de la liste déroulante avec nos sites web. Le script Greasemonkey va s’exécuter une fois qu’on clique sur la liste déroulante, au passage l’interface web CPanel est codé en Angular. Mais cela n’influence pas notre script.
On a donc une liste déroulante en HTML qui est chargé de façon asynchrone, nous allons voir pourquoi tout à l’heure. Pour remplacer le texte des élément <li>, nous devons capturer l’élément HTML, parcourir ses éléments et remplacer avec innerHTML le contenu de ces <li>.
Greasemonkey permet d’injecter un script Javascript dans la page. Voici le code:
// ==UserScript==
// @name Customize O2Switch
// @version 1
// @grant none
// ==/UserScript==
let mapp = new Map()
mapp.set('exceret (huynh.odns.fr)',"site1.com")
mapp.set('sc1exceret (sc1exceret.universe.wf)',"site2.fr")
mapp.set('sc2exceret (sc2exceret.universe.wf)',"site3.com")
mapp.set('sc3exceret (sc3exceret.universe.wf)',"site4.com")
mapp.set('sc4exceret (sc4exceret.universe.wf)',"site5.com")
let handler = function(){
let e =document.querySelector('#ddlAccounts_chosen')
let f = e.querySelector('.chosen-results')
f.children[0].innerHTML = mapp.get(f.children[0].innerHTML)
f.children[1].innerHTML = mapp.get(f.children[1].innerHTML)
f.children[2].innerHTML = mapp.get(f.children[2].innerHTML)
f.children[3].innerHTML = mapp.get(f.children[3].innerHTML)
}
let body = document.querySelector('body')
body.addEventListener("click", handler, false);
On constitue notre objet Map qui est l’équivalent d’un tableau associatif PHP, chaque clé est associé une valeur le nom du domaine. Grâce à querySelector, je capture l’élément HTML, et à la fin du script j’ajoute un event listener qui s’exécute au clic, ce qui va bien car la liste déroulante se charge en asynchrone.
ce script n’est pas parfait car au chargement du Cpanel vous êtes dans la vue principale qui liste les 5 VPS, mais une fois que vous avez cliqué une des lunes, la liste se réduit aux 4 lunes décalant les index. Le script ci-dessus a été optimisé pour la page avec les 4 lunes. Il faudrait pouvoir détecter le contexte et proposer le bon affichage.
Voici un résumé des étapes que vous devez faire (avant de regarder la vidéo)
Si vous voulez accéder à votre CPF et que vous n’aviez pas encore fait avant la date du 25 Octobre 2022, il faut créer votre identité numérique La Poste et pour utiliser votre Compte Personnel de Formation (CPF) pour financer une formation, voici les étapes à suivre :
Il est important de noter que pour utiliser votre CPF, vous devez être âgé de 16 ans ou plus et être salarié ou demandeur d’emploi. Si vous êtes salarié, vous devez également avoir travaillé au moins 1 an dans l’entreprise où vous êtes employé.
Savez vous qu’il existe de nombreux site gouvernementaux qui vous rendent service, mais à condition que vous ayez un compte créé sur ledit site? Imaginez donc le nombre de compte et de mot de passes qu’il faudrait tenir à jour quelque part, d’autant plus que certains ne sont utilisé qu’une fois dans l’année…
Maintenant imaginez qu’un compte unique puisse vous permettre d’accéder à tous ces services avec un seul compte…c’est ce que le gouvernement vous propose avec FranceConnect. Un seul compte pour accéder à tous les services, ouf !
FranceConnectPlus c’est quoi?
Eh bien une identité renforcée ! Vous allez devoir montrer patte blanche, on va vous demander de vous photographier et prouver que vous savez parler.
FranceConnectPlus (ou Franceconnect+) est la variante de FranceConnect tournée vers les dispositif CPF ! Mis en place dès le 25 Octobre 2022, que le différence par rapport à FranceConnect?
Pourquoi c’est plus compliqué de s’inscrire après Octobre 2022?
Il faut savoir que cette identité est renforcée n’est obligatoire que si vous accédez pour la première fois au CPF après le 25 Octobre 2022, si vous aviez un compte avant cette date rien ne change.
Vidéo détaillée de la création du compte d’identité numérique (FranceConnect+) sur le site de la Poste
Instructions textuelles pour la création d’un compte FranceConnect+
Aller sur le site de la Poste
.
https://lidentitenumerique.laposte.fr/
.
Ai-je besoin de créer un email à la Poste? NON vous pouvez garder votre email habituel
Remplissez vos informations d’identité, vous avez le choix entre la carte d’identité (recommandée pour la facilité de prise en photo).
Ensuite vous devez prouver que vous êtes un humain via AR24.
Vérification identité en ligne grâce à AR24
La vérification de votre existence dans le monde réel n’est pas fait par la Poste mais par une autre société nommée AR24 (spécialisée dans les email recommandés qui remplacent les lettres recommandées)
Procédure KYC Photo de mobile+ titre identité
Le plus simple et franchement je vous suggère fortement est d’utiliser votre téléphone mobile équipé d’une caméra à selfie.
Le principe du KYC (Know Your Customer) est de lier votre identité numérique à votre véritable identité.
Vous allez recevoir un mail de AR24, vous allez aller sur leur site pour prendre votre photo et vidéo de vous dictant trois chiffres. Cette étape est sans doute la plus délicate. Utilisez votre smartphone !
Votre identité numérique est validée ! Connexion au CPF !
Si vous avez installé l’application de la Poste, il y a un bouton avec le lien pour aller directement sur le site du CPF, là vous allez cliquer sur le lien de connexion et vous allez suivre quelques étapes pour vous authentifier sur le site du CPF, je reconnais c’est beaucoup de choses pour se connecter sur une site.
Suites à la parution des nouvelles CGU, une vidéo récapitulative pour voir ce qui a changé par rapport à la dernière version du 17/11/2022 de CGU d’EDOF
Suite à la difusion des nouvelles conditions d’utilisation de EDOF, cette vidéo explique les changements par rapport à la précédente version des CGU d’EDOF
Deux choses transparaissent : L’ajout de France Connect+, et la responsabilité engagée de l’organisme de formation vis à vis des sous-traitants et des prestataires.
La classe appelante est couplée à la classe appelée, si on veut changer de manière de lire des données, il faut réécrire la classe appelante.
Des classes découplées
La classe appelante est découplée à la classe appelée, grâce à une interface, si on veut changer de manière de lire des données, il suffit lors de l’appel de la méthode de passer une autre classe appelée.
Ce qu’il faut retenir
Ici le plus important est que c’est l’interface qui est passée en paramètre de la méthode lors de sa définition MAIS pas de l’exécution de la méthode, à ce moment là on passe un objet(!) dont la classe implémente l’interface.
Vous exercez une activité en autoentrepreneur et vous désirez faire une seconde activité. SI cette dernière est d’importance ovus pouvez demander à l’URSSAF d’ajouter un second code NAF GRATUITEMENT.
Inutile de payer quoique ce soit pour cela, et en plus la procédure est assez simple.
Après m’être entretenu avec la hotline de l’URSSAF au 36 98, voici les instruction qu’il faut suivre.
Tout d’abord aller sur le site de l’URSSAF en mode déconnecté. Allez sur Gérer Entreprise
En fonction de votre activité, vous êtes en libéral (formateur par exemple), ou commerçant ou artisan.
Ensuite cliquez sur modifier mon auto-entreprise
C’est là que ça se joue, il faut cocher « Adjonction d’activité«
Vous remplissez les informations obligatoire, et vous soumettez le formulaire, un email de confirmation vous sera envoyé gardez votre numéro de dossier.
Combien de temps pour une adjonction d’activité?
Il se dite que c’est entre deux semaines et 4 semaines, mais n’attendez pas la dernière semaine pour appeler, pour ma part ça m’a pris environs dix jours.
Et je ne le savais pas j’ai attendu 4 semaines avant d’appeler, car ce que je faisais c’était d’aller sur le site de l’INSEE pour voir si le nouveau numéro NAF s’est ajouté à mon avis de situation, il n’y figurera pas!
Mon nouveau code NAF apparaitra-t-il sur mon avis de situation?
Ce qu’il faut savoir c’est que votre nouveau code NAF ou APE n’apparaitra pas sur votre relevé de situation, donc comment faire pour prouver que vous avez ajouté une nouvelle activité?
Demander une attestation à l’URSSAF
Malheureusement l’URSSAF ne vous préviendra pas que votre demande a été ajoutée, il faut donc appeler et leur demander de vous envoyer dans votre espace URSSAF le précieux document.
Le mot return permet de passer un valeur à l’appelant de la fonction
Le mot clé return est un des plus compliqués à expliquer en fait le mot clé rythme n’existe que dans une fonction et il sert à retourner la valeur au monde extérieur à l’appelant c’est-à-dire qui a appelé la fonction.
En effet une fonction est un ensemble de codes qui permet de faire des calculs et on obtient un résultat à la fin de ce calcul ce résultat eh bien il faut le stocker dans une variable et comme le col se déroule à l’intérieur de la fonction la seule façon de passer cette valeur ce résultat à une variable et d’utiliser le mot clé return en fait on peut imaginer que une fonction c’était comme un vase clos qui a eu une entrée et une sortie dans le return c’est la sortie on peut imaginer que c’est une boîte noire qui prend des paramètres en entrée et il va nous délivrer un résultat à la sortie.
Comment trouver son OPCO avec notre moteur de recherche
Plus bas dans cet article vous disposez d’un moteur de recherche d’OPCO, tapez un mots et quelques suggestions à vérifier par vous vous donneront le nom de votre OPCO. Mais avant il faut savoir si vous êtes un salarié ou micro entrepreneur. Le moteur de recherche est plutôt adaptée aux salariés, pour les entrepreneurs une autre méthode est proposée.
Pourquoi demander un financement à son OPCO?
Que vous soyez salarié ou à votre compte, vous pouvez demander un financement de votre OPCO pour une formation (voir tous les financements possibles). Attention l’organisme qui dispense la formation doit être certifié Qualiopi.
Chaque OPCO possède sont site web, et vous devez créer un compte sur leur site préalablement à toute demande de financement.
Par exemple si vous êtes formateur indépendant, vous vous adresserez sans doute à la FIFPL, allez sur leur site et créez votre compte. C’est gratuit.
Ensuite vous constituez votre demande de formation, il faudra demande à l’organisme de formation
un devis
un programme détaillé
Vous remplissez les informations et vous attendez une vingtaine de jours pour avoir la réponse.
Comment trouver votre OPCO?
Cette information on ne l’a pas forcément, et peut être dure à trouver si vous ne savez pas comment la chercher. Deux situations se présentent, soit vous êtes salarié, soit vous êtes travailleur indépendant.
Si vous êtes salarié, vous pouvez aller sur le site cfadock, mais il n’est pas très fonctionnel, et méfiez vous des sites qui vous demandent d’appeler un numéro spécial payant, cette information vous est fournie de façon gratuite.
Sur le site de cfadock, vous entrez votre SIRET et il est censé vous retourner votre OPCO, mais en pratique ça ne marche jamais, une popup vous demande alors de préciser votre numéro de département et votre convention collective (le IDCC si vous savez ce que ça veut dire) !
La manière la plus simple est de passer si vous êtes salarié par la fiche de paye, et si vous êtes travailleur indépendant de passer par le site de l’URSSAF
Si vous êtes travailleur indépendant
Connectez vous sur le site de l’URSSAF et allez dans Mes Documents
Sélectionnez le type d’attestation que vous voulez générer
Votre OPCO est indiqué !
Téléchargez le PDF et votre OPCO est indiqué dans le message.
Comment trouver son OPCO pour un salarié
Prenez votre fiche de salaire et regardez la convention collective de votre société
Moteur de recherche d’OPCO
A partir de cette information, utilisez le moteur de recherche et entrez le nom de la convention collective. Le numéro correspond au IDCC (numéro de convention collective), ensuite vous avez le nom de l’OPCO, puis le nom de la convention collective détaillée. Par exemple, sur la fiche de paye, la convention collective est « publicité », il faut donc taper ce mot dans la boite de recherche.
tout étudiant en informatique est souvent confronté à des difficultés pour comprendre la boucle fort parce que ça demande beaucoup d’efforts ça met en jeu beaucoup de concepts, je vais essayer à travers cette vidéo de vous les montrer, de la manière la plus simple possible . tout d’abord une boucle for permet de répéter un bout de code autant de fois qu’il le faut , si je veux faire une fois 2*1000 fois, ou 1000000 de fois, c’est une boucle for qu’il me faut . et c’est la raison d’être de nos machines, c’est de répéter une action alors vous me direz donc dans quel genre de situation on peut utiliser une boucle for ? en théorie de la boucle for permet de parcourir les collections de données mise en pratique qu’est-ce que c’est ? je vous le montre la syntaxe d’une boucle dans 2 langages très courants le javascript et le PHP .
Décomposition d’une boucle for
Dans les quels que soient les langages, je vais vous en à 3
paramètres après le mot clé fort il y a d’abord le premier paramètre qui est
initial c’est le début de la boucle le point de départ de la boucle le 2e
paramètre représente la limite supérieure de la boucle virgule et le 3e
paramètre Eh bien c’est le pas c’est à dire on la progression a de combien
j’avance et entre les accolades nous avons le bout de code à répéter
On appelle ça un bloc de code ici c’est une simple ligne qui
affiche la variable de lit mais on peut faire aussi complexe ce qu’on veut
La variable i va donc partir de la position 0 puis il va valoir 1,2,3,4 et 5 et va s’arrêter là, il ne va pas prendre la valeur 6 puisque la condition du milieu i < 6 le lui interdit
La boucle fort en l’utilise pas avec une variable i ,dans la réalité on utilise la boucle for lorsqu’on travaille avec des variables qui sont des collections, c’est quoi une collection ? une collection c’est une variable qui contient plusieurs valeurs en javascript ce sera un tableau et en PHP c’est un tableau également
Que serait un code sans notion de collection?
Si nous ne connaissons pas les collections ou les tableaux on va créer une variable pour contenir une valeur par exemple la variable $eleve va contenir Dupont, et si j’ai plusieurs élèves comment je fais? et bien on va devoir créer plusieurs variables $eleve1, $eleve2 etc, et c’est vraiment pas pratique ! La solution c’est d’utiliser donc un tableau, dans lequel on va déclarer une seule variable, de type tableau et dedans on met tous les prénoms séparés par une virgule.
Corollaire : la boucle FOR s’utilise presque toujours avec une variable de type collection
donc la boucle for s’utilise principalement avec une collection, en PHP ce sont des tableaux et idem en javascript, on va se servir de la boucle for pour parcourir le tableau. Un élément dans un tableau est repéré par sa position encore appelé index . Le premier élément a un index 0, le dernier élément a un index qui est égal à la taille du tableau (c’est à dire le nombre d’éléments du tableau moins 1).
Quelles sont les applications concrètes d’une d’une boucle for?
Par exemple lorsque vous êtes dans votre espace Amazon, et que vous voulez lister les commandes que vous avez déjà passées et si vous avez fait plusieurs commandes par le passé, ces commandes seront insérées dans des dans des tableaux,
Les onglets que vous avez ouverts sur votre navigateur par exemple ce sont des items contenus dans un tableau, donc si j’ai une dizaine d’onglets ouverts j’ai 10 éléments dans un tableau d’onglets.
Un menu de page web par exemple, aussi c’est ce sont des différents éléments d’un tableau.
Illustration graphique des index dans un tableau
Je vais essayer d’illustrer le l’histoire des index avec parking de supermarché voilà nous avons en parking avec des voitures des places des parkings numérotées et souvent il la place de parking numérotée 0 ça n’existe pas ! donc ça commence à 1,mais en informatique on commence pas 1, on commence à 0 donc sur l’exemple qu’on voit ici la voiture numéro un à la place de parking numéro un en fait en informatique ce sera l’index 0
En informatique on ne code pas en dur les valeurs, on aime bien que le code soit générique, qu’il qu’il puisse marcher dans toutes les situations. Dans l’exemple du tableau de prénoms, bien que nous ayons 3 éléments on ne va pas mettre le nombre 3 pour la longueur du tableau, mais on va mettre une une expression qui va représenter la longueur du tableau de façon symbolique, ceci va nous permettre de de faire marcher le script quel que soit le nombre d’éléments qu’on a dans notre tableau
Voilà pourquoi on utilise les variables c’est pour que notre code ait des emplacements dans lesquels les valeurs peuvent être diverses une fois qu’on a écrit le code on n’y touche plus le code doit marcher quelque soit les situations donc c’est important de ne pas coder en dur les variables
La variable i parcoure les index
L’astuce de la boucle FOR est donc de faire promener la variable i dans l’intervalle de valeur des index, ceci nous permet de parcourir tous les éléments d’un tableau.
La solution relativement simple consiste à créer un input de type hidden donc invisible qui contient la valeur à envoyer dans tous les cas. Elle sera écrasée par la valeur de la checkbox quand cette dernière est cochée.
Les formation se trouvant sur le CPF en distanciel se déroulent de la manière suivante :
L’apprenant a accès à la plateforme e-learning avec les cours en vidéo avec transcription en texte
Les QCM et les exercices pour s’exercer
lors des visioconférences, on passe en revue les exercice que vous avez fait, je les commenterai, et vous pourrez me poser des questions sur ce que vous n’avez pas compris.
Rendez vous pour les visio-conférences :on détermine une heure dans la semaine pour se voir en fonction de nos agenda respectifs. On détermine une semaine à l’avance l’heure et la date.
Pour toute annulation merci de prévenir 24 heure à l’avance. Les annulations tardives seront comptées comme effectuées, ainsi que les annulations à répétition.
Toute formation se déroulant sur plus de deux fois la durée prévue pourra être terminée à l’initiative de l’organisme de formation.
Pour la visioconférence, de préférence le logiciel Zoom, et sur votre ordinateur personnel si possible (pas celui du travail qui limite les connexion réseau potentiellemnet)
Les visioconférence ne pourront commencer que si les CGV seront signées.
Selon votre situation, les source de financement peuvent être différentes, cela dépend de votre situation professionnelle, de votre tranche d’âge et de l’endroit poù vous vous situez.
Bien sûr il est d’évidence que c’est Pôle Emploi qui vous finance, mais il existe plusieurs dispositifs de financement au sein de Pôle Emploi
Je suis salarié
Si vous êtes salarié, vous pouvez demander un financement de l’organisme paritaire de votre branche, ce sont les OPCO (anciennement OPCA)
Suivant le code APE de votre employeur, vous avez un OPCO désigné. Il existe un site qui vous indique l’OPCO en fonction de votre code APE
Je suis indépendant
Je peux faire appel au Fond d’Assurance Formation. C’est vrai que les indépendants ne sont pa le smieux lotis dans cette histoire.
Dans tous les cas le CPF
Le CPF Compte Personnel de Formation est un dispositif très large, toute personne y a droit (à condition d’avoir travaillé). Si vous travaillez une année pleine, vous avez 500 euros de crédité sur votre compte personnel de formation (comment créer son compte personnel de formation?). Via l’application MonCompteFormation, vous avez accès à un large catalogue de formation (le prix des formation vont de 100 à plusieurs milliers d’euros). Si votre crédit est inssufisant, vous avez le pouvoir de compléter avec un financement personnel.
Quelle langage informatique viser, quelle technologie viser? quelles entreprises viser ? beaucoup de débutants se posent ces questions car faire ce choix n’est pas simple, par exemple de temps en temps je vois des gens qui recommandent d’apprendre le langage Java, est-ce vraiment pertinent? si votre but est de travailler dans une agence Web, je vous recommande d’apprendre le PHP et le JavaScript, parce que le Java, c’est dans des très gros logiciels typiquement en informatique de banque. Pourquoi cette distinction est importante?
Si vous travaillez dans une agence Web, vous allez travailler sur des projets de petite envergure entre trois mois et six mois, parfois plus neuf mois ou un an. Alors que si vous travaillez dans le langage Java, vous allez travailler sur des gros systèmes. Non seulement vous allez travailler dans un contexte énorme, mais en plus vous allez travailler sur les très longues durées, des années voire sans fin, ce n’est pas forcément du goût de tout le monde.
Je vous rappelle que ce billet est dans le contexte du développement web (on ne parle pas de jeux vidéos, développement de logiciel desktop…)
Dans le monde du web il y a les langages back end (côté serveur) et front end (côté client ou navigateur). Dans le front end Javascript règne en maitre, il est complétté par le HTML et le CSS pour la mise en forme des pages. Côté serveur, c’est plus disputé, il y a énormément de langages plus ou moins populaire. PHP est très populaire, il y a aussi Python, Ruby, Java, C# et de nouveau Javascript.
Quand un novice demande quel langage il faut étudier, et je sais que pour ce novice le conseil est très important, car il va passer beaucoup de temps avec ce langage, j’entend des réponses plus ou moins réalistes.
La raison voudrait qu’on réponde PHP ou Javascript pour le back end, (car pour le front end y a pas photo pas de débat c’est javascript), mais j’entends aussi Python ou Java. Et désolé, mais c’est vraiment pas très réaliste, les gens qui répondent ça, travaillent-ils dans ces technologies? travaillent-ils ou ont-ils travaillé dans d’autres technologies?
En effet, vu le contexte de la demande, je trouve que ce n’est pas bon conseil de conseiller le Java pour faire du web. Qui dit Java dit Java EE, Hibernate, mais surtout une courbe d’apprentissage très très longue. Et surtout vous n’allez pas faire un site vitrine, ou un petit e-commerce avec Java. Java c’est fait pour des très gros logiciels en environnement bancaire notamment. c’est un langage considéré sûr pour des choses « sérieuses », le PHP c’est pour faire mumuse. Plus sérieusement, à chaque problématique répond un langage. Si vous voulez faire un site de petite ou moyenne taille PHP ya pas photo. Pour des gros sites aussi c’est PHP. Par contre c’est ridicule d’utiliser Java EE et Hibernate pour faire un Prestashop, que tout le monde va s’approprier. La technicité est toute autre avec Java, alors non ne dites plus de bêtises, surtout si vous ne travaillez pas avec Java.
Quant au Python, malgré tout le buzz que la presse veut bien relayer, dans le monde du web, il cède la place à PHP. N’apprenez pas Python si vous voulez faire du web, vous allez rester au chômage longtemps. Python, c’est utilisé dnas l’IA, machine learning, etc, si vous voulez travailler dans ces domaine alors oui allez-y pour le Python et pas PHP.
Quant à Ruby il est trop confidentiel en France. On est en 2020, pariez sur PHP, merci.
Un truc simple à faire : Allez sur Indeed ou tout autre plateforme de job, et cherchez les offres dans ces différents languages par ville et comparez.
Quelle technologie viser?
Outre le fait de développer un logiciel en un langage pur sans faire appel à un framework, ceci prend du temps et n’est pas tout le temps justifié, il existe des frameworks qui vous facilitent le développement d’applications.
Si vous avez lu le premier paragraphe, vos choix se sont rétrécis, du moins pour le langage back-end. Maintenant, ne parlons que du PHP, il existe actuellement deux frameworks qui se détachent : Symfony et Laravel, et sont orientés objet de la façon la plus classique. Les deux sont très demandés , un petit plus pour Symfony en France, mais à l’échelle mondiale, c’est Laravel.
Mon opinion personnelle est que Symfony est un peu plus délicat à prendre en main pour un débutant que Laravel, mais quand on commence à le connaître, mais aussi quand on commence à comprendre les principes de la programmation orientée objet, (injection de dépendance, quelques pattern ORM, les closures) on arrive à se débrouiller pas mal avec, sans pour autant être un expert.
Je trouve que Laravel est plus terre à terre d’entrée de jeu, en particulier l’ORM Eloquent qui est beaucoup plus facile à appréhender que Doctrine.
Quelle entreprise viser?
Vous avez différents types d’entreprises qui recrutent des développeurs informatiques: agences web, SSII, département SI(système d’information) de grandes structures, éditeurs de logiciels, ceci c’est pour le salariat, à quoi il faut ajouter le status de freelance.
L’erreur que je rencontre le plus souvent chez les étudiant qui viennent d’obtenir leur certification (je parle de ceux qui sont en reconversion et non des étudiant en informatique), c’est qu’ils veulent se mettre en freelance pour engranger le plus rapidement de l’argent.
Parce qu’ils ont réussi un parcours, ne veut pas dire qu’ils sont prêts à l’emploi ! il y a une différence entre le niveau d’un étudiant diplômé et quelqu’un d’opérationnel. Là où on rencontre le plus souvent ce cas de figure, ce sont les étudiants en WordPress, qui se mettent en freelance pour proposer un site à 500 ou 1500 euros, ça peut sembler intéressant pour eux (au passage ils tirent les prix du marché vers le bas), mais savent-ils qu’il vont passer deux voire 3 semaines ou un mois pour le faire? Et si je vous disait que pour un site à 1500 euros, en agence, un développeur wordpress peut le torcher en un ou deux jours? vous la voyez la différence?
Le paradoxe de la pénurie de développeurs
Dans le média on nous rabâche sans cesse que l’on est en grande pénurie de développeurs, mais pourtant ce qu’on entend aussi c’est que les étudiants ou les développeur juniors ont du mal à trouver un poste (dans certains cas). D’où vient ce paradoxe? il semble que la réponse soit que le marché manque de développeurs certes, mais de développeurs expérimentés !
Aussi en réussissant un parcours certifiant ou diplômant pour les gens en reconversion, vous n’êtes qu’à mi-parcours, il reste encore du chemin à faire. Ce n’est pas de votre faute si à l’issue de votre parcours vous avez du mal à trouver un job, malheureusement les entreprises sont dans une logique économique, où il faut rentrer de l’argent, et ils préfèrent parier sur des profils plus expérimentés, ne pas prendre le risque. Mettez vous à l place d’u patron de bopite et vous comprendrez.
Ce qu’il manque au jeune développeur
Ce qu’il manque c’est des entreprises qui acceptent de jouer le jeu de montée en compétence du junior à terme, qu’ils capitalisent sur le junior, le forme afin qu’il devienne performant. Et du côté du junior, il doit jouer le jeu en acceptant un salaire qui ne soit pas mirobolant lors de la première année. Vous êtes payé pour monter en compétence que demander de plus?
Ce type d’entreprise existent rassurez-vous, il faut les trouver. En fait ce n’est pas une entreprise en particuliers, cela dépend de si vous avez un mentor qui veut bien vous faire monter en compétence, si le service informatique où vous êtes pratique cette montée en compétence.
Chez Formapedia nous prenons en compte ce paradoxe et nous accompagnons les juniors dans leurs premiers pas en entreprise.
Et se faire financer intégralement la formation? c’est possible
Pole emploi intervient sous deux angles pour aider les demandeurs d’emploi à retrouver un emploi.
La première catégorie concerne les demandeurs d’emploi qui ont trouvé un employeur prêt à les embaucher à condition qu’ils suivent une formation.
La seconde catégorie concerne les demandeurs d’emploi qui veulent suivre une formation pour se préparer à un métier, mais qui n’ont pas commencé à chercher un emploi, où qui n’ont pas encore trouvé d’emploi.
La première catégorie sera concernée par le POEI (Préparation opérationnelle à l’Emploi Individuel). Dans quel cas peut on donc tomber dans ce cas de figure?
L’exemple typique est que le demandeur d’emploi tombe sur une offre d’emploi qui l’intéresse mais s’aperçoit qu’il lui manque quelques compétences pour correpondre aux exigences du poste.
Financez votre formation développeur web avec un POEI
Formapedia est Datadocké et sera bientôt Qualiopi, ce qui veut dire que vous pouvez venir vous former au métier de développeur web et bénéficier d’un financement si vous êtes demandeur d’emploi.
De votre côté quelles sont les conditions pour bénéficier d’un POEI ?
vous êtes demandeur d’emploi indemnisé ou non
vous avez une proposition d’emploi (CDI ou CDD minimum de 12 mois, ou contrat de professionnalisation ou contrat d’apprentissage d’au moins 12 mois), ce poste nécessitant un apprentissage de compétence manquante.
Financez votre formation développeur web avec un AIF
Là, la différence avec le POEI, c’est que c’est vous qui initiez un projet de retour à l’emploi, qui doit être cohérent, aujourd’hui le métier de développeur est demandé, donc les temps sont favorables.
Faites valider votre projet de formation par votre conseiller Pole Emploi, il validera votre projet en regardant le contenu et le coût de la formation. Et sur sont efficacité de retour à l’emploi.
Pole emploi va vous remettre un formulaire AIF à remplir par l’organisme de formation au moins 15 jours avant l’entrée en formation.
L’AIF couvre l’intégralité des frais de formation RESTANT à votre charge, donc en complément des autres financements. Si vous touchez les indemnités de chômage ( par exemple l’ARE, vous continuerez à les toucher durant la formation)
Pour offrir les meilleures expériences, nous utilisons des technologies telles que les cookies pour stocker et/ou accéder aux informations des appareils. Le fait de consentir à ces technologies nous permettra de traiter des données telles que le comportement de navigation ou les ID uniques sur ce site. Le fait de ne pas consentir ou de retirer son consentement peut avoir un effet négatif sur certaines caractéristiques et fonctions.
Fonctionnel
Toujours activé
L’accès ou le stockage technique est strictement nécessaire dans la finalité d’intérêt légitime de permettre l’utilisation d’un service spécifique explicitement demandé par l’abonné ou l’utilisateur, ou dans le seul but d’effectuer la transmission d’une communication sur un réseau de communications électroniques.
Préférences
L’accès ou le stockage technique est nécessaire dans la finalité d’intérêt légitime de stocker des préférences qui ne sont pas demandées par l’abonné ou l’internaute.
Statistiques
Le stockage ou l’accès technique qui est utilisé exclusivement à des fins statistiques.Le stockage ou l’accès technique qui est utilisé exclusivement dans des finalités statistiques anonymes. En l’absence d’une assignation à comparaître, d’une conformité volontaire de la part de votre fournisseur d’accès à internet ou d’enregistrements supplémentaires provenant d’une tierce partie, les informations stockées ou extraites à cette seule fin ne peuvent généralement pas être utilisées pour vous identifier.
Marketing
L’accès ou le stockage technique est nécessaire pour créer des profils d’internautes afin d’envoyer des publicités, ou pour suivre l’utilisateur sur un site web ou sur plusieurs sites web ayant des finalités marketing similaires.
