En raison d’une maintenance technique, la boutique Editions ENI sera inaccessible ce mercredi soir à compter de 21h, jusqu’à 2h jeudi matin. Nous vous invitons à passer votre commande avant 20h30. Merci pour votre compréhension. L’équipe des Editions ENI
  1. Livres et vidéos
  2. Développement et architecture des Applications Web Modernes - Retrouver les fondamentaux

Développement et architecture des Applications Web Modernes Retrouver les fondamentaux

  • En stock
  • Expédié en 24h00
  • Livraison à partir de 0,01 €
  • Version en ligne offerte pendant 1 an
  • 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
  • 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

Présentation

Préface de Hubert Sablonnière - Développeur et conférencier spécialiste du Web
Postface de Wassim Chegham - Sr. JavaScript Developer Advocate Engineer chez Microsoft


Les années 2010 ont bouleversé à jamais le développement web. HTML5, ECMAScript 6, les Web Components et de nombreuses nouvelles capacités permettent enfin de créer nativement des applications ambitieuses et performantes. Pourtant, l'ensemble du secteur donne aujourd'hui l'impression de se résumer à un trio Angular-React-Vue.

Un courant de développement web moderne questionne l'importance de ces frameworks et bibliothèques en s’appuyant sur les innovations les plus récentes. Pourquoi avoir ajouté tant de complexité ? Devrions-nous persévérer dans cette direction ? Les capacités natives de la plateforme ne pourraient-elles pas suffire ?

S'inscrivant dans la continuité de ce mouvement, ce livre permet à chacun, du développeur web débutant (disposant d'une première expérience de JavaScript et HTML), à l'architecte le plus confirmé, d'adopter une plus large perspective du développement applicatif web, en trois étapes. En décomposant les bases communes à toute application web moderne, ce livre expose une approche originale permettant d'appréhender le développement web moderne dans son ensemble.

Dans les deux premiers chapitres, l'auteur revient tout d'abord sur l'histoire et l'organisation du Web (et ses standards) ainsi que sur les navigateurs, permettant ainsi au lecteur de mieux comprendre la situation actuelle et d'anticiper les évolutions futures.

Les quatre chapitres qui suivent, constituant le cœur de l'ouvrage, présentent pas-à-pas et à l'aide d'exemples actuels et concrets, les éléments les plus fondamentaux du développement applicatif : la programmation orientée composant, les Web Components, le routage des applications monopages et enfin le rendering.

Pour finir, un ultime chapitre répertorie et met en perspective les approches architecturales concrètes applicables au quotidien, illustrées par une présentation complète de nombreuses micro-bibliothèques.

Le code source des exemples du livre est disponible en téléchargement sur le site www.editions-eni.fr et des compléments sont disponibles sur le site de l’auteur fullweb.dev.

