diff --git a/docs/src/content/docs/en/index.mdx b/docs/src/content/docs/en/index.mdx index df890b0e..a27603d0 100644 --- a/docs/src/content/docs/en/index.mdx +++ b/docs/src/content/docs/en/index.mdx @@ -59,18 +59,18 @@ CppUtils is built upon uncompromising core principles: - **Hermetic isolation & faster builds**: each module is compiled only once, drastically reducing build times compared to redundant preprocessor (`#include`) headers. - + Zero architectural lock-in or contagion: CppUtils never attempts to dictate its types or colonize your codebase. - - **Non-invasive design & zero contagion**: unlike invasive frameworks such as **Qt** that mandate proprietary meta-compilers (`moc`), closed types (`QString`, `QByteArray`), and heavy inheritance trees, CppUtils remains strictly non-invasive and introduces zero viral dependencies: the goal is never to make you dependent to lock you into an ecosystem, actively refusing any form of vendor lock-in. - - **Design by contract**: APIs are constrained through standard concepts (`std::ranges::input_range`, `std::formattable`, `std::invocable`, etc.) rather than bound to rigid, imposed types: your containers propagate without defensive copying or conversion overhead (explore [design by contract with `auto` and concepts on my blog](https://morgancaron.github.io/articles/cpp/auto#abbreviated-function-template-depuis-c20)). - - **Isolated adoption**: pick a single standalone component (`MultiKeyMap`, `UniqueLocker`) in complete autonomy without being forced to import the rest of the library. + - **Non-invasive design & zero contagion**: unlike invasive frameworks such as **Qt** that mandate proprietary meta-compilers (`moc`), closed types (`QString`, `QByteArray`), and heavy inheritance hierarchies, CppUtils remains strictly non-invasive and introduces zero viral dependencies: the goal is never to lock you into a proprietary ecosystem (*vendor lock-in*). + - **Design by contract**: APIs are constrained through standard concepts (`std::ranges::input_range`, `std::formattable`, `std::invocable`, etc.) rather than bound to rigid, imposed types: your containers propagate without unnecessary copying or conversion overhead (explore [design by contract with `auto` and concepts on my blog](https://morgancaron.github.io/articles/cpp/auto#abbreviated-function-template-depuis-c20)). + - **Targeted adoption**: pick a single standalone component (`MultiKeyMap`, `UniqueLocker`) in complete autonomy without having to import the rest of the library. - + Continuously targets the latest language standard (**C++26**) to immediately deliver state-of-the-art capabilities: native modules, monadic operations, advanced concepts, enhanced safety, and reflection. - **Zero legacy compromise**: no artificial preservation of obsolete patterns or technical debt accumulation. - - **Pragmatic transition**: targeted feature-test macros (`__cpp_lib_*`) ease compilation on recent compilers with partial C++26 standard library rollouts, without carrying obsolete legacy baggage. - - **Future-proof architecture**: continuous refactorings to keep the codebase clean, robust, and modern. + - **Pragmatic transition**: targeted feature-test macros (`__cpp_lib_*`) ease compilation on recent compilers with partial C++26 standard library support, without burdening the codebase with backward-compatibility layers. + - **Future-proof architecture**: continuous refactoring to keep the codebase clean, robust, and modern. diff --git a/docs/src/content/docs/fr/index.mdx b/docs/src/content/docs/fr/index.mdx index 13fb1bc7..dec7dda0 100644 --- a/docs/src/content/docs/fr/index.mdx +++ b/docs/src/content/docs/fr/index.mdx @@ -23,7 +23,7 @@ export const base = import.meta.env.BASE_URL.replace(/\/$/, ''); ## Découvrir la documentation -CppUtils se compose de plusieurs grandes bibliothèques modulaires (tests unitaires, réseau, topologie de graphes) accompagnées de nombreux utilitaires spécialisés. Les modules C++20 permettent d'importer aisément l'ensemble en une seule directive (`import CppUtils;`) sans surcharger le binaire final, seuls les composants effectivement utilisés étant intégrés lors de la compilation. +CppUtils se compose de plusieurs grandes bibliothèques modulaires (tests unitaires, réseau, topologie de graphes) accompagnées de nombreux utilitaires spécialisés. Les modules C++20 permettent d'importer aisément l'ensemble en une seule directive (`import CppUtils;`) sans alourdir le binaire final, seuls les composants effectivement utilisés étant intégrés lors de la compilation. @@ -56,24 +56,24 @@ CppUtils repose sur des principes directeurs sans concession : Réunit l'essentiel (conteneurs, concurrence, réseau, parsing, tests, crypto, etc.) pour éliminer la prolifération de dépendances externes. Grâce aux **modules C++**, cette richesse favorise une réutilisabilité maximale sans aucun surcoût : - **À la carte ou globale** : importez un sous-domaine ciblé (`import CppUtils.Container;`) ou tout le catalogue (`import CppUtils;`). - **Zéro empreinte superflue** : seuls les composants effectivement appelés sont incorporés au binaire final. - - **Isolation hermétique & compilation accélérée** : chaque module n'est compilé qu'une seule fois, allégeant massivement les temps de build face aux en-têtes préprocesseur (`#include`). + - **Isolation hermétique & compilation accélérée** : chaque module n'est compilé qu'une seule fois, allégeant massivement les temps de compilation par rapport aux en-têtes préprocesseur (`#include`). - - Aucun carcan ni contamination architecturale : CppUtils ne cherche jamais à imposer ses types ni à coloniser votre codebase. - - **Conception non invasive & zéro contagion** : contrairement à des frameworks invasifs comme **Qt** qui imposent partout leur méta-compilateur propriétaire (`moc`), leurs types fermés (`QString`, `QByteArray`) et de lourdes hiérarchies d'héritage, CppUtils reste strictement non invasif et ne propage aucune adhérence virale : l'objectif n'est jamais de vous rendre dépendant pour vous retenir dans un écosystème, refusant toute forme de captivité technique (*vendor lock-in*). + + Aucun verrouillage ni contamination architecturale : CppUtils ne cherche jamais à imposer ses types ni à coloniser votre codebase. + - **Conception non invasive & zéro contagion** : contrairement à des frameworks invasifs comme **Qt** qui imposent partout leur méta-compilateur propriétaire (`moc`), leurs types fermés (`QString`, `QByteArray`) et de lourdes hiérarchies d'héritage, CppUtils reste strictement non invasif et ne propage aucune adhérence virale : l'objectif n'est jamais de vous rendre captif d'un écosystème propriétaire (*vendor lock-in*). - **Programmation par contrat** : les interfaces s'expriment via des concepts standards (`std::ranges::input_range`, `std::formattable`, `std::invocable`, etc.) plutôt que des types figés et imposés : vos conteneurs se propagent sans copie ni conversion superflue (en savoir plus sur la [programmation par contrat avec `auto` et les concepts sur mon blog](https://morgancaron.github.io/articles/cpp/auto#abbreviated-function-template-depuis-c20)). - - **Adoption isolée** : intégrez un composant unique (`MultiKeyMap`, `UniqueLocker`) en toute indépendance, sans devoir importer le reste du catalogue. + - **Adoption ciblée** : intégrez un composant unique (`MultiKeyMap`, `UniqueLocker`) en toute indépendance, sans devoir importer le reste du catalogue. - + Alignement assumé sur le dernier standard (**C++26**) pour délivrer immédiatement l'état de l'art : modules natifs, typage monadique, concepts avancés, sécurité accrue et réflexivité. - - **Zéro compromis legacy** : aucun maintien artificiel de pratiques obsolètes ni accumulation de dette technique. - - **Transition pragmatique** : des gardes de fonctionnalités ciblées (`__cpp_lib_*`) facilitent la compilation sur les compilateurs récents au support C++26 encore partiel, sans alourdir le code de compatibilité rétrograde. + - **Zéro compromis sur l'obsolescence** : aucun maintien artificiel de pratiques dépassées ni accumulation de dette technique. + - **Transition pragmatique** : des gardes de fonctionnalités ciblées (`__cpp_lib_*`) facilitent la compilation sur les compilateurs récents au support C++26 encore partiel, sans alourdir le code de couches de compatibilité rétrograde. - **Architecture pérenne** : refactorisations continues pour préserver une base de code moderne, saine et prête pour l'avenir. - + La performance maximale sans jamais sacrifier la clarté ni la sécurité : - **Lisibilité & simplicité** : interfaces épurées, transparentes et auto-documentées, sans complexité accidentelle ni magie obscure. - **Performance sans compromis** : abstractions à coût nul (*zero-cost*), agencement mémoire adapté au cache et évaluation maximale à la compilation (`constexpr`, `consteval`).