meejah
@diazona @isagalaev @mitsuhiko I like that it's extremely readable. Looking "practically like pseudocode" was an example of just _how_ readable it is -- it makes great generic examples!
For me, type-hints greatly decrease that for many, many readers. Only in larger projects do they start to make sense. I don't want a slower, less-parallel C++ -- I want something nicer to read and write!
Also I don't believe the tale of them being "optional"...already, they're pretty non-optional.
phiofx
@meejah @diazona @isagalaev @mitsuhiko
After observing the phenomenon for a few decades I am pretty convinced (but lack the expertise to prove) that long-running arguments about programming are not gratuitous bickering but involve real and complex cognitive issues.
E.g. people will use expressions like "clean, readable, comprehensible" etc. code as if its an objective and isolated reality. Well, clearly it isn't. There is tons of context involved and maybe even neurophysiological differences.
David Zaslavsky
@meejah @isagalaev @mitsuhiko I see. I'm not convinced though. Like, if the thing you like most about Python is that it looks like pseudocode, then that's fine, but you can still write Python that looks like pseudocode if you want to because type hints are optional. We don't write complex libraries and applications in pseudocode, though. (Or, we shouldn't) In those situations, static type checking is a big part of what elevates Python beyond pseudocode and makes it suitable for building those complex systems. (1/2)
meejah
@diazona @isagalaev @mitsuhiko So, I agree there are benefits to stronger typing. Most of the code I've produced is C++ ... but the very thing I like most about Python is being eroded by bolt-on type-hinting (that _still_ isn't very good, IMO, and very hard to read or type properly for remotely complex things).
If you like real types, use Haskell or something ;)
David Zaslavsky
@meejah @isagalaev @mitsuhiko ooh, them's fightin' words 😂
But seriously though, I would say almost the exact opposite of this. The type system in #Python isn't perfect, sure, but for me it definitely helps readability and comprehension. It's useful enough that the ability to use a static type checker has probably been the single biggest productivity boost I've experienced in the entire time I've been using Python (or at least is on the short list for that title).
meejah
@diazona @isagalaev @mitsuhiko Nearly into "re-hashing typing vs. untyped" arguments here, but what I'm getting at is that un-typed Python reads an awful lot like pseudo-code. Once you start putting type-hints on it, that all breaks down.
So, I'm also agreeing with Armin on the fact that there _are_ benefits to static/strict typing but Python's isn't very good at the "advanced" aspects of that and also has the huge downside of "hard to read" (esp. for someone who's a programmer, but not Python)
meejah
@diazona @isagalaev @mitsuhiko For example, the Ethereum 2 (or whatever, the proof-of-stake stuff) specifications literally used Python for their example / pseudo code (and even had unit-tests for them).
Pretty hard to do that with type-hints involved.
There's also a "Python3" level of extra work for library authors. I kind of dread the first ticket filed for "give me type-hints in txtorcon" -- because if one dep lacks type-hints, many benefits go away.
meejah
@isagalaev I 100% agree with what seems to be @mitsuhiko 's main point there: that trying to bolt typing onto Python is not a great idea, and has led to *far* less readable Python, overall.
If you want a strongly-typed language, there are plenty to choose from.
#python #haskell
(I too don't want to re-hash all the argument for or against types, and I do know C++, Java and at least enough Haskell to be dangerous)
Ivan Sagalaev :flag_wbw:
Recent from Armin Ronacher is worth a read: https://lucumr.pocoo.org/2023/12/1/the-python-that-was/
It strikes a note with me, although I don't agree on a couple of points.
Like, "runtime errors flying left and right [..] because bad types were passed". No, most of the errors were and still are from wrong *values* being passed. Also mutable state, tight coupling and incomplete understanding of the domain. Unless your kind of programming is implementing some formal spec, types will only catch the most trivial errors.
GNU social JP is a social network, courtesy of GNU social JP管理人. It runs on GNU social, version 2.0.2-dev, available under the GNU Affero General Public License.
All GNU social JP content and data are available under the Creative Commons Attribution 3.0 license.