From 693698d6e74b0ae4f984b85d12bafc62dde9ad1c Mon Sep 17 00:00:00 2001 From: Arnaud Bailly Date: Fri, 29 May 2026 15:34:43 +0200 Subject: site: premiere version statique du site web --- site/assets/logo.png | Bin 0 -> 15480 bytes site/event.css | 95 +++++ site/events/2022-05-19-reutilisation-effets.html | 60 ++++ site/events/2022-09-20-gadts-free-monads.html | 58 ++++ site/events/2023-06-23-haskell.html | 60 ++++ site/events/2023-10-23-monades-gratuites.html | 58 ++++ site/events/2024-06-20-types-dependants.html | 58 ++++ site/events/2024-10-10-lambda-calcul.html | 58 ++++ site/events/2025-01-30-tests-proprietes.html | 56 +++ site/events/2025-03-27-logs-observabilite.html | 56 +++ site/events/2025-10-09-lambda-calcul-type.html | 58 ++++ site/events/2025-11-13-injection-dependances.html | 60 ++++ site/events/2025-12-10-interprete-prolog.html | 58 ++++ site/events/2026-02-19-langages-de-niches.html | 58 ++++ site/events/2026-03-19-plain-pattern-language.html | 58 ++++ site/events/2026-04-16-atelier-4.html | 56 +++ .../2026-05-21-programmation-compositionnelle.html | 60 ++++ site/index.html | 383 ++++++++++++++++++++ site/style.css | 385 +++++++++++++++++++++ 19 files changed, 1735 insertions(+) create mode 100644 site/assets/logo.png create mode 100644 site/event.css create mode 100644 site/events/2022-05-19-reutilisation-effets.html create mode 100644 site/events/2022-09-20-gadts-free-monads.html create mode 100644 site/events/2023-06-23-haskell.html create mode 100644 site/events/2023-10-23-monades-gratuites.html create mode 100644 site/events/2024-06-20-types-dependants.html create mode 100644 site/events/2024-10-10-lambda-calcul.html create mode 100644 site/events/2025-01-30-tests-proprietes.html create mode 100644 site/events/2025-03-27-logs-observabilite.html create mode 100644 site/events/2025-10-09-lambda-calcul-type.html create mode 100644 site/events/2025-11-13-injection-dependances.html create mode 100644 site/events/2025-12-10-interprete-prolog.html create mode 100644 site/events/2026-02-19-langages-de-niches.html create mode 100644 site/events/2026-03-19-plain-pattern-language.html create mode 100644 site/events/2026-04-16-atelier-4.html create mode 100644 site/events/2026-05-21-programmation-compositionnelle.html create mode 100644 site/index.html create mode 100644 site/style.css diff --git a/site/assets/logo.png b/site/assets/logo.png new file mode 100644 index 0000000..1f9fba0 Binary files /dev/null and b/site/assets/logo.png differ diff --git a/site/event.css b/site/event.css new file mode 100644 index 0000000..8c0bcdd --- /dev/null +++ b/site/event.css @@ -0,0 +1,95 @@ +/* === Event page styles === */ +.event-hero { + background: linear-gradient(135deg, var(--sand-light) 0%, var(--sky-light) 100%); + padding: 48px 0 40px; +} + +.event-hero__back { + display: inline-flex; + align-items: center; + gap: 6px; + text-decoration: none; + font-size: 0.9rem; + color: var(--ink-light); + margin-bottom: 20px; +} + +.event-hero__back:hover { + color: var(--ink); +} + +.event-hero h1 { + font-family: "JetBrains Mono", "Fira Code", monospace; + font-size: 2rem; + font-weight: 700; + line-height: 1.3; + margin-bottom: 16px; +} + +.event-meta { + display: flex; + flex-wrap: wrap; + gap: 20px; + color: var(--ink-light); + font-size: 0.95rem; +} + +.event-meta__item { + display: inline-flex; + align-items: center; + gap: 6px; +} + +.event-body { + padding: 48px 0 64px; +} + +.event-body__content { + max-width: 720px; + line-height: 1.8; +} + +.event-body__content h2 { + font-family: "JetBrains Mono", "Fira Code", monospace; + font-size: 1.3rem; + margin: 32px 0 12px; +} + +.event-body__content p { + margin-bottom: 16px; +} + +.event-body__content strong { + font-weight: 600; +} + +.event-link { + display: inline-flex; + align-items: center; + gap: 8px; + margin-top: 24px; + padding: 10px 20px; + background: var(--sky-light); + border: 1px solid var(--sky); + border-radius: 8px; + text-decoration: none; + font-weight: 500; + font-size: 0.9rem; + transition: background 0.2s; +} + +.event-link:hover { + background: var(--sky); + color: var(--ink); +} + +@media (max-width: 700px) { + .event-hero h1 { + font-size: 1.5rem; + } + + .event-meta { + flex-direction: column; + gap: 8px; + } +} diff --git a/site/events/2022-05-19-reutilisation-effets.html b/site/events/2022-05-19-reutilisation-effets.html new file mode 100644 index 0000000..90dc6a5 --- /dev/null +++ b/site/events/2022-05-19-reutilisation-effets.html @@ -0,0 +1,60 @@ + + + + + + Réutilisation de fonctions et abstraction d'effets - Lambda Nantes + + + + + + + + + + +
+
+ ← Toutes les rencontres +

