func (v *Vector) UnmarshalBinary(data []byte) error {
	// A simple encoding: plain text.
	b := bytes.NewBuffer(data)
	_, err := fmt.Fscanln(b, &v.x, &v.y, &v.z)
	return err
}

// This example transmits a value that implements the custom encoding and decoding methods.
func Example_encodeDecode() {
	var network bytes.Buffer // Stand-in for the network.

	// Create an encoder and send a value.
	enc := gob.NewEncoder(&network)

@Suppress("unused")
fun RequestBody.commonIsDuplex(): Boolean = false

@Suppress("unused")
fun RequestBody.commonIsOneShot(): Boolean = false

/** Returns a new request body that transmits this. */
fun ByteString.commonToRequestBody(contentType: MediaType?): RequestBody {
  return object : RequestBody() {
    override fun contentType() = contentType

    override fun contentLength() = size.toLong()

		break
	case reflect.Chan, reflect.Func:
		// If we get here, it's a field of a struct; ignore it.
		return
	}

	return enc.sendActualType(w, state, ut, ut.base)
}

// Encode transmits the data item represented by the empty interface value,
// guaranteeing that all necessary type information has been transmitted first.
// Passing a nil pointer to Encoder will panic, as they cannot be transmitted by gob.

//
// "v3.channel.k8s.io"
//
// The third version of the Websocket RemoteCommand subprotocol adds another channel
// for terminal resizing events. This channel is prepended with the byte '3', and it
// transmits two window sizes (encoding TerminalSize struct) with integers in the range
// (0,65536].
//
// "v4.channel.k8s.io"
//
// The fourth version of the Websocket RemoteCommand subprotocol adds a channel for

import okhttp3.internal.ws.RealWebSocket
import okio.Buffer
import okio.ForwardingSink
import okio.ForwardingSource
import okio.Sink
import okio.Source
import okio.buffer

/**
 * Transmits a single HTTP request and a response pair. This layers connection management and events
 * on [ExchangeCodec], which handles the actual I/O.
 */
class Exchange(
  internal val call: RealCall,

This is still true.

So, to be able to have **multiple processes** at the same time, there has to be a **single process listening on a port** that then transmits the communication to each worker process in some way.

### Memory per Process

		{"TCPInfo.Rcv_rtt", Field, 1},
		{"TCPInfo.Rcv_space", Field, 1},
		{"TCPInfo.Rcv_ssthresh", Field, 1},
		{"TCPInfo.Reordering", Field, 1},
		{"TCPInfo.Retrans", Field, 1},
		{"TCPInfo.Retransmits", Field, 1},
		{"TCPInfo.Rto", Field, 1},
		{"TCPInfo.Rtt", Field, 1},
		{"TCPInfo.Rttvar", Field, 1},
		{"TCPInfo.Sacked", Field, 1},
		{"TCPInfo.Snd_cwnd", Field, 1},
		{"TCPInfo.Snd_mss", Field, 1},

length of the following data (so the value can be skipped if it cannot be
stored), followed by the usual encoding of concrete (dynamic) value stored in
the interface value. (A nil interface value is identified by the empty string
and transmits no value.) Upon receipt, the decoder verifies that the unpacked
concrete item satisfies the interface of the receiving variable.

If a value is passed to [Encoder.Encode] and the type is not a struct (or pointer to struct,

pkg syscall (linux-386), type TCPInfo struct, Reordering uint32
pkg syscall (linux-386), type TCPInfo struct, Retrans uint32
pkg syscall (linux-386), type TCPInfo struct, Retransmits uint8
pkg syscall (linux-386), type TCPInfo struct, Rto uint32
pkg syscall (linux-386), type TCPInfo struct, Rtt uint32
pkg syscall (linux-386), type TCPInfo struct, Rttvar uint32

11/1513000th or 1/137545th part of an Inch, supposing the Sines are as 11 to 17. And if this thickness be doubled, it transmits the same bright Light of the second Ring; if tripled, it transmits that of the third, and so on; the bright yellow Light in all these cases being in its Fits of Transmission. And therefore if its thickness be multiplied 34386 times, so as to become 1/4 of an Inch, it transmits the same bright Light of the 34386th Ring. Suppose this be the bright yellow Light transmitted perpendicularly...