Table des matières

  • Introduction
    • 1. Pourquoi ce livre ?
      • 1.1 État des lieux
      • 1.2 Approche générale
      • 1.3 Modernité et minimalisme
      • 1.4 À qui s'adresse ce livre ?
    • 2. Contenu
      • 2.1 Déroulement
      • 2.2 Chapitres
      • 2.3 Conseils de lecture
  • Comprendre l’histoire du Web et de ses standards
    • 1. Être un "bon citoyen" du Web
    • 2. IETF, les réseaux et Internet
      • 2.1 Origines de la standardisation des réseaux
      • 2.2 Indépendance et internationalisation
      • 2.3 RFC : un fondamental de la collaboration
    • 3. Invention de l’hypertexte
      • 3.1 Modéliser la connaissance
      • 3.2 Première implémentation
    • 4. Origines du Web
    • 5. W3C, standardiser et promouvoir le Web
      • 5.1 Origines (1991-1997)
      • 5.2 Fonctionnement
      • 5.3 Organisation générale
      • 5.4 Préévaluation par la communauté
      • 5.5 Élaboration des recommandations
      • 5.6 Working groups
    • 6. WHATWG, HTML et DOM
      • 6.1 Critiques et dissensions au W3C
      • 6.2 Le Web comme plateforme de développement applicatif
      • 6.3 Ouverture et réconciliation
      • 6.4 Domaines d’autorité
      • 6.5 Développement continu
      • 6.6 Processus et hiérarchie
    • 7. TC39, de JavaScript à ECMAScript
      • 7.1 Première standardisation
      • 7.2 Évolutions de JavaScript
      • 7.3 Moderniser le développement web pour de bon
      • 7.4 Processus actuel
      • 7.5 Organisation
    • 8. Références
  • Suivre les évolutions de la plateforme
    • 1. Les précurseurs
      • 1.1 Les premiers navigateurs (1993-1994)
      • 1.2 Dynamiser le Web (1994-1995)
    • 2. De Netscape à Internet Explorer
      • 2.1 La première guerre des navigateurs (1995-2001)
      • 2.2 Naissance de Mozilla (1998-2004)
      • 2.3 Internet Explorer contre Firefox (2004-2010)
    • 3. Naissance de Chrome et de Safari
    • 4. L'entrée dans le Web moderne
      • 4.1 Le succès des smartphones (2011-2017)
      • 4.2 Le règne de Google (2017- ? )
      • 4.3 Situation actuelle (2021)
    • 5. À l’écoute des nouveaux standards
      • 5.1 L’inintelligibilité supposée des standards
      • 5.2 Trouver et suivre les propositions
    • 6. Progresser avec les navigateurs modernes
      • 6.1 Trois approches distinctes
      • 6.2 Google Chrome
      • 6.3 Apple Safari et WebKit
      • 6.4 Mozilla et Firefox
      • 6.5 Veille et montée en compétences
      • 6.6 Perspectives présentes et futures
    • 7. Références
  • Adopter une approche par composant
    • 1. Introduction à la programmation par composant
      • 1.1 Un cadre de référence nécessaire
      • 1.2 Niveau de complexité et réutilisabilité
      • 1.3 Qu’est-ce qu’un composant ?
      • 1.4 Définir un composant
      • 1.5 Les limites initiales du développement web
    • 2. Premières fondations pour le Web
      • 2.1 Les plug-ins
      • 2.2 Une seconde génération de frameworks
    • 3. Cas d’étude : AngularJS
    • 4. Liens avec une approche fonctionnelle
      • 4.1 Fonctions et réactivité
      • 4.2 Approche générale
      • 4.3 Représenter HTML dans JavaScript
      • 4.4 Problème du rendering
      • 4.5 Problème de la gestion d’état
      • 4.6 Vers un langage fonctionnel ?
    • 5. Naissance d’un standard
      • 5.1 Les prédécesseurs
      • 5.2 Première émergence des Web Components
      • 5.3 Introduction aux Web Components
      • 5.4 Anticiper et dépasser le standard
    • 6. Références
  • Faire bon usage des Web Components
    • 1. Introduction
    • 2. Étendre le vocabulaire HTML
      • 2.1 Définir un élément personnalisé
      • 2.2 Éviter les conflits
      • 2.3 Utiliser un nom valide
      • 2.4 Créer une classe
      • 2.5 Afficher un message
      • 2.6 Créer un élément personnalisé programmatiquement
      • 2.7 Cycle de vie
      • 2.8 Support
    • 3. Créer et utiliser un arbre fantôme
      • 3.1 Notions fondamentales
      • 3.2 light DOM et shadow DOM
      • 3.3 Restreindre l’accès au shadom DOM
    • 4. Définir le style d’un Web Component
      • 4.1 Style externe
      • 4.2 Élément hôte
      • 4.3 Style par défaut de l’élément hôte
      • 4.4 Contexte
      • 4.5 Customisation
    • 5. Templates et composition
      • 5.1 <template>
      • 5.2 <slot> et composition
      • 5.3 Slots nommés
    • 6. Attributs et propriétés
      • 6.1 Principe : suivre la logique du standard HTML
      • 6.2 Mise en place d’un Web Component de démonstration
      • 6.3 Exposer l’état du composant
      • 6.4 Effectuer des actions simples
      • 6.5 Récupérer des valeurs primitives
      • 6.6 Réagir aux changements de valeur d’un attribut
      • 6.7 Manipuler des valeurs non primitives
      • 6.8 Charger des propriétés dynamiquement
    • 7. Limites des Web Components
    • 8. Références
  • Développer une application monopage
    • 1. Structure et objectifs
      • 1.1 Les défauts des sites web multipages
      • 1.2 Offrir une meilleure expérience utilisateur
      • 1.3 Architecture
    • 2. Principes essentiels du routage
    • 3. Manipuler l’URL du document
      • 3.1 L’interface Location
      • 3.2 Utiliser l’identificateur de fragment de l’URL
      • 3.3 Hash et historique
      • 3.4 L’interface History
      • 3.5 Compatibilité
      • 3.6 Réécriture des URL côté serveur
    • 4. Définir des routes
      • 4.1 Uniformiser le rendu dynamique
      • 4.2 Définir une collection de routes
      • 4.3 Définir une route par défaut
      • 4.4 Approche des principaux frameworks
    • 5. Transmettre des données
      • 5.1 Paramètres de route
      • 5.2 Paramètres d’URL
      • 5.3 Objets état associés à l’historique
    • 6. Navigation et changement de route
      • 6.1 Gestion globale
      • 6.2 Évènement popstate
    • 7. Au-delà du routage
      • 7.1 Modularité
      • 7.2 Limitations du routage
    • 8. Références
  • Afficher des données dynamiquement
    • 1. Optimiser le chargement initial
      • 1.1 Faire primer l’expérience utilisateur
      • 1.2 Capturer l’attention des utilisateurs
      • 1.3 Audit des performances du chargement initial
      • 1.4 Éviter les contenus bloquants
      • 1.5 Améliorer le chargement des scripts
      • 1.6 Accélérer l’affichage d’un texte
      • 1.7 Ne charger que les styles utiles
      • 1.8 Au-delà du simple chargement
    • 2. Comparer différentes approches
      • 2.1 Présentation de la solution employée
      • 2.2 Implémentation des tests de performance
      • 2.3 Est-il vraiment important de comparer les performances ?
    • 3. Bien utiliser la DOM API
      • 3.1 Créer un ensemble d’éléments
      • 3.2 Mettre à jour le contenu d’un élément
    • 4. Littéraux de gabarit et innerHTML
      • 4.1 Gérer les évènements
      • 4.2 Mettre à jour le contenu de l’élément
      • 4.3 Performances
    • 5. HyperScript
      • 5.1 Une bibliothèque, une fonction et une syntaxe
      • 5.2 HyperScript, React et les VDOM
      • 5.3 Syntaxes alternatives pour HyperScript
      • 5.4 Créer une fonction HyperScript
      • 5.5 Performances
    • 6. Minimiser les accès au DOM
      • 6.1 Identifier les responsabilités de chacun
      • 6.2 Fragments
      • 6.3 Mettre en cache les éléments
      • 6.4 Liens avec la programmation orientée composant
      • 6.5 Comparaison avec les littéraux de gabarits
      • 6.6 Mettre en cache un élément avec HyperScript
      • 6.7 Mettre en cache l’état
    • 7. Optimiser pour la répétition
      • 7.1 Optimiser la mise en cache des éléments avec cloneNode()
      • 7.2 Utiliser innerHTML pour améliorer la lisibilité
      • 7.3 Construire sa propre solution
      • 7.4 Performances
    • 8. Conclusion
    • 9. Références
  • Définir une architecture cohérente
    • 1. Comment faire "le bon choix" ?
      • 1.1 Déterminer l’approche optimale en fonction du contexte
      • 1.2 Trouver le bon équilibre entre abstraction et dette technique
    • 2. Vanilla Web et les microbibliothèques
      • 2.1 De Vanilla JS au modern Web
      • 2.2 Complexité et poids d’un code JavaScript
      • 2.3 Évolution d’une bibliothèque dans le temps
      • 2.4 Quand et pourquoi utiliser des microbibliothèques
      • 2.5 Aides à la manipulation du DOM
      • 2.6 Réalité du "Vanilla"
      • 2.7 RE:DOM
    • 3. Bibliothèques de rendering
      • 3.1 Principe des étiquettes de gabarits
      • 3.2 Bibliothèques de rendering utilisant les étiquettes de gabarits
      • 3.3 Naissance et évolution de lit-html
      • 3.4 Fonctionnement de lit-html
      • 3.5 Exemple d’application
      • 3.6 Les directives lit-html
      • 3.7 JSX face aux littéraux de gabarits
      • 3.8 React est-il vraiment une bibliothèque de rendering ?
    • 4. Modularité et programmation orientée composant
      • 4.1 Principes de lit-element
      • 4.2 Démarrer un projet avec lit-element
      • 4.3 web component par compilation avec Stencil
    • 5. Programmation réactive
      • 5.1 Notions fondamentales
      • 5.2 RxJS
      • 5.3 Observables et opérateurs
      • 5.4 Combiner des observables
      • 5.5 hot et cold observables
      • 5.6 Alternatives à RxJS
      • 5.7 Forces et faiblesses de la programmation réactive
    • 6. Gestion d’état
      • 6.1 Créer un conteneur d’état avec Redux
      • 6.2 Permettre à des composants de partager un état
      • 6.3 Rendre les composants indépendants de l'état global
    • 7. Routeurs
      • 7.1 Page.js
      • 7.2 Universal-router
    • 8. Frameworks
      • 8.1 Définition
      • 8.2 Microframeworks
      • 8.3 React, Vue et Angular : frameworks ou écosystèmes ?
      • 8.4 Metaframeworks
    • 9. Synthèse
      • 9.1 Vanilla JS et Vanilla Web : comment développer sans assistance ?
      • 9.2 Le modern Web face aux compilateurs et aux frameworks
    • 10. Références
  • Annexes
    • 1. Les bibliothèques, les frameworks et les outils
      • 1.1 Le rendering
        • 1.1.1 Les manipulations du DOM
        • 1.1.2 Les tagged template literals
        • 1.1.3 JSX et React
      • 1.2 La programmation orientée composant
      • 1.3 Le routage et la navigation
      • 1.4 La programmation réactive et les gestionnaires d’état
      • 1.5 Les frameworks
      • 1.6 Les outils de développement
      • 1.7 Les polyfills et les shims
    • 2. Groupes de travail du W3C
      • 2.1 Note à propos des abréviations
      • 2.2 Fondamentaux front-end
      • 2.3 Accessibilité (WAI)
      • 2.4 Web API
      • 2.5 Sémantique et données
      • 2.6 Divers
      • 2.7 Références
    • 3. Glossaire
    • 4. Principes fondamentaux de Chrome
      • 4.1 Multiprocessing
      • 4.2 V8, l’interpréteur JavaScript
      • 4.3 Expérience utilisateur
      • 4.4 Sécurité
      • 4.5 Gears, standards et open source

