Python en español

Python en español #10: Tertulia 2020-12-09


Listen Later

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.

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

                                          Python en españolBy Jesús Cea


                                          More shows like Python en español

                                          View all
                                          Libros para Emprendedores by Luis Ramos

                                          Libros para Emprendedores

                                          1,115 Listeners