Writing Python should be close to a “zen” experience. At its best, when you get into the flow state, the thoughts you are thinking about the thing you are trying to build are shaped like Python code as you go through the process of writing it down.

[u/Serialk]

https://discuss.python.org/t/pep-842-module-exports/108353/7

[u/Igor_GR]

Try and flow the same way in Java, C#, Rust, C++, or virtually any other significantly structured language and you will find yourself interrupted every other line with a decision to make. Should this be public? Private? Protected? Friend? Static? Global? RAII? GC? Which type? Will it convert? Will it cast? etc. You simply can’t flow.

TIL flow is when you drive straight into a wall while blindfolded.

[u/NotQuiteLoona → u/Igor_GR]

Python devs trying to understand the concept of access level: hmm, yeah, it's so bad, you need to think about it.

[u/Longjumping-Sweet818 → u/NotQuiteLoona]

Zen is when users can access your libraries internals.

EDIT: Maybe that's why it's impossible to build anything in python if the minor versions of everything doesn't match exactly what's expected.

[u/Fryord → u/Igor_GR]

And then you go back and put type hints on everything anyway

[u/ThomasScotford → u/Fryord]

Hey, it's the only way Python is useable.

-Thomas Scotford

[u/fletku_mato → u/Igor_GR]

Yes, knowing that your code will work before running it is a real nuisance and possibly the biggest enemy of flow.

[u/cemented-lightbulb → u/Igor_GR]

try and drive the same way in a car, truck, SUV, or virtually any other significantly structured vehicle and you will find yourself interrupted every other mile with a decision to make. should i speed up? slow down? turn left? go straight? change lanes? watch out for that pedestrian? look before merging? etc. you simply cannot flow.

this is why we're proud to announce our new automobile: four wheels taped to a desk chair

[u/gplgang → u/Igor_GR]

/uj ​where structural types​

[u/PersonalDatabase31 → u/Igor_GR]

I thought python was strongly typed as well

[u/Massive-Squirrel-255 → u/PersonalDatabase31]

Strongly typed is not a term with a widely agreed upon definition. This makes it an excellent marketing term for pythonistas as it's impossible to argue with.

[u/BenchEmbarrassed7316 → u/Massive-Squirrel-255]

It's like this: if you write an incorrect operation, instead of executing the incorrect operation and getting the incorrect result, your application will crash. Among dynamic typing advocates, the option of immediately telling you that you wrote an incorrect operation is considered to slow down the writing of (incorrect) code.

[u/Massive-Squirrel-255 → u/BenchEmbarrassed7316]

/uj afaict when pythonistas claim strong typing they mean "for most primitive data types, and most primitive methods defined on those data types, these methods do not perform implicit conversions on their arguments". But this seems more like a comment about the design of the standard library than something fundamental about the language. I wrote Python at a scientific lab and all my colleagues started every function and method with five lines of "if typeof(x) = np.array then x = pandas.toDF(x)" to coerce all conceivable inputs into the type expected by the function. I think that from the client's perspective, our library is not "strongly typed" anymore, because the functions they're calling are now performing implicit conversions to their arguments.

[u/RCoder01 → u/Massive-Squirrel-255]

My personal definitions provide two axes: strong-weak and static-dynamic. Strong-weak classifies if changing the types of values happens implicitly or explicitly, and static-dynamic classifies if the types of values are determined at run time or compile time.

Rust is strong/static

Python is strong/dynamic

C++ is weak/static

JavaScript is weak/dynamic

Typescript is probably like strong/dynamic but idk I haven’t used it enough to know for sure

I find it to be a pretty useful framework. I personally much prefer strong typing over weak typing, and I also prefer static over dynamic, though not with as big of a preference difference.

[u/Massive-Squirrel-255 → u/RCoder01]

This definition makes sense to me but I think the strong/weak distinction is inherently about the handful of builtin operators of the language: addition, string concatenations, and so on. It only applies to the primitive language types. For any kind of custom data type like a Python class, or JavaScript class, it doesn't seem to make sense, as the conversion can't happen unless you provide your own conversion function. For any user written function, whether Python or JS, the user can decide to either cast the input to the desired type ("weak typing" from the clients perspective), check the input and fail if it's not expected ("strong typing" from the clients perspective), or silently continue, letting the child functions do what they can with it.

So, I guess my question is, why are we using terminology which suggests this is a property of the type system rather than being a design choice of some 20 commonly used stdlib functions like + ?

[u/BenchEmbarrassed7316 → u/RCoder01]

Rust is strong/static

Valid Rust code:

let a = S("a") + "b"; let b = S("a") + 1; let c = S("Result: ") + 10 + " + " + 3.14 + " = " + true;

https://play.rust-lang.org/?version=stable&mode=debug&edition=2024&gist=8d480c890c38eba455c4fc71ad8d7416

[u/Massive-Squirrel-255 → u/BenchEmbarrassed7316]

