diff --git a/doc/design/csp.md b/doc/design/csp.md
index ba9cacfdea7dcf7c6499b562dfc58400d082f2c8..2f6ce8d6fa8617fc0ec78d18b28e0abb51753e8b 100644
--- a/doc/design/csp.md
+++ b/doc/design/csp.md
@@ -71,14 +71,14 @@ ch1 := make(chan int, 100)  // a channel that can buffer 100 ints.
 In Fluid, we should be able to do the same:
 
 ```python
-ch  = fluid.make_chan(dtype=INT)
-ch1 = fluid.make_chan(dtype=INT, 100)
+ch  = fluid.make_channel(dtype=INT)
+ch1 = fluid.make_channel(dtype=INT, 100)
 ```
 
 In addition to that, we want channels that can hold more complex element types, e.g., Tensors of float16:
 
 ```python
-ch = fluid.make_chan(dtype=Tensor, etype=float16)
+ch = fluid.make_channel(dtype=Tensor, etype=float16)
 ```
 
 or Tensors of Tensors of float16 etc.
@@ -87,6 +87,76 @@ The point here is that we need a consistent way to compose types, like in C++ we
 
 ### Send and Recv
 
+In Go, we first create a channel as explained in the section above and then perform read and write operations on top of the channels.
+
+```go
+ch1  := make(chan int)       
+ch2  := make(chan int, 100)
+```
+
+To write (or perform a `Send` operation) the value of a variable `x`, to channel `ch1` above, we perform the following:
+
+```go
+ch1 <- x
+fmt.Println("Written to the channel")
+```
+Now to read (or perform a `Recv` operation) the value stored in `ch2` into a variable `y`, we perform the following:
+
+```go
+y <- ch2
+fmt.Println("Received from channel")
+```
+
+In Fluid, we should be able to perform the above operations on the channel objects as well. As of now, we support two different kinds of channels : [Buffered Channel](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/framework/details/buffered_channel.h) and [UnBuffered Channel](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/framework/details/unbuffered_channel.h)
+
+Send and Receive can be performed as following on a buffered channel:
+
+```python
+import threading
+
+def send_to_channel(channel, num_time=1):
+  for i in xrange(num_time):
+    channel.send(i)
+
+# Create a buffered channel of capacity 10
+buffer_size = 10;
+ch = fluid.make_channel(dtype=INT, buffer_size)
+
+# Now write three elements to the channel
+thread = threading.Thread(target=send_to_channel, args=(ch, 3, ))
+thread.daemon = True
+thread.start()
+
+# Read all the data from the channel
+for i in xrange(3):
+  y = ch.recv()
+
+# Done receiving , now close the channel
+ch.close()
+```
+
+The send and receive operations will be similar for unbuffered channel as well, except for the fact that there is no buffer in an unbuffered channel, so the operations are completely synchronized. For example:
+
+```python
+import threading
+
+def send_to_channel(channel, data):
+  channel.send(data)
+
+# Create an unbuffered channel
+ch = fluid.make_channel(dtype=INT)
+
+# Writes and Reads are synchronous otherwise the calls will block.
+thread = threading.Thread(target=send_to_channel, args=(ch, 10, ))
+thread.daemon = True
+thread.start()
+
+y = ch.recv()
+
+# Done receiving , now close the channel
+ch.close()
+```
+
 ### Select
 
 ## Example Programs