Hi, I like POE and the idea of distributed applications. I read the IKC TODO, talked to the author, Philip Gwyn, and thought some things should be added to POE, too. Some things are IKC specific, but most things would be useful for single-kernel programs as well. Some of the things are by Philip, maybe he wants to forward his mail to the list. -Transactions: I'd like to be able to give a session or the like a group of events/commands, maybe with operators (action a and b or at least three of c..f), and have it executed for me, with a single report coming back including the overall results and the sub-result history. rollback is certainly not easy to do, as it might not be possible for some problems. so one could post a group of commands to a network service component and don't have to check for errors after every command. additionally it removes a lot of states for the different steps. This could be implemented as a session wrapping the actual worker session(s) or as a loadable addon to sessions. although specifying a general return code protocoll for the worker states won't be easy ... -NFAs or similar session types: it would be good if they could be improved and/or extendend. although it seems like only a few people are using them yet so it's not clear what is really needed :/ NFAs or the like can put a lot of logic into a automaton representation, which is much easier to read than code with a lot of branching... -clusters and crash recovery: transactions might be useful for this. it should be divided into session clusters and kernel clusters, the first one needed by the second. for session clusters it must be possible to copy (fork) sessions and to migrate them. most things are given in the state contexts, only things like selects and aliases are specific to a specific kernel or process. probably some additional code or at least guidelines are needed, that can break these dependencies, at least for sessions that want to support it. if it can be done for one kernel, extending it to work between different kernels shouldn't be too hard. crash recovery should work if there are transactions, copying and migration. sessions must work properly of course. session-internal fallback should be handled by sessions themselves as it depends on their inner logic. implementations of these features should not touch POE basics if possible. but, you can program object oriented in c, but everyone uses c++. it's the same here: using events for transactions, returning values through postbacks, ... is certainly possible and good. but support for specific features saves users a lot of time and makes programs a lot more readable. to me this is what new ways like POE are all about, mostly. a lot of things can probably be covered with a mighty nfa. additionally there could be something like session addons. functionality that can be attached to a session, like telling the session's create that there should be transaction support. could be handled through new classes derived from session, but (with the vision of a lot of addons) there would be too many combinations. all it would need would be some hooks and "just" some guidelines so that addons interoperate properly. btw, philip's idea of extending his proxy sessions to proxy objects (method calls are (transparently?) translated into (distributed) poe event posts/ calls) would be very useful for non-poe clients. together with clusters etc. this could make good application servers, if this is the right buzzword :) so i would like to know what other people think about these topics. and if some of us find some spare time, maybe some of things even get implemented ... :) torvald