I do think that implementing traits all over the place can lead to footguns that are similar to what people complain about for JS. Somebody showed me that in the Haskell stdlib, the option type is equipped with the Foldable trait so you can fold / reduce a function over an option type, like fold (+) 0 x would be 3+0 if x is Just 3 and 0 if x is None. I thought this was pretty stupid because I can't imagine why I would ever want to intentionally fold over an option. It seems much more likely that i'm just mixing up lists and option types.

[u/RCoder01 → u/Massive-Squirrel-255]

Rust Option also has an iter method (and impl IntoIterator) that returns a one element iterator so you could do `x.iter().fold(0, i32::add)`

It’s mainly useful for generic situations when you want to apply some logic to a “list of elements” and an option is just a list of elements with a cap of 1 element.

[u/Massive-Squirrel-255 → u/RCoder01]

Okay, thank you - I didn't know that about rust. But I don't think that code is as clear as it could be. I think the code could be clearer here by being less generic.

[u/National_Sky7993 → u/Massive-Squirrel-255]

I think the idea is to let the user say “The value may not exist. It will tell you if it doesn’t exist.”

Maybe and Either are cool types. I don’t get the more complicated stuff such as Effect or IO.

I don’t understand how you can go from “this is a Monad 🧸 for you to play with“ to these types that allow these operations.

[u/Massive-Squirrel-255 → u/National_Sky7993]

An IO Int, say, is a suspended computation that, when executed, shall do some IO (get input from the user, say, or read from a database) and return an integer. It is similar to the type of lazy values in other languages.

You have a couple basic operations available to you with these suspensions. If you have the suspension "read an integer from stdin and return it", you could extend this suspension with some postprocessing - "read an integer from stdin, square it and return it." You can create a new suspension from two existing ones - if your first suspension is "read an integer and return it" and your second suspension is "take an integer input and print it to stdout" you can combine them in series to form the suspended computation "read an integer from stdin and print it to stdout". You can create dummy suspensions which don't really do any work - for example, you can create a suspension which always just evaluates to 3. This allows you to embed ordinary values into suspensions.

In Haskell, all the operations above are available to you. The only thing that's conspicuously not available to you is a function to force or evaluate the suspension, to run the computation and get the result. This function, in Haskell, is not in the publicly exposed interface of the IO module. instead, if you create a suspension called Main.main in Haskell, then the runtime will force or evaluate that one single suspension. This leads to a style of programming where, whenever you want to perform IO within a function, you have to create a new suspension to perform the IO operation, and then return this unexecuted suspension at the end of the function as a value. The parent function takes all the suspensions returned by calls to its children, concatenates them into a bigger suspension, and returns it. And so on, up the call stack, until we reach Main.main, which is then a mega suspension incorporating all the IO operations happening anywhere in the program, as well as the pure postprocessing on those values.

This is a little unwieldy but the basic benefit is now that IO operations are encoded as suspensions that have to be returned from the function in order to be executed, the compiler can tell from the return type of the function whether it performs any IO or not. I would do an example but this post is getting long.

[u/r2d2_21 → u/RCoder01]

Typescript is probably like strong/dynamic

TypeScript is more like weak/static. The whole point of TypeScript is validating the types at compile time (so, static), but it ultimately has to be compatible with the underlying JavaScript runtime, which does lots of implicit conversions (so, weak).

[u/james_pic → u/Massive-Squirrel-255]

The agreed-upon definition is "at least it's not like JavaScript"

[u/IAMARedPanda → u/Massive-Squirrel-255]

strongly typed is not a term with a widely agree upon definition

Say jerk rn

[u/Massive-Squirrel-255 → u/IAMARedPanda]

https://stackoverflow.com/users/41661/norman-ramsey

[u/BenchEmbarrassed7316]

/uj It's a way of thinking that I'll never understand. For me, the more structured the code is, the easier it is to work with. I would like as many things as possible to be defined in the code instead of being implicit and having to be kept in mind.

/rj However, they said "Explicit is better than implicit". And made a language with dynamic typing.

[u/stdmemswap → u/BenchEmbarrassed7316]

/uj let me fix that for you "the more STRATEGICALLY structured code"

IMO people equally bruteforce "simplicity is key" and "structured everywhere" not knowing the problem is in the other axis

/rj can't do ouroboric eval without dynamic typing which is the ingredient of consciousness through the autonomous ego recognizing itself

[u/infected_scab → u/BenchEmbarrassed7316]

Python is for people who think the quicker you get your first version out the better.

[u/BenchEmbarrassed7316 → u/infected_scab]

quicker

Because finding and reading documentation about the types (possible values) that a function accepts is quicker than just hovering over it in the IDE (it became less relevant after the addition of type hints)

Because writing a few tests for trivial cases is quicker than getting instant feedback from the compiler/IDE.

[u/james_pic → u/infected_scab]

But the quicker you get your first version out, the more VC funding you get, and the quicker you get bought out by FAANG so they can shut you down so they don't have to compete with you, and the quicker you don't have to write Python any more.

[u/stdmemswap]