LambdaNantes 1 : Réutilisation de fonctions et abstraction d'effets

+
+ 📅 19 mai 2022 + 🕐 17h00 - 20h00 + 📍 SFEIR, 40 Rue La Tour d'Auvergne, Nantes +
+
+
+ +
+
+
+

Première édition de LambdaNantes ! Deux présentations d'experts suivies de discussions informelles dans un café à proximité.

+ +

Function Reuse is Only a Pious Wish

+

Nicolas Rinaudo (CTO de Besedo) démystifie les concepts de programmation fonctionnelle comme "Monad" et "Functor". Plutôt que de s'appuyer sur la théorie des catégories, il démontre comment ces abstractions émergent naturellement dans les projets du monde réel.

+ +

Abstraction d'effets via Stream Processing par Free Monad

+

Romain Lecomte (développeur chez Conduktor) explore les applications pratiques de structures fonctionnelles développées lors de la construction d'un outil léger de gestion de cluster Kafka en Scala.

+ + Voir sur Mobilizon → +
+
+
+ + + + diff --git a/site/events/2022-09-20-gadts-free-monads.html b/site/events/2022-09-20-gadts-free-monads.html new file mode 100644 index 0000000..97c1371 --- /dev/null +++ b/site/events/2022-09-20-gadts-free-monads.html @@ -0,0 +1,58 @@ + + + + + + GADTs et Free Monades - Lambda Nantes + + + + + + + + + + +
+
+ ← Toutes les rencontres +

LambdaNantes 2 : GADTs pour l'OOP et sur la triste réalité des Free Monades

+
+ 📅 20 septembre 2022 + 🕐 17h00 - 20h00 + 📍 SFEIR, 40 Rue La Tour d'Auvergne, Nantes +
+
+
+ +
+
+
+

Heureux les simples d'esprit

+

Arnaud Bailly examine pourquoi les free monads et les algèbres d'effets, bien qu'élégantes théoriquement, ont échoué à plusieurs reprises dans le développement professionnel en Haskell, et questionne leur pertinence pour les projets logiciels à longue durée de vie.

+ +

Méthodes gardées

+

Xavier Van de Woestyne démontre comment encoder des méthodes gardées en OCaml en utilisant les GADTs et les témoins d'égalité de types, implémentant une fonctionnalité OOP absente dans la plupart des langages statiquement typés.

+ + Voir sur Mobilizon → +
+
+
+ + + + diff --git a/site/events/2023-06-23-haskell.html b/site/events/2023-06-23-haskell.html new file mode 100644 index 0000000..621c1a0 --- /dev/null +++ b/site/events/2023-06-23-haskell.html @@ -0,0 +1,60 @@ + + + + + + Haskell à l'honneur - Lambda Nantes + + + + + + + + + + +
+
+ ← Toutes les rencontres +

LambdaNantes 3 : Haskell à l'honneur

+
+ 📅 23 juin 2023 + 🕐 17h00 - 19h30 + 📍 PaloIT, 1 Rue Saint Julien, Nantes +
+
+
+ +
+
+
+

Building biscuit-haskell: lessons learned and fancy techniques

+

Clément Delafargue présente son implémentation Haskell des tokens biscuit, explorant le C FFI, megaparsec, les type-families et template haskell.

+ +

Flora.pm, code, architecture and DDD

+

Théophile Choutri présente un dépôt de paquets Hackage alternatif mettant l'accent sur l'expérience utilisateur et les concepts de domain-driven design.

+ +

Les présentations sont en français malgré les titres et résumés en anglais.

+ + Voir sur Mobilizon → +
+
+
+ + + + diff --git a/site/events/2023-10-23-monades-gratuites.html b/site/events/2023-10-23-monades-gratuites.html new file mode 100644 index 0000000..3efc111 --- /dev/null +++ b/site/events/2023-10-23-monades-gratuites.html @@ -0,0 +1,58 @@ + + + + + + Monades Gratuites et Systèmes de build - Lambda Nantes + + + + + + + + + + +
+
+ ← Toutes les rencontres +

LambdaNantes 4 : Monades Gratuites et Systèmes de build

+
+ 📅 23 octobre 2023 + 🕐 17h00 - 19h30 + 📍 PaloIT, 1 Rue Saint Julien, Nantes +
+
+
+ +
+
+
+

La monade discutablement gratuite

+

Nicolas Rinaudo aborde un sujet simple, compréhensible et original sur les Free Monads, conçu pour intéresser les développeurs Scala de la région.

+ +

Construction d'un build system avec du jargon fonctionnel

