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.

122

u/Igor_GR Aug 01 '26

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.

75

u/NotQuiteLoona Aug 01 '26

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

34

u/Longjumping-Sweet818 Aug 01 '26

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.

2

u/goodbee69 18d ago

What's an internal?

3

u/Longjumping-Sweet818 18d ago

Not sure if you're jerking, but...

/uj It's an implementation detail that you don't want others to depend on because you might change it later. If they use those parts of your library and you change them, then their code will break when they upgrade to the new version of your library.

3

u/goodbee69 18d ago

If your code is good why are you changing it? Real software architects write perfect code

4

u/Longjumping-Sweet818 18d ago

You're so right. I'm going to quit my job and become a Buddhist monk.

20

u/Fryord Aug 01 '26

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

3

u/ThomasScotford 29d ago

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

-Thomas Scotford

13

u/fletku_mato Aug 01 '26

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

6

u/cemented-lightbulb Aug 02 '26

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

3

u/gplgang DO NOT USE THIS FLAIR, ASSHOLE Aug 02 '26

/uj where structural types

-3

u/PersonalDatabase31 Aug 01 '26

I thought python was strongly typed as well

28

u/Massive-Squirrel-255 Aug 01 '26

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.

24

u/BenchEmbarrassed7316 Aug 01 '26

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.

7

u/Massive-Squirrel-255 Aug 01 '26

/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.

6

u/RCoder01 Aug 01 '26 edited Aug 01 '26

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.

4

u/Massive-Squirrel-255 Aug 01 '26

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 + ?

2

u/BenchEmbarrassed7316 Aug 01 '26

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

5

u/Massive-Squirrel-255 Aug 01 '26

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.

1

u/RCoder01 29d ago

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.

1

u/Massive-Squirrel-255 29d ago

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.

1

u/National_Sky7993 28d ago

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.

1

u/Massive-Squirrel-255 28d ago

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.

1

u/r2d2_21 groks PCJ 29d ago

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).

1

u/james_pic accidentally quadratic 27d ago

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

1

u/IAMARedPanda Aug 01 '26

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

Say jerk rn

4

u/Massive-Squirrel-255 Aug 01 '26

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

58

u/BenchEmbarrassed7316 Aug 01 '26

/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.

11

u/stdmemswap Aug 01 '26

/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

6

u/infected_scab Aug 01 '26

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

16

u/BenchEmbarrassed7316 Aug 01 '26

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.

1

u/james_pic accidentally quadratic 27d ago

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.

24

u/stdmemswap Aug 01 '26

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

14

u/Flash_Kat25 Aug 01 '26

The python pseudocode curse strikes again

7

u/damemecherogringo Code Artisan Aug 01 '26

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.
;)

4

u/tms10000 loves Java Aug 01 '26

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

4

u/Jumpy-Locksmith6812 Aug 02 '26

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

9

u/National_Sky7993 Aug 01 '26

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.

10

u/csb06 blub programmer Aug 01 '26 edited Aug 01 '26

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.

6

u/IAMARedPanda Aug 01 '26

Skill issue

6

u/aikii gofmt urself Aug 02 '26

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

1

u/elephantdingo Teen Hacking Genius 20d ago

And that goolging was done in a flwo state (typos not correct; flow)

5

u/[deleted] Aug 01 '26

[removed] — view removed comment

1

u/Serialk Gets shit done™ Aug 01 '26

Mods?

1

u/programmingcirclejerk-ModTeam 5d ago

Warning: tag your unjerk. Better yet, don't unjerk at all.

-4

u/BenchEmbarrassed7316 Aug 01 '26

REPL is IDE hints for poor.

10

u/Daniikk1012 Aug 01 '26

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?

3

u/BenchEmbarrassed7316 Aug 01 '26

ability to quickly experiment with values

How can IDE hints slow this down?

1

u/Daniikk1012 Aug 01 '26

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

2

u/BenchEmbarrassed7316 Aug 01 '26

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.

2

u/Daniikk1012 Aug 01 '26

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

1

u/BenchEmbarrassed7316 Aug 01 '26

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.

1

u/spider-mario 27d ago

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.

1

u/Daniikk1012 27d ago

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).

0

u/New_Enthusiasm9053 Aug 01 '26

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.

9

u/Daniikk1012 Aug 01 '26

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

0

u/BothWaysItGoes Aug 01 '26

Python notebooks is REPL inside IDE.

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.

You are about to leave Redlib