Python en español #11: Tertulia 2020-12-15

En lo que sigue, cuando se habla de CPython, se refiere al intérprete de referencia de Python, que está escrito en lenguaje C: https://www.python.org/downloads/.

Participantes:

• Eduardo Castro, email: info@ecdesign.es. Conectando desde A Guarda.

• Jesús Cea, email: jcea@jcea.es, twitter: @jcea, https://blog.jcea.es/, https://www.jcea.es/. Conectando desde Madrid.

• Javier, conectando desde Madrid.

• Víctor Ramírez, twitter: @virako, programador python y amante de vim, conectando desde Huelva.

• Miguel Sánchez, email: msanchez@uninet.edu, conectando desde Canarias.

Audio editado por Pablo Gómez, twitter: @julebek.

La música de la entrada y la salida es "Lightning Bugs", de Jason Shaw. Publicada en https://audionautix.com/ con licencia - Creative Commons Attribution 4.0 International License.

• [00:52] Aviso de que se está grabando. Temas legales.

• [01:52] Valor de publicar estos audios y las dificultades para hacerlo.

• [02:42] Métodos mágicos:

  • __set_name__(). PEP 487: https://www.python.org/dev/peps/pep-0487/.

• [04:12] Problemas con PIP 20.3.2: https://github.com/pypa/pip/issues/9284.

• [05:52] ¿Actualizar a la última versión o esperar?

  • Poder "echar atrás" fácil.

  • Acumular cambios pendientes es deuda técnica.

• [10:42] Google caído https://www.theguardian.com/technology/2020/dec/14/google-suffers-worldwide-outage-with-gmail-youtube-and-other-services-down.

• [11:02] Generación de wheels en varios sistemas: https://pythonwheels.com/.

  • auditwheel: https://pypi.org/project/auditwheel/.

  • ¿Generación de Wheels en Microsoft Windows?

• [13:12] Caché local de PIP https://pip.pypa.io/en/stable/.

• [14:17] Event Sourcing https://dev.to/barryosull/event-sourcing-what-it-is-and-why-its-awesome.

  • Módulo eventsourcing: https://pypi.org/project/eventsourcing/.

• [14:42] De momento se puede usar el viejo "resolver" de dependencias de PIP.

  • Se puede usar la opción -use-deprecated=legacy-resolver.

  • Esa opción se puede meter también en el fichero de configuración, para no tener que escribirlo en cada invocación.

  • Jesús Cea comete el pecado de meter paquetes Python en el sistema operativo.

• [17:02] Batallitas de Jesús Cea.

  • Jesús lleva dos años dándole vueltas a esto: bpo35930: "Raising an exception raised in a "future" instance will create reference cycles": https://bugs.python.org/issue35930.

    Explicación detallada del asunto.

  • Brainstorming.

  • [21:22] Visión a alto nivel del recolector de basuras de Python (cpython)

    • Contador de referencias. Inmediato, pero no recoge ciclos.

    • Si se crean instancias y no se destruyen, se llama a un recolector "pesado" que también recoge ciclos.

      • Esto puede ser problemático al arrancar el programa, antes de que la creación/destrucción de objetos se "estabilice".

      • gc.disable(): https://docs.python.org/3/library/gc.html#gc.disable.

    • Jesús Cea "abusa" de los destructores y de que se ejecuten cuando él quiere. Lo práctico contra lo puro.

  • Jesús ofrece cervezas.

  • gc.collect(): https://docs.python.org/3/library/gc.html#gc.collect. Esto sirve tanto para recoger los ciclos como para comprobar si tu programa tiene ciclos de memoria o no.

  • Futures: https://docs.python.org/3/library/concurrent.futures.html.

• [35:29] Módulo Manhole https://pypi.org/project/manhole/.

  • Explorar un programa en producción.

  • Tracemalloc: https://docs.python.org/3/library/tracemalloc.html.

  • DTrace: http://dtrace.org/blogs/about/.

  • py-spy: https://pypi.org/project/py-spy/.

  • Pérdidas de memoria: Recordar lo hablado ya en tertulias anteriores.

  • jemalloc: http://jemalloc.net/.

  • MALLOC_PERTURB_: https://debarshiray.wordpress.com/2016/04/09/malloc_perturb_/.

  • zswap: https://en.wikipedia.org/wiki/Zswap.

