---
# System prepended metadata

title: Tableau revision

---

| Name | Def | Why? | How? |
|------|-----|------|------|
| **Java** | Langage de programmation orienté objet multiplateforme. | typage fort, GC, gestion erreur et exception |JVM, JRE, JDK, API |
| **JVM** | Java Virtual Machine: environnement d'exécution pour des programmes Java, indépendant de la plateforme sous-jacente. | portabilité | Au niveau logiciel: ClassLoader, GC, moteur d'exécution, compilateur JIT(Just-In-Time). Convertit le code en instructions compréhensibles par l'OS. |
| **JRE** | Java Runtime Env.: exécuter du Java sans avoir besoin de développer ou de compiler le code source (code source compilé -> JVM) | Le kit JDK et l'environnement JRE interagissent l'un avec l'autre pour créer un environnement d'exécution durable |*JRE combine le code Java créé à l'aide du JDK avec les bibliothèques requises pour l'exécuter sur une JVM, puis crée une instance de cette JVM.* **ClassLoader**: charger et d'initialiser les classes. **Vérificateur de bytecode**: Le vérificateur de bytecode garantit le format et l'exactitude du code Java avant sa transmission à l'interpréteur. Si le code viole l'intégrité du système ou les droits d'accès, la classe est considérée comme endommagée et n'est pas chargée. **Interpréteur**: Une fois le bytecode chargé, l'interpréteur Java crée une instance de la machine virtuelle Java qui permet au programme Java d'être exécuté en natif sur la machine sous-jacente.|
|**JDK**|Java development kit, contient les libs, le compilateur, le débugger et la JVM|Le kit JDK et l'environnement JRE interagissent l'un avec l'autre pour créer un environnement d'exécution durable||
|**ClassLoader**|Charger et initialiser les classes pour préparer leur utilisation dans l'application.|l'environnement JRE utilise des ClassLoaders pour automatiser ce processus à la demande.| Voici ce que cela implique : **Chargement** : localiser et à charger le fichier binaire (.class) correspondant à la classe dans la mémoire.  **Vérification** : s'assurer qu'elle respecte les règles de sécurité et d'intégrité du langage Java: vérification de la structure de la classe, des dépendances et des autorisations d'accès. **Préparation** : l'espace mémoire est alloué pour les variables statiques de la classe, valeurs par défaut initialisées, et les constantes. **Résolution** : lier les références de la classe avec les méthodes, les variables correspondantes, les références vers d'autres classes, interfaces ou méthodes. **Initialisation** : exécution du bloc statique initial (s'il en existe un) et l'initialisation des variables statiques avec les valeurs spécifiées.|
|**JIT**|Le compilateur JIT (Just-In-Time) est un composant de l'environnement d'exécution qui améliore les performances des applications Java™ en compilant des bytecodes en code machine natif lors de l'exécution.| Obtenir un équilibre optimal entre temps de démarrage et performances à long terme.|Dans la pratique, les méthodes ne sont pas compilées lorsqu'elles sont appelées la première fois. Pour chaque méthode, la JVM tient à jour un décompte des appels, qui commence à un seuil prédéfini et est décrémenté à chaque nouvel appel de la méthode. Lorsque ce décompte arrive à zéro, une compilation JIT est déclenchée pour la méthode. |
| **GC**|Garbage Collector: automatise la gestion de la mémoire, Object is garbage when it can no longer be reached from any reference of any other live object in the running program.Bcp et tous differents.[Source](https://www.oracle.com/webfolder/technetwork/tutorials/obe/java/gc01/index.html) | éviter les fuites de mémoire et rendre le développement plus efficace en déchargeant les développeurs de la responsabilité de gérer manuellement la mémoire. | Allocation -> Mark -> Following -> Sweep. Types:**Serial**: Generational, single threaded, stop the world type of operation. **Parallel**: Same as Single threaded with multiple thread -> quicker. **CMS**: Multithreaded + conurrent. Simply put, applications using this type of GC respond slower on average, but don't stop responding to perform garbage collection. Deprecated as of JDK 9. **G1**: or Garbage First, since java 7, add compaction of old generation + Mixed collections + choose collections based on stats + remembered sets.|
|**Collection**| Implemente Iterator. Ensemble de classes et d'interfaces pour gérer des ensembles d'objets|  fournit une infrastructure solide et prête à l'emploi pour la manipulation et la gestion des collections d'objets. Réutilisation du code, Gestion simplifiée, Performance optimisées | List, Set, Queue |
|**List**|Une collection ordonnée(ou séquence). Contrôle précis sur l'endroit où chaque élément est inséré. Accéder aux éléments par leur index et rechercher des éléments.|allow duplication, typically pairs of elements e1 and e2 such that e1.equals(e2), and allow multiple null ||
|**ArrayList**|Resizable-array implementation of List.|**Performance**: faster access to elements by index. **Memory**: needs to allocate memory for a fixed-size array, even when not fully utilized. **Usage**: for fast access by index or mass operation|has an array whith a capacity>=size, management not specified in doc. Not synchronized, iterator is fail-fast -> throws if structural modification after iterator is created|
|**LinkedList**|Doubly-linked list implementation of the List and Deque interfaces.|**Performance**: faster insertion and deletion, especially at the beginning or end of the list. **Memory**: allocation only for each element and pointers. **Usage**: for fast insertion/deletion|has a doubly-linked list|
|**Set**|A collection that contains no duplicate elements(on the contract of equals()). At most 1 null(if accepted). Replicate mathematical set. __Edge cases__: cannot contain itself, undefined behavior for mutable object changing the equals | Efficient for .contains(), act as mathematical set with .addAll() .retainAll() .removeAll(). Best suited for collection of distinct element.||
|**HashSet**|Implementation of Set using hash table | offers constant time performance for the basic operations (add, remove, contains and size), assuming hash function disperses properly | Backed by a hashMap, not synchronized, iterator fail-fast|
|**LinkedHashSet**|HashSet avec pointeurs sur suivant et précédent
|**TreeSet**|Set->SortedSet->NavigableSet->TreeSet. Elements are ordered by natural ordering or comparator.|guaranteed log(n) time cost for the basic operations (add, remove and contains).|uses a self-balancing binary search tree called a Red-Black tree as its underlying data structure. modify structure to keep log height to its size (use coloration) |
|**Queue**|A collection designed for holding elements prior to processing.|jobqueue type of processing| queues provide additional insertion, extraction, and inspection operations. Each exists in two forms: one throws an exception if it fails, the other returns either null or false. Deque subinterface for double-end queue.| 
|**Map**|An object that maps keys to values. A map cannot contain duplicate keys; each key can map to at most one value. takes the place of the Dictionary class, which was a totally abstract class ||HashMap(hash table based, not sync), TreeMap(NavigableMap->SortedMap)|
|**Equals**|Indicates whether some other object is "equal to" this one.||equivalence relation on non-null object references: It is **reflexive**: for any non-null reference value x, x.equals(x) -> true. It is **symmetric**: for any non-null reference values x, y, x.equals(y) -> true <=> y.equals(x) -> true. It is **transitive**: for any non-null reference values x, y, and z, x.equals(y) -> true and y.equals(z) -> true then x.equals(z) -> true. It is **consistent**: if x.equals(y) -> true, it returns true every time, provided no information on modification of x or y. For any non-null x, **x.equals(null) -> false**.|
|**HashCode**|Returns a hash code value (int) for the object.|for the benefit of hash tables such as those provided by HashMap.| Should return every time for the same object(not necessarily between application execution). For any non-null reference values x and y, x.equals(y) -> true => x.hashCode() == y.hashCode() (x.hasCode() == y.hashCode() !=> x.equals(y) -> true).|
|**Piliers de POO**|Objet (et classe), Encapsulation, Abstraction, Polymorphisme, Héritage| La programmation par objet consiste à utiliser des techniques de programmation pour mettre en œuvre une conception basée sur les objets. Définition et interaction de briques logicielles appelées objets ; un objet représente un concept, une idée ou toute entité du monde physique. |**Objet**: Objet/Classe. **Héritage**: réutiliser les comportements dans les classes parents dans les classes enfants en les spécialisant. **Encapsulation**: private, protected, package, public -> cacher implementation, pour controle et + de sécurité. **Abstraction**: abstract class/interface, evite couplage, augmente coherence. **Polymorphisme**: Capacité de changer le comportement d'une méthode |
|**Coherence**|Une classe est cohérente lorsqu'elle ne peut pas être subdivisé en plusieurs classes| high cohesion is associated with robustness, reliability, reusability, and understandability whereas low cohesion is associated with low maintainability, hardly testable, difficult to reuse, and even difficult to understand.||
|**Couplage**|Classe dépendante d'autres classes(implémentation)| same as coherence | |
|**Polymorphisme**| **Héritage**: réécriture d’une méthode présente dans la classe parent pour les classes enfants. **Surcharge**: ou ad hoc, la même méthode peut avoir des paramètres différents et changer l'implémentation. **Généricité**: on utilise le même code avec des types de données différents.|progammation plus générique||
|**S.O.L.I.D**|Principe de conception: **Single Responsability**: Chaque brique logiciel doit avoir juste 1 responsabilité. **Open/Close Principle**: Open to extension and close to modification. **Liskov Substitution**: On doit pouvoir mettre une classe enfant dans la place de la classe parent dans une méthode et le code doit continuer à fonctionner. **Interface Segregation**: On doit séparer les grandes interfaces en plusieurs petites interfaces avec une fonctionnalité(augmenter la cohérence). **Dependency Inversion**: on priorise l'abstraction et non l'implementation|apporter une ligne directrice permettant le développement de logiciels plus fiables, plus robustes, plus maintenables, plus extensibles et plus testables||
|**Spring**| Simply put, the Spring framework provides comprehensive infrastructure support for developing Java applications. | Se concentrer sur le code metier plutot que le technique | en utilisant l’IoC à partir de DI.|
|**Framework x Librairie**|Une librairie possède des fonctions qu’on peut appeler. Un framework va definir la maniere d'ecrire ton code (peut contenir un runtime). |||
|**Inversion de contrôle**| Laisser le framework gérer le cycle de vie des objets/du programme using POJO(Plain Old Java Object) |||
|**Injection de dépendances**| On va injecter, pendant le Runtime, les morceaux de code sur les endroits annotées. Design pattern: Dependency injection is basically providing the dependencies of an object instead of having it constructed by themselve s. It's a very useful technique for testing, since it allows dependencies to be mocked or stubbed out.| prioriser abstraction, baisser le couplage, augmenter coherence||
|**AOP**| Aspect oriented programming: ex: lombok/spring.|Ajouter du comportement dans du code, sans changer le code en lui-même.|  Princips: **joinpoint**: endroit specifique dans l'app ou l'advice est exécuté. methods pour spring AOP. **pointcut**:(le où?) expression matching(regex) with joinpoints to know if advice executed or not. **advice**:(le quoi?) code rejouté + def du before/after/around. **aspect**: definition et configuration. **AOP Proxy**: create the Proxy classes with target classes and advice invocations. **Target Object**: Object on which advice are applied(, and proxied). **Weaving**: process of linking aspects with other objects to create the advised proxy objects.(Runtime-> Proxy(on peut court circuiter en appelant des methodes internes), Compile-> réécriture(Lombok), ClassLoadTime: ex:debugger)|
|**Bean**| Un objet instancié par Spring| Injection de dependance | Annotation bean : utilisé sur des méthodes, Annotation component : utilisé sur des classes, (Component, Service, Repository, Controller (+ Index))|
|**Spring's Scope**| **Singleton**(entityManager), **prototype**(Entity), Web's scopes: **request**(per request), **session**(per HTTP session), **application**(for the lifecycle of ServletContext), **websocket**(per WebSocket)|||
|**Servlet**|Ex:TomCat a un Srvlet qui reponds sur /\*\*, il a instantié des dispatcher servlet qui scannent les classes annotées @Controller|||
|**Spring MVC**|Spring MVC permet de construire des applications Web en Java. Comme son nom le suggère, il utilise le principe du Modèle/Vue/Contrôleur (MVC) en association avec le modèle IoC (Inversion of Control) du Spring Framework.||Au cœur de Spring MVC, on trouve la DispatcherServlet. Avec Spring MVC, il n’est pas nécessaire de créer des servlets puisque le framework la fournit déjà. Il faut le configurer dans le web.xml ou dans le code avec @EnableWebMvc.|
|**@Transactional**| Annotion chargé de s’assurer que les instructions dans la méthode se passent bien, si il y a >=1 erreur, il va faire un rollback.|| aspect with around advice. ACID(Atomique:,Cohérent:contraintes,Isolation: il faut pas que les modifications soient visibles avant le commit,Durable) |
|**Spring Boot**| Une extension de Spring qui fournit des fichiers de configuration et d'initialisation. Il possède aussi des packages de dépendance qui sont compatibles entre eux. Exemple de starter: Starter web, spring data jpa, starter test, security.| convention over configuration. Se concentrer sur le code métier plutot que le boilerplate. | API Conditionnal (TODO: recherche fonctionnement) |
|**Framework Condition(al)**|Au runtime.Regarde ce qu'il y a dans le classloader pour appliquer la configuration qui ait le plus de sens possible|||
|**REST**|Representational State Transfer. Une idéologie de conception des APIs basée sur des bonnes pratiques. Tout est ressource, on doit savoir quel objet on va manipuler. Utilise les headers (Authentication, Content-type, Accept,...) ainsi que la route pour rendre requetes idempotent et stateless  |Utilise les requetes HTTP, on utilise les verbes, les headers, les codes de retours,... **Stateless** : Le serveur ne va pas garder des informations de la session. **Idempotent** : Une requête aura toujours la même réponse pour la même entrée. | Les verbes HTTP : GET,POST,PUT,DELETE,PATCH. Codes de retour :100 info, 200 OK, 300 redirect, 400 error client, 500 internal error.|
|**JWT**| Json Web Token composé d’un Header, Payload et Signature | Utilisé en Bearer token pour les requetes nécessitant d'être authentifié | **Header** : JSON décrivant le token. **Payload** : JSON des infos du token. **Signature**|
|**Hibernate**| framework ORM (object relational mapping) qui implémente JPA pour relier les objets java avec les tables dans la base de données|||
|**JPA**| ensemble de spécifications pour interagir avec la base de données|||
|**JDBC**|Java DataBase Connectivity|||
|**Connection Pool**|In software engineering, a connection pool is a cache of reusable database connections managed by the client. It reduces the overhead of opening and closing connections, improving performance and scalability in database applications.|Avoir toujours au moins une connexion à la db de dispo -> minimiser la latence, augmenter la scalabilité |HikariCP|
|**DataSource**|1 connexion a la db||
|**get(), load(), flush(), merge(), save()**|get()/load()=unhydrated(has the query not te data)/hydrated. flush():apply modification. merge()/save()=aplique changement sur des objets détaché/transient.|||
|**update notes**|Spring6 , Spring boot3|||
|**Lazy loading**| Récupération des données au plus tard, sans jointure -> Problème n+1|||
|**Problème n+1**| Une requête pour l’objet principal + n requêtes pour chaque objet lazy loadé. **Solutions**: Changer le fetchtype à Eager, Utiliser join fetch pour faire une seule requête, utiliser des views |||
|**EntityManager**| Outil de communication entre le monde objet et le monde relationnel, responsable pour le CRUD|||
|**Etat des objets** |Transient, Persistent, Detached|||
|**Cache**| L1 : entitymanager; L2 : Partagé entre session(Bean scope session) avec une DB key value(Redis, Hazelcast); |||
|**Flush**| Permet de synchroniser l’état de la session avec la base de données|||
|||||
|Communication|RPC, EBS, Message broker, API Gateway(Auth, Retry, Metrique), GraphQL, gRPC & AVRO|||
|Architectures|Définitions, + et - de approches, approche micro-services, transactions distribués, service failure, circuit breaker, aut healing monitoring|
|Archi Monolythique| Isolation des couches, ex: 3-tiers(controller, service, repos), Separation of concerns, Domain Driven Dev|||
|Microservices|Architecture structurant une application comme un ensemble de services faiblement couplés. |**Avantages:** Maintenabilité, Testable, évolutif, indépendant du langage de programmation, adapté pour grosses équipes. **Inconvéniants:** performances impactés par le réseau, :warning:mauvaise archi -> couplage|Les microservices communiquent les uns avec les autres en utilisant des API |
|**ES/JS/TS**|JavaScript marque d'oracle(abus de language), implementation d'EcmaScript|||

