GÉ N I E

L OG I C I EL
D I P L Ô M E
D ’ UN I VERS I TÉ
G É N I E L O G I C I E L

PROGRAMME
DES ÉTUDES
SOMMAIRE
PRÉSENTATION GÉNÉRALE 1
Coordinateur pédagogique : .............................................................................................. 1
PROGRAMME DES ÉTUDES 1

ADMISSION 2
Renseignements................................................................................................................. 2
MATIÈRES ENSEIGNÉES 2
FUTE3 / TLC : Théorie des langages et compilation 3
FUTE3 / PI : Programmation impérative 4
FUTE3 / PO : Programmation objet 5
FUTE3 / SYS : Systèmes d’exploitation 6
FUTE3 / METH : Méthodologie de développement de logiciel 7
FUTE3 / UNIC : Pratique du système Unix 8
FUTE3 / C : Programmation en C 9
FUTE3 / RES : Réseaux 10
FUTE3 / ALG : Algorithmique des graphes (option) 11
FUTE3 / PPR : Programmation parallèle et répartie (option) 12
FUTE3 / PTR : Programmation temps réel (option) 13
PRÉSENTATION GÉNÉRALE
Le Diplôme d'Université Génie Logicie est un diplôme de second cycle.
Ouvert uniquement en formation continue, il s'adresse à des stagiaires
titulaires d'un DUT ou BTS scientifique, ou possédant un niveau
équivalent avec une expérience professionnelle. Il répond à un besoin
de formation dans certains métiers, tels ceux liés à l'électronique par
exemple, où l'informatique est de plus en plus présente. Il donne par
ailleurs la possibilité à des informaticiens professionnels de mettre à
jour leurs connaissances.
Il est constitué d'un tronc commun de huit modules et d'une option, pour
un volume horaire global de 580h, avec une possibilité de validation des
acquis pouvant autoriser une dispense concernant certains modules. La
formation complète dure un an, avec des périodes d'alternance en
entreprise pour les salariés. La capitalisation des modules est possible,
permettant d'acquérir le Certificat sur plus d'un an.
Les stagiaires ayant suivi la formation pourront s'intégrer dans des
équipes de conception, de développement et de maintenance de
logiciels complexes. Le contenu de la formation se veut suffisamment
fondamental pour que les diplômés puissent évoluer à long terme dans
le métier d'ingénieur du logiciel en s'adaptant à l'évolution très rapide
des technologies dans ce domaine. Une poursuite d'étude est par ailleurs
envisageable, par exemple en DESS Isa.

Coordinateur pédagogique :
Raoul Vorc'h, Maître de conférences Ifsic

PROGRAMME DES ÉTUDES

PRÉSENTATION
Si les méthodes de conception et de programmation objet prennent une GÉNÉRALE
part importante dans la formation, celle-ci couvre par ailleurs un large
spectre des savoirs nécessaires à un informaticien pour concevoir et
réaliser des logiciels : systèmes d'exploitation, réseaux, théorie des
langages et compilation etc. Un module de programmation impérative
permet aux débutants en programmation d'acquérir les méthodes
fondamentales d'écriture des algorithmes. Enfin, un module optionnel
 permet une spécialisation : programmation temps réel, programmation
parallèle et répartie etc.

ADMISSION
L'admission s'effectue sur dossier et entretien.
Diplômes requis : DUT ou BTS scientifique, ou niveau équivalent avec
une expérience professionnelle.

Renseignements
Service d'Éducation Permanente
4, rue Kléber
35000 Rennes.
Tel. 02 99 84 39 63
http://www.univ-rennes1.fr/sep/

MATIÈRES ENSEIGNÉES
Les différentes matières sont décrites dans les pages suivantes : ne page
par matière qui comprend une présentation, un plan, le sigle de la
matière et le nombre d'heures d'enseignement.

ADMISSION

2
Diplôme d’Université Génie Logiciel
FUTE3 / TLC : Cours : 40 heures ; TP : 30 heures. FUTE3 / TLC : Théorie des langages et compilation

Théorie des langages et compilation

Le cours comporte deux volets : (1) une initiation à la théorie des
langages, grammaires et automates, langages réguliers (ou rationnels) et
non-contextuels (algébriques) et (2) un enseignement de compilation,
analyse syntaxique LL(1), points de génération, schémas d’exécution
fondamentaux.
D’un point de vue pratique, on participe à l’écriture d’un compilateur en
ajoutant des fonctionnalités à un compilateur existant. La
programmation est faite en Eiffel et l’un des intérêts des exercices
proposés réside dans l’étude de la structuration d’un logiciel de taille
conséquente.

