unofficial mirror of guix-devel@gnu.org 
 help / color / mirror / code / Atom feed
From: Ricardo Wurmus <rekado@elephly.net>
To: "Ludovic Courtès" <ludo@gnu.org>
Cc: zimoun <zimon.toutoune@gmail.com>,
	guix-devel@gnu.org,
	GNU Guix maintainers <guix-maintainers@gnu.org>
Subject: Re: Teams: first draft list
Date: Fri, 01 Jul 2022 12:28:33 +0200	[thread overview]
Message-ID: <878rpd6q3r.fsf@elephly.net> (raw)
In-Reply-To: <87a6a43j0j.fsf@gnu.org>

[-- Attachment #1: Type: text/plain, Size: 1208 bytes --]


Ludovic Courtès <ludo@gnu.org> writes:

> Ricardo Wurmus <rekado@elephly.net> skribis:
>
>> Now the question is merely how to represent and present this.  It’s not
>> a bad idea to have the team associations in the repository so that we
>> can present the data on the website and also use it with our tools to
>> notify the right people.
>
> Mathieu suggested that we have a team file in guix.git, which would
> allow us to eventually write tools like ‘get-tutors.scm’ as Mathieu
> calls it.

Attached is a draft etc/teams.scm, which defines teams, their members,
and procedures to fetch a relevant subset of the information.

An example:

   ./pre-inst-env guile --no-auto-compile -l etc/teams.scm -c '(cc r core)'

This prints “git send-email” arguments to Cc members of the R and Core
teams when a patch is received by Debbugs.

Another example:

   ./pre-inst-env guile --no-auto-compile \
     -l etc/teams.scm -c '(list-teams)' | recsel -p name,members

I haven’t defined any other members yet, because I think it’s better for
people to do this by themselves to avoid adding people who don’t
actually want to be a member of any team.

-- 
Ricardo


[-- Attachment #2: teams.scm --]
[-- Type: application/octet-stream, Size: 5795 bytes --]

;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2022 Ricardo Wurmus <rekado@elephly.net>
;;;
;;; This file is part of GNU Guix.
;;;
;;; GNU Guix is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.

;;; Commentary:

;; This code defines development teams and team members.

;;; Code:

(use-modules (srfi srfi-1)
             (srfi srfi-9)
             (ice-9 format)
             (guix ui))

(define-record-type <team>
  (make-team id name description members)
  team?
  (id          team-id)
  (name        team-name)
  (description team-description)
  (members     team-members set-team-members!))

(define-record-type <person>
  (make-person name email)
  person?
  (name    person-name)
  (email   person-email))

(define* (person name #:optional email)
  (make-person name email))

(define* (team id #:key name description (members '()))
  (make-team id
             (or name (symbol->string id))
             description
             members))

(define %teams
  (make-hash-table))

(define-syntax define-team
  (lambda (x)
    (syntax-case x ()
      ((_ id value)
       #`(begin
           (define-public id value)
           (hash-set! %teams 'id id))))))

(define-syntax-rule (define-member person teams ...)
  (let ((p person))
    (for-each (lambda (team-id)
                (let ((team
                       (hash-ref %teams team-id
                                 (lambda ()
                                   (error (format #false
                                                  "Unknown team ~a for ~a~%"
                                                  team-id p))))))
                  (set-team-members!
                   team (cons p (team-members team)))))
              (quote (teams ...)))))

(define (cc . teams)
  "Return arguments for `git send-email' to notify the members of the given
TEAMS when a patch is received by Debbugs."
  (format #true
          "~{--add-header=\"X-Debbugs-Cc: ~a\"~^ ~}"
          (map person-email
               (delete-duplicates (append-map team-members teams) equal?))))

(define (list-teams)
  "Print all teams and their members."
  (define port* (current-output-port))
  (define width* (%text-width))
  (hash-for-each
   (lambda (key team)
     (format port*
             "\
id: ~a
name: ~a
description: ~a
members:
"
             (team-id team)
             (team-name team)
             (or (and=> (team-description team)
                        (lambda (text)
                          (string->recutils
                           (fill-paragraph text width*
                                           (string-length "description: ")))))
                 "<none>"))
     (for-each
      (lambda (member)
        (format port*
                "+ ~a <~a>~%"
                (person-name member)
                (person-email member)))
      (team-members team))
     (newline))
   %teams))

\f
(define-team python
  (team 'python
        #:name "Python team"
        #:description
        "Python, Python packages, the \"pypi\" importer, and the python-build-system."))

(define-team haskell
  (team 'haskell
        #:name "Haskell team"
        #:description
        "GHC, Hugs, Haskell packages, the \"hackage\" and \"stackage\" importers, and
the haskell-build-system."))

(define-team r
  (team 'r
        #:name "R team"
        #:description
        "The R language, CRAN and Bioconductor repositories, the \"cran\" importer,
and the r-build-system."))

(define-team julia
  (team 'julia
        #:name "Julia team"
        #:description
        "The Julia language, Julia packages, and the julia-build-system."))

(define-team ocaml
  (team 'ocaml
        #:name "OCaml and Dune team"
        #:description
        "The OCaml language, the Dune build system, OCaml packages, the \"opam\"
importer, and the ocaml-build-system."))

(define-team java
  (team 'java
        #:name "Java and Maven team"
        #:description
        "The JDK and JRE, the Maven build system, Java packages, the ant-build-system,
and the maven-build-system."))

(define-team maths
  (team 'maths
        #:name "Algebra and Maths team"))

(define-team emacs
  (team 'emacs
        #:name "Emacs team"))

(define-team lisp
  (team 'lisp
        #:name "Lisp team"))

(define-team ruby
  (team 'ruby
        #:name "Ruby team"))

(define-team go
  (team 'go
        #:name "Go team"))

(define-team embedded-bootstrap
  (team 'embedded-bootstrap
        #:name "Embedded / Bootstrap"))

(define-team rust
  (team 'rust
        #:name "Rust"))

(define-team kernel
  (team 'kernel
        #:name "Linux-libre kernel team"))

(define-team core
  (team 'core
        #:name "Core / Tools / Internals"))

(define-team games
  (team 'games
        #:name "Games and Videos"))

(define-team translations
  (team 'translations
        #:name "Translations"))

(define-team installer
  (team 'installer
        #:name "Installer script and system installer"))

(define-team home
  (team 'home
        #:name "Team for \"guix home\""))

\f
(define-member (person "Ricardo Wurmus"
                       "rekado@elephly.net")
  r core)

(define-member (person "Ludovic Courtès"
                       "ludo@gnu.org")
  core home embedded-bootstrap)

  parent reply	other threads:[~2022-07-01 11:16 UTC|newest]

Thread overview: 62+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2022-06-04 12:07 Teams Ricardo Wurmus
2022-06-04 13:00 ` Teams Maxime Devos
2022-06-04 13:19 ` Teams Ekaitz Zarraga
2022-06-04 14:50 ` Teams Tobias Geerinckx-Rice
2022-06-04 15:52   ` Teams Maxime Devos
2022-06-04 15:56   ` Teams david larsson
2022-06-05  9:10   ` Teams pelzflorian (Florian Pelz)
2022-06-07  4:11     ` Teams Thiago Jung Bauermann
2022-06-05  8:19 ` Teams Josselin Poiret
2022-06-06 21:21   ` Teams Ludovic Courtès
2022-06-14 11:31   ` Teams Andrew Tropin
2022-06-14 18:52     ` Teams Blake Shaw
2022-06-15  6:19       ` how to write services (was: Re: Teams) catonano
2022-06-15 13:53         ` Ricardo Wurmus
2022-06-15 17:01           ` Blake Shaw
2022-06-15 17:32             ` Maxime Devos
     [not found]               ` <CAKjmbcA56WL8ude232fz_5_G9U2RfoNNf4gqMHu5tft5kMbjFQ@mail.gmail.com>
2022-06-15 22:04                 ` Maxime Devos
2022-06-15 22:13                 ` Maxime Devos
2022-06-15 22:28                 ` Maxime Devos
2022-06-15 23:20                   ` Blake Shaw
2022-06-16  8:27                     ` Maxime Devos
2022-06-16  5:14             ` catonano
2022-06-16  6:46               ` Ricardo Wurmus
2022-06-16 13:09               ` Brian Cully via Development of GNU Guix and the GNU System distribution.
2022-06-18 11:53                 ` how to write services indieterminacy
2022-06-18 12:23                   ` Maxime Devos
2022-06-18 13:33                     ` indieterminacy
2022-06-15 10:53       ` How to write a service (was: Re: Teams) catonano
2022-06-05  9:31 ` Teams Lars-Dominik Braun
2022-06-05  9:51 ` Teams zimoun
2022-06-05 10:00   ` Teams Julien Lepiller
2022-06-07 17:49   ` Teams Efraim Flashner
2022-06-05  9:51 ` Teams Andreas Enge
2022-06-09  4:39   ` Teams Eric Bavier
2022-06-05 10:30 ` Teams indieterminacy
2022-06-05 17:59 ` Teams Mathieu Othacehe
2022-06-06 21:26   ` Teams Ludovic Courtès
2022-06-06 14:12 ` Teams Maxim Cournoyer
2022-06-07  0:28 ` Teams Ryan Prior
2022-06-07 19:06 ` Teams Vagrant Cascadian
2022-06-08 21:30   ` Teams Ludovic Courtès
2022-06-09  2:21     ` Teams Thiago Jung Bauermann
2022-06-09 19:28 ` Teams Arun Isaac
2022-06-13 13:38   ` Teams Blake Shaw
2022-06-13 22:33     ` Teams raingloom
2022-06-21 15:21 ` Teams: first draft list zimoun
2022-06-21 17:28   ` bokr
2022-06-21 22:21     ` zimoun
2022-06-22  6:56       ` Efraim Flashner
2022-06-22 16:19         ` bokr
2022-06-22  7:59   ` Ricardo Wurmus
2022-06-22  9:19     ` zimoun
2022-06-22 12:30       ` Josselin Poiret
2022-06-22 13:10         ` Maxime Devos
2022-06-22 13:49     ` Ludovic Courtès
2022-06-22 14:18       ` Blake Shaw
2022-07-01 10:28       ` Ricardo Wurmus [this message]
2022-07-01 17:36         ` Liliana Marie Prikler
2022-07-01 19:08           ` Ricardo Wurmus
2022-07-03 13:04             ` Teams: please add yourself to etc/teams.scm.in Ricardo Wurmus
2022-07-03 14:51               ` Andreas Enge
2022-07-01 20:53   ` Teams: first draft list Leo Famulari

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

  List information: https://guix.gnu.org/

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=878rpd6q3r.fsf@elephly.net \
    --to=rekado@elephly.net \
    --cc=guix-devel@gnu.org \
    --cc=guix-maintainers@gnu.org \
    --cc=ludo@gnu.org \
    --cc=zimon.toutoune@gmail.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
Code repositories for project(s) associated with this public inbox

	https://git.savannah.gnu.org/cgit/guix.git

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).