+

Xavier Van de Woestyne explore les approches fonctionnelles de la construction de systèmes. Les idiomes présentés sont utiles et peuvent être appliqués sous forme réduite pour résoudre des problèmes plus courants comme la génération de sites statiques, la construction de pipelines, etc.

+ + Voir sur Mobilizon → +
+
+
+ + + + diff --git a/site/events/2024-06-20-types-dependants.html b/site/events/2024-06-20-types-dependants.html new file mode 100644 index 0000000..b4bd183 --- /dev/null +++ b/site/events/2024-06-20-types-dependants.html @@ -0,0 +1,58 @@ + + + + + + Types, types et types (dépendants) - Lambda Nantes + + + + + + + + + + +
+
+ ← Toutes les rencontres +

LambdaNantes 5 : Types, types et types (dépendants)

+
+ 📅 20 juin 2024 + 🕐 17h00 - 19h30 + 📍 PaloIT, 1 Rue Saint Julien, Nantes +
+
+
+ +
+
+
+

Le XXIème sera typé ou ne sera pas

+

Arnaud Bailly explore le Type-Driven Development à travers des exemples en Elm, Haskell et Idris, couvrant les types algébriques, type classes, type families, etc. jusqu'aux frontières des types dépendants.

+ +

Types dépendants : de la théorie à la pratique en mode interactif !

+

Didier Plaindoux passe de la théorie vers la pratique en examinant les définitions formelles. Les sujets incluent les types fonctions dépendants, les paires dépendantes, les types somme et l'égalité propositionnelle.

+ + Voir sur Mobilizon → +
+
+
+ + + + diff --git a/site/events/2024-10-10-lambda-calcul.html b/site/events/2024-10-10-lambda-calcul.html new file mode 100644 index 0000000..77db059 --- /dev/null +++ b/site/events/2024-10-10-lambda-calcul.html @@ -0,0 +1,58 @@ + + + + + + Interprétons le Lambda Calcul - Lambda Nantes + + + + + + + + + + +
+
+ ← Toutes les rencontres +

Workshop 1 : Interprétons le Lambda Calcul

+
+ 📅 10 octobre 2024 + 🕐 17h00 - 19h30 + 📍 PaloIT, 1 Rue Saint Julien, Nantes +
+
+
+ +
+
+
+

Première édition des Workshops de Lambda Nantes ! Une session interactive explorant le Lambda Calcul. Les participants construisent collaborativement un interpréteur de Lambda Calcul, dans le langage de programmation de leur choix.

+ +

La session couvre l'implémentation d'un interpréteur, la compréhension des arbres syntaxiques abstraits, leur représentation dans des langages mainstream comme TypeScript ou Kotlin, et l'évaluation d'expressions.

+ +

Premier d'une série, cet atelier initie une progression vers la construction d'un langage de programmation compilé. Des implémentations canoniques en Kotlin et TypeScript sont fournies pour les sessions futures.

+ + Voir sur Mobilizon → +
+
+
+ + + + diff --git a/site/events/2025-01-30-tests-proprietes.html b/site/events/2025-01-30-tests-proprietes.html new file mode 100644 index 0000000..7becb07 --- /dev/null +++ b/site/events/2025-01-30-tests-proprietes.html @@ -0,0 +1,56 @@ + + + + + + Les tests dirigés par les propriétés - Lambda Nantes + + + + + + + + + + +
+
+ ← Toutes les rencontres +

LambdaNantes 6 : Les tests dirigés par les propriétés

+
+ 📅 30 janvier 2025 + 🕐 18h00 - 19h30 + 📍 PaloIT, Place Royale, Nantes +
+
+
+ +
+
+
+

Atelier animé par Arnaud Bailly introduisant le property-based testing (PBT). La session explore les principes fondamentaux, les applications pratiques et les approches d'implémentation à travers des exercices pratiques : construction d'un outil de test simple et expérimentation avec des frameworks existants.

+ +

L'événement accueille tous les langages de programmation et ne nécessite aucun prérequis. Bien que le PBT soit largement reconnu comme précieux, sa mise en oeuvre pratique peut être difficile. Cet atelier vise à démontrer comment la compréhension du PBT peut renforcer la résilience des applications.

+ + Voir sur Mobilizon → +
+
+
+ + + + diff --git a/site/events/2025-03-27-logs-observabilite.html b/site/events/2025-03-27-logs-observabilite.html new file mode 100644 index 0000000..ca8edf0 --- /dev/null +++ b/site/events/2025-03-27-logs-observabilite.html @@ -0,0 +1,56 @@ + + + + + + Des logs pour de la traçabilité et de l'observabilité - Lambda Nantes + + + + + + + + + + +
+
+ ← Toutes les rencontres +

LambdaNantes 7 : Des logs pour de la traçabilité et de l'observabilité

+
+ 📅 27 mars 2025 + 🕐 18h15 - 19h30 + 📍 PaloIT, 1 Rue Saint Julien, Nantes +
+
+
+ +
+
+
+

