V8 VS Cython

It sounds like you want to know how JavaScript is implemented in the browser. The thing is, there is no universal implementation for JavaScript. JavaScript defines a specification that must be adhered to, and then each browser vendor can implement it in whatever way they see fit, as long as it does the specified things. For example (and I'm not saying this is the case) it's entirely possible for Chrome to implement Array.sort() using merge sort, while Firefox implements it as quick sort. You can try to find the source code for the implementation in a certain browser, but that will not be universal. I imagine you can find out how it works in Chrome somewhere in https://chromium.googlesource.com/v8/v8.git, though I'm not sure exactly where.

chrome v8 commits referring to spread operator one of them: https://github.com/v8/v8/commit/93b3397e52d3faf38059718de335027e57b9690d

Looks like these are the two commits, based on the issue number:

https://github.com/v8/v8/commit/0981e91a4f8692af337e2588562a...

https://github.com/v8/v8/commit/a2cae2180a7a6d64ccdede44d730...

Although there could be others.

https://github.com/v8/v8/blob/master/src/objects/dictionary.h https://wiki.cdot.senecacollege.ca/wiki/Inline_Assembly_Language https://en.cppreference.com/w/c/language/asm https://en.wikipedia.org/wiki/Inline_assembler https://stackoverflow.com/questions/2268562/what-are-intrinsics https://www.codeproject.com/Articles/15971/Using-Inline-Assembly-in-C-C https://stackoverflow.com/questions/48518225/what-are-intrinsic-types-in-javascript https://stackoverflow.com/questions/12168575/executing-generated-assembler-inline

It must be a fairly large echo chamber since it has room for Clang, GCC, V8, OpenJDK, Roslyn, etc. (The Zend parser for PHP seems to use some flavor of YACC, but given PHP, I don't know if that strengthens or weakens my point.)

What you're describing is not really possible with JS. Your best bet would be to look at the "V8 engine" source code. It is the interpreter used in Node.js and Chrome (and I think Edge would be using it too as Edge is built on Chromium). But there is nothing forcing Node.js to use V8, there are other JS interpreters. https://github.com/v8/v8

and again, everything that was released after using an older version of cython.

Packages using cython (note the linked issues) due to this change.

Just for reference,

* Nuitka[0] "is a Python compiler written in Python. It's fully compatible with Python 2.6, 2.7, 3.4, 3.5, 3.6, 3.7, 3.8, 3.9, 3.10, and 3.11."

* Pypy[1] "is a replacement for CPython" with builtin optimizations such as on the fly JIT compiles.

* Cython[2] "is an optimising static compiler for both the Python programming language and the extended Cython programming language... makes writing C extensions for Python as easy as Python itself."

* Numba[3] "is an open source JIT compiler that translates a subset of Python and NumPy code into fast machine code."

* Pyston[4] "is a performance-optimizing JIT for Python, and is drop-in compatible with ... CPython 3.8.12"

[0] https://github.com/Nuitka/Nuitka

[1] https://www.pypy.org/

[2] https://cython.org/

[3] https://numba.pydata.org/

[4] https://github.com/pyston/pyston

Profile and optimize the hotspots with cython (or whatever the cool kids are using these days... It's been a while.)

Cython - - embed demo

There are also just-in-time compilers available for some Python features, that compile those parts to machine code. That includes Numba (usable as a library within CPython) and Pypy (an alternative Python implementation that includes a JIT compiler to improve performance). There’s also Cython, which is a superset of Python that allows more directly interfacing with C and C++ functions, and compiling the resulting combined code.

Conceptually, Cython is mainly for accelerating Python code, and can _also_ access C code. Meanwhile CFFI is specifically for calling C code and nothing else. I recommend the video for the differences.

One concrete thing that pops to my mind is that Cython doesn't support Py_LIMITED_API which means that you need to ship a lot more binary wheels. At least the issue is still open (https://github.com/cython/cython/issues/2542) and Cython projects IME need new wheels for each minor Python release. Compare that to cffi projects that (musl & pypy aside) only have to ship wheels for one Python version / architecture: https://pypi.org/project/argon2-cffi-bindings/#files

As you can see, in this benchmark Starlite handily beats even blakchseep, a notoriously fast ASGI framework written in Cython

How does this relate to

https://cython.org/

?

Would it be possible to write performance-sensitive parts of a Python system in Codon and link that to a CPython or PyPy runtime that supports more dynamic features?