PLAN
1. Introduction à la théorie des langages et à la compilation
• structure d’un compilateur, outils pour la construction de compilateurs ;
• vocabulaires, mots et langages.
2. Automates à nombre fini d’états et langages rationnels
• langages reconnaissables et automates finis, déterministes ou non,
minimisation, équivalences, lemme de l’étoile ;
• langages et expressions rationnels ;
• programmation par automate ; applications à l’analyse lexicale.
3. Grammaires et classes de langages
• grammaires et dérivations ; classification de Chomsky.
4. Langages algébriques
• grammaires non-contextuelles et arbres syntaxiques ;
• formes normales, automates à pile, équivalences, lemme d’itération.
5. Analyse syntaxique descendante LL(1) et automates procéduraux
• ensembles premiers et suivants, analyse LL(1) ; MATIÈRES
• utilisation de la pile de récursivité ; ENSEIGNÉES
• autres techniques ; générateurs d’analyseurs syntaxiques.
6. Analyse sémantique et génération
• contrôles statiques de types ;
• production de code à l’aide de points de génération.
7. Quelques schémas d’exécution fondamentaux

FUTE3 / TLC : Cours : 40 heures ; TP : 30 heures.

3
 Diplôme d’Université Génie Logiciel
FUTE3 / PI : Cours : 50 heures ; TP : 30 heures. FUTE3 / PI : Programmation impérative

Programmation impérative
Ce module est une introduction à l’algorithmique et à la programmation
impérative, avec application aux structures de données les plus
classiques. La première partie s’adresse à des personnes ayant une
pratique de l’informatique, mais pouvant n’avoir jamais programmé.
Les premiers exemples sont donnés dans un Langage de Description
d’Algorithmes. Les exemples suivants et les travaux pratiques sont
effectués en Eiffel.

PLAN
1. Algorithmique et programmation de base
• types simples : entiers, booléens, avec leurs opérateurs ;
• nommage ; affectation ; séquentialité ; entrées-sorties ;
• conditionnelle ;
• sous-programmes ;
• itération ;
• objets généraux (en Eiffel) : création, affectation, propriétés, notation
pointée ;
• tableaux.
2. Programmation et structures de données
• les autres types simples : réels, caractères ;
• les types généraux « utilisateur » (exemple d’un type DATE) ; classe,
création, initialisation, propriétés, accès, protection, pré et post-conditions ;
• retour sur l’itération (invariant, terminaison) ;
• tableaux (approfondissement) : ensemble d’objets ; tableau trié
(dichotomie) ; évaluation des coûts ; méthodes de tri ;
• adressage dispersé ;
• structures chaînées : cellules, listes ; utilisation itérative ; programmation
récursive des listes ;
• arbres : binaires de recherche ; "en tas" (le heapsort) ; arbres N-aires.
MATIÈRES
ENSEIGNÉES

FUTE3 / PI : Cours : 50 heures ; TP : 30 heures.

4
Diplôme d’Université Génie Logiciel
FUTE3 / PO : Cours : 40 heures ; TP : 40 heures. FUTE3 / PO : Programmation objet

Programmation objet
Ce module constitue une présentation complète de la programmation
par objets. Les concepts fondamentaux de cette programmation y sont
présentés : classes, généricité, héritage ainsi que les aspects
dynamiques : objets, polymorphisme, liaison dynamique. Cette
présentation s’appuie sur l’étude de trois langages : Eiffel, C++, et Java.
Les Travaux Pratiques s’appuient sur l’EDI EiffelBench, sur les
bibliothèques C++ et sur les outils de développement Java disponibles
à l’Ifsic.

PLAN
1. Les principes de base de la programmation objet
• classes, attributs et méthodes ; objets, champs et messages ;
• gestion des objets : création, modification, destruction ; gestion de la
mémoire : pile, tas ;
• outils pour la qualité : assertions, exceptions.
2. Les concepts avancés (outils pour la réutilisabilité)
• généricité ;
• héritage simple ; liaison dynamique, polymorphisme ; surcharge ;
• classes abstraites et interfaces ;
• héritage multiple et répété.
3. Mises en oeuvre : étude comparative des langages Eiffel, C++, Java
• environnements de programmation ;
• directives de compilation ;
• organisation des classes.

