#Python nodejs full#
#Python nodejs android#

I misremembered: it's for ordering (not equality) in Python 2 `a < b` will first invoke `type(a)._lt_(a, b)`, then if that's not implemented fall back to `type(b)._ge_(a)`, and if that's not implemented either it'll fall back to a few hard-coded cases (e.g.

Because someone somewhere used `in` on your object and you hadn't defined `_iter_` let alone `_contains_`. Which is why sometimes you define `_getitem_` for a pseudo-mapping convenience and then you get weird blowups that it's been called with `0` (you only ever expected string-keys). `in` will first try to use `_contains_`, if that doesn't exist it uses `iter()` which tries to use `_iter_` but if that doesn't exist it falls back to calling `_getitem_` with non-negative sequential integer. even `a = b` will try `type(a)._eq_(a, b)` then fall back to `type(b)._eq_(a)` (~~and then it'll do some weird stuff with type names IIRC~~).Īnd most operators are not considered symmetric so the fallback is not the same as the initial (even `+` has `_add_` and `_radd_`, also `_radd_` might be called first depending on the relationship between type(a) and type(b)).Īnd then there's the 'operations' which fallback to entirely different protocols e.g. I expect this wouldn't have worked in the long run as these methods are often just part of the protocol e.g. _add_() for example to call the python add operator. > The third was that js has no operator overloading, so I had to use. But I was happy to learn something about underlying cpython and v8 from it. Also I was wondering if anyone really need to do things in this way, given there are bunch of popular and stable RPC libraries. It's a toy project I did years ago and not even compiling now.

(Or maybe other utilities, idk what would be more elegant.) The third was that js has no operator overloading, so I had to use. Although this could be resolved by manually breaking up the circle, it could be better to have weak references.

#Python nodejs android#

Node.js, one of the best cross-platform frameworks, gives you the freedom to build a single app that will run across multiple platforms such as Windows, Mac, and Android among others. Since references across boundaries are global, garbage collector on either side could not reclaim circularly referenced objects. For Python vs Node.js speed, Node.js easily takes the cup of the best backend technology in 2022 in this case against Python. The second was circular references between runtimes. Yes you can catch exceptions in native code and convert it to exceptions in the other language, but it's not straightforward to keep stacktraces. It is feasible because the languages and runtimes share a number of common designs. So that you can use python objects and functions as native javascript objects and functions.

#Python nodejs full#

I was once trying to do something even crazier: exposing full python accessibility to node.js, using proxies.