Documentation Community Team Meeting (January 2024)#

  • Date: 2024-01-02

  • Time: 20:00 UTC

  • This HackMD:

  • Discourse thread (for January)

  • Meeting reports (the latest one might be an unmerged PR)

  • Calendar event: (send your e-mail to Mariatta for an invitation)

  • How to participate:

    • Go to Google Meet and ask to be let in.

    • To edit notes, click the “pencil” or “split view” button on the HackMD document. You need to log in (e.g. with a GitHub account).

By participating in this meeting, you are agreeing to abide by and uphold the PSF Code of Conduct. Please take a second to read through it!

Roll call#

(Name / @GitHubUsername [/ Discord, if different])

  • Carol Willing / @willingc / carolwilling

  • Petr Viktorin / @encukou

  • Ezio Melotti / @ezio-melotti

  • Hugo van Kemenade / @hugovk

  • Guido van Rossum / @gvanrossum

  • Daniele / @EvilDMP / danieleprocida

  • Ege Akman / @egeakman

  • Ned / @nedbat

  • Ryan / @ryan-duve

  • Jim / @JDLH

  • CAM / @CAM-Gerlach

  • Usman Akinyemi / @Unique-Usman

  • Bradley / @shenanigansd

Reports and celebrations#

  • The Steering Council has accepted PEP 732 (“The Python Documentation Editorial Board”) 🎉

    • [Carol] First meeting will be January 8, 2024.

    • [Carol] Looking at docs and website from a new user’s perspective

    • [Hugo] What would be the best way to contact the Board? [Guido] That’s already on the agenda. [Carol] For the short term we could use the docs community repo too.

  • I [Jim] appreciate how considerate this group is. The particular incident motivating my appreciation is that I got mentioned in the minutes of last meeting, and several people took pains to be sure that my name was presented there as I wanted it to be. Thank you.

  • [Ryan] We made the update to the TOML documentation we talked about on the last call and got my first Python pull request merged!


  • [Petr] The tkinter, pty/termios, sqlite3 (maybe more?) use master/slave terminology in API and docs. What’s the best way to come up with, and switch to, better terms? Is there an expert I should talk to?

    • [Carol] Thursday Bram has authored a Responsible Communications book which may have helpful guidelines. Other communities have used leader/follower. Linux PR on the subject

    • [Hugo] Some suggestions (Carol: I like the suggestions in this document for different usages.)

    • [CAM] Earlier BPO issue: python/cpython#78786

    • Next steps:

      • Check and update the devguide for new docs not to use terms and suggest alternatives

      • Determine process for future changes of existing terminology

      • Consider adding a statement to the documentation about existing code

    • Petr will bounce ideas off Daniele :)

  • Ryan tried introducing argument lists (like in sqlite3) to the collections module, didn’t work too well as the functions take one or two arguments and they’re pretty obvious. Petr recommended looking at subprocess.Popen.

    • [Carol] Ryan, feel free to ping me when you have an example since I’m very familiar with the scientific Python docs.

    • Guido doesn’t like forcing people to stick to a template

    • Daniele mentions there are two kinds of users, one of which – a forensic analyst – could need very strictly formatted documentation

    • [Guido] The bulleted list makes it less likely to fit everything on a screen. Vertical space is a precious resource.

    • [Carol] Doc usage has changed thanks to intellisense, nowadays you get lists of arguments on hovering.

    • [Carol] Areas where users ask for help most should get most attention.

    • [Ezio] In addition to arguments, there are also return values and raised exceptions that can be documented using specific Sphinx options.

    • [Ezio] Even though there is some value in having a consistent format for all these, I don’t think we should use bullet lists for them throughout the docs since arguments are usually already explained well enough in prose (return values and exceptions are sometimes harder to find though).

    • [Daniele] It doesn’t need to be machine-readable. It should always be maximally human-comfortable.

    • [Jim] It sounds like the framing of this discussion is, source text targeting a big module documentation page with docs for all that module’s methods. There are other possible targets: docstrings, tooltips text. Are there other targets for doc source which we should consider in this discussion?

    • [Ned] We write docs twice – once for the docstrings and once in rst. That’s more work, but it means we can have different strategies for each use case.

      • [Guido] Changing that would involve several PEPs.

      • [Ned] Right, I wasn’t suggesting we change it, just ensuring everyone knew.

    • [CAM] Sphinx has ways to generate docs for a whole module, or just a single function, from docstrings. But yes, starting to use that would need a PEP.

    • [CAM] The strategy we took for sqlite3 was to focus on the functions with most arguments, where the bulleted lists have most benefit, and leave the smaller functions for later, when we have more experience with the approach.

    • [Carol] And we should keep in mind that our perspectives are not necessarily the users’ perspective. If we do make major changes we should think about users and we should vet the changes.

    • Ryan started contributing by trying to get the contract of collections.Counter.most_common, and not finding it in the docstring nor in the documentation.

    • [Carol] If you’re coming from the scientific world, where the ? in IPython gives you the docstring, that is often the first thing you look at.

    • Ryan will take a look at only documenting return type and “raises” in a structured way, leaving parameters in the prose.

    • Guido warns that collections.Counter is not that typical.

  • If we have time, would like to hear from Daniele on the thread he started on the structure of the Python docs as to the takeaways from that so far and next steps there.

    • Discussion between Daniele and Ezio on the Python tutorial

  • [Carol] We should always go back to the users and what their pathways and needs are. The tutorial can’t fit all users – absolute beginners, people for whom Python is the first language, people coming from other languages. The current tutorial doesn’t work for completely new users.

  • [CAM] The current tutorial targets people who are already familiar with programming languages. Perhaps we should have separate tutorials for complete beginners and people coming from specific languages.

  • [Daniele] One drawback of the current tutorial is lots of preamble saying why you want to learn Python. But the user is already here, wanting to learn Python. We should start directly with the examples. Also, we don’t need to cover the edge cases right after people do something for the first time. Long explanations detract from the tutorial.

  • [Ezio] It seems that for the tutorial, examples work better than prose, for both new and experienced users. Also, we could have cheatsheets for people coming from other languages.

  • [Ezio] As an aside, the docs for builtin functions doesn’t have many examples. We could add a separate page with 1-3 examples for each function.

  • [Carol] There’s a bigger pressing need for onboarding people from different groups, like people who don’t know how to use the command line.

Next meeting#

The docs team generally meets on the first Tuesday of every month around 20:00-ish UTC.

We have a recurring Google Calendar event for the meeting. Let Mariatta know your email address and she can invite you.