var cat = new node.Process("cat");
 cat.onOutput = function (chunk) {
   puts("cat said: " + chunk);
 };
 cat.onExit = function (status) {
   puts("cat exited with status " + status);
 };
 cat.write("hello");
 cat.write(" ");
 cat.write("world");
 cat.close();

var cat = popen("cat");

cat.onOutput = function (chunk) {
  puts("cat said: '" + chunk + "'");
};

cat.onExit = function (code) {
  puts("the cat program exited with code " + code);
};

cat.write("hello world");
cat.close();
cat.kill(); 

for i in $HOME/local/*; do
  [ -d $i/bin ] && PATH="${i}/bin:${PATH}"
  [ -d $i/include ] && CPATH="${i}/include:${CPATH}"
  [ -d $i/lib ] && LD_LIBRARY_PATH="${i}/lib:${LD_LIBRARY_PATH}"
  [ -d $i/lib/pkgconfig ] && PKG_CONFIG_PATH="${i}/lib/pkgconfig:${PKG_CONFIG_PATH}"
  [ -d $i/share/man ] && MANPATH="${i}/share/man:${MANPATH}"
done

process : computer
 thread : core

evan

[...] When you have that much memory it's difficult to actually make use of all of it from a language like JavaScript because it's single-threaded. That is, the time it takes to read in and out (or more importantly, process) that much data starts making apps that would use more data unuseful. He suggested that part of the reason 64-bit Java was important was that there were these heavyweight servers with multiple cores that wanted to run a bunch of Java threads in the same heap simultaneously.

There's an interesting parallel here to servers. Say you can stick 10 terabytes of disk in a single machine -- it ends up not being too useful as a server unless it's archival, as in most of that data isn't accessed, because you're ultimately limited by disk bandwidth. Just trying to stream the contents of the disks at a sequential 50mb/sec** would take two and a half days. So when you're trying to serve real-time data off a disk (like, say, a search engine might) you're better off having more machines with smaller disks.

A TCP connection may terminate in two ways:

1. the normal TCP close sequence using a FIN handshake, and
2. an "abort" in which one or more RST segments are sent and the connection state is immediately discarded.

If a TCP connection is closed by the remote site, the local application MUST be informed whether it closed normally or was aborted.

The normal TCP close sequence delivers buffered data reliably in both directions. Since the two directions of a TCP connection are closed independently, it is possible for a connection to be "half closed," i.e., closed in only one direction, and a host is permitted to continue sending data in the open direction on a half-closed connection.

A host MAY implement a "half-duplex" TCP close sequence, so that an application that has called CLOSE cannot continue to read data from the connection. If such a host issues a CLOSE call while received data is still pending in TCP, or if new data is received after CLOSE is called, its TCP SHOULD send a RST to show that data was lost.

When a connection is closed actively, it MUST linger in TIME-WAIT state for a time 2xMSL (Maximum Segment Lifetime). However, it MAY accept a new SYN from the remote TCP to reopen the connection directly from TIME-WAIT state, if it:

1. assigns its initial sequence number for the new connection to be larger than the largest sequence number it used on the previous connection incarnation, and
2. returns to TIME-WAIT state if the SYN turns out to be an old duplicate.

DISCUSSION:

TCP's full-duplex data-preserving close is a feature that is not included in the analogous ISO transport protocol TP4.

Some systems have not implemented half-closed connections, presumably because they do not fit into the I/O model of their particular operating system. On these systems, once an application has called CLOSE, it can no longer read input data from the connection; this is referred to as a "half-duplex" TCP close sequence.

The graceful close algorithm of TCP requires that the connection state remain defined on (at least) one end of the connection, for a timeout period of 2xMSL, i.e., 4 minutes. During this period, the (remote socket, local socket) pair that defines the connection is busy and cannot be reused. To shorten the time that a given port pair is tied up, some TCPs allow a new SYN to be accepted in TIME-WAIT state.

client-program   client-kernel   server-kernel  server-program
      |                |               |              |
      |--shutdown()--->|               |              |        client: shutdown(fd, SHUT_WR)
      |                |-----FIN------>|              |
      |                |               |--read EOF--->|        server: read() returns 0
      |                |<----ACK-------|              |
      |                |               |              |
      |                |               |              |
      |                |      .        |              |
      |                |      .        |              |
      |                |      .        |              |
      |                |               |              |
      |                |               |              |
      |                |               |<--write()----|        server: optionally still writes data
      |                |<--------------|              |
      |<--- read()-----|               |              |        client: still reads data as normal
      |                |-----ACK------>|              |
      |                |               |<--write()----|
      |                |<--------------|              |
      |<--- read()-----|               |              |        client: still reads data as normal
      |                |-----ACK------>|              |
      |                |               |              |
      |                |               |              |
      |                |      .        |              |
      |                |      .        |              |
      |                |      .        |              |
      |                |               |              |
      |                |               |              |
      |                |               |<--close()----|        server: close(fd) or shutdown(fd, SHUT_WR)
      |                |<-----FIN------|              |                both have the same effect 
      |<--read EOF ----|               |              |        client: read() returns 0
      |                |-----ACK------>|              |
      |---close()----->|               |              |        client: close(fd)

    * No dependencies
    * Parses both requests and responses.
    * Handles keep-alive streams.
    * Decodes chunked encoding.
    * Extracts the following data from a message
          o header fields and values
          o content-length
          o request method
          o response status code
          o transfer-encoding
          o http version
          o request path, query string, fragment
          o message body

They are connecting on the Internet, holding meet-ups in bars, advertising on billboards and buses, volunteering at food pantries and picking up roadside trash, earning atheist groups recognition on adopt-a-highway signs.

They liken their strategy to that of the gay-rights movement, which lifted off when closeted members of a scorned minority decided to go public.

“It’s not about carrying banners or protesting,” said Herb Silverman, a math professor at the College of Charleston who founded the Secular Humanists of the Lowcountry, which has about 150 members on the coast of the Carolinas. “The most important thing is coming out of the closet.”

Polls show that the ranks of atheists are growing. The American Religious Identification Survey, a major study released last month, found that those who claimed “no religion” were the only demographic group that grew in all 50 states in the last 18 years.