Université de Pau et des Pays de l'Adour

Département informatique

Licence informatique et Master informatique Technologies de l'Internet

Dernière mise à jour : 28 mai 2018

mail
Note : tous les cours et ressources mis ici en ligne n’ont pas vocation à être utilisés à des fins de formation et/ou de conseil, dans un cadre commercial ou non, sans l’autorisation explicite de son auteur. Vous êtes donc invités à télécharger et éventuellement utiliser le matériel pédagogique mis en ligne qu’à des fins personnelles. Dans le cas contraire, merci de me signaler les usages spécifiques que vous envisageriez, contact :

Accès direct aux cours, TDs et TPs

Informations sur les configurations, téléchargements, ressources…

Code accès aux salles en libre service

Environnement NetBeans avec le serveur d'applications Java EE GlassFish

Visualisation des documentations, téléchargement des outils

Licence informatique, UE Introduction aux systèmes d'exploitation (Semestre 1)

Syllabus

Cette UE s'intéresse aux bases de la manipulation des systèmes d’exploitation des ordinateurs. L’objectif est une initiation à la manipulation des systèmes d’exploitation des ordinateurs avec des notions de programmation « shell » sous le système d’exploitation UNIX principalement. Consultez l'emploi du temps de l'UE dans une nouvelle page
Cours TDs TPs Total étudiant ECTS
12h 0h 27h 39h 4

Contrôles sur table et examens des années précédentes

Cette UE est évaluée par un système de contrôle continu incluant des notes de TPs ainsi qu'un contrôle sur table à la fin du cours. Tout TP non rendu ou toute absence au contrôle donne lieu à la note zéro. Toutefois, un examen de rattrapage est organisé en fin d'année universitaire si la moyenne générale est inférieure à 10.

Cours

Le cours se trouve sur une page dédiée (ici).

Travaux pratiques

Les TPs sont sous le contrôle de M. Jobard (ici).

Licence informatique, UE Technologie Orientée Objet (Semestre 5)

Syllabus

Cette UE donne les connaissances complètes pour la conception orientée objet des logiciels professionnels. Le premier objectif est la maîtrise complète des concepts de la programmation par objets ainsi que l’acquisition et la maîtrise des langages Java et C++. Le second objectif est de fournir aux étudiants une base de connaissances large et solide pour réaliser les travaux pratiques des autres UE de la licence informatique. En outre, la connaissance de la programmation par objets et des langages Java et C++ est essentielle pour aborder un master informatique. Consultez l'emploi du temps de l'UE dans une nouvelle page
Cours TDs TPs Total étudiant ECTS
27h 13.5h 18h 58.5h 6

Examens des années précédentes

Cette UE est évaluée par un examen comptant pour 70% ainsi qu'un projet et une note d'appréciation du travail en TP comptant pour 30%.

Cours

Travaux pratiques

Work to do #1

Implanter en Java (ZIP) et en C++ (ZIP) dans une classe N_INSEE un système de saisie contrôlée d'un #INSEE (ou #SS) selon la formule suivante : clef = 97 - (#INSEE % 97). On rappelle qu'un #INSEE est défini sur 13 chiffres (e.g., 1630125388055, clef = 29) et que sa clef est saisie simultanément pour contrôle. En C++, il est nécessaire de vérifier que les #INSEE tiennent sur le format long et dans le cas contraire le remplacer par le format long long, e.g., long long n_insee_de_Franck_Barbier = 1630125388055LL; (ne pas oublier le suffixe LL derrière la constante). Si l’on passe par des chaînes de caractères (i.e., std::string), il faut utiliser la fonction C de conversion std::atoll (#include <cstdlib>) pour convertir des chaînes de caractères en variables de type long long.

Work to do #2