Lucas, développeur backend freelance spécialisé dans les microservices et les langages typés (Golang, Rust), présente l'observabilité dans les systèmes distribués.

+ +

La présentation aborde comment les logs traditionnels atteignent leurs limites dans les architectures distribuées, avec un manque de contexte et une mauvaise visibilité inter-services. Lucas démontre l'utilisation d'OpenTelemetry, un standard ouvert pour les métriques, traces et logs, pour atteindre une observabilité complète et corréler les données à travers les systèmes.

+ + Voir sur Mobilizon → +
+
+
+ + + + diff --git a/site/events/2025-10-09-lambda-calcul-type.html b/site/events/2025-10-09-lambda-calcul-type.html new file mode 100644 index 0000000..468043a --- /dev/null +++ b/site/events/2025-10-09-lambda-calcul-type.html @@ -0,0 +1,58 @@ + + + + + + Interprétons le lambda-calcul typé - Lambda Nantes + + + + + + + + + + +
+
+ ← Toutes les rencontres +

Workshop 2bis : Interprétons le lambda-calcul typé

+
+ 📅 9 octobre 2025 + 🕐 17h00 - 19h00 + 📍 Epitech, 2 Place Louis Daubenton, Nantes +
+
+
+ +
+
+
+

Cet atelier pratique fait suite à une précédente exploration du lambda-calcul. Les participants enrichiront un interpréteur de lambda-calcul en ajoutant un système de types simples.

+ +

La session couvre des concepts importants de programmation : typage structurel, inférence de types, variables de types, et types somme/produit.

+ +

L'atelier ne nécessite pas d'avoir participé à l'événement original, les concepts fondamentaux seront revus. Les participants sont invités à apporter leurs machines et environnements de développement pour coder collaborativement, le travail en binôme étant possible pour ceux sans équipement.

+ + Voir sur Mobilizon → +
+
+
+ + + + diff --git a/site/events/2025-11-13-injection-dependances.html b/site/events/2025-11-13-injection-dependances.html new file mode 100644 index 0000000..0994b7b --- /dev/null +++ b/site/events/2025-11-13-injection-dependances.html @@ -0,0 +1,60 @@ + + + + + + Injection de dépendances dans les langages fonctionnels - Lambda Nantes + + + + + + + + + + +
+
+ ← Toutes les rencontres +

Lambda Nantes 8 : De l'injection de dépendances dans les langages fonctionnels

+
+ 📅 13 novembre 2025 + 🕐 18h00 - 20h00 + 📍 Epitech, 2 Place Louis Daubenton, Nantes +
+
+
+ +
+
+
+

Deux présentations explorant l'injection de dépendances dans les langages fonctionnels, permettant une analyse comparative entre différents langages.

+ +

Injection de dépendances en Unison

+

Eric Torreborre discute de comment implémenter l'injection de dépendances en Unison, un langage fonctionnel dépourvu de métaprogrammation mais offrant un système d'effets "abilities". Il établit des critères d'évaluation et montre comment utiliser les abilities pour l'injection de dépendances et permettre des "typeclasses programmables".

+ +

Injection de dépendances en OCaml

+

Xavier van de Woestyne présente l'injection de dépendances via l'encodage "ReaderT" combiné avec le polymorphisme de rangée d'OCaml. Cette approche s'appuie sur un article sur les modèles d'abstraction d'effets, montrant comment tirer parti de la sûreté de types du langage sans sacrifier l'expressivité. Aucune expérience préalable d'OCaml n'est requise.

+ + Voir sur Mobilizon → +
+
+
+ + + + diff --git a/site/events/2025-12-10-interprete-prolog.html b/site/events/2025-12-10-interprete-prolog.html new file mode 100644 index 0000000..3579af1 --- /dev/null +++ b/site/events/2025-12-10-interprete-prolog.html @@ -0,0 +1,58 @@ + + + + + + Créons un interprète Prolog - Lambda Nantes + + + + + + + + + + +
+
+ ← Toutes les rencontres +

Workshop 3 : Créons un interprète Prolog

+
+ 📅 10 décembre 2025 + 🕐 18h00 - 20h00 + 📍 Epitech, 2 Place Louis Daubenton, Nantes +
+
+
+ +
+
+
+

Cet atelier introduit la programmation logique et invite les participants à développer collaborativement un interprète Prolog minimal en petits groupes.

+ +

La session explore les concepts fondamentaux : base de faits (atomes), base de règles, recherche, inférence et coupure. Aucune connaissance préalable en programmation logique n'est nécessaire, et l'atelier reste agnostique quant au langage de programmation utilisé.

+ +

Les participants sont invités à apporter leurs machines et environnements de développement, mais la collaboration avec d'autres est possible pour ceux qui n'ont pas d'équipement.

