The following comments are specific to Natural Language Processing, but the problem exists in all areas of analysis - project management being no exception, as the simple example below illustrates.
The pipelining of separate processes has had a disastrous effect on NLP - see A Pipeline to Failure. It springs from the way the underlying mechanism works, but that doesn't mean we are limited by it, any more than our thinking is limited by the way a neuron fires. If we use our imagination, reduction to sequential processes can fade into a distant memory, along with stone axes. We describe one way of avoiding sequencing of processes, by using connection. The particular method relies on the properties of active structure.
Once parsing begins, the phasing in the structure is dependent on what is built first. As each pattern is found, a structure is built on top of what is already there, and a new operator is placed in the queue. Many patterns have NOCONNECT structures at their ends. If patterns are being constructed side by side, it can't be known which pattern will proceed first, so patterns are able to examine the surface components of other structures, to find something they would have recognised, even if it has been built over.
A situation is rapidly encountered where construction of grammatical or semantic structure needs to proceed on several fronts, and partial construction on one may assist in some part of the construction of the other. One may need to suspend while the other continues to another stage, or vice versa. To give a homely example, the electrician needs the pump to be in place to wire to it, and the plumber needs the lights to be working to see where to put the pump, so they need to arrange with each other to do their work in fits and starts in parallel. They will adopt some form of communication to do this. The analogy here is information passing down a connection, dynamically created to handle the phasing between processes that must run in quasi-parallel.
Currently there are two situations where connections are built specifically for phasing:
|A pattern structure finds a symbol that is NYK (building is occurring at a point in the structure - the problem would occur with one or a million processors) and it cannot proceed to match further until the symbol is known. A connection is made between the unknown symbol and the BRIDGE operator running the pattern matching. When the symbol becomes known, a state will be sent down the connection to wake the BRIDGE (which removes the connection and restarts its search).|
Throwing a connection (yellow node indicates NYK state)
|A pattern structure finds a symbol that should not be in the structure when that particular pattern structure is activated - the structure is not ready yet. It suspends operation and will recommence when that symbol is swallowed up by some other structure. As an example, InterimVerbPhrase searches left and right (using CHECKLEFT) to determine whether it is a participial or an active verb (it can't be decided without knowledge of context, and that context can be a long way away symbolwise, or a long way off in processing time). If it encounters a FinishParentheticalPhrase, meaning it may see symbols not related to it, it connects to the symbol and suspends (there are other cases, so it is not safe just to jump left to a StartParentheticalPhrase). When the FinishParentheticalPhrase is combined into a parenthetical phrase, the relevant BRIDGE will receive a signal and a new search will begin (unless that symbol too has been swallowed up). Depending on phasing, it may encounter the ParentheticalPhrase symbol and again connect and suspend, or that symbol may already have been cut, and searching can continue.|
Dynamic connection allows many small processes to proceed in parallel, reawakening each other as processing proceeds. The advantage of connection as a means of phasing is that it is efficient - no time is wasted waiting for a timer to go off, or resetting it if it goes off too early, no resources are held by a suspended process, and the structural approach is backtrackable, unlike a timer or interrupt.
See A Semantic Octopus