@abulafia Eso :-)

Asco de hilos en Qt:

Todo por no esperar a que termine el backend. Si es que no escarmiento :-(

Joer, @Trauma ese Ulrich es un toca pelotas. XD. Luego me siento mal por mis comentarios ácidos que a veces dejo. XD

@LuisDonaldoGarcíaCastro en el mero México no hay?

@Trauma ¿No tienes la posibilidad de usar programación asincrona?

@CandidMoe Eso es asíncrono ... con varios hilos, para ponerlo fácil. Se envian mensajes de un hilo al otro. Es un test para una cola de mensajes multihilo que estoy haciendo.

@MauricioContreras No desborda simpatía, no :-)

@Trauma Asincrono en el sentido de asyncio de Python, donde cada tarea libera explicitamente el control de la CPU, evitando de raíz cualquier posibilidad de race condition.

Es que acabo de portar una aplicación de threads a asyncio y quede fascinado con sus ventajas y desempeño.

@CandidMoe Y hace menos de 24h preguntabas por qué existía asyncio habiendo threads :-)

@abulafia Para que veas lo rápido que aprendo.

sí, estoy impresionado. A mi el paradigma asíncrono me cuesta un montón. Va en contra de mi forma de pensar. Aún no he conseguido retorcer el cerebro para que encaje

@CandidMoe Es que es eso mismo :-) Hay un hilo que maneja la GUI, y un hilo que hace de backend. He hecho una cola de mensajes (del back a la GUI) para que la primera pueda responder a eventos de la segunda

cuando creo que ya lo entendí todo por fin, pasan unas semanas y ya se me olvidó otra vez qué era lo que había entendido

@Trauma estás creando la Internet 3.0 tu eh?

No me digas, se llama SkyNet

@MauricioContreras jejeje ... eso, chavalin, es un esqueleto para una aplicación de control de una máquina de soldar por ultrasonidos

Es muy posible que sea mi próximo proyecto :-)

y es que no me basta con entender la API y los ejemplos. Quiero saber de verdad qué pasa por dentro, y ahí es donde acabo fracasando. Y eso que he visto los vídeos de David Bleazey construyendo curio desde cero...

o quizás por haber visto eso es por lo que no entiendo nada :-)

Fijate. Aqui echo a andar un servidor web. server es el callback. Y el callback recibe el control con dos streams abierto (read and write):

web_server = uasyncio.start_server(server, "0.0.0.0", 80)
uasyncio.create_task(web_server)

@abulafia échale un ojo a libuv

es la implementación en C que usa node.js internamente

Y aqui está el callback:

LA MAQUINA DE SOLDAR

def server(reader, writer):
    linea = await reader.readline()

@Trauma Si no consigo entenderlo con Python voy a entenderlo con C

@MauricioContreras ¡¡ HAHAHAHA !!

@abulafia Con C es mas fácil: solo callbacks xD

No hay mas abstracciones

Bucle de eventos -> evento entrante -> callback de acción -> vuelta al bucle de eventos

Ah, si es solo con callbacks eso lo entiendo ya también en python. Básicamente el patrón reactor, alrededor de select() o poll(), con una lista de callbacks registrados y que el bucle reactor va invocando cuando los handles de E/S están listos para leer o escribir

@Trauma "Multitasking Cooperativo" que le decían en Win

lo que me empieza a marear son el resto de abstracciones: corutina, tarea, futuro, promesa, etc...

y que conste que lo entiendo, eh? Si hasta te lo podría explicar y todo. Pero... no sé. En el fondo siento que realmente no lo entiendo

@CandidMoe Correctísimo :-)

@abulafia Todas esas cosas son solo abstracciones de python para complicarte la vida xD

@CandidMoe Sí, si todo esta moda de async no es más que otra oscilación del péndulo. Es lo que había antes de que hubiera trhreads, que venían a mejorar todo

WARNING: InOutQueueTest::limit15() onPendingEvents: queue.size = 0
   Loc: [/home/juanjo/Trabajos/qml/test/inoutqueue.cpp(89)]
WARNING: InOutQueueTest::limit15() Generate 19 numbers, starting at 510
   Loc: [/home/juanjo/Trabajos/qml/test/inoutqueue.cpp(53)]
WARNING: InOutQueueTest::limit15() Generate 8 numbers, starting at 529
   Loc: [/home/juanjo/Trabajos/qml/test/inoutqueue.cpp(53)]
PASS   : InOutQueueTest::limit15()
PASS   : InOutQueueTest::cleanupTestCase()
Totals: 3 passed, 0 failed, 0 skipped, 0 blacklisted, 5250ms

@Trauma Hice aplicaciones Arduinos complejas donde tuve que construir mi propio scheduler para tomar lecturas de sensores, controlar relays con horario, enviar y recibir comandos al MQTT. Cientos de líneas de código dedicados solo a coordinar la ejecución del resto.