+ + Voir sur Mobilizon → +
+
+
+ + + + diff --git a/site/events/2026-02-19-langages-de-niches.html b/site/events/2026-02-19-langages-de-niches.html new file mode 100644 index 0000000..a840131 --- /dev/null +++ b/site/events/2026-02-19-langages-de-niches.html @@ -0,0 +1,58 @@ + + + + + + Pourquoi choisir des langages de niches ? - Lambda Nantes + + + + + + + + + + +
+
+ ← Toutes les rencontres +

Lambda Nantes 9 : Pourquoi choisir des langages de niches ?

+
+ 📅 19 février 2026 + 🕐 18h00 - 20h00 + 📍 Epitech, 2 Place Louis Daubenton, Nantes +
+
+
+ +
+
+
+

Clément Delafargue, ingénieur logiciel chez Datadog avec une expérience de Tech Lead, CTO, formateur et consultant, discute de pourquoi les langages de programmation de niche peuvent être supérieurs aux alternatives mainstream.

+ +

S'appuyant sur son expérience pratique avec Scala, Haskell et Rust, il aborde les préoccupations managériales notamment le recrutement, la formation d'équipe et la rétention. La présentation explore les impacts concrets sur les développeurs à travers des écosystèmes plus petits et les gains potentiels, tout en examinant les stratégies gagnantes et les pièges à éviter.

+ +

La session conclut en réévaluant les critères de succès pour l'adoption de technologies spécialisées, allant au-delà des affirmations simplifiées de productivité vers une prise de décision nuancée.

+ + Voir sur Mobilizon → +
+
+
+ + + + diff --git a/site/events/2026-03-19-plain-pattern-language.html b/site/events/2026-03-19-plain-pattern-language.html new file mode 100644 index 0000000..4411aba --- /dev/null +++ b/site/events/2026-03-19-plain-pattern-language.html @@ -0,0 +1,58 @@ + + + + + + Plain Pattern Language - Lambda Nantes + + + + + + + + + + +
+
+ ← Toutes les rencontres +

Lambda Nantes 10 : Plain Pattern Language

+
+ 📅 19 mars 2026 + 🕐 18h00 - 20h00 + 📍 Place Louis Daubenton, Nantes +
+
+
+ +
+
+
+

Lorie den Os explore les méthodes de grammaires formelles appliquées à des contextes non conventionnels, comme la génération procédurale de maisons dans des simulations. La présentation aborde les méta-grammaires d'arbres, la syntaxe spatiale, et "A Pattern Language" de Christopher Alexander - l'oeuvre qui a inspiré les design patterns en développement logiciel.

+ +

La conférence couvre les grammaires d'arbres pour la génération de texte, les méta-grammaires, les ontologies, et les techniques pour formaliser les concepts abstraits de patterns d'Alexander. L'objectif : démontrer comment "construire des maisons de la même manière qu'on compose des phrases".

+ +

Lorie den Os est Product Tech Lead chez Yseop, spécialisée dans les technologies de génération de texte au-delà des grands modèles de langage.

+ + Voir sur Mobilizon → +
+
+
+ + + + diff --git a/site/events/2026-04-16-atelier-4.html b/site/events/2026-04-16-atelier-4.html new file mode 100644 index 0000000..4238d6d --- /dev/null +++ b/site/events/2026-04-16-atelier-4.html @@ -0,0 +1,56 @@ + + + + + + Atelier Lambda Nantes #4 - Lambda Nantes + + + + + + + + + + +
+
+ ← Toutes les rencontres +

Atelier Lambda Nantes #4

+
+ 📅 16 avril 2026 + 🕐 17h00 - 19h00 + 📍 Place Louis Daubenton, Nantes +
+
+
+ +
+
+
+

Cet atelier explore OCaml pour le développement web à travers les unikernels, comme alternative aux architectures conventionnelles de microservices. Plutôt que de s'appuyer sur les abstractions Docker et Kubernetes, les participants développeront et déploieront collaborativement un unikernel conçu pour ajouter des fonctionnalités d'interaction sociale aux sites web générés statiquement.

+ +

Le projet sert de fondation pour la présence en ligne officielle de LambdaNantes, offrant aux participants l'opportunité de contribuer directement aux efforts de développement du groupe. Des instructions d'installation seront fournies au préalable pour maximiser la productivité de l'atelier.

+ + Voir sur Mobilizon → +
+
+
+ + + + diff --git a/site/events/2026-05-21-programmation-compositionnelle.html b/site/events/2026-05-21-programmation-compositionnelle.html new file mode 100644 index 0000000..2740785 --- /dev/null +++ b/site/events/2026-05-21-programmation-compositionnelle.html @@ -0,0 +1,60 @@ + + + + + + Programmation compositionnelle et traversabilité - Lambda Nantes + + + + + + + + + + +
+
+ ← Toutes les rencontres +

Programmation compositionnelle et traversabilité

+
+ 📅 21 mai 2026 + 🕐 17h00 - 19h00 + 📍 2 Place Louis Daubenton, Nantes +
+
+
+ +
+
+
+

