path: root/site/index.html

<!DOCTYPE html>
<html lang="fr">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Lambda Nantes - Programmation fonctionnelle et langages</title>
  <meta name="description" content="Lambda Nantes est un groupe de développeuses et développeurs de Nantes passionnés par la programmation fonctionnelle, les langages de programmation et la théorie des types.">

  <!-- Fonts -->
  <link rel="preconnect" href="https://fonts.googleapis.com">
  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
  <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=JetBrains+Mono:wght@400;700&display=swap" rel="stylesheet">

  <link rel="stylesheet" href="style.css">
  <link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><text y='.9em' font-size='90'>&#955;</text></svg>">
</head>
<body>

  <!-- Hero -->
  <header class="hero code-bg">
    <div class="code-snippets" aria-hidden="true">
      <pre><span class="cm">(* OCaml *)</span>
<span class="kw">let</span> <span class="fn">tape_backward</span> last =
  <span class="kw">let</span> tp = !tape <span class="kw">in</span>
  <span class="kw">let</span> vals = tp.vals <span class="kw">in</span>
  <span class="kw">let</span> grads = tp.grads <span class="kw">in</span>
  <span class="kw">for</span> cur = last <span class="kw">downto</span> <span class="num">0</span> <span class="kw">do</span>
    <span class="kw">let</span> g = <span class="ty">Float.Array</span>.get grads cur <span class="kw">in</span>
    <span class="kw">if</span> g &lt;&gt; <span class="num">0.0</span> <span class="kw">then begin</span>
      <span class="kw">let</span> op = ops.(cur) <span class="kw">in</span>
      <span class="kw">if</span> op = op_mul <span class="kw">then begin</span>
        <span class="ty">Float.Array</span>.set grads p1
          (grads p1 <span class="op">+.</span> g <span class="op">*.</span> vals p2);
        <span class="ty">Float.Array</span>.set grads p2
          (grads p2 <span class="op">+.</span> g <span class="op">*.</span> vals p1)
      <span class="kw">end</span>
    <span class="kw">end</span>
  <span class="kw">done</span>

<span class="kw">let</span> <span class="fn">softmax</span> logits =
  <span class="kw">let</span> m = <span class="ty">Array</span>.fold_left max
    neg_infinity logits <span class="kw">in</span>
  <span class="kw">let</span> exps = <span class="ty">Array</span>.map
    (<span class="kw">fun</span> x <span class="op">-&gt;</span> exp (x <span class="op">-.</span> m)) logits <span class="kw">in</span>
  <span class="kw">let</span> s = <span class="ty">Array</span>.fold_left
    (<span class="op">+.</span>) <span class="num">0.0</span> exps <span class="kw">in</span>
  <span class="ty">Array</span>.map (<span class="kw">fun</span> x <span class="op">-&gt;</span> x <span class="op">/.</span> s) exps</pre>

      <pre><span class="cm">-- Haskell</span>
<span class="fn">randomGaussian</span> <span class="op">::</span> <span class="ty">Double</span> <span class="op">-&gt;</span> <span class="ty">Double</span> <span class="op">-&gt;</span> <span class="ty">IO Double</span>
<span class="fn">randomGaussian</span> &#956; &#963; = <span class="kw">do</span>
  u1 <span class="op">&lt;-</span> randomIO <span class="op">::</span> <span class="ty">IO Double</span>
  u2 <span class="op">&lt;-</span> randomIO <span class="op">::</span> <span class="ty">IO Double</span>
  <span class="kw">let</span> z0 = sqrt (<span class="op">-</span>(<span class="num">2.0</span> <span class="op">*</span> log u1))
           <span class="op">*</span> cos (<span class="num">2.0</span> <span class="op">*</span> pi <span class="op">*</span> u2)
  pure <span class="op">$</span> &#956; <span class="op">+</span> &#963; <span class="op">*</span> z0

