Skip to content

docs(homepage): improve wording of the philosophy cards #62

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
MorganCaron merged 1 commit into from
Oct 23, 2026
Merged

docs(homepage): improve wording of the philosophy cards #62

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
14 changes: 7 additions & 7 deletions docs/src/content/docs/en/index.mdx
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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.
</Card>

<Card title="Unopinionated integration & design by contract" icon="heart">
<Card title="Non-invasive integration & design by contract" icon="heart">
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.
</Card>

<Card title="C++26 cutting edge, zero legacy debt" icon="rocket">
<Card title="Cutting-edge C++26 & zero technical debt" icon="rocket">
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.
</Card>

<Card title="Performance & modern best practices" icon="seti:cpp">
Expand Down
20 changes: 10 additions & 10 deletions docs/src/content/docs/fr/index.mdx
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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.

<CardGrid stagger>
<a href={`${base}/fr/guides/getting-started/`} class="card-link">
Expand Down Expand Up @@ -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`).
</Card>

<Card title="Intégration libre & programmation par contrat" icon="heart">
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*).
<Card title="Intégration non invasive & programmation par contrat" icon="heart">
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.
</Card>

<Card title="Pointe de C++26 & zéro dette legacy" icon="rocket">
<Card title="À la pointe du C++26 & zéro dette technique" icon="rocket">
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.
</Card>

<Card title="Performance & bonnes pratiques" icon="seti:cpp">
<Card title="Performance & bonnes pratiques modernes" icon="seti:cpp">
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`).
Expand Down
Loading