Avant-dernière session de la saison 2025-2026 de Lambda Nantes, accueillie par Epitech Nantes, suivie de discussions informelles dans un bar à proximité.

+ +

Programmation compositionnelle

+

Eric Torreborre aborde les avancées récentes dans la résolution du "Expression Problem". Il explore comment la modularisation du code, bien que bénéfique, présente des défis significatifs. A travers un exemple concret de système, il examine les difficultés de modularité et montre pourquoi les solutions existantes s'avèrent insuffisantes pour les dépendances modulaires complexes. La session explore un nouveau langage de programmation avec des systèmes de types avancés offrant des progrès sur ces questions.

+ +

Traversabilité

+

Clément Delafargue explique pourquoi "c'est toujours traverse !" dans les communautés de programmation fonctionnelle. Cette fonction est devenue largement applicable dans des contextes variés : appels asynchrones, validation de données, exécution conditionnelle et génération de parsers. La discussion couvre les foncteurs applicatifs qui sous-tendent cette abstraction.

+ + Voir sur Mobilizon → +
+
+
+ + + + diff --git a/site/index.html b/site/index.html new file mode 100644 index 0000000..d3eb061 --- /dev/null +++ b/site/index.html @@ -0,0 +1,383 @@ + + + + + + Lambda Nantes - Programmation fonctionnelle et langages + + + + + + + + + + + + + +
+ + +
+ +

λ-Nantes

+

+ Un groupe de développeuses et développeurs de Nantes et sa région, + passionnés par la programmation fonctionnelle, les langages et la théorie des types. +

+ Nous rejoindre +
+
+ + + + + +
+
+

A propos

+

+ Nous nous réunissons régulièrement pour des conférences et des ateliers + autour des langages de programmation et du développement logiciel. +

+
+
+ +

Programmation fonctionnelle

+

+ Haskell, OCaml, Elm, Elixir, Clojure, Scala... + Nous explorons les langages fonctionnels et les concepts qui les sous-tendent. +

+
+
+ +

Théorie des types

+

+ Des types simples aux types dépendants, en passant par le polymorphisme + et les systèmes de preuves. +

+
+
+ +

Langages et compilation

+

+ Conception de langages, interpréteurs, compilateurs, + machines virtuelles et analyses statiques. +

+
+
+ +

Développement logiciel

+

+ Tests, qualité, architecture, outils... + Tout ce qui rend le développement logiciel plus fiable et agréable. +

+
+
+
+
+ + +
+
+

Nos sujets de prédilection

+

+ Quelques-uns des thèmes que nous abordons lors de nos rencontres. +

+
+ Lambda-calcul + Haskell + OCaml + Typage + Preuves formelles + Property-based testing + Interpréteurs + Compilateurs + Elm + Rust + Prolog + Catégories + Effets algébriques + Logique + Récursion + Monades + Parsers +
+
+
+ + +
+
+

Nos rencontres

+

+ Retrouvez l'historique de nos rencontres depuis 2022. Conférences, ateliers + et discussions autour de la programmation fonctionnelle. +

+
+ +
21 mai
2026
+
+

Programmation compositionnelle et traversabilité

+

Expression Problem et foncteurs applicatifs avec Eric Torreborre et Clément Delafargue.

+
+ + +
16 avr
2026
+
+

Atelier Lambda Nantes #4

+

OCaml pour le web : développement et déploiement d'un unikernel.

+
+ + +
19 mar
2026
+
+

Lambda Nantes 10 : Plain Pattern Language

+

Grammaires formelles et génération procédurale avec Lorie den Os.

+
+ + +
19 fév
2026
+
+

Lambda Nantes 9 : Pourquoi choisir des langages de niches ?

+

Retour d'expérience Scala, Haskell et Rust avec Clément Delafargue.

+
+ + +
10 déc
2025
+
+

Workshop 3 : Créons un interprète Prolog

+

Atelier collaboratif d'introduction à la programmation logique.

+
+ + +
13 nov
2025
+
+

Lambda Nantes 8 : Injection de dépendances fonctionnelle

+

Comparaison Unison vs OCaml avec Eric Torreborre et Xavier van de Woestyne.

+
+ + +
09 oct
2025
+
+

Workshop 2bis : Interprétons le lambda-calcul typé

+

Ajout d'un système de types simples à un interpréteur de lambda-calcul.

+
+ + +
27 mar
2025
+
+

LambdaNantes 7 : Logs, traçabilité et observabilité

+

OpenTelemetry et observabilité dans les systèmes distribués avec Lucas.

+
+ + +
30 jan
2025
+
+

LambdaNantes 6 : Les tests dirigés par les propriétés

+

Atelier property-based testing avec Arnaud Bailly.

+
+ + +
10 oct
2024
+
+

Workshop 1 : Interprétons le Lambda Calcul

+

Premier atelier : construire un interpréteur de lambda-calcul.

+
+ + +
20 jun
2024
+
+

