←

Dev back-end

Programmation

Objectifs

  • Connaître les fondamentaux de la programmation

La mémoire applicative

La mémoire applicative est volatile. L'application peut être interrompue et relancée à tout instant.

Le tas et la pile

Ce sont 2 espaces memoire:
  • Le stack (la pile) est utilisé entre autre pour les variables dites "automatique", en gros les variables dont on connais toutes les informations (type, taille) à la compilation.
  • Le heap (le tas) est utilisé pour les variables dites "dynamique", soit les variables dont on ne connais les informations qu'a l'execution.
Code Stack Heap public void main() { int age = 5; age=5 string name = 'Anaé'; name='Anaé' Person p = new Person(name, age); allocate Person('Anaé',5) p=ref(Person) }

Gestion de la mémoire

Allocation de la mémoire

Le callback (fonction de rappel)

// test de parité
function isEven(num){
  return num%2 == 0;
}
var evens = [0,1,2,3,4,5,6,7,8,9,10].filter(isEven);
console.log(evens);
  • filter attends une fonction de rappel
  • Cette fonction doit retourner vrai (garder) au faux (omettre) pour filter les éléments d'un tableau
  • Ici elle est appelée pour chacun des éléments du tableau
// Exemple d'implémentation
Array.prototype.filter = function filter(shouldBeKept){
  var result = []
  for(var i = 0; i < this.length; i++) {
    var iValue = this[i]
    if (shouldBeKept(iValue)) {
      result.push(iValue)
    }
  }
  return result
}
var evens = [0,1,2,3,4,5,6,7,8,9,10].filter(num => num%2 == 0);
console.log(evens);
  • shouldBeKept est la fonction de callback
  • Dans une fonction de prototype, this est l'objet sur lequel on applique la méthode

Closures (fermetures)

https://developer.mozilla.org/fr/docs/Web/JavaScript/Closures

Cache et invalidation de cache

There are only two hard things in Computer Science: cache invalidation and naming things.
—Phil Karlton
Il n'y a que 2 choses difficiles en informatique, l'invalidation de cache et nommer les choses.

Mettre en cache

Mettre en cache consiste à stocker une données calculée en mémoire pour pouvoir la relire sans la recalculer dans le but d'améliorer les performances de l'application.

Le danger

Le danger du cache: Lorsqu'une des données utilisée pour le calcul change, alors le cache devient obsolète et il doit être recalculé.

Invalidation

L'idée générale consiste à mettre en place une mécanique d'invalidation du cache lorsqu'on détecte son obsolescence.

Le cache invalidé pourra être recalculé :
  • à sa prochaine tentative de lecture
    • intéressant si la donnée a peu de chance d'être relue, si l'invalidation est provoquée par une action humaine, ou s'il y a beaucoup de caches à recalculer (ce qui peut être très long à faire en une seule fois et peut bloquer des ressources matérielles).
  • dès l'invalidation
    • permet d'accélérer l'accès des prochains utilisateurs. C'est utile lorsque l'invalidation est provoquée de manière automatique par un robot (et non par un utilisateur humain), de sorte que l'expérience utilisateur soit la meilleure possible.
Parfois le cache doit être invalidé et réutilisé immédiatement, Il n'y a alors aucune différence entre les 2 approches.

Stratégies d'invalidation

  • Automatiser le recalcul du cache lors d'une mise à jour d'une donnée source, il s'agit de Programmation réactive.
  • Invalider après une date d'expiration.
    • Ex: Une donnée pour laquelle une mise à jour légèrement différée n'est pas génantes.
  • Invalider manuellement.
    • Lorsque le développeur maitrise le moment où l'obsolescence est créée.

Emplacement du cache

On surveillera :
  • Les variables persistantes dans la durée (static, singletons, variables de classe)
  • Les fichiers temporaires ou fichiers de cache (ex: rendus html exportés en fichier)
  • Toutes les données calculées à partir d'une autre source

Pour toute donnée calculée il est important de connaître exhaustivement ses sources. Sinon l'invalidation n'est plus possible et on peut se retrouver avec des bugs de données incohérentes.

Nommer les choses

There are only two hard things in Computer Science: cache invalidation and naming things.
—Phil Karlton
Il n'y a que 2 choses difficiles en informatique, l'invalidation de cache et nommer les choses.
  • Utiliser un nommage ennuyeux, simple. Le stagiaire doit comprendre.
  • Doit exprimer le but, l'objectif et comment il est utilisée.
  • Être aussi précis et lisible que possible.
  • Être cohérent, discuter des règles en équipe.
  • Classe: Décrire sa responsabilité (découper la classe si plusieurs responsabilités).
  • Fonction: Utiliser un verbe d'action (découper si plusieurs fontions).
  • Ne pas répéter l'arborescence (ex: form/Login, form/LoginForm.
  • Eviter les accronymes et les contractions
  • Eviter le type (ex: birthdayDate, birthdayStr => birthday)
  • Utiliser l'anglais.