1. Livres et vidéos
  2. Architecture logicielle - Pour une approche organisationnelle, fonctionnelle et technique (2e édition)

Architecture logicielle Pour une approche organisationnelle, fonctionnelle et technique (2e édition)

  • Accès illimité 24h/24, 7J/7
  • Tous les livres en ligne, les vidéos et les cours enregistrés ENI
  • Plus de 10 nouveautés livres et vidéos chaque mois
  • Les nouveautés disponibles le jour de leur sortie
  • Accès 100% en ligne
  • En stock
  • Expédié en 24h00
  • Livraison à partir de 0,01 €
  • Version en ligne offerte
  • 1 h d'accès gratuit à tous nos livres et vidéos pour chaque commande
  • Accessible immédiatement
  • Version HTML
  • Accès illimité 24h/24, 7J/7

Présentation

Ce livre s'adresse aux DSI, chefs de projets, maîtres d'ouvrage, architectes, administrateurs ou développeurs ; il peut également intéresser les étudiants en informatique ou toute personne impliquée dans un projet logiciel exigeant. Tout au long du livre, l'auteur propose une approche didactique et accessible qui permet de donner au lecteur une vision claire de la dimension architecturale des systèmes informatiques.

Le livre révèle les liens tissés par les disciplines afférentes à la réalisation d'un projet logiciel d'envergure, agile et réactif. Il permet au lecteur de comprendre comment bâtir un système qui soit à la fois capable de répondre aux besoins du client, de réaliser les objectifs métiers de l'entreprise, tout en optimisant sa production, en facilitant sa maintenance, en s'intégrant aux infrastructures existantes, en rationalisant les coûts et en anticipant sa montée en charge.

Le lecteur progresse du niveau fonctionnel jusqu'à la technique pure. Il commence par appréhender les processus de développement les plus répandus, qu'ils soient agiles ou formels. Il découvre ensuite les techniques de recueil des exigences et d'élaboration des cas d'utilisation. Il aboutit enfin aux différents concepts d'architectures multi-tiers, distribuées, orientées services/messages et mobiles avant d'approfondir les tests automatisés, la modélisation, la conception orientée objet, la programmation fonctionnelle et les design patterns en passant par les bases de données NoSQL.

Cette deuxième édition s'enrichit de trois nouveaux chapitres couvrant les briques fondamentales du Big Data, tant au niveau des modes de stockage distribués que des techniques de traitements massivement parallèles, les principes de λ-Architecture et le design d'applications réactives grâce à la programmation fonctionnelle.


Les chapitres du livre :
Avant-propos – Ingénierie pilotée par les modèles – Approche processus – Méthodes agiles – Spécifications – Cas d'utilisation – Test et assurance qualité – Architectures d'application – Architectures d'intégration – Conception orientée objet – Stockages distribués – Traitements et architectures distribués – Modélisation – Design patterns – Programmation fonctionnelle – Boîte à outils – Bibliographie

