Ce cours présente la notion de qualité de code et comment il est possible de l'évaluer grâce à des métriques mesurables. Après avoir présenté plusieurs métriques standards, il se concentrer sur des aspects de qualité de code spécifique à l'orienté objet et présente les cinq concepts de l'orienté objet. La deuxième partie du cours présente plusieurs bonnes pratiques à avoir en programmation orientée objet, sur base d'exemples concrets.
Cette introduction vise à:
* définir le rôle de l'architecture logicielle;
* retracer l'évolution du développement logiciel afin de mieux comprendre l'état (d'immaturité) de cette discipline;
* brosser un portrait des qualités essentielles d'un architecte;
* introduire quelques fondements de cette discipline.
Notions de base de programmation en langage C, le syntaxe, les opérateurs, l'affichage et le saisie, les structures de contrôle, les boucles.
cours par Benouini Rachid.
Ce support explique les concepts de base de Big Data Processing. Elle aborde les parties suivantes :
Série de vidéos : https://www.youtube.com/watch?v=1JAljjxpm-Q
- Introduction au Big Data
- Système de stockage en Big Data
- Batch Processing et Stream Processing en Big Data
- Aperçu bref de l’écosystème de Hadoop
- Aperçu de l’écosystème des outils du Bid Gata
- Big data stream processing avec Kafka écosystème
- Architecture de Kafka (Brokers, Zookeeper, Procuder, Consumer, Kafka Streams, Connecteurs)
- Comment démarrer un cluster de brokers KAFKA
- Création et configuration des Topics
- Création d’un Java Kafka consumer
- Création d’un Java Kafka Produder
- Kafka Producer et Kafka Consumer dans une application basée sur Spring
- Kafka Streams
- Intégration de Kafka dans Spring Cloud.
Mot clés : Big data, Big Data Processing, Stream Processing, Kafka, Kafka Streams, Java, Spring
Bon apprentissage
Présentation générale d'une architecture orientée service :
- Définition des différents acteurs
- Notion de service
- Définition d'une plateforme SOA
- Implémentation WCF
Slides du cours "JAVA1001 : Introduction à la programmation Java" de la formation "Apprendre Java et la Programmation Orientée-Objets" du learning center de http://www.ukonline.be
Ce cours introduit aux trois langages de programmation du Web que sont l'HTML, le CSS et le Javascript. L'HTML est un langage de balisage qui permet de décrire un document et sa structure. Le CSS est un langage qui permet de définir des règles de style à appliquer à un document. Enfin, Javascript est un langage permettant d'ajouter un aspect dynamique à une page web.
Cette introduction vise à:
* définir le rôle de l'architecture logicielle;
* retracer l'évolution du développement logiciel afin de mieux comprendre l'état (d'immaturité) de cette discipline;
* brosser un portrait des qualités essentielles d'un architecte;
* introduire quelques fondements de cette discipline.
Notions de base de programmation en langage C, le syntaxe, les opérateurs, l'affichage et le saisie, les structures de contrôle, les boucles.
cours par Benouini Rachid.
Ce support explique les concepts de base de Big Data Processing. Elle aborde les parties suivantes :
Série de vidéos : https://www.youtube.com/watch?v=1JAljjxpm-Q
- Introduction au Big Data
- Système de stockage en Big Data
- Batch Processing et Stream Processing en Big Data
- Aperçu bref de l’écosystème de Hadoop
- Aperçu de l’écosystème des outils du Bid Gata
- Big data stream processing avec Kafka écosystème
- Architecture de Kafka (Brokers, Zookeeper, Procuder, Consumer, Kafka Streams, Connecteurs)
- Comment démarrer un cluster de brokers KAFKA
- Création et configuration des Topics
- Création d’un Java Kafka consumer
- Création d’un Java Kafka Produder
- Kafka Producer et Kafka Consumer dans une application basée sur Spring
- Kafka Streams
- Intégration de Kafka dans Spring Cloud.
Mot clés : Big data, Big Data Processing, Stream Processing, Kafka, Kafka Streams, Java, Spring
Bon apprentissage
Présentation générale d'une architecture orientée service :
- Définition des différents acteurs
- Notion de service
- Définition d'une plateforme SOA
- Implémentation WCF
Slides du cours "JAVA1001 : Introduction à la programmation Java" de la formation "Apprendre Java et la Programmation Orientée-Objets" du learning center de http://www.ukonline.be
Ce cours introduit aux trois langages de programmation du Web que sont l'HTML, le CSS et le Javascript. L'HTML est un langage de balisage qui permet de décrire un document et sa structure. Le CSS est un langage qui permet de définir des règles de style à appliquer à un document. Enfin, Javascript est un langage permettant d'ajouter un aspect dynamique à une page web.
Cette présentation concerne le développement piloté par les tests (TDD, Test-Driven Development). Cette méthodologie se base sur des tests unitaires qui testent de manière indépendante des unités de code (module, procédure/fonction, classe...). En particulier, cette présentation utilise la librairie CUnit utilisée pour le langage C.
Git est un logiciel de gestion de versions décentralisé qui vous permettra de gérer la vie d'un code informatique. Il permet une stratégie de backup, de gérer des versions et de stocker tout l'historique des modifications apportées à un projet informatique.
Ce cours aborde la gestion d'erreurs en programmation, c'est-à-dire comment gérer les situations où une erreur se produit. Après avoir présenté le principe des spécifications et de la programmation défensive avec l'instruction assert, ce cours présente l'instruction try/except qui permet de capturer des erreurs. Enfin, le cours termine en présentant comment définir ses propres erreurs et les générer avec l'instruction raise.
Cette présentation concerne la mesure des distances entre la Terre et les étoiles. Elle présente notamment la technique du l'écho radar et celle de la parallaxe.
Ce premier cours avancé sur Python concerne les deux structures de données avancées que sont les ensembles et les dictionnaires. Ces derniers sont notamment utilisés pour construire des bases de données orientées document.
Dans ce cours, on découvre comment lire et écrire des fichiers à l'aide de Python. Il est possible de créer des fichiers texte ou des fichiers binaires. Pour manipuler un fichier, il faut d'abord l'ouvrir, puis on peut faire les opérations et enfin on doit le refermer.
Ce cours concerne la manipulation des chaines de caractères et les expressions régulières. La première partie présente la classe str Python ainsi que les opérations qu'il est possible de faire sur des objets str. La seconde partie concerne les expressions regulières qui permettent de valider des chaines de caractères ou d'en extraire des sous-chaines qui satisfont un motif donné. On y voit finalement comment utiliser le module re Python.
Ce cours concerne les arbres, structure de données organisant les données de manière hiérarchique dans de nœuds reliés entre eux par une relation parent-enfant. Le cours présente les arbres généraux et ensuite les arbres binaires, où chaque nœud possède 0 ou 2 enfants. Enfin, le cours termine en présentant des algorithmes de recherche et en particulier l'arbre binaire de recherche.
Ce premier cours introduit à plusieurs aspects liés au développement informatique. Le cours présente comment versioner son code avec le système Git et comment le déployer avec Heroku. Il présente ensuite comment débugguer avec le module pdb et comment profiler son code avec les modules timeit et profile. Enfin, le cours termine en présentant le concept de tests unitaires que l'on peut construire avec les modules doctest et unittest.
Cette présentation montre plusieurs outils gratuits qui peuvent être utilisés pour gérer plusieurs aspects de la gestion de projets, en particulier informatique, de manière collaborative. On y voit comment versioner son code avec Git, déployer son code avec Heroku, tester son code avec Travis, gérer et planifier son temps et ses tâches avec Trello, FreedCamp et Tom'splanner, comment communiquer avec Slack et comment rédiger sa documentation avec Read the Docs.
Ce cours présente le langage UML qui permet notamment de modéliser des logiciels programmés en orienté objet. Ce cours présente les diagrammes de classes qui permettent de décrire la structure d'un logiciel et les diagrammes d'activité qui permettent de décrire les aspects dynamiques de l'exécution.
Ce cours présente comment réaliser des interfaces graphiques avec Python en utilisant la librairie Kivy. La première partie rappelle les principes de la programmation évènementielle puis présente la séparation interface/comportement à l'aide de fichiers KV et Python. La deuxième partie présente comment réaliser des dessins avec les composants Canvas. On y voit comment dessiner des formes, appliquer des transformations et on termine avec un exemple de composants déplaçables.
Ce cours présente ce qu'est l'internet des objets (IoT), un réseau parallèle au web connectant entre eux des dispositifs physiques. Les différences majeures entre l'IoT et le web sont mises en avant, ainsi que les grands défis auxquels le monde de l'IoT est confronté. Le cours présente ensuite brièvement comment on peut gérer un système embarqué à distance, notamment pour la maintenance, le monitoring, le disaster recovery, notamment à l'aide d'un watchdog. Enfin, pour conclure, plusieurs architectures réseaux possibles sont présentées, pour inter-connecter des systèmes embarqués et les relier au web.
Cette conférence présente LaTeX, un outil permettant de réaliser des documents de haute qualité typographique et professionnelle. Après avoir présenté quelques règles de typographie de la langue française, la présentation fait découvrir les bases de LaTeX et montre comment réaliser son premier document. Elle présente ensuite plusieurs constructions de base comme les listes, l'inclusion d'images et de tableaux, les mathématiques, les listings de code source. Enfin, elle termine avec des constructions plus avancées, comme la notion de figure et références croisées.
Cette conférence présente le framework Johnny-Five qui permet de programmer des cartes embarquées à l'aide d'un module Node.js. Après un tour rapide du JavaScript et de son fonctionnement, en particulier la programmation fonctionnelle et l'exécution pilotée par les évènements, la présentation décrit Node.js et aborde rapidement son fonctionnement. La troisième partie présente Johnny-Five et plusieurs exemples simples de contrôle d'une LED et de l'utilisation des entrées/sorties numériques et analogiques.
Ce cours présente les techniques que l'on peut utiliser pour effectuer des calculs parallèles avec une machine. La première partie introduit à la notion de parallélisme et de processus. Elle présente ensuite comment lancer et manipuler des processus avec les modules subprocess et multiprocessing. On y voit également comment communiquer entre processus avec des Queue et des Pipe. La deuxième partie présente les threads et leur utilisation avec le module threading. On y voit également comment créer un pool de workers/executors pour exécuter des jobs. Enfin, la dernière partie présente le framework dispy qui permet de facilement faire du calcul distribué et exploiter le parallélisme de données.
Ce cours présente le notion de qualité de code et quels sont les critères et pratiques à adopter pour produire du code de qualité. Il présente les erreurs de programmation les plus fréquentes auprès des apprentis programmeurs. La deuxième partie du cours présente la notion de convention de codage et en particulier le PEP 0008 qui décrit des conventions à adopter lorsqu'on programme en Python.
Tout comme on fait attention au style d'écriture utilisé lorsque l'on rédige un livre, en plus d'appliquer les règles d'orthographe et de grammaire, il faut également appliquer des règles stylistiques lorsqu'on rédige du code.
Cette conférence présente plusieurs aspects à prendre en compte pour rédiger du code de qualité, allant de la structure globale d'un programme à la mise en page de son code, en passant par les noms des variables.
L'amélioration des tests unitaires par le refactoringPascal Laurin
Les tests unitaires font maintenant partie de nos pratiques courantes de développement d'applications. Par contre, ils sont encore trop souvent considérés comme du code de second ordre, écrit rapidement après le développement sans trop d'attention. Considérant qu'un bon test unitaire doit être facile à comprendre, rapide, indépendant et ne tester qu'une seule chose alors comment faire pour améliorer la situation?
L'amélioration des tests unitaires par le refactoringMSDEVMTL
4 mai 2015
Groupe .NET/ASP.NET
Sujet: L'amélioration des tests unitaires par le refactoring
Conférencier: Pascal Laurin
Les tests unitaires font maintenant partie de nos pratiques courantes de développement d'applications. Par contre, ils sont encore trop souvent considérés comme du code de second ordre, écrit rapidement après le développement sans trop d'attention. Considérant qu'un bon test unitaire doit être facile à comprendre, rapide, indépendant et ne tester qu'une seule chose alors comment faire pour améliorer la situation?
Dans cette présentation je vais montrer plusieurs astuces en partant de mauvais tests (legacy) et finir avec de meilleurs tests unitaires. Nous allons aussi voir de meilleures façons de concevoir notre code de production ainsi qu'une stratégie efficace de planifier le développement piloté par les tests.
Une base de données, pourquoi faire ? Le SQL, c’est quoi ce langage ? Un DBA, ça sert à quoi ? Cette session est là pour démystifier la base de données du point de vue des développeurs. Au programme : des bonnes pratiques, de la méthodologie, quelques tips techniques… De quoi rapprocher les développeurs et les DBA.
Le principe de la pensée objet se caractérise par la définition de chaque entité ayant une existence propre par ses propres caractéristiques avant même de penser quoi calculer ou programmer pour arriver au résultat ou sortie à afficher par notre programme, nous appelons cette entité Objet. Chaque Objet par exemple un Rectangle est définit tel que nous le percevons dans son domaine des « Formes Géométriques » avec ses « propriétés » et ses « méthodes » le caractérisant. Nous compléterons sa définition en le reliant à d’autres objets du même domaine comme la forme Carre qui est un cas particulier d’un Rectangle.
Introduction à la partie technique de la formation Digitalent mise en place par l'équipe ECAM. Cette formation couvre l'impression 3D, la programmation et l'électronique embarquée.
Ce cours présente la notion de système embarqué temps-réel et comment il est possible de gérer cela au niveau software avec un Linux embarqué. Plusieurs solutions sont présentées : OS temps-réel, linux préemptif et support hardware. Enfin, le cours présente le PRU-ICSS, dont est dotée la BeagleBone Black, une unité de calcul spécialisée pour les applications temps réel. Le cours présente comment programmer le PRU et notamment comment compiler un code à sa destination à l'aide d'un langage d'assemblage.
Ce cours présente les principaux moyens de communications que l'on peut déployer au sein d'un système embarqué. Après un rappel sur les différents types de communication (série/parallèle, synchrone/asynchrone, half-duplex/full-duplex), le cours présente le port série ainsi que l'implémentation UART. Vient ensuite le bus USB et les deux modes en hôte ou périphérique. Après cela, le cours présente les protocoles I2C et puis SPI. Enfin, il termine avec le simple bus 1-Wire. Tous ces différents moyens de communication sont disponibles sur la BeagleBone Black et le cours illustre comment les manipuler à l'aide du Linux embarqué.
Ce cours présente la notion de système d'exploitation et en particulier les Linux embarqués qui sont spécialement conçus pour des systèmes embarqués de haut niveau avec des processeurs à usage général (GPP) comme unité de calcul principale. Il explique ensuite comment Linux embarqué démarre, quelles sont les différentes phases et modalités de stockage du système d'exploitation. Enfin, il présente la BeagleBone Black, ses caractéristiques et comment la programmer. Le cours conclut en expliquant la notion de driver de périphérique et comment ils sont conçus sous Linux à l'aide de fichiers.
Ce premier cours introduit la notion de système embarqué en commençant par en donner une définition. Il les caractérise ensuite sur base de plusieurs critères : type d'application, de fonction visé, taille, fiabilité, efficacité. Il présente ensuite plusieurs aspects hardware (unité de calcul, architecture matérielle, composants clés) et software (niveau de programmation, processus de développement). Enfin, il conclut en discutant sur ce qu'est un ingénieur en systèmes embarqués.
Présentation du projet de transmission numérique dans lequel les étudiants sont amenés, en équipes mixtes électroniciens - informaticiens, à développer une application qui, sur base de données collectées par des senseurs, propose une analyse de ces dernières pour fournir un service.
Ce second cours d'algorithmique présente des techniques utilisées en intelligence artificielle pour trouver une solution à un problème de recherche. La première partie définit un problème de recherche : état, action, arbre d'exécution, espace d'états, cout, objectif et formalisation. La deuxième partie présente plusieurs algorithmes de recherche : non informé (BFS, UCS, DFS, DLS, ID-DFS, BS), informé (BFS, A*) et avec adversaire (Minimax, Alpha-Beta Pruning). Enfin, la troisième partie présente deux librairies Python qui implémentent des algorithmes de recherche.
Ce cours introduit à l'intelligence artificielle. La première partie du cours présente et définit ce qu'est l'intelligence et décrit les notions d'agent rationnel et d'environnement et leurs propriétés. Ces deux concepts permettent d'offrir un cadre de réflexion sur l'intelligence. La fin de la première partie présente les neufs formes d'intelligence selon Howard Gardner. La seconde partie du cours présente et définit l'intelligence artificielle, initiée par Marvin Minsky et John McCarthy au MIT. Elle présente également le test de Turing, test permettant de déterminer si une machine peut penser. Cette partie se termine en présentant les six grands domaines de l'intelligence artificielle.
Ce cours présente la programmation fonctionnelle et montre comment il est possible de programmer avec ce paradigme en utilisant Python. La première partie présente la notion d'objet de type fonction, les fonctions lambda, le type callable et les closures. La deuxième partie présente les décorateur et montre comment ajouter du comportement à une fonction à l'aide d'un décorateur. La troisième partie présente les itérateurs et les générateurs qui, grâce à l'instruction yield, génère les données à la demande.
Ce cours est le premier en lien avec l'algorithmique présente les algorithmes et fonctions récursives ainsi que le type abstrait de données arbre. La première partie revient sur les notions de problème, algorithhme et spécification. La deuxième partie présente la récursion et de nombreux exemples. Enfin, la troisième partie présente le type abstrait de données arbre qui permet d'organiser des données de manière hiérarchique. Le cours se termine avec une introduction aux notions de backtracking et lookahead.
Ce deuxième cours aborde la programmation réseau, c'est-à-dire le développement d'applications avec plusieurs composants qui communiquent entre eux via la réseau. Après une rapide présentation des protocoles UDP et TCP, le cours aborde la notion de socket et présente le module Python de même nom. Le cours présente deux applications concrètes : une application de chat (basé sur UDP) et une application echo (basé sur TCP). Le cours se termine par la découverte de la notion de protocole de communication et de la définition du format des messages échangés.
Ce cours présente ce qu'est Internet et son fonctionnement. En partant de l'ordinateur personnel ou smartphone connectés en un réseau local, le cours remonte petit à petit vers le fournisseur d'accès et l'Internet complet. Le cours présente ensuite plusieurs protocoles qui assurent le bon fonctionnement d'Internet et des services qu'il permet d'offrir. Enfin, la dernière partie concerne l'internet des objets.
Ce cours introduit à la notion de type abstrait de données (TAD). On commence par y découvrir les principes de complexité temporelle et spatiale permettant d'analyser les performances d'une structure de données et d'algorithmes. Ensuite, le cours présente plusieurs TAD : la pile, la file, le deque et le vecteur. Enfin, il présente comment implémenter des TAD avec des structures chainées.
Ce cours concerne le polymorphisme, c'est-à-dire la capacité pour une variable de prendre plusieurs types de donnée durant le temps de sa vie. Le cours présente aussi la notion de classe abstraite et d'interface qui est une classe abstraite pure.
Dans ce cours, on découvre comment construire une interface graphique en Python en utilisant la librairie Tk. Après avoir vu les différents composants de base, ce cours présente la programmation évènementielle qui permet d'écrire du code qui réagit à des évènements comme le clic sur un bouton, par exemple.
Ce cours présente la notion d'héritage entre classes qui permet de construire une relation de type "is-a". On crée une sous-classe à partir d'une super-classe, pour en hériter une partie de ses membres. On peut ensuite y ajouter des membres spécifiques. Ce cours présente également la redéfinition de méthodes, et comment utiliser les modificateurs de visibilité des membres.
OCTO TALKS : 4 Tech Trends du Software Engineering.pdfOCTO Technology
En cette année 2024 qui s’annonce sous le signe de la complexité, avec :
- L’explosion de la Gen AI
-Un contexte socio-économique sous tensions
- De forts enjeux sur le Sustainable et la régulation IT
- Une archipélisation des lieux de travail post-Covid
Découvrez les Tech trends incontournables pour délivrer vos produits stratégiques.
L'IA connaît une croissance rapide et son intégration dans le domaine éducatif soulève de nombreuses questions. Aujourd'hui, nous explorerons comment les étudiants utilisent l'IA, les perceptions des enseignants à ce sujet, et les mesures possibles pour encadrer ces usages.
Constat Actuel
L'IA est de plus en plus présente dans notre quotidien, y compris dans l'éducation. Certaines universités, comme Science Po en janvier 2023, ont interdit l'utilisation de l'IA, tandis que d'autres, comme l'Université de Prague, la considèrent comme du plagiat. Cette diversité de positions souligne la nécessité urgente d'une réponse institutionnelle pour encadrer ces usages et prévenir les risques de triche et de plagiat.
Enquête Nationale
Pour mieux comprendre ces dynamiques, une enquête nationale intitulée "L'IA dans l'enseignement" a été réalisée. Les auteurs de cette enquête sont Le Sphynx (sondage) et Compilatio (fraude académique). Elle a été diffusée dans les universités de Lyon et d'Aix-Marseille entre le 21 juin et le 15 août 2023, touchant 1242 enseignants et 4443 étudiants. Les questionnaires, conçus pour étudier les usages de l'IA et les représentations de ces usages, abordaient des thèmes comme les craintes, les opportunités et l'acceptabilité.
Résultats de l'Enquête
Les résultats montrent que 55 % des étudiants utilisent l'IA de manière occasionnelle ou fréquente, contre 34 % des enseignants. Cependant, 88 % des enseignants pensent que leurs étudiants utilisent l'IA, ce qui pourrait indiquer une surestimation des usages. Les usages identifiés incluent la recherche d'informations et la rédaction de textes, bien que ces réponses ne puissent pas être cumulées dans les choix proposés.
Analyse Critique
Une analyse plus approfondie révèle que les enseignants peinent à percevoir les bénéfices de l'IA pour l'apprentissage, contrairement aux étudiants. La question de savoir si l'IA améliore les notes sans développer les compétences reste débattue. Est-ce un dopage académique ou une opportunité pour un apprentissage plus efficace ?
Acceptabilité et Éthique
L'enquête révèle que beaucoup d'étudiants jugent acceptable d'utiliser l'IA pour rédiger leurs devoirs, et même un quart des enseignants partagent cet avis. Cela pose des questions éthiques cruciales : copier-coller est-il tricher ? Utiliser l'IA sous supervision ou pour des traductions est-il acceptable ? La réponse n'est pas simple et nécessite un débat ouvert.
Propositions et Solutions
Pour encadrer ces usages, plusieurs solutions sont proposées. Plutôt que d'interdire l'IA, il est suggéré de fixer des règles pour une utilisation responsable. Des innovations pédagogiques peuvent également être explorées, comme la création de situations de concurrence professionnelle ou l'utilisation de détecteurs d'IA.
Conclusion
En conclusion, bien que l'étude présente des limites, elle souligne un besoin urgent de régulation. Une charte institutionnelle pourrait fournir un cadre pour une utilisation éthique.
Le Comptoir OCTO - Équipes infra et prod, ne ratez pas l'embarquement pour l'...OCTO Technology
par Claude Camus (Coach agile d'organisation @OCTO Technology) et Gilles Masy (Organizational Coach @OCTO Technology)
Les équipes infrastructure, sécurité, production, ou cloud, doivent consacrer du temps à la modernisation de leurs outils (automatisation, cloud, etc) et de leurs pratiques (DevOps, SRE, etc). Dans le même temps, elles doivent répondre à une avalanche croissante de demandes, tout en maintenant un niveau de qualité de service optimal.
Habitué des environnements développeurs, les transformations agiles négligent les particularités des équipes OPS. Lors de ce comptoir, nous vous partagerons notre proposition de valeur de l'agilité@OPS, qui embarquera vos équipes OPS en Classe Business (Agility), et leur fera dire : "nous ne reviendrons pas en arrière".
Le Comptoir OCTO - Qu’apporte l’analyse de cycle de vie lors d’un audit d’éco...OCTO Technology
Par Nicolas Bordier (Consultant numérique responsable @OCTO Technology) et Alaric Rougnon-Glasson (Sustainable Tech Consultant @OCTO Technology)
Sur un exemple très concret d’audit d’éco-conception de l’outil de bilan carbone C’Bilan développé par ICDC (Caisse des dépôts et consignations) nous allons expliquer en quoi l’ACV (analyse de cycle de vie) a été déterminante pour identifier les pistes d’actions pour réduire jusqu'à 82% de l’empreinte environnementale du service.
Vidéo Youtube : https://www.youtube.com/watch?v=7R8oL2P_DkU
Compte-rendu :
Ouvrez la porte ou prenez un mur (Agile Tour Genève 2024)Laurent Speyser
(Conférence dessinée)
Vous êtes certainement à l’origine, ou impliqué, dans un changement au sein de votre organisation. Et peut être que cela ne se passe pas aussi bien qu’attendu…
Depuis plusieurs années, je fais régulièrement le constat de l’échec de l’adoption de l’Agilité, et plus globalement de grands changements, dans les organisations. Je vais tenter de vous expliquer pourquoi ils suscitent peu d'adhésion, peu d’engagement, et ils ne tiennent pas dans le temps.
Heureusement, il existe un autre chemin. Pour l'emprunter il s'agira de cultiver l'invitation, l'intelligence collective , la mécanique des jeux, les rites de passages, .... afin que l'agilité prenne racine.
Vous repartirez de cette conférence en ayant pris du recul sur le changement tel qu‘il est généralement opéré aujourd’hui, et en ayant découvert (ou redécouvert) le seul guide valable à suivre, à mon sens, pour un changement authentique, durable, et respectueux des individus! Et en bonus, 2 ou 3 trucs pratiques!
PRESENTATION DE L'ACTIVE DIRECTORY SOUS WINDOWS SERVEUR.pptx
Qualité de code et bonnes pratiques
1. PO3T Programmation orientée objet
Séance 12
Qualité de code et
bonnes pratiques
Sébastien Combéfis, Quentin Lurkin mercredi 9 décembre 2015
2. Ce(tte) œuvre est mise à disposition selon les termes de la Licence Creative Commons
Attribution – Pas d’Utilisation Commerciale – Pas de Modification 4.0 International.
3. Rappels
Variable et méthode de classe
Instance de la classe Class
Partage d’information entre instances
Définition et utilisation de classe interne d’instance/de classe
Partage privé de this avec une autre instance
Modularité et structuration « horizontale »
Organisation de classes en packages
Définition et constitution d’un package de classes
Visibilité package
3
4. Objectifs
Évaluer la qualité d’un code
Définition et critères de qualité d’un code
Processus de refactoring
Bonnes pratiques en programmation orientée objet
Utilisation adéquate des classes et objets
Héritage versus composition
4
7. Qualité de code (2)
Nécessite d’évaluer la qualité d’un code
Utilisation de métrique et critères d’évaluation
Plusieurs types de qualité
Qualité du code (ou structurelle)
Manière avec laquelle une fonctionnalité est implémentée
Qualité logicielle (ou fonctionnelle)
Résultat final de la fonctionnalité
Qualité du code peut être mesurée automatiquement
Outils existants pour la plupart des langages de programmation
7
8. Métrique
Métrique permet de mesurer un certain aspect du code
Fournit une valeur chiffrée pour un critère mesuré
Ne pas se forcer à atteindre de bonnes valeurs des métriques
Course aux bonnes valeurs et comportement contre-productif
Un mauvais rapport doit être perçu comme un signal d’alarme
Le lecteur du rapport doit donc aller plus loin dans sa démarche
8
9. Métriques standards (1)
Complexité cyclomatique
Nombre de chemins linéaires possibles dans une fonction
SLOC (Source Line of Code)
Nombre de lignes de code du programme
Densité des commentaires (DC)
DC = CLOC / SLOC
Couverture de code
Proportion du code qui est couverte par des tests
9
10. Métriques standards (2)
Code dupliqué
Pourcentage de code dupliqué ou très similaire
Couplage afferent (Ca) ou efferent (Ce)
Nombre de références vers/depuis une classe
Instabilité (Ce / (Ce + Ca))
Niveau de résistance au changement (stable = difficile à changer)
10
11. Couplage
La classe Shape est très stable
Ca = 2, Ce = 0 et donc une instabilité de 0
Niveau d’abstraction élevé pour des classes très stables
Rapport entre types abstraits et autres types
Shape
Rectangle
Square
Circle
11
12. Autres critères (1)
Architecture
Maintenabilité, évolutivité, performance, pertinence
Style et lisibilité
Mise en page, indentation, structure, nommage...
Documentation technique
Pour qu’une personne extérieure puisse rentrer dans le code
Fiabilité
Nombre de défaillances rencontrées dans un laps de temps donné
12
13. Autres critères (2)
Portabilité
Capacité d’un logiciel à fonctionner sur des systèmes différents
Sécurité
Exigences en matière de sécurité dépendent du type de logiciel
Nombre de bugs
Nombre de problèmes perturbant l’usage normal du logiciel
13
14. KISS
Keep It Simple, Stupid
Il faut éviter de rendre les problèmes plus compliqués
Principe phare en ingénierie logicielle
“Many great problem solvers were not great coders,
but yet they produced great code !”
14
15. Refactoring (1)
Transformation de code qui préserve son comportement
“A change made to the internal structure of a software to
make it easier to understand and cheaper to modify without
changing its observable behaviour” — Martin Fowler
Objectifs
Rendre plus facile l’ajout de nouveau code
Améliorer le design du code existant
Mieux comprendre un code
Rendre le code moins ennuyeux
15
16. Refactoring (2)
Ne faire du refactoring que sur du code fonctionnel et testé
Permet d’améliorer la qualité du code
Utilisation de cycles TDD
Utiliser des tests unitaires pour se rassurer que rien n’a été altéré
Les problèmes de design proviennent de code...
...dupliqué
...pas clair
...compliqué
16
17. Programmation orientée objet
Il faut trouver et identifier des objets du monde réel
Plusieurs questions à se poser
Identifier l’objet et ses attributs
Déterminer ce qui peut être fait avec l’objet
Identifier ce que l’objet peut faire à d’autre objets
Déterminer ce qui sera visible de l’objet
Définir l’interface publique de l’objet
17
18. Abstraction
Créer une bonne abstraction de l’objet représenté
S’assurer que les détails d’implémentation soient bien cachés
L’abstraction doit former un tout cohérent et consistent
Le niveau d’abstraction doit être consistent
Abstraction — “Le fait de voir une opération complexe
sous une forme simplifiée”
18
19. Encapsulation
Minimiser l’accès aux classes et à leurs membres
Ne pas exposer les données de la classe
Ne pas exposer des détails d’implémentation
Diminuer au maximum le couplage entre classes
1 public class GradeReport
2 {
3 private Grade [] grades;
4
5 public double getGrade (String courseName) { /* ... */ }
6
7 private static class Grade { /* ... */ }
8 }
19
20. Membres d’une classe
Limiter le nombre de méthodes
Limiter les appels de méthodes directs et indirects
En général : limiter la collaboration avec d’autres classes
Law of Demeter (LoD)
Une méthode M d’un objet O ne peut invoquer que :
1 ses propres méthodes ;
2 les méthodes de ses paramètres ;
3 les méthodes des objets qu’elle instance ;
4 et les méthodes de ses objets composants.
20
21. Constructeur
Initialiser toutes les variables d’instance
Interdire la création d’instances avec un constructeur privé
Éviter les shallow copies des paramètres
1 public class BookStore
2 {
3 private Books [] books;
4
5 public BookStore (Books [] books)
6 {
7 this.books = books;
8 }
9 }
21
22. Pourquoi une classe ?
Modéliser un objet du monde réel
Modéliser des objets abstraits
Réduire ou isoler la complexité
Limiter les impacts lors de modifications
Cacher les données et détails d’implémentation
Faciliter la réutilisation de code
22
23. Composition ou héritage ? (1)
HAS-A
Une classe se compose à
partir d’autres
7 ± 2 (composants)
Surveillez le couplage
IS-A
Une classe est une
spécialisation d’une autre
6 (niveaux d’héritage)
Surveillez l’encapsulation
23
25. Principe de Substitution de Liskov
Liskov Substitution Principle (LSP)
Si q(x) est une propriété démontrable pour tout objet x de type T,
Alors q(y) est vraie pour tout objet y de type S
tel que S est un sous-type de T.
Principe qui définit ce qu’est un bon sous-type
Soit S un sous-type de T
Tout objet de type T peut être remplacé par un objet de type S
Pas d’altération des propriétés désirables du programme
25
26. Violation du LSP
Rectangle
Square
getWidth(), setWidth(w),
getHeight(), setHeight(h)
@post width et height
librement modifiables
@post width et height
doivent être égaux
Square ne peut pas être utilisé partout à la place de Rectangle
Redéfinition des mutateurs dans Square avec vérification
Violation de la postcondition des Rectangle
26
27. Cinq principes de l’OO
1 SRP — Single Responsibility Principle
Une classe = une responsabilité (éviter les god classes)
2 OCP — Open/Closed Principle
Entité software open pour l’extension, fermée pour la modification
3 LSP — Liskov Substitution Principle
Remplacement d’un objet d’un type par un autre d’un sous-type
4 ISP — Interface Segregation Principle
Plusieurs interfaces clients plutôt qu’une seule grosse
5 DIP — Dependency Inversion Principle
Module de haut niveau doit dépendre d’abstractions
27
29. Exemple 1
Il faut éviter un bloc vide pour l’instruction catch
Impossibilité de détecter si une erreur s’est produite
1 public static void main (String [] args)
2 {
3 for (int i = 0; i < 10; i++)
4 {
5 try
6 {
7 Thread.sleep (i * 100);
8 }
9 catch ( InterruptedException exception){}
10 }
11 }
29
30. Exception
Plusieurs types d’erreurs peuvent causer une exception
Bug
Mauvaise entrée utilisateur
Un problème n’étant pas un bug
Plusieurs réactions possibles suite à une exception
Informer l’utilisateur (recommandé)
Logguer le problème
Envoyer un e-mail à l’administrateur
30
31. Exemple 2
Il ne faut pas toujours réinventer la roue
Il faut exploiter au maximum les librairies existantes
1 public static void main (String [] args)
2 {
3 String [] tab = {"One", "Two", "Three", "Four",
4 "Five", "Six", "Eleven"};
5 String s = "[";
6
7 if (tab.length > 0)
8 {
9 s += tab [0];
10 }
11
12 for (int i = 1; i < tab.length; i++)
13 {
14 s += ", " + tab[i];
15 }
16
17 System.out.println (s + "]");
18 }
31
32. Exploiter la librairie standard
Il faut exploiter la librairie standard du language
Recèle de classes avec des méthodes utiles
Il existe également des librairies spécialisées
Boost pour C++, SciPy en Python, JUNG en Java...
1 public static void main (String [] args)
2 {
3 String [] tab = {"One", "Two", "Three", "Four",
4 "Five", "Six", "Eleven"};
5
6 String s = Arrays.toString (tab);
7
8 System.out.println (s);
9 }
32
33. Exemple 3
Attention aux calculs avec des nombres en précision finie
Il faut utiliser des objets spécialisés pour ces calculs
1 public static List <Double > change (double toPay , double givenMoney)
2 {
3 ArrayList <Double > back = new ArrayList <Double >();
4 double diff = givenMoney - toPay;
5 int i = coins.length - 1;
6
7 while (diff != 0)
8 {
9 while (i >= 0 && coins[i] <= diff)
10 {
11 back.add (coins[i]);
12 diff = diff - coins[i];
13 }
14 i = i - 1;
15 }
16
17 return Collections . unmodifiableList (back);
18 }
33
34. Classe BigDecimal (1)
Utiliser java.math.BigDecimal pour représenter de l’argent
Les BigDecimal sont des objets immuables
Utiliser le style d’arrondi ROUND_HALF_EVEN
Utiliser le constructeur BigDecimal (String)
Utiliser les types primitifs int ou long
≤ 9 chiffres : int, long ou BigDecimal
≤ 18 chiffres : long ou BigDecimal
> 18 chiffres : BigDecimal
34
35. Classe BigDecimal (2)
1 public static List <BigDecimal > change ( BigDecimal toPay ,
2 BigDecimal givenMoney)
3 {
4 ArrayList <BigDecimal > back = new ArrayList <BigDecimal >();
5 BigDecimal diff = givenMoney.subtract (toPay);
6 int i = coins.length - 1;
7
8 while (diff.compareTo ( BigDecimal .ZERO) != 0)
9 {
10 while (i >= 0 && coins[i]. compareTo (diff) <= 0)
11 {
12 back.add (coins[i]);
13 diff = diff.subtract (coins[i]);
14 }
15 i = i - 1;
16 }
17
18 return Collections . unmodifiableList (back);
19 }
35
36. Exemple 4
Fermeture et libération correcte des ressources
Par exemple lorsqu’on ouvre un fichier, ou un socket...
1 try
2 {
3 List <String > list = Arrays.asList ("1", "2", "3");
4 BufferedWriter writer = new BufferedWriter (new FileWriter ("file.txt"));
5
6 for (String data : list)
7 {
8 writer.write (data);
9 writer.newLine ();
10 }
11
12 writer.close ();
13 }
14 catch ( IOException exception)
15 {
16 System.err.println ("Erreur : " + exception.getMessage ());
17 }
36
37. Utilisation de finally
Instruction finally exécutée dans tous les cas
Créer une méthode et laisser remonter les erreurs d’E/S
1 public static void print (List <String > list , String path) throws IOException
2 {
3 try
4 {
5 List <String > list = Arrays.asList ("1", "2", "3");
6 BufferedWriter writer = new BufferedWriter (new FileWriter (path));
7
8 for (String data : list)
9 {
10 writer.write (data);
11 writer.newLine ();
12 }
13 }
14 finally
15 {
16 writer.close ();
17 }
18 }
37
38. Exemple 5
Énumérations pour un ensemble de valeurs possibles
Pour que le compilateur puisse contrôler les valeurs
1 public class VendingMachine
2 {
3 public static final double ONECENT = 0.01;
4 public static final double TWOCENTS = 0.02;
5 // ...
6
7 public void insert (double coin)
8 {
9 // ...
10 }
11
12 public static void main ( String [] args)
13 {
14 new VendingMachine ().insert (TWOCENTS);
15 }
16 }
38
40. Exemple 6
Prudence en utilisant l’héritage
Rédéfinir adéquatement les méthodes, songer à la composition
1 public class Point
2 {
3 private final int x, y;
4
5 public Point (int x, int y)
6 {
7 this.x = x;
8 this.y = y;
9 }
10 }
11
12 public class ColoredPoint extends Point
13 {
14 private final Color color;
15
16 public ColoredPoint (int x, int y, Color c)
17 {
18 super (x, y);
19 color = c;
20 }
21 }
40
41. Héritage
Il faut utiliser l’héritage avec prudence
Attention à la redéfinition de equals, compareTo...
Les constructeurs, readObject et clone ne devraient pas
appeler des méthodes pouvant être redéfinies
Empêcher la redéfinition avec final
Considérer la composition à la place de l’héritage
41