Index: libcfa/src/concurrency/channel.hfa
===================================================================
--- libcfa/src/concurrency/channel.hfa	(revision 8bb46d2a7a3c03f09935c6ab002dd8ed478259f0)
+++ libcfa/src/concurrency/channel.hfa	(revision 1f951abd376df4a7064ad98779090e5e0ec9565c)
@@ -15,4 +15,128 @@
 static inline void   on_wakeup( no_reacq_lock & this, size_t recursion ) {}
 
+#define __PREVENTION_CHANNEL
+#ifdef __PREVENTION_CHANNEL
+forall( T ) {
+struct channel {
+    size_t size;
+    size_t front, back, count;
+    T * buffer;
+    thread$ * chair;
+    T * chair_elem;
+    exp_backoff_then_block_lock c_lock, p_lock;
+    __spinlock_t mutex_lock;
+};
+
+static inline void ?{}( channel(T) &c, size_t _size ) with(c) {
+    size = _size;
+    front = back = count = 0;
+    buffer = anew( size );
+    chair = 0p;
+    mutex_lock{};
+    c_lock{};
+    p_lock{};
+}
+
+static inline void ?{}( channel(T) &c ){ ((channel(T) &)c){ 0 }; }
+static inline void ^?{}( channel(T) &c ) with(c) { delete( buffer ); }
+static inline size_t get_count( channel(T) & chan ) with(chan) { return count; }
+static inline size_t get_size( channel(T) & chan ) with(chan) { return size; }
+static inline bool has_waiters( channel(T) & chan ) with(chan) { return chair != 0p; }
+
+static inline void insert_( channel(T) & chan, T & elem ) with(chan) {
+    memcpy((void *)&buffer[back], (void *)&elem, sizeof(T));
+    count += 1;
+    back++;
+    if ( back == size ) back = 0;
+}
+
+static inline void insert( channel(T) & chan, T elem ) with( chan ) {
+    lock( p_lock );
+    lock( mutex_lock __cfaabi_dbg_ctx2 );
+
+    // have to check for the zero size channel case
+    if ( size == 0 && chair != 0p ) {
+        memcpy((void *)chair_elem, (void *)&elem, sizeof(T));
+        unpark( chair );
+        chair = 0p;
+        unlock( mutex_lock );
+        unlock( p_lock );
+        unlock( c_lock );
+        return;
+    }
+
+    // wait if buffer is full, work will be completed by someone else
+    if ( count == size ) {
+        chair = active_thread();
+        chair_elem = &elem;
+        unlock( mutex_lock );
+        park( );
+        return;
+    } // if
+
+    if ( chair != 0p ) {
+        memcpy((void *)chair_elem, (void *)&elem, sizeof(T));
+        unpark( chair );
+        chair = 0p;
+        unlock( mutex_lock );
+        unlock( p_lock );
+        unlock( c_lock );
+        return;
+    }
+    else insert_( chan, elem );
+
+    unlock( mutex_lock );
+    unlock( p_lock );
+}
+
+static inline T remove( channel(T) & chan ) with(chan) {
+    lock( c_lock );
+    lock( mutex_lock __cfaabi_dbg_ctx2 );
+    T retval;
+
+    // have to check for the zero size channel case
+    if ( size == 0 && chair != 0p ) {
+        memcpy((void *)&retval, (void *)chair_elem, sizeof(T));
+        unpark( chair );
+        chair = 0p;
+        unlock( mutex_lock );
+        unlock( p_lock );
+        unlock( c_lock );
+        return retval;
+    }
+
+    // wait if buffer is empty, work will be completed by someone else
+    if ( count == 0 ) { 
+        chair = active_thread();
+        chair_elem = &retval;
+        unlock( mutex_lock );
+        park( );
+        return retval;
+    }
+
+    // Remove from buffer
+    memcpy((void *)&retval, (void *)&buffer[front], sizeof(T));
+    count -= 1;
+    front = (front + 1) % size;
+
+    if ( chair != 0p ) {
+        insert_( chan, *chair_elem );  // do waiting producer work
+        unpark( chair );
+        chair = 0p;
+        unlock( mutex_lock );
+        unlock( p_lock );
+        unlock( c_lock );
+        return retval;
+    }
+
+    unlock( mutex_lock );
+    unlock( c_lock );
+    return retval;
+}
+
+} // forall( T )
+#endif
+
+#ifndef __PREVENTION_CHANNEL
 forall( T ) {
 struct channel {
@@ -41,5 +165,5 @@
 static inline bool has_waiting_producers( channel(T) & chan ) with(chan) { return !empty( prods ); }
 
-static inline void insert_( channel(T) & chan, T elem ) with(chan) {
+static inline void insert_( channel(T) & chan, T & elem ) with(chan) {
     memcpy((void *)&buffer[back], (void *)&elem, sizeof(T));
     count += 1;
@@ -107,2 +231,3 @@
 
 } // forall( T )
+#endif
Index: libcfa/src/containers/array.hfa
===================================================================
--- libcfa/src/containers/array.hfa	(revision 8bb46d2a7a3c03f09935c6ab002dd8ed478259f0)
+++ libcfa/src/containers/array.hfa	(revision 1f951abd376df4a7064ad98779090e5e0ec9565c)
@@ -9,9 +9,35 @@
 
 
-//
-// Single-dim array sruct (with explicit packing and atom)
-//
-
+// 
+// The `array` macro is the public interface.
+// It computes the type of a dense (trivially strided) array.
+// All user-declared objects are dense arrays.
+//
+// The `arpk` (ARray with PacKing info explicit) type is, generally, a slice with _any_ striding.
+// This type is meant for internal use.
+// CFA programmers should not instantiate it directly, nor access its field.
+// CFA programmers should call ?[?] on it.
+// Yet user-given `array(stuff)` expands to `arpk(stuff')`.
+// The comments here explain the resulting internals.
+//
+// Just as a plain-C "multidimesional" array is really array-of-array-of-...,
+// so does arpk generally show up as arpk-of-arpk-of...
+//
+// In the example of `array(float, 3, 4, 5) a;`,
+// `typeof(a)` is an `arpk` instantiation.
+// These comments explain _its_ arguments, i.e. those of the topmost `arpk` level.
+//
+// [N]    : the number of elements in `a`; 3 in the example
+// S      : carries the stride size (distance in bytes between &myA[0] and &myA[1]), in sizeof(S); 
+//          same as Timmed when striding is trivial, same as Timmed in the example
+// Timmed : (T-immediate) the inner type; conceptually, `typeof(a)` is "arpk of Timmed";
+//          array(float, 4, 5) in the example
+// Tbase  : (T-base) the deepest element type that is not arpk; float in the example
+//
 forall( [N], S & | sized(S), Timmed &, Tbase & ) {
+
+    //
+    // Single-dim array sruct (with explicit packing and atom)
+    //
     struct arpk {
         S strides[N];