diff --git a/src/main/java/org/apache/ode/jacob/Jacob.java b/src/main/java/org/apache/ode/jacob/Jacob.java
index cc7570c..51967c0 100644
--- a/src/main/java/org/apache/ode/jacob/Jacob.java
+++ b/src/main/java/org/apache/ode/jacob/Jacob.java
@@ -41,7 +41,7 @@
      *
      * @param concretion the concretion of a process template
      */
-    public static void instance(Runnable concretion) {
+    public static void instance(RunnableProcess concretion) {
         JacobVPU.activeJacobThread().instance(concretion);
     }
 
diff --git a/src/main/java/org/apache/ode/jacob/oo/ProcessUtil.java b/src/main/java/org/apache/ode/jacob/oo/ProcessUtil.java
index b7e61a6..5b9fabd 100644
--- a/src/main/java/org/apache/ode/jacob/oo/ProcessUtil.java
+++ b/src/main/java/org/apache/ode/jacob/oo/ProcessUtil.java
@@ -18,10 +18,22 @@
  */
 package org.apache.ode.jacob.oo;
 
+import java.util.Arrays;
+
+import org.apache.ode.jacob.RunnableProcess;
 import org.apache.ode.jacob.vpu.JacobVPU;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static org.apache.ode.jacob.Jacob.instance;
+import static org.apache.ode.jacob.Jacob.newChannel;
+import static org.apache.ode.jacob.Jacob.object;
 
 
 public final class ProcessUtil {
+	// TODO: add more logging at TRACE level
+    private static final Logger LOG = LoggerFactory.getLogger(ProcessUtil.class);
+
     private ProcessUtil() {
         // Utility class
     }
@@ -49,4 +61,178 @@
     	return new ReceiveProcess().setChannel(proxy).setReceiver(listener);
     }
 
+	/**
+	 * 
+	 * @return	A noop RunnableProcess
+	 */
+	public static RunnableProcess nil() {
+		return new Nil();
+	}
+
+	/**
+	 * 
+	 * @param callback
+	 * @return a RunnableProcess that wraps a return notification in a separate process
+	 * 
+	 */
+	public static RunnableProcess terminator(final Synch callback) {
+		return callback != null ? new Terminator(callback) : null;
+	}
+
+	/**
+	 * 
+	 * @param callback
+	 * @param process
+	 * @return
+	 * 
+	 * Returns a synchronized process embedding the runnable process. Once the process finishes it 
+	 * will notify that on the callback return channel
+	 */
+    public static Synchronized sync(final Synch callback, final RunnableProcess process) {
+    	return new SynchronizedWrapper(callback, process);
+    }
+
+	/**
+	 * 
+	 * @param callback
+	 * @param process
+	 * @return
+	 * 
+	 * Intercepts the execution of a synchronized process and executes an interceptor before the 
+	 * termination of the process is actually signaled
+	 */
+	public static Synchronized intercept(final Synchronized process, final RunnableProcess interceptor) {
+		if (interceptor == null) {
+			return process;
+		}
+		Synch callback = newChannel(Synch.class, "");
+		object(receive(callback, new InterceptorSynch(process.getCallback(), interceptor)));
+		process.setCallback(callback);
+		return process;
+    }
+
+	/**
+	 * 
+	 * @param processes
+	 * @return a Synchronized process
+	 * 
+	 * Ensures the sequential execution of processes
+	 */
+	public static Synchronized sequence(final RunnableProcess... processes) {
+    	return sequence(null, processes);
+    }
+
+	/**
+	 * 
+	 * @param callback
+	 * @param processes
+	 * @return
+	 * 
+	 * Ensures the sequential execution of processes. After the execution is complete a 
+	 * notification is sent to the callback channel
+	 */
+    public static Synchronized sequence(final Synch callback, final RunnableProcess... processes) {
+    	return new SequenceProcess(callback, processes);
+    }
+
+    // Helpers Process composers
+
+    /**
+     * TODO: Document me
+     */
+    public static class Nil extends RunnableProcess {
+		private static final long serialVersionUID = 1L;
+		public void run() {
+			// do nothing
+		}
+    }
+
+    /**
+     * TODO: Document me
+     */
+    public static class Terminator extends RunnableProcess {
+		private static final long serialVersionUID = 1L;
+		protected Synch callback;
+		public Terminator(final Synch callback) {
+			this.callback = callback;
+		}
+		public Synch getCallback() {
+			return callback;
+		}
+		public void run() {
+			callback.ret();
+		}
+    }
+
+    public static abstract class Synchronized extends RunnableProcess {
+		private static final long serialVersionUID = 1L;
+		protected Synch callback;
+
+		public abstract void execute();
+
+		public Synchronized(final Synch callback) {
+			setCallback(callback);
+		}
+		public Synch getCallback() {
+			return callback;
+		}
+		public void setCallback(final Synch callback) {
+			this.callback = callback;
+		}
+		public void run() {
+			execute();
+			if (callback != null) {
+				callback.ret();
+			}
+		}
+    }
+
+    public static class SynchronizedWrapper extends Synchronized {
+		private static final long serialVersionUID = 1L;
+		protected final RunnableProcess process;
+		public SynchronizedWrapper(final Synch callback, final RunnableProcess process) {
+			super(callback);
+			this.process = process;
+		}
+		public void execute() {
+			process.run();
+		}
+    }
+
+    public static final class InterceptorSynch implements Synch {
+		private static final long serialVersionUID = 1L;
+		protected final RunnableProcess interceptor;
+		private final Synch target;
+		public InterceptorSynch(final Synch target, final RunnableProcess interceptor) {
+			this.target = target;
+			this.interceptor = interceptor;
+		}
+		public void ret() {
+			instance(sync(target, interceptor));
+		}
+    }
+
+    public static final class SequenceProcess extends Synchronized {
+		private static final long serialVersionUID = 1L;
+		private final RunnableProcess[] processes;
+
+		public SequenceProcess(final Synch callback, final RunnableProcess[] processes) {
+			super(callback);
+			this.processes = processes;
+		}
+
+		public void execute() {
+			// can only sequence synchronized processes
+			final Synchronized current = ensureSynchronized(processes[0]);
+			instance(intercept(current, processes.length > 1 ? 
+				sequence(this.callback, Arrays.copyOfRange(processes, 1, processes.length)) :
+				terminator(this.callback)));
+			this.callback = null;
+		}
+		
+		public Synchronized ensureSynchronized(RunnableProcess process) {
+			return process instanceof Synchronized ? (Synchronized)process : sync(null, process);
+		}
+    }
+
 }