LambdaNantes 5 : Types, types et types (dépendants)

+

Type-Driven Development et types dépendants avec Arnaud Bailly et Didier Plaindoux.

+
+ + +
23 oct
2023
+
+

LambdaNantes 4 : Monades Gratuites et Systèmes de build

+

Free Monads et build systems avec Nicolas Rinaudo et Xavier Van de Woestyne.

+
+ + +
23 jun
2023
+
+

LambdaNantes 3 : Haskell à l'honneur

+

Biscuit tokens et Flora.pm avec Clément Delafargue et Théophile Choutri.

+
+ + +
20 sep
2022
+
+

LambdaNantes 2 : GADTs et Free Monades

+

Réalité des Free Monads et méthodes gardées avec Arnaud Bailly et Xavier Van de Woestyne.

+
+ + +
19 mai
2022
+
+

LambdaNantes 1 : Réutilisation de fonctions et abstraction d'effets

+

Première édition ! Monads, Functors et stream processing avec Nicolas Rinaudo et Romain Lecomte.

+
+ +
+
+
+ + +
+
+

Nous rejoindre

+

+ Que vous soyez débutant ou expert, vous êtes les bienvenu(e)s ! + Retrouvez-nous sur Mobilizon pour connaître les prochains événements. +

+
+ + + Mobilizon + + + + Radicle + +
+
+
+ + + + + + diff --git a/site/style.css b/site/style.css new file mode 100644 index 0000000..5ed68e2 --- /dev/null +++ b/site/style.css @@ -0,0 +1,385 @@ +/* === Reset & Base === */ +*, +*::before, +*::after { + margin: 0; + padding: 0; + box-sizing: border-box; +} + +:root { + --sky: #8ecae6; + --sky-light: #d4edf8; + --sand: #f5deb3; + --sand-light: #fdf3e0; + --ink: #2b2d42; + --ink-light: #555b6e; + --white: #fefefe; + --radius: 12px; +} + +html { + scroll-behavior: smooth; +} + +body { + font-family: "Inter", "Helvetica Neue", Arial, sans-serif; + color: var(--ink); + background: var(--white); + line-height: 1.7; + font-size: 17px; +} + +a { + color: var(--ink); + text-decoration-color: var(--sky); + text-underline-offset: 3px; + transition: color 0.2s; +} + +a:hover { + color: #1a6fa0; +} + +/* === Layout === */ +.container { + max-width: 960px; + margin: 0 auto; + padding: 0 24px; +} + +/* === Header / Hero === */ +.hero { + background: linear-gradient(135deg, var(--sand-light) 0%, var(--sky-light) 100%); + padding: 80px 0 60px; + text-align: center; +} + +.hero__logo { + width: 160px; + height: 160px; + border-radius: 50%; + object-fit: cover; + border: 4px solid var(--white); + box-shadow: 0 4px 24px rgba(0, 0, 0, 0.08); + margin-bottom: 24px; +} + +.hero h1 { + font-family: "JetBrains Mono", "Fira Code", monospace; + font-size: 2.8rem; + font-weight: 700; + letter-spacing: -1px; + margin-bottom: 8px; +} + +.hero h1 .lambda { + color: #3a9fbf; +} + +.hero__tagline { + font-size: 1.15rem; + color: var(--ink-light); + max-width: 560px; + margin: 0 auto 32px; +} + +.hero__cta { + display: inline-block; + background: var(--sky); + color: var(--ink); + font-weight: 600; + padding: 12px 28px; + border-radius: 8px; + text-decoration: none; + transition: background 0.2s, transform 0.15s; +} + +.hero__cta:hover { + background: #6fb8d9; + color: var(--ink); + transform: translateY(-1px); +} + +/* === Nav === */ +.nav { + background: var(--white); + border-bottom: 1px solid #e8e8e8; + position: sticky; + top: 0; + z-index: 10; +} + +.nav__inner { + display: flex; + align-items: center; + justify-content: space-between; + padding: 12px 0; +} + +.nav__brand { + font-family: "JetBrains Mono", "Fira Code", monospace; + font-weight: 700; + font-size: 1.2rem; + text-decoration: none; +} + +.nav__links { + display: flex; + gap: 24px; + list-style: none; +} + +.nav__links a { + text-decoration: none; + font-size: 0.95rem; + font-weight: 500; + color: var(--ink-light); + transition: color 0.2s; +} + +.nav__links a:hover { + color: var(--ink); +} + +/* === Sections === */ +section { + padding: 64px 0; +} + +section:nth-child(even) { + background: var(--sand-light); +} + +.section__title { + font-family: "JetBrains Mono", "Fira Code", monospace; + font-size: 1.6rem; + margin-bottom: 12px; +} + +.section__subtitle { + color: var(--ink-light); + margin-bottom: 40px; + max-width: 600px; +} + +/* === About === */ +.about__grid { + display: grid; + grid-template-columns: 1fr 1fr; + gap: 32px; + margin-top: 32px; +} + +.about__card { + background: var(--white); + border: 1px solid #e8e8e8; + border-radius: var(--radius); + padding: 28px; + transition: box-shadow 0.2s; +} + +.about__card:hover { + box-shadow: 0 4px 16px rgba(0, 0, 0, 0.06); +} + +.about__card h3 { + font-family: "JetBrains Mono", "Fira Code", monospace; + font-size: 1.1rem; + margin-bottom: 8px; +} + +.about__card .icon { + font-size: 1.8rem; + margin-bottom: 12px; + display: block; +} + +/* === Topics === */ +.topics__list { + display: flex; + flex-wrap: wrap; + gap: 12px; + margin-top: 24px; +} + +.topic-tag { + background: var(--sky-light); + border: 1px solid var(--sky); + border-radius: 24px; + padding: 8px 20px; + font-size: 0.9rem; + font-weight: 500; + white-space: nowrap; +} + +/* === Workshops / Events === */ +.events__list { + display: flex; + flex-direction: column; + gap: 20px; + margin-top: 24px; +} + +.event-card { + background: var(--white); + border: 1px solid #e8e8e8; + border-radius: var(--radius); + padding: 24px 28px; + display: flex; + align-items: flex-start; + gap: 20px; + transition: box-shadow 0.2s, border-color 0.2s; + text-decoration: none; + color: var(--ink); +} + +.event-card:hover { + box-shadow: 0 4px 16px rgba(0, 0, 0, 0.06); + border-color: var(--sky); + color: var(--ink); +} + +.event-card__date { + font-family: "JetBrains Mono", "Fira Code", monospace; + font-size: 0.85rem; + color: var(--ink-light); + background: var(--sand-light); + border-radius: 8px; + padding: 8px 12px; + white-space: nowrap; + text-align: center; + min-width: 90px; +} + +.event-card__content h3 { + font-size: 1.05rem; + margin-bottom: 4px; +} + +.event-card__content p { + color: var(--ink-light); + font-size: 0.92rem; +} + +/* === Join / CTA === */ +.join { + text-align: center; + background: linear-gradient(135deg, var(--sky-light) 0%, var(--sand-light) 100%); +} + +.join__links { + display: flex; + justify-content: center; + gap: 16px; + margin-top: 28px; + flex-wrap: wrap; +} + +.join__link { + display: inline-flex; + align-items: center; + gap: 8px; + background: var(--white); + border: 1px solid #e0e0e0; + border-radius: 8px; + padding: 12px 24px; + text-decoration: none; + font-weight: 500; + transition: border-color 0.2s, box-shadow 0.2s; +} + +.join__link:hover { + border-color: var(--sky); + box-shadow: 0 2px 12px rgba(0, 0, 0, 0.06); + color: var(--ink); +} + +/* === Footer === */ +.footer { + background: var(--ink); + color: #c0c0c0; + padding: 32px 0; + text-align: center; + font-size: 0.88rem; +} + +.footer a { + color: var(--sky); +} + +/* === Code decoration === */ +.code-bg { + position: relative; + overflow: hidden; +} + +.code-bg > * { + position: relative; + z-index: 1; +} + +.code-snippets { + position: absolute; + inset: 0; + z-index: 0; + pointer-events: none; + display: grid; + grid-template-columns: 1fr 1fr 1fr 1fr; + gap: 16px; + padding: 20px; + opacity: 0.45; + mask-image: radial-gradient(ellipse 90% 80% at 50% 50%, black 30%, transparent 75%); + -webkit-mask-image: radial-gradient(ellipse 90% 80% at 50% 50%, black 30%, transparent 75%); +} + +.code-snippets pre { + font-family: "JetBrains Mono", monospace; + font-size: 0.65rem; + line-height: 1.5; + white-space: pre; + overflow: hidden; + margin: 0; + text-align: left; +} + +/* Syntax highlighting colors */ +.code-snippets .kw { color: #7c3aed; } /* keywords - purple */ +.code-snippets .fn { color: #2563eb; } /* functions - blue */ +.code-snippets .ty { color: #0891b2; } /* types - teal */ +.code-snippets .str { color: #16a34a; } /* strings - green */ +.code-snippets .num { color: #dc2626; } /* numbers - red */ +.code-snippets .op { color: #9333ea; } /* operators - violet */ +.code-snippets .cm { color: #6b7280; font-style: italic; } /* comments - gray */ +.code-snippets .var { color: #1e3a5f; } /* variables - dark blue */ + +@media (max-width: 700px) { + .code-snippets { + grid-template-columns: 1fr 1fr; + font-size: 0.5rem; + } +} + +/* === Responsive === */ +@media (max-width: 700px) { + .hero h1 { + font-size: 2rem; + } + + .hero__logo { + width: 120px; + height: 120px; + } + + .about__grid { + grid-template-columns: 1fr; + } + + .event-card { + flex-direction: column; + } + + .nav__links { + gap: 16px; + } +} -- cgit v1.3.1