LAVAUD Enzo

Rapport de fin de stage

CNP Assurances Angers
Développement d’une application Web
Du 12 mai au 8 juillet 2022

Stage supervisé par M. MONDIN (CNP Assurances) et M. HUBERT (ESAIP)

1
Table des matières
Notations et abréviations: ........................................................................................................................ 3
Introduction : ........................................................................................................................................... 5
Présentation de l’entreprise : ................................................................................................................... 6
Présentation des tâches : .......................................................................................................................... 6
Contexte : ............................................................................................................................................ 7
Tâches à réaliser : ................................................................................................................................ 7
Contraintes : ........................................................................................................................................ 7
Facteurs clé de succès : ....................................................................................................................... 7
Réalisations : ........................................................................................................................................... 8
Installation de poste :........................................................................................................................... 8
Organisation : ...................................................................................................................................... 8
Méthode de travail :........................................................................................................................... 11
Réalisations Techniques : ...................................................................................................................... 13
Première mission : calcul et affichage de l’âge ................................................................................. 13
Seconde mission : calcul et affichage de la clé DRT ........................................................................ 16
Intérêt du résultat pour l’entreprise : ................................................................................................. 19
Retour par rapport au travail effectué :.............................................................................................. 19
Expérience humaine : ............................................................................................................................ 20
Ce que j’ai appris :............................................................................................................................. 20
Mon ressenti : .................................................................................................................................... 20
Conclusion :........................................................................................................................................... 20

2
Notations et abréviations :

[1] CNP : Caisse Nationale de Prévoyance

[2] Java : Langage de programmation

[3] Javascript : Langage de programmation

[4] Perl : Langage de programmation

[5] JSP : Type de fichier similaire aux fichiers HTML mais pouvant exécuter du Java