diff --git a/src/main/java/org/apache/ode/jacob/vpu/JacobVPU.java b/src/main/java/org/apache/ode/jacob/vpu/JacobVPU.java
index c709a95..72e33ce 100644
--- a/src/main/java/org/apache/ode/jacob/vpu/JacobVPU.java
+++ b/src/main/java/org/apache/ode/jacob/vpu/JacobVPU.java
@@ -27,6 +27,7 @@
 import org.apache.ode.jacob.JacobThread;
 import org.apache.ode.jacob.Message;
 import org.apache.ode.jacob.MessageListener;
+import org.apache.ode.jacob.RunnableProcess;
 import org.apache.ode.jacob.oo.Channel;
 import org.apache.ode.jacob.oo.ChannelListener;
 import org.apache.ode.jacob.oo.ClassUtil;
@@ -175,7 +176,7 @@
      * the injected process. This method is equivalent to the parallel operator,
      * but is intended to be used from outside of an active {@link JacobThread}.
      */
-    public void inject(Runnable concretion) {
+    public void inject(RunnableProcess concretion) {
         LOG.debug("injecting {}", concretion);
         addReaction(concretion, ClassUtil.RUN_METHOD_ACTION, new Class[]{},
             (LOG.isInfoEnabled() ? concretion.toString() : null));
diff --git a/src/test/java/org/apache/ode/jacob/examples/helloworld/HelloWorld.java b/src/test/java/org/apache/ode/jacob/examples/helloworld/HelloWorld.java
index 4dac54a..5165f8b 100644
--- a/src/test/java/org/apache/ode/jacob/examples/helloworld/HelloWorld.java
+++ b/src/test/java/org/apache/ode/jacob/examples/helloworld/HelloWorld.java
@@ -296,7 +296,7 @@
 		}
 
 		@Override
-		protected Runnable doStep(int step, Synch done) {
+		protected RunnableProcess doStep(int step, Synch done) {
 			return new SequenceItemEmitter(greetings[step], done, out);
         }
 
diff --git a/src/test/java/org/apache/ode/jacob/examples/sequence/Sequence.java b/src/test/java/org/apache/ode/jacob/examples/sequence/Sequence.java
index 8ea152c..c7b7e6c 100644
--- a/src/test/java/org/apache/ode/jacob/examples/sequence/Sequence.java
+++ b/src/test/java/org/apache/ode/jacob/examples/sequence/Sequence.java
@@ -68,7 +68,7 @@
      * @param done notification after step completion
      * @return runnable process
      */
-    protected abstract Runnable doStep(int step, Synch done);
+    protected abstract RunnableProcess doStep(int step, Synch done);
 
     public static class SequenceData {
         public int _steps;
diff --git a/src/test/java/org/apache/ode/jacob/oo/JacobChannelsTest.java b/src/test/java/org/apache/ode/jacob/oo/JacobChannelsTest.java
index c68c7f4..e11a517 100644
--- a/src/test/java/org/apache/ode/jacob/oo/JacobChannelsTest.java
+++ b/src/test/java/org/apache/ode/jacob/oo/JacobChannelsTest.java
@@ -25,6 +25,7 @@
 import java.util.ArrayList;
 import java.util.List;
 
+import org.apache.ode.jacob.RunnableProcess;
 import org.apache.ode.jacob.soup.CommChannel;
 import org.apache.ode.jacob.vpu.ChannelFactory;
 import org.apache.ode.jacob.vpu.ExecutionQueueImpl;
@@ -55,7 +56,7 @@
         vpu.setContext(new ExecutionQueueImpl());
 
         final List<String> result = new ArrayList<String>();
-        vpu.inject(new Runnable() {
+        vpu.inject(new RunnableProcess() {
             public void run() {
                 Val v = (Val)vpu.newChannel(Val.class, "");
                 object(receive(v, new Val() {
@@ -88,7 +89,7 @@
         vpu.setContext(new ExecutionQueueImpl());
 
         final List<String> result = new ArrayList<String>();
-        vpu.inject(new Runnable() {
+        vpu.inject(new RunnableProcess() {
             public void run() {
                 Val v = (Val)vpu.newChannel(Val.class, "");
                 object(ProcessUtil.compose(receive(v, new Val() {
diff --git a/src/test/java/org/apache/ode/jacob/oo/SequentialProcessingTest.java b/src/test/java/org/apache/ode/jacob/oo/SequentialProcessingTest.java
new file mode 100644
index 0000000..1bd938c
--- /dev/null
+++ b/src/test/java/org/apache/ode/jacob/oo/SequentialProcessingTest.java
@@ -0,0 +1,269 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.ode.jacob.oo;
+
+
+import org.apache.ode.jacob.Jacob;
+import org.apache.ode.jacob.RunnableProcess;
+import org.apache.ode.jacob.oo.ProcessUtil.Synchronized;
+import org.apache.ode.jacob.vpu.ExecutionQueueImpl;
+import org.apache.ode.jacob.vpu.JacobVPU;
+import org.junit.Assert;
+import org.junit.Test;
+
+import static org.apache.ode.jacob.Jacob.instance;
+import static org.apache.ode.jacob.Jacob.object;
+import static org.apache.ode.jacob.oo.ProcessUtil.intercept;
+import static org.apache.ode.jacob.oo.ProcessUtil.receive;
+import static org.apache.ode.jacob.oo.ProcessUtil.sequence;
+import static org.apache.ode.jacob.oo.ProcessUtil.sync;
+
+
+public class SequentialProcessingTest {
+
+    @SuppressWarnings("serial")
+	@Test
+    public void testParallelProcesses() {
+    	final StringBuffer out = new StringBuffer();
+    	executeProcess(new RunnableProcess() {
+			public void run() {
+				instance(intercept(sync(null, atomicProcess("A", out)), atomicProcess("0", out)));
+				instance(intercept(sync(null, atomicProcess("B", out)), atomicProcess("1", out)));
+			}
+        });
+    	// parallelism is proven by process "B" being executed before "A0" and "A1"
+    	Assert.assertEquals("AB01", out.toString());
+    }
+
+    @SuppressWarnings("serial")
+	@Test
+    public void testSynchronizeProcess() {
+    	final StringBuffer out = new StringBuffer();
+    	executeProcess(new RunnableProcess() {
+			public void run() {
+		        Synch c1 = Jacob.newChannel(Synch.class, "");
+		        object(receive(c1, new Synch() {
+					public void ret() {
+						out.append("x");
+					}
+				}));
+				instance(sync(c1, atomicProcess("A", out)));
+			}
+        });
+    	// Return hook "x" is executed after process "A" 
+    	Assert.assertEquals("Ax", out.toString());
+    }
+
+    @SuppressWarnings("serial")
+	@Test
+    public void testSynchronizeSynchronizedProcess() {
+    	final StringBuffer out = new StringBuffer();
+    	executeProcess(new RunnableProcess() {
+			public void run() {
+		        Synch c1 = Jacob.newChannel(Synch.class, "");
+		        object(receive(c1, new Synch() {
+					public void ret() {
+						out.append("x");
+					}
+				}));
+		        Synch c2 = Jacob.newChannel(Synch.class, "");
+		        object(receive(c2, new Synch() {
+					public void ret() {
+						out.append("y");
+					}
+				}));
+		        Synchronized process = synchronizedProcess(c1, "S", out);
+				instance(sync(c2, process));
+			}
+        });
+    	// Both return hooks "x" and "y" are executed after synchronized process "S" 
+    	Assert.assertEquals("Sxy", out.toString());
+    }
+
+    @SuppressWarnings("serial")
+	@Test
+    public void testInterceptProcess() {
+    	final StringBuffer out = new StringBuffer();
+    	executeProcess(new RunnableProcess() {
+			public void run() {
+		        Synch c1 = Jacob.newChannel(Synch.class, "");
+		        object(receive(c1, new Synch() {
+					public void ret() {
+						out.append("x");
+					}
+				}));
+				instance(intercept(sync(c1, atomicProcess("A", out)), atomicProcess("B", out)));
+			}
+        });
+    	// Return interceptor "B" is executed after process "A", but before the hook "x" 
+    	Assert.assertEquals("ABx", out.toString());
+    }
+
+    @SuppressWarnings("serial")
+	@Test
+    public void testInterceptSynchronizedProcess() {
+    	final StringBuffer out = new StringBuffer();
+    	executeProcess(new RunnableProcess() {
+			public void run() {
+		        Synch c1 = Jacob.newChannel(Synch.class, "");
+		        object(receive(c1, new Synch() {
+					public void ret() {
+						out.append("x");
+					}
+				}));
+		        Synch c2 = Jacob.newChannel(Synch.class, "");
+		        object(receive(c2, new Synch() {
+					public void ret() {
+						out.append("y");
+					}
+				}));
+				instance(intercept(sync(c1, atomicProcess("A", out)), sync(c2, atomicProcess("B", out))));
+			}
+        });
+    	// Return interceptor "B" is executed after process "A", but before the hook "x" 
+    	Assert.assertEquals("AByx", out.toString());
+    }
+
+    @SuppressWarnings("serial")
+    @Test
+    public void testSimpleSequence() {
+    	final StringBuffer out = new StringBuffer();
+    	executeProcess(new RunnableProcess() {
+			public void run() {
+				Jacob.instance(sequence(
+			        atomicProcess("A", out), 
+			        atomicProcess("B", out), 
+			        atomicProcess("C", out)));
+			}
+        });
+    	// TODO: explain 
+    	Assert.assertEquals("ABC", out.toString());
+    }
+
+    @SuppressWarnings("serial")
+    @Test
+    public void testSynchronizedSequence() {
+    	final StringBuffer out = new StringBuffer();
+    	executeProcess(new RunnableProcess() {
+			public void run() {
+		        Synch c1 = Jacob.newChannel(Synch.class, "");
+		        object(receive(c1, new Synch() {
+					public void ret() {
+						out.append("x");
+					}
+				}));
+				Jacob.instance(sequence(c1,
+			        atomicProcess("A", out), 
+			        atomicProcess("B", out), 
+			        atomicProcess("C", out), 
+			        atomicProcess("D", out)));
+			}
+        });
+    	// TODO: explain 
+    	Assert.assertEquals("ABCDx", out.toString());
+    }
+
+    @SuppressWarnings("serial")
+    @Test
+    public void testTransitiveSequence() {
+    	final StringBuffer out = new StringBuffer();
+    	executeProcess(new RunnableProcess() {
+			public void run() {
+		        Synch c1 = Jacob.newChannel(Synch.class, "");
+		        object(receive(c1, new Synch() {
+					public void ret() {
+						out.append("x");
+					}
+				}));
+				Jacob.instance(sequence(c1,
+			        atomicProcess("A", out), 
+			        sequence(atomicProcess("B", out), atomicProcess("C", out)), 
+			        atomicProcess("D", out)));
+			}
+        });
+    	// TODO: explain 
+    	Assert.assertEquals("ABCDx", out.toString());
+    }
+
+    @SuppressWarnings("serial")
+    @Test
+    public void testSequenceComposition() {
+    	final StringBuffer out = new StringBuffer();
+    	executeProcess(new RunnableProcess() {
+			public void run() {
+		        Synch c1 = Jacob.newChannel(Synch.class, "");
+		        object(receive(c1, new Synch() {
+					public void ret() {
+						out.append("x");
+					}
+				}));
+		        Synch c2 = Jacob.newChannel(Synch.class, "");
+		        object(receive(c2, new Synch() {
+					public void ret() {
+						out.append("y");
+					}
+				}));
+		        // just test a more complex scenario once
+				Jacob.instance(sequence(c1,
+				    sequence(
+				        sequence(
+				        	atomicProcess("A", out),
+				        	atomicProcess("B", out),
+				        	atomicProcess("C", out)),
+				        atomicProcess("D", out)), 
+				    atomicProcess("E", out), 
+			        sequence(c2,
+			        	atomicProcess("F", out), 
+		        	    sequence(
+		        	    	atomicProcess("G", out),
+        	                atomicProcess("H", out)))));
+			}
+        });
+    	// TODO: explain 
+    	Assert.assertEquals("ABCDEFGHxy", out.toString());
+    }
+
+    @SuppressWarnings("serial")
+	protected RunnableProcess atomicProcess(final String id, final StringBuffer out) {
+    	return new RunnableProcess() {
+			public void run() {
+				out.append(id);
+			}
+    	};
+    }
+
+    @SuppressWarnings("serial")
+	protected Synchronized synchronizedProcess(final Synch callback, final String id, final StringBuffer out) {
+    	return new Synchronized(callback) {
+			public void execute() {
+				out.append(id);
+			}
+    	};
+    }
+    
+    protected void executeProcess(final RunnableProcess process) {
+        final JacobVPU vpu = new JacobVPU();
+        vpu.setContext(new ExecutionQueueImpl());
+        vpu.inject(process);
+        while (vpu.execute()) {
+            // keep doing it...
+        }
+    }
+
+}
diff --git a/src/test/java/org/apache/ode/jacob/vpu/ChannelRefTest.java b/src/test/java/org/apache/ode/jacob/vpu/ChannelRefTest.java
index b50e45b..50ccad9 100644
--- a/src/test/java/org/apache/ode/jacob/vpu/ChannelRefTest.java
+++ b/src/test/java/org/apache/ode/jacob/vpu/ChannelRefTest.java
@@ -1,69 +1,71 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-package org.apache.ode.jacob.vpu;
-
-import static org.apache.ode.jacob.Jacob.newCommChannel;
-import static org.junit.Assert.*;
-import org.apache.ode.jacob.ChannelRef;
-import org.apache.ode.jacob.oo.Synch;
-import org.apache.ode.jacob.oo.Val;
-import org.apache.ode.jacob.soup.CommChannel;
-
-import org.junit.Test;
-
-public class ChannelRefTest {
-
-    @Test
-    public void testConnectWithInterface() {
-        JacobVPU vpu = new JacobVPU();
-        vpu.setContext(new ExecutionQueueImpl());
-        
-        vpu.inject(new Runnable() {
-            @Override
-            public void run() {
-                ChannelRef cref = newCommChannel("unbound channel");
-                CommChannel cchannel = cref.getEndpoint(CommChannel.class);
-                assertNotNull(cchannel);
-                assertNull(cchannel.getType());
-                
-                // now connect it to Val.class
-                Val val = cref.getEndpoint(Val.class);
-                assertNotNull(val);
-                assertEquals(Val.class, cchannel.getType());
-                
-                // now try to associate it with a different channel interface
-                try {
-                    cref.getEndpoint(Synch.class);
-                    fail("we should get an IllegalStateException");
-                } catch (IllegalStateException e) {
-                    assertEquals("ChannelRef is already associated with a channel of a different type", e.getMessage());
-                }
-                
-                // now try to associate with the same channel
-                Val val2 = cref.getEndpoint(Val.class);
-                assertNotNull(val2);
-                assertSame(val, val2);
-            }
-        });
-        
-        assertEquals(true, vpu.getContext().hasReactions());
-        vpu.execute();
-        assertEquals(false, vpu.getContext().hasReactions());
-    }
-}
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.ode.jacob.vpu;
+
+import static org.apache.ode.jacob.Jacob.newCommChannel;
+import static org.junit.Assert.*;
+
+import org.apache.ode.jacob.ChannelRef;
+import org.apache.ode.jacob.RunnableProcess;
+import org.apache.ode.jacob.oo.Synch;
+import org.apache.ode.jacob.oo.Val;
+import org.apache.ode.jacob.soup.CommChannel;
+import org.junit.Test;
+
+public class ChannelRefTest {
+
+    @Test
+    public void testConnectWithInterface() {
+        JacobVPU vpu = new JacobVPU();
+        vpu.setContext(new ExecutionQueueImpl());
+
+        vpu.inject(new RunnableProcess() {
+            @Override
+            public void run() {
+                ChannelRef cref = newCommChannel("unbound channel");
+                CommChannel cchannel = cref.getEndpoint(CommChannel.class);
+                assertNotNull(cchannel);
+                assertNull(cchannel.getType());
+
+                // now connect it to Val.class
+                Val val = cref.getEndpoint(Val.class);
+                assertNotNull(val);
+                assertEquals(Val.class, cchannel.getType());
+
+                // now try to associate it with a different channel interface
+                try {
+                    cref.getEndpoint(Synch.class);
+                    fail("we should get an IllegalStateException");
+                } catch (IllegalStateException e) {
+                    assertEquals("ChannelRef is already associated with a channel of a different type", e.getMessage());
+                }
+
+                // now try to associate with the same channel
+                Val val2 = cref.getEndpoint(Val.class);
+                assertNotNull(val2);
+                assertSame(val, val2);
+            }
+        });
+
+        assertEquals(true, vpu.getContext().hasReactions());
+        vpu.execute();
+        assertEquals(false, vpu.getContext().hasReactions());
+    }
+
+}
diff --git a/src/test/resources/log4j.properties b/src/test/resources/log4j.properties
index 91bd688..c1d9d01 100644
--- a/src/test/resources/log4j.properties
+++ b/src/test/resources/log4j.properties
@@ -16,10 +16,11 @@
 #
 
 # Set root logger level to WARN and its only appender to CONSOLE
-log4j.rootLogger=TRACE, file
+log4j.rootLogger=INFO, file
 
 # log4j properties to work with command line tools.
-log4j.category.org.apache.ode=TRACE
+log4j.category.org.apache.ode=DEBUG
+#log4j.category.org.apache.ode.jacob.oo=TRACE
 
 # Console appender
 log4j.appender.stdout=org.apache.log4j.ConsoleAppender