Python en español

Python en español

By Jesús CeaTechnology
Download on the App Store

Python en español episodes

  • Python en español #19: Tertulia 2021-02-09
    ¿Se pueden usar diferentes versiones de una misma librería en un proyecto? (resumen: ¡No vayas por ahí!). MultiVersion Concurrent Control https://podcast.jcea.es/python/19

    Participantes:

    • Jesús Cea, email: [email protected], twitter:

      @jcea, https://blog.jcea.es/,
      https://www.jcea.es/. Conectando desde Madrid.

    • Víctor Ramírez, twitter: @virako,

      programador python y amante de
      vim, conectando desde Huelva.

    • Javier, conectando desde Madrid.

    • 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] Prólogo:

        • FOSDEM https://fosdem.org/.

        • Escuchar audios previos para ver errores y comentar

          "erratas".

        • [03:07] ¡Tenemos un voluntario para editar el podcast!

          • Detalles de cómo grabamos las tertulias.

          • Todo se graba en una sola pista :-(.

          • RNNoise: https://people.xiph.org/~jm/demo/rnnoise/.

          • Ideas para automatizar el proceso.

          • [09:17] Aviso legal de que se está grabando el sonido y que se

            va a publicar online.

            • El audio publicado tendrá un índice en texto, para poder
            • hacer búsquedas y poder moverse con facilidad entre temas.
            • [11:22] Errata de la tertulia anterior: No, pipenv

              https://pypi.org/project/pipenv/ no puede instalar dos
              versiones diferentes de la misma librería.

            • [13:07] Tormenta de ideas

              https://es.wikipedia.org/wiki/Lluvia_de_ideas sobre cómo usar
              diferentes versiones de la misma librería en el mismo proyecto.
              Conclusión: ¡No vayas por ahí!

              • Las bibliotecas solo se cargan una vez en el programa,

                aunque se hagan muchos import en el código.

              • sys.modules

                https://docs.python.org/3/library/sys.html#sys.modules.

              • Dependencias transitivas.

              • Subintérpretes Python. PEP 554:

                https://www.python.org/dev/peps/pep-0554/.

              • Módulos en C: PEP 489 -- Multi-phase extension module

                initialization https://www.python.org/dev/peps/pep-0489/.

              • [22:17] Python 3.10a5. PEP 636 -- Structural Pattern Matching:

                Tutorial https://www.python.org/dev/peps/pep-0636/.

                • ¡Más sintaxis nueva!

                • PEP 617 -- New PEG parser for CPython

                  https://www.python.org/dev/peps/pep-0617/.

                • [23:57] Nuitka https://nuitka.net/.

                  • Puede generar un binario que no depende de tener nada
                  • instalado.
                  • [26:02] Volvemos a "Structural Pattern Matching"

                    https://www.python.org/dev/peps/pep-0636/.

                    • "Switch" con esteroides.
                    • [27:32] Lo importante que fue la modernización de los tutoriales

                      y ejemplos para ayudar a la migración de Python 2 a Python 3.

                      • PEP 414 -- Explicit Unicode Literal for Python 3.3

                        https://www.python.org/dev/peps/pep-0414/.

                      • Jesús Cea opina que la migración de Python 2 a Python 3

                        se hizo mal y ha sido muy traumática.

                      • [30:22] PEP 8 https://www.python.org/dev/peps/pep-0008/.

                        • ¿Ajustarse estrictamente a 80 columnas?

                        • Flake8: https://pypi.org/project/flake8/.

                        • [33:22] Mucho cuidado con "python-ideas"

                          https://mail.python.org/mailman3/lists/python-ideas.python.org/.

                          • Tabulación de código.

                          • La anotación de tipos puede gustar o no, pero de momento es

                            opcional.

                          • Tema recurrente: ¿Qué es ser pythonico?

                          • [35:12] Ventajas de anotar tipos.

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

                            • Aportar información al IDE

                              https://en.wikipedia.org/wiki/Integrated_development_environment.

                            • Valor a la hora de documentar los tipos en los API

                              https://en.wikipedia.org/wiki/API.

                            • [39:52] Cryptography https://cryptography.io/en/latest/ y

                              polémica al integrar módulos en Rust
                              https://en.wikipedia.org/wiki/Rust_(programming_language)

                              • Comunidad tóxica.
                              • [41:27] Digresión sobre systemd

                                https://en.wikipedia.org/wiki/Systemd y otras cosas de
                                sistemas.

                                • ¿El cambio por el cambio?
                                • [45:07] El peso de la web está moviéndose otra vez al backend.

                                  ¿Qué opciones tiene Python en este area?

                                  • El cliente web solo envía eventos al servidor y recibe

                                    cambios al DOM
                                    https://es.wikipedia.org/wiki/Document_Object_Model
                                    enviadas por el servidor.

                                  • Abre la posibilidad olvidarnos de JavaScript:

                                    https://es.wikipedia.org/wiki/JavaScript.

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

                                  • [51:02] splash https://pypi.org/project/splash/.

                                    Servicio de dibujado de javascript en Python.

                                    • AJAX: https://es.wikipedia.org/wiki/AJAX.
                                    • [56:07] Integrar Python en otros programas y demonios.

                                      • LUA: https://es.wikipedia.org/wiki/Lua.
                                      • [57:07] PyOxidizer

                                        https://pyoxidizer.readthedocs.io/en/stable/ y PyO3
                                        https://pyo3.rs/.

                                        • Interactuar con otros lenguajes.

                                        • Python en Java, interactuando sin dolor: Jython

                                          https://www.jython.org/.

                                        • [59:52] ¿Cómo empezamos en Python?

                                          • Valor de Python como lenguaje fácil de entender y

                                            pseudocódigo.

                                            • SpamBayes: http://spambayes.sourceforge.net/.
                                            • Tutorial de Python:

                                              https://docs.python.org/es/3/tutorial/index.html.

                                            • bc -l https://linux.die.net/man/1/bc.

                                            • [01:05:07] Modificación atómica de ficheros.

                                              • En Unix se suele hacer: write + flush + rename.

                                                • rename:
                                                • https://www.man7.org/linux/man-pages/man2/rename.2.html.
                                                • MS Windows eso no funciona.

                                                • Python 3.3 añadió os.replace()

                                                  https://docs.python.org/3.8/library/os.html#os.replace.

                                                • En MS Windows es atómico... casi siempre: Issue8828: Atomic

                                                  function to rename a file
                                                  https://bugs.python.org/issue8828.

                                                • [01:10:02] Combinar fork e hilos en Python es una receta para el

                                                  desastre.

                                                  • fork:

                                                    https://www.man7.org/linux/man-pages/man2/fork.2.html.

                                                  • multiprocessing:

                                                    https://docs.python.org/3/library/multiprocessing.html.

                                                  • [01:11:37] Decorador @overload

                                                    https://docs.python.org/3/library/typing.html#typing.overload.

                                                    • @functools.singledispatch

                                                      https://docs.python.org/3/library/functools.html.

                                                    • ¿Qué se ve cuando salta una excepción?

                                                    • Especializaciones.

                                                    • Cython https://cython.org/.

                                                    • [01:17:00] AnyIO

                                                      https://anyio.readthedocs.io/en/stable/basics.html.
                                                      Unificación de reactores asíncronos.

                                                    • [01:18:12] "lxml soporta xpath".

                                                      • Hilo en la lista de correo: "[Python-es] Biblioteca XPATH"

                                                        https://mail.python.org/pipermail/python-es/2021-February/037931.html.

                                                      • lxml: https://lxml.de/.

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

                                                      • XPath: https://es.wikipedia.org/wiki/XPath.

                                                      • Scrapy: https://scrapy.org/.

                                                      • El buscador de PyPI https://pypi.org/ funciona fatal a la

                                                        hora de ordenar por relevancia.

                                                      • [01:20:02] El valor de estudiar el código fuente ajeno no solo

                                                        para aprender de él sino también para descubrir qué bibliotecas
                                                        útiles utilizan para añadirlas a tu cajón de herramientas.

                                                        • Es la documentación última.

                                                        • Los tests son muy útiles para saber cómo se usa el producto.

                                                        • [01:22:02] ¿Cómo gestionáis la paginación cuando los datos del

                                                          backend cambian? ¿Cómo evitáis repetir resultados o saltaros
                                                          datos?

                                                          • Brainstorming de diversas estrategias.

                                                          • Berkeley DB: https://pypi.org/project/berkeleydb/.

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

                                                          • Multiversion concurrency control:

                                                            https://es.wikipedia.org/wiki/Multiversion_concurrency_control.

                                                          • Copy on Write:

                                                            https://es.wikipedia.org/wiki/Copy_on_write.

                                                          • Snapshot:

                                                            https://es.wikipedia.org/wiki/Copia_instant%C3%A1nea_de_volumen.

                                                          • BTree: https://es.wikipedia.org/wiki/%C3%81rbol-B.

                                                          • PostgreSQL: https://www.postgresql.org/.

                                                          • ZFS:

                                                            https://es.wikipedia.org/wiki/ZFS_(sistema_de_archivos).

                                                          • Normalización y formas normales:

                                                            https://es.wikipedia.org/wiki/Forma_normal_(base_de_datos).

                                                          • [01:48:42] FOSDEM https://fosdem.org/:

                                                            Virako recomienda las siguientes:

                                                            • Some SQL Tricks of an Application DBA - Non-trivial tips for

                                                              database development
                                                              https://fosdem.org/2021/schedule/event/postgresql_some_sql_tricks_of_an_application_dba/.

                                                            • Database Disasters and How to Find Them

                                                              https://fosdem.org/2021/schedule/event/postgresql_database_disasters_and_how_to_find_them/.

                                                            • Practical advice for using Mypy - Hidden gems in the typing

                                                              system!
                                                              https://fosdem.org/2021/schedule/event/python_mypy/.

                                                            • Escaping the Cargo Cult - How to structure your project

                                                              without losing your mind.
                                                              https://fosdem.org/2021/schedule/event/python_escaping_cargo_cult/.

                                                            • [01:52:02] Charla Python Madrid https://www.python-madrid.es/.

                                                              • TDD - ¿panacea del desarrollo o pérdida de tiempo?
                                                              • https://www.python-madrid.es/meetings/reunion-febrero-2021-python-madrid/.
                                                              • [01:54:27] Comentado en la tertulia de la semana pasada: Bugs

                                                                sobre "pickle" https://docs.python.org/3/library/pickle.html
                                                                en el módulo __main__.

                                                                Se trata de un problema conocido.

                                                                • Ejemplo de código: https://pastebin.com/vGM1sh8r.

                                                                • Issue24676: Error in pickle using cProfile

                                                                  https://bugs.python.org/issue24676.

                                                                • Issue9914: trace/profile conflict with the use of

                                                                  sys.modules[__name__] https://bugs.python.org/issue9914.

                                                                • Issue9325: Add an option to pdb/trace/profile to run library

                                                                  module as a script https://bugs.python.org/issue9325.

                                                                • [02:00:42] Que te cuenten lo que no funciona es mucho más

                                                                  interesante.

                                                                  • Postmortem.
                                                                  • [02:02:52] Whoosh:

                                                                    https://whoosh.readthedocs.io/en/latest/intro.html. ¿Cómo
                                                                    normalizar las palabras para español?

                                                                    • La palabra "real" Whoosh:
                                                                    • https://www.wordreference.com/es/translation.asp?tranword=whoosh.
                                                                      Dificultades para buscar el proyecto Python Whoosh
                                                                      https://whoosh.readthedocs.io/en/latest/intro.html en
                                                                      internet.
                                                                    • [02:05:48] Final.

                                                                      2 hr 7 min
                                                                    • Python en español #18: Tertulia 2021-02-02
                                                                      Anotaciones de tipos: ¿Son pythónicas? También versiones de paquetes y grafos de dependencias https://podcast.jcea.es/python/18

                                                                      En este audio hay un hablante que no identifico. ¿Quien es?. Es

                                                                      quien habla, por ejemplo, en 01:06:00 o en 01:12:00. ¿Antoni?

                                                                      Participantes:

                                                                      • Jesús Cea, email: [email protected], twitter:

                                                                        @jcea, https://blog.jcea.es/,
                                                                        https://www.jcea.es/. Conectando desde Madrid.

                                                                      • Víctor Ramírez, twitter: @virako,

                                                                        programador python y amante de
                                                                        vim, conectando desde Huelva.

                                                                      • Dani, conectando desde Málaga.

                                                                      • Eduardo Castro, email:

                                                                        [email protected]. Conectando desde A
                                                                        Guarda.

                                                                        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] Preámbulo.

                                                                          • Design of CPython’s Garbage Collector:

                                                                            https://devguide.python.org/garbage_collector/.

                                                                          • Dificultades con el horario de la tertulia.

                                                                            • Podría haber más tertulias en otros horarios, llevadas
                                                                            • por otras personas.
                                                                            • Problemas para publicar los audios.

                                                                              • Editar es un infierno.

                                                                              • Las notas de los audios tienen una importancia

                                                                                transcendental.

                                                                              • Dinámica de las tertulias.

                                                                                • Antiguo podcast "Python en español":
                                                                                • https://podcast.jcea.es/python/.
                                                                                • [08:32] Presentaciones.

                                                                                  • Raspberry Pi Pico:

                                                                                    https://www.raspberrypi.org/products/raspberry-pi-pico/.

                                                                                  • Micropython: https://www.micropython.org/.

                                                                                  • [13:32] El aviso legal para poder grabar los audios.

                                                                                  • [14:32] Bugs sobre "pickle"

                                                                                    https://docs.python.org/3/library/pickle.html en el módulo
                                                                                    __main__.

                                                                                    Se trata de un problema conocido.

                                                                                    • Ejemplo de código: https://pastebin.com/vGM1sh8r.

                                                                                    • Issue24676: Error in pickle using cProfile

                                                                                      https://bugs.python.org/issue24676.

                                                                                    • Issue9914: trace/profile conflict with the use of

                                                                                      sys.modules[__name__] https://bugs.python.org/issue9914.

                                                                                    • Issue9325: Add an option to pdb/trace/profile to run library

                                                                                      module as a script https://bugs.python.org/issue9325.

                                                                                    • [16:27] Lo importante que es abrir bugs, para que puedan

                                                                                      solucionarse. Queja productiva.

                                                                                    • [18:12] Nueva versión de MYPY http://mypy-lang.org/ y MYPYC

                                                                                      https://github.com/mypyc/mypyc, que aprovechan Python 3.9.

                                                                                      Sigue fallando mucho.

                                                                                    • [20:42] pyannotate https://pypi.org/project/pyannotate/ para

                                                                                      meter anotaciones de tipos de forma automática.

                                                                                      • Las dificultades de meter tipos en un proyecto ya maduro.
                                                                                      • [22:52] Puedes usar tipos o no. Son opcionales. Ventajas en

                                                                                        equipos grandes.

                                                                                        • Linter: https://es.wikipedia.org/wiki/Lint.

                                                                                        • Impone disciplina y una cultura.

                                                                                        • Las anotaciones de tipos no se verifican en tiempo de

                                                                                          ejecución. Se usan en el sistema de test e integración
                                                                                          continua.

                                                                                        • Una de la ventaja de los "__slots__" es que si te

                                                                                          equivocas en el nombre de atributo en una asignación, te
                                                                                          dará un error claro. Los tipos ayudan aquí también.

                                                                                        • "pyannotate" https://pypi.org/project/pyannotate/.

                                                                                        • Las anotaciones de tipos te permiten luego compilar Python

                                                                                          para ganar rendimiento "sin coste".

                                                                                        • Las anotaciones se pueden meter en el mismo código o en un

                                                                                          fichero "compañero".

                                                                                          • Usar un fichero "compañero" es útil para poder usar

                                                                                            anotaciones modernas en versiones antiguas de Python.

                                                                                          • Evitar "contaminar" el sistema de control de versiones

                                                                                            con cambios masivos irrelevantes que ofuscan la historia
                                                                                            de un proyecto. Por ejemplo, el autor original del código.

                                                                                          • Que los creadores de código y los etiquetadores de tipos

                                                                                            sean personas diferentes.

                                                                                          • "typeshed": Collection of library stubs for Python, with

                                                                                            static types: https://github.com/python/typeshed.

                                                                                          • ¿Y meter tipos en los comentarios, como se hacía

                                                                                            antiguamente?

                                                                                          • Hay mucha literatura de ingeniería de software sobre si es

                                                                                            bueno documentar tipos o no, según el tipo de equipo y el
                                                                                            tipo de proyecto.

                                                                                          • [40:17] Python podría ser mucho más rápido aunque no se usen

                                                                                            tipos. Podría ser mucho más inteligente.

                                                                                            • Descubrimiento de tipos en tiempo de ejecución.

                                                                                            • Tema recurrente.

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

                                                                                            • Javascript V8:

                                                                                              https://en.wikipedia.org/wiki/V8_(JavaScript_engine).

                                                                                            • [43:06] Habiendo tantos compiladores, ¿por qué no se integra

                                                                                              alguno en el intérprete normal de Python?

                                                                                              • Complejidad y compatibilidad.

                                                                                              • Faltan manos.

                                                                                              • Hay muchos "gérmenes" que no germinan.

                                                                                              • Dispersión de esfuerzos.

                                                                                              • [46:12] Puntos de dolor de Python para la gente que viene de

                                                                                                otros lenguajes:

                                                                                                • Tipos.

                                                                                                • Velocidad.

                                                                                                • Espacios significantes.

                                                                                                • [46:37] ¿Qué es "Python"?

                                                                                                  • Cada novedad de sintaxis de Python cambia el lenguaje. ¿Qué

                                                                                                    es Python?

                                                                                                    • Problemas para los que llegan nuevos al lenguaje.
                                                                                                    • Hay organizaciones grandes que un lenguaje sin tipos ni

                                                                                                      siquiera lo consideran.

                                                                                                    • [51:22] Cultura común en todos los proyectos Python. Baja

                                                                                                      barrera de entrada si conoces esa cultura.

                                                                                                    • La cultura va evolucionando.

                                                                                                    • Solución de compromiso: Meter tipos solo en la frontera.

                                                                                                    • [53:02] El tipado avanzado de Python 3.9 da un error de sintaxis

                                                                                                      al importar el código en una versión anterior de Python.

                                                                                                    • [54:46] El operador morsa no se puede usar dentro de un "list

                                                                                                      comprehension":

                                                                                                      >>> [i for i in ('a', '' ,'b') if i := i.strip()]
                                                                                                      File "", line 1
                                                                                                      [i for i in ('a', '' ,'b') if i := i.strip()]
                                                                                                      ^
                                                                                                      SyntaxError: invalid syntax

                                                                                                      No queda otra que escribirlo como:

                                                                                                      >>> [i.strip() for i in ('a', '' ,'b') if i.strip()]
                                                                                                      ['a', 'b']

                                                                                                      duplicando el i.strip().

                                                                                                    • [56:40] En versiones de Python anteriores a 3.8 no se podría

                                                                                                      usar un continue en un finally. El texto era
                                                                                                      https://docs.python.org/3.7/reference/compound_stmts.html#the-try-statement:

                                                                                                      When a return, break or continue statement is executed in

                                                                                                      the try suite of a try...finally statement, the finally clause
                                                                                                      is also executed ‘on the way out.’ A continue statement is
                                                                                                      illegal in the finally clause. (The reason is a problem with
                                                                                                      the current implementation — this restriction may be lifted in
                                                                                                      the future).

                                                                                                      • Eso se solucionó en Issue32489: Allow 'continue' in
                                                                                                      • 'finally' clause: https://bugs.python.org/issue32489.
                                                                                                      • [57:47] f-string con datetime

                                                                                                        https://docs.python.org/3/library/datetime.html.

                                                                                                        • Ya está en los propios ejemplos de PEP 498: Literal String
                                                                                                        • Interpolation: https://www.python.org/dev/peps/pep-0498/.
                                                                                                        • [59:22] Modo depuración en f-strings en Python 3.8:

                                                                                                          >>> a = 5
                                                                                                          >>> f'{a=}'
                                                                                                          'a=5'

                                                                                                          Útil para el loging.

                                                                                                        • [01:00:47] Versiones fijas de dependencias y actualizar un

                                                                                                          despliegue.

                                                                                                          • Herramientas para esto: "pip"

                                                                                                            https://pypi.org/project/pip/, "virtualenv"
                                                                                                            https://pypi.org/project/virtualenv/.

                                                                                                          • "pipenv" https://pypi.org/project/pipenv/.

                                                                                                          • "Poetry": https://pypi.org/project/poetry/.

                                                                                                          • Grafo de dependencias "pip-tree": https://pypi.org/project/pip-tree/.

                                                                                                          • Paralelismos con el enlazado estático y dinámico.

                                                                                                          • [01:14:22] ¿Por qué se ha instalado este paquete, qué paquetes

                                                                                                            exige y qué paquetes dependen de él?

                                                                                                            • pip show.

                                                                                                            • Grafo de dependencias "pip-tree": https://pypi.org/project/pip-tree/.

                                                                                                            • [01:19:22] Visualizar el grafo de versiones de un sistema de

                                                                                                              control de versiones moderno. Por ejemplo con Mercurial: "hg
                                                                                                              glog" https://www.mercurial-scm.org/.

                                                                                                            • [01:23:07] Recogida de basuras:

                                                                                                              • Design of CPython’s Garbage Collector:

                                                                                                                https://devguide.python.org/garbage_collector/.

                                                                                                              • Hora de sacar la basura garbage collector - Pablo Galindo y

                                                                                                                Victor Terrón - PyConES 2018
                                                                                                                https://www.youtube.com/watch?v=G9wOSExzs5g.

                                                                                                              • La recolección de basura de la generación más antigua

                                                                                                                funciona de forma diferente. En vez de ser por un número
                                                                                                                fijo de desequilibrio entre creación y destrucción de
                                                                                                                objetos, funciona por porcentaje.

                                                                                                              • [01:31:37] Divagación: Powerball https://powerball.org.uk/.

                                                                                                              • [01:31:52] Explicación de cómo funciona "__slots__"

                                                                                                                https://docs.python.org/3/reference/datamodel.html.

                                                                                                              • [01:34:22] Libro "CPython Internals":

                                                                                                                https://realpython.com/products/cpython-internals-book/.

                                                                                                                • Website de "Real Python": https://realpython.com/. Merece

                                                                                                                  bastante la pena.

                                                                                                                • También tienen podcast: "The Real Python Podcast: Python

                                                                                                                  Tips, Interviews, and More"
                                                                                                                  https://realpython.com/podcasts/rpp/.

                                                                                                                • [01:36:42] Más sobre "__slots__"

                                                                                                                  https://docs.python.org/3/reference/datamodel.html.

                                                                                                                  • Técnica estándar.

                                                                                                                  • Un diccionario vacío ocupa 64 bytes: sys.getsizeof({}).

                                                                                                                  • Se puede usar para evitar errores mecanográficos al escribir

                                                                                                                    en atributos.

                                                                                                                  • [01:38:52] "AutoScraper: A Smart, Automatic, Fast and

                                                                                                                    Lightweight Web Scraper for Python"
                                                                                                                    https://pypi.org/project/autoscraper/. Búsquedas "borrosas".

                                                                                                                    • Seguimos sin encontrar la biblioteca de scraping de foros de
                                                                                                                    • la que ha hablado Eduardo en tertulias anteriores.
                                                                                                                    • [01:43:02] Librería para dibujar grafos: graphviz

                                                                                                                      https://pypi.org/project/graphviz/.

                                                                                                                      • Le das un texto describiendo nodos y conexiones entre nodos

                                                                                                                        y calcula un gráfico.

                                                                                                                      • Sería trivial para dibujar el grafo de dependencias de

                                                                                                                        "pip".

                                                                                                                      • Ejemplo:

                                                                                                                        • El gráfico de antes, con ciclos:

                                                                                                                          https://lists.es.python.org/pipermail/general/attachments/20201229/0c14bc58/attachment-0002.png.

                                                                                                                        • El gráfico de después, sin ciclos:

                                                                                                                          https://lists.es.python.org/pipermail/general/attachments/20201229/0c14bc58/attachment-0003.png.

                                                                                                                        • [01:47:22] ¿Cómo asegurarse que el nombre de un fichero no tenga

                                                                                                                          caracteres extraños? ¡Problema de seguridad!

                                                                                                                          • Expresiones regulares. Cuidado con el unicode

                                                                                                                            https://en.wikipedia.org/wiki/Unicode. Mejor usar una
                                                                                                                            lista blanca que una lista negra.

                                                                                                                          • Usar pathlib.is_relative_to()

                                                                                                                            https://docs.python.org/3/library/pathlib.html#pathlib.PurePath.is_relative_to.
                                                                                                                            Novedad en Python 3.9.

                                                                                                                          • [01:52:07] ¡Usa la versión actual de Python, leches! Ahora

                                                                                                                            mismo, Python 3.9.

                                                                                                                            • Ventajas de compilar el intérprete desde código fuente para

                                                                                                                              no depender de la versión que te proporciona el sistema
                                                                                                                              operativo.

                                                                                                                            • Puedes tener tu propio intérprete de Python dentro de un

                                                                                                                              "virtualenv" https://pypi.org/project/virtualenv/.

                                                                                                                            • Proyectos "llave en mano". El cliente quiere algo que se

                                                                                                                              instale como un componente en lo que ya conoce. Por ejemplo,
                                                                                                                              en un panel de configuración en un servicio de hospedaje.

                                                                                                                            • [01:56:47] Jesús Cea repite una vez más la anécdota de que

                                                                                                                              al principio de los tiempos para conducir un coche tenías
                                                                                                                              que ser mecánico, pero ya no.

                                                                                                                              Falta toda la base, pero... ¿Hace falta?

                                                                                                                            • [01:59:12] Memoria escasa en un microcontrolador.

                                                                                                                            • [01:59:55] Final.

                                                                                                                              2 hr 1 min
                                                                                                                            • Python en español #17: Tertulia 2021-01-26
                                                                                                                              Eduardo Castro se desata y nos invita a comentar trucos y construcciones idiomáticas no evidentes https://podcast.jcea.es/python/17

                                                                                                                              Participantes:

                                                                                                                              • Jesús Cea, email: [email protected], twitter:

                                                                                                                                @jcea, https://blog.jcea.es/,
                                                                                                                                https://www.jcea.es/. Conectando desde Madrid.

                                                                                                                              • Eduardo Castro, email:

                                                                                                                                [email protected]. Conectando desde A
                                                                                                                                Guarda.

                                                                                                                              • Javier, conectando desde Madrid.

                                                                                                                              • Víctor Ramírez, twitter: @virako,

                                                                                                                                programador python y amante de vim, conectando desde Huelva.

                                                                                                                              • Dani, conectando desde Málaga.

                                                                                                                              • Miguel Sánchez, email:

                                                                                                                                [email protected], conectando desde
                                                                                                                                Canarias.

                                                                                                                              • Jorge Rúa, conectando desde Vigo.

                                                                                                                                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] Haciendo tiempo hasta que entre más gente.

                                                                                                                                  • Raspberry Pi Pico:

                                                                                                                                    https://www.raspberrypi.org/products/raspberry-pi-pico/.

                                                                                                                                    • Jesús Cea está encantado con su rango de alimentación.
                                                                                                                                    • Micropython: https://www.micropython.org/.

                                                                                                                                    • [06:02] Truco: Python -i: Ejecuta un script y pasa a modo

                                                                                                                                      interactivo.

                                                                                                                                      También se puede hacer desde el propio código con

                                                                                                                                      code.InteractiveConsole(locals=globals()).interact().

                                                                                                                                      Jesús Cea se queja de que usando la invocación desde código

                                                                                                                                      no funciona la edición de líneas. Javier da la pista correcta:
                                                                                                                                      para que funcione, basta con hacer import readline antes de
                                                                                                                                      lanzar el modo interactivo.

                                                                                                                                    • [11:17] Regresión con ipdb: https://pypi.org/project/ipdb/.

                                                                                                                                    • [12:37] Nueva versión de Pyston https://www.pyston.org/.

                                                                                                                                      • Intérprete de Python más rápido. Un 50% más rápido que
                                                                                                                                      • cpython.
                                                                                                                                      • [16:22] Ver si dos fechas son iguales con datetime

                                                                                                                                        https://docs.python.org/3/library/datetime.html.

                                                                                                                                        • Trabajar siempre en UTC
                                                                                                                                        • https://es.wikipedia.org/wiki/Tiempo_universal_coordinado,
                                                                                                                                          aunque solo tengas una zona horaria.
                                                                                                                                        • [19:52] Jesús Cea ha investigado cómo funcionan los POSTs HTTP

                                                                                                                                          en las protecciones CSRF https://es.wikipedia.org/wiki/CSRF.

                                                                                                                                          • Buena práctica: La respuesta al POST es una redirección a un

                                                                                                                                            GET. Patrón Post/Redirect/Get (PRG)
                                                                                                                                            https://es.wikipedia.org/wiki/Post/Redirect/Get.

                                                                                                                                          • Ventajas de usar un framework.

                                                                                                                                          • [24:32] ¿Optimizaciones cuando tienes grandes cantidades de

                                                                                                                                            datos?

                                                                                                                                            • Tema muy amplio, hacen falta detalles del problema.

                                                                                                                                            • Se ofrecen algunas ideas:

                                                                                                                                              • Map/Reduce: https://en.wikipedia.org/wiki/Map_reduce.

                                                                                                                                              • Usar generadores u otras construcciones "lazy" siempre

                                                                                                                                                que sea posible.
                                                                                                                                                https://wiki.python.org/moin/Generators.

                                                                                                                                              • [31:52] Gestión de memoria en Python.

                                                                                                                                                • Design of CPython’s Garbage Collector:

                                                                                                                                                  https://devguide.python.org/garbage_collector/.

                                                                                                                                                • Hora de sacar la basura garbage collector - Pablo Galindo y

                                                                                                                                                  Victor Terrón - PyConES 2018
                                                                                                                                                  https://www.youtube.com/watch?v=G9wOSExzs5g.

                                                                                                                                                • [35:17] Tipografía para programadores:

                                                                                                                                                  • Victor Mono: https://rubjo.github.io/victor-mono/.

                                                                                                                                                  • Fira Code: https://fonts.google.com/specimen/Fira+Code.

                                                                                                                                                  • Fira Code Retina:

                                                                                                                                                    https://github.com/tonsky/FiraCode/issues/872.

                                                                                                                                                  • [37:17] Eduardo Castro se ha currado una lista de trucos

                                                                                                                                                    sencillos pero interesantes:

                                                                                                                                                    En estas notas solo referenciamos los puntos a los que

                                                                                                                                                    dedicamos más tiempo, se habló de más cosas.

                                                                                                                                                    El documento para poder seguir los comentarios de la

                                                                                                                                                    grabación está en https://demo.hedgedoc.org/s/hEZB92q40#.

                                                                                                                                                    • hash(float('inf')) -> 314159.

                                                                                                                                                    • [43:02] LRU Caché:

                                                                                                                                                      <https://docs.python.org/3/library/functools.html#functools.lru_cache.

                                                                                                                                                      • Bugs abundantes en LRU Cache y múltiples hilos:
                                                                                                                                                      • https://bugs.python.org/issue?%40columns=id%2Cactivity%2Ctitle%2Ccreator%2Cassignee%2Cstatus%2Ctype&%40sort=-activity&%40filter=status&%40action=searchid&ignore=file%3Acontent&%40search_text=lru_cache+threads&submit=search&status=-1%2C1%2C2%2C3.
                                                                                                                                                      • Yield:

                                                                                                                                                        • Ojo con excepciones y filtraciones de memoria.

                                                                                                                                                        • [48:37] Uso interesante con los "context managers":

                                                                                                                                                          @contextlib.contextmanager
                                                                                                                                                          https://docs.python.org/3/library/contextlib.html#contextlib.contextmanager
                                                                                                                                                          y @contextlib.asynccontextmanager
                                                                                                                                                          https://docs.python.org/3/library/contextlib.html#contextlib.asynccontextmanager.

                                                                                                                                                        • [51:12] itertools:

                                                                                                                                                          https://docs.python.org/3/library/itertools.html. A Jesús
                                                                                                                                                          Cea no le entra en la cabeza la programación funcional.

                                                                                                                                                        • [56:02] ¿Qué es ser Pythonico?

                                                                                                                                                          • Aunque esté en la biblioteca estándar, no significa que sea

                                                                                                                                                            pythónico:

                                                                                                                                                            • asyncore:

                                                                                                                                                              https://docs.python.org/3/library/asyncore.html. Está
                                                                                                                                                              marcado como obsoleto desde Python 3.6.

                                                                                                                                                            • Mover métodos funcionales en una librería separada.

                                                                                                                                                            • Las dos jerarquías distintas que existían en Python 2.

                                                                                                                                                              Esto se unificó en Python 3.

                                                                                                                                                            • from __future__ import ....

                                                                                                                                                            • La migración a Python 3 fue un intento de simplificar el

                                                                                                                                                              lenguaje. Pero Python 3 se está complicando cada vez
                                                                                                                                                              más.

                                                                                                                                                              • La complejidad fragmenta los diferentes idiomas del
                                                                                                                                                              • lenguaje.
                                                                                                                                                              • [01:08:22] Seguimos desgranando los trucos propuestos por

                                                                                                                                                                Eduardo.

                                                                                                                                                                • collections.defaultdict():
                                                                                                                                                                • https://docs.python.org/3/library/collections.html#collections.defaultdict.
                                                                                                                                                                • [01:11:12] iter() y next() admiten una parametro extra

                                                                                                                                                                  centinela opcional que especifica un valor que termina el
                                                                                                                                                                  iterador.

                                                                                                                                                                  • Utilizar objetos centinelas que no sean None, porque
                                                                                                                                                                  • None puede ser un objeto válido.
                                                                                                                                                                  • [01:17:32] Los "slices" son objetos que se pueden crear y

                                                                                                                                                                    utilizar: slice(1,100).

                                                                                                                                                                    • Pasar un iterador a una función abre posibilidades

                                                                                                                                                                      interesantes.

                                                                                                                                                                    • Slice Objects: https://docs.python.org/3/c-api/slice.html.

                                                                                                                                                                    • [01:23:42] contextlib.suppress()

                                                                                                                                                                      https://docs.python.org/3/library/contextlib.html#contextlib.suppress.

                                                                                                                                                                      • Hay que recordar que aunque la excepción se suprime, la
                                                                                                                                                                      • ejecución del cuerpo se corta en ese punto.
                                                                                                                                                                      • [01:24:47] pathlib:

                                                                                                                                                                        https://docs.python.org/3/library/pathlib.html.

                                                                                                                                                                      • [01:25:12] Usos atípicos de else: if, for, try,

                                                                                                                                                                        while...

                                                                                                                                                                        • https://docs.python.org/3/tutorial/controlflow.html#break-and-continue-statements-and-else-clauses-on-loops.

                                                                                                                                                                        • https://docs.python.org/3/tutorial/errors.html#handling-exceptions.

                                                                                                                                                                        • Teoría unificada sobre else en Python.

                                                                                                                                                                        • [01:30:07] El orden de los except ... IMPORTA.

                                                                                                                                                                        • [01:32:22] Tu yo del futuro tiene que tratar con tu yo del

                                                                                                                                                                          pasado. "Escribe código como si el siguiente que tuviera que
                                                                                                                                                                          trabajar con el fuese un psicópata asesino que sabe
                                                                                                                                                                          donde vives".

                                                                                                                                                                          • Sistemas de control de versiones: "Annotate" -> "blame".
                                                                                                                                                                          • [01:33:57] Usos de lambda.

                                                                                                                                                                            • Módulo Operator: https://docs.python.org/3/library/operator.html.
                                                                                                                                                                            • [01:35:52] Algunos trucos cortos adicionales.

                                                                                                                                                                              • collections.deque:

                                                                                                                                                                                https://docs.python.org/3/library/collections.html.

                                                                                                                                                                              • dateutil: https://pypi.org/project/python-dateutil/.

                                                                                                                                                                              • itertools:

                                                                                                                                                                                https://docs.python.org/3/library/itertools.html.

                                                                                                                                                                              • if a < x < b:

                                                                                                                                                                                >>> import dis
                                                                                                                                                                                >>> dis.dis(lambda x: a < x < b)
                                                                                                                                                                                1 0 LOAD_GLOBAL 0 (a)
                                                                                                                                                                                2 LOAD_FAST 0 (x)
                                                                                                                                                                                4 DUP_TOP
                                                                                                                                                                                6 ROT_THREE
                                                                                                                                                                                8 COMPARE_OP 0 (<)
                                                                                                                                                                                10 JUMP_IF_FALSE_OR_POP 18
                                                                                                                                                                                12 LOAD_GLOBAL 1 (b)
                                                                                                                                                                                14 COMPARE_OP 0 (<)
                                                                                                                                                                                16 RETURN_VALUE
                                                                                                                                                                                >> 18 ROT_TWO
                                                                                                                                                                                20 POP_TOP
                                                                                                                                                                                22 RETURN_VALUE
                                                                                                                                                                              • Desempaquetado complejo:

                                                                                                                                                                                >>> a, b, (c, d), *e, f = 1, 2, (3, 4), 5, 6, 7, 8, 9
                                                                                                                                                                                >>> print(a,b,c,d,e,f)
                                                                                                                                                                                1 2 3 4 [5, 6, 7, 8] 9
                                                                                                                                                                              • Usar la variable "guión bajo" para descartar valores. Ojo

                                                                                                                                                                                con la internacionalización.

                                                                                                                                                                              • [01:56:22] Python cada vez tiene más "gotchas". Algunos

                                                                                                                                                                                ejemplos:

                                                                                                                                                                                • Operador morsa. Tratado con projilidad en tertulias

                                                                                                                                                                                  anteriores.

                                                                                                                                                                                • Parámetros mutables.

                                                                                                                                                                                • Definir "closures" dentro de un for pero usarlo fuera.

                                                                                                                                                                                • Tuplas con un solo elemento. Es más evidente el constructor

                                                                                                                                                                                  tuple(), pero ojo: tuple('abc') -> ('a', 'b', 'c').

                                                                                                                                                                                • [02:01:06] ¡Terminamos con los trucos!

                                                                                                                                                                                • [02:01:37] Ideas para indexar y buscar el documentos:

                                                                                                                                                                                  • Whoosh:

                                                                                                                                                                                    https://whoosh.readthedocs.io/en/latest/intro.html.

                                                                                                                                                                                  • Solr: https://solr.apache.org/.

                                                                                                                                                                                  • [02:04:22] Deberes para el futuro: módulos dis

                                                                                                                                                                                    https://docs.python.org/3/library/dis.html y enum
                                                                                                                                                                                    https://docs.python.org/3/library/enum.html.

                                                                                                                                                                                  • [02:04:47] Sugerencia sobre visión artificial:

                                                                                                                                                                                    https://www.pyimagesearch.com/. De lo mejor que hay.

                                                                                                                                                                                  • [02:06:47] regex https://pypi.org/project/regex/ que libera el

                                                                                                                                                                                    GIL https://en.wikipedia.org/wiki/Global_interpreter_lock.

                                                                                                                                                                                  • [02:07:47] Acelerador y distribución de programas Python

                                                                                                                                                                                    precompilados en binario y empaquetados en un directorio e,
                                                                                                                                                                                    incluso, en un único fichero: Nuitka: https://nuitka.net/.

                                                                                                                                                                                  • [02:08:57] Design of CPython’s Garbage Collector:

                                                                                                                                                                                    https://devguide.python.org/garbage_collector/.

                                                                                                                                                                                  • [02:09:17] Cierre.

                                                                                                                                                                                  • [02:10:52] Casi se nos olvida el aviso legal para grabar y

                                                                                                                                                                                    publicar las sesiones.

                                                                                                                                                                                  • [02:12:55] Final.

                                                                                                                                                                                    2 hr 14 min
                                                                                                                                                                                  • Python en español #16: Tertulia 2021-01-19
                                                                                                                                                                                    Polémica Frameworks, compilación al vuelo, compiladores y rendimiento Python, scraping web y la persistencia vuelve a la carga https://podcast.jcea.es/python/16

                                                                                                                                                                                    Participantes:

                                                                                                                                                                                    • Jesús Cea, email: [email protected], twitter:

                                                                                                                                                                                      @jcea, https://blog.jcea.es/,
                                                                                                                                                                                      https://www.jcea.es/. Conectando desde Madrid.

                                                                                                                                                                                    • Eduardo Castro, email:

                                                                                                                                                                                      [email protected]. Conectando desde A
                                                                                                                                                                                      Guarda.

                                                                                                                                                                                    • Javier, conectando desde Madrid.

                                                                                                                                                                                    • Víctor Ramírez, twitter: @virako,

                                                                                                                                                                                      programador python y amante de vim, conectando desde Huelva.

                                                                                                                                                                                    • Dani, conectando desde Málaga, invitado por Virako.

                                                                                                                                                                                    • Javier, conectando desde Sevilla, también invitado por Virako.

                                                                                                                                                                                    • Antonio, conectado desde Albacete.

                                                                                                                                                                                    • Jorge Rúa, conectando desde Vigo.

                                                                                                                                                                                      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.

                                                                                                                                                                                      • [01:17] Event sourcing y nieve.

                                                                                                                                                                                        • Borrasca Filomena:
                                                                                                                                                                                        • https://es.wikipedia.org/wiki/Borrasca_Filomena.
                                                                                                                                                                                        • [03:52] Los comentarios legales habituales para poder grabar

                                                                                                                                                                                          la tertulia.

                                                                                                                                                                                        • [04:47] Presentaciones varias, dinámica y motivación de las

                                                                                                                                                                                          tertulias.

                                                                                                                                                                                        • [11:22] Los problemas logísticos de Jesús Cea con sus charlas.

                                                                                                                                                                                        • [12:52] Debate: Frameworks y cómo condicionan el conocimiento

                                                                                                                                                                                          del lenguaje y la forma de desarrollar código.

                                                                                                                                                                                          Mucha tela que cortar.

                                                                                                                                                                                          • [30:22] Conexión con el mundo asyncio.

                                                                                                                                                                                          • [34:12] Digresión: ¿Cómo funciona la protección CSRF?

                                                                                                                                                                                            https://es.wikipedia.org/wiki/Cross-site_request_forgery.

                                                                                                                                                                                            • Diferencia semántica entre verbos HTTP: GET y POST

                                                                                                                                                                                              https://en.wikipedia.org/wiki/POST_(HTTP).

                                                                                                                                                                                            • Algunos recursos de seguridad web (no exhaustivo, la

                                                                                                                                                                                              lista es infinita):

                                                                                                                                                                                              • CSRF:

                                                                                                                                                                                                https://es.wikipedia.org/wiki/Cross-site_request_forgery.

                                                                                                                                                                                              • Cross-Origin Resource Sharing (CORS)

                                                                                                                                                                                                https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS.

                                                                                                                                                                                              • Content Security Policy Reference

                                                                                                                                                                                                https://content-security-policy.com/.

                                                                                                                                                                                              • La documentación de FastAPI

                                                                                                                                                                                                https://fastapi.tiangolo.com/ tiene mucho de
                                                                                                                                                                                                seguridad:

                                                                                                                                                                                                • CORS (Cross-Origin Resource Sharing):

                                                                                                                                                                                                  https://fastapi.tiangolo.com/tutorial/cors/.

                                                                                                                                                                                                • OAuth2 with Password (and hashing), Bearer with

                                                                                                                                                                                                  JWT tokens
                                                                                                                                                                                                  https://fastapi.tiangolo.com/tutorial/security/oauth2-jwt/.

                                                                                                                                                                                                • About HTTPS

                                                                                                                                                                                                  https://fastapi.tiangolo.com/deployment/https/.

                                                                                                                                                                                                • [39:52] Proyecto ItsNat

                                                                                                                                                                                                  https://en.wikipedia.org/wiki/ItsNat. Estado en el
                                                                                                                                                                                                  servidor y el cliente solo gestiona eventos y
                                                                                                                                                                                                  actualizaciones del DOM que le envía el servidor.

                                                                                                                                                                                                • Se está moviendo otra vez la inteligencia del navegador al

                                                                                                                                                                                                  servidor.

                                                                                                                                                                                                • [44:42] ¿Realmente es imprescindible usar Javascript si tu

                                                                                                                                                                                                  interfaz es el navegador?

                                                                                                                                                                                                  • Brython: https://brython.info/.

                                                                                                                                                                                                  • Pyjs (antiguo Pyjamas):

                                                                                                                                                                                                    https://en.wikipedia.org/wiki/Pyjs.

                                                                                                                                                                                                  • Emscripten: https://emscripten.org/.

                                                                                                                                                                                                  • [48:57] ¡Compilación al vuelo!

                                                                                                                                                                                                    • Versionado de diccionarios. PEP 509 Add a private version to

                                                                                                                                                                                                      dict: https://www.python.org/dev/peps/pep-0509/.

                                                                                                                                                                                                    • Compilación al vuelo: Pyjion:

                                                                                                                                                                                                      https://pyjion.readthedocs.io/en/latest/index.html.

                                                                                                                                                                                                    • Conflicto con la portabilidad del intérprete.

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

                                                                                                                                                                                                    • Hay pocos "core developers" y heredar código avanzado que

                                                                                                                                                                                                      luego hay que mantener es un problema.

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

                                                                                                                                                                                                    • [01:04:27] Los lenguajes de programación deben ser conservadores

                                                                                                                                                                                                      porque no tienes ni idea de lo que están utilizando los
                                                                                                                                                                                                      programadores.

                                                                                                                                                                                                    • [01:05:32] Si la documentación se ha actualizado, más vale que

                                                                                                                                                                                                      hayas actualizado tu código a "cómo se hacen ahora las cosas".

                                                                                                                                                                                                    • [01:06:47] Tema recurrente: ¿Es mejor estar dentro o fuera de la

                                                                                                                                                                                                      biblioteca estándar?

                                                                                                                                                                                                      • Boost: https://www.boost.org/.
                                                                                                                                                                                                      • [01:09:12] Compiladores de Python:

                                                                                                                                                                                                        • Cython: https://cython.org/. Rendimiento y ofuscación.

                                                                                                                                                                                                        • nuitka: https://nuitka.net/.

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

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

                                                                                                                                                                                                        • [01:10:42] Mejoras recientes en la implementación de Python:

                                                                                                                                                                                                          • Issue 26647: ceval: use Wordcode, 16-bit bytecode:

                                                                                                                                                                                                            https://bugs.python.org/issue26647.

                                                                                                                                                                                                          • Issue 9203: Use computed gotos by default:

                                                                                                                                                                                                            https://bugs.python.org/issue9203.

                                                                                                                                                                                                          • [01:14:52] Psyco https://en.wikipedia.org/wiki/Psyco.

                                                                                                                                                                                                          • [01:16:22] Etiquetado de tipos para ayudar a los JIT.

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

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

                                                                                                                                                                                                              • MYPYC:
                                                                                                                                                                                                              • https://mypyc.readthedocs.io/en/latest/index.html.
                                                                                                                                                                                                              • Especialización.

                                                                                                                                                                                                              • [01:22:37] GHC (The Glasgow Haskell Compiler):

                                                                                                                                                                                                                https://www.haskell.org/ghc/.

                                                                                                                                                                                                              • [01:25:07] Memoria transaccional

                                                                                                                                                                                                                https://en.wikipedia.org/wiki/Transactional_memory.

                                                                                                                                                                                                                • Implementaciones en Python: Sistemas de persistencia como

                                                                                                                                                                                                                  Durus https://www.mems-exchange.org/software/DurusWorks/ o
                                                                                                                                                                                                                  ZODB http://www.zodb.org/.

                                                                                                                                                                                                                  • Mecanismos de resolución de conflictos.
                                                                                                                                                                                                                  • [01:34:32] Más sobre optimizaciones y guardas.

                                                                                                                                                                                                                    • Mucha discusión sobre el GIL:

                                                                                                                                                                                                                      https://en.wikipedia.org/wiki/Global_interpreter_lock.

                                                                                                                                                                                                                    • La atomicidad de operaciones no está documentada en ningún

                                                                                                                                                                                                                      sitio.

                                                                                                                                                                                                                    • [01:42:02] Ejemplo de bytecode:

                                                                                                                                                                                                                      >>> def rutina(n):
                                                                                                                                                                                                                      ... n += 1
                                                                                                                                                                                                                      ... n = n + 1
                                                                                                                                                                                                                      ...
                                                                                                                                                                                                                      >>> dis.dis(rutina)
                                                                                                                                                                                                                      2 0 LOAD_FAST 0 (n)
                                                                                                                                                                                                                      2 LOAD_CONST 1 (1)
                                                                                                                                                                                                                      4 INPLACE_ADD
                                                                                                                                                                                                                      6 STORE_FAST 0 (n)
                                                                                                                                                                                                                      3 8 LOAD_FAST 0 (n)
                                                                                                                                                                                                                      10 LOAD_CONST 1 (1)
                                                                                                                                                                                                                      12 BINARY_ADD
                                                                                                                                                                                                                      14 STORE_FAST 0 (n)
                                                                                                                                                                                                                      16 LOAD_CONST 0 (None)
                                                                                                                                                                                                                      18 RETURN_VALUE
                                                                                                                                                                                                                    • [01:45:02] Cuando haces cosas muy avanzadas que usan cosas no

                                                                                                                                                                                                                      definidas formalmente, mejor verificar las suposiciones.

                                                                                                                                                                                                                    • [01:46:47] La ventaja de probar cosas en proyectos personales:

                                                                                                                                                                                                                      • ¿Por qué Jesús Cea se ha hecho su propio scraper web?

                                                                                                                                                                                                                        • "Maldades".

                                                                                                                                                                                                                        • scrapy: https://scrapy.org/.

                                                                                                                                                                                                                        • [01:49:22] Migración de versiones en sistemas de persistencia.

                                                                                                                                                                                                                        • [02:05:07] Event sourcing.

                                                                                                                                                                                                                          • Event sourcing:

                                                                                                                                                                                                                            https://dev.to/barryosull/event-sourcing-what-it-is-and-why-its-awesome.

                                                                                                                                                                                                                          • Logs de modificaciones.

                                                                                                                                                                                                                          • [02:08:07] Ventajas de haber usado scrapy: https://scrapy.org/.

                                                                                                                                                                                                                            • Concurrencia.

                                                                                                                                                                                                                            • tarpit.

                                                                                                                                                                                                                            • Problemas habituales:

                                                                                                                                                                                                                              • Normalización de URLs.

                                                                                                                                                                                                                              • Webs mal formadas.

                                                                                                                                                                                                                              • [02:13:47] Módulos de scraping:

                                                                                                                                                                                                                                • newspaper3k: https://pypi.org/project/newspaper3k/.
                                                                                                                                                                                                                                • [02:15:02] Recapitulación.

                                                                                                                                                                                                                                  • Pyjion:

                                                                                                                                                                                                                                    https://pyjion.readthedocs.io/en/latest/index.html.

                                                                                                                                                                                                                                  • MYPYC: https://mypyc.readthedocs.io/en/latest/index.html.

                                                                                                                                                                                                                                  • [02:16:02] Compilación de módulos de Python para MS Windows.

                                                                                                                                                                                                                                    Generar un wheel.

                                                                                                                                                                                                                                    • Aprovechar sistemas de integración continua que levantan
                                                                                                                                                                                                                                    • máquinas virtuales.
                                                                                                                                                                                                                                    • [02:22:21] Final.

                                                                                                                                                                                                                                      2 hr 24 min
                                                                                                                                                                                                                                    • Python en español #15: Tertulia 2021-01-12
                                                                                                                                                                                                                                      Python aprieta, pero no ahoga https://podcast.jcea.es/python/15

                                                                                                                                                                                                                                      Participantes:

                                                                                                                                                                                                                                      • Jesús Cea, email: [email protected], twitter:

                                                                                                                                                                                                                                        @jcea, https://blog.jcea.es/,
                                                                                                                                                                                                                                        https://www.jcea.es/. 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.

                                                                                                                                                                                                                                      • José Luis, conectando desde Madrid.

                                                                                                                                                                                                                                      • Eduardo Castro, email:

                                                                                                                                                                                                                                        [email protected]. Conectando desde A
                                                                                                                                                                                                                                        Guarda.

                                                                                                                                                                                                                                        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.

                                                                                                                                                                                                                                        • [01:37] Reducir dependencias en los proyectos.

                                                                                                                                                                                                                                          • Las listas de Numpy https://numpy.scipy.org/ no son como

                                                                                                                                                                                                                                            las listas de Python.

                                                                                                                                                                                                                                          • statistics: https://docs.python.org/3/library/statistics.html

                                                                                                                                                                                                                                          • Hacer scraping web sin usar Scrapy https://scrapy.org/.

                                                                                                                                                                                                                                            • Beautiful Soup:
                                                                                                                                                                                                                                            • https://www.crummy.com/software/BeautifulSoup/bs4/doc/.
                                                                                                                                                                                                                                            • [05:52] Usar librerías hace que no sepas cómo funcionan las

                                                                                                                                                                                                                                              cosas.

                                                                                                                                                                                                                                              • ¿Cuánto ocupa ese objeto en memoria?

                                                                                                                                                                                                                                              • Se oculta la complejidad, se trabaja a más alto nivel.

                                                                                                                                                                                                                                              • Ineficiencia.

                                                                                                                                                                                                                                              • [09:52] La "nube" te factura toda esa ineficiencia.

                                                                                                                                                                                                                                                • Ventajas de tener servidores dedicados.

                                                                                                                                                                                                                                                • ¿Y los backups?

                                                                                                                                                                                                                                                  • ZFS

                                                                                                                                                                                                                                                    https://es.wikipedia.org/wiki/ZFS_(sistema_de_archivos).

                                                                                                                                                                                                                                                  • rsync: https://es.wikipedia.org/wiki/Rsync.

                                                                                                                                                                                                                                                  • Contenedores Solaris:

                                                                                                                                                                                                                                                    https://en.wikipedia.org/wiki/Solaris_Containers.

                                                                                                                                                                                                                                                  • Docker: https://es.wikipedia.org/wiki/Docker_(software).

                                                                                                                                                                                                                                                  • Hipervisor: https://es.wikipedia.org/wiki/Hipervisor.

                                                                                                                                                                                                                                                    • SmartOS: https://es.wikipedia.org/wiki/SmartOS.
                                                                                                                                                                                                                                                    • Ansible: https://es.wikipedia.org/wiki/Ansible_(software).

                                                                                                                                                                                                                                                      • Evitar las configuraciones manuales a toda costa.
                                                                                                                                                                                                                                                      • [16:22] Delegar en la magia hace que no sepas cómo funcionan las

                                                                                                                                                                                                                                                        cosas, pero también te permite ocuparte de problemas de más alto
                                                                                                                                                                                                                                                        nivel.

                                                                                                                                                                                                                                                        • Entender los pros y contras. Decisión informada.
                                                                                                                                                                                                                                                        • [18:47] doctest

                                                                                                                                                                                                                                                          https://docs.python.org/3/library/doctest.html.

                                                                                                                                                                                                                                                          • Una utilidad de los tests es enseñarte cómo usar un

                                                                                                                                                                                                                                                            proyecto. A veces la documentación formal es muy mala.

                                                                                                                                                                                                                                                            • Tutoriales.
                                                                                                                                                                                                                                                            • unittest: https://docs.python.org/3/library/unittest.html.

                                                                                                                                                                                                                                                            • pytest: https://docs.pytest.org/en/6.2.x/.

                                                                                                                                                                                                                                                            • [22:42] ZODB https://zodb.org/en/latest/.

                                                                                                                                                                                                                                                            • [23:20] Jesús Cea se plantea mantener Durus

                                                                                                                                                                                                                                                              https://www.mems-exchange.org/software/DurusWorks/ por su
                                                                                                                                                                                                                                                              cuenta.

                                                                                                                                                                                                                                                              • Problemas con la licencia.

                                                                                                                                                                                                                                                              • Imposible ponerse en contacto con sus autores originales.

                                                                                                                                                                                                                                                              • ¿Hacer un fork hostil?

                                                                                                                                                                                                                                                                https://es.wikipedia.org/wiki/Bifurcaci%C3%B3n_(desarrollo_de_software).

                                                                                                                                                                                                                                                              • [25:57] Problemas para conectar la persistencia tradicional con

                                                                                                                                                                                                                                                                el nuevo paradigma asíncrono.

                                                                                                                                                                                                                                                              • [26:57] La persistencia tiene un sistema de almacenamiento

                                                                                                                                                                                                                                                                concreto configurable:

                                                                                                                                                                                                                                                                • Por defecto, almacenamiento "cutre" en un fichero.

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

                                                                                                                                                                                                                                                                • Jesús Cea: Berkeley DB Backend Storage Engine for DURUS:

                                                                                                                                                                                                                                                                  https://www.jcea.es/programacion/durus-berkeleydbstorage.htm.

                                                                                                                                                                                                                                                                  • Berkeley DB:

                                                                                                                                                                                                                                                                    https://es.wikipedia.org/wiki/Berkeley_DB.

                                                                                                                                                                                                                                                                    • Durabilidad regulable.

                                                                                                                                                                                                                                                                    • Group Committing.

                                                                                                                                                                                                                                                                    • [29:52] Más de lo que nunca quisiste saber sobre Group Committing.

                                                                                                                                                                                                                                                                    • [32:52] Persistencia y Durus.

                                                                                                                                                                                                                                                                      • Jesús Cea: Berkeley DB Backend Storage Engine for DURUS:

                                                                                                                                                                                                                                                                        https://www.jcea.es/programacion/durus-berkeleydbstorage.htm.

                                                                                                                                                                                                                                                                        • Tal vez portarlo a ZODB https://zodb.org/en/latest/.
                                                                                                                                                                                                                                                                        • [34:52] Persistencia y versionado de objetos.

                                                                                                                                                                                                                                                                          • Versionado objeto por objeto. Se actualiza al ir cargando

                                                                                                                                                                                                                                                                            objetos durante el funcionamiento normal.

                                                                                                                                                                                                                                                                          • Versión de la base de datos. Migración de todos los objetos

                                                                                                                                                                                                                                                                            al arrancar el programa.

                                                                                                                                                                                                                                                                            • Rompe el encapsulamiento de objetos.
                                                                                                                                                                                                                                                                            • La migración es algo que no se explica nunca lo suficiente

                                                                                                                                                                                                                                                                              en la documentación.

                                                                                                                                                                                                                                                                            • [47:52] La mayoría de los tutoriales son demasiado simples.

                                                                                                                                                                                                                                                                              • Tutorial de Python en español:

                                                                                                                                                                                                                                                                                https://docs.python.org/es/3/tutorial/index.html.

                                                                                                                                                                                                                                                                              • Tutoriales progresivos.

                                                                                                                                                                                                                                                                              • La mayoría de las charlas son "introducción a ...". No

                                                                                                                                                                                                                                                                                aportan mucho.

                                                                                                                                                                                                                                                                                • Las mejores charlas son los postmortem.

                                                                                                                                                                                                                                                                                • Pegas, pero desde un punto de vista constructivo y

                                                                                                                                                                                                                                                                                  realista.

                                                                                                                                                                                                                                                                                • Es más interesante conocer los puntos débiles.

                                                                                                                                                                                                                                                                                • [51:57] Un motivo para no tener temáticas cerradas en las

                                                                                                                                                                                                                                                                                  tertulias es que es difícil que los intereses de dos expertos se
                                                                                                                                                                                                                                                                                  solapen.

                                                                                                                                                                                                                                                                                • [55:42] El tema legal habitual sobre grabar los audios de las

                                                                                                                                                                                                                                                                                  tertulias.

                                                                                                                                                                                                                                                                                • [57:37] Python Madrid.

                                                                                                                                                                                                                                                                                  • Kaleidos: https://kaleidos.net/.

                                                                                                                                                                                                                                                                                  • Meetup Python Madrid:

                                                                                                                                                                                                                                                                                    https://www.meetup.com/python-madrid/.

                                                                                                                                                                                                                                                                                  • Nostalgia de los "buenos tiempos".

                                                                                                                                                                                                                                                                                  • Networking entre personas.

                                                                                                                                                                                                                                                                                  • [01:09:52] super()

                                                                                                                                                                                                                                                                                    https://docs.python.org/3/library/functions.html#super.

                                                                                                                                                                                                                                                                                  • [01:11:17] Operador Morsa.

                                                                                                                                                                                                                                                                                    • PEP 572: https://www.python.org/dev/peps/pep-0572/.

                                                                                                                                                                                                                                                                                    • Tema recurrente.

                                                                                                                                                                                                                                                                                    • [01:13:42] La sintaxis de Python cada vez se complica más.

                                                                                                                                                                                                                                                                                    • [01:15:57] Guido van Rossum sigue muy activo como "core

                                                                                                                                                                                                                                                                                      developer": https://es.wikipedia.org/wiki/Guido_van_Rossum.

                                                                                                                                                                                                                                                                                    • [01:16:22] Funciones lambda.

                                                                                                                                                                                                                                                                                      • Closures: https://es.wikipedia.org/wiki/Clausura_(inform%C3%A1tica).
                                                                                                                                                                                                                                                                                      • [01:21:12] Función universal que se comporta de forma diferente

                                                                                                                                                                                                                                                                                        dependiendo de si se llama de forma síncrona o asíncrona.

                                                                                                                                                                                                                                                                                        • What Color is Your Function?

                                                                                                                                                                                                                                                                                          https://journal.stuffwithstuff.com/2015/02/01/what-color-is-your-function/.

                                                                                                                                                                                                                                                                                        • Go: https://golang.org/.

                                                                                                                                                                                                                                                                                        • Corrutina: https://es.wikipedia.org/wiki/Corrutina.

                                                                                                                                                                                                                                                                                        • CSP:

                                                                                                                                                                                                                                                                                          https://en.wikipedia.org/wiki/Communicating_sequential_processes.

                                                                                                                                                                                                                                                                                        • La implementación actual en Python no es transparente,

                                                                                                                                                                                                                                                                                          "colorea" todo el programa.

                                                                                                                                                                                                                                                                                        • [01:30:17] Stackless Python:

                                                                                                                                                                                                                                                                                          https://en.wikipedia.org/wiki/Stackless_Python.

                                                                                                                                                                                                                                                                                          • Documentación:

                                                                                                                                                                                                                                                                                            https://github.com/stackless-dev/stackless/wiki.

                                                                                                                                                                                                                                                                                          • ¿Por qué no se integró en CPython? Portabilidad.

                                                                                                                                                                                                                                                                                          • [01:37:07] Licencia del logotipo de Python.

                                                                                                                                                                                                                                                                                            • Logotipo de Python Madrid: https://www.python-madrid.es/.

                                                                                                                                                                                                                                                                                            • Condiciones de uso del logo de Python:

                                                                                                                                                                                                                                                                                              https://www.python.org/community/logos/.

                                                                                                                                                                                                                                                                                            • [01:40:44] Repesca de temas de tertulias anteriores:

                                                                                                                                                                                                                                                                                              • "Closures".

                                                                                                                                                                                                                                                                                              • Respuestas "de nivel" en las listas de correo cuando la

                                                                                                                                                                                                                                                                                                pregunta es interesante.

                                                                                                                                                                                                                                                                                              • Versionado de diccionarios.

                                                                                                                                                                                                                                                                                              • Cacheo de "lookups" en la implementación actual de Python.

                                                                                                                                                                                                                                                                                              • [01:46:12] Nuestra relación con PEP 8

                                                                                                                                                                                                                                                                                                https://www.python.org/dev/peps/pep-0008/.

                                                                                                                                                                                                                                                                                                • Jesús Cea: Problemas por ser un dinosaurio y por programar
                                                                                                                                                                                                                                                                                                • en varios lenguajes diferentes.
                                                                                                                                                                                                                                                                                                • [01:47:12] Jesús Cea y código abierto:

                                                                                                                                                                                                                                                                                                  • Mercurial de Jesús Cea: http://hg.jcea.es/.

                                                                                                                                                                                                                                                                                                  • https://blog.jcea.es.

                                                                                                                                                                                                                                                                                                  • El código publicado no es bueno. Personal. Hago lo mínimo

                                                                                                                                                                                                                                                                                                    para que funcione.

                                                                                                                                                                                                                                                                                                  • No hay test, por practicidad.

                                                                                                                                                                                                                                                                                                  • El código pagado no se puede enseñar.

                                                                                                                                                                                                                                                                                                  • Solo puede enseñar código el que tiene tiempo para programar

                                                                                                                                                                                                                                                                                                    código abierto, por ejemplo, gente joven sin cargas
                                                                                                                                                                                                                                                                                                    familiares.

                                                                                                                                                                                                                                                                                                  • Ideas interesantes, código regulero.

                                                                                                                                                                                                                                                                                                  • [01:52:02] Equilibrio entre practicidad y perfección.

                                                                                                                                                                                                                                                                                                    • Tener claros los "puntos de dolor".

                                                                                                                                                                                                                                                                                                    • Hacer lo mínimo imprescindible.

                                                                                                                                                                                                                                                                                                    • Máquinas limitadas como la Raspberry PI:

                                                                                                                                                                                                                                                                                                      https://es.wikipedia.org/wiki/Raspberry_Pi.

                                                                                                                                                                                                                                                                                                    • Recibir notificaciones de cambios en el disco duro:

                                                                                                                                                                                                                                                                                                      Watchman: https://github.com/facebook/watchman.

                                                                                                                                                                                                                                                                                                    • Entrega de valor constante e incremental.

                                                                                                                                                                                                                                                                                                    • [01:57:32] Los clientes son muy vagos y no quieren hacer los

                                                                                                                                                                                                                                                                                                      deberes.

                                                                                                                                                                                                                                                                                                      • Metodologías ágiles.

                                                                                                                                                                                                                                                                                                      • El cliente nunca tiene tiempo para probar las entregas.

                                                                                                                                                                                                                                                                                                      • [02:01:32] Compartir archivos en la tertulia, para cositas

                                                                                                                                                                                                                                                                                                        pequeñas. Algo pendiente para el futuro.

                                                                                                                                                                                                                                                                                                      • [02:03:32] El valor de leerse la documentación de Python como si

                                                                                                                                                                                                                                                                                                        fuera un libro, de principio a fin.

                                                                                                                                                                                                                                                                                                        • Aparte de aprender en profundidad, el valor de colaborar
                                                                                                                                                                                                                                                                                                        • puliendo la documentación.
                                                                                                                                                                                                                                                                                                        • [02:05:42] Cambio de licencia de Python 1.x a Python 2.x.

                                                                                                                                                                                                                                                                                                          • Python 2.0 License:
                                                                                                                                                                                                                                                                                                          • https://www.python.org/download/releases/2.0/license/.
                                                                                                                                                                                                                                                                                                          • [02:06:37] Estudiar el código fuente de las propias librerías de

                                                                                                                                                                                                                                                                                                            Python.

                                                                                                                                                                                                                                                                                                          • [02:07:02] El bug 35930 sigue coleando. Estado de la cuestión.

                                                                                                                                                                                                                                                                                                            • Issue35930: Raising an exception raised in a "future"

                                                                                                                                                                                                                                                                                                              instance will create reference cycles
                                                                                                                                                                                                                                                                                                              https://bugs.python.org/issue35930.

                                                                                                                                                                                                                                                                                                            • Temas de estilo.

                                                                                                                                                                                                                                                                                                            • [02:11:27] Despedida.

                                                                                                                                                                                                                                                                                                            • [02:13:10] Los riesgos de caerse con nieve en polvo.

                                                                                                                                                                                                                                                                                                            • [02:14:29] Final.

                                                                                                                                                                                                                                                                                                              2 hr 16 min
                                                                                                                                                                                                                                                                                                            • Python en español #14: Tertulia 2021-01-05
                                                                                                                                                                                                                                                                                                              Detalles internos de rendimiento de Python y exabruptos sobre asyncio https://podcast.jcea.es/python/14

                                                                                                                                                                                                                                                                                                              Participantes:

                                                                                                                                                                                                                                                                                                              • Jesús Cea, email: [email protected], twitter:

                                                                                                                                                                                                                                                                                                                @jcea, https://blog.jcea.es/,
                                                                                                                                                                                                                                                                                                                https://www.jcea.es/. Conectando desde Madrid.

                                                                                                                                                                                                                                                                                                              • Eduardo Castro, email:

                                                                                                                                                                                                                                                                                                                [email protected]. Conectando desde A
                                                                                                                                                                                                                                                                                                                Guarda.

                                                                                                                                                                                                                                                                                                              • Javier, conectando desde Madrid.

                                                                                                                                                                                                                                                                                                              • Víctor Ramírez, twitter: @virako,

                                                                                                                                                                                                                                                                                                                programador python y amante de vim, conectando desde Huelva.

                                                                                                                                                                                                                                                                                                              • Juan Carlos, conectando desde Bilbao.

                                                                                                                                                                                                                                                                                                                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.

                                                                                                                                                                                                                                                                                                                • [01:32] Nuevas versiones: Python 3.10a4 y Numpy.

                                                                                                                                                                                                                                                                                                                • [01:57] Don’t Use Recursion In Python Any More,Python Closure —

                                                                                                                                                                                                                                                                                                                  A Pythonic technique you must know

                                                                                                                                                                                                                                                                                                                  • Don’t Use Recursion In Python Any More,Python Closure — A

                                                                                                                                                                                                                                                                                                                    Pythonic technique you must know:
                                                                                                                                                                                                                                                                                                                    https://towardsdatascience.com/dont-use-recursion-in-python-any-more-918aad95094c.

                                                                                                                                                                                                                                                                                                                  • Hilo en la lista de correo de Python Madrid:

                                                                                                                                                                                                                                                                                                                    https://lists.es.python.org/pipermail/madrid/2021-January/004838.html.

                                                                                                                                                                                                                                                                                                                  • Closure:

                                                                                                                                                                                                                                                                                                                    https://es.wikipedia.org/wiki/Clausura_(inform%C3%A1tica).

                                                                                                                                                                                                                                                                                                                  • Mixin: https://es.wikipedia.org/wiki/Mixin.

                                                                                                                                                                                                                                                                                                                  • [10:02] ¿Qué es ser "Pythónico"?

                                                                                                                                                                                                                                                                                                                    • Twisted daña el cerebro: https://twistedmatrix.com/trac/.

                                                                                                                                                                                                                                                                                                                    • unittest: https://docs.python.org/3/library/unittest.html.

                                                                                                                                                                                                                                                                                                                    • Black: https://pypi.org/project/black/.

                                                                                                                                                                                                                                                                                                                    • from __future__ import braces.

                                                                                                                                                                                                                                                                                                                    • [14:52] Python Ideas:

                                                                                                                                                                                                                                                                                                                      • https://mail.python.org/mailman3/lists/python-ideas.python.org/.
                                                                                                                                                                                                                                                                                                                      • [16:52] ¿Comillas simples o comillas dobles? ' o ".

                                                                                                                                                                                                                                                                                                                        • Diferencias semánticas con otros lenguajes como C.
                                                                                                                                                                                                                                                                                                                        • [23:07] Tamaño de columnas: ¿80?, ¿120?, ¿132?

                                                                                                                                                                                                                                                                                                                        • [31:02] Primar la legibilidad, no el rendimiento.

                                                                                                                                                                                                                                                                                                                          • Cuando tienes if ... else ..., ¿Qué caso pones primero?,

                                                                                                                                                                                                                                                                                                                            ¿el corto o el largo? ¿Primero la condición normal?

                                                                                                                                                                                                                                                                                                                          • Microoptimizaciones que complican la legibilidad sin

                                                                                                                                                                                                                                                                                                                            ganancia de rendimiento que importe en realidad.

                                                                                                                                                                                                                                                                                                                          • [41:57] En las variables locales, la longitud del nombre de una

                                                                                                                                                                                                                                                                                                                            variable no impacta en el rendimiento.

                                                                                                                                                                                                                                                                                                                          • [43:02] Curiosear el "bytecode"

                                                                                                                                                                                                                                                                                                                            https://es.wikipedia.org/wiki/Bytecode que genera Python.

                                                                                                                                                                                                                                                                                                                            • Dispositivo de Duff:

                                                                                                                                                                                                                                                                                                                              https://es.wikipedia.org/wiki/Dispositivo_de_Duff.

                                                                                                                                                                                                                                                                                                                            • El "bytecode" https://es.wikipedia.org/wiki/Bytecode que

                                                                                                                                                                                                                                                                                                                              genera Python no está nada optimizado. Es mejorable.

                                                                                                                                                                                                                                                                                                                            • [46:22] Bytecode generado para a + a:

                                                                                                                                                                                                                                                                                                                              >>> dis.dis(lambda a: a + a)
                                                                                                                                                                                                                                                                                                                              1 0 LOAD_FAST 0 (a)
                                                                                                                                                                                                                                                                                                                              2 LOAD_FAST 0 (a)
                                                                                                                                                                                                                                                                                                                              4 BINARY_ADD
                                                                                                                                                                                                                                                                                                                              6 RETURN_VALUE
                                                                                                                                                                                                                                                                                                                              • ¡Guardas!

                                                                                                                                                                                                                                                                                                                              • Sí se hacen algunas optimizaciones simples:

                                                                                                                                                                                                                                                                                                                                >>> dis.dis(lambda : 5 + 3)
                                                                                                                                                                                                                                                                                                                                1 0 LOAD_CONST 1 (8)
                                                                                                                                                                                                                                                                                                                                2 RETURN_VALUE
                                                                                                                                                                                                                                                                                                                              • [50:12] Python deja su pila de evaluación vacía al terminar de

                                                                                                                                                                                                                                                                                                                                calcular una expresión.

                                                                                                                                                                                                                                                                                                                                • Máquina virtual de registros en vez de máquina virtual

                                                                                                                                                                                                                                                                                                                                  orientada a pila.

                                                                                                                                                                                                                                                                                                                                  • El compilador debe ser más sofisticado, pero puede
                                                                                                                                                                                                                                                                                                                                  • reutilizar valores.
                                                                                                                                                                                                                                                                                                                                  • Muchas operaciones redundantes:

                                                                                                                                                                                                                                                                                                                                    >>> import dis
                                                                                                                                                                                                                                                                                                                                    >>> def suma(valores):
                                                                                                                                                                                                                                                                                                                                    ... s=0
                                                                                                                                                                                                                                                                                                                                    ... for i in valores:
                                                                                                                                                                                                                                                                                                                                    ... s+=i
                                                                                                                                                                                                                                                                                                                                    ... return s
                                                                                                                                                                                                                                                                                                                                    ...
                                                                                                                                                                                                                                                                                                                                    >>> dis.dis(suma)
                                                                                                                                                                                                                                                                                                                                    2 0 LOAD_CONST 1 (0)
                                                                                                                                                                                                                                                                                                                                    2 STORE_FAST 1 (s)
                                                                                                                                                                                                                                                                                                                                    3 4 LOAD_FAST 0 (valores)
                                                                                                                                                                                                                                                                                                                                    6 GET_ITER
                                                                                                                                                                                                                                                                                                                                    >> 8 FOR_ITER 12 (to 22)
                                                                                                                                                                                                                                                                                                                                    10 STORE_FAST 2 (i)
                                                                                                                                                                                                                                                                                                                                    4 12 LOAD_FAST 1 (s)
                                                                                                                                                                                                                                                                                                                                    14 LOAD_FAST 2 (i)
                                                                                                                                                                                                                                                                                                                                    16 INPLACE_ADD
                                                                                                                                                                                                                                                                                                                                    18 STORE_FAST 1 (s)
                                                                                                                                                                                                                                                                                                                                    20 JUMP_ABSOLUTE 8
                                                                                                                                                                                                                                                                                                                                    5 >> 22 LOAD_FAST 1 (s)
                                                                                                                                                                                                                                                                                                                                    24 RETURN_VALUE
                                                                                                                                                                                                                                                                                                                                  • ¿Qué ocurre a la hora de depurar o para gestionar

                                                                                                                                                                                                                                                                                                                                    excepciones?

                                                                                                                                                                                                                                                                                                                                  • [56:32] Que un hilo modifique variables de otro hilo.

                                                                                                                                                                                                                                                                                                                                    • ¡Guardas!

                                                                                                                                                                                                                                                                                                                                    • NOTA DESDE EL FUTURO:

                                                                                                                                                                                                                                                                                                                                      • Python 3.9.5:

                                                                                                                                                                                                                                                                                                                                        https://docs.python.org/release/3.9.5/whatsnew/changelog.html.

                                                                                                                                                                                                                                                                                                                                      • Traceback objects allow accessing frame objects without

                                                                                                                                                                                                                                                                                                                                        triggering audit hooks:
                                                                                                                                                                                                                                                                                                                                        https://bugs.python.org/issue42800.

                                                                                                                                                                                                                                                                                                                                      • [58:37] Pensábais que las interioridades del intérprete de

                                                                                                                                                                                                                                                                                                                                        Python son aburridas, pero no...

                                                                                                                                                                                                                                                                                                                                        • La complejidad debe estar en tu programa, no en el lenguaje

                                                                                                                                                                                                                                                                                                                                          o el intérprete.

                                                                                                                                                                                                                                                                                                                                        • Compiladores optimizadores. Python se está quedando atrás.

                                                                                                                                                                                                                                                                                                                                        • Hacer caché al buscar atributos:

                                                                                                                                                                                                                                                                                                                                          • Issue1616125: Cached globals+builtins lookup optimization:

                                                                                                                                                                                                                                                                                                                                            https://bugs.python.org/issue1616125.

                                                                                                                                                                                                                                                                                                                                          • issue43452: Microoptimize PyType_Lookup for cache hits

                                                                                                                                                                                                                                                                                                                                            https://bugs.python.org/issue43452.

                                                                                                                                                                                                                                                                                                                                          • Detectar cambios en un diccionario, incluyendo

                                                                                                                                                                                                                                                                                                                                            diccionarios internos como locals o __builtins__:
                                                                                                                                                                                                                                                                                                                                            PEP 509 Add a private version to dict:
                                                                                                                                                                                                                                                                                                                                            https://www.python.org/dev/peps/pep-0509/.

                                                                                                                                                                                                                                                                                                                                          • [01:06:52] Huevos de pascua en Python:

                                                                                                                                                                                                                                                                                                                                            • from __future__ import braces.

                                                                                                                                                                                                                                                                                                                                            • import antigravity.

                                                                                                                                                                                                                                                                                                                                            • import this.

                                                                                                                                                                                                                                                                                                                                            • import __hello__.

                                                                                                                                                                                                                                                                                                                                            • [01:08:27] Usar pass o ... (ellipsis).

                                                                                                                                                                                                                                                                                                                                              • Ellipsis:
                                                                                                                                                                                                                                                                                                                                              • https://docs.python.org/3/library/constants.html#Ellipsis
                                                                                                                                                                                                                                                                                                                                                y
                                                                                                                                                                                                                                                                                                                                                https://docs.python.org/3/library/stdtypes.html?highlight=ellipsis#the-ellipsis-object.
                                                                                                                                                                                                                                                                                                                                              • [01:09:22] El PEP 509 no es para hacer diccionarios inmutables.

                                                                                                                                                                                                                                                                                                                                                • Es algo interno para el API de C. No está accesible desde

                                                                                                                                                                                                                                                                                                                                                  Python.

                                                                                                                                                                                                                                                                                                                                                • Cambios pequeños pueden abrir posibilidades interesantes.

                                                                                                                                                                                                                                                                                                                                                  ¡Guardas!.

                                                                                                                                                                                                                                                                                                                                                • [01:13:07] Curiosidades encontradas esta semana:

                                                                                                                                                                                                                                                                                                                                                  • traceback.clear_frames(tb):

                                                                                                                                                                                                                                                                                                                                                    https://docs.python.org/3/library/traceback.html#traceback.clear_frames.

                                                                                                                                                                                                                                                                                                                                                  • inspect: https://docs.python.org/3/library/inspect.html.

                                                                                                                                                                                                                                                                                                                                                  • Manipular frame.back.

                                                                                                                                                                                                                                                                                                                                                  • Que una función sepa si se le está llamando de una forma

                                                                                                                                                                                                                                                                                                                                                    síncrona o asíncrona.

                                                                                                                                                                                                                                                                                                                                                  • [01:17:02] Los problemas filosóficos que tiene Jesús Cea con

                                                                                                                                                                                                                                                                                                                                                    la programación asíncrona tal y como está implementada en Python.

                                                                                                                                                                                                                                                                                                                                                    • Una biblioteca debe decidir si es síncrona o asíncrona y

                                                                                                                                                                                                                                                                                                                                                      "contamina" todo tu código.

                                                                                                                                                                                                                                                                                                                                                    • Hacer corrutinas "de verdad":

                                                                                                                                                                                                                                                                                                                                                      https://es.wikipedia.org/wiki/Corrutina.

                                                                                                                                                                                                                                                                                                                                                    • Persistencia y programación asíncrona.

                                                                                                                                                                                                                                                                                                                                                    • Concepto de "awaitable":

                                                                                                                                                                                                                                                                                                                                                      https://docs.python.org/3/library/asyncio-task.html#awaitables.

                                                                                                                                                                                                                                                                                                                                                    • future.result():

                                                                                                                                                                                                                                                                                                                                                      https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.Future.result.

                                                                                                                                                                                                                                                                                                                                                    • [01:32:17] Es difícil plantear temas tan esotéricos sin una

                                                                                                                                                                                                                                                                                                                                                      preparación formal de la charla o sin avisar con tiempo para
                                                                                                                                                                                                                                                                                                                                                      que la gente se lo pueda ver con calma antes.

                                                                                                                                                                                                                                                                                                                                                    • [01:33:32] Problemas con el control de carga de asyncio

                                                                                                                                                                                                                                                                                                                                                      https://docs.python.org/3/library/asyncio.html.

                                                                                                                                                                                                                                                                                                                                                      • Vuelve a tratarse el tema de si la biblioteca estándar debe

                                                                                                                                                                                                                                                                                                                                                        crecer o adelgazar.

                                                                                                                                                                                                                                                                                                                                                      • Según Jesús Cea, asyncio

                                                                                                                                                                                                                                                                                                                                                        https://docs.python.org/3/library/asyncio.html es la peor
                                                                                                                                                                                                                                                                                                                                                        opción.

                                                                                                                                                                                                                                                                                                                                                      • Alternativas a asyncio:

                                                                                                                                                                                                                                                                                                                                                        • Curio: https://curio.readthedocs.io/en/latest/.

                                                                                                                                                                                                                                                                                                                                                        • Trio: https://trio.readthedocs.io/en/stable/.

                                                                                                                                                                                                                                                                                                                                                          Monkey patching:
                                                                                                                                                                                                                                                                                                                                                          https://en.wikipedia.org/wiki/Monkey_patch.

                                                                                                                                                                                                                                                                                                                                                        • La dificultad de luchar con una biblioteca que está incluída

                                                                                                                                                                                                                                                                                                                                                          en la biblioteca estándar.

                                                                                                                                                                                                                                                                                                                                                        • [01:42:32] La programación asíncrona es útil para muchas más

                                                                                                                                                                                                                                                                                                                                                          cosas además de para gestionar peticiones de la red.

                                                                                                                                                                                                                                                                                                                                                          • Por ejemplo, operaciones de ficheros locales. Aprovechar
                                                                                                                                                                                                                                                                                                                                                          • tanto que el disco sea lento como para lanzar operaciones
                                                                                                                                                                                                                                                                                                                                                            concurrentes a discos duros.
                                                                                                                                                                                                                                                                                                                                                          • [01:44:12] Mejor usar concurrent.futures

                                                                                                                                                                                                                                                                                                                                                            https://docs.python.org/3/library/concurrent.futures.html que
                                                                                                                                                                                                                                                                                                                                                            threading https://docs.python.org/3/library/threading.html
                                                                                                                                                                                                                                                                                                                                                            directamente.

                                                                                                                                                                                                                                                                                                                                                            • Transportar excepciones entre hilos.

                                                                                                                                                                                                                                                                                                                                                            • Control de carga y paralelismo.

                                                                                                                                                                                                                                                                                                                                                            • [01:45:42] Referencia al bug solucionado en la tertulia

                                                                                                                                                                                                                                                                                                                                                              anterior: Issue35930: Raising an exception raised in a "future"
                                                                                                                                                                                                                                                                                                                                                              instance will create reference cycles
                                                                                                                                                                                                                                                                                                                                                              https://bugs.python.org/issue35930.

                                                                                                                                                                                                                                                                                                                                                              • Queda por ultimar el detalle de cómo solucionar el problema

                                                                                                                                                                                                                                                                                                                                                                exactamente y enviar el parche para que se integre
                                                                                                                                                                                                                                                                                                                                                                oficialmente en Python.

                                                                                                                                                                                                                                                                                                                                                              • Jesús Cea describe las dos opciones que está barajando:

                                                                                                                                                                                                                                                                                                                                                                weakrefs https://docs.python.org/3/library/weakref.html o
                                                                                                                                                                                                                                                                                                                                                                try ... finally.

                                                                                                                                                                                                                                                                                                                                                              • [01:50:57] Ya hubo "flames" brutales con Guido cuando se

                                                                                                                                                                                                                                                                                                                                                                introdujo el operador ternario en Python.

                                                                                                                                                                                                                                                                                                                                                              • [01:55:02] Despedida.

                                                                                                                                                                                                                                                                                                                                                              • [01:55:50] Final.

                                                                                                                                                                                                                                                                                                                                                                1 hr 57 min
                                                                                                                                                                                                                                                                                                                                                              • Python en español #13: Tertulia 2020-12-29
                                                                                                                                                                                                                                                                                                                                                                Resolución de Issue35930: Raising an exception raised in a "future" instance will create reference cycles https://podcast.jcea.es/python/13

                                                                                                                                                                                                                                                                                                                                                                Participantes:

                                                                                                                                                                                                                                                                                                                                                                • Jesús Cea, email: [email protected], twitter:

                                                                                                                                                                                                                                                                                                                                                                  @jcea, https://blog.jcea.es/,
                                                                                                                                                                                                                                                                                                                                                                  https://www.jcea.es/. 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.

                                                                                                                                                                                                                                                                                                                                                                • Juan Carlos.

                                                                                                                                                                                                                                                                                                                                                                • Plutarco, conectando desde Madrid.

                                                                                                                                                                                                                                                                                                                                                                • Eduardo Castro, email:

                                                                                                                                                                                                                                                                                                                                                                  [email protected]. Conectando desde A
                                                                                                                                                                                                                                                                                                                                                                  Guarda.

                                                                                                                                                                                                                                                                                                                                                                • Julio, conectando desde Chile.

                                                                                                                                                                                                                                                                                                                                                                  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] Presentaciones.

                                                                                                                                                                                                                                                                                                                                                                  • [03:24] Aviso legal de que se está grabando y objetivos de la

                                                                                                                                                                                                                                                                                                                                                                    tertulia.

                                                                                                                                                                                                                                                                                                                                                                  • [06:22] Autoimport, ¿debería ser una funcionalidad del IDE?

                                                                                                                                                                                                                                                                                                                                                                    • PyCharm: https://www.jetbrains.com/pycharm/.
                                                                                                                                                                                                                                                                                                                                                                    • [12:52] Los IDEs y las inercias.

                                                                                                                                                                                                                                                                                                                                                                      • PyCharm: https://www.jetbrains.com/pycharm/.

                                                                                                                                                                                                                                                                                                                                                                      • Atajos de teclado.

                                                                                                                                                                                                                                                                                                                                                                      • vim: https://es.wikipedia.org/wiki/Vim.

                                                                                                                                                                                                                                                                                                                                                                        • Ubicuo y poder editar ficheros de forma remota.
                                                                                                                                                                                                                                                                                                                                                                        • Uso del teclado en vez del ratón.

                                                                                                                                                                                                                                                                                                                                                                        • Emacs: https://es.wikipedia.org/wiki/Emacs.

                                                                                                                                                                                                                                                                                                                                                                        • [19:22] Operador morsa (walrus). Sigue usándose muy poco.

                                                                                                                                                                                                                                                                                                                                                                          • Python va complicando la sintaxis más y más.

                                                                                                                                                                                                                                                                                                                                                                          • Se habló en una tertulia anterior.

                                                                                                                                                                                                                                                                                                                                                                          • Jesús solo ha encontrado este caso útil:

                                                                                                                                                                                                                                                                                                                                                                            • Pasar de:

                                                                                                                                                                                                                                                                                                                                                                              buf = f.read(1000)
                                                                                                                                                                                                                                                                                                                                                                              while buf:
                                                                                                                                                                                                                                                                                                                                                                              [Hace el procesamiento]
                                                                                                                                                                                                                                                                                                                                                                              buf = f.read(1000)
                                                                                                                                                                                                                                                                                                                                                                            • A lo siguiente:

                                                                                                                                                                                                                                                                                                                                                                              while buf := f.read(1000):
                                                                                                                                                                                                                                                                                                                                                                              [Hace el procesamiento]
                                                                                                                                                                                                                                                                                                                                                                            • [25:57] Erratas en tertulias anteriores:

                                                                                                                                                                                                                                                                                                                                                                              • Migración de Python a Github fue en 2017.

                                                                                                                                                                                                                                                                                                                                                                              • No es "Steering committee" sino "Steering Council".

                                                                                                                                                                                                                                                                                                                                                                              • [27:02] Pablo Galindo forma parte del "council" tras las

                                                                                                                                                                                                                                                                                                                                                                                últimas elecciones.

                                                                                                                                                                                                                                                                                                                                                                                Charla de Pablo Galindo en la PyconES 2019 sobre el mundo

                                                                                                                                                                                                                                                                                                                                                                                de los Core Developers de Python:
                                                                                                                                                                                                                                                                                                                                                                                https://www.youtube.com/watch?v=qcvZOaY1emk.

                                                                                                                                                                                                                                                                                                                                                                              • Algunos proyectos Python están usando Rust. Por ejemplo:

                                                                                                                                                                                                                                                                                                                                                                                https://cryptography.io/, con cierta polémica. Mercurial
                                                                                                                                                                                                                                                                                                                                                                                también usa Rust https://www.mercurial-scm.org/.

                                                                                                                                                                                                                                                                                                                                                                              • Las variables locales pueden ser modificadas a través de su

                                                                                                                                                                                                                                                                                                                                                                                "closure", en funciones hijas o en otros hilos. Es una
                                                                                                                                                                                                                                                                                                                                                                                barbaridad, pero la posibilidad existe.

                                                                                                                                                                                                                                                                                                                                                                                Esto es lo que hace, por ejemplo, un debugger.

                                                                                                                                                                                                                                                                                                                                                                              • [35:37] ¡Spoiler sobre la resolución del "Memory Leak"!

                                                                                                                                                                                                                                                                                                                                                                                • Issue35930: Raising an exception raised in a "future"

                                                                                                                                                                                                                                                                                                                                                                                  instance will create reference cycles
                                                                                                                                                                                                                                                                                                                                                                                  https://bugs.python.org/issue35930.

                                                                                                                                                                                                                                                                                                                                                                                • Traceback:

                                                                                                                                                                                                                                                                                                                                                                                  https://docs.python.org/3/library/traceback.html

                                                                                                                                                                                                                                                                                                                                                                                • Frame:

                                                                                                                                                                                                                                                                                                                                                                                  https://docs.python.org/3/library/traceback.html#traceback.FrameSummary.

                                                                                                                                                                                                                                                                                                                                                                                • Stack:

                                                                                                                                                                                                                                                                                                                                                                                  https://docs.python.org/3/library/traceback.html#stacksummary-objects.

                                                                                                                                                                                                                                                                                                                                                                                • [39:17] Usar una técnica similar para detectar las

                                                                                                                                                                                                                                                                                                                                                                                  características de quien te llama para poder mezclar de forma
                                                                                                                                                                                                                                                                                                                                                                                  más limpia código síncrono y asíncrono.

                                                                                                                                                                                                                                                                                                                                                                                  • Biblioteca Unsync: https://pypi.org/project/unsync/.
                                                                                                                                                                                                                                                                                                                                                                                  • [41:32] Sigo explicando detalles de la solución del "Memory

                                                                                                                                                                                                                                                                                                                                                                                    Leak".

                                                                                                                                                                                                                                                                                                                                                                                    • Issue35930: Raising an exception raised in a "future"

                                                                                                                                                                                                                                                                                                                                                                                      instance will create reference cycles
                                                                                                                                                                                                                                                                                                                                                                                      https://bugs.python.org/issue35930.

                                                                                                                                                                                                                                                                                                                                                                                    • Estamos continuando una conversación que ha durado varias

                                                                                                                                                                                                                                                                                                                                                                                      tertulias.

                                                                                                                                                                                                                                                                                                                                                                                    • Jesús Cea pone un ejemplo de cómo generar un ciclo con una

                                                                                                                                                                                                                                                                                                                                                                                      excepcion.

                                                                                                                                                                                                                                                                                                                                                                                    • La caja y media de cervezas se las lleva... ¡Jesús!

                                                                                                                                                                                                                                                                                                                                                                                    • [47:22] No se está conectando gente desde Hispanoamérica. ¿Por

                                                                                                                                                                                                                                                                                                                                                                                      qué?

                                                                                                                                                                                                                                                                                                                                                                                    • [50:07] Más erratas: Los "tracebacks" NO son inmutables.

                                                                                                                                                                                                                                                                                                                                                                                    • [50:32] Nuevo método "with_traceback()" a la hora de crear

                                                                                                                                                                                                                                                                                                                                                                                      excepciones:

                                                                                                                                                                                                                                                                                                                                                                                      • https://docs.python.org/3/library/exceptions.html#BaseException.with_traceback.

                                                                                                                                                                                                                                                                                                                                                                                        Puedes generar una excepción con un "traceback"

                                                                                                                                                                                                                                                                                                                                                                                        arbitrario.

                                                                                                                                                                                                                                                                                                                                                                                      • El caballo de batalla del bug es que el "future"

                                                                                                                                                                                                                                                                                                                                                                                        https://docs.python.org/3/library/concurrent.futures.html
                                                                                                                                                                                                                                                                                                                                                                                        levanta una excepción y esa excepción debe "transportarse" a
                                                                                                                                                                                                                                                                                                                                                                                        otro hilo.

                                                                                                                                                                                                                                                                                                                                                                                      • Explicando cómo se visualizan los "traceback" si un "future"

                                                                                                                                                                                                                                                                                                                                                                                        https://docs.python.org/3/library/concurrent.futures.html
                                                                                                                                                                                                                                                                                                                                                                                        muere con una excepción.

                                                                                                                                                                                                                                                                                                                                                                                        def a():
                                                                                                                                                                                                                                                                                                                                                                                        1/0
                                                                                                                                                                                                                                                                                                                                                                                        try:
                                                                                                                                                                                                                                                                                                                                                                                        a()
                                                                                                                                                                                                                                                                                                                                                                                        except Exception as e:
                                                                                                                                                                                                                                                                                                                                                                                        raise e
                                                                                                                                                                                                                                                                                                                                                                                        Traceback (most recent call last):
                                                                                                                                                                                                                                                                                                                                                                                        File "", line 4, in
                                                                                                                                                                                                                                                                                                                                                                                        File "", line 2, in
                                                                                                                                                                                                                                                                                                                                                                                        File "", line 2, in a
                                                                                                                                                                                                                                                                                                                                                                                        ZeroDivisionError: division by zero
                                                                                                                                                                                                                                                                                                                                                                                      • Cuando un "future"

                                                                                                                                                                                                                                                                                                                                                                                        https://docs.python.org/3/library/concurrent.futures.html
                                                                                                                                                                                                                                                                                                                                                                                        lanza una excepción, se ven "frames" repetidos.

                                                                                                                                                                                                                                                                                                                                                                                      • Hay varias formas de solucionar el bug. Ahora hay que pensar

                                                                                                                                                                                                                                                                                                                                                                                        en cual elegir, que sea la más simple e intuitiva.

                                                                                                                                                                                                                                                                                                                                                                                      • [01:01:52] Sobre el "nivel" de las tertulias y sus motivaciones.

                                                                                                                                                                                                                                                                                                                                                                                      • [01:06:12] Referencia rápida a temas de la tertulia anterior:

                                                                                                                                                                                                                                                                                                                                                                                        • Dataclasses:

                                                                                                                                                                                                                                                                                                                                                                                          https://docs.python.org/3/library/dataclasses.html. Se
                                                                                                                                                                                                                                                                                                                                                                                          hablo mucho sobre ellas en la tertulia de la semana pasada.

                                                                                                                                                                                                                                                                                                                                                                                        • Pydantic: https://pypi.org/project/pydantic/.

                                                                                                                                                                                                                                                                                                                                                                                        • FastAPI: https://pypi.org/project/fastapi/.

                                                                                                                                                                                                                                                                                                                                                                                        • [01:09:17] Diagnóstico exhaustivo del bug "Memory Leak", causa

                                                                                                                                                                                                                                                                                                                                                                                          raíz y propuestas de soluciones.

                                                                                                                                                                                                                                                                                                                                                                                          • Issue35930: Raising an exception raised in a "future"

                                                                                                                                                                                                                                                                                                                                                                                            instance will create reference cycles
                                                                                                                                                                                                                                                                                                                                                                                            https://bugs.python.org/issue35930.

                                                                                                                                                                                                                                                                                                                                                                                          • Exploración del propio código fuente de Python.

                                                                                                                                                                                                                                                                                                                                                                                          • Repaso detallado del funcionamiento de un "future"

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

                                                                                                                                                                                                                                                                                                                                                                                          • Uno de los problemas fundamentales de trabajar con hilos es

                                                                                                                                                                                                                                                                                                                                                                                            cómo notificar excepciones a otros hilos. La gran ventaja de
                                                                                                                                                                                                                                                                                                                                                                                            los "futures" es gestionar esto de forma trivial.

                                                                                                                                                                                                                                                                                                                                                                                          • Este "transporte" es lo que está ocasionando el "Memory

                                                                                                                                                                                                                                                                                                                                                                                            Leak".

                                                                                                                                                                                                                                                                                                                                                                                          • ¡Agárrate que vienen curvas!

                                                                                                                                                                                                                                                                                                                                                                                          • [01:21:32] Ojo a la línea self = None. Aquí se rompe el

                                                                                                                                                                                                                                                                                                                                                                                            ciclo en la excepción original:
                                                                                                                                                                                                                                                                                                                                                                                            https://github.com/python/cpython/blob/3.9/Lib/concurrent/futures/thread.py#L47.

                                                                                                                                                                                                                                                                                                                                                                                          • Closures:

                                                                                                                                                                                                                                                                                                                                                                                            https://es.wikipedia.org/wiki/Clausura_(inform%C3%A1tica).

                                                                                                                                                                                                                                                                                                                                                                                          • "Pool" de "workers". De forma estándar, Python te

                                                                                                                                                                                                                                                                                                                                                                                            proporciona dos ejecutores: el ejecutor de hilos y el
                                                                                                                                                                                                                                                                                                                                                                                            ejecutor de procesos
                                                                                                                                                                                                                                                                                                                                                                                            https://docs.python.org/3/library/concurrent.futures.html#executor-objects.

                                                                                                                                                                                                                                                                                                                                                                                          • [01:31:32] Las partes relevantes en el hilo principal son:

                                                                                                                                                                                                                                                                                                                                                                                            • https://github.com/python/cpython/blob/3.9/Lib/concurrent/futures/_base.py#L413.

                                                                                                                                                                                                                                                                                                                                                                                            • https://github.com/python/cpython/blob/2fe408497e6838b6fb761e42e8f8ffc70bd6f3b1/Lib/concurrent/futures/_base.py#L387.

                                                                                                                                                                                                                                                                                                                                                                                            • [01:37:02] ¡Brainstorming!

                                                                                                                                                                                                                                                                                                                                                                                            • [01:42:42] try ... finally

                                                                                                                                                                                                                                                                                                                                                                                              Jejeje, alguien propone algo que funcionaría :-).

                                                                                                                                                                                                                                                                                                                                                                                              • [01:43:57] Weakref:

                                                                                                                                                                                                                                                                                                                                                                                                https://docs.python.org/3/library/weakref.html. Hay
                                                                                                                                                                                                                                                                                                                                                                                                contertulios que no están familiarizados con el concepto,
                                                                                                                                                                                                                                                                                                                                                                                                Jesús Cea repasa qué son y para qué sirven las "Weakref".

                                                                                                                                                                                                                                                                                                                                                                                              • Se pueden "resucitar" objetos.

                                                                                                                                                                                                                                                                                                                                                                                              • [01:51:02] Volvemos al hilo, la corrección del bug.

                                                                                                                                                                                                                                                                                                                                                                                                • El gráfico de antes, con ciclos:

                                                                                                                                                                                                                                                                                                                                                                                                  https://lists.es.python.org/pipermail/general/attachments/20201229/0c14bc58/attachment-0002.png.

                                                                                                                                                                                                                                                                                                                                                                                                • El gráfico de después, sin ciclos:

                                                                                                                                                                                                                                                                                                                                                                                                  https://lists.es.python.org/pipermail/general/attachments/20201229/0c14bc58/attachment-0003.png.

                                                                                                                                                                                                                                                                                                                                                                                                • [01:55:12] Comprobar este bug con un test unitario.

                                                                                                                                                                                                                                                                                                                                                                                                  • Por sus características... complicado.

                                                                                                                                                                                                                                                                                                                                                                                                  • "sys.getrefcount()":

                                                                                                                                                                                                                                                                                                                                                                                                    https://docs.python.org/3/library/sys.html#sys.getrefcount.

                                                                                                                                                                                                                                                                                                                                                                                                  • "sys.exc_info()": https://docs.python.org/3/library/sys.html#sys.exc_info.

                                                                                                                                                                                                                                                                                                                                                                                                  • "Race conditions":

                                                                                                                                                                                                                                                                                                                                                                                                    https://es.wikipedia.org/wiki/Condici%C3%B3n_de_carrera.

                                                                                                                                                                                                                                                                                                                                                                                                  • [01:59:22] Cuando recoge basura de objetos, podemos pedir que

                                                                                                                                                                                                                                                                                                                                                                                                    los guarde en "gc.garbage" para revisarlos:
                                                                                                                                                                                                                                                                                                                                                                                                    https://docs.python.org/3/library/gc.html#gc.garbage.

                                                                                                                                                                                                                                                                                                                                                                                                    • "gc.DEBUG_SAVEALL":

                                                                                                                                                                                                                                                                                                                                                                                                      https://docs.python.org/3/library/gc.html#gc.DEBUG_SAVEALL.

                                                                                                                                                                                                                                                                                                                                                                                                    • Se puede limpiar "gc.garbage" antes de la ejecución del

                                                                                                                                                                                                                                                                                                                                                                                                      código que nos interesa analizar.

                                                                                                                                                                                                                                                                                                                                                                                                    • [02:03:42] Bola extra:

                                                                                                                                                                                                                                                                                                                                                                                                      • Editar los audios.

                                                                                                                                                                                                                                                                                                                                                                                                      • Machine learning para el procesado de audio.

                                                                                                                                                                                                                                                                                                                                                                                                        • El problema del cocktail:

                                                                                                                                                                                                                                                                                                                                                                                                          https://en.wikipedia.org/wiki/Cocktail_party_effect y
                                                                                                                                                                                                                                                                                                                                                                                                          una solución aplicando inteligencia artificial:
                                                                                                                                                                                                                                                                                                                                                                                                          https://www.technologyreview.com/2015/04/29/168316/deep-learning-machine-solves-the-cocktail-party-problem/.

                                                                                                                                                                                                                                                                                                                                                                                                        • RNNoise https://jmvalin.ca/demo/rnnoise/.

                                                                                                                                                                                                                                                                                                                                                                                                        • [02:09:52] Repaso del día para los que llegaron tarde.

                                                                                                                                                                                                                                                                                                                                                                                                        • [02:12:52] Weakref:

                                                                                                                                                                                                                                                                                                                                                                                                          https://docs.python.org/3/library/weakref.html.

                                                                                                                                                                                                                                                                                                                                                                                                          • Jesús ofrece algunos ejemplos de su utilidad.

                                                                                                                                                                                                                                                                                                                                                                                                            • [02:19:22] Iteradores WSGI

                                                                                                                                                                                                                                                                                                                                                                                                              https://www.python.org/dev/peps/pep-0333/.

                                                                                                                                                                                                                                                                                                                                                                                                            • [02:21:12] Weakref en caché de objetos Durus

                                                                                                                                                                                                                                                                                                                                                                                                              https://www.mems-exchange.org/software/DurusWorks/DurusWorks-1.2.tar.gz/DurusWorks-1.2/doc/durus.html.

                                                                                                                                                                                                                                                                                                                                                                                                            • [02:23:52] El valor de la tertulia es llevarse algo que probar

                                                                                                                                                                                                                                                                                                                                                                                                              en casa.

                                                                                                                                                                                                                                                                                                                                                                                                            • [02:25:22] La tertulia la hacen los asistentes.

                                                                                                                                                                                                                                                                                                                                                                                                            • [02:28:36] Final.

                                                                                                                                                                                                                                                                                                                                                                                                              2 hr 30 min
                                                                                                                                                                                                                                                                                                                                                                                                            • Python en español #12: Tertulia 2020-12-22
                                                                                                                                                                                                                                                                                                                                                                                                              Ciclos de memoria, "core developers" y dataclasses https://podcast.jcea.es/python/12

                                                                                                                                                                                                                                                                                                                                                                                                              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.

                                                                                                                                                                                                                                                                                                                                                                                                              • Juan Carlos.

                                                                                                                                                                                                                                                                                                                                                                                                                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] Seguimos hablando del bug comentado la semana pasada.

                                                                                                                                                                                                                                                                                                                                                                                                                  • bug bpo35930: "Raising an exception raised in a "future"
                                                                                                                                                                                                                                                                                                                                                                                                                  • instance will create reference cycles":
                                                                                                                                                                                                                                                                                                                                                                                                                    https://bugs.python.org/issue35930.
                                                                                                                                                                                                                                                                                                                                                                                                                  • [02:17] El "bytecode" https://es.wikipedia.org/wiki/Bytecode

                                                                                                                                                                                                                                                                                                                                                                                                                    que genera Python es muy mejorable.

                                                                                                                                                                                                                                                                                                                                                                                                                    >>> import dis
                                                                                                                                                                                                                                                                                                                                                                                                                    >>> def suma(valores):
                                                                                                                                                                                                                                                                                                                                                                                                                    ... s=0
                                                                                                                                                                                                                                                                                                                                                                                                                    ... for i in valores:
                                                                                                                                                                                                                                                                                                                                                                                                                    ... s+=i
                                                                                                                                                                                                                                                                                                                                                                                                                    ... return s
                                                                                                                                                                                                                                                                                                                                                                                                                    ...
                                                                                                                                                                                                                                                                                                                                                                                                                    >>> dis.dis(suma)
                                                                                                                                                                                                                                                                                                                                                                                                                    2 0 LOAD_CONST 1 (0)
                                                                                                                                                                                                                                                                                                                                                                                                                    2 STORE_FAST 1 (s)
                                                                                                                                                                                                                                                                                                                                                                                                                    3 4 LOAD_FAST 0 (valores)
                                                                                                                                                                                                                                                                                                                                                                                                                    6 GET_ITER
                                                                                                                                                                                                                                                                                                                                                                                                                    >> 8 FOR_ITER 12 (to 22)
                                                                                                                                                                                                                                                                                                                                                                                                                    10 STORE_FAST 2 (i)
                                                                                                                                                                                                                                                                                                                                                                                                                    4 12 LOAD_FAST 1 (s)
                                                                                                                                                                                                                                                                                                                                                                                                                    14 LOAD_FAST 2 (i)
                                                                                                                                                                                                                                                                                                                                                                                                                    16 INPLACE_ADD
                                                                                                                                                                                                                                                                                                                                                                                                                    18 STORE_FAST 1 (s)
                                                                                                                                                                                                                                                                                                                                                                                                                    20 JUMP_ABSOLUTE 8
                                                                                                                                                                                                                                                                                                                                                                                                                    5 >> 22 LOAD_FAST 1 (s)
                                                                                                                                                                                                                                                                                                                                                                                                                    24 RETURN_VALUE
                                                                                                                                                                                                                                                                                                                                                                                                                    • Inferencia de tipos:
                                                                                                                                                                                                                                                                                                                                                                                                                    • https://es.wikipedia.org/wiki/Inferencia_de_tipos.
                                                                                                                                                                                                                                                                                                                                                                                                                    • [08:32] Recogida de basuras.

                                                                                                                                                                                                                                                                                                                                                                                                                      • gc.set_threshold():

                                                                                                                                                                                                                                                                                                                                                                                                                        https://docs.python.org/3/library/gc.html#gc.set_threshold.

                                                                                                                                                                                                                                                                                                                                                                                                                      • gc.disable():

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

                                                                                                                                                                                                                                                                                                                                                                                                                      • [11:27] Herramientas de monitorización:

                                                                                                                                                                                                                                                                                                                                                                                                                        • DTrace: http://dtrace.org/blogs/. Monitoriza el sistema
                                                                                                                                                                                                                                                                                                                                                                                                                        • operativo entero, incluyendo las aplicaciones, todo
                                                                                                                                                                                                                                                                                                                                                                                                                          integrado, de forma segura y sin modificar el software.
                                                                                                                                                                                                                                                                                                                                                                                                                        • [13:32] Funcionalidades de auditoría de Python:

                                                                                                                                                                                                                                                                                                                                                                                                                          • PEP 551 -- Security transparency in the Python runtime

                                                                                                                                                                                                                                                                                                                                                                                                                            https://www.python.org/dev/peps/pep-0551/.

                                                                                                                                                                                                                                                                                                                                                                                                                          • PEP 578 -- Python Runtime Audit Hooks

                                                                                                                                                                                                                                                                                                                                                                                                                            https://www.python.org/dev/peps/pep-0578/.

                                                                                                                                                                                                                                                                                                                                                                                                                          • [16:47] Más herramientas de monitorización:

                                                                                                                                                                                                                                                                                                                                                                                                                            • SystemTap: https://es.wikipedia.org/wiki/SystemTap.

                                                                                                                                                                                                                                                                                                                                                                                                                            • eBPF: https://ebpf.io/.

                                                                                                                                                                                                                                                                                                                                                                                                                            • py-spy: https://github.com/benfred/py-spy.

                                                                                                                                                                                                                                                                                                                                                                                                                            • [17:52] Más sobre DTrace

                                                                                                                                                                                                                                                                                                                                                                                                                              https://es.wikipedia.org/wiki/DTrace_(Sun_Microsystems) y Python:

                                                                                                                                                                                                                                                                                                                                                                                                                              • Añadir sondas DTrace al intérprete de Python:
                                                                                                                                                                                                                                                                                                                                                                                                                              • https://www.jcea.es/artic/python_dtrace.htm.
                                                                                                                                                                                                                                                                                                                                                                                                                              • [22:12] Tracemalloc.

                                                                                                                                                                                                                                                                                                                                                                                                                                • tracemalloc:
                                                                                                                                                                                                                                                                                                                                                                                                                                • https://docs.python.org/3/library/tracemalloc.html.
                                                                                                                                                                                                                                                                                                                                                                                                                                • [23:02] Seguimos hablando del bug comentado la semana pasada.

                                                                                                                                                                                                                                                                                                                                                                                                                                  • bug bpo35930: "Raising an exception raised in a "future"

                                                                                                                                                                                                                                                                                                                                                                                                                                    instance will create reference cycles":
                                                                                                                                                                                                                                                                                                                                                                                                                                    https://bugs.python.org/issue35930.

                                                                                                                                                                                                                                                                                                                                                                                                                                  • ¡Se ofrece una caja de cervezas!

                                                                                                                                                                                                                                                                                                                                                                                                                                  • Brainstorming.

                                                                                                                                                                                                                                                                                                                                                                                                                                  • Diagnóstico detallado.

                                                                                                                                                                                                                                                                                                                                                                                                                                  • weakref — Weak references:

                                                                                                                                                                                                                                                                                                                                                                                                                                    https://docs.python.org/3/library/weakref.html.

                                                                                                                                                                                                                                                                                                                                                                                                                                  • Se sube la apuesta a caja y media de cervezas :-).

                                                                                                                                                                                                                                                                                                                                                                                                                                  • La excepción salta en un hilo y se "transporta" y almacena

                                                                                                                                                                                                                                                                                                                                                                                                                                    para que se pueda acceder desde otro hilo.

                                                                                                                                                                                                                                                                                                                                                                                                                                  • Test reproducible.

                                                                                                                                                                                                                                                                                                                                                                                                                                  • [36:42] Aviso legal.

                                                                                                                                                                                                                                                                                                                                                                                                                                    • Machine learning para identificar los diferentes hablantes.
                                                                                                                                                                                                                                                                                                                                                                                                                                    • [38:27] Las futuras notas de las grabaciones serán EXHAUSTIVAS

                                                                                                                                                                                                                                                                                                                                                                                                                                      (como estáis comprobando leyendo esto :).

                                                                                                                                                                                                                                                                                                                                                                                                                                    • [39:17] Ideas para "cebar" las tertulias.

                                                                                                                                                                                                                                                                                                                                                                                                                                      • Muchos temas recurrentes, se ve que hay temas "flotando"
                                                                                                                                                                                                                                                                                                                                                                                                                                      • en el aire.
                                                                                                                                                                                                                                                                                                                                                                                                                                      • [40:37] Cómo organizar las tertulias, diferentes intereses y

                                                                                                                                                                                                                                                                                                                                                                                                                                        profundidad. Dinámica de la tertulia.

                                                                                                                                                                                                                                                                                                                                                                                                                                      • [42:32] ¿Cómo se organizan los "core developers"?

                                                                                                                                                                                                                                                                                                                                                                                                                                        • El desarrollo se ha movido en github. Los bugs están a medio

                                                                                                                                                                                                                                                                                                                                                                                                                                          migrar, se va a integrar más en github.

                                                                                                                                                                                                                                                                                                                                                                                                                                          • https://pyfound.blogspot.com/2020/05/pythons-migration-to-github-request-for.html

                                                                                                                                                                                                                                                                                                                                                                                                                                          • PEP 581 -- Using GitHub Issues for CPython

                                                                                                                                                                                                                                                                                                                                                                                                                                            https://www.python.org/dev/peps/pep-0581/.

                                                                                                                                                                                                                                                                                                                                                                                                                                          • Guía del desarrollador: https://devguide.python.org/.

                                                                                                                                                                                                                                                                                                                                                                                                                                          • Backporting de bugs de cpython de la versión en desarrollo a

                                                                                                                                                                                                                                                                                                                                                                                                                                            las versiones estables.

                                                                                                                                                                                                                                                                                                                                                                                                                                          • ¿Cómo se obtiene y se pierde el status de "core developer"?

                                                                                                                                                                                                                                                                                                                                                                                                                                          • Steering council. PEP 8016:

                                                                                                                                                                                                                                                                                                                                                                                                                                            https://www.python.org/dev/peps/pep-8016/. Rol que cumple
                                                                                                                                                                                                                                                                                                                                                                                                                                            y cómo se elige.

                                                                                                                                                                                                                                                                                                                                                                                                                                          • Desde que Guido no es BDFL, está muy activo en listas de

                                                                                                                                                                                                                                                                                                                                                                                                                                            correo y picando código.

                                                                                                                                                                                                                                                                                                                                                                                                                                          • [52:22] ¡Víctor quiere más bugs para aprender!

                                                                                                                                                                                                                                                                                                                                                                                                                                            • Bugs marcados como "easy", como forma de entrada a
                                                                                                                                                                                                                                                                                                                                                                                                                                            • desarrolladores nuevos.
                                                                                                                                                                                                                                                                                                                                                                                                                                            • [53:42] ¿Qué partes de CPython están escritas en C y cuáles en

                                                                                                                                                                                                                                                                                                                                                                                                                                              Python?

                                                                                                                                                                                                                                                                                                                                                                                                                                              • Se escribe en C lo que no tiene más remedio, por rendimiento

                                                                                                                                                                                                                                                                                                                                                                                                                                                o porque interactúa con el sistema operativo.

                                                                                                                                                                                                                                                                                                                                                                                                                                              • Más adelante de la conversación Jesús Cea explica cómo ver

                                                                                                                                                                                                                                                                                                                                                                                                                                                si un módulo concreto está en C o en Python sin tener que ir
                                                                                                                                                                                                                                                                                                                                                                                                                                                al código fuente.

                                                                                                                                                                                                                                                                                                                                                                                                                                              • [57:32] PyPy https://www.pypy.org/. Intérprete de Python

                                                                                                                                                                                                                                                                                                                                                                                                                                                escrito en Python.

                                                                                                                                                                                                                                                                                                                                                                                                                                                • RPython: https://rpython.readthedocs.io/en/latest/.
                                                                                                                                                                                                                                                                                                                                                                                                                                                • [58:27] ¿Incluir otros lenguajes en la implementación de

                                                                                                                                                                                                                                                                                                                                                                                                                                                  CPython?

                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Rust:

                                                                                                                                                                                                                                                                                                                                                                                                                                                    https://es.wikipedia.org/wiki/Rust_(lenguaje_de_programaci%C3%B3n).

                                                                                                                                                                                                                                                                                                                                                                                                                                                  • PyOxidizer: https://github.com/indygreg/PyOxidizer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Fragmentación. Jesús Cea estoy más centrado en la parte de C

                                                                                                                                                                                                                                                                                                                                                                                                                                                    porque la mayor parte de los "core developers" no saben C.
                                                                                                                                                                                                                                                                                                                                                                                                                                                    Añadir más lenguajes reduce el grupo de gente que puede
                                                                                                                                                                                                                                                                                                                                                                                                                                                    mantener esas partes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Portabilidad de C.

                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Bootstraping de un lenguaje con el propio lenguaje.

                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Forth:
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • https://en.wikipedia.org/wiki/Forth_(programming_language).
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • [01:05:02] Python 3.9. Mejoras.

                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Dificultades para utilizar la última versión de Python, en
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • función de lo que tenga el cliente.
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • [01:08:07] Dataclasses:

                                                                                                                                                                                                                                                                                                                                                                                                                                                        https://docs.python.org/3/library/dataclasses.html.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        • La dificultad para tener atributos opcionales. Algunas

                                                                                                                                                                                                                                                                                                                                                                                                                                                          ideas.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        • attrs: https://www.attrs.org/en/stable/.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Usar valores "sentinel".

                                                                                                                                                                                                                                                                                                                                                                                                                                                        • DRY: https://es.wikipedia.org/wiki/No_te_repitas.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        • [01:20:52] Pydantic: https://pydantic-docs.helpmanual.io/.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        • [01:23:07] Horarios de las tertulias. Mucha discusión y algunas

                                                                                                                                                                                                                                                                                                                                                                                                                                                          ideas. De momento no habrá cambios. Hace falta más feedback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Se agradecería que la gente que deje las tertulias,
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • explicase por qué se ha ido.
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • [01:30:27] Jesús Cea explica cómo ver si un módulo concreto está

                                                                                                                                                                                                                                                                                                                                                                                                                                                            en C o en Python sin tener que ir al código fuente.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          • [01:31:18] Más sobre la dinámica de las tertulias.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Debate sobre presentarse o no en tertulias abiertas, o tener

                                                                                                                                                                                                                                                                                                                                                                                                                                                              la cámara apagada.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Va siendo necesario tener algun repositorio para que la

                                                                                                                                                                                                                                                                                                                                                                                                                                                              gente de la tertulia pueda compartir cosas.

                                                                                                                                                                                                                                                                                                                                                                                                                                                              • ¿Lista de correo específica para las tertulias?
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • [01:36:42] Actas de las tertulias y publicar las grabaciones de

                                                                                                                                                                                                                                                                                                                                                                                                                                                                una puñetera vez. ¿Algún ingeniero de sonido en la sala?
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ¿Baratito?

                                                                                                                                                                                                                                                                                                                                                                                                                                                              • [01:39:08] El "nivel" de las listas de correo. ¿Dónde están las

                                                                                                                                                                                                                                                                                                                                                                                                                                                                conversaciones interesantes? (aparte de la tertulia semanal :-).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                • La maldición de lo básico e "introducción a". Igual para que

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  haya conversación interesante, hay que hacer preguntas
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interesantes :-).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Python-Madrid antes de que llegase Meetup.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Jesús Cea sugiere listas como "python-ideas":

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  https://mail.python.org/mailman3/lists/python-ideas.python.org/.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  También la lista de programación Python en español:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Javier tiene intereses muy extraños :-).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                • [01:54:52] Cierre.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                • [01:56:42] Final.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1 hr 58 min
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Python en español #11: Tertulia 2020-12-15
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1 hr 43 min
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Python en español #10: Tertulia 2020-12-09
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Más sobre persistencia de datos https://podcast.jcea.es/python/10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    En esta ocasión grabamos un miércoles porque ayer fue festivo en

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    España.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Miguel Sánchez, email:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [email protected], conectando desde
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Canarias.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Víctor Ramírez, twitter: @virako,

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      programador python y amante de vim, conectando desde Huelva.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Artur, conectando desde Vigo.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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] Problemas de sonido.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • [01:57] "Duda/problema con mod_wsgi-express"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Referencia a un

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          mensaje
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          enviado a la lista de correo.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Los módulos se importan una sola vez.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • mod_wsgi: https://pypi.org/project/mod-wsgi/.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • matplotlib: https://matplotlib.org/.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Damos con la solución: Ojo con los objetos globales y

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          múltiples hilos.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • [07:52] Python 3.9.1.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • PEP 384: https://www.python.org/dev/peps/pep-0384/.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Py_FileSystemDefaultEncodeErrors and Py_UTF8Mode are not

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            available with limited API:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            https://bugs.python.org/issue41986.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • [09:07] Estado de persistencia en Python.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • ZODB: http://www.zodb.org/en/latest/.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Durus: https://www.mems-exchange.org/software/DurusWorks/.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • [10:07] ¿Cómo conectar la tecnología de persistencia con el

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              mundo de Python asíncrono?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • [11:47] Según la opinión de Jesús Cea, la implementación actual

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              de async/await en Python es... fea.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • La idea es buena, pero la implementación es chapucera y poco

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                transparente.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Es muy difícil combinar los mundos síncronos y asíncronos.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Las librerías tienen que tomar partido.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • El código asíncrono "contamina" todo el programa.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • [15:52] Moderación en la lista de correo.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • [18:47] Reconducimos la tertulia. ¿Estáis usando Python 3.9?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Las distribuciones no están a la última. Cada cliente tiene

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  instalado algo distinto.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Utilizar cosas como Docker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  https://es.wikipedia.org/wiki/Docker, para independizarte
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  de la versión orifial del Sistema Operativo.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Los tests te salvan el día a la hora de actualizar de

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  versión.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • [25:22] Sistemas de tests avanzados.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Hypothesis: https://pypi.org/project/hypothesis/.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Prueba de mutación:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    https://es.wikipedia.org/wiki/Prueba_de_mutaci%C3%B3n.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • [27:37] Podcasts en inglés que escucha Jesús:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Python Bytes https://pythonbytes.fm/.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Seis temas, media hora. Semanal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Opinión con criterio.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Podcast de testing: Test & Code https://testandcode.com/.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • [30:52] Justificar actualizar a versiones modernas de Python.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • No suele haber problemas de compatibilidad actualizando a

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          versiones más modernas de Python 3, y los cambios necesarios
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -si los hay- son menores.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Problema: Los paquetes precompilados de librerías complejas

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          pueden tardar en estar disponible para la nueva versión de
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Python.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Muchas librerías complejas no publican versiones

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          precompiladas de forma retroactiva para las versiones
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          nuevas de Python cuando salen, hay que esperar a que
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          saquen una nueva versión de la librería, a veces meses
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          después.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Si tardas en actualizar, actualizar múltiples versiones de

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          golpe puede ser muy costoso.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • [34:32] El nuevo "resolver" de dependencias de PIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          https://pyfound.blogspot.com/2020/11/pip-20-3-new-resolver.html.

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Librerías compatibles con versiones nuevas de Python, pero

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            que PIP no quiere instalar porque en los descriptores del
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            proyecto no dice que sea compatible. Esto es un problema
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            cuando sale una versión nueva de Python.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • [38:24] ¿Desde dónde conectamos cada uno?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Spam de Jesús en las listas de correo.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • ¿Qué pasa con la gente de hispanoamérica?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Mucha gente conectando desde Vigo y alrededores.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Comunidades técnicas en el entorno de Vigo.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Vigo Tech Alliance https://vigotech.org/.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • A Industriosa https://aindustriosa.org/.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • [43:42] Aviso de que las tertulias se graban.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • [44:42] Las ideas de Jesús Cea sobre las tertulias.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • [46:37] Bases de datos.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • SQLAlchemy https://www.sqlalchemy.org/.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Modelos de datos.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Diversas bases de datos.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • PostgreSQL: https://www.postgresql.org/.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • MySQL: https://www.mysql.com/.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • MongoDB: https://www.mongodb.com/.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Jesús Cea usa sistemas de persistencia. Se ha hablado mucho

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  de esto en una tertulia anterior.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • [51:42] Persistencia en Python.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Tema abordado de forma extensa en la tertulia anterior:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  https://podcast.jcea.es/python/9. Revisa el audio y/o las
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  notas de esa grabación.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • [01:02:52] La persistencia no usa teoría relacional.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Trabajando con persistencia, no puedes traerte tus ideas de

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  teoría relacional. Se trabaja de otra manera.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Acceso al sistema de persistencia a través de un API.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • [01:09:27] Nuevas incorporaciones a la tertulia.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • [01:10:12] ¿ORM de Django https://www.djangoproject.com/ o

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SQLAlchemy https://www.sqlalchemy.org/?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • [01:14:32] Jesús insiste en sus sistemas de persistencia.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • ZODB: http://www.zodb.org/en/latest/.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • ¿Cómo se actualiza la definición de objetos? Jesús describe

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    las dos técnicas que usa:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Versión global de la base de datos con actualización en

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      el arranque.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Cada objeto tiene su versión y se actualiza al cargarlo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      en memoria.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Los objetos son objetos nativos de Python. Para que otros

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      lenguajes puedan acceder a los datos hay que proporcionarles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      un API.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. [01:26:32] Tecnología "publicar & suscribir"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      https://en.wikipedia.org/wiki/Publish%E2%80%93subscribe_pattern.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Event Sourcing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        https://dev.to/barryosull/event-sourcing-what-it-is-and-why-its-awesome.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Lenguaje Linda

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        https://en.wikipedia.org/wiki/Linda_(coordination_language).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • RabbitMQ: https://www.rabbitmq.com/.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • ZeroMQ: https://zeromq.org/.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Redis: https://redis.io/.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Pyro: https://pyro5.readthedocs.io/en/latest/.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Colas persistentes.

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • [01:40:37] Open Source y mantenedores quemados.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Github: https://github.com/.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Github actions: https://docs.github.com/en/actions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • [01:49:54] Final.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1 hr 51 min

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          About Python en español

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          From the publisher's feed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'Feed' de Python en español.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          More shows like Python en español

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Libros para Emprendedores by Luis Ramos

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Libros para Emprendedores

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          1,118 Listeners