<span class="fn">applyGradients</span> <span class="op">::</span> <span class="ty">Model</span> <span class="op">-&gt;</span> <span class="ty">LearningParameters</span>
  <span class="op">-&gt;</span> <span class="ty">Int</span> <span class="op">-&gt;</span> <span class="ty">UV.Vector Double</span>
  <span class="op">-&gt;</span> <span class="ty">Training</span> <span class="op">-&gt;</span> <span class="ty">IO</span> ()
<span class="fn">applyGradients</span> <span class="ty">Model</span>{weightValues}
    params step grads
    <span class="ty">Training</span>{mAdam, vAdam} = <span class="kw">do</span>
  <span class="kw">let</span> n = <span class="ty">UMV</span>.length weightValues
  forM_ [<span class="num">0</span> .. n <span class="op">-</span> <span class="num">1</span>] <span class="op">$</span> \i <span class="op">-&gt;</span> <span class="kw">do</span>
    <span class="kw">let</span> m_i' = beta1 <span class="op">*</span> m_i
              <span class="op">+</span> (<span class="num">1</span> <span class="op">-</span> beta1) <span class="op">*</span> w_grad
        v_i' = beta2 <span class="op">*</span> v_i
              <span class="op">+</span> (<span class="num">1</span> <span class="op">-</span> beta2) <span class="op">*</span> w_grad <span class="op">*</span> w_grad
    <span class="ty">UMV</span>.write weightValues i
      <span class="op">$</span> w <span class="op">-</span> lr <span class="op">*</span> m_hat <span class="op">/</span> (sqrt v_hat <span class="op">+</span> eps)</pre>

      <pre><span class="cm">; Scheme</span>
(<span class="kw">define</span> (<span class="fn">tape:eval-linear</span> last)
  (<span class="kw">let</span> ((tp (<span class="op">*</span>tape<span class="op">*</span>)))
    (<span class="kw">let</span> <span class="fn">loop</span> ((i <span class="num">0</span>))
      (<span class="kw">when</span> (fx&lt;= i last)
        (<span class="kw">let</span> ((op-tag (vector-ref
                (tape-op tp) i))
              (vals (tape-val tp)))
          (<span class="kw">cond</span>
            ((fx= op-tag <span class="var">op-add</span>)
             (f64vector-set! vals i
               (<span class="op">+</span> (f64vector-ref vals
                    (vector-ref
                      (tape-p1 tp) i))
                  (f64vector-ref vals
                    (vector-ref
                      (tape-p2 tp) i)))))
            ((fx= op-tag <span class="var">op-mul</span>)
             (f64vector-set! vals i
               (<span class="op">*</span> (f64vector-ref vals
                    (vector-ref
                      (tape-p1 tp) i))
                  (f64vector-ref vals
                    (vector-ref
                      (tape-p2 tp) i)))))))
        (<span class="fn">loop</span> (fx+ i <span class="num">1</span>))))))</pre>

      <pre><span class="cm">\ Forth</span>
<span class="op">:</span> <span class="fn">gaussian</span> <span class="cm">( mean stddev -- val )</span>
  <span class="num">1e</span> frnd f- frnd
  flog <span class="num">2e</span> fnegate f* fsqrt fswap
  <span class="num">2e</span> pi f* f* fcos f* f* f+ <span class="op">;</span>

<span class="op">:</span> <span class="fn">matvec-mul</span>
  <span class="cm">( mat vec rows cols -- res )</span>
  { mat vec rows cols }
  rows cells allocate throw
  { result }
  rows <span class="num">0</span> <span class="kw">do</span> i { row }
    mat row cols <span class="op">*</span> cells <span class="op">+</span> @
    vec @ <span class="op">*.</span>
    cols <span class="num">1</span> <span class="kw">do</span>
      mat row cols <span class="op">*</span> i <span class="op">+</span>
        cells <span class="op">+</span> @
      vec i cells <span class="op">+</span> @ <span class="op">*.</span> <span class="op">+.</span>
    <span class="kw">loop</span>
    result row cells <span class="op">+</span> !
  <span class="kw">loop</span> result <span class="op">;</span>

