You will find yourself being that next person when you haven’t touched the code for a week and come back to add something and are like wtf.

I’d guess it’s less true for something statically typed, just because that reduces the ways it can be unintuitive.

Oh boy, you really wanna talk about it?

PyPI has a huge selection of libraries

It does, but the lack of static typing means it is more difficult to interact with foreign code (correctly).

When I pull in a library in a JVM language or Rust etc., I quickly glance at the documentation to get a rough idea of the entrypoint for the library.
Like, let’s say I want to create a .tar file, then the short “Writing an archive” example tells me all I need to know to get started: https://crates.io/crates/tar

If I need to find out more, like how to add a directory, then having the tar Builder initialized is enough for me to just ask my code completion. It will tell me the other available functions + their documentation + what parameters they accept.
If I make a mistake, the compiler will immediately tell me.

In Python, my experience was completely different. Pulling in a library often meant genuinely reading through its documentation to figure out how to call it, because the auto-completion was always unreliable at best.
Some libraries’ functions wouldn’t even tell you what types you’re allowed to feed into them, nor what type they return, and not even even diving into their code would help, because they just never had to actually specify it.

PyCharm a super powerful IDE, VSCode has tons of Python extensions that L rival PyCharm’s functionality, lots of other IDEs have decent python support

Yes, PyCharm is a super powerful IDE when compared to Nodepad++. But it’s a trashcan fire compared to IntelliJ or even the much younger RustRover.

Half the time it can’t assist you, because no one knows what types your code even has at that point.
The other half of the time, it can’t assist you, because, for whatever reason, the Python interpreter configured in it can’t resolve the imports.
And the third half of the time, it can’t assist you, because of what I already mentioned above, that the libraries you use just don’t specify types.

These are problems I’ve encountered when working on a larger project with multiple sub-components. It cost us so much time and eventually seemed to just be impossible to fix, so I ended up coding in a plain text editor, because at least that wouldn’t constantly color everything red despite there being no errors.

These problems are lessened for smaller projects, but in that case, you also don’t need assistance from an IDE.

or a distribution build

Not sure exactly what you mean by this

What I mean by that is that Python tooling is terrible. There’s five different ways to do everything, which you have to decide between, and in the end, they all have weird limitations (which is probably why four others exist).

or you’re more familiar with another language

Yeah this can be said about any language. “You’re quickest in the language you’re most familiar with”. That’s basically a tautology.

Yes. That is all I wanted to say by that. People just often claim that Python is a great prototyping language, to the point where the guy I was responding to, felt they’re doing the wrong thing by using the familiar tool instead. I’m telling them, they’re not.

I don’t know if you’re trying to be funny or your autocorrect is, but in Germany, when they switched from diploma to the bachelor/master system, both bachelor and master come with a theses. Many people leave with a bachelor, especially in computer science, so that might be why. Don’t know about other countries

Neither of those provide type inference? Type inference is when you give the compiler only occasional type hints and it can still figure out what the types are behind the scenes.

For example:

name = "World"
greeting = "Hello " + name
compile_error = greeting / 42

In a type-inferred language, the compiler would automatically know that:

1. the first line is of type String, because it’s trivially initiated as one.
2. the second line is of type String, because String + String results in a String.
3. the third line is non-sense, because greeting is a String and cannot be divided by a number. It could tell this before you run the program.

Mypy on the other hand can only tell these things, if you give the first two lines an explicit type hint:

name: String = "World"
greeting: String = "Hello " + name

Having to do this on every line of code is extremely noisy and makes refactoring annoying. I can absolutely understand that Python folks think you get productivity gains from duck typing, if this is the version of static typing they’re presented.

And we did excessively use mypy + type hints + pydantic on my most recent Python project. These are not the silver bullet you think they are…

Too much nested code was likely part of the problem, but not being able to easily tell where a block of coded ended without seeing the top of the block made it difficult to work with.

Torvalds wrote this about C. There’s plenty languages where it’s much more common and less of a complexity indicator to open up scopes.

It’s because there is no clear indication of where a block ends.

Here is some sample code. I find it difficult to tell how many indentations I have or where I need to write if I want to continue at a certain level.

import time
import aiohttp

"""
Retreives the data from RSS URL and return the status codes as well as the data. Return -1 if something went wrong.
"""
async def get_rss_feed(rss_url):
    async with aiohttp.ClientSession() as session:
        try:
            retry_count = 0
            while retry_count < 5:
                async with session.get(rss_url) as resp:
                    if resp.status == 200:
                        return {'status': resp.status, 'data': await resp.text()}
                    else:
                        retry_count += 1
                        time.sleep(60)
            if retry_count == 5:
                raise ValueError('To many failed connection attempts', retry_count)
        except aiohttp.InvalidURL as error:
            return {'status': -1, 'data': f"Error: {rss_url} is not a valid URL.", 'error': error}
        except aiohttp.ClientConnectorError as error:
            return {'status': -1, 'data': f"Error: Could not connect to {rss_url}.", 'error': error}
        except ValueError as error:
            return {'status': -1, 'data': f"Error: Could not connect to {rss_url} after {retry_count} attempts.", 'error': error}

Java/Type Script

I’ve never had a complaint about logging stuff in python. It generally does what I expect.

“Create a copy of your object and print that” is what I ended up doing, but I don’t think most people would say that’s intuitive. I expect if i print something at a particular time, I get what it is at that point in time.

I’d just like to highlight what you mention below: Logging it as an object allows you to inspect it in the browser console, presumably with some JSON tree representation, rather than just a dumb string.

It’s described in the “Outputting a single object” example here: https://developer.mozilla.org/en-US/docs/Web/API/console#examples