• [42:52] Micropython: https://micropython.org/.

  • ESP8266: https://en.wikipedia.org/wiki/ESP8266.

  • ESP32: https://en.wikipedia.org/wiki/ESP32.

  • Bluetooth Low Energy: https://en.wikipedia.org/wiki/Bluetooth_Low_Energy.

  • ¿Qué ventajas aporta usar Micropython?

    • Velocidad de desarrollo y depuración.

• [52:42] ¿El futuro será mejor? O no.

  • Desperdicio de recursos materiales porque realmente sobran.

  • Python es mucho más lento que C y no digamos ensamblador.

• [57:17] Cambiar Python por un lenguaje más rápido.

  • Go: https://en.wikipedia.org/wiki/Go_(programming_language).

  • Rust: https://en.wikipedia.org/wiki/Rust_(programming_language).

  • C++: https://en.wikipedia.org/wiki/C%2B%2B.

• [01:00:20] Python no pinta nada en móviles.

  • Kivy: https://kivy.org/.

• [01:02:07] Acelerar Python.

  • Subinterpreters: PEP 554: https://www.python.org/dev/peps/pep-0554/.

    Si los subintérpretes no compartiesen NADA, se podrían lanzar simultaneamente en varios núcleos de la CPU sin competir por un GIL https://en.wikipedia.org/wiki/Global_interpreter_lock único.

  • JIT: https://es.wikipedia.org/wiki/Compilaci%C3%B3n_en_tiempo_de_ejecuci%C3%B3n.

    • PYPY: https://www.pypy.org/.

      • RPython: https://rpython.readthedocs.io/en/latest/.

    • Numba: https://numba.pydata.org/.

    • Cython: https://cython.org/.

    • Python es "potencialmente" muy dinámico, pero en la práctica los programas no lo son. Jesús pone varios ejemplos.

      • Conversación densa entre Jesús y Javier.

      • Guardas para comprobar que la especialización sigue siendo correcta. Por ejemplo, para los diccionarios: PEP 509 Add a private version to dict: https://www.python.org/dev/peps/pep-0509/

      • "Tipado" más estricto.

        • MYPY: http://mypy-lang.org/.

        • Pydantic: https://pydantic-docs.helpmanual.io/.

          Comprobación de tipos en tiempo de ejecución.

      • Descubrimiento de tipos en tiempo de ejecución, proporcionando "especialización".

        • psyco: https://en.wikipedia.org/wiki/Psyco.

      • Eduardo Castro entra y simplifica la discusión.

      • Jesús explica qué hace "a+b" internamente.

• [01:29:22] PyParallel http://pyparallel.org/

  • Memoria transaccional: https://es.wikipedia.org/wiki/Memoria_transaccional.

  • (nota de Jesús Cea): Los sistemas de persistencia Python descritos en tertulias anteriores pueden considerarse casos de memoria transaccional... si somos flexibles.

  • "Colorear" objetos y que dos hilos no puedan acceder a objetos del mismo color simultaneamente o en transacciones concurrentes.

• [01:30:42] PYPY https://www.pypy.org/ es tan sofisticado que no lo entiende ni dios.

  • Jesús Cea lo ha intentado y se ha rendido.

  • psyco: https://en.wikipedia.org/wiki/Psyco.

  • CFFI: https://cffi.readthedocs.io/en/latest/.

• [01:35:22] Compilar CPython a WebAssembly https://en.wikipedia.org/wiki/WebAssembly va más rápido que en C nativo.

• [01:36:02] Simplemente compilar código python con Cython https://cython.org/ sin declaración de tipos dobla la velocidad de ejecución.

  • ¡CPython lo puede hacer mejor!

• [01:36:57] Subinterpreters: PEP 554: https://www.python.org/dev/peps/pep-0554/.

  Poder usar todos los núcleos de la CPU.

• [01:38:07] Seguimos hablando del asunto.

• [01:39:07] Un problema es que Python tiene la vocación de funcionar en todas partes, así que hay resistencia para implementar mejoras solo en ciertas plataformas.

• [01:40:17] Cierre.

  Dadle una pesada al bug bpo35930: "Raising an exception raised in a "future" instance will create reference cycles": https://bugs.python.org/issue35930.

• [01:41:13] Final.