What differentiates dialog from the simple Chain Model of Communication?

number of the interlocutors (sender/receiver pairs)
	-> at least two (strict dialog vs. multi-party dialogue)
two-way communication (bi-directional channel)
	¬ two channels, one channel is enough
	time-division multiplexing (half-duplex)
	¬ frequency-division multiplexing
turn-taking: find out who is supposed to speak
floor-tracking: "to hold the floor"
	→ one way communication or two-way
many ways of the dialog failing (not just turn-taking)
responses
many concepts and ideas are being interchanged
visual cues (gestures, facial expressions) beyond "plain" speech
contextual knowledge (shared among the interlocutors) 
	that's already necessary for decoding one-way communication. In fact, the requirement for contextual knowledge in dialog might be smaller because I can always ask back to clarify something


What's important to mark turn-taking?

silence: length of the pause is indicative
	-> but pauses can also come within turns
	-> pauses too long (when it becomes awkward; ~ 2seconds)
	-> minimum duration of pauses (between 2 seconds why not overlap?)
sentence-ending particles (DE: "ne?", EN: "right?"/"isn't it?")
sentence/question is complete (syntactically/semantically/pragmatic)
help out when the interlocutor is struggling for words: "Co-completion"
	-> carry on conversation or manipulate other speaker
sentence-final intonation marking
!!!interruption!!!
facial expression, non-verbal feedback
	body language, eye-movement, attention
verbal invitation / verbal next-speaker selection
cultural differences / individual differences


Reductionist vs. Connectionist models:

below, B stands for blackboards (connectionist architecture), 
P stands for pipelines (reductionist architecture): 

B+: central unit, makes things more simple?
B-: just a central data structure, not a "unit" that would itself be useful
B-: alternative requirements result from the whiteboard (e.g. different modules request the system to say two different things at the same time)
B-: no centralized control (every module can do anything)
B+: reduces complexity (easier to add modules)
B-: increases complexity (what happens with the information on the blackboard?)
B+: easier to use different kinds of information
P+: few connections → few places for error
P-: very limited (no backward flows, no skipping, ...)
P-: failing modules will mean full failure
B+: failing modules might be substituted by others
B/P: information fusion: probably also possible by joining parallel pipelines
B-: horrible concurrency issues, whereas this is simple in P