Re: Python (was Re: I did not inhale)

On 28/08/2024 17:41, Bart wrote:

On 28/08/2024 16:25, John Ames wrote:

On Wed, 28 Aug 2024 02:48:59 -0000 (UTC)
Sebastian <sebastian@here.com.invalid> wrote:
>

At my company, somebody tried to delete a method like method2() above,
but forgot the last few lines (represented by call6()). This does
not introduce a SyntaxError. Instead, call6() is now part of method1()
because it's at the same level of indentation. In most programming
languages, the beginning of method2() would be preceded by some
delimiter marking the end of method1(), which would prevent an
accidental merger of this type.

>
(Waiting for the Python advocates to fire back with "well, don't do
that, then!" and completely miss the point that it's exactly the topic
of contention here that Python's scope-by-layout approach that makes it
easy to do that...)
>

 Or they will say that whoever deleted method2 could also have deleted that 'end' line if one was used. Whilst also forgetting to delete method2's own 'end' line.
 Or maybe they deleted method2 plus both the preceding and succeeding lines so that method1 merges into method3.
 Generally, they might point all the ways that such oversights and all kinds of other typos can result in still-valid code in any language. But fragile syntax like Python's just makes it so easier to do that.
 

Having overly-large functions in any language is a risky way to code. Deleting large chunks of a function is risky in any language.  Failing to have check in place (like automated tests) that catch the error fairly quickly is also risky in any language.
But it is fair to say, I think, that Python's space-sensitive syntax combined with limited static checking (even with tools like pylint) mean you are more likely to be able to make a mistake that is not spotted until later in testing, compared to languages with explicit block delimiters.
And it is made worse by Python common practice of defining all methods of a class inline in the class, leading to long stretches of code that is all indented at least one tabstop.  It is possible to add methods to a class later on - optionally after giving a placeholder, but it is not common practice (as far as I have seen) :
class A :
     def __init__(self) :
         self.x = 10
     def foo(self) :
         "Increment x"
         self.x = self.x + 1
         return self.x
     def foobar(self) :
         "Complicated action"
          raise NotImplementedError
def A_foobar(self) :
     self.x = self.x * 10
     return self.x
A.foobar = A_foobar
(I'm sure a decorator could be used to make this slightly neater.)