MATIÈRES
ENSEIGNÉES

FUTE3 / PO : Cours : 40 heures ; TP : 40 heures.

5
 Diplôme d’Université Génie Logiciel
FUTE3 / SYS : Cours : 70 heures. FUTE3 / SYS : Systèmes d’exploitation

Systèmes d’exploitation
Ce cours présente la structure et le fonctionnement des systèmes
d’exploitation multi-usagers multiprogrammés : notion de processus et
de ressource , allocation de ressources (processeur, mémoire,...),
gestion de processus, coopération et compétition entre processus,
systèmes d’entrées/sorties, systèmes de gestion de fichiers.

PLAN
1. Aspects liés au matériel
• architecture d’un ordinateur ;
• langage d’assemblage ;
• sous-programmes ;
• mécanismes d’adressage et accès aux objets en mémoire ;
• entrées-sorties : coupleurs et périphériques, E/S physiques.
2. Systèmes d’exploitation
• rôle d’un système d’exploitation, notions de processus et de ressources ;
• allocation de ressources : allocation de processeurs et de mémoire, mémoire
virtuelle paginée, interblocage ;
• coopération entre processus : exclusion mutuelle, section critique, outils de
synchronisation ;
• problème de synchronisation dans les systèmes de gestion des E/S ;
• système de gestion de fichiers ;
• désignation des objets dans un programme : modèle pour la désignation et
la liaison, partage d’objet, édition de liens dynamique.

MATIÈRES
ENSEIGNÉES

FUTE3 / SYS : Cours : 70 heures.

6
Diplôme d’Université Génie Logiciel
FUTE3 / METH : Cours : 50 heures ; TP : 40 heures. FUTE3 / METH : Méthodologie de développement de logiciel

Méthodologie de développement de logiciel

Le module donne des techniques de développement de logiciels de
grande taille (de quelques milliers à quelques centaines de milliers de
lignes de code source). Il porte sur des techniques d’analyse par objets
(méthodes OMT, notation UML), de conception (patrons de
conception), de gestion de qualité (politique de test, gestion de
documentation) et de gestion de cycle de vie (versions, extensions,
politique de gestion).
La première phase du module donne les techniques élémentaires de
conception par objets et fait suite au module de programmation objet ;
elle permet d’améliorer l’efficacité des stagiaires lors de leur projet en
entreprise. La seconde phase contient des cours, TD et TP incluant tous
les aspects importants des techniques de développement de logiciel :
définition de projet, analyse, conception, mise en oeuvre et test,
maintenance. Un projet de développement complet d’un logiciel sous-
tend l’ensemble des enseignements.

PLAN
1. Sensibilisation aux problèmes ; méthodes de micro-développement
• sensibilisation aux problèmes généraux de l’ingénierie du logiciel : taille,
coût, évolutivité, qualité ;
• processus de macro-développement : méthodes, analyse, conception,
construction, test, maintenance ;
• introduction à la notation UML ;
• processus de micro-développement : modularité (méthode CRC),
documentation, tests (contrats de service, non-régression), gestion de
versions ;
• mini-projet d’application du processus de micro-développement :
conception, développement, tests et documentation.
MATIÈRES
2. Méthodes et outils pour le macro-développement ENSEIGNÉES
• processus de macro-développement, gestion de projet, cycle de vie ;
• la notation UML (CM) ;
• les patrons de conception à objets (design patterns) ;
• développement d’une application : analyse, conception, construction et
tests, recette, maintenance corrective et évolutive ;
• pratique des outils (éditeurs, AGL, gestionnaire de configuration) sur un
exemple concret.

FUTE3 / METH : Cours : 50 heures ; TP : 40 heures.

7
 Diplôme d’Université Génie Logiciel
FUTE3 / UNIC : Cours : 15 heures ; TP : 15 heures. FUTE3 / UNIC : Pratique du système Unix

Pratique du système Unix

Le cours présente les concepts de base du système, son système de
fichiers, le fonctionnement des commandes essentielles, tout en faisant
ressortir les piéges et difficultés. Comme la conception du système se
réfléchit dans le langage de commandes, le « shell », il est important de
bien maîtriser les mécanismes liés aux processus pour en tirer le
meilleur parti. Ici, le fossé avec Windows est énorme.

