Comments for lukeplant.me.uk/blog/posts/pythons-disappointing-superpowers/

Comment #1369

2023-09-13T17:29:14.365315Z

I had a real use case of needing to extract expressions for gate-level standard cells used in Digital design, from a PDF, and convert the expression to Python then generate the truth table. The truth table generation I turned into this RosettaCode task and my Python solution uses compile and eval to very succinctly turn any Python boolean expression into a truth table.

https://rosettacode.org/wiki/Truth_table#Python

Comment #1323

2023-02-04T17:06:52.931602Z

Marcos: "and if not, we'll probably fork the language"

But forking a language is virtually impossible. A language is, by definition, a tool for communication. Once forked, it's a different language. You're probably not going to share (or call) code across this boundary -- especially if you're forking it to (re-)allow dynamic metaprogramming, as above.

You can fork the implementation, but even this is almost impossible. How many such forks have there ever been? Off the top of my head, I can only think of a couple that might fit this description -- started by large companies, who then got out of that business as soon as possible. It seems as though, if you've got the resources to maintain a fork, you've got the resources to design your own language from scratch which suits your needs even better.

Comment #1322

2023-02-03T09:23:55.572696Z

I've worked on an experimental project lambdex [1] to make Python "support" multi-line lambda expressions, which involves a great number of dynamic techniques I have ever crafted in the realm of Python. It more or less resembles Pony-ORM that compiles the "DSL" into Python code at runtime, works as an interesting attempt to extend Python with itself.

[1] https://github.com/hsfzxjy/lambdex

Comment #1320

2023-02-02T17:21:15.901827Z

You have to see Dynaconf.com and how it does a lot of those tricks to load as a django extension or dynamically read nested data.

Comment #1319

2023-02-02T14:49:58.542086Z

"consider the fact that Python has had support for keyword arguments since as long as I can remember, and for keyword-only arguments since Python 3.0. But typing.Callable has zero support for them, meaning they can’t be typed in a higher-order context. " You can type keyword arguments but you have to do it using typing.Protocol rather than typing.Callable. With Protocol you can even handle overloaded functions where the allowable keyword arguments come in different groups.

Comment #1318

2023-02-02T14:02:45.924136Z

Hey Kevin. Awesome article, I can't believe that I somehow forgot all these things were possible.

I’m worried that a de-facto move away from dynamic stuff in the Python ecosystem, possibly motivated by those who use Python only because they have to, and just want to make it more like the C# or Java they are comfortable with, could leave us with the very worst of all worlds.

I don't quite agree. Static typing is a tool, and since it's optional in Python, you can easily live without. It's so optional, that 'the' type checker is not even part of the Python release. You and me and everyone else interested can continue to do these magic tricks/ugly hacks forever (and if not, we'll probably fork the language :-P)

Meanwhile, most 'normal' programming can benefit a lot from static typing. I started sparsely using it in my non-'dynamic' programs and it has definitely helped me find some bugs. I think it's a good companion of a good seasoning of testing.

you may end up with a lot of tedious and noisy code to pass these dependencies through layers of code, or complex automatic dependency injection frameworks to avoid that

To be honest, being exposed to golang meant that I got to experience dependency injection first hand and yes, it can be a pain, but there is a simple solution where you build a constructor that accepts the DI for testing, and then you add a second one that just calls the first one with the values your code is going to use always, and then you use that second constructor everywhere in your code. Yes, you never get 100% coverage, but I'm pretty sure you already know that's not something you really want to do.

Why don’t we talk about these much?

Here are my 2¢: https://www.grulic.org.ar/~mdione/glob/posts/customizing-the-python-language/

On a final note, I find rather confusing the style for link underlines, specially if the text is so long that it wraps and you end up with half of it of a color, half of it grey.

Comment #1315

2023-02-01T16:45:08.429111Z

What an amazing post, thank you! You must be right that people don't talk about this much because I can't recall ever seeing so many meta-programming examples in one article. It's an inspiring reminder of what's possible in Python.