Table des matières

  • Avant-propos
    • 1. Objectifs
    • 2. Public visé
    • 3. Organisation de l’ouvrage
  • Ingénierie pilotée par les modèles
    • 1. Sémantique introductive
      • 1.1 Designer
      • 1.2 Finitude
      • 1.3 Conjectures
    • 2. Architecture logicielle
      • 2.1 Architecte
      • 2.2 Points clés d’une architecture
      • 2.3 Challenges
      • 2.4 Agilité
      • 2.5 Spécification
        • 2.5.1 Le System Architecture Document (SAD)
        • 2.5.2 Le Guide de design des composants
        • 2.5.3 Le Prototype architectural
        • 2.5.4 Le Modèle
      • 2.6 Workflow
        • 2.6.1 Spécification des exigences
        • 2.6.2 Analyse architecturale
        • 2.6.3 Design architectural
        • 2.6.4 Design orienté objet
    • 3. Architecture pilotée par les modèles (MDA)
      • 3.1 Fondations
        • 3.1.1 MOF
        • 3.1.2 XMI
        • 3.1.3 UML
        • 3.1.4 OCL
      • 3.2 Architecture MDA
        • 3.2.1 Cycle de vie du développement
        • 3.2.2 Modèle indépendant de la plateforme (PIM)
        • 3.2.3 Modèle spécifique à la plateforme (PSM)
        • 3.2.4 Code
      • 3.3 Exemple
        • 3.3.1 PIM
        • 3.3.2 PSM base de données
        • 3.3.3 PSM Java
        • 3.3.4 Code
      • 3.4 Conclusion
  • Approche processus
    • 1. Management
      • 1.1 Arborescence
      • 1.2 Machine à café
      • 1.3 Organisation
      • 1.4 Kanban
      • 1.5 PMBOK
    • 2. Processus
      • 2.1 Manifeste
      • 2.2 Cycle vertueux
      • 2.3 Qualité
      • 2.4 Classification
      • 2.5 Choix cornélien
    • 3. Maturité
    • 4. Épistémologie
      • 4.1 Le formalisme libère !
      • 4.2 Waterfall
      • 4.3 Prototype
      • 4.4 Spirale
      • 4.5 Itération
      • 4.6 SADD
    • 5. Agilité
      • 5.1 Manifeste Agile
      • 5.2 Principes
      • 5.3 Gourous
      • 5.4 Le grand mix
      • 5.5 Détracteurs
  • Méthodes agiles
    • 1. Extreme Programming
      • 1.1 Quatre valeurs
      • 1.2 Douze pratiques
        • 1.2.1 Développement piloté par les tests (TDD)
        • 1.2.2 Le jeu du planning
        • 1.2.3 Client dans l’équipe
        • 1.2.4 Petites livraisons
        • 1.2.5 Usage des métaphores
        • 1.2.6 Design simple
        • 1.2.7 Refactorisation à outrance
        • 1.2.8 Propriété collective
        • 1.2.9 Programmation par binômes
        • 1.2.10 Intégration continue
        • 1.2.11 Rythme de travail raisonnable
        • 1.2.12 Conventions de nommage
      • 1.3 Particularités
        • 1.3.1 Humanisme
        • 1.3.2 Vélocité
        • 1.3.3 YAGNI
        • 1.3.4 Espace
      • 1.4 Conclusion
        • 1.4.1 Architecture émergente
        • 1.4.2 Exosquelette
        • 1.4.3 Entropie
    • 2. Scrum
      • 2.1 Concept
      • 2.2 Processus
      • 2.3 Rôles
        • 2.3.1 Product Owner
        • 2.3.2 Team
        • 2.3.3 Scrum Master
      • 2.4 Backlog
      • 2.5 Sprint Planning
      • 2.6 Daily Scrum
      • 2.7 Burndown Chart
      • 2.8 Bénéfices
      • 2.9 Questions socratiques
      • 2.10 Tour d’ivoire
    • 3. Processus Unifié Ouvert (Open UP)
      • 3.1 Rational Unified Process (RUP)
      • 3.2 Open UP
      • 3.3 Principes
      • 3.4 Organisation
        • 3.4.1 Zone de contenu
        • 3.4.2 Rôles
      • 3.5 Cycle de vie du projet
        • 3.5.1 Inception
        • 3.5.2 Élaboration
        • 3.5.3 Construction
        • 3.5.4 Transition
      • 3.6 Itérations
  • Spécifications
    • 1. Exigences
      • 1.1 Formulations
        • 1.1.1 Café
        • 1.1.2 Code
        • 1.1.3 Tests
        • 1.1.4 Modèle
        • 1.1.5 Backlog
        • 1.1.6 Documents
      • 1.2 Les parties prenantes
      • 1.3 Typologie des exigences
        • 1.3.1 Fonctionnalité
        • 1.3.2 Exigences fonctionnelles
        • 1.3.3 Cas d’utilisation
        • 1.3.4 Prototype
      • 1.4 Exigences non fonctionnelles
        • 1.4.1 Disponibilité
        • 1.4.2 Fiabilité
        • 1.4.3 Souplesse
        • 1.4.4 Flexibilité
        • 1.4.5 Performance
        • 1.4.6 Montée en charge
        • 1.4.7 Réutilisation
        • 1.4.8 Sécurité
    • 2. Ingénierie
      • 2.1 Capture
      • 2.2 Analyse
      • 2.3 Documentation
      • 2.4 Validation
      • 2.5 Gestion
    • 3. Vision
      • 3.1 Exigences d’entreprise
        • 3.1.1 Fondements
        • 3.1.2 Opportunité commerciale
        • 3.1.3 Objectifs commerciaux et critères de succès
        • 3.1.4 Besoins clients
        • 3.1.5 Risques métier
      • 3.2 Vision de la solution
        • 3.2.1 Énoncé de la vision
        • 3.2.2 Fonctionnalités majeures
        • 3.2.3 Hypothèses et dépendances
        • 3.2.4 Périmètre et limitations
        • 3.2.5 Périmètre de la version initiale
        • 3.2.6 Périmètre des versions ultérieures
        • 3.2.7 Limitations et exclusions
      • 3.3 Contexte métier
        • 3.3.1 Profil des parties prenantes
        • 3.3.2 Priorités du projet
        • 3.3.3 Environnement d’exécution
    • 4. Spécification
      • 4.1 Introduction
        • 4.1.1 Intention
        • 4.1.2 Conventions
        • 4.1.3 Audience
        • 4.1.4 Cadre du projet
        • 4.1.5 Références
      • 4.2 Description générale
        • 4.2.1 Perspective du produit
        • 4.2.2 Fonctionnalités du produit
        • 4.2.3 Classes d’utilisateurs
        • 4.2.4 Environnement opérationnel
        • 4.2.5 Contraintes de design et d’implémentation
        • 4.2.6 Documentation utilisateur
        • 4.2.7 Hypothèses et dépendances
      • 4.3 Fonctionnalités du système
      • 4.4 Exigences des interfaces externes
        • 4.4.1 Interfaces utilisateur
        • 4.4.2 Interfaces matérielles
        • 4.4.3 Interfaces logicielles
        • 4.4.4 Interfaces de communication
        • 4.4.5 Exigences non fonctionnelles
      • 4.5 Appendices
    • 5. Modélisation
      • 5.1 Modèle fonctionnel
        • 5.1.1 Exigences
        • 5.1.2 Reporting
        • 5.1.3 Diagrammes d’exigences
        • 5.1.4 Diagrammes de cas d’utilisation
      • 5.2 Gestion du changement
        • 5.2.1 Traçabilité
        • 5.2.2 Matrice
  • Cas d’utilisation
    • 1. Histoires d’usage
      • 1.1 Historique
      • 1.2 Terminologie
        • 1.2.1 Acteur
        • 1.2.2 Scénario
        • 1.2.3 Étape
      • 1.3 Formalisme
        • 1.3.1 Tout habillé
        • 1.3.2 Relaxe
      • 1.4 Rédaction
      • 1.5 Erreurs classiques
    • 2. Diagrammes
    • 3. Use Case points
      • 3.1 Pourquoi l’utiliser ?
      • 3.2 Adoption
      • 3.3 Auteurs
      • 3.4 Méthode de Karner
    • 4. Étude de cas
      • 4.1 Exigences
      • 4.2 Cas d’utilisation
        • 4.2.1 Version intégrale
        • 4.2.2 Version allégée
      • 4.3 Modèle UML
      • 4.4 Estimation de coûts
        • 4.4.1 Estimation
        • 4.4.2 Conclusion
  • Test et assurance qualité
    • 1. Contexte
      • 1.1 Utilisation
        • 1.1.1 Agilité
        • 1.1.2 Refactorisation
        • 1.1.3 Intégration continue
      • 1.2 Granularité
        • 1.2.1 Tests d’acceptance
        • 1.2.2 Tests unitaires
      • 1.3 Plan de test
        • 1.3.1 Smoke testing
        • 1.3.2 Positive/Negative testing
        • 1.3.3 Performance testing
        • 1.3.4 Stress testing
      • 1.4 Testabilité
        • 1.4.1 Membres statiques
        • 1.4.2 Encapsulation
        • 1.4.3 Non-MVC
        • 1.4.4 IOC
        • 1.4.5 Factory
    • 2. Outils
      • 2.1 JUnit
      • 2.2 JMeter
      • 2.3 Code coverage
    • 3. Techniques
      • 3.1 Boîte noire
        • 3.1.1 Exemple
        • 3.1.2 Corollaire de Gödel
      • 3.2 Boîte blanche
      • 3.3 Tests d’interface
      • 3.4 Mock object
  • Architectures d’application
    • 1. Principes d’architecture
    • 2. Couches
      • 2.1 Présentation
      • 2.2 Logique métier
      • 2.3 Accès aux données
    • 3. Tier
      • 3.1 Monolithique
        • 3.1.1 Mise à jour automatique
        • 3.1.2 Compatibilité
        • 3.1.3 Business model
      • 3.2 Le deuxième tier
      • 3.3 Architectures n-tier
        • 3.3.1 Schéma conceptuel
        • 3.3.2 Avantages
        • 3.3.3 Linéarité
        • 3.3.4 Client léger
        • 3.3.5 Middle-tier
    • 4. MVC
      • 4.1 Bénéfices
      • 4.2 Workflow
      • 4.3 Différences
    • 5. Applications mobiles
      • 5.1 Développement natif
      • 5.2 Application web
      • 5.3 Approche hybride
    • 6. Exemple
      • 6.1 Architecture
        • 6.1.1 3-tier
        • 6.1.2 Modèle MVC
      • 6.2 Implémentation
        • 6.2.1 Vue
        • 6.2.2 Contrôleur
        • 6.2.3 Modèle
      • 6.3 Conclusion
  • Architectures d’intégration
    • 1. Paysage IT
      • 1.1 Évolution des SI
      • 1.2 Les limites de l’objet
    • 2. Architecture orientée services (SOA)
      • 2.1 Le concept de service
      • 2.2 Vue d’ensemble
      • 2.3 Service
        • 2.3.1 Contrat
        • 2.3.2 Interface
        • 2.3.3 Implémentation
        • 2.3.4 Logique métier
        • 2.3.5 Données
      • 2.4 Bus de services
        • 2.4.1 Journalisation
        • 2.4.2 Sécurité
        • 2.4.3 Transaction
      • 2.5 Dépôt de services
        • 2.5.1 Utilité
        • 2.5.2 Liaison
      • 2.6 Application front-end
    • 3. Technologies
      • 3.1 Systèmes distribués
        • 3.1.1 Objets distribués (ORB)
        • 3.1.2 Middleware orienté messages (MOM)
        • 3.1.3 Serveurs d’application
      • 3.2 Services web
        • 3.2.1 WSDL
        • 3.2.2 SOAP
        • 3.2.3 UDDI
        • 3.2.4 BPMN
        • 3.2.5 BPEL
      • 3.3 RESTful web services
        • 3.3.1 REST
        • 3.3.2 WADL
      • 3.4 Stubs et Dispatcher
        • 3.4.1 Top/Down
        • 3.4.2 Bottom/Up
        • 3.4.3 MDA
  • Conception orientée objet
    • 1. L’avènement des objets
      • 1.1 Quelles sont les différences ?
      • 1.2 Complexité
        • 1.2.1 Modularité
        • 1.2.2 Abstraction
        • 1.2.3 Polymorphisme
      • 1.3 Entropie
    • 2. Principes élémentaires
      • 2.1 Encapsulation
        • 2.1.1 Comment l'appliquer ?
        • 2.1.2 Exemple
      • 2.2 Cohésion
      • 2.3 Couplage
    • 3. Principes avancés
      • 3.1 Responsabilité unique (SRP)
        • 3.1.1 Comment l'appliquer ?
        • 3.1.2 Exemple
      • 3.2 Ouverture/fermeture (OCP)
        • 3.2.1 Comment l'appliquer ?
        • 3.2.2 Exemple 1
        • 3.2.3 Exemple 2
      • 3.3 Substitution de Liskov (LSP)
      • 3.4 Ségrégation d’interfaces (ISP)
      • 3.5 Inversion de dépendances (DIP)
      • 3.6 Inversion de contrôle (IOC)
        • 3.6.1 Service locator
        • 3.6.2 Injection par container
    • 4. Conclusion
  • Stockages distribués
    • 1. Introduction
    • 2. Big Data et scalabilité
      • 2.1 Les enjeux
      • 2.2 Les nouveaux métiers
      • 2.3 Les cas d’usage
        • 2.3.1 Modélisation des risques
        • 2.3.2 Analyse de la perte des clients (churn)
        • 2.3.3 Moteur de recommandations
        • 2.3.4 Ciblage publicitaire
        • 2.3.5 Prédiction de pannes par analyse réseau
        • 2.3.6 Détection de fraudes
        • 2.3.7 Recherche
        • 2.3.8 Bac à sable
      • 2.4 Les distributions
      • 2.5 Les grands acteurs
    • 3. Hadoop et le Big Data
      • 3.1 HDFS : un système de fichiers distribué
        • 3.1.1 Architecture HDFS
        • 3.1.2 Réplication des données
      • 3.2 Paradigme MapReduce
      • 3.3 Orchestration des jobs avec YARN
      • 3.4 Un exemple en Java
    • 4. Stockages NoSQL
      • 4.1 NoSQL ou la fin des formes normales
      • 4.2 Schémas et formats de sérialisation
        • 4.2.1 Protocoles d’échange de données
        • 4.2.2 Apache Parquet
      • 4.3 HBase, une base de données clé/valeur orientée colonnes
      • 4.4 Lucene et les moteurs de recherche
        • 4.4.1 Les annuaires inversés
        • 4.4.2 Le sharding pattern
      • 4.5 Bases de données orientées graphes
        • 4.5.1 Que peut-on faire avec des graphes ?
        • 4.5.2 Quid des performances ?
  • Traitements et architectures distribués
    • 1. Introduction
    • 2. Écosystème Hadoop
      • 2.1 Acquisition des données
        • 2.1.1 Sqoop
        • 2.1.2 Flume
        • 2.1.3 Storm
        • 2.1.4 Kafka
      • 2.2 Traitements
        • 2.2.1 Pig
        • 2.2.2 Hive
      • 2.3 Traitements itératifs avec Spark
        • 2.3.1 Faiblesses d'Hadoop
        • 2.3.2 Jeux de données résilients et distribués (RDD)
        • 2.3.3 Modèle d’exécution
        • 2.3.4 MapReduce avec Spark
    • 3. ? -Architecture
      • 3.1 Principes et avantages
        • 3.1.1 Batch layer
        • 3.1.2 Realtime layer
        • 3.1.3 Serving layer
      • 3.2 Conclusions
      • 3.3 Pile technologique
      • 3.4 Architecture log-centric
        • 3.4.1 Concept de log
        • 3.4.2 Systèmes distribués
        • 3.4.3 Intégration des données
  • Modélisation
    • 1. MERISE
      • 1.1 Origine
      • 1.2 Cycle de vie
      • 1.3 Modèle conceptuel de données (MCD)
        • 1.3.1 Entités
        • 1.3.2 Associations
        • 1.3.3 Cardinalités
        • 1.3.4 Dimension
        • 1.3.5 Méthode
        • 1.3.6 Formes normales
      • 1.4 Modèle logique des données (MLD)
        • 1.4.1 Tables
        • 1.4.2 Relations n/m
        • 1.4.3 Relations 1/n
      • 1.5 Modèle physique des données (MPD)
    • 2. UML
      • 2.1 Modèles et vues
      • 2.2 Éléments
        • 2.2.1 Classe
        • 2.2.2 Interface
        • 2.2.3 Package
        • 2.2.4 Composant
        • 2.2.5 Nœud
        • 2.2.6 État
      • 2.3 Relations
        • 2.3.1 Types
        • 2.3.2 Multiplicité
      • 2.4 Notes et stéréotypes
      • 2.5 Diagrammes
        • 2.5.1 Diagramme de classes
        • 2.5.2 Diagramme de structure composite
        • 2.5.3 Diagramme de composants
        • 2.5.4 Diagramme de déploiement
        • 2.5.5 Diagramme d’objets
        • 2.5.6 Diagramme de packages
        • 2.5.7 Diagramme de profils
        • 2.5.8 Diagramme d’activité
        • 2.5.9 Diagramme de cas d’utilisation
        • 2.5.10 Machine à états
        • 2.5.11 Diagramme de timing
        • 2.5.12 Diagramme de séquence
        • 2.5.13 Diagramme de communication
        • 2.5.14 Diagramme global d’interaction
  • Design patterns
    • 1. Introduction
      • 1.1 Genèse
      • 1.2 Origine
      • 1.3 Définition
      • 1.4 Intérêt
      • 1.5 Formalisme
    • 2. Patterns
      • 2.1 Création
        • 2.1.1 Abstract Factory
        • 2.1.2 Builder
        • 2.1.3 Factory Method
        • 2.1.4 Prototype
        • 2.1.5 Singleton
      • 2.2 Structure
        • 2.2.1 Adapter
        • 2.2.2 Bridge
        • 2.2.3 Composite
        • 2.2.4 Decorator
        • 2.2.5 Facade
        • 2.2.6 Flyweight
        • 2.2.7 Proxy
      • 2.3 Comportement
        • 2.3.1 Chain of Responsibility
        • 2.3.2 Command
        • 2.3.3 Interpreter
        • 2.3.4 Iterator
        • 2.3.5 Mediator
        • 2.3.6 Memento
        • 2.3.7 Observer
        • 2.3.8 State
        • 2.3.9 Strategy
        • 2.3.10 Template Method
        • 2.3.11 Visitor
  • Programmation fonctionnelle
    • 1. Introduction
    • 2. Programmation fonctionnelle
      • 2.1 Brève introduction à Scala
        • 2.1.1 Mutable/Immutable
        • 2.1.2 Fonction
        • 2.1.3 Une classe simple
        • 2.1.4 Les collections
        • 2.1.5 Les itérations
        • 2.1.6 Fonctions récursives
        • 2.1.7 Petit script pour compter les mots dans un fichier
      • 2.2 Principes de programmation fonctionnelle
        • 2.2.1 Effets de bord
        • 2.2.2 Transparence référentielle et fonctions pures
        • 2.2.3 Des états immutables
        • 2.2.4 Options et pattern matching
        • 2.2.5 Boucles for-comprehension
        • 2.2.6 Fainéantise et structures infinies
    • 3. Théorie des catégories et design patterns
      • 3.1 Monoïdes
        • 3.1.1 Quelques exemples mathématiques simples
        • 3.1.2 Généralisation de la première équation : la fermeture
        • 3.1.3 Généralisation de la deuxième équation : l’associativité
        • 3.1.4 Généralisation de la troisième équation : l’élément neutre
        • 3.1.5 Récapitulatif
        • 3.1.6 Usage des monoïdes
        • 3.1.7 Définition théorique en Scala
      • 3.2 Monades
        • 3.2.1 Un exemple concret
        • 3.2.2 La monade Option[T]
        • 3.2.3 Utilisation fonctionnelle de la monade Option
        • 3.2.4 Travail sur les listes et les boucles for-comprehension
        • 3.2.5 Try[T] au secours des exceptions
        • 3.2.6 Définition théorique d’une monade
        • 3.2.7 Les lois des monades
    • 4. Systèmes réactifs
      • 4.1 Reactive manifesto
      • 4.2 Le modèle d'acteurs
        • 4.2.1 Concepts fondamentaux
        • 4.2.2 Un système d’acteurs
        • 4.2.3 Un exemple avec Akka
        • 4.2.4 Conclusion
  • Boîte à outils
    • 1. Métrologie
      • 1.1 Productivité
        • 1.1.1 Métriques d’ordre général
        • 1.1.2 Lignes de code (LOC)
      • 1.2 Qualité du design
        • 1.2.1 Complexité cyclomatique
        • 1.2.2 Couplage entre objets (CBO)
        • 1.2.3 Manque de cohésion des méthodes (LCOM)
      • 1.3 Qualité de service
        • 1.3.1 Durée moyenne de panne (MTTF)
        • 1.3.2 Défauts par ligne de code
      • 1.4 Exemple
        • 1.4.1 Classe à l’étude
        • 1.4.2 Résultats
    • 2. Outils CASE
      • 2.1 Références
        • 2.1.1 ArgoUML
        • 2.1.2 Rational software
        • 2.1.3 PowerAMC
        • 2.1.4 Objecteering
        • 2.1.5 Enterprise Architect
      • 2.2 Génie logiciel
        • 2.2.1 Génération de code
        • 2.2.2 Reverse engineering
        • 2.2.3 Synchronisation
      • 2.3 Documentation
      • 2.4 Analyse d’exécution
    • 3. Traité d’esthétisme
      • 3.1 Théorie constructale
      • 3.2 Le nombre d’or
      • 3.3 Émergence
    • Bibliographie
    • Index

Auteur

Thomas BAILETEn savoir plus

Thomas BAILET est consultant en Architecture Logicielle. Mathématicien diplômé de l'université de Toulouse, il a effectué une carrière professionnelle dans le génie logiciel auprès de grandes entreprises dans le domaine de la micro-électronique comme Motorola, au sein de sociétés de service et de start-up innovantes. Il a fondé un studio de création multimédia, a participé à la conception de logiciels de synchronisation de données, d'applications mobiles et d'applications distribuées. Son expérience de l'élaboration de processus de développement agiles est riche. Il la partage à travers ce livre pour fournir au lecteur un manuel didactique qui expose de façon claire l'essentiel de l'architecture logicielle.

Caractéristiques

  • Niveau Initié à Confirmé
  • Nombre de pages 474 pages
  • Parution avril 2016
    • Livre (broché) - 17 x 21 cm
    • ISBN : 978-2-7460-9921-0
    • EAN : 9782746099210
    • Ref. ENI : DP2ARC
  • Niveau Initié à Confirmé
  • Parution avril 2016
    • HTML
    • ISBN : 978-2-409-00189-5
    • EAN : 9782409001895
    • Ref. ENI : LNDP2ARC