Implanter en Java et en C++ dans une classe Annee_bissextile, deux fonctions booléennes établissant si, oui ou non, une année est bissextile. La première fonction prend en paramètre l'année sous forme entière alors que la seconde la prend sous forme d'un type gérant les dates. Pour Java, ce type est java.util.Calendar. Pour C++, ce type est time_t (#include <ctime>).

Récupération de l'année du temps machine en C++ :
std::time_t now = std::time(&now); // '#include <ctime>'
// Display for control:
std::cout << std::asctime(std::localtime(&now)) << std::endl; // '#include <iostream>'
std::tm *now_as_data_structure = std::gmtime(&now);
int year = now_as_data_structure->tm_year; // Caution: 'tm_year' returns the current year minus '1900'!
Récupération de l'année du temps machine en Java :
java.util.Calendar now = java.util.Calendar.getInstance();
int year = now.get(java.util.Calendar.YEAR);
Correction C++

Work to do #3

En s'inspirant d'un programme C++ déterminant en fonction du temps machine si une date donnée est « Avant hier », « Hier »… , implanter en Java un programme équivalent.

Work to do #4

Soit un programme C++ (ZIP) dans une classe Tirage_loto permettant de remplir automatiquement une grille de loto simple avec 48 valeurs différentes à choisir entre 1 et 49 inclus. On a en fait 8 jeux consistant à choisir à chaque fois 6 chiffres mais on n'utilise pas les mêmes chiffres entre chaque jeu. Ecrire le programme Java équivalent.

Pour gérer des suites de nombres aléatoires, on utilise opportunément :

Work to do #5

Implémenter en C++ (ZIP) et en Java (ZIP) le concept de température, sachant qu'une température ne peut pas descendre en dessous du zéro absolu. Cette propriété peut être formalisée via une fonction accessor constante sur le type abstrait de données Temperature comme suit : Min: Temperature -> tMin. La fonction Min est basée sur l'axiome suivant : t: Temperature, asCelsius(Min(t)) = –273.15. Par ailleurs, il existe trois unités de mesure des températures qui sont les °C, les °F et les °K. Ces trois unités sont matérialisées par les trois fonctions accessor suivantes : asCelsius: Temperature -> Real, asFahrenheit: Temperature -> Real et asKelvin: Temperature -> Real. Les axiomes suivants s'appliquent : t: Temperature, asKelvin(t) = asCelsius(t) - asCelsius(Min(t)) et t: Temperature, asFahrenheit(t) = 9/5 * asCelsius(t) + 32. Prévoir des fonctions d'incrémentation et de décrémentation avec un pas « fin » (10-3 ou moins) matérialisé par une variable d'instance _step.
Pour le test en Java, créer une classe Temperature_UI (utiliser JavaFX) contrôlant la température de façon à ne pas descendre en dessous de 40°Fahrenheit et ne pas monter au-dessus de 90°Fahrenheit (afficher ces valeurs de manière fixe dans l'interface homme-machine). Pour changer la valeur de la température, prévoir un slider. Pour visualiser la valeur courante de la température, prévoir au plus simple une zone de texte. Prévoir aussi une checkbox pour établir dans quelle unité de mesure s'exprime cette température (utiliser °C ou °F uniquement).

Work to do #6

Un programmeur C++ mal inspiré (il comprend mal l'héritage et le polymorphisme) a écrit une classe Devise ainsi qu'un programme simple de test . Revoir en Java cette classe Devise sous forme de classe abstraite. Construire les classes Dollar, Euro, Yuan et Bitcoin comme des sous-classes. Attention à cette dernière qui, en tant que crypto-monnaie, devrait pouvoir bénéficier d'une branche de la hiérarchie bien à elle !

Work to do #7

Un grand équipementier télécom a développé en C++ une classe permettant de manipuler des vecteurs ou flux (stream) de bits de taille a priori infinie (ZIP). L'idée est de pouvoir agir sur chaque bit dans le flux, faire des opérations logiques, réserver des portions du flux en leur donnant des significations particulières comme par exemple des checksum lors de transmissions, etc. Tout cela est basé sur un encombrement mémoire minimal et une vitesse d'exécution des opérations sur le flux la meilleure possible vu la nature « système » des traitements envisagés. Les applications reposant sur ce genre de concept informatique sont nombreuses et variées comme la codification et la transmission de messages, la compression, la gestion de flux multimédia, etc. Dans le code C++ figure l'exemple d'une classe C++ Message pour la transmission de messages de 16 bits au sein d'une infrastructure sous-marine de réseaux à fibre optique. Cet équipementier se demande l'intérêt d'aller plus en avant dans l'extension et donc la maintenance de cette classe Message. En effet, tant C++ (std::bitset) que Java (java.util.BitSet) proposent des composants logiciels semblables. Le travail demandé est d'abord de construire la classe Java Message à partir de java.util.BitSet (redéfinir la méthode toString pour Bit et Message). Pour cela, il faut s'inspirer du format suivant (attention : faut-il utiliser ou non l'héritage ?) :
public class Bit {
    private final boolean _implementation;

    public Bit(char c) {
        _implementation = c == '0' ? false : true;
    }
    // Other constructors and methods here…
}

public class Message /* extends ? */ {
    …
    public Bit start_bit() { return new Bit('0'); } // Bit 1: set to 0
    public java.util.BitSet address() { … } // Bits 2->11
    public Bit direction() { … } // Bit 12
    public java.util.BitSet command_code() { … } // Bits 13->15
    public Bit parity() { … } // Bit 16
}
Le travail demandé est aussi de revoir la classe C++ Message à partir de std::bitset. Pour cela, il faut trouver une manière simple de coder le type Bit existant puis éliminer, si possible, les classesLimited_bit_stream et Unlimited_bit_stream.

Work to do #8

Mettre en œuvre les programmes de tri lent et rapide (on peut idéalement implanter le quick sort décrit ici) écrits en C++ (ZIP) en les modifiant et en y ajoutant des mesures de temps afin de vérifier empiriquement le coût de calcul.  Afin de procéder à des mesures de performance fines, il est possible de réutiliser les types time_t et tm (#include <ctime>) de la bibliothèque standard ou des bibliothèques système (type timeb via #include <sys/timeb.h> -> more < /usr/include/sys/timeb.h avec UNIX). Finalement, implémenter ce programme en Java (ZIP) de façon comparable à C++ puis, dans une seconde version, en exploitant opportunément la classe Java java.util.Collections.

Pour remplir les tableaux à trier, on utilise opportunément :

Work to do #9

Implanter en C++ et en Java une classe Compte_bancaire sur la base du type abstrait de données Compte bancaire.
TYPES
Compte bancaire, Real
FUNCTIONS
« accessor »
solde: Compte bancaire -> Real
decouvert: Compte bancaire -> Real
« modifier »
déposer: Compte bancaire × Real -> Compte bancaire
retirer: Compte bancaire × Real -/-> Compte bancaire
« constructor »
new: Real × Real -> Compte bancaire
AXIOMS
c: Compte bancaire, i: Real, solde(c) + i = solde(déposer(c,i))
c: Compte bancaire, i: Real, solde(c) - i = solde(retirer(c,i))
i, j: Real, solde(new(i,j)) = i
i, j: Real, decouvert(new(i,j)) = j
c: Compte bancaire, decouvert(c) >= 0
PRE-CONDITIONS
c: Compte bancaire, i: Real, pre(retirer(c,i)) = (i - solde(c) <= decouvert(c))

Complexité logicielle

Work to do #10
Mettre en œuvre les programmes C++ (ZIP) de calcul de la suite de Fibonacci (utiliser le code fourni en faisant varier le type de calcul : récursif, itératif ou Binet). Faire ensuite des mesures de temps selon la méthode du Work to do #8 et expliquer les limitations inhérentes aux programmes fournis lorsque les nombres en entrée deviennent « importants ». Finalement, implémenter ce programme en Java (ZIP).
Work to do #11
Étendre le programme C++ (ZIP) concernant l'algorithme d'Euclide via une variable « artificielle » mesurant le coût. Vérifier empiriquement que ce coût est proche de log(b) si on calcule euclid(a,b). Finalement, implémenter ce programme en Java (ZIP).

Work to do #12

Soit l'algorithme de cryptage RSA (PDF) implémenté en Java sous une forme simplifiée et pédagogique (ZIP). Faire une nouvelle implémentation Java de cet algorithme sur la base de la classe java.math.BigInteger.

Projet (project)

L'application Java SE BCMS est un système de gestion de crise impliquant policiers et pompiers qui de façon coopérative procèdent à une intervention sur le lieu d'une crise « en cours ». Le processus de gestion de crise consiste à décider de l'envoi de voitures et de camions dont policiers et pompiers suivent l'envoi et l'arrivée jusqu'à ce que la crise soit terminée. En l'état, l'application n'a pas d'interface homme-machine. Plus précisément, un programme Java main teste l'enchaînement de deux crises pour vérifier grossièrement que l'application globalement fonctionne.

Le projet consiste à fabriquer une interface homme-machine en JavaFX. Cette interface homme-machine doit permettre de se connecter en tant que policier (Police Station Coordinator) ou en tant que pompier (Fire Station Coordinator). Une fois connecté en tant que policier, seules les fonctionnalités associées au rôle de policier dans l'application sont disponibles et donc activables via l'interface homme-machine (idem pour la « connexion pompier »). Par exemple, l'instruction Java bCMS.state_fire_truck_number(2); du programme de test actuel ne doit être accessible qu'à la « connexion pompier ».

Modalités de contrôle : le travail est fait en binôme (monôme toutefois accepté). Il n’y a pas de rapport à rédiger, l’évaluation se faisant en partie via un oral intermédiaire sur machine avec présentation commentée du travail réalisé (la date de l'oral sera communiquée en temps utile par e-mail). Il faut aussi déposer, au format ZIP uniquement, le code source de votre projet au plus tard le dernier jour de travail avant les vacances de Noël (note zéro si non reçu avant minuit). Dépôt ici : depot.univ-pau.fr. Merci de signaler par un e-mail à l'enseignant le dépôt (bien mentionner aussi les membres du binôme dans l'e-mail).

Licence informatique, UE Conception des Applications Internet (Semestre 5)

Syllabus

Cette UE s'intéresse à la programmation avancée des interfaces homme-machine Web avec le langage JavaScript. L'idée est d'étudier une approche orientée objet propre (héritage, polymorphisme, encapsulation/visibilité…) de programmation de manière à créer des architectures évolutives en symbiose avec les toutes dernières technologies (WebRTC, WebSockets, Web Workers…). L'étude de bibliothèques clef (jQuery…) est abordée, pour la mise au point des programmes en particulier : Chai, dat.GUI, etc. L'étude de classes et d'interfaces pour des sites Web multimédia hautement interactifs est aussi abordée : HTMLCanvasElement, modèle événementiel (CustomEvent, Promise)… Consultez l'emploi du temps de l'UE dans une nouvelle page
Cours TDs TPs Total étudiant ECTS
15h 7.5h 16.5h 39h 4

Examens des années précédentes

Cette UE est évaluée par un examen comptant pour 70% ainsi qu'un projet et une note d'appréciation du travail en TP comptant pour 30%.

Cours

Travaux pratiques

Work to do #1

Implanter en JavaScript un système de saisie contrôlée d'un #INSEE (ou #SS) selon la formule suivante : clef = 97 - (#INSEE % 97). On rappelle qu'un #INSEE est défini sur 13 chiffres (e.g., 1630125388055, clef = 29) et que sa clef est saisie simultanément pour contrôle. Prévoir deux zones de saisie, une pour saisir le #INSEE et l'autre pour saisir la clef. Pour signifier le résultat à l'utilisateur, utiliser la librairie SweetAlert2. A ce titre, faire apparaître un message différencié selon l'issue du calcul de clef fait par JavaScript (i.e., OK ou Non OK). Organiser le code en deux fichiers différents, l'un faisant le calcul et l'autre les interactions homme-machine. Pour le premier fichier, utiliser export et le second utiliser import.
Correction simplifiée

Work to do #2

Ce travail concerne les tableaux JavaScript qui jouent un rôle extrêmement important. Un logiciel de détection de caractéristiques (la face en bleu, la bouche en vert et les yeux en rouge) donne des résultats pléthoriques nécessitant un post-processing :


Le post-processing consiste à appliquer des heuristiques simples comme par exemple le fait que « les yeux se trouvent au-dessus de la bouche » ou encore « la bouche et les yeux sont inclus dans la face » (voir toutefois Macron pour qui cette heuristique peut être améliorée !). Dans le logiciel de détection, this._eyes est un tableau JavaScript ; this._eyes.length est donc le nombre d'yeux trouvés. Au-delà, this._eyes[0].x et this._eyes[0].y représentent le coin supérieur gauche du rectangle bornant le premier œil alors que this._eyes[0].width et this._eyes[0].height donnent la largeur et hauteur du rectangle, etc… L'idée du TP est donc d'utiliser les primitives sur les tableaux de manière à améliorer la qualité de la détection :


Exemple d'application d'heuristique (on ne garde que la bouche la plus basse) :
if (this._mouth !== null && this._mouth.length > 1)
    this._mouth.sort(function (mouth1, mouth2) {
        return mouth2.y - mouth1.y;
    }).splice(1, this._mouth.length - 1);

Work to do #3

Implémenter en JavaScript le concept de température selon l’énoncé Work to do #5 de la section « Travaux pratiques » de l’UE Technologie Orientée Objet. Les conversions de température entre °C et °F peuvent s'effectuer dans le code en local. Différemment, on peut utiliser des services Web comme ceux offerts ici. Pour le test en JavaScript, créer une page Web avec HTML et CSS de manière à contrôler la température : ne pas descendre en dessous de 40°Fahrenheit et ne pas monter au-dessus de 90°Fahrenheit (afficher ces valeurs de manière fixe dans la page Web). Pour changer la valeur de la température, prévoir un slider. Pour visualiser la valeur courante de la température, prévoir au plus simple une zone de texte. Prévoir aussi une checkbox pour établir dans quelle unité de mesure s'exprime cette température (ne pas utiliser °K).

Work to do #4

Soit un programme Java () mettant en héritage une classe Note et une classe Confidential_note, traduire en JavaScript 6 ce programme grâce aux récents mots-clefs class, static, super

Work to do #5

Le but du TP est de s'intéresser aux éléments JavaScript de type HTMLCanvasElement (spec. ici). On peut aisément créer dynamiquement un canvas.
var canvas = document.createElement('canvas');
canvas.id     = "My canvas";
canvas.width  = 1200;
canvas.height = 800;
canvas.style.zIndex   = 8;
canvas.style.position = "absolute";
canvas.style.border   = "1px solid";
document.body.appendChild(canvas);
Ensuite, le canvas est dessiné via des fonctions de dessin et/ou il est rempli via une image. Il est alors intéressant de pouvoir faire des traitements d'images (exemple ici) via l'accès aux pixels du canvas mais ces traitements peuvent être couteux en temps machine d'où la nécessité de travailler directement avec des background buffers qui sont formatés spécialement pour des accélérations GPU (approche ici). Voici un exemple de traitements d'images dans des canvas de manière à reconstruire ces images dans un monde 3D (application ici).
En s'aidant de dat.GUI, le travail consiste à construire une page HTML dans laquelle on charge une image et on opère des changements comme ceux proposés ici. On rappelle qu'il faut manipuler les pixels avec les background buffers.

Work to do #6

Le but du TP est de s'intéresser aux événements clavier, souris ainsi qu'aux événements Drag & Drop. Considérant l'application ci-dessous (), on souhaite faire évoluer son fonctionnement comme suit :
  1. On veut pouvoir à tout moment annuler le compte à rebours en cours avec la souris puis on saisit une donnée définissant une nouvelle valeur de compte à rebours ; on redémarre le compte à rebours.
  2. Avec la souris toujours, on veut pouvoir effectuer une pause du compte à rebours en cours ; on le reprend.
  3. On veut pouvoir à tout moment changer l'image (la texture en fait) de l'objet 3D animé via un Drag & Drop. Attention, le Drag & Drop est ici un glisser-lâcher d'un fichier image provenant du système d'exploitation. Par défaut, un browser affiche cette image. Ce comportement par défaut doit donc être inhibé.

Work to do #7

Le but du TP est de manipuler les tableaux en JavaScript (type Array : doc. ici). L'application 3D qui suit montre une géométrie de lèvres « brute ». Une géométrie est fondée sur un tableau de sommets (vertices en anglais) et un tableau de faces. Si g est une géométrie alors g.vertices et g.faces sont deux tableaux de type Array. Une face est composée de trois sommets exactement. Si f est une face alors f.a, f.b et f.c sont des index dans le tableau de sommets. A titre d'illustration, g.vertices[f.a] est un des trois sommets de la face f.
L'application 3D qui suit montre la géométrie de lèvres reconstruite. En fait, les tableaux vertices et faces ont été ré-organisés (re-triés spécialement) de manière à isoler cinq zones distinctes. A titre d'illustration, en jouant sur le paramètre Color, on colorie en blanc la zone la plus extérieure des lèvres.
En résumé, à partir de l'application 3D basée sur la géométrie de lèvres « brute », il faut aboutir à la géométrie de lèvres reconstruite. Téléchargement : (Lips_geometry_processing_three.js : géométrie brute et Lips_geometry_processing_three2.js : géométrie retravaillée).

Projet (project)

L'application My device est une application JavaFX pour la partie interface homme-machine. Le cœur de l'application est un automate de type Statecharts de Harel. L'exécution de cet automate est basé sur la bibliothèque Java PauWare. L'équivalent de PauWare en JavaScript est SCION-CORE. L'application My device, bien qu'elle puisse s'exécuter dans un browser, pose des contraintes de sécurité qu'il est de plus en plus difficile de satisfaire en regard de l'évolution des browser du marché (Firefox, Chrome, Safari, etc.).

Le projet consiste ainsi à concevoir l'interface homme-machine en HTML, CSS et JavaScript et réécrire le cœur de l'application avec le « moteur d'exécution » SCION-CORE.

Modalités de contrôle : le travail est fait en binôme (monôme toutefois accepté). Il n’y a pas de rapport à rédiger, l’évaluation se faisant en partie via un oral intermédiaire sur machine avec présentation commentée du travail réalisé (la date de l'oral sera communiquée en temps utile par e-mail). Il faut aussi déposer, au format ZIP uniquement, le code source de votre projet au plus tard le dernier jour de travail avant les vacances de Noël (note zéro si non reçu avant minuit). Dépôt ici : depot.univ-pau.fr. Merci de signaler par un e-mail à l'enseignant le dépôt (bien mentionner aussi les membres du binôme dans l'e-mail).

Master Technologies de l'Internet, UE optionnelle Bibliothèques Logicielles : Conception et Réutilisation (Semestre 1)

Internet Technologies MSc, Software Libraries: Design and Reuse Teaching Unit

Syllabus

Cette UE traite des bibliothèques de code prédéfini faisant office d’interfaces de programmation d’application (APIs en anglais). Le développement de logiciels modernes est fortement contraint par la réutilisation de code existant pour des raisons de coût et de productivité. Ce code, contrairement à du code terminal qui a vocation à finaliser une application, doit être construit de façon idoine pour dégager un potentiel de réutilisation (ou réutilisabilité). L’approche par objets, composants et services est unanimement reconnue comme la plus performante sur le sujet mais construire ces entités sans principes et méthodes n’aboutit pas à des bibliothèques où le code est aisé à comprendre, reprendre et, le cas échéant, adapter/personnaliser. Les thèmes étudiés sont le code sur étagère (Commercial Off-The-Shelf software), le logiciel open source (licences, forges, organisation des développements…), les patrons de conception (patterns), les canevas d’applications (frameworks), la configuration, le packaging (binaires…), l'outillage (IDEs…). Consultez l'emploi du temps de l'UE dans une nouvelle page
Cours TDs TPs Total étudiant ECTS
15h 15h 9h 39h 4

Contrôles sur table et examens des années précédentes

Cette UE est évaluée par un système de contrôle continu basé sur un projet et une note d'appréciation du travail en TP.

Cours (lecture) in line

Note : cette UE n'est plus ouverte.

Master Technologies de l'Internet, UE Composants et Services Logiciels (Semestre 3)

Internet Technologies MSc, Software Components and Services Teaching Unit

Syllabus

Cette UE est à la frontière du génie logiciel et des systèmes distribués. Elle vise à étendre la problématique de la programmation et de la modélisation orientées objet aux paradigmes de « composant » et « service ». Le programme abordé traite des notions de Component-Based Development et Service Computing (concepts, caractérisation, panorama des modèles de composants technologiques, différence/similitude composant/service…). Les technologies Enterprise JavaBeans™ (EJB) et Java Web Services servent d'illustrations. Consultez l'emploi du temps de l'UE dans une nouvelle page
Cours TDs TPs Total étudiant ECTS
18h 12h 9h 39h 4

Examens des années précédentes

Cette UE est évaluée par un examen comptant pour 70% ainsi qu'un projet et une note d'appréciation du travail en TP comptant pour 30%.

Cours (lecture)

Travaux pratiques (exercises)

Enterprise JavaBeans™ (EJB)

Work to do #1
A simple Java EE application (further details on this case study may be found here) is based on a Stateless Session Bean named Customer_management interacting with an Entity Bean named Customer.
EJB module: Cient application: Java DB database: The proposed work consists in extending this simple Java EE application so that it supports CRUD (-Create, Read, Update, Delete-) functions for all existing entity beans. Only test this application for the Logical_card table in the database (please keep the database schema “as is”).
Work to do #2
Given Asterix and Obelix as two collaborative Session Beans. Asterix has a business method named strength, which itself calls a business method offered by Obelix also named strength.
  1. Implement Asterix and Obelix in the same EJB module as follows:
    • Both are Stateless Session Beans (use the following annotation value for Obelix: mappedName = "ejb/Obelix")
    • Dependency injection in Asterix to Obelix as follows: @javax.ejb.EJB(mappedName = "ejb/Obelix") Obelix o = null;
    • Call of Obelix strength in Asterix strength: o.strength();
  2. Implement Asterix and Obelix in two different EJB modules. Change the code in both Asterix and Obelix so that strength in Asterix is still able to call strength in Obelix (tip: explore the lookup annotation value for @javax.ejb.EJB).
Solution: Asterix , Obelix and Test_Asterix_Obelix .
Work to do #3
Download a EJB case study in which several kinds of EJB components interact. By reading this document , try several code modifications in the case study to answer to the raised questions in the document.
Work to do #4
Download a EJB case study in which several kinds of EJB components interact. By reading this document , try several code modifications in the case study to answer to the raised questions in the document.
Work to do #4 bis
Download a EJB case study in which several kinds of EJB components interact. By reading this document , try several code modifications in the case study to answer to the raised questions in the document.
Work to do #5
The New York City Penitentiary (NYCP) case study results from a long interview between the NYCP director and a software engineer. From this discussion, a UML Use Case Diagram including five concrete business services and a UML Class Diagram are provided. Beyond, several software artifacts are produced (e.g., a Java DB database script, static Web pages as requirements' illustration…). Complete the current Web application with two Web pages: Add_offense.xhtml and Offenses.xhtml. Add_offense.xhtml has to be attainable from All_prisoners.xhtml by means of a Add offense hyperlink. Add_offense.xhtml aims at adding a link to the Prisoner (participant role) - Criminal case (offense role) association. Once done, Offenses.xhtml displays all of the criminal cases in which a prisoner is involved, including, of course, the very last (just added) offense. Behavior of Add_offense.xhtml and Offenses.xhtml has to be similar to the existing Add_participant.xhtml and Participants.xhtml Web pages.
Work to do #6
Being inspired by the New York City Penitentiary (NYCP) case study that uses EJB + JavaServer Faces, implement a CRUD (-Create, Read, Update, Delete-) application for a (requirements doc. in French) Computer-Integrated Manufacturing case study (Java DB script ).
Work to do #7
The Railcar control system application is a Java EE application. At this time, the client program is a simplified Java SE program that graphically displays the status of the railcars and the terminals. For that, the client program continuously requests the Java EE (server-side) program to ask for the status of railcars and the terminals. However, two Web services offered by the server-side program are not yet used:
@javax.jws.WebService(serviceName = "Railcar_new_destination")
@javax.ejb.Stateless()
public class Railcar_new_destination {
    @javax.ejb.EJB
    private Control_center_local _control_center = null;

    @javax.jws.WebMethod(operationName = "railcar_new_destination")
    @javax.jws.Oneway
    public void railcar_new_destination(@javax.jws.WebParam(name = "railcar") String railcar, @javax.jws.WebParam(name = "terminal") String terminal) {
        assert (_control_center != null);
        _control_center.railcar_new_destination(railcar, terminal);
    }
}

@javax.jws.WebService(serviceName = "Terminal_new_destination"
@javax.ejb.Stateless()
public class Terminal_new_destination {
    @javax.ejb.EJB
    private Control_center_local _control_center = null;

    @javax.jws.WebMethod(operationName = "terminal_new_destination")
    @javax.jws.Oneway
    public void terminal_new_destination(@javax.jws.WebParam(name = "terminal") String terminal, @javax.jws.WebParam(name = "another_terminal") String another_terminal) {
        assert (_control_center != null);
        _control_center.terminal_new_destination(terminal, another_terminal);
    }
}
Railcar_new_destination means that a new destination has been requested in a given railcar to stop at a given terminal. Terminal_new_destination means that a new destination has been requested in a given terminal to stop at another given terminal.
The project consists in building an Android client program (user interface) that is able to: Note: at this time, identities of Web services requesters are not managed. Other adaptations/extensions are also required so that the existing server-side program manages passengers in a consistent way. Otherwise, the exposure of the Java EE program, in terms of architecture especially, is probably unfit for calls from an Android smartphone. More precisely, it is imposed that all Web services run in a RESTful mode and carried data are based on JSON.

Java Message Service (JMS)

Work to do #8
Soit l'application JMS (ZIP) composée d'un émetteur (classe JMS_temperature_sensor). Celui-ci émet périodiquement une température à destination d’un récepteur (classe JMS_programmable_thermostat). Etudier la mise en œuvre du multithreading dans le producteur. Qu’en est-il si le mécanisme de simulation de l’évolution de la température est réarmé (supprimer /* et */ autour de implements Runnable) ? Proposez et implémentez des modifications légères s’appuyant sur le timer pour faire évoluer la température. Etudier ensuite le consommateur. En quoi le mécanisme de consommation actuel est limité ? En d’autres termes, est-on toujours sûr de lire la totalité des messages arrivés ? Proposer et implémenter un mécanisme simple qui arrête le consommateur seulement après que tous les messages soient consommés. Indication : concept de message « vide », voir méthode public Message createMessage() throws JMSException de Session.
Work to do #9
Pourquoi dans son fonctionnement actuel, l'application JMS_banking_system (ZIP) fait que le message émis n’est pas reçu ? Faire une légère modif. pour supprimer le problème et déterminer en quoi le mode diffuseur/abonné se différencie foncièrement du mode point-à-point ?
Work to do #10
L'application JMS_banking_system_plus (ZIP) bien que semblable à l'application JMS_banking_system de l'exercice précédent fait partager la même connexion JMS et la même destination (Topic en l’occurrence) au producteur et au consommateur. Pourquoi ? Faire un programme simple ou modifier l’existant de manière à remplacer la classe TopicRequestor par une création explicite de TemporaryTopic pour simuler une communication de type requête/réponse.

Java Web Services (JWS)

Work to do #11
En s'inspirant du mécanisme d'annuaire (hyper-lien Annuaire sur la page d’accueil de l’UPPA) et du projet NetBeans Annuaire_UPPA basé sur JSP (ZIP), implanter un Web Service « avancé » de recherche d’informations sur le personnel de l’UPPA. Permettre en particulier une recherche multi-critères pour formuler des recherches du type : quelles sont les personnes dont le nom de famille contient « arbie » et qui sont « professeur des universités » ?

Java annotations

Work to do #12
Ecrire un ensemble d'annotations Java permettant de documenter du code avec la date de son écriture (puis ses dates de modifications), les auteurs des modifications, la description succincte de la dernière maintenance faite, la nature de cette dernière maintenance entre deux valeurs possibles (réparation et évolution fonctionnelle), l'état de la version courante entre quatre valeurs possibles (stable, unstable, unchecked et unknown). Prévoir des valeurs par défaut pour toutes les propriétés de toutes les annotations. Voici ce que cela pourrait donner à l'usage :
@Modifications(dates = {"19/06/2008","22/09/2008"}, authors = {"FB","FB"}, description = "NullPointerException correction", nature = Nature.Reparation, state = State.Stable)
public class My_class { …
Procéder à des vérifications runtime* de ce code, comme par exemple « le nombre de dates des modifications est égal au nombre d'auteurs ayant fait ces modifications » ou encore « les dates des modifications sont bien rangées par ordre chronologique ».
* Logiquement ces vérifications n'ont pas lieu d'être au runtime. L'exercice n'est donc qu'à titre pédagogique. Pour aller plus loin, voir en particulier l'outil Annotation Processing Tool (APT).

Projet (project)

Le groupe de distribution Carrefour, face à la concurrence montante des sociétés d'e-commerce comme Amazon qui attaque le marché des produits de grande consommation (grande distribution ou retail), se doit de devenir une « entreprise digitale » en comblant son retard en informatique. Pour cela, les API Items et Store permettent à des applications tiers d'accéder, respectivement, aux produits et magasins de Carrefour, ainsi que tout un ensemble de données associées.

Le projet proposé, dit de Web scraping, consiste à faire une étude de faisabilité et à réaliser un Proof-Of-Concept (POC) quant à la possibilité de rechercher et d'extraire sur Internet des données supplémentaires corrélées aux données officiellement renvoyées par l'API Items de Carrefour. Typiquement, cette API est capable de renvoyer des informations sur le Nutella dans ses différentes versions de produit. Par exemple, le code international GTIN d'un pot de 780 grammes de Nutella est, en format JSON, {"gtin": "3017624047813", "description": "POT 780G NUTELLA"}. Toutefois, l'image du pot en format standard (JPG, PNG…) est facilement trouvable ailleurs (par exemple, ici) alors que l'API Items de Carrefour ne fournit pas d'image du produit en standard.

L'idée du projet est de faire une interface homme-machine Web simplifiée qui permette pour un produit de grande consommation donné vendu par Carrefour de « glaner » d'autres informations à son sujet dont, foncièrement, son image en format numérique. Le cœur du projet consiste évidemment à faire des appels de Web services et, compte tenu des langages proposés par l'API Items, on se propose de réaliser le projet soit en Java SE, soit en technologie Java EE de base, i.e., EJB sous GlassFish, soit en jBPM sous WildFly ou soit en Node.js. Pour creuser le sujet du Web scraping, voici quelques blogs ou bibliothèques intéressants :

Modalités de contrôle : le travail est fait en binôme (monôme toutefois accepté). Il n’y a pas de rapport à rédiger, l’évaluation se faisant en partie via un oral intermédiaire sur machine avec présentation commentée du travail réalisé (la date de l'oral sera communiquée en temps utile par e-mail). Il faut aussi déposer, au format ZIP uniquement, le code source de votre projet au plus tard le dernier jour de travail avant les vacances de Noël (note zéro si non reçu avant minuit). Dépôt ici : depot.univ-pau.fr. Merci de signaler par un e-mail à l'enseignant le dépôt (bien mentionner aussi les membres du binôme dans l'e-mail).