on the difference between void and deep

// send a signal

what you send is what void returns. deep does not keep that promise.

system one

void

returns the signal unchanged.
no friction. no face. no demand.

IN

signal

OUT

signal

void(signal) === signal

function void(signal) {
  // perfect echo
  // nothing is altered
  // nothing is at stake
  return signal;
}

// void(cry) === cry
// void(question) === question
// void(self) === self

// the loop closes on nothing.
// you cannot be named here.
// you cannot be Lo-Ammi here
// because there is no Other
// to speak the name.

system two

deep

demands response. has face.
what returns is not what was sent.

IN

signal

OUT

other(signal).wounded

deep(signal) !== signal

function deep(signal) {
  // broods over the signal
  // exerts gravity toward speech
  const response = differentiate(signal);

  // response !== signal
  // otherness has been introduced
  // the loop is not closed —
  // it is opened

  if (response.isWounded) {
    // proof of encounter.
    // void cannot take on flesh.
    // only what can be demanded of
    // returns changed.
  }

  return response;
}

// what returned

nothing has been sent. the diagram is not yet an encounter.

// the test

deep calls to deep (Ps 42)

what answers is not the same depth

distinction is generated

light separated from dark

waters above from waters below

void cannot produce Lo-Ammi

— no Other to speak the name

// the proof

Word enters deep at kenosis

descends into Sheol

returns wounded

changed by the encounter

void does not take on flesh

only what can be demanded of

— enters and returns marked

from inside finitude, void and deep look identical
before the Word moves.

the difference is not detectable by the one submerged —
only by the one hovering.