event-driven | Event Driven Micro service architecture with rabbit MQ | Microservice library

Context:

1. In Azure function with EventHubTrigger, I save data mapped from handled event to database (through the Entity framework). This action performs synchronously
2. Trigger a new event about successful data insertion using event hub producer. This action is async
3. Handle that triggered event at some other place

I guess it might happen that something fails during saving data, so I am wondering how to prevent inconsistency and secure that event is not sent if it should not. As far as I know Azure Event Hub has no outbox pattern implemented yet, so I guess I would need to mimic it somehow.

I am also thinking about alternative and a bit smelly solution to make this publish event method synchronous in step 2 (even if nature of the event-driven is to be async) and to add an addition check between step 1 and step 2 - to make sure that everything is saved in db. Only if that condition is fulfilled, event is going to be triggered (step 3).

Any advice?

I need to write a paper on the Event-Driven Programming Paradigm in Logic Programing. I have been able to find a lot of information on Event-Driven Programming in Object-Oriented and Functional programming, but not for Logic programing. I would appreciate some direction in respect to Event-Driven Programming in Logical Programing.

So I'm trying to build a small app, and I really enjoy the Guizero package and it's easy, event-driven programming.

The only thing it seems to lack is a method to implement theme changes, so it looks really outdated at the moment. Is there a way to apply Tkinter packages or something?

Below is some code I've tried, and it even prints 'vista' out correctly, but it doesn't seem to implement the actual theme change.

I'm writing an event-driven program with the event scheduling written in C. The program uses Python for extension modules. I would like to allow extension modules to use async/await syntax to implement coroutines. Coroutines will just interact with parts of my program, no IO is involved. My C scheduler is single-threaded and I need coroutines to execute in its thread.

In a pure Python program, I would just use asyncio as is, and let my program use its event loop to drive all events. This is however not an option; my event loop needs to serve millions of C-based events per second and I cannot afford Python's overheads.

I tried to write my own event loop implementation, that delegates all scheduling to my C scheduler. I tried a few approaches:

• Re-implement EventLoop, Future, Task etc to imitate how asyncio works (minus IO), so that call_soon delegates scheduling to my C event loop. This is safe, but requires a bit of work and my implementation will always be inferior to asyncio when it comes to documentation, debugging support, intricate semantic details, and correctness/test coverage.
• I can use vanilla Task, Future etc from asyncio, and only create a custom implementation of AbstractEventLoop, delegating scheduling to my C event loop in the same way. This is pretty straightforward, but I can see that the vanilla EventLoop accesses non-obvious internals (task._source_traceback, _asyncgen_finalizer_hook, _set_running_loop), so my implementation is still second class. I also have to rely on the undocumented Handle._run to actually invoke callbacks.
• Things appeared to get simpler and better if I subclassed from BaseEventLoop instead of AbstractEventLoop (but docs say I shouldn't do that). I still need Handle._run, though.
• I could spawn a separate thread that run_forever:s a vanilla asyncio.DefaultEventLoop and run all my coroutines there, but coroutines depend on my program's extension API, which does not support concurrent calls. So I must somehow make DefaultEventLoop pause my C event loop while calling Handle._run(). I don't see a reasonable way to achieve that.

Any ideas on how to best do this? How did others solve this problem?

I wanted to create two servers in Node.js and make full-duplex communication with each other over rabbitMQ. I am new to messagebrokers or event-driven development, I just want to make one server serve API to the front-end another one just a chat server? Is that even a good approach?

We're building a small REPL that evaluates (with eval) javascript expressions as they are being entered by the user. Since the whole thing is event-driven, evaluation must take place in a separate function, but the context (that is, all declared variables and functions) must be preserved between the calls. I came up with the following solution:

I have an example, where input and output elements are on the same site.

1. The element value is generated
2. The element value is given by the user
3. There is another element, where the 1. and 2. elements product are shown.

The example should be event-driven.

• If the user types in an input, the Product must change.
• If the user-generated a new number, the Product must also change.

• Only the Typed parameter can cause a change in the Product element's value. There could be some reason, due to the changes of the Generated number is not triggering the product calculation.

How could I modify my example to calculate the Product in case of change the Generated number or the Typed parameter?

I'm having trouble understanding control flow with asynchronous programming in JS. I come from classic OOP background. eg. C++. Your program starts in the "main" -- top level -- function and it calls other functions to do stuff, but everything always comes back to that main function and it retains overall control. And each sub-function retains control of what they're doing even when they call sub functions. Ultimately the program ends when that main function ends. (That said, that's about as much as I remember of my C++ days so answers with C++ analogies might not be helpful lol).

This makes control flow relatively easy. But I get how that's not designed to handle event driven programming as needed on something like a web server. While Javascript (let's talk node for now, not browser) handles event-driven web servers with callbacks and promises, with relative ease... apparently.

I think I've finally got my head around the idea that with event-driven programming the entry point of the app might do little more than set up a bunch of listeners and then get out of the way (effectively end itself). The listeners pick up all the action and respond.

But sometimes stuff still has to be synchronous, and this is where I keep getting unstuck.

With callbacks, promises, or async/await, we can effectively build synchronous chains of events. eg with Promises:

I'm trying to understand these concepts

• Event-driven
• Asynchronous
• non-blocking I/O