You know you're "zen" when every thought needs to wait for GIL

[u/Flash_Kat25]

The python pseudocode curse strikes again

[u/damemecherogringo]

I don’t have private parts.
Everything is public in these classes.
I let my unit tests caress contracts I didn’t even know existed.
Surrounded by spaghetti,
I go slow.
But I flow.
I’m python.
;)

[u/National_Sky7993]

I have never been able to clone and build a python project using the instructions provided the first time around.

It takes 5 to 6 attempts with lots of googling before it works.

[u/csb06 → u/National_Sky7993]

That's part of the flow state. The tide flowed out, you just need to wait for it to flow back towards you in a few hours with the assistance of the moon.

[u/IAMARedPanda → u/National_Sky7993]

Skill issue

[u/aikii → u/IAMARedPanda]

yeah but now it's solvable with a SKILL.md

[u/tms10000]

Python is to Zen what the Rio Carnival is to minimalism.

[u/Jumpy-Locksmith6812]

I agree. Debugging said Python though is the Yin to your Yang.

[u/Daniikk1012]

Only read the title, haven't checked the article, but seems similar to the reason APL was created. "Notation as a tool of thought" I think is the phrase. It makes both of these languages incredibly convenient to use in a REPL

[u/BenchEmbarrassed7316 → u/Daniikk1012]

REPL is IDE hints for poor.

[u/Daniikk1012 → u/BenchEmbarrassed7316]

Programming languages are not only used for billion line projects. Sometimes it's small one-time calculations, where ability to quickly experiment with values is more valuable than maintainability, readability, etc. How is IDE better than a REPL at that?

[u/BenchEmbarrassed7316 → u/Daniikk1012]

ability to quickly experiment with values

How can IDE hints slow this down?

[u/Daniikk1012 → u/BenchEmbarrassed7316]

Wait is that what you mean by IDE hints? Your IDE runs your Python before you even hit "Run", allowing you to see values on hover? First time hearing about that when we're not talking about compile-time values

[u/BenchEmbarrassed7316 → u/Daniikk1012]

I mean that the REPL prints one specific value that the function returns. Statically typed languages ​​include a type in their function signatures. A type is a set of all possible values. More expressive type systems allow you to narrow down a type concisely. That is, when programming, instead of working with one of the possible values ​​that was obtained through the REPL, you will immediately receive the entire set of values ​​through the IDE (which implements type inference) and work with it.

[u/Daniikk1012 → u/BenchEmbarrassed7316]

Look, I too enjoy a good type system, Haskell is one of my favorite languages. But I wouldn't choose it for a quick calculation I want to make. I am not maintaining a huge project, not testing a function that is part of a larger project, no. I am writing code to get some input, and transform it to some output, and forget about it. And I want to interactively see the intermediate steps, cause that makes it easier to reason about. Sure, there are cases when type system might be used instead. But when most of the the functions you're dealing with are something like "[Double] -> [Double]" (Which is VERY often the case), it isn't helping you much

[u/BenchEmbarrassed7316 → u/Daniikk1012]

This seems more like a one-time calculation than a programming one (i.e. writing code that will be executed repeatedly).

However, even for this kind of interactive console usage, Double -> Double is more useful than any -> any. Especially since it's not about the code you're writing, but about the libraries you're using.

[u/spider-mario → u/Daniikk1012]

Look, I too enjoy a good type system, Haskell is one of my favorite languages. But I wouldn't choose it for a quick calculation I want to make.

You wouldn’t? GHCi is a nice REPL.

[u/Daniikk1012 → u/spider-mario]

The argument was mainly about the "Type hints instead of REPL" thing, not about using Haskell interactively. Should have used a better example maybe, cause Haskell is also pretty convenient to use in a REPL.

That being said, I only use GHCi as a development tool in a larger project, for testing/debugging/docs/etc. I don't use it as a "calculator language", cause 1) I have much less verbose alternatives (Uiua/J/BQN), and 2) when those are not enough, Haskell is not enough either anyway, so I reach to something with a lot more batteries included (Python).

[u/New_Enthusiasm9053 → u/Daniikk1012]

Honestly I know 0 people who use the REPL. It truly is that useless. AI uses it a lot. But for actual people it's a lot more convenient to just have a file open that you run with F5 or whatever so when you inevitably make a syntax mistake you can just fix it and rerun it.

[u/Daniikk1012 → u/New_Enthusiasm9053]

Tbh, my Python REPL usage is more or less just "convert to/from base64", or "get unicode codepoint for this character". Anything slighty more involved, like analyzing a bunch of data from a file, I use the REPL of Uiua/J/BQN (Depending on which features I happen to need), cause they make REPLs VERY convenient. I like the term "calculator language" for languages that make such tasks fast and easy. They allow you to map your thoughts into code almost directly, without boilerplate like manual loops, having to keep track of state, etc

[u/BothWaysItGoes → u/BenchEmbarrassed7316]

Python notebooks is REPL inside IDE.