Skip to content

README.md

Latest commit

 

History

History
120 lines (88 loc) · 4.22 KB

README.md

File metadata and controls

120 lines (88 loc) · 4.22 KB

HelloFromJava - Le Troll de l'Over-Engineering 🎭

Un simple "Hello World" personnalisé implémenté avec une complexité totalement disproportionnée utilisant ExecutorService, Callable, Future et la programmation asynchrone... pour une tâche qui pourrait tenir en une ligne ! 😄

🎯 Concepts utilisés (pour rien du tout)

Programmation asynchrone excessive

  • ExecutorService : Un pool de threads... d'UN SEUL thread pour dire "Hello"
  • Callable : Une tâche asynchrone pour concaténer deux chaînes de caractères
  • Future : Un résultat asynchrone pour récupérer... une concaténation
  • Thread pool management : Création et fermeture propre d'un thread pool pour UNE opération

Over-Engineering Pattern

  • Complexité artificielle : Utiliser des concepts avancés là où System.out.println("Hello " + name) suffirait
  • Architecture distribuée : Pour une opération locale instantanée
  • Gestion des exceptions : ExecutionException et InterruptedException pour une simple concaténation

Anti-Pattern éducatif

  • Démonstration par l'absurde : Montrer ce qu'il NE faut PAS faire
  • Satire technologique : Parodier les architectures sur-complexes
  • Humour de développeur : Le plaisir de coder quelque chose de ridicule mais techniquement correct

🏗️ Architecture (ridiculement complexe)

HelloFromJava
├── Demande le nom à l'utilisateur (synchrone)
├── Crée un ExecutorService à un thread
├── Soumet une tâche Callable pour... concaténer
├── Attend le résultat avec Future.get()
├── Affiche le résultat
└── Ferme proprement l'ExecutorService

Ce que ça fait réellement : "Hello " + nom

Complexité ajoutée : 300% de code en plus, gestion de threads, exceptions asynchrones

🚀 Installation et exécution

Prérequis

  • Java JDK 8 ou supérieur
  • Un sens de l'humour développeur
  • La capacité à apprécier l'ironie

Compilation

javac HelloFromJava.java

Exécution

java HelloFromJava

📝 Utilisation

Enter your name: Alice
Hello Alice

Temps d'exécution : ~5ms (création thread pool + exécution + fermeture)

Version simple équivalente :

System.out.println("Hello " + scanner.nextLine());

Temps d'exécution : ~1ms

🤡 Le Troll expliqué

Pourquoi c'est ridicule ?

  1. Overhead démesuré : On crée un thread pool pour une opération instantanée
  2. Asynchrone inutile : Aucune opération longue ou bloquante à gérer
  3. Complexité cognitive : 10 concepts avancés pour faire "Hello World"
  4. Gestion d'erreurs overkill : Try-catch pour une concaténation de chaînes

Pourquoi c'est génial ?

  1. Pédagogie par l'absurde : Montre tous les concepts d'un coup
  2. Humour de développeur : On comprend immédiatement la blague
  3. Code techniquement correct : Tout fonctionne parfaitement
  4. Démonstration maîtrisée : Prouve qu'on connaît les outils (même mal utilisés)

📚 Points d'apprentissage (malgré le troll)

Ce projet enseigne :

  • L'utilisation d'ExecutorService et sa fermeture propre
  • La différence Runnable vs Callable (avec retour de valeur)
  • La gestion des Future pour récupérer des résultats asynchrones
  • Les exceptions de concurrence (ExecutionException, InterruptedException)
  • Quand NE PAS utiliser ces outils (le plus important !)

🎭 Variantes du troll

Version encore plus ridicule

CompletableFuture.supplyAsync(() -> "Hello " + name)
    .thenApply(String::toUpperCase)
    .thenCompose(s -> CompletableFuture.completedFuture(s.toLowerCase()))
    .join();

Version microservices

// TODO: Déployer "Hello" sur un conteneur Docker
// TODO: "nom" dans une base de données Redis
// TODO: Concaténation via une API REST

🏆 Conclusion

Ce projet est la preuve parfaite qu'on peut techniquement tout faire avec Java... même les choses les plus inutiles !

Morale : Maîtriser les outils, c'est aussi savoir quand ne PAS les utiliser.

Note : Ce code est un excellent exemple à montrer en entretien pour démontrer qu'on comprend la différence entre "pouvoir faire" et "devoir faire". 😉