Mon parcours en réalisations.

Applications métier, plateformes web, outils internes et systèmes documentaires : des formes différentes qui demandent toutes de penser les utilisateurs, les données et les règles de fonctionnement.

Définir le périmètre, découper le système, développer les composants et les relier. Puis vérifier les parcours, préparer la publication et rendre le résultat compréhensible pour ceux qui vont l’utiliser.

Prévoir les erreurs, les corrections et l’évolution. Un prototype sert à apprendre ; un système livré doit pouvoir être exploité et maintenu. Ces étapes ne se confondent pas.

Architecture modulaire, responsabilités délimitées, API et contrats documentés : chaque composant doit savoir ce qu’il reçoit, ce qu’il garantit et ce qui appartient à un autre module.

Tests, documentation et observabilité adaptée au contexte rendent le comportement lisible. Les données et les erreurs font partie de l’architecture, autant que le chemin nominal.

Évaluer les dépendances, isoler les changements et préparer des migrations progressives. L’évolutivité tient aussi à la capacité de conserver une solution simple tant que le besoin le permet.

Travailler sur des modèles mathématiques, des systèmes déterministes et la résolution d’interactions. Relier les règles formelles aux comportements observés, puis examiner leurs limites et leur reproductibilité.

Construire des prototypes et des preuves de concept pour explorer de nouvelles méthodes. Comparer des architectures, expérimenter les performances et comprendre pourquoi un comportement apparaît, avant d’en faire une solution.

Explorer l’IA locale et des systèmes autonomes, avec leurs contraintes de ressources, de contrôle et de comportement. Ce sont des sujets de recherche parmi d’autres, distincts de l’intégration de l’IA dans un produit.

Encore jeune, j’ai mené un projet personnel de reconnaissance d’images en Python. Le dépôt est aujourd’hui perdu : ce repère historique décrit une exploration, pas une preuve de résultat ni la limite de mes recherches actuelles.

Vérifier les parcours, les erreurs et les intégrations ; distinguer données et environnements de test et de production. Contrôler la configuration et les conditions nécessaires à l’usage réel.

Organiser le déploiement, les sauvegardes et les migrations lorsqu’elles sont nécessaires. Prévoir les contrôles après publication et un retour arrière adapté au changement.

Documenter l’exploitation, faciliter les corrections et suivre le fonctionnement. La maintenance et la transmission prolongent la réalisation au-delà de sa première mise en ligne.

Concevoir les modèles qui gouvernent les comportements, organiser la résolution des interactions et travailler leur reproductibilité. Une simulation déterministe permet de relier une situation à ses règles et de comparer les résultats.

Développer des systèmes de gameplay, des machines à états et des réponses aux actions de l’utilisateur. Unity et C# font partie de mes environnements selon les projets ; C# est un langage de forte maîtrise que j’apprécie particulièrement.

Articuler mises à jour, événements et contraintes de temps réel ou quasi temps réel. Examiner les performances et les interactions entre systèmes pour comprendre le comportement d’ensemble.

Explorer la codebase, les dépendances, les données et les parcours. Reconstituer le fonctionnement réel et distinguer dette technique, défauts de conception et problèmes localisés.

Hiérarchiser les corrections en fonction du risque et de l’usage. Consolider les tests, corriger les faiblesses et optimiser les points qui ont une incidence réelle.

Préparer une migration progressive, isoler les changements et vérifier la continuité. Conserver ce qui est fiable évite de recréer inutilement les risques que l’existant a déjà résolus.

Scripts, pipelines et workflows relient les outils et les flux de données. Prévoir les contrôles, les erreurs et les reprises fait partie du traitement, tout comme l’action nominale.

Concevoir des outils internes, des tableaux de bord et des automatisations documentaires. Adapter les interfaces aux opérations réelles plutôt que multiplier les manipulations entre applications.

Privilégier une approche local-first lorsque l’usage local et la maîtrise des données le justifient. Intégrer des agents si leur souplesse est utile, en conservant des règles explicites et les validations humaines nécessaires.

Interfaces, applications métier, API, services et intégrations : le web relie architecture serveur, données, sécurité et déploiement. J’ai une longue pratique de PHP et de JavaScript, avec l’expérimentation de nombreux frameworks de ces écosystèmes, sans attachement systématique à un seul.

Python, JavaScript / TypeScript et C# sont des langages de forte maîtrise. J’apprécie particulièrement C#. Ces repères décrivent mon parcours, sans note individuelle ni prétention à tout maîtriser.

Go fait partie de mes langages favoris et intervient dans plusieurs travaux actuels. Rust est également un favori, avec deux projets à ce jour. J’ai pratiqué C et C++, avec une préférence nette pour C++. Leur place dépend du système à construire.

Audiovisuel, aéronautique, fintech et immobilier sont des contextes de mon parcours. Ce sont des secteurs d’application, à distinguer des compétences de conception et des technologies employées. Aucun compteur artificiel ne les additionne.