Python is DOOMED! Again!

[Mark Lawrence]

On 28/01/2015 15:04, Mario Figueiredo wrote:
> In article <54c83ab4$0$12982$c3e8da3$5496439d at news.astraweb.com>,
> steve+comp.lang.python at pearwood.info says...
>>
>> Mario Figueiredo wrote:
>>
>>> Static analysis cannot and should not clutter executable code.
>>
>> (1) It isn't clutter. The human reader uses that information as well as the
>> compiler, interpreter, type-checker, IDE, text editor, correctness tester,
>> etc.
>>
>> (2) Algol, Ada, Boo, C, C#, C++, Cobol, Cobra, D, F#, Fantom, Fortran, Go,
>> Haskell, Java, Julia, Kotlin, Oberon, Pascal, Rust, Scala and dozens
>> (hundreds?) of other languages disagree with you.
>>
>
> Sorry. Somehow I missed this post. Only realized now from the Skip
> answer.
>
> This is simply not true!
>
> For most of the strongly typed languages (e.g. static typed languages)
> in that list -- C, C++, C# and Scala, the ones I know best from that
> list -- require little to no annotations in the code (and certainly no
> new explicit function or class based syntax) in order for static
> analysers to perform their thing, except perhaps on the most exotic
> static analysers.

C and C++ are weakly and statically typed languages.  Python is a 
strongly and dynamically typed language.  Therefore anything following 
based on the above paragraph alone is wrong.

>
> Being a strongly typed language, there is no need for added information
> in the function signatures. From that list you can safely exclude all
> strongly-typed languages.
>
> For dynamically typed languages, what I have seen being implemented on
> almost all cases is doc-like features for type annotation. Of the list
> you provide (few there are dynamically typed, btw) Julia is the one I
> know of. Julia implements a similar type annotation to type annotations
> in Python. In fact I see a lot of Julia in PEP 484. But with different
> objectives:
>
>      function add(a::Int, b::Int)
>          a + b
>      end
>
> Here the :: annotation is meant to attribute a type in an otherwise
> dynamically typed language and that function signature is executed at
> runtime with all the implications of a statically typed signature.
>
> Static analysis in Julia admitedly can only be performed if those
> annotations are present, and of the entire list you provide this is the
> only example language that more closely matches your argument. The
> others simply are not true.
>
> But in any case, in Julia type annotations, contrary to Python, are
> evaluated at runtime. It then makes all sense for them to coexist with
> the language syntax.
>


-- 
My fellow Pythonistas, ask not what our language can do for you, ask
what you can do for our language.

Mark Lawrence