Path: ...!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: Keith Thompson <Keith.S.Thompson+u@gmail.com>
Newsgroups: comp.unix.shell,comp.unix.programmer,comp.lang.misc
Subject: Re: Python (was Re: I did not inhale)
Date: Wed, 28 Aug 2024 17:23:25 -0700
Organization: None to speak of
Lines: 136
Message-ID: <875xrkb2iq.fsf@nosuchdomain.example.com>
References: <uu54la$3su5b$6@dont-email.me> <va4aut$3q4g0$1@dont-email.me>
	<va4fbr$3qvij$1@dont-email.me> <va5108$3tmmd$1@dont-email.me>
	<va51ok$3tqr9$1@dont-email.me> <va5ec2$3vluh$1@dont-email.me>
	<va6q4g$c1a7$1@dont-email.me> <va6rpa$c6bg$1@dont-email.me>
	<va6se9$cb8e$1@dont-email.me> <20240826083330.00004760@gmail.com>
	<vaises$2k7o6$2@dont-email.me> <20240826155113.000005ba@gmail.com>
	<wwvo75eicla.fsf@LkoBDZeT.terraraq.uk> <vak9k9$2ujrs$1@dont-email.me>
	<valgpu$34s18$1@dont-email.me>
	<87y14hd4bk.fsf@nosuchdomain.example.com>
	<valnei$35rt8$2@dont-email.me>
	<87ikvlcs7i.fsf@nosuchdomain.example.com>
	<vamclm$3c4ke$1@dont-email.me>
	<87ttf4bdcx.fsf@nosuchdomain.example.com>
	<vaoaak$3l470$3@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: 8bit
Injection-Date: Thu, 29 Aug 2024 02:23:27 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="d17aacdbc8a710bbcdf54ea5a7e9baf3";
	logging-data="3842266"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX19RZmFtFJ5/GcwhQBBLI9ZN"
User-Agent: Gnus/5.13 (Gnus v5.13)
Cancel-Lock: sha1:enReKqZMoF2WJ+LPubXJbxQ0uhM=
	sha1:1wC0GrgoTsPbl2hw7xiuc9BgYoY=
Bytes: 6686

Lawrence D'Oliveiro <ldo@nz.invalid> writes:
> On Wed, 28 Aug 2024 13:29:18 -0700, Keith Thompson wrote:
>> But ok, I found your post and removed all the #end comments.  I found it
>> just as readable without them as with them.
>
> You know what? You are right. That example was just too
> well-structured.
>
> Here’s a more dangerous one:
>
>     def register_additional_standard(self, **kwargs) :
>         "registers additional standard interfaces that are not automatically" \
>         " installed at Connection creation time. Currently the only one is" \
>         " the object-manager interface, registered with\n" \
>         "\n" \
>         "    «conn».register_additional_standard(managed_objects = True)\n"

That's not the conventional way to format a docstring.  If you're using
backslashes to splice lines in Python, it's likely you're doing
something wrong.

>         for key in kwargs :
>             if kwargs[key] :
>                 if key == "managed_objects" :
>                     if self._managed_objects != None :

I think "is not None" is more idiomatic.

>                         raise asyncio.InvalidStateError \
>                           (
>                             "object manager interface already registered"
>                           )

You don't need the \ if you put the ( on the same line.

>                     #end if
>                     self.register \
>                       (
>                         path = "/",
>                         interface = ManagedObjectsHandler(),
>                         fallback = True
>                       )

Again, you've decided how you want to place parentheses and you're
forcing the syntax to cater to that.  I might write that as:

                    self.register(
                        path = "/",
                        interface = ManagedObjectsHandler(),
                        fallback = True
                    )

>                     self._managed_objects = {}
>                 else :

You leave a space between "else" and ":".  It's not wrong, but it's not
something I've ever seen.  It's likely to be just a little jarring to
readers.

>                     raise TypeError("unrecognized argument keyword “%s”" % key)

Do you have a requirement to use older versions of Python that don't
support f-strings?

>                 #end if
>             #end if
>         #end for
>         return \
>             self

Why not just "return self"?

>     #end register_additional_standard
>
> versus
>
>     def register_additional_standard(self, **kwargs) :
>         "registers additional standard interfaces that are not automatically" \
>         " installed at Connection creation time. Currently the only one is" \
>         " the object-manager interface, registered with\n" \
>         "\n" \
>         "    «conn».register_additional_standard(managed_objects = True)\n"
>         for key in kwargs :
>             if kwargs[key] :
>                 if key == "managed_objects" :
>                     if self._managed_objects != None :
>                         raise asyncio.InvalidStateError \
>                           (
>                             "object manager interface already registered"
>                           )
>                     self.register \
>                       (
>                         path = "/",
>                         interface = ManagedObjectsHandler(),
>                         fallback = True
>                       )
>                     self._managed_objects = {}
>                 else :
>                     raise TypeError("unrecognized argument keyword “%s”" % key)
>         return self

Again, the #end comments don't make it any more readable *for me*.
I suspect that would be even more true for more experienced Python
programmers.

> I was looking for quite a tricky example I remember seeing on the
> ArjanCodes channel on YouTube, but I can’t find it.

In any language, if a block of code is so deeply indented that it's
confusing, you should consider refactoring it.  (Though that's not
always the answer.)

I once reviewed some C code with misleading indentation.  Depending on
the viewer's tab settings (4 vs 8 columns) it looked either like this:

    if (condition)
        this;
        that;

or like this:

    if (condition)
        this;
    that;

Of course it meant the same to the compiler.

In any language, I think it's important to use consistent indentation
that reflects the structure of the code, and to avoid mixing tabs and
spaces.  (My personal preference is to use spaces exclusively, but I'll
conform to what existing code does.)  As I've said elsethread, Python's
rules just force me to do what I would have done anyway.

-- 
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
void Void(void) { Void(); } /* The recursive call of the void */