2 ms·
In my view, the biggest drawback of the evented approach is that logically sychronous code involving IO becomes very low level spaghetti code. E.g: log(write
by fauigerzigerk 15y ago
In my view, the biggest drawback of the evented approach is that logically sychronous code involving IO becomes very low level spaghetti code. E.g:
log(write(process(read(source))))
becomes:
read(source, function(input) {
write(process(input), function(success) {
log(success)
})
})
- FooBarWidget 15y agoI don't see that as spaghetti code at all, especially when you want to handle other things while the read() or write() is blocked. Callback-style code allows you to see the interleaving of events. If you use threads then the interleaving is non-obvious.
- fauigerzigerk 15y agoI guess if you don't see the interleaving in log(write(process(read(source)))) our mental models are too different to merit further discussion of this aspect. And of course thread based code can do other things as well during blocking IO - on other threads.
- dramaticus3 15y agouse channels, you can make them block so the first loop will wait for logger to finish the logging if you like do { source = <- sources // read a source from the sources channel if source data = read(source) process <- data // send it to the process channel else process <- nil } while source fn processor { do { data = <- process result = process(data) results <- result } while data } fn writer { do { data = <- results msg = write(data) log <- msg } while data } fn logger { do { msg = <- log if msg print msg } while msg }
- fauigerzigerk 15y agoMy ideal version would be something like parallel for(item in source) log(write(process(read(item)))) And let the compiler/runtime figure out how to do that. It could generate something similar to your code for instance.
- dramaticus3 15y agook, but now I have a generic logger that I can send all kind of messages to. I can use the source channel anywhere and pop a new data source into it etc. etc. channels rule :)
- fauigerzigerk 15y agoI meant to say "logically sequential" not "logically synchronous".