PLAN
1. Introduction
• vue générale sur Unix ; forme des commandes, la commande man ; ;
• présentation de X-Windows ; Netscape ; la messagerie.
2. Le système de fichiers
• hiérarchie de fichiers, déplacements dans la hiérarchie ; ;
• protections, droits d’accès, copie, renommage, liens, affichage,.
3. Les shells
• le Bourne-Shell, le C-Shell et les autres ; ;
• variables, environnement ; redirections ; instructions ;
• sous-programmes (script), fichiers de démarrage ; .
4. Les outils de recherche : grep, whereis, find,
5. Les processus
• création et composition, représentation, visualisation des processus ; ;
• synchronisation, filiation, mort des processus ;
• processus et redirection, processus périodiques, processus différés.
6. Les éditeurs
• l’éditeurs de texte emacs ; expressions régulières ; ;
• éditeurs de texte en mode série, sed et ed ; écriture de filtres Shell.
MATIÈRES 7. Traitement sur les textes
ENSEIGNÉES
• outils pour trier, couper, joindre, calculer ; l’outil awk.
8. Compilation, exécution et édition de liens
9. Divers
• gestion des sources : le SCCS ; le configurateur : make.

FUTE3 / UNIC : Cours : 15 heures ; TP : 15 heures.

8
Diplôme d’Université Génie Logiciel
FUTE3 / C : Cours : 15 heures ; TP : 15 heures. FUTE3 / C : Programmation en C

Programmation en C
L’objectif du stage est de présenter l’ensemble des éléments du langage
et de donner des notions de conception structurée et de modularité
appliquées au langage C à l’aide d’exemples détaillés.
La présentation des éléments du langage est accompagnée d’exemples
simples. Les outils de conception sont introduits en partant d’exemples
détaillés pas à pas.
Des séances de travaux pratiques sur machine permettent de mettre
directement en pratique les notions et les exemples étudiés en cours.

PLAN
1. Éléments de programmation structurée
• décomposition descendante ;
• découpage en fonctions ;
• étude d’un exemple de décomposition (à suivre).
2. Les outils de base du langage C
• les types prédéfinis ;
• les opérateurs et les expressions ;
• les structures de contrôle.
3. Structuration des programmes
• les fonctions, les paramètres ;
• les classes d’allocation ;
• la compilation séparée.
4. Structuration des données
• les tableaux ;
• les types structurés ;
• les types synonymes et énumérés.
MATIÈRES
5. Éléments avancés
ENSEIGNÉES
• les pointeurs ;
• les fichiers ;
• l’allocation dynamique ;
• les tableaux de pointeurs.
6. Notion de composant logiciel
• présentation du concept de réutilisabilité à partir d’un exemple.

FUTE3 / C : Cours : 15 heures ; TP : 15 heures.

9
 Diplôme d’Université Génie Logiciel
FUTE3 / RES : Cours : 70 heures ; TP : 20 heures. FUTE3 / RES : Réseaux

Réseaux
Ce cours introduit les notions fondamentales et les techniques de base
nécessaires à la compréhension des différents mécanismes intervenant
dans les réseaux informatiques.
La première partie s’appuie sur le modèle de référence OSI : techniques
de transmission du signal prenant en compte les contraintes physiques
liées aux différents types de supports ; mécanismes de base mis en
oeuvre pour assurer la transmission de données numériques ; protocoles
de plus hauts niveaux.
La deuxième partie, par le biais de la présentation de nouvelles familles
protocolaires, montre les concepts et les mécanismes propres à assurer
la transmission de données. De nombreuses variantes des mécanismes
de base vont être différemment abordées pour en découvrir les ressorts
profonds. Nous étudierons les réseaux locaux, Internet, l’administration
du réseau, et quelques réseaux à haut débit.

PLAN
1. Introduction aux réseaux informatiques
2. Transmission du signal (couche Physique du modèle OSI)
3. Transmission de trames (couche Liaison de données)
4. Transmission de paquets (couche Réseau)
5. RNIS (Réseau Numérique à Intégration de Services)
6. La couche Transport et les couches hautes de l’OSI
7. Réseaux locaux
MATIÈRES 8. Interconnexion de réseaux locaux
ENSEIGNÉES
9. Internet : IP
10. Protocoles de transport : TCP et UDP
11. Routage et résolution d’adresse
12. L’administration du réseau
13. Réseaux à haut débit : FDDI, Frame relay, ATM
FUTE3 / RES : Cours : 70 heures ; TP : 20 heures.