<span class="op">:</span> <span class="fn">layer-forward</span>
  <span class="cm">( input w b n-in n-out )</span>
  { inp w b n-in n-out }
  n-out cells allocate throw
  { out }
  n-out <span class="num">0</span> <span class="kw">do</span>
    b i cells <span class="op">+</span> @ { acc }
    n-in <span class="num">0</span> <span class="kw">do</span>
      inp j cells <span class="op">+</span> @
      w i n-in <span class="op">*</span> j <span class="op">+</span> cells <span class="op">+</span> @
      <span class="op">*.</span> acc <span class="op">+.</span> to acc
    <span class="kw">loop</span>
    acc out i cells <span class="op">+</span> !
  <span class="kw">loop</span> out <span class="op">;</span></pre>
    </div>

    <div class="container">
      <img src="assets/logo.png" alt="Logo Lambda Nantes" class="hero__logo">
      <h1><span class="lambda">&lambda;</span>-Nantes</h1>
      <p class="hero__tagline">
        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.
      </p>
      <a href="#rejoindre" class="hero__cta">Nous rejoindre</a>
    </div>
  </header>

  <!-- Nav -->
  <nav class="nav">
    <div class="container nav__inner">
      <a href="#" class="nav__brand"><span class="lambda">&lambda;</span>-Nantes</a>
      <ul class="nav__links">
        <li><a href="#a-propos">A propos</a></li>
        <li><a href="#sujets">Sujets</a></li>
        <li><a href="#ateliers">Rencontres</a></li>
        <li><a href="#rejoindre">Rejoindre</a></li>
      </ul>
    </div>
  </nav>

  <!-- About -->
  <section id="a-propos">
    <div class="container">
      <h2 class="section__title">A propos</h2>
      <p class="section__subtitle">
        Nous nous réunissons régulièrement pour des conférences et des ateliers
        autour des langages de programmation et du développement logiciel.
      </p>
      <div class="about__grid">
        <div class="about__card">
          <span class="icon" aria-hidden="true">&lambda;</span>
          <h3>Programmation fonctionnelle</h3>
          <p>
            Haskell, OCaml, Elm, Elixir, Clojure, Scala...
            Nous explorons les langages fonctionnels et les concepts qui les sous-tendent.
          </p>
        </div>
        <div class="about__card">
          <span class="icon" aria-hidden="true">&forall;</span>
          <h3>Théorie des types</h3>
          <p>
            Des types simples aux types dépendants, en passant par le polymorphisme
            et les systèmes de preuves.
          </p>
        </div>
        <div class="about__card">
          <span class="icon" aria-hidden="true">&vdash;</span>
          <h3>Langages et compilation</h3>
          <p>
            Conception de langages, interpréteurs, compilateurs,
            machines virtuelles et analyses statiques.
          </p>
        </div>
        <div class="about__card">
          <span class="icon" aria-hidden="true">&supe;</span>
          <h3>Développement logiciel</h3>
          <p>
            Tests, qualité, architecture, outils...
            Tout ce qui rend le développement logiciel plus fiable et agréable.
          </p>
        </div>
      </div>
    </div>
  </section>

  <!-- Topics -->
  <section id="sujets">
    <div class="container">
      <h2 class="section__title">Nos sujets de prédilection</h2>
      <p class="section__subtitle">
        Quelques-uns des thèmes que nous abordons lors de nos rencontres.
      </p>
      <div class="topics__list">
        <span class="topic-tag">Lambda-calcul</span>
        <span class="topic-tag">Haskell</span>
        <span class="topic-tag">OCaml</span>
        <span class="topic-tag">Typage</span>
        <span class="topic-tag">Preuves formelles</span>
        <span class="topic-tag">Property-based testing</span>
        <span class="topic-tag">Interpréteurs</span>
        <span class="topic-tag">Compilateurs</span>
        <span class="topic-tag">Elm</span>
        <span class="topic-tag">Rust</span>
        <span class="topic-tag">Prolog</span>
        <span class="topic-tag">Catégories</span>
        <span class="topic-tag">Effets algébriques</span>
        <span class="topic-tag">Logique</span>
        <span class="topic-tag">Récursion</span>
        <span class="topic-tag">Monades</span>
        <span class="topic-tag">Parsers</span>
      </div>
    </div>
  </section>

  <!-- Events -->
  <section id="ateliers">
    <div class="container">
      <h2 class="section__title">Nos rencontres</h2>
      <p class="section__subtitle">
        Retrouvez l'historique de nos rencontres depuis 2022. Conférences, ateliers
        et discussions autour de la programmation fonctionnelle.
      </p>
      <div class="events__list">
        <a href="events/2026-05-21-programmation-compositionnelle.html" class="event-card">
          <div class="event-card__date">21 mai<br>2026</div>
          <div class="event-card__content">
            <h3>Programmation compositionnelle et traversabilité</h3>
            <p>Expression Problem et foncteurs applicatifs avec Eric Torreborre et Clément Delafargue.</p>
          </div>
        </a>
        <a href="events/2026-04-16-atelier-4.html" class="event-card">
          <div class="event-card__date">16 avr<br>2026</div>
          <div class="event-card__content">
            <h3>Atelier Lambda Nantes #4</h3>
            <p>OCaml pour le web : développement et déploiement d'un unikernel.</p>
          </div>
        </a>
        <a href="events/2026-03-19-plain-pattern-language.html" class="event-card">
          <div class="event-card__date">19 mar<br>2026</div>
          <div class="event-card__content">
            <h3>Lambda Nantes 10 : Plain Pattern Language</h3>
            <p>Grammaires formelles et génération procédurale avec Lorie den Os.</p>
          </div>
        </a>
        <a href="events/2026-02-19-langages-de-niches.html" class="event-card">
          <div class="event-card__date">19 fév<br>2026</div>
          <div class="event-card__content">
            <h3>Lambda Nantes 9 : Pourquoi choisir des langages de niches ?</h3>
            <p>Retour d'expérience Scala, Haskell et Rust avec Clément Delafargue.</p>
          </div>
        </a>
        <a href="events/2025-12-10-interprete-prolog.html" class="event-card">
          <div class="event-card__date">10 déc<br>2025</div>
          <div class="event-card__content">
            <h3>Workshop 3 : Créons un interprète Prolog</h3>
            <p>Atelier collaboratif d'introduction à la programmation logique.</p>
          </div>
        </a>
        <a href="events/2025-11-13-injection-dependances.html" class="event-card">
          <div class="event-card__date">13 nov<br>2025</div>
          <div class="event-card__content">
            <h3>Lambda Nantes 8 : Injection de dépendances fonctionnelle</h3>
            <p>Comparaison Unison vs OCaml avec Eric Torreborre et Xavier van de Woestyne.</p>
          </div>
        </a>
        <a href="events/2025-10-09-lambda-calcul-type.html" class="event-card">
          <div class="event-card__date">09 oct<br>2025</div>
          <div class="event-card__content">
            <h3>Workshop 2bis : Interprétons le lambda-calcul typé</h3>
            <p>Ajout d'un système de types simples à un interpréteur de lambda-calcul.</p>
          </div>
        </a>
        <a href="events/2025-03-27-logs-observabilite.html" class="event-card">
          <div class="event-card__date">27 mar<br>2025</div>
          <div class="event-card__content">
            <h3>LambdaNantes 7 : Logs, traçabilité et observabilité</h3>
            <p>OpenTelemetry et observabilité dans les systèmes distribués avec Lucas.</p>
          </div>
        </a>
        <a href="events/2025-01-30-tests-proprietes.html" class="event-card">
          <div class="event-card__date">30 jan<br>2025</div>
          <div class="event-card__content">
            <h3>LambdaNantes 6 : Les tests dirigés par les propriétés</h3>
            <p>Atelier property-based testing avec Arnaud Bailly.</p>
          </div>
        </a>
        <a href="events/2024-10-10-lambda-calcul.html" class="event-card">
          <div class="event-card__date">10 oct<br>2024</div>
          <div class="event-card__content">
            <h3>Workshop 1 : Interprétons le Lambda Calcul</h3>
            <p>Premier atelier : construire un interpréteur de lambda-calcul.</p>
          </div>
        </a>
        <a href="events/2024-06-20-types-dependants.html" class="event-card">
          <div class="event-card__date">20 jun<br>2024</div>
          <div class="event-card__content">
            <h3>LambdaNantes 5 : Types, types et types (dépendants)</h3>
            <p>Type-Driven Development et types dépendants avec Arnaud Bailly et Didier Plaindoux.</p>
          </div>
        </a>
        <a href="events/2023-10-23-monades-gratuites.html" class="event-card">
          <div class="event-card__date">23 oct<br>2023</div>
          <div class="event-card__content">
            <h3>LambdaNantes 4 : Monades Gratuites et Systèmes de build</h3>
            <p>Free Monads et build systems avec Nicolas Rinaudo et Xavier Van de Woestyne.</p>
          </div>
        </a>
        <a href="events/2023-06-23-haskell.html" class="event-card">
          <div class="event-card__date">23 jun<br>2023</div>
          <div class="event-card__content">
            <h3>LambdaNantes 3 : Haskell à l'honneur</h3>
            <p>Biscuit tokens et Flora.pm avec Clément Delafargue et Théophile Choutri.</p>
          </div>
        </a>
        <a href="events/2022-09-20-gadts-free-monads.html" class="event-card">
          <div class="event-card__date">20 sep<br>2022</div>
          <div class="event-card__content">
            <h3>LambdaNantes 2 : GADTs et Free Monades</h3>
            <p>Réalité des Free Monads et méthodes gardées avec Arnaud Bailly et Xavier Van de Woestyne.</p>
          </div>
        </a>
        <a href="events/2022-05-19-reutilisation-effets.html" class="event-card">
          <div class="event-card__date">19 mai<br>2022</div>
          <div class="event-card__content">
            <h3>LambdaNantes 1 : Réutilisation de fonctions et abstraction d'effets</h3>
            <p>Première édition ! Monads, Functors et stream processing avec Nicolas Rinaudo et Romain Lecomte.</p>
          </div>
        </a>
      </div>
    </div>
  </section>

  <!-- Join -->
  <section id="rejoindre" class="join">
    <div class="container">
      <h2 class="section__title">Nous rejoindre</h2>
      <p class="section__subtitle" style="margin-left:auto;margin-right:auto;">
        Que vous soyez débutant ou expert, vous êtes les bienvenu(e)s !
        Retrouvez-nous sur Mobilizon pour connaître les prochains événements.
      </p>
      <div class="join__links">
        <a href="https://mobilizon.fr/@lambdanantes" class="join__link" target="_blank" rel="noopener">
          <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="4" width="18" height="18" rx="2" ry="2"></rect><line x1="16" y1="2" x2="16" y2="6"></line><line x1="8" y1="2" x2="8" y2="6"></line><line x1="3" y1="10" x2="21" y2="10"></line></svg>
          Mobilizon
        </a>
        <a href="https://radicle.network/nodes/seed.hydra.bzh/rad:z28SSH7hyCTu387guFhtPXYxcwtUs" class="join__link" target="_blank" rel="noopener">
          <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="3"></circle><path d="M12 2v4m0 12v4M4.93 4.93l2.83 2.83m8.48 8.48l2.83 2.83M2 12h4m12 0h4M4.93 19.07l2.83-2.83m8.48-8.48l2.83-2.83"></path></svg>
          Radicle
        </a>
      </div>
    </div>
  </section>

  <!-- Footer -->
  <footer class="footer">
    <div class="container">
      <p>&lambda;-Nantes &mdash; Nantes, France</p>
    </div>
  </footer>

</body>
</html>