DRAFT roadmap.txt

Node v0.8 roadmap
-----------------

- Move the remaining platform functions from src/platform-*.cc into libuv.

- Get rid of waf. Waf is an ugly build system. All platforms will build
  using gyp. (Ben)

- Extensions. We need to define an easy and suggested way of building
  extensions, which should be similar across all supported platforms. (Bert,
  Ben)

- Isolates. Node will allow users to spawn "child processes" that actually
  run in a thread. We have to get rid of all the global variables in node.
  Compiled extensions need know which isolate they're targeting, and we need
  to decide if we want to load the extension multiple times or just once.
  Also, some changes to libuv are necessary, since we will have to completely
  clean up a loop. Finally we'll have to deal with debugging a multi-threaded
  node process. (Node work: Ryan, Ben; Libuv work: all)

- fs.watch() improvements. We need to have decent fallback mechanism for 
  supporting remote filesystems. Also, we need to define its semantics more 
  clearly (for example, what happens when a watched object gets deleted or 
  renamed?) and make sure behavior is the same on all platforms. (all)

- Domains. Domains provide a lightweight isolation mechanism for all i/o
  related to a particular network connection (e.g. an incoming http request).
  If an unhandled error is encountered, all i/o local to that particular
  domain is canceled and all handles are cleaned up. An experimental
  implementation can be found at
  https://github.com/joyent/node/commits/domains. (Bert, Ryan)

- Better slab allocator. Currently node uses a slab allocator to provide
  read buffers for incoming data streams. This slab allocator is only
  reasonably efficient for network connections and local pipes on Unix, and on
  Windows when zero reads are used. For file i/o and buffered reads on Windows
  we need a better story. (Igor)

- Streams. The streams api is currently too complicated, it is very difficult
  for people to define their own stream class that plays nice with Stream.pipe.
  The api should be streamlined, naming should be more consistent and easy
  to understand. Stream.pipe should be used within node's core where possible
  instead of relying on some ad-hoc pipe implementation. (Isaac)