Python en español

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


Listen Later

Más de lo que nunca quisiste aprender sobre JIT, guardas y especialización https://podcast.jcea.es/python/11

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:

    [email protected]. Conectando desde A
    Guarda.

  • Jesús Cea, email: [email protected], 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:

    [email protected], 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.

                                                    ...more
                                                    View all episodesView all episodes
                                                    Download on the App Store

                                                    Python en españolBy Jesús Cea


                                                    More shows like Python en español

                                                    View all
                                                    Libros para Emprendedores by Luis Ramos

                                                    Libros para Emprendedores

                                                    1,115 Listeners