[6] DRT : Demande de rachat de bon de capitalisation (produit d 'épargne)

[7] Bitlocker : Logiciel qui crypte les données

[8] Gitlab : Application qui permet de travailler en équipe sur des projets informatiques

[9] IDE : integrated development environment, ce qui signifie environnement de développement

intégré, l’application sur laquelle on code

[10] Eclipse : IDE

[11] Formateur : Outil permettant de gérer l’indentation

[12] Méthode agile : Méthode de travail

[13] Sprint : Période de durée de travail

[14] Pesée : Estimation de la durée de réalisation de la tâche

[15] Debug : Mode d’exécution du code qui permet de s’arrêter sur des lignes choisies

[16] Merge request : Demande de fusion du code à un autre

[17] Merge : Fusion du code à un autre

[18] Fonction : Représente un ensemble de codes qui une fois exécuté effectue, comme son nom
l’indique, une fonction précise.

[19] Classe : Ensemble de fonctions

[20] Bouchon : Pratique qui permet de forcer l’utilisation de certaines données, souvent utilisé pour
effectuer des tests

[21] Div : Balise HTML qui sert de bloc

[21] Bibliothèque : Classe que l’on peut importer

[22] Méthode : Fonction membre d’une classe

[23] Objet : « Objet », que l’on peut paramétrer en code

[24] Span : Balise HTML accueillant le plus souvent du texte

[25] CSS : Langage de programmation

3
[26] Modulo : Opération dont le résultat est le reste d’une division euclidienne

[27] Boucle : Répétition d’une même action qui peut être paramétrée avec des conditions

[28] Surcharge : Permet d’attribuer le même nom à deux fonctions ou méthodes

[29] Programmation orienté objet : Méthode de programmation

4
Introduction :
Mon stage de fin de première année de Bachelor Numérique
a été un des temps fort de l’année, en effet c’était pour moi la première occasion de découvrir
le domaine d’activité dans lequel je souhaitais m’orienter depuis le collège. Celui-ci a eu lieu
du 12 mai au 8 juillet 2022.
Après avoir eu une attirance dans les sociétés évoluant dans le domaine de mes passions, j’ai
orienté mes recherches vers de grandes structures angevines, en effet ce choix me permettait de
ne pas subir d’éventuelles restrictions dans le cadre de la crise COVID mais aussi de pouvoir
poursuivre l’exercice de mon emploi étudiant débuté à la rentrée 2021/2022.
Je souhaitais également dans le cadre de ce premier stage évoluer dans un service informatique
conséquent me permettant de découvrir de nombreuses fonctions, mais surtout de pouvoir me
voir confier des missions qui me seraient propres dans le développement web ; dont les résultats
seraient vérifiables avant la fin de mon stage. Je voulais ainsi me confronter à l’utilité ou non
de mes connaissances et savoir-faire dans une entreprise.
J’ai donc réalisé mon stage au sein du service informatique de la société CNP[1] Assurances, je
connaissais déjà cette entreprise pour y avoir réalisé mon stage de classe de 3ème ; au cours
duquel j’avais navigué dans différents services. L’accueil qui m’y avait été réservé au service
informatique avait été révélateur et confirmait mon souhait de poursuivre dans l’informatique
et le numérique.

My internship of first year’s ending of Numeric Bachelor was a key moment from this year, in
fact, that was the first occasion to discover my domain of activity in which I oriented my course
choice since high school.
After researched an internship in enterprise who works in my hobby’s domain, I redirected my
research to big enterprises located in Angers indeed, that choice of research permitted myself
to take care of possible COVID restriction but also to continue my student job.
I also wished for my first internship to progress in a consequent computer science department
to be able to discover many new aspects of that kind of job. I also wanted to be able to realize
task that the enterprise gave me, in the web development domain of which I can see the results.
I wanted to confront my knowledges and skills in an enterprise.
I realized this internship in the society CNP[1] Assurances, I already knew this enterprise because
I already did my Year 9 internship here. During this past internship, I had the opportunity to
navigate and discover all kind of services and that was the discovering of the computer science
department that marked myself and gave me the desire to work in this domain.

5
Présentation de l’entreprise :
Le groupe CNP[1] Assurances est un acteur de référence de
l’assurance de personnes en France, en Europe et au Brésil. Assurances vie, retraite emprunteur,
prévoyance, santé services … CNP[1] Assurances répond aux multiples changements qui
affectent la vie de ses clients.
L’entreprise CNP[1] Assurances voit le jour en 1959 et est la fusion de 2 branches de la Caisse
des Dépôts et Consignation reprenant les activités d’assurances en cas de décès ou d’accident,
c’est en 1992 que l’historique CNP[1] devient société anonyme privée et change de nom.
Elle est actuellement le leader en assurances emprunteur et la deuxième assurances vie en
France. C’est le septième assureur européen et se développe actuellement au Brésil où elle
occupe la troisième place.
Les produits de CNP[1] Assurances sont distribués par deux partenaires : La Banque Postale et
le Groupe BPCE (Banque Populaire et Caisse d’Épargne). 78 % des actions de CNP[1]
Assurances sont détenues par la Banque Postale qui devient ainsi l’actionnaire principal.
CNP[1] Assurances emploie 5 156 employés dont un peu plus de 2200 à l’international, en
France il y a trois sites situés à Angers, Arcueil et Paris.
J’ai réalisé mon stage au sein de l’équipe de développement du service informatique de CNP[1]
Assurances, ce service a une fonction primordiale au sein de l’entreprise ; son efficacité et sa
proactivité sont indispensables pour le bon fonctionnement de l’entreprise interconnectée au
quotidien avec ces différents partenaires. Mais gérant surtout de la donnée sensible en lien
notamment avec la santé ainsi que des supports monétisés (ex : bon au porteur).
L’équipe de développement, elle, au quotidien assure les parties innovation, maintenance et
optimisation des différentes applications mises à disposition des gestionnaires.

Organigramme de l’équipe au sein de laquelle j’ai évolué

6
Présentation des tâches :
Contexte :
Au cours de mon stage j’ai travaillé exclusivement sur
l’application YVOIRE, celle-ci est pilotée par CNP[1] Assurances mais également par des
prestataires venant de chez SOPRA STERIA.
YVOIRE est une application web qui permet de visualiser, modifier et traiter les « affaires »
liées aux contrats d’assurances. Cette application possède de nombreuses fonctionnalités telles
que : la possibilité de filtrer les affaires, faire des recherches, visualiser les documents liés à
l’affaire...
YVOIRE est principalement codé en Java[2] qui représente 90% du code constituant
l’application, on retrouve aussi un peu de JavaScript[3] (représente 7% du code) ainsi que des
bribes de Perl[4]. Le rendu final sur le navigateur est assuré par des fichiers .jsp[5].

Tâches à réaliser :
A l’issue de mes entretiens d’embauche, j’avais déjà pu
échanger avec mon maître de stage sur les missions qui me serait confiées, elles ont été
définies en fonction des besoins de l’entreprise mais aussi en adéquation avec mon niveau de
connaissances en fin de première année pour que je puisse les gérer en autonomie.
Ainsi j’ai démarré mon stage en connaissant mon programme, à l’origine deux tâches m’ont
été confiées. La première consistait à afficher l’âge de l’assuré à un endroit précis d’une page,
la seconde à calculer la clé DRT[6] puis l’afficher sur même page.
Ayant terminé ces deux tâches plus tôt que prévu il m’a ensuite demandé de placer le bloc
d’informations utilisé en haut de cette page avec une animation. Je reviendrai plus en détails
sur ces tâches plus tard.

Contraintes :
Les tâches m’ayant été confiées consistaient à mettre à jour
l’application YVOIRE en y apportant de nouvelles fonctionnalités, je me devais donc d’utiliser
le même langage que celui de l’application web, à savoir le Java[2].
Il était impératif que les 2 missions initiales soient en production à la fin de mon stage, d’une
part car cet engagement correspondait au cahier des charges défini ; mais aussi me permettant
à titre personnel d’être challengé sur un timing à tenir ; je devais ainsi donner régulièrement
mon état d’avancement.

Facteurs clé de succès :

Le premier facteur de réussite de ces tâches était
l’approbation de mon code par les autres développeurs de l’équipe, pour cela il fallait que je
sois vigilant à ma façon de coder : nom des variables, indentation, coder dans les bons
fichiers…

7
Le second facteur de réussite était l’approbation des fonctionnalités ajoutées à l’application
web par mon maître de stage et par les utilisateurs ayant demandé l’ajout de ces
fonctionnalités.

Réalisations :
Installation de poste :
Lors de mon intégration après avoir réalisé des modalités
liées à la sécurité, et avoir eu la présentation de l’équipe ; une station de travail m’a été
confiée. J’ai donc installé mon poste (PC Portable), en créant ma session Windows et en
configurant mes mots de passe pour Windows ou le bitlocker[7].
Ensuite j’ai commencé la configuration de mon poste, pour cela j’ai suivi un wiki qui était
présent sur le Gitlab[8] de l’équipe dans laquelle je me trouvais. Cela consistait en
l’installation des ressources Java[2] ainsi que la création de répertoires.
Une fois les ressources nécessaires installées je suis passé à la configuration de mon IDE[9].
Pour cela j’ai importé le projet de l’application web YVOIRE, établit un lien entre Eclipse[10]
qui est l’IDE[9] sur lequel j’ai travaillé et mon compte Gitlab[8]. Puis j’ai configuré un serveur
local et paramétré le formateur[11] d’Eclipse[10].

Organisation :
L’équipe au sein de laquelle j’ai évolué pendant mon stage
travaillait sur la méthode Agile . C’est-à-dire qu’au sein de cette équipe, le travail s’effectue
[12]

par sprint[13] de deux semaines. Cette méthode de travail a pour avantages de pouvoir changer
le planning plus rapidement et faire face aux imprévus.
Par rapport à une méthode plus conventionnelle, de légères mises à jour vont être effectuées sur
YVOIRE toutes les deux semaines au lieu d’une conséquente tous les trois mois ; ainsi les
fonctionnalités sont dans un premier temps que peu développées mais bien présentes puis sont
améliorées au fil des sprints[13]. Cela permet de minimiser la présence de bugs et la correction
de ceux-ci. Je vais maintenant détailler le déroulement d’un sprint[13] au sein de l’équipe :
Chaque matin une petite réunion nommée « Stand-Up », d’une durée de quinze minutes se tient,
chaque développeur décrit les tâches effectuées la veille ainsi que les informations importantes
qu’il a à communiquer et les problèmes rencontrés, il demande le soutien de l’équipe s’il en a
besoin.
Le lundi, après le Stand-Up, une instruction des dossiers est faite avec tous les développeurs.
Toutes les requêtes sélectionnées par le product owner (mon maître de stage) faites par les
utilisateurs d’YVOIRE sont pris en compte, que ce soit l’ajout de fonctionnalités ou bien la
correction de bugs puis elles sont pesées[14]. C’est-à-dire que les développeurs évaluent la
complexité ainsi que la durée de réalisation d’une requête. Une fois cette étape passée, la requête
est ajoutée au sprint[13] et attribuée à un développeur sur Jira, un outil qui permet de créer des
requêtes, de les peser et de suivre leur avancement durant le sprint[13].

8
Les captures d’écrans suivantes vous donnent un aperçu de l’application Jira :

Description d’une tâche sur Jira.

Vu globale d’un sprint[13] sur Jira, à droite dans le rond gris est affiché le poids de la tâche.

Suivi de l’avancement d’un sprint[13] sur Jira.

9
Il est important de mettre à jour l’état d’avancement de sa tâche sur Jira afin que l’avancé du
sprint[13] ne soit pas biaisé. Pour cela une tâche passe par plusieurs étapes :
- A faire : la tâche n’est pas encore commencée
- En cours : la tâche est en cours de réalisation
- En attente : la tâche est au point mort
- A Démontrer : la tâche est en attente de la Démo de fin de sprint[13]
- Merge request : la tâche est en attente d’éventuelle correction et de deux approbations
- Terminé : la tâche est finie et va être intégrée à l’application web.
Le sprint[13] se conclu par deux événements, la démo fonctionnelle et la démo technique. La
première démo a pour but de présenter les nouveaux ajouts, fonctionnalités, modifications et
corrections d’éventuels bugs sur YVOIRE ; aux représentants des utilisateurs de l’application
web.
Cette première démo, au-delà de présenter le fonctionnement des nouveautés permet surtout
d’avoir des retours par rapport au travail effectué. Durant cette démo des idées d’ajouts de
fonctionnalités sont aussi évoquées.
La seconde démo, elle, n’est destinée qu’aux développeurs. Elle permet de faire le point sur la
correction de bugs mineurs, les modifications sur les bases de données etc... Cette seconde démo
permet aussi de faire un bilan sur le sprint[13] passé.

Planning d’un Sprint[13]

10
Méthode de travail :
La première chose à faire avant de commencer à coder est de
mettre à jour le statut de la tâche que l’on effectue sur Jira, l’étape suivante est de créer une
nouvelle branche dans Eclipse[10].

Création d’une nouvelle branche, IDD-2423 et IDD-2602 sont des branches créées pour deux
tâches distinctes.
Créer une nouvelle branche permet de toujours avoir le code source inchangé à disposition et
facilite l’envoi de modifications de code sur Gitlab[8]. Cela permet également de mieux
s’organiser, en effet pour chaque tâche une branche est créée ; ainsi aucune confusion n’est
possible dans les tâches et dans le code.
Dès que la branche est créée, on peut commencer à coder ; on visualise le rendu de notre code
sur notre navigateur grâce au serveur local que l’on peut par ailleurs démarrer en mode
debug[15] ce qui est très utile.
Une fois le code fini, il faut créer une merge request[16], dans un premier temps il faut envoyer
les fichiers modifiés sur Gitlab[8], pour cela Eclipse[10] a des outils intégrés tel qu’un
comparateur de fichiers, grâce à celui-ci on peut distinguer les modifications apportées à un
fichier et ainsi supprimer des imports inutiles ou bien encore visualiser des erreurs
d’indentation ou des espaces inutiles.

Exemple de comparaison de fichiers

11
Une fois que l’on a vérifié les fichiers, il ne reste plus qu’à envoyer les fichiers souhaités sur
Gitlab[8]. Pour cela il faut dans un premier temps « commit » ces fichiers, c’est-à-dire que l’on
donne l’information que se sont ces fichiers que je souhaite modifier puis « push, » c’est-à-
dire les envoyer sur Gitlab[8], Eclipse[10] permet de faire les deux en même temps.
Au moment de l’envoi, Eclipse[10] demandera si on souhaite envoyer les fichiers directement
dans une merge request[16] préalablement créée, mais on peut aussi juste « push » les fichiers
et ensuite créer la merge request[16].

Exemple de commit et push

Pour créer une merge request[16], il faut d’abord sélectionner la branche source, celle depuis
laquelle on a codé puis la branche visée, celle que l’on veut modifier qui est dans la plupart
des cas la branche master, car c’est la branche de l’application web.

Sélection de sources lors de la création d’une merge request[16]

Une fois les branches sélectionnées il ne reste plus qu’à mettre un titre, celui-ci doit être le
numéro de la tâche sur Jira suivi du nom de celle-ci. Un lien est établi entre Jira et Gitlab[8]
qui permet de notifier par e-mail les personnes concernées par la tâche. Il est possible de
laisser un commentaire durant la création de la merge request[16].
Pour être merge[17], la merge request[16] a besoin de l’approbation de deux développeurs, ceux-
ci lisent le code et peuvent effectuer des retours par rapport à celui-ci. Il est possible de push
de nouveaux des fichiers modifiés suite au retour de ses pairs.
Dès que l’on a reçu deux approbations, il faut merge[17] notre code. Une fois que celui-ci est
merge[17] on change d’outil et on passe sur Jenkins qui est un outil qui permet d’automatiser
les tests, builds et déploiements.
Quand le build et le déploiement de celui-ci est effectué la dernière étape consiste à vérifier
que notre code fonctionne bien sur un serveur de test.

12
Réalisations Techniques :
Première mission : calcul et affichage de l’âge

Ma première tâche fut de calculer l’âge de l’assuré puis de

l’afficher sur un bloc d’informations. Bien que la tâche puisse paraître de prime abord très
simple elle a été dans les faits plus compliquée à réaliser que ce que je pensais et cela pour
plusieurs raisons.
La première étant que je n’avais jamais codé en Java[2], ni utilisé de fichiers .jsp[5], j’ai donc
du me former et m’informer sur ce point. J’ai également eu une phase de découverte et
d’analyse du code mis en place, de la construction de l’application et de l’organisation et
fonctionnement des différentes fonctions[18] et classes[19].
La seconde réside dans le fait que sur le serveur local, les données de l’assuré ne sont pas
affichées ; j’ai donc du créer un bouchon[20] afin de pouvoir afficher l’âge en local et faire mes
tests. Enfin pour calculer l’âge je devais avoir accès à la date actuelle, or il existe de
nombreuses bibliothèques[21] pouvant faire cette action ; malheureusement certaines sont
désormais obsolètes, il a été complexe et chronophage de trouver la bonne.

A gauche l’affichage du bloc d’informations sur le serveur local, à droite sur la version live
J’ai donc commencé par coder une fonction[18] calculant l’âge en dehors du code de
l’application web. Puis avec l’outil de développement intégré au navigateur j’ai recherché le
nom de la div[21] contenant le bloc d’informations sur mon serveur local, c’est à cette étape
que je me suis rendu compte que les données n’étaient pas disponible, j’ai donc refait la même
manipulation sur la version live.

Utilisation de l’outil de développement intégré au navigateur

13
Une fois le nom de la div[21] trouvé j’ai effectué une recherche de celle-ci dans Eclipse[10]. J’ai
alors trouvé le fichier .jsp[5] contenant le bloc d’informations, la variable attribuée à la date de
naissance ; et c’est à partir de celle-ci que j’ai retrouvé les fichiers où la date de naissance
était définie.
Ma fonction[18] getAge fonctionne ainsi : je récupère la date de naissance de l’assuré puis je la
compare à la date actuelle grâce à la méthode[22] between de la classe[19] Period que j’ai
importé puis je renvoie le résultat. Entre temps je convertis la date de naissance contenue dans
la variable temp en type LocalDate afin de rendre la comparaison possible.

J’ai ensuite crée une seconde fonction[18] setAge qui permet de faire passer l’âge en paramètre
d’une variable. J’ai réecris ces fonctions[18] dans un autre fichier pour pouvoir ensuite les
utiliser avec deux objets différents, seule la fonction[18] getAge est modifiée.

Après avoir écrit mes fonctions[18] je les utilise à l’aide de l’objet[23] BlocClient et de la
classe[19] PersonnePhysique. Personne est un objet[23] représentant l’assuré et BlocClient
représente le bloc où les informations de l’assuré apparaissent.

14
Enfin je crée une balise span[24] dans le bloc d’informations de l’assuré ou j’affiche l’âge, j’ai
uniquement modifié la taille de la police dans la partie CSS[25] du fichier .jsp[5].

Résultat final : Avant / Après

15
Seconde mission : calcul et affichage de la clé DRT

Il convient de se demander ce qu’est une DRT[6] et sa clé,

une DRT[6] est une demande de rachat d’un bon de capitalisation, le numéro de celle-ci se
compose ainsi : 3 lettres en majuscule suivies de six chiffres. Sa clé permet de vérifier la
conformité du numéro de la DRT[6]. Mais avant de parler de comment je l’ai codé, je pense
qu’il est intéressant de d’abord expliquer comment est calculée la clé. La clé DRT[6] est un
nombre entier inférieur à cent.
Prenont le numéro de demande DRT123456 comme exemple, chaque lettre ou chiffre à une
position, celle-ci étant décroissante.

Ensuite une transcodification des trois premières lettres est effectuée, chaque lettre équivault à
un chiffre, une fois la transcodification faite on multiplie la valeur des lettres par leurs
positions et on fait de même pour les chiffres.

La dernière étape consiste à faire la somme des résultats des multiplications valeurs/positions,
puis de faire un modulo[26] 23 de cette nouvelle somme. Si le nombre est inférieur à 10 il faut
rajouter un 0 devant.
Comme pour l’affichage de l’âge j’ai recherché sur YVOIRE à l’aide de l’outil de
développement la div[21] ou était affiché le numéro de DRT[6], puis exactement comme pour
l’âge j’ai ensuite recherché le nom de la variable contenant le numéro de DRT[6].
Cependant la tâche était ici bien plus ardue que pour l’âge, en effet le bloc d’informations
dans lequel est affiché cette donnée contient beaucoup d’informations. Tous les codes et
numéros dont celui de DRT[6] sont affichés grâce à une seule et même variable nommée
reference.
Donc trouver le nom de la variable ne suffisait pas il fallait également que je trouve la
fonction[18] qui génère ce bloc d’informations et plus particulièrement l’affichage du numéro
de DRT[6]. Pour ce faire je me suis beaucoup aidé de l’outil de recherche d’Eclipse[10] ainsi
que du mode debug[15].

16
La fonction[18] que j’ai écrite pour calculer la clé DRT[6] prend en entrée un argument, celui-ci
est le numéro de DRT[6]. Je crée ensuite une variable drt qui stocke le numéro de DRT[6] puis
grâce à la fonction[18] transformeReferenceAlphanumeriqueEnNumerique qui avait déjà
été codé, j’effectue la transcodification lettre/chiffre en mettant en argument le numéro de
DRT[6] et une table de transcodification qui elle aussi avait déjà été codée.

Table de transcodification lettre/chiffre

La prochaine étape consiste à convertir le résultat de la transcodification en une chaine de
caractères, afin de pouvoir grâce à une boucle[27] mettre chaque caractère dans une liste. Suite
à cela, j’effectue une nouvelle boucle[27] qui va dans un premier temps convertir chaque
caractère en entier puis effectuer la multiplication valeur/position. J’effectue ensuite
l’opération modulo[26] 23. La dernière partie de la fonction[18] consiste, grâce à des boucles[27],
à rajouter la clé DRT[6] au numéro de DRT[6] que j’ai stocké dans la variable drt et de rajouter
un zéro devant le chiffre si la clé de DRT[6] est inférieure à dix.

17
Juste avant ma fonction[18] j’ai placé un @override de manière à créer une surcharge[28] pour
pouvoir l’utiliser plus simplement dans le futur. Cette fonction[18] est aussi présente dans un
autre fichier là aussi pour des raisons de simplicité quant à l’appel de la fonction[18].

Une fois que j’ai écrit ma fonction[18], je dois gérer l’appel de celle-ci afin de pouvoir afficher
la clé DRT[6]. Pour cela j’ai modifié une fonction[18] déjà existante nommée
recupererRefeference et qui comme son nom l’indique récupère les références afin de
pouvoir les afficher correctement.
J’ai simplement rajouté une condition qui fait en sorte que si la référence est égale à une
demande de rachat alors j’exécute ma fonction[18], et la référence sera égale au résultat de
l’exécution de celle-ci. Etant donné que ma fonction[18] retourne directement la clé DRT[6]
ainsi que son numéro, je n’ai pas eu besoin de modifier le fichier .jsp[5] associé au bloc
d’informations où s’affiche le numéro de DRT[6].

Résultat Final : Avant / Après

18
Intérêt du résultat pour l’entreprise :

Les tâches que j’ai réalisées au cours de ce stage proviennent

de demandes des utilisateurs d’YVOIRE.
L’affichage de l’âge en plus de la date de naissance a permis aux utilisateurs d’YVOIRE de
gagner en temps car ils n’ont plus besoin de faire le calcul, de plus dans le monde de
l’assurance l’âge peut être crucial. L’âge peut déterminer des taux ou d’autres paramètres
ainsi bien que l’information puisse paraître banale, dans ce contexte, cette information prend
une tout autre dimension.
Pour ce qui est du calcul et affichage de la clé DRT[6], là aussi, l’intérêt est de gagner du
temps. En effet avant ma mission, la clé devait être calculée par les utilisateurs grâce à un
classeur Excel.

Retour par rapport au travail effectué :

L’ajout de l’âge a reçu de bons retours, je ne m’y attendais pas étant donné la simplicité de
l’information affichée, néanmoins les utilisateurs ont vraiment apprécié cet ajout. Du côté de
mon code, j’avais oublié de supprimer un appel de fonction que je n’utilisais pas ce que j’ai
corrigé par la suite avant de merge[17] mon code.
L’affichage de la clé DRT, a aussi satisfait les utilisateurs d’YVOIRE ; bien qu’elle serve moins
que l’âge. Au niveau de mon code, j’avais codé un dictionnaire servant à faire la
transcodification lettre/chiffre ainsi qu’une boucle l’utilisant pour rien. Une fonction et une
table de transcodification que je n’avais pas remarqué existait déjà dans un autre fichier
spécialisé dans le calcul. J’ai donc suite au retour de mes pairs réécris ma fonction dans ce
fichier et utilisant ces outils avant de merge[17] mon code.

19
Expérience humaine :

Ce que j’ai appris :

Ce stage a été très enrichissant dans de nombreux domaines.
En termes de programmation, j’ai appris à coder en Java[2]. Celui-ci étant spécialisé dans la
programmation orienté objet[29] j’ai pu par la même occasion renforcé les compétences que
j’avais acquises durant mes cours de Python. J’ai également découvert l’utilisation des
fichiers .jsp[5].
Tout au cours de ce stage j’ai également été amené à utiliser le debug[15], bien plus souvent
qu’à l’accoutumé. Avant je ne l’utilisais que très rarement, mais compte tenu de la longueur
du code, cet outil c’est montré indispensable. En plus de cela je trouve l’outil très bien fait sur
Eclipse[10] en comparaison à d’autres IDE[9]. L’utilisation de celui-ci et de ses nombreux outils
fait aussi partie des compétences que j’ai pu acquérir durant ce stage.
L’une de mes plus grandes découvertes de stage a été Gitlab[8] et ses fonctionnalités, c’est un
outil que j’ai envie d’approfondir et que je réutiliserai surement étant donné sa praticité,
notamment en termes de travaux de groupes et de sauvegardes.
En ce qui concerne les méthodes de travail, durant toute la période de mon stage j’ai travaillé
en méthode Agile[12], ce que j’ai particulièrement apprécié. En effet avec cette méthode on ne
passe quasiment pas de temps à spécifier les besoins et tout se fait rapidement et
naturellement, on cherche directement à répondre à ceux-ci.

Mon ressenti :
Les premières semaines ont été complexes, j’avais
l’impression de travailler au ralenti, mais au fil des semaines j’ai gagné en rapidité. Je pense
que mes difficultés des premières semaines étaient dû à la découverte d’un nouvel IDE[9],
d’un nouveau langage mais aussi du code de l’application WEB.
D’un point de vue humain, l’équipe a toujours été dans l’accompagnement et l’encouragement
me permettant de prendre confiance et de m’intégrer pleinement dans celle-ci et je les en
remercie tout comme l’a été M. HUBERT qui a su répondre à mes questions durant ce stage.

Conclusion :
Ce premier stage de fin d’année m’a permis de prendre
conscience de la dimension professionnalisante de ma formation. C’est réellement
l’aboutissement d’une année riche en enseignements, elle permet de se positionner de mesurer
ses forces et ses axes d’amélioration.
Au cours de ses 8 semaines ce n’est pas seulement des savoir-faire (nouveaux outils, nouveau
langage de programmation) que j’ai acquis mais bel et bien de nouvelles méthodes de travail
qui me seront très utiles dans la suite de mon cursus, à titre d’exemple je sous estimais jusque-
là les capacités de l’outil de debug[15] ; qui m’a été indispensable tout au long de ce projet.

20
Ce stage au-delà de m’avoir donnée une première expérience professionnelle dans le monde
de l’informatique, m’a conforté dans mon choix d’orientation ; le développement est de
manière affirmée la branche dans laquelle je souhaite progresser et évoluer ; les connaissances
acquises vont me permettre de progresser et de travailler d’une manière plus efficace et
différente qu’avant.

This first end year internship permitted myself to be aware of the professionalization aspect of
the numeric Bachelor. This is really the completion of a rich year of learning, this first
professional experience was the opportunity to position myself, and look at my strength and
weakness.
During these 8 weeks, I do not only learn skills (new tools, new programming language) I
also learn new works method that will be very useful in the future. For example, I
underestimate the utility and the power of the debug[15] tool which was essential during my
internship.
This internship beyond the fact that it gave me a first professional experience in computer
science, comforted myself in my course choose, indeed, computer science is the branch where
I want to progress et improve, all the knowledge that I acquired along this internship will
permit myself to be more efficient.

21