I just went to a talk about pony ... now I want to get back to ocean! The main ideas were: - type "Capabilities" like shared/unshared/once/whatever - concurrency though message passing, not locks. I need to think about the latter. How does it scale. e.g. can it implement the sort of concurrency we use for the dcache. That includes fine-grained spinlocks and RCU. I think that pony uses a separate thread(actors) to manage any shared/mutable object. Messages are sent to the actor and they act. That means one thread for each dentry?? With coarse grained locking this might be good, like Hoare monitors. How would you model locks and RCU in this sort of language? control structure for holding the lock? Reference that is allowed to unlock? RCU ?? read_lock is easy enough. So this would be supported in the "runtime". What would the language check?... Certainly message passing is easier to work with. If I was to provide that I would need a green-thread implementation. This would need - non-blocking kernel APIs so thread can switch tasks instead of block - stack allocation. For internal code we might be able to use a tiny stack and grow as needed. For FFI a real stack allocation is important. But FFI isn't task-aware so it can use thread stack. internal calls could be annotated with stack usage, calculated at link time - whether dynamic or not. If a recursive function is called it has a preamble which allocates a dynamic stack. Sending a message would queue for the task then try to take the lock and run. If lock isn't available, then when the lock is released, the next message will be dequeued. Do we wait for a reply? If we did, we could deadlock. So have to wait for *any* message (including reply), and allow other messages to intervene. So if a monitor blocks waiting on a reply, then it must accept messages on oher threads?? That means different threads hold the 'same' lock. Is that a good idea? Probably not. So how is pony deadlock free? It doesn't allow reply messages. So you cannot say "insert if not present". You have to "insert, and call me back when done".