Auteur

Noël MACEEn savoir plus

Noël Macé nourrit depuis toujours une passion sans faille pour la pédagogie et l'innovation, qu'il transmet depuis onze ans lors des formations et conférences qu’il dispense. En 2014 il décide de faire du développement d'applications web sa spécialité, l'exerçant dans des contextes variés en tant que développeur, architecte logiciel, directeur technique et Developer Advocate. Depuis, il recherche ainsi systématiquement à identifier et transmettre les approches optimales pour les équipes de développements et les utilisateurs, recherche dont il expose dans ce livre les premières conclusions.

Caractéristiques

  • Nombre de pages 608 pages
  • Parution mars 2021
    • Livre (broché) - 17 x 21 cm
    • ISBN : 978-2-409-02952-3
    • EAN : 9782409029523
    • Ref. ENI : DPAWM
  • Parution mars 2021
    • HTML
    • ISBN : 978-2-409-02951-6
    • EAN : 9782409029516
    • Ref. ENI : LNDPAWM

Téléchargements

En complétant ce formulaire, vous acceptez d'être contacté afin de recevoir des informations sur nos produits et services ainsi que nos communications marketing. Vous aurez la possibilité de vous désabonner de nos communications à tout moment. Pour plus d'informations sur notre politique de protection des données, cliquez ici.
  • DPAWM (2 422 Ko)