Pues ya tengo test. No los pasa ... pero los tengo xD

Todo eso reemplazado ahora con unas pocas lineas de Python.

@CandidMoe Pero ya deberías de saber que yo disfruto haciendo mis ladrillos :-)

Desde luego, que python ya tenga asyncio es muy cómodo

también tiene su versión de libuv, sin await. Solo con callbacks. Mas familiar para mí.

@Trauma El problema de los callbacks es que divides una tarea en segmentos de código desperdigados por aquí y allá. Con asyncio tienes todo en una misma función.

@CandidMoe Eso si que es cierto. Con callbacks necesitas cosas auxiliares para ir manteniendo los estados. Con asyncio, es mas emulando-lo-lineal

Tengo hecho por ahí una prueba-de-concepto de hilos-de-usuario para C++, con intención de usarlos con libuv y hacer algo parecido a eso

@Trauma Claro, esa es la razón de ser de todas esas abstracciones y complicaciones internas. Se barre la complejidad bajo la alfombra. El código queda con apariencia de secuencial

el problema es que yo miro bajo la alfombra

@abulafia y yo :-) por eso sigo usando callbacks

Aqui tengo la función que toma lecturas de la intensidad de luz, las promedia y publica en una variable global para el resto del programa:

async def lux_sensor():
    """
    Toma muestras del sensor de luz BH1750 conectado por I2C

    Las lecturas se publican en la variable global lux.
    """
    global lux
    muestras = 10
    q_lux = Acumulador(muestras)

    lux_sensor = BH1750(i2c)
    #print("Sensitivity: {:d}".format(lux_sensor.mtreg))
    while True:
        lux_sample = int(lux_sensor.measure_low_res())
        q_lux.put(lux_sample)
        if q_lux.items >= muestras:
            lux = q_lux.average()
        else:
            lux = q_lux[-1]

Nada de callback ni race conditions-.

@CandidMoe Yo digo como @abulafia, me lio con los async/await

@Trauma En C quizás los callbacks sean medio legibles. Aunque cuando necesitas el resultado de un callback como argumento de otro... el encadenamiento de llamadas lleva al callback hell, pero bueno, todavía puede soportarse. Lo que ya no tiene arreglo es el tinglado para manejar las excepciones. Con async todo es mucho más limpio

@abulafia si no lo discuto, cuando todo el mundo usa async/await, alguna ventaja tendrá

El código es igual que la versión threads, sólo tuve que agregar el await al final para soltar el control.

Ese await es el que pone ese hilo/coroutine o como se llame a dormir

eso en C sería un dolor de cajones hacerlo :-)

@Trauma Correcto: "espera" a que la función indicada retorne.

En C, tendrías que usar setjmp( ) / longjmp( ) al principio del callback e ir jugando con ello

En este caso, simplemente espera 10 segundos para tomar la siguiente lectura.

Sí, la sintaxis y la semántica son muy claras. Lo que es confuso es qué ocurre "en realidad", o dicho de otra forma, desenmarañar el flujo de ejecución "real", entrando y saliendo continuamente del bucle de eventos, de una corutina a otra, etc.

También me tiene un poco perplejo cómo "arranca" todo, ya que una rutina asíncrona sólo se puede llamar desde otra asíncrona... y sin embargo el main() por así decir es síncrono, por lo que hay ahi una especie de paradoja

otros lenguajes te ocultan el bucle de eventos, que de alguna forma es parte del runtime

pero en python no, de hecho es reemplazable por el que tú quieras, y puedes tener incluso más de uno a la vez

demasiada abstracción xD

@abulafia Hay un patrón claro: defines un async def main() que es el verdadero maín:

async def main():
    uasyncio.create_task(sensor(pin_dht11))
    uasyncio.create_task(lux_sensor())
    uasyncio.create_task(statistic(stats))
    web_server = uasyncio.start_server(server, "0.0.0.0", 80)
    uasyncio.create_task(web_server)

    while True:
        await uasyncio.sleep(60)
        print("memory: ", gc.mem_free())
        print(stats)
        print("------------")

#control.i2c = machine.I2C(sda=machine.Pin(27), scl=machine.Pin(26))


uasyncio.run(main())

pero cuidado, que asyncio no es más que una biblioteca, no es "parte del lenguaje". Es la que viene preisntalada sí, pero hay otras posibles (y hoy día cada vez más... Trio tiene buena pinta)

lo único que es parte del lenguaje es async/await y lo que yo quiero entender es cómo se monta un asyncio o equivalente desde cero a partir de esas primitivas

lo peor de eso es cuando hay que interactuar con librerias extra que no soportan esas cosas

@MauricioContreras de casualidad sabes si existe alguna manera de convertir un color hex a ansi en php???

@CandidMoe Sí, eso lo entiendo. Pero lo que quiero entender es la "magia" que hace uasincyio.run(), que claramente es código síncrono, para poner en marcha todo el motor asíncrono

