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 : 1 juin 2017

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 :
mail

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);

Work to do #2bis

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 #3

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.

Work to do #4

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 utilisera 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 utilisateur). 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 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, autre ?) que Java (java.util.BitSet, autre ?) proposent des composants logiciels semblables. Le travail demandé est d'abord de montrer que l'on peut facilement construire et instrumenter la classe Message à partir de bit_vector et std::bitset pour C++ et java.util.BitSet pour Java. Y-a-t-il d'autres possibilités venant de bibliothèques moins standards ? Qu'en est-il en matière de performance (faire un benchmark) ? Proposer une stratégie de réutilisation et/ou de « développement maison » à l'équipementier basée sur vos observations, analyses et conclusions. On peut s'inspirer du format suivant (version Java) :
public class Bit {
    …
    Bit(char c) {
        assert(c == '0' || c == '1');
        …
    }
    …
}

public class Message /* extends ? */ {
    …
    Bit start_bit() { return new Bit('0'); } // Bit 1: set to 0
    java.util.BitSet address() { … } // Bits 2->11
    Bit direction() { … } // Bit 12
    java.util.BitSet command_code() { … } // Bits 13->15
    Bit parity() { … } // Bit 16
}

Work to do #7

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))

Work to do #8

Créer en C++ (ZIP) et en Java (ZIP) une hiérarchie de classes dont la racine est la classe abstraite Compte_bancaire, puis Compte_cheque et Compte_epargne qui en héritent et finalement Compte_epargne_logement qui hérite de Compte_epargne. La classe Compte_bancaire supporte une seule méthode abstraite qui est en Java abstract float taux_interet();. Cette classe possède aussi deux champs qui sont l'identité du compte et son solde. On considère que les comptes chèque sont rémunérés (taux variant selon le client) mais seulement à partir d'un certain seuil (variant aussi selon le client) alors que les comptes épargne sont toujours rémunérés mais le taux varie en fonction du type : épargne logement (taux en vigueur du compte épargne logement), etc. Toutes les classes possèdent la méthode appliquer_taux_interet appelée chaque fin d'année. Le corps de cette méthode en Java est le suivant :
public void appliquer_taux_interet() {
    _solde *= (1.F + (taux_interet() / 100.F));
}
Ajouter ensuite à cette hiérarchie, les notions de Livret A, Plan épargne logement, Livret développement durable (ex. Codevi)… Créer ensuite une classe Client_de_banque possédant une collection (utiliser l'interface java.util.Map<K,V> -K = String- en Java et map<Key,Data,Compare,Alloc> en C++, -Key = std::string) de comptes bancaires. Cette classe doit offrir le service cumul_interets qui retourne le cumul des intérêts des comptes bancaires possédés par le client. Créer pour terminer une classe Banque possédant une collection de clients et offrir le même service cumul_interets qui donne le cumul des intérêts à payer à tous les clients.
PS : la table de hachage dans toute instance de Client_de_banque mémorise les comptes possédés par le client. Les clefs de cette table sont par convention les identités des comptes.

Complexité logicielle

Work to do #9
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 #3 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 #10
É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 #11

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)

Le projet consiste à implémenter une application CRUD (Create, Read, Update, Delete) en JavaFX de l'étude de cas Prison de Nantes.

La base de données doit être embarquée et gérée dans l'application selon le modèle établi dans l'application Banking system. Plus précisément, il faut regarder avec attention (et uniquement) la classe Java Banking_system_database de cette application pour comprendre la méthode de gestion d'une base de données embarquée Java DB.

Modalités de contrôle (à confirmer oralement par l'enseignant) : il n’y a pas de rapport à rédiger, l’évaluation se faisant via un oral sur machine avec présentation commentée de la réalisation (emploi du temps à établir). Il faut aussi envoyer par e-mail 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).

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

Syllabus

Cette UE s'intéresse à la programmation avancée des interfaces 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 (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) et ses variantes en jQuery (deferred/promise objects)… Consultez l'emploi du temps de l'UE dans une nouvelle page
Cours TDs TPs Total étudiant ECTS
12h 7.5h 19.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

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 #2

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 #3

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 #4

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 Java Programmable thermostat est une application faite en JavaFX pour la partie interface homme-machine. Cette application, bien qu'elle s'exécute dans un browser, demande l'autorisation d'exécuter Java ; cette autoration est difficile à obtenir à cause de la sécurité.

Le travail à faire consiste donc à réécrire l'interface homme-machine en HTML, CSS et JavaScript. Toutefois, le cœur de l'application est écrit avec la bibliothèque Java PauWare qu'il est plus difficile de remplacer. Il y a deux stratégies pour s'en sortir (en choisir une !) :
  1. Remplacer le code Java dépendant de l'API PauWare par un équivalent JavaScript basé sur la bibliothèque SCION-CORE. L'avantage de cette solution est une application tout JavaScript sans nécessité d'une architecture forcément complexe.
  2. Conserver la partie Java PauWare et connecter l'interface homme-machine HTML, CSS et JavaScript avec cette partie conservée grâce aux WebSockets. Pour cela, il faut lancer un serveur de WebSockets dans la partie Java de l'application. Idéalement, ce serveur est une variable static de la classe contenant la méthode main (initialiser et lancer ce serveur grâce à l'initialiseur static {}). Pour mettre en place un tel serveur, il faut une bibliothèque idoine, typiquement Tyrus, mais d'autres bibliothèques sont possibles. A chaque cycle run-to-completion de PauWare, il suffit alors d'envoyer le résultat au browser en format JSON. Pour information, les browsers récents supportent nativement les WebSockets (voir aussi ici).
Modalités de contrôle (à confirmer oralement par l'enseignant) : il n’y a pas de rapport à rédiger, l’évaluation se faisant via un oral sur machine avec présentation commentée de la réalisation (emploi du temps à établir). Il faut aussi envoyer par e-mail 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).

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 #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)

The Banking system case study is a client-server application that allows credit card withdrawals, deposits, etc. At this time, there is no backend application that allows the creation of clients, logical cards, plastic cards, etc. 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 managing all the necessary data in the database.
Modalités de contrôle (à confirmer oralement par l'enseignant) : il n’y a pas de rapport à rédiger ; l’évaluation se fait via un oral sur machine avec présentation commentée de la réalisation (emploi du temps à établir). Il faut aussi envoyer par e-mail le code source de votre travail au plus tard le dernier jour de travail avant les vacances de Noël (note zéro si non reçu avant minuit).