Développement

Ce cours s'adresse aux développeurs Java devant réaliser des applications mobiles pour téléphone.

Bonnes connaissances de Java et de l'utilisation d'Internet. Connaissances de base d'XML. Expérience requise d'une chaîne de développement Java.

1. Découvrir la plateforme Android
   • Les utilisations de la plateforme Android.
   • Le modèle Android et son architecture.
   • Présentation du système d'exploitation (fonctionnalité, version, outils, etc).
   • Les applications clés pour l'utilisation d'un terminal.
   • Les outils de développement, l'environnement de développement : Eclipse, plug-in ADT, SDK Android.
   • La mise en oeuvre du SDK Android.
   • Les terminaux cibles (Smartphones, tablettes, assistants de navigation personnels, virtuels, etc).
   • L'internationalisation des applications Android.
   • Android et Linux.
2. Développement Android
   • Les concepts de base d'une application Android.
   • Le cycle de vie de l'application (de l'édition du programme au test).
   • Présentation du framework de développement, des librairies.
   • Présentation des classes de base et utilitaires.
   • Création de son premier projet : code, ressource, propriété et détail du projet.
   • Exécuter son application sur le simulateur du SDK et la tester.
   • Le SDK Manager et la configuration des terminaux virtuels Android (AVD) : target, SDCard, ...
   • Utilisation d'un débogueur pour contrôler l'exécution des programmes.
   • Comment accéder aux logs de l'application.
   • L'identification de l'application et le fichier manifest (version, minSDK, nom de l'application, ...).
   • La mise à disposition de son application.
3. Les interfaces utilisateurs avec Android
   • Vue d'ensemble du layout et de la place du composant.
   • Les spécificités des terminaux mobiles en matière d'affichage et d'interaction avec l'utilisateur.
   • Les composants graphiques : layouts, menus, listes...
   • Créer une interface graphique avec les views.
   • La mise en place de menus (principal, icône, sous-menu, ...).
   • La mise en place des conteneurs layouts (Gallery, GridView, ScrollView, ...).
   • La gestion événementielle (mise en place, réaction, écoute).
   • Styles et thèmes appliqués aux widgets.
   • Notification de l'utilisateur (barre de notification, toast, boîtes de dialogue).
   • Ressources alternatives : multi-devices, localisation.
4. Le modèle de composants
   • Le concept de base : activité et cycle de vie.
   • Les composants fondamentaux : Activity, Service, BroadcastReceiver, ContentProvider, Intents.
   • L'arrêt des composants (finish, stopSelf, ...).
   • Les activités (cycle de vie, navigation entre les activités, communication interactivités...).
   • Les services (cycle de vie, tâches de fond ...). Les types de services (locaux et distants).
   • Les différences entre une activité et un service.
   • Le lancement d'une activité, ses principaux états.
   • Le langage AIDL (Android Interface Description Language). Le bus de messages et les Intents.
5. La persistance des données
   • Comment partager des données entre les applications.
   • La sauvegarde de données simple.
   • Utilisation des préférences (SharedPreferences, le mode de lecture). Récupération d'un ensemble de préférences.
   • Utilisation du système de fichiers (dont XML).
   • L'emplacement des fichiers contenant les données (zone internal/external).
   • Utilisation de la base de données embarquée (SQLite), insertion de données.
   • Utilisation de l'API Android.
6. La gestion réseau
   • Rappels sur la programmation réseau.
   • Communication avec une Socket serveur.
   • Utiliser HTTP avec les API Android.
   • Introduction à la consommation des services web.
   • Parser du JSON avec la librairie Gson pour Android, utilisation de la librairie Gson.
7. Compléments
   • Gestion de la téléphonie. Appels. Gestion des SMS. Interactions avec la carte SIM.
   • Multimédia. Dessin et animations. Lecture audio et vidéo.
   • La capture multimédia (son, image, vidéo, ...).
   • Les API de (géo)localisation avec Google Maps.
   • Configurer l'émulateur pour tester la géolocalisation.

Ce cours est destiné aux développeurs et chefs de projets amenés à mettre en place des Web Services au moyen du langage Java.

Bonnes connaissances du langage Java. Connaissances de base en XML. Expérience requise en développement Java.

1. Introduction aux Web Services
   • Définir le rôle des Web Services et l'intérêt de leur utilisation.
   • Rappel sur le contexte des architectures n-tiers, applications et composants distribués.
   • Approche Web Services, qu'est-ce qu'un Web Service ? Objectif, principe.
   • Web Services et EAI, A2A, B2C, B2B.
   • Principales technologies des Web Services (REST, SOAP, WSDL, UDDI).
   • Architecture orientée service (SOA).
   • Le rôle de XML et de la plate-forme Java.
   • Exemples mettant en oeuvre des Web Services.
2. Rappel sur XML et les API Java
   • Place du XML par rapport aux Web Services.
   • Les langages à balises, domaines d'application de XML, le concept de document, objectifs.
   • Echange de données, XML et SOAP.
   • Besoins pour la création de requêtes SOAP et la manipulation des réponses.
   • Les modèles de données : XML Schema.
   • Les parseurs XML (API SAX et DOM) et autres API.
3. Web Services SOAP/WSDL et REST
   • Description du protocole SOAP.
   • De XML à SOAP, anatomie d'un message SOAP, enveloppe SOAP.
   • Gestion des erreurs avec SOAP Fault.
   • Transmission de contenus binaires MTOM.
   • Le langage de description des Web Services, WSDL (Web Services Description Language).
   • Référencement de Web Services, les solutions : UDDI, WS-Inspection, solutions de gouvernance OSS (Mule Galaxy)...
   • Utilisation, architecture, rôle pour les services Web, publication et localisation, sécurité.
   • Principes de REST, comment les mettre en œuvre.
4. Le langage de description des Web Services
   • Comprendre comment décrire un Web Service en XML.
   • Introduction à WSDL. Anatomie d'un document WSDL.
   • WSDL et Java.
5. Mise en place des Web Services avec SOAP/WSDL et REST
   • Les outils de programmation pour la création et l'utilisation de Web Services.
   • Construire des Web Services et des clients avec JAX-WS. Types supportés par JAX-WS et JAX-RS.
   • Outils wsgen.
   • Projet Open Source SOAP du groupe Apache.
   • Utilisation de SOAP dans des contextes RPC.
   • Les Web Services depuis des terminaux mobiles. Possibilités et restrictions.
6. Publication et recherche de Web Services
   • Le rôle des annuaires dans les applications mettant en oeuvre des Web Services. Rôle et limites d'UDDI.
   • La différence entre annuaires runtime et annuaires design-time.
   • Mettre à disposition des Web Services via des annuaires UDDI.
   • Programmation UDDI, structure de données UDDI.
   • Vue d'ensemble et architecture de JAXR.
   • Création et exécution d'un client JAXR, accès au registre, interrogation, gestion des données.
   • Utilisation de descriptions WSDL avec UDDI.
7. Projets CXF, JAX-WS RI et Axis
   • Les mécanismes des principales boîtes à outils de nouvelle génération SOAP.
   • Architecture et composants des projets, CXF, JAX-WS RI et Axis.
   • Installation, configuration, déploiement de services SOAP/WSDL.
   • Consommer et publier des Web Services, correspondance données XML/Java.
   • Utilisation des annotations spécifiques à JAX-WS (JSR 224) et des annotations pour le mapping Java/XML.
   • Au moyen de Java : obtention du WSDL d'un service déployé et construction d'un WSDL.
   • Outils : TCPMon, SOAP Monitor, SOAP UI version OSS.
8. Projet Jersey pour les services REST
   • Les mécanismes de mapping entre Java et le monde REST.
   • Architecture et composants du projet Jersey.
   • Installation, configuration, déploiement de services REST.
   • Consommer et publier des Web Services REST.
   • Utilisation des annotations spécifiques à JAX-RS (JSR 311) et des annotations pour le mapping Java/XML.
   • Comment utiliser JAX-RS et Jersey pour publier des Services REST. Implémentations alternatives à Jersey (Restlet...).
   • Outils : TCPMon, SOAP Monitor, SOAP UI version OSS.
9. Sécurisation des services Web
   • Authentification, autorisation, cryptage.
   • Signatures digitales XML, cryptage XML des informations, toolkit Java, gestion des clés.
   • Authentification personnalisée : les en-têtes SOAP.
   • Extension de sécurité SOAP.
   • Web Services Security Specifications (WS-Security).

• Mettre en œuvre les principes de la programmation orientée objet
• Maîtriser la syntaxe du langage Java
• Maîtriser les principales librairies standards Java
• Maîtriser un environnement de développement intégré pour programmer en Java

Concepteur, développeur, ingénieur, chef de projets opérationnel.

Bonnes connaissances en programmation C ou C++. Expérience requise en développement logiciel.

1. Les techniques Objet
   • Les bases de la syntaxe : variables, types, expressions, instructions, tableaux, structures de contrôle et autoboxing.
   • Définition et instanciation des classes. Les champs, les méthodes, les constructeurs, les champs et méthodes statiques.
   • Les méthodes à nombre variable d'arguments. Les aspects méthodologiques : la conception des classes.
   • Les unités de compilation et packages : le contrôle de la visibilité des classes, le mécanisme d'import.
   • Les différentes formes d'héritage : l'extension et l'implémentation.
   • Les interfaces et l'implémentation des interfaces.
   • Le polymorphisme et sa mise en oeuvre.
   • La construction de hiérarchies de classes.
   • La définition des classes dérivées, les constructeurs, les références.
   • La factorisation de code : les classes abstraites.
   • L'utilisation simultanée de l'implémentation et de l'extension.
   • Les classes abstraites.
   • Les types génériques.
   • Les aspects méthodologiques : le regroupement des constantes, la spécification de services.
2. La conception d'interfaces graphiques (AWT, Swing)
   • Concepts de base : principes de la visualisation et de la gestion des événements, quelques classes génériques.
   • Visualisation des composants graphiques.
   • Les conteneurs et les Layouts : BorderLayout, FlowLayout, GridLayout, GridBagLayout et CardLayout.
   • Construction de conteneurs hiérarchiques.
   • Quelques composants graphiques : labels, boutons, menus, zones de texte, boîtes à cocher, canevas.
   • La gestion des événements. Les Listeners et Adapters.
   • L'association de gestionnaires aux composants graphiques.
   • Les particularités de Swing.
3. Introduction à la programmation Web : les applets
   • Les principes et les constituants du Web.
   • Les Applets : principes, cycle de vie, la classe Applet.
   • Intégration d'une Applet dans une page? HTML, le passage des paramètres, les problèmes de sécurité.
4. Les entrées/sorties et quelques classes utilitaires
   • Les I/O. La hiérarchie des classes d'entrée/sortie. Quelques classes de manipulation des systèmes de fichiers.
   • Quelques classes d'entrée/sortie travaillant sur les flots de bytes, sur les flots de char. Les entrées/sorties clavier.
   • La sérialisation.
   • Les classes d'encapsulation des types.
   • Les classes système.
   • Les classes de conteneur.
   • Les classes d'observateur.
5. La connexion aux bases de données : JDBC
   • Le modèle de JDBC et les principes généraux.
   • Rappels de SQL.
   • Connexion à un SGBD.
   • Exécution des requêtes et traitement des réponses.
   • L'utilisation des requêtes précompilées.

• Créer des interfaces web riches et ergonomiques avec les composants GWT
• Mettre en œuvre une communication client-serveur avec GWT
• Intégrer GWT dans une architecture existante
• Tester une application GWT
• Analyser les performances d'une application GWT

Ce cours s'adresse aux développeurs et chefs de projets désireux de découvrir un framework permettant d'améliorer l'ergonomie des applications Web, mais aussi d'en simplifier le développement.

Bonnes connaissances des langages Java et JavaScript. Expérience souhaitable en programmation Java/Web.

1. Présentation
   • Présentation du Web 2.0 et des technologies Ajax.
   • Mécanismes de Google Web Toolkit.
   • Utilisation de GWT au sein d'Eclipse (Dev Mode).
2. La bibliothèque de composants graphiques
   • Utilisation de l'API et des composants de base.
   • Construction d'écrans à l'aide des panels de placement.
   • Nouveau système de positionnement par CSS.
   • Construction d'interfaces par déclaration (UiBinder).
   • Mise en oeuvre du modèle événementiel.
   • Utilisation des composants CellTable, DataGrid...
   • Construction de composants personnalisées.
   • Data-binding entre les données et les formulaires.
3. JavaScript Native Interface et composants personnalisés
   • Interactions entre JavaScript et GWT.
   • Utiliser les types JavaScript en GWT.
   • Intégrer une librairie JavaScript avec GWT.
4. Accès au serveur
   • Architecture de type Ajax.
   • Communication asynchrone via RPC.
   • Gérer la sérialisation, les exceptions.
   • Formats d'échange JSON et XML.
   • Invocation d'un service de type REST.
5. Concepts GWT avancés
   • Gérer la session et la navigation.
   • Internationalisation.
   • Organisation par modules GWT.
   • Le modèle MVP.
   • Construire un projet Maven GWT.
   • Code splitting, ClientBundle.
   • Analyse des performances avec Speed Tracer.
   • Paramétrage du compilateur GWT.
6. Implémenter une politique de tests
   • Mise en place de JUnit avec GWTTestCase.
   • Intégration de l'outil HTMLUnit.
7. Considérations architecturales
   • Position de GWT au sein d'une architecture JavaEE.
   • Modèles d'architectures : MVC/MVP, Portail, SOA...
   • Intégration avec d'autres technologies : EJB3, JSF...
8. L'écosystème GWT
   • Librairies Sencha-GXT, Smart GWT, Vaadin.
   • Librairies GWT-DnD, GWD Chart.

Toute personne devant apprendre à programmer.

Aucune connaissance particulière.

1. Les fondements de la programmation
   • Qu'est-ce qu'un programme ? Qu'est-ce qu'un langage ? Les différents paradigmes. Quel langage pour quelle application ?
   • Les compilateurs. Les exécutables.
   • Les responsabilités d'un programmeur.
   • Qu'est-ce qu'un algorithme ?
   • Les besoins auxquels répond un algorithme.
   • Le concept de pseudo-langage.
2. Genèse d'un premier programme
   • Ecriture d'un programme simple : syntaxe et instructions.
   • Compilation et exécution du programme.
   • Qu'est-ce qu'une librairie ? Son rôle, son usage.
3. Règles de programmation
   • Convention de nommage.
   • Convention syntaxique.
   • Utilisation des commentaires. Pourquoi commenter les développements ?
   • Améliorer la lisibilité des programmes : indentation du code, découpage du code...
4. Les variables
   • Qu'est-ce qu'une variable ?
   • Pourquoi typer une variable ?
   • Les types primitifs : entiers, chaînes de caractères, nombres réels, autres.
   • Déclaration, définition et initialisation d'une variable.
   • Les constantes.
   • Saisie, affichage, affectation, conversion de type.
   • Organiser ses données sous forme de tableaux.
   • Les types évolués : enregistrement, matrice, arbre.
5. Opérateurs et expressions
   • Les différents opérateurs (multiplicatif, additif, comparaison, égalité, logique, affectation).
   • Combinaison d'opérateurs.
   • Expression booléenne.
6. Les structures de contrôle
   • Les sélections alternatives (si, si-alors-sinon, sélection cas).
   • Les blocs d'instructions (notion de Début... Fin).
   • Les boucles itératives (tant que-répéter, répéter-jusqu'à, pour-de- à).
   • Imbrication des instructions.
   • Les commentaires.
7. Les procédures et les fonctions
   • Définitions : procédure, fonction.
   • Pourquoi sont-elles incontournables en programmation (réutilisabilité, lisibilité...) ?
   • Le passage de paramètres.
   • Le code retour d'une fonction.
   • Sensibilisation aux limites du passage de la valeur d'une variable.
   • Notion de passage par adresse.
   • Appel de fonctions.
8. Introduction à la programmation objet
   • Les concepts associés à la programmation objet : classe, attribut, méthode, argument.
   • La modélisation objet à partir des exigences fonctionnelles.
   • Introduction aux bonnes pratiques d'organisation de conception et d'organisation d'un programme.
9. L'accès aux bases de données
   • Organisation et stockage des données.
   • Les traitements de base (connexion, requêtes, récupération des données).
   • Application cliente et serveur de données.
   • Affichage et manipulation des données dans l'application cliente.
10. Maintenance, débogage et test des programmes
    • Savoir lire et interpréter les différents messages d'erreurs.
    • Utiliser un débogueur : exécuter un programme pas à pas, points d'arrêts, inspecter les variables pendant l'exécution.
    • Prévoir les tests unitaires.

Informaticiens souhaitant développer des applications Web avec les technologies Java/JEE.

Bonnes connaissances du langage Java 5 ou 6 et des technologies Web. Expérience requise en programmation Java. Connaissance du langage HTML préférable.

1. Rappel sur les applications Web d'entreprise
   • Serveur et client Web. Protocoles applicatifs (HTTP). Gestion des sessions. Accès aux bases de données.
   • La plateforme JEE. Architecture multitiers.
2. Architecture des applications Java Web
   • Serveur applicatif, notion de conteneur. Modèle MVC.
   • Principaux composants : Servlets, pages JSP, JSF.
   • Architecture du conteneur Web Tomcat.
   • Déploiement et packaging des applications JEE. Le fichier web.xml. Notion de pluggability.
3. Pages JSP : composants de présentation
   • Technique de développement. Les Scriplets.
   • Utilisation de JavaBeans à partir de pages JSP.
   • Expression Language (EL).
   • Principe des librairies et extensions de balises.
   • Présentation de la JSTL.
4. API Servlet 3.0 : composants de contrôle et de navigation Architecture de type Ajax.
   • Conteneur de servlets. Cycle de vie d'une servlet. L'annotation WebServlet. Gestion des formulaires HTML.
   • Filtrage des requêtes/réponses. Invocation d'autres ressources Web.
   • Gestion des erreurs et journalisation des événements.
   • Suivi de session. Les différentes méthodes.
5. Accès aux bases de données
   • Mise en place de la base et de l'interface JDBC. Connexion à la base, requêtes.
   • Transaction. Pool de connexions. Les DataSources. L'annotation Ressource.
   • Correspondance BDR/Modèles objet : l'API JPA.
6. JSF 2
   • Présentation du framework. Composants essentiels.
   • Cycle de vie du traitement d'une page JSF. Les composants UI. Facelets.
   • La Servlet « FacesServlet ». Notion de FacesContext.
   • Mise en oeuvre des Managed Beans. Définir la navigation entre pages. Convertir et valider des données.
7. Sécurisation des applications Web
   • Notions de users, realms, roles. Authentification et autorisation.
   • Sécurité et programmation de servlets.
   • Installer et configurer SSL. Certificats numériques.

• Concevoir et développer une application n-tiers basée sur les spécifications Java JEE 7
• Mettre en place une couche d'accès aux données avec JPA.
• Mettre en place une architecture distribuée avec EJB et JMS
• Mettre en place une couche de présentation avec JSF et Ajax
• Développer et consommer des webservice REST
• Mettre en place un canal de communication entre un navigateur HTML5 et un serveur via les Websockets.

Développeurs, architectes, chefs de projets.

Bonnes connaissances en Java ainsi que des bases du Web : HTTP, HTML, CSS, JavaScript. Les bases de la programmation JEE (ex : Servlet / JSP) seront un plus.

1. Introduction
   • Briques de la spécification Java EE 7.
   • Bonnes pratiques de conception : séparation des responsabilités, KISS, DRY, POJO.
   • Nouveautés par rapport à la version 6.
   • Panorama de l'offre Java EE, le framework Spring.
2. Environnement de travail
   • Environnement Eclipse. Dépendances Maven.
   • Tests unitaires avec le conteneur embarqué.
   • Utilisation des webtools, prise en main du serveur.
3. Découpage n-tiers et injection de dépendances
   • Découpage en couche, approche POJO.
   • Scopes et gestion de l'état.
   • Injection de dépendances.
   • Intercepteurs.
4. Accès aux données avec JPA
   • Mapping objet relationnel (xml, annnotations).
   • Lazy loading.
   • Manipulation de l'API 2.1 : EntityManager...
   • JPA-QL, API Criteria, MetaModel, EntityGraph.
   • Transactions, l'annotation @Transactional JTA 1.2.
5. Architecture distribuée avec EJB et JMS
   • Services techniques de l'API EJB : sécurité, remoting, accès concurrents, accès asynchrones, timers.
   • Positionnement des EJB par rapport aux beans CDI.
   • JMS 2.0 pour les échanges de messages.
6. Web et JSF
   • Concepts (MVP, Presenter, View).
   • Facelets, taglibs, jsf-el.
   • Validation JSR303.
   • Mise en oeuvre d'Ajax.
7. Web Services REST
   • API JAX-RS 2.0 pour les services web RESTful.
   • Rappels HTTP : les verbes, les contentType...
   • CORS : Cross origin shared ressource. HATEOAS.
   • Produire et consommer des objets via l'API Java de traitement JSON.
8. Web Services REST
   • Websockets
   • Concepts du web "real time".
   • Support par les navigateurs, mécanismes de fallback.
   • Mise en place côté serveur et client.

Informaticiens souhaitant développer des applications Internet/Intranet en utilisant les technologies .NET (ASP.NET et ADO.NET) dans le cadre de l'environnement Visual Studio 2012

Bonnes connaissances de la programmation C# ou VB.NET. Connaissances de base des technologies Web côté client (HTML, JavaScript...).

1. Rappels des concepts liés à l'Internet/Intranet et technologies .NET
   • Serveur Web, sites statiques et dynamiques.
   • Architecture d'une application Internet/Intranet.
   • Technologies .NET. Application Web en .NET.
   • Outils intégrés à Visual Studio.
2. Fonctionnement des pages ASP.NET
   • Principe et problématique des pages dynamiques.
   • Rappel des méthodes HTTP GET et POST.
   • Principe des pages ASP.NET (ASPX).
   • Utilisation des contrôles serveur WebForms. Intégration dans les pages ASPX avec Visual Studio.
   • Gestion automatique de la persistance de l'état des contrôles serveur avec le ViewState.
   • Gestion de la persistance des données applicatives : Session, Cache, Application, Cookies.
   • Membres caractéristiques des classes page, HttpRequest, HttpResponse et HttpServerUtility.
   • Utilisation et limitations du QueryString.
   • Mise en oeuvre du CrossPagePostBack.
   • Gestion des événements dans les pages ASP.NET : Load, UnLoad, PreRender...
   • Gestion des événements de l'application : fichier global.asax, événements importants, utilisation.
   • Structuration d'une application Web avec Visual Studio (dossiers spéciaux, ressources, etc.).
3. Contrôles serveur HTML
   • Utilité des contrôles serveur HTML pour la création de pages actives côté client et serveur.
   • Principaux contrôles. Utilisation.
   • Intégration des contrôles serveur HTML avec les scripts clients JavaScript.
4. Contrôles serveur Web
   • Principe des contrôles serveur.
   • Caractéristiques des contrôles de base : TextBox, Label, Literal, Listes, Boutons, Table, TableCell, etc.
   • Contrôles conteneur : Panel, MultiView, Wizard...
   • Contrôles riches : Calendar, AdRotator, FileUpload...
   • Contrôles de validation et groupe de validation.
   • Réalisation d'un contrôle utilisateur.
   • Principe et mise en oeuvre de l'Ajax.
5. Conception de la structure d'un site Web
   • Contrôles utilisateur pour la structuration des pages.
   • Mise en forme d'un site à l'aide des MasterPages.
   • Rôles des dossiers spéciaux (App_Code, App_Data, App_Themes, etc.).
   • Utilisation des feuilles de style CSS et des thèmes.
   • Mise en place d'un système de navigation avec un fichier SiteMap et des contrôles SiteMapPath, TreeView et Menu.
6. Contrôle de sources de données
   • Introduction à ADO.NET. Modèle objet ADO.NET.
   • Mécanismes d'accès à une BD : connexion, instruction SQL, procédure stockée, lecture. Utilisation d'un DataSet.
   • Mécanisme de DataBinding.
   • Utilisation des contrôles liés à une source de données : XmlDataSource, GridView (tri et pagination).
   • Afficher une vue Maître/Détail entre un contrôle GridView et les contrôles DetailsView, FormView.
   • Principes des modèles de lignes (Templates).
7. Gestion de la sécurité
   • Les types d'attaques (SQL injection, spoofing, répudiation...) et les moyens de s'en prémunir.
   • Contrôle applicatif des accès et des droits.
   • Gestion de la sécurité basée sur Windows.
8. Configuration et déploiement
   • Gestion des exceptions.
   • Rôle et format du fichier Web.config.
   • Le Web Administration Tool intégré à Visual Studio.
   • Sauvegarde des paramètres de l'application.
   • Configuration de la gestion des sessions.
   • Rôle du serveur Web : présentation de IIS.
   • Le mode Release. Publication de l'application.
9. Utilisation des services Web
   • Principe. Architecture, communication XML/SOAP. Langage WSDL (Web Service Description Language).
   • Appel d'un service Web à partir d'une requête HTTP et d'un proxy.

Administrateurs et ingénieurs système en charge de l'administration de serveurs Web.

Bonnes connaissances des protocoles et des architectures Web. Connaissances de base de l'administration de Windows Server 2008.

1. Présentation
   • Nouveautés de IIS 7.0. Migration depuis IIS 6.0.
   • Administration via la MMC (IIS Manager) et l'outil en ligne de commandes (AppCmd).
   • Les différents types d'installations.
2. Configuration de base
   • Gestion des services IIS. Configuration post-installation.
   • Structure d'un site Web. Configuration : web.config.
   • Pools d'applications.
3. Paramétrage de sites et d'applications Web
   • Migration de sites et d'applications Web.
   • Publication de sites statiques et dynamiques.
   • Installation et paramétrage des langages de développement. Illustration ASP. NET.
4. Sécurité
   • Rappel : la sécurité d'un serveur sur Internet et des applications web. Les attaques classiques.
   • Le cryptage via SSL. Certificats côté client et serveur.
   • Configurer des autorisations d'accès.
   • Sécurité des applications hébergées.
   • Réduire les risques grâce à la modularité d'IIS 7.0.
5. FTP, WEBDAV et SMTP
   • Configuration du service FTP. Gestion des utilisateurs, des groupes et des permissions.
   • Configuration de l'accès WEBDAV. Mise à jour d'un site web.
   • Configuration du service SMTP. Sécurité. Relayage.
6. Gestion des performances
   • Outils d'analyse. Gérer la charge du serveur, le nombre de requêtes par seconde et le trafic réseau.
7. Maintenance d'un serveur Web
   • Gestion des logs de IIS. Dépannage. Sauvegarde et restauration de la configuration du serveur Web.
   • Gestion d'un serveur IIS avec PowerShell.

Développeurs, ingénieurs, architectes, chefs de projet.

Bonnes connaissances du langage C#.

1. Introduction
   • Optimiser : quoi, comment, quand ? Objectifs.
2. Fabrication des codes IL et machine
   • Efficacité intrinsèque des différents langages.
   • Utiliser C++ (managé ?) pour les parties sensibles ?
   • Etapes de la fabrication : compilateur et CLR.
3. Les constructions simples du langage
   • Traitement des chaînes de caractères.
   • Performance des classes et des structures.
   • Exceptions. Delegates et lambdas. Interfaces et fonctions virtuelles.
   • Le moniteur de performances. Fonctionnement.
   • Anciens compteurs toujours utiles, nouveautés .NET, compteurs personnalisés.
4. Le ramasse-miettes GC, optimisation et librairies externes
   • La gestion de la mémoire. Les finaliseurs, le Pattern Dispose. Utilisation d'un profileur et de SOS.DLL.
   • Portage depuis COM ou Win32, coût de la réutilisation.
   • Accès aux DLL système ou utilisateur : Interop et P/Invoke. Le marshaling et son coût.
5. Communications interdomaines
   • Domaine d'application et .NET Remoting : rappels.
   • Communication entre domaines : d'un même processus, de processus différents.
   • Mesure de performances. Les règles à respecter.
6. La gestion des threads
   • Optimiser les traitements concurrents et leur synchronisation.
   • Interblocages. Utilisation du pool de threads ou création de threads. Les appels asynchrones.
7. Paralléliser les traitements et optimisation de la phase de démarrage
   • La librairie de parallélisation de Microsoft. Nouvelles classes de System.
   • Threading. Synchronisation.
   • Chargement des assemblages, initialisations, précompilation avec NGEN.
8. Conception et architecture des programmes
   • Une synthèse et quelques conseils.
   • Bien concevoir ses classes.
   • Gestion de cache pour les données.
   • Utilisation de composants distants : le pattern "Facade".
   • Processus différents ou Application Domains ?

Développeurs habitués à la programmation procédurale qui souhaitent tirer parti de la POO pour développer des applications professionnelles basées sur le framework .NET.

Bonnes connaissances en programmation procédurale. Expérience requise en développement logiciel.

1. Intérêts de la POO
   • Rappel des principes de la programmation procédurale.
   • Avantages et inconvénients de cette approche.
   • Exemple d'une application orientée Objet.
2. La notion d'architecture applicative
   • Du Mainframe au client-serveur.
   • Du client-serveur aux architectures multiniveaux.
   • Architecture globale des applications en .NET : organisation en couches et en niveaux.
   • Principe du modèle en trois couches : présentation, métier et accès aux données.
   • Principe des applications distribuées et des architectures SOA.
3. La notion d'objet
   • Démystifier la notion d'objet et terminologie associée.
   • Conception et manipulations d'objets (classes, instances).
   • Utilisation du diagramme de classes UML.
4. L'implémentation d'une classe
   • Mise en oeuvre du mécanisme d'encapsulation.
   • Implémenter une méthode avec surcharges.
   • Ajouter des constructeurs. Créer un membre statique.
   • Définir la visibilité d'un membre et contrôler son accès.
5. Les concepts de la POO
   • Principe et intérêt du mécanisme d'héritage.
   • Redéfinir un membre dérivé.
   • Rôle des classes abstraites et des interfaces.
   • Faire du polymorphisme avec une interface.
6. Manipulations courantes d'objets en .NET
   • Principe de la liaison précoce ou tardive et de la réflexion.
   • Rôle et comportement des types valeur et référence.
   • Regroupement d'objets en collections.
   • Principe du DataBinding. Principe de LINQ.
7. Outils et méthodes
   • Aperçu des techniques d'analyse (RUP ; Agile).
   • Tirer parti d'UML (principaux diagrammes, pièges à éviter...).
   • Principe et intérêt des Design Patterns.

Ingénieurs système ou responsables de réseaux.

Bonnes connaissances de l'administration système et réseau. Connaissances de base d'Office et du HTML.

1. Vue d'ensemble de SharePoint 2013
   • Présentation des produits et services.
   • Principales nouveautés. Architecture générale.
2. Installation de l'environnement
   • Pré requis logiciels et matériels.
   • Topologies de la solution. Paramètres système.
   • Présentation des outils d'administration.
3. Gestion des applications Web et de services
   • Applications Web et applications de services.
   `
   • Configuration des paramètres des applications.
   • Bases de données de contenu.
   • Sites et collections de sites.
4. Administration des sites
   • Principes de sécurité. La sécurité dans SharePoint.
   • Quotas et blocages.
   • Gestion des listes et bibliothèques.
   • Solutions et fonctionnalités.
5. Mise en place de services applicatifs
   • Service de métadonnées gérées.
   • Business Connectivity Services. Excel Services.
   • Service des profils utilisateurs et sites personnels.
6. Recherche d'entreprise
   • La recherche dans SharePoint.
   • Configuration de la recherche.
   • Paramétrages avancés : sources de contenu, origines des résultats...
7. Maintenance et diagnostic
   • Surveillance des performances.
   • Journaux de diagnostics. Le "Developer Dashboard".
   • Stratégies de sauvegarde et restauration.
   • Procédures de "Disaster Recovery".
   • Stratégie de mise à jour de SharePoint.
   • Installation de packs de langue.

Développeurs ASP.NET.

Bonnes connaissances du langage C# 3.0 et expérience en développement Web ASP.Net 2.0 souhaitée. Les développeurs VB.Net peuvent suivre ce cours mais les TP seront réalisés en C#.

1. Introduction au développement dans SharePoint 2013
   • Architecture et artefacts.
   • Modèle des Web Applications et SharePoint sur le Cloud.
   • Documentation et bonnes pratiques.
   • Outils externes conseillés.
2. Modèle Objet Serveur
   • Les principaux espaces et sous-espaces de noms.
   • Gérer les objets usuels SPSite, SPWeb, SPList...
   • Gérer les pages applicatives et des pages d'erreurs.
   • Gérer les autorisations et l'audit de site SharePoint
   • Projets Windows et projets SharePoint (SPContext)002E
3. Web Part visuelle
   • Développer et déployer une Web Part visuelle.
   • Personnaliser la fenêtre de propriété d'une Web Part.
   • Développer une connexion entre deux Web Parts.
   • Personnaliser le menu d'une Web Part.
4. Gestion des flux
   • Flux par défaut.
   • Développer un flux via SharePoint Designer 2013 et VS 2012.
   • Créer des activités. Déployer des flux.
5. Gestion des données
   • Gérer des données de listes : requêtes CAML et LINQ.
   • Gérer des données externes via BCS.
   • Services WCF Data Service et requêtes oData.
   • Gestionnaires événementiels synchrones et distants.
6. Modèles Objets Clients (CSOM)
   • Modèle Objet pour .NET, JavaScript, Silverlight.
7. Personnalisation de l'interface utilisateur
   • Personnaliser la v4.master et création de styles.
   • Personnaliser des menus via CustomAction.
   • Personnaliser le ruban via CommanUIExtension.
   • Infrastructure SP.UI pour les boîtes de dialogue...
8. Déploiement de solutions
   • Solutions SharePoint WSP et schéma d'une fonctionnalité (SPFeature).
   • Artefacts déployés et activés via une fonctionnalité.
   • Evénements attachés aux fonctionnalités.
   • Notion de «Feature Stapling».
   • Gérer la mise à jour des applications SharePoint.

Développeurs, webmasters ayant déjà une bonne connaissance d'un langage de programmation client (javascript ou vbscript).

Connaissances de base du langage HTML et d'au moins un langage de programmation.

1. Introduction
   • L'architecture du Web : HTTP, CGI, interactivité : script client ou script serveur.
   • Qu'est-ce que PHP ?
   • Historique de PHP.
   • Les différences entre PHP 4 et PHP 5.
   • Notions d'architecture multicouche. Introduction aux principes MVC.
   • Présentation de l'exemple utilisé durant la formation : le site de vente en ligne.
2. Automatisation d'une page Web
   • Les principes du client-serveur.
   • Premiers éléments du langage.
   • Intégration de PHP dans une page HTML.
   • Variables et fonctions.
   • Librairies.
   • Fonctions de base, variables serveur et variable PHP.
   • Variables serveur et variable PHP.
   • Contrôles de flux et boucles.
3. Les formulaires simples
   • Passage et transmission de variables.
   • Lecture/écriture de fichier.
   • Vérification de Login/mot de passe.
   • Redirection.
4. Les variables complexes : tableaux
   • Constructeur Array.
   • Fonctions associées aux tableaux.
   • Fonctions d'extraction.
   • Fonctions de navigation dans un tableau.
5. Gestion des sessions utilisateurs
   • Variables persistantes : Cookies et Session.
   • Avantages et inconvénients des Cookies et Sessions.
   • Limitations et précautions.
   • Les variables de session.
   • Fonctions liées aux variables de session.
   • Les Cookies.
   • Sérialisation des variables complexes.
   • Utilisation.
6. Utilisation d'une base de données MySQL
   • Présentation de MySQL.
   • Concepts fondamentaux : bases, tables, champs, enregistrements.
   • Bases MySQL.
   • Tables MySQL.
   • Champs MySQL.
   • Enregistrements MySQL.
   • Fonctions PHP MySQL.
   • Introduction au langage SQL (sélection, modification, suppression).
   • Traitement des résultats des requêtes.
7. Les formulaires complexes
   • Moteur de recherche : formulaire en relation avec une base de données.
   • Fonctions avancées de sélection : recherches et tris.
8. Le graphisme en PHP
   • Présentation de la librairie GD.
   • Création d'image, réutilisation.
   • Gestion des polices et de l'écriture en mode image.
   • Superposition de texte pour protection de droits.
   • Intégration au site.
   • Réalisation de graphiques statistiques.

• Maîtriser la chaîne de production d'un programme écrit en langage C
• Mettre en oeuvre les opérateurs, les expressions et les structures de contrôle du langage C
• Manipuler des structures de données, des tableaux, des pointeurs et des chaînes de caractères
• Organiser le code d'un programme à l'aide de fonctions.
• Exploiter les principales bibliothèques standards du langage C

Les ingénieurs et les informaticiens qui souhaitent acquérir une formation complète et opérationnelle sur le langage C.

Connaissances de base en programmation.

1. Premiers pas en C
   • Présentation du langage C, ses atouts.
   • Le C++ par rapport au C. Normes C++11 et C11.
   • Les fichiers sources (.c, .h).
   • Structure générale d'un programme.
   • La syntaxe de base du langage.
   • Les types de données et les constantes de base.
   • Variables globales et locales.
   • Stockage et passage de paramètres.
   • Entrées/sorties formatées.
   • Les commentaires.
   • Utilisation élémentaire de la chaîne de production.
   • Les environnements d'édition, de compilation et d'exécution.
   • Exécution d'un premier programme.
2. Opérateurs et expressions
   • Opérateurs arithmétiques.
   • Mécanismes d'évaluation des expressions.
   • Post et pré-incrémentation de décrémentation.
   • Précédence et associativité des opérateurs.
   • Opérateurs d'affectation.
   • Mécanismes de fonctionnement des expressions logiques.
   • Expressions logiques dans les instructions while, if...
   • Opérateurs de comparaison : <, >, ==, !=...
   • Opérateurs logiques : ET, OU, négation.
   • Les types numériques composés. Règle de conversion dans les expressions mixtes. Conversions implicites/explicites.
   • Initialisation des variables.
   • Arithmétique sur les adresses.
   • Formats d'entrée/sortie associés aux types numériques.
   • Opérateurs bit à bit : ET, OU, OU exclusif, complément à 1, négation. Opérateurs de décalage : >>, <<.
   • Expression conditionnelle avec l'opérateur ternaire.
3. Structures de contrôle
   • Notion de blocs.
   • Les structures de boucles : while, for.
   • Instructions de contrôle de boucles : break, continue.
   • Structures de choix : if, else, else if.
   • Structure de choix multiple : switch.
4. Tableaux, pointeurs et chaînes de caractères
   • Définition, initialisation et accès aux éléments d'un tableau.
   • Définition d'un pointeur. Récupérer l'adresse mémoire d'un objet. Accéder au contenu d'un pointeur.
   • Equivalences pointeurs/tableaux.
   • Calculs sur les pointeurs.
   • Chaînes de caractères.
   • Exemples de manipulation de chaînes de caractères.
   • Les chaînes de caractères Unicode de C11.
5. Les structures
   • Intérêts des structures.
   • Déclarer, initialiser et accéder aux champs d'une structure.
   • Utiliser des structures imbriquées.
   • Créer de nouveaux types en utilisant Typedef.
   • Les champs de bits.
   • Les unions.
   • Les énumérations.
   • Les structures et énumérations anonymes de C11.
   • Définir des pointeurs sur structures.
6. Les fonctions
   • Définition d'une fonction.
   • Appel d'une fonction.
   • Passage de paramètres : par valeur ou par référence.
   • Code retour d'une fonction. Les types de retour.
   • La fonction " main ".
7. Compilation séparée, classe d'allocation
   • Mécanisme de fonctionnement de la chaîne de production.
   • Utilisation de bibliothèque de sources.
   • Notion de Makefile.
   • Configuration mémoire d'un programme C (pile, tas...).
   • Classes d'allocation des variables (auto, register, static, extern).
   • Différents cas de figure de la compilation séparée.
   • Notion d'objet externe.
   • Cas des données globales et statiques.
   • Cas des données locales.
   • Règle de visibilité.
   • Compléments sur les fonctions et les initialisations.
8. Le préprocesseur
   • Utilisation des macros prédéfinies (constantes symboliques). Définir ses propres macros avec #define.
   • Définir des macros comme des fonctions. Utilisation des marqueurs # et ##.
   • Annuler la définition de constante avec #undef.
   • La compilation conditionnelle : #if, #ifdef, #ifndef, #elif, #endif.
   • Inclure des ressources avec #include.
9. Les bibliothèques standard
   • Les fonctions de calcul mathématique (sqrt, sin...).
   • Les fonctions d'entrées/sorties (fprintf, fscanf...).
   • Les fonctions d'accès aux fichiers (fread, fwrite...).
   • Les fonctions de manipulation de chaînes de caractères (strlen, strcat...).
   • Les fonctions de gestion de la mémoire (malloc, free...).
   • Mise en place de structures chaînées (listes chaînées, arbres n-aire...).
   • Les fonctions « sécurisées » de la librairie standard C11 (strcat_s, strlen_s, ...).

Ce cours s'adresse aux ingénieurs qui souhaitent acquérir une formation à l'approche objet et aux spécificités du langage C++. A l'issue de ce cours, ils sauront utiliser ce langage comme un véritable outil de programmation objet.

Bonnes connaissances du langage C.

1. La syntaxe du C++ (différences entre C et C++)
   • Fonctions importantes : Texte, Conditionnelles, Statistiques descriptives, Logiques, Recherches...
   • Saisie semi-automatique et imbrication de fonctions.
   • Audit de formules.
2. Approche orientée objet
   • Les principes généraux des techniques objet.
   • C++ et la programmation objet.
   • Une introduction aux méthodologies orientées " objets ".
   • Une introduction aux modèles et à la notation UML (modèle statique, dynamique, modèle de coopération, scénario).
3. Les classes et les objets
   • Les aspects syntaxiques : les champs, les méthodes, les constructeurs.
   • Le contrôle d'accès.
   • L'auto-référence.
   • Les champs et méthodes statiques.
   • Les fonctions.
   • Les méthodes et les classes friend.
   • La création dynamique des tableaux d'objets.
   • Les aspects méthodologiques : la conception des classes.
   • Les constructeurs de copie.
4. Dérivation et héritage
   • Principe de la dérivation.
   • Les aspects syntaxiques : la définition des classes dérivées, les constructeurs.
   • Le contrôle d'accès.
   • La mise en œuvre du polymorphisme : les fonctions virtuelles.
   • La réutilisation de code : les classes abstraites.
   • La dérivation multiple.
   • Les aspects sémantiques et méthodologiques : la factorisation du code.
5. Les exceptions
   • Les aspects syntaxiques : les blocs de try, la génération des exceptions.
   • Les aspects méthodologiques : la construction d'une hiérarchie d'exception, l'utilisation des exceptions.
6. La surcharge des opérateurs
   • Principe de la surcharge.
   • Surcharge des opérateurs binaires.
   • Surcharge particulière : l'opérateur indice, fonction, conversion.
   • Surcharge des opérateurs de gestion mémoire.
   • Surcharge des opérateurs '<<' et '>>'.
7. Les modèles
   • Modèle de classe. Principes et mécanismes généraux. Surcharge des modèles et redéfinition de méthodes.
   • Modèle de fonction. Principes et mécanismes généraux. Surcharge des modèles.
   • Modèles et surcharge des opérateurs.
   • Les modèles et les mécanismes de dérivation.
8. Les I/O et aperçu sur la STL
   • Les I/O.
   • Le principe des streams et la hiérarchie des classes d'entrée/sortie.
   • Description de quelques classes d'entrées/sorties.
   • Aperçu sur la STL.
   • Objectifs et principes.
   • Descriptions de quelques modèles et classes.
   • Les conteneurs, les itérateurs.
9. Conclusion
   • Cycle de vie du logiciel : test, intégration, méthode de mise en production.
   • Interaction avec les autres environnements.
   • Analyse critique du C++.
   • Evolution du C++.