@Trauma Bueno, en python lo tienes relativamente fácil. asyncio te proporciona también wrappers para ejecutar en otro hilo lo que sea, de modo que el wrapper hace await hasta que el otro hilo acabe

ah, que ya incorpora su propia comunicación entre hilos :-O

muy mucho práctico :-)

aburrido ... pero práctico xD

@Trauma Mi aplicación usa librerías sincronicas para el bus I2C, pero son tareas que sólo demoran unos milisegundos, asi que no se nota.

ok, no interfieren apenas con el event-loop

De verdad que me gustan estar charlas. Normalmente, no tengo con quien tenerlas :-)

A ver si os desenganchais del python ese y ya podemos hablar de cosas de hombres XD

@Trauma Correcto. A nivel de hardware, estos sensores típicamente te ofrecen la posibillidad de iniciar una lectura con un comando, para que después de un rato le pidas el resultado. Asi evitas quedar bloqueado.

ok. No he trabajado con cosas de esas

@Trauma cosas de hombres como JAVA?!

@Benito-B ufff ... eso ya es mucho nivel para mí xD

@Trauma Hombre! Sacando la cuenta ... empece a escribir C con Microsoft C v 1.0 y sigo hasta hoy ... son ... 35 años.

@CandidMoe Y no sería posible iniciar la lectura, hacer un await asyncio.sleep() y recoger el resultado? ¿por qué tener hacer esa parte sincrónica?

@CandidMoe Lleva usted más años programando que yo respirando, caballero

Los verdaderos programadores modifican las posiciones de los átomos en el disco duro con una aguja fina y buen pulso

@abulafia Anda! Eso hacía mi abuela con los calcetines

O algo así...

@abulafia no no no ... usan mariposas xD

Aguja tenía eh

@Trauma Yo también llevo más años programando en C que en Python

@Trauma No puedo seguir el chiste. Hace años que dejé de usar Emacs

Siempre me flipó ese chiste xD

Jolines trauma

La lupa donde la guardaste?

jejeje

la primera imagen que encontré

XDDD Menos mal que conozco el chiste, porque vaya vaya

explainxkcd.com/wiki/index.php/378:_Real_Programmers

ah no, no reconoce enlaces a xkcd

@Trauma xkcd tiene varios clásicos. A mi me gusta el de contar ovejas con desbordamiento

@abulafia El patron queda ilustrado por esta versión reducida que lee el sensor de temp/humedad:

async def sensor(pin):
    temp_sensor = dht.DHT11(machine.Pin(pin))
    temp_sensor.measure()  # Pedir la primera lectura.
    await uasyncio.sleep(1)
    while True:
        temp = temp_sensor.temperature() # Leer el dato
        #
        #  Realizar otras operaciones con el dato
        temp_sensor.measure() # iniciar la siguiente lectura
        await uasyncio.sleep(10) # Soltar el control

@Trauma No es a xkcd, es a explainxkcd

Ese no lo conozco :-O

Hola

@abulafia XDDDDD

O el de Bobby Tables...

Güenísimo :-D

O el de sudo:

jejeje ... ese si. Güenísimo también xD

Que significa una pregunta bien recibida por 30 dias consecutivos(medalla inquisidor)

@abulafia Jajajajajjaja

@abulafia JAJAJAJAJAJAJAJAJA Little bobby'); DROP TABLE Students;--

@CandidMoe Ah, entonces sí que usas el sleep() asíncrono. Te había entendido que hacías un sleep() normal porque duraba poco y eso no iba a interferir el bucle de eventos

Como el señor que se puso NULL de matrícula de coche para que no le llegasen multas y le llegaron todas las que fallaban la lectura. Ojalá sea cierto que eso pasó

@abulafia El módulo I2C hace sleep normal; es la única manera de garantizar que los timings se ajusten al protocolo.

@Benito-B Steve Jobs cambiaba el Mercedes cada 6 meses, que era el plazo máximo que podía circular sin colocarle patente/matrícula. Asi podia estacionar en sitios reservados sin que lo multaran. Otra de sus tantas maldades.

@CandidMoe JAJAJAJAJA Esa no la sabía tampoco

Je, no conocía este:

Bueno, me retino. No seáis malos :-)

@Benito-B Cuando Jobs trabajaba en Atari uno un desafío interno: "Reducir el número de chips usados en una consola". Jobs le pasó el problema a Wozniak, que trabajaba en HP, sin contarle cuanto era el monto del premio. La solución de Woz fue la premiada, pero Jobs se embolso la plata y le dio una cantidad mínima a Woz.

Jobs también se negó a reconocer a su hija y pagar la pensión de alimentos.

Buenas tardes!

Buenaaas

@FranciscoNúñez Borraste la pregunta ?

Cómo traducirían Github-flavored? "con sabor a Github" no es que quede muy bien que digamos

@padaleiana Estilo Github

Mucho mejor. Gracias