10
Diplôme d’Université Génie Logiciel
FUTE3 / ALG : Cours : 20 heures ; TP : 20 heures. FUTE3 / ALG : Algorithmique des graphes (option)

Algorithmique des graphes (option)

Le but de ce module est double : d’une part, il constitue un apport de
connaissances algorithmiques basées sur un modèle fréquemment
rencontré en informatique et réseaux ; d’autre part, la mise en oeuvre
des algorithmes permet d’appliquer l’approche objet de la
programmation vue par ailleurs.

PLAN
1. Le type « Graphe » et ses représentations
2. Typologie de problèmes : existence, énumération, structure,
optimum
3. Existence de chemins
• fermeture transitive, algorithme de Roy-Warshall ;
• méthodes d’exploration de la descendance d’un sommet.
4. Problèmes de circuit et de connexité : algorithmes de Marimont, de
Foulkes
5. Chemins de valeur optimale
• algorithmes de Bellmann-Kalaba ; algorithme ordinal ;
• algorithme de Warshall généralisé.
6. Application aux problèmes d’ordonnancement : modélisation
potentiel-tâches

MATIÈRES
ENSEIGNÉES

FUTE3 / ALG : Cours : 20 heures ; TP : 20 heures.

11
 Diplôme d’Université Génie Logiciel
FUTE3 / PPR : Cours : 20 heures ; TP : 10 heures. FUTE3 / PPR : Programmation parallèle et répartie (option)

Programmation parallèle et répartie (option)

Le but de ce cours est d’introduire, d’une part, le concept d’activités
parallèles et d’autre part les mécanismes et les méthodes de création et
de synchronisation. Ces aspects seront abordés d’abord d’un point de
vue système et ensuite d’un point de vue langages de programmation
dans les deux contextes centralisé et réparti.

PLAN
1. Introduction
• modèles parallèle/réparti ;
• communication.
2. Synchronisation (approche centralisée)
• sémaphores ;
• rendez-vous ;
• moniteurs.
3. Synchronisation répartie
• exclusion mutuelle ;
• détection de la terminaison.
4. Approches langage/système
• IPC (Unix) ;
• CSP et Ada ;
• Java.

MATIÈRES
ENSEIGNÉES

FUTE3 / PPR : Cours : 20 heures ; TP : 10 heures.

12
Diplôme d’Université Génie Logiciel
FUTE3 / PTR : Cours : 20 heures ; TP : 10 heures. FUTE3 / PTR : Programmation temps réel (option)

Programmation temps réel (option)

Ce module passe en revue différentes méthodes de programmation
d’applications dans le domaine des systèmes Temps Réels. L’approche
synchrone est plus particulièrement développée, avec applications et
mise en œuvre dans le langage synchrone Signal.

PLAN
1. Introduction au génie logiciel temps réel
2. Les concepts temps réel dans la programmation
• Temps continu/temps discret ;
• Modélisation des procédés ;
• Représentation des événements dans les systèmes continus ; Simulink.
3. Méthodologie
• SART ; UML et le temps réel ; STATECHARTS.
4. Les concepts temps réel dans la programmation
• ADA et le rendez-vous, le non déterminisme ;
• VHDL et le temps simulé ;
• Principe d’abstraction synchrone ;
• Sous-ensembles pour le temps réel dur ;
• Sparc ADA ;
• Traits dangereux en C ;
• Utilisation de l’assembleur.
5. La conception de systèmes temps réel dans un modèle flot de
données
• Suite discrète de valeurs, signaux, processus ;
• Signaux réguliers et calculs associés ;
• Itération de calculs ;
• Variables d’état, Composition ;
• Signaux non réguliers et calculs associés ; MATIÈRES
• Sélection, Entrelacement ; ENSEIGNÉES
• Gestion d’événements ;
• Programmation de concepts temps réel en SIGNAL.
6. La modélisation et la vérification des applications temps réel
• Rappels sur les OS ;
• Gestion de tâches et ordonnancement ;
• Vérifications de mise en oeuvre ;
• Panorama des systèmes temps réel.
FUTE3 / PTR : Cours : 20 heures ; TP : 10 heures.

13
 MATIÈRES
ENSEIGNÉES

14