diff --git a/docs/source/applications.rst b/docs/source/applications.rst
index 13b4aa4..f2418d0 100644
--- a/docs/source/applications.rst
+++ b/docs/source/applications.rst
@@ -6,15 +6,15 @@
 Reference applications
 ++++++++++++++++++++++
 
-CcnxConsumerCbr
+NdnConsumerCbr
 ^^^^^^^^^^^^^^^
 
-:ndnsim:`CcnxConsumerCbr` an application that generates Interest traffic with predefined pattern (constant frequency, constant average rate with inter-Interest gap distributed uniformly at random, exponentially at random, etc.).
+:ndnsim:`NdnConsumerCbr` an application that generates Interest traffic with predefined pattern (constant frequency, constant average rate with inter-Interest gap distributed uniformly at random, exponentially at random, etc.).
 
 .. code-block:: c++
 
    // Create application using the app helper
-   CcnxAppHelper helper ("ns3::CcnxConsumerCbr");
+   NdnAppHelper helper ("ns3::NdnConsumerCbr");
 
 This applications has the following attributes:
 
@@ -48,15 +48,15 @@
      // Set attribute using the app helper
      helper.SetAttribute ("Randomize", StringValue ("uniform"));
 
-CcnxConsumerBatches
+NdnConsumerBatches
 ^^^^^^^^^^^^^^^^^^^
 
-:ndnsim:`CcnxConsumerBatches` is an on-off-style application gen- erating a specified number of Interests at specified points of simulation.
+:ndnsim:`NdnConsumerBatches` is an on-off-style application gen- erating a specified number of Interests at specified points of simulation.
 
 .. code-block:: c++
 
    // Create application using the app helper
-   CcnxAppHelper consumerHelper ("ns3::CcnxConsumerBatches");
+   NdnAppHelper consumerHelper ("ns3::NdnConsumerBatches");
 
 This applications has the following attributes:
 
@@ -74,15 +74,15 @@
      helper.SetAttribute ("Batches", StringValue ("1s 1 2s 5 10s 2"));
 
 
-CcnxConsumerWindow
+NdnConsumerWindow
 ^^^^^^^^^^^^^^^^^^
 
-:ndnsim:`CcnxConsumerWindow` is an application generating a variable rate Interest traffic. It relies on an optional NACK-Interest feature and implements a simple sliding-window-based Interest generation mecha- nism.
+:ndnsim:`NdnConsumerWindow` is an application generating a variable rate Interest traffic. It relies on an optional NACK-Interest feature and implements a simple sliding-window-based Interest generation mechanism.
 
 .. code-block:: c++
 
    // Create application using the app helper
-   CcnxAppHelper consumerHelper ("ns3::CcnxConsumerWindow");
+   NdnAppHelper consumerHelper ("ns3::NdnConsumerWindow");
 
 
 This applications has the following attributes:
@@ -110,24 +110,24 @@
 
   If ``Size`` is set to -1, Interests will be requested till the end of the simulation.
 
-CcnxProducer
+NdnProducer
 ^^^^^^^^^^^^
 
-:ndnsim:`CcnxProducer` a simple Interest-sink application, which replying every incoming Interest with Data packet with a specified size and name same as in Interest.
+:ndnsim:`NdnProducer` a simple Interest-sink application, which replying every incoming Interest with Data packet with a specified size and name same as in Interest.
 
 .. code-block:: c++
 
    // Create application using the app helper
-   CcnxAppHelper consumerHelper ("ns3::CcnxProducer");
+   NdnAppHelper consumerHelper ("ns3::NdnProducer");
 
 
 Custom applications
 +++++++++++++++++++
 
-Applications interact with the core of the system using :ndnsim:`CcnxAppFace` realization of Face abstraction. 
-To simplify implementation of specific NDN application, ndnSIM provides a base :ndnsim:`CcnxApp` class that takes care of creating :ndnsim:`CcnxAppFace` and registering it inside the NDN protocol stack, as well as provides default processing for incoming Interest and Data packets.
+Applications interact with the core of the system using :ndnsim:`NdnAppFace` realization of Face abstraction. 
+To simplify implementation of specific NDN application, ndnSIM provides a base :ndnsim:`NdnApp` class that takes care of creating :ndnsim:`NdnAppFace` and registering it inside the NDN protocol stack, as well as provides default processing for incoming Interest and Data packets.
 
-.. Base CcnxApp class
+.. Base NdnApp class
 .. ^^^^^^^^^^^^^^^^^^
 
 
@@ -139,20 +139,20 @@
 
 .. code-block:: c++
 
-    class CustomApp : public CcnxApp
+    class CustomApp : public NdnApp
     {
     public:
-      // overridden from CcnxApp
+      // overridden from NdnApp
 
       // Processing upon start of the application
       virtual void
       StartApplication ()
       {
-        // initialize CcnxApp
-        CcnxApp::StartApplication ();
+        // initialize NdnApp
+        NdnApp::StartApplication ();
         
         // Create a name components object for name ``/prefix/sub``
-	Ptr<CcnxNameComponents> prefix = Create<CcnxNameComponents> (); // now prefix contains ``/``
+	Ptr<NdnNameComponents> prefix = Create<NdnNameComponents> (); // now prefix contains ``/``
 	prefix->Add ("prefix"); // now prefix contains ``/prefix``
 	prefix->Add ("sub"); // now prefix contains ``/prefix/sub``
 
@@ -161,24 +161,24 @@
         /////////////////////////////////////////////////////////////////////////////
 
         // Get FIB object        
-        Ptr<CcnxFib> fib = GetNode ()->GetObject<CcnxFib> ();
+        Ptr<NdnFib> fib = GetNode ()->GetObject<NdnFib> ();
 
         // Add entry to FIB
-        // Note that ``m_face`` is cretaed by CcnxApp
-        CcnxFibEntryContainer::type::iterator fibEntry = fib->Add (*prefix, m_face, 0);
+        // Note that ``m_face`` is cretaed by NdnApp
+        NdnFibEntryContainer::type::iterator fibEntry = fib->Add (*prefix, m_face, 0);
       
         /////////////////////////////////////
 	// Sending one Interest packet out //
         /////////////////////////////////////
 
-        // Create and configure CcnxInterestHeader
-        CcnxInterestHeader interestHeader;
+        // Create and configure NdnInterestHeader
+        NdnInterestHeader interestHeader;
         UniformVariable rand (0,std::numeric_limits<uint32_t>::max ());
         interestHeader.SetNonce            (rand.GetValue ());
         interestHeader.SetName             (prefix);
         interestHeader.SetInterestLifetime (Seconds (1.0));
       
-        // Create packet and add CcnxInterestHeader
+        // Create packet and add NdnInterestHeader
         Ptr<Packet> packet = Create<Packet> ();
         packet->AddHeader (interestHeader);
 
@@ -193,21 +193,21 @@
       virtual void
       StopApplication ()
       {
-        // cleanup CcnxApp
-        CcnxApp::StopApplication ();
+        // cleanup NdnApp
+        NdnApp::StopApplication ();
       }
     
       // Callback that will be called when Interest arrives
       virtual void
-      OnInterest (const Ptr<const CcnxInterestHeader> &interest, Ptr<Packet> packet)
+      OnInterest (const Ptr<const NdnInterestHeader> &interest, Ptr<Packet> packet)
       {
-        // Create and configure CcnxContentObjectHeader and CcnxContentObjectTail
+        // Create and configure NdnContentObjectHeader and NdnContentObjectTail
         // (header is added in front of the packet, tail is added at the end of the packet)
         
-        CcnxContentObjectHeader data;
-        data.SetName (Create<CcnxNameComponents> (interest->GetName ())); // data will have the same name as Interests
+        NdnContentObjectHeader data;
+        data.SetName (Create<NdnNameComponents> (interest->GetName ())); // data will have the same name as Interests
       
-        CcnxContentObjectTail trailer; // doesn't require any configuration
+        NdnContentObjectTail trailer; // doesn't require any configuration
 
         // Create packet and add header and trailer
         Ptr<Packet> packet = Create<Packet> (1024);
@@ -224,7 +224,7 @@
      
       // Callback that will be called when Data arrives
       virtual void
-      OnContentObject (const Ptr<const CcnxContentObjectHeader> &contentObject,
+      OnContentObject (const Ptr<const NdnContentObjectHeader> &contentObject,
                        Ptr<Packet> payload)
       {
         std::cout << "DATA received for name " << contentObject->GetName () << std::endl; 
diff --git a/docs/source/examples.rst b/docs/source/examples.rst
index 867f006..6132b4e 100644
--- a/docs/source/examples.rst
+++ b/docs/source/examples.rst
@@ -4,7 +4,7 @@
 Simple scenario
 ---------------
 
-The first example (``ccnx-simple.cc``) shows very basics of ndnSIM.  In the simulated
+The first example (``ndn-simple.cc``) shows very basics of ndnSIM.  In the simulated
 topology there are 3 nodes, connected with point-to-point links, one
 NDN consumer, and one NDN producer:
 
@@ -18,10 +18,10 @@
       |          |         10ms   |        |         10ms   |          |
       +----------+                +--------+                +----------+
 
-Consumer is simulated using :ndnsim:`CcnxConsumerCbr` reference application and generates Interests towards the producer
+Consumer is simulated using :ndnsim:`NdnConsumerCbr` reference application and generates Interests towards the producer
 with frequency of 10 Interests per second (see :doc:`applications`).
 
-Producer is simulated using :ndnsim:`CcnxProducer` class, which is used to satisfy all incoming Interests with virtual payload data (1024 bytes).
+Producer is simulated using :ndnsim:`NdnProducer` class, which is used to satisfy all incoming Interests with virtual payload data (1024 bytes).
 
 FIB on every node is populated using default routes (see :doc:`helpers`).
 
@@ -55,21 +55,21 @@
       p2p.Install (nodes.Get (1), nodes.Get (2));
 
       // Install CCNx stack on all nodes
-      CcnxStackHelper ccnxHelper;
+      NdnStackHelper ccnxHelper;
       ccnxHelper.SetDefaultRoutes (true);
       ccnxHelper.InstallAll ();
 
       // Installing applications
 
       // Consumer
-      CcnxAppHelper consumerHelper ("ns3::CcnxConsumerCbr");
+      NdnAppHelper consumerHelper ("ns3::NdnConsumerCbr");
       // Consumer will request /prefix/0, /prefix/1, ...
       consumerHelper.SetPrefix ("/prefix");
       consumerHelper.SetAttribute ("Frequency", StringValue ("10")); // 10 interests a second
       consumerHelper.Install (nodes.Get (0)); // first node
 
       // Producer
-      CcnxAppHelper producerHelper ("ns3::CcnxProducer");
+      NdnAppHelper producerHelper ("ns3::NdnProducer");
       // Producer will reply to all requests starting with /prefix
       producerHelper.SetPrefix ("/prefix");
       producerHelper.SetAttribute ("PayloadSize", StringValue("1024"));
@@ -83,16 +83,16 @@
       return 0;
     }
 
-If this code is placed into ``scratch/ccnx-simple.cc`` and NS-3 is compiled in debug mode, you can run and see progress of the
+If this code is placed into ``scratch/ndn-simple.cc`` and NS-3 is compiled in debug mode, you can run and see progress of the
 simulation using the following command (in optimized mode nothing will be printed out)::
 
-     NS_LOG=CcnxConsumer:CcnxProducer ./waf --run=ccnx-simple
+     NS_LOG=NdnConsumer:NdnProducer ./waf --run=ndn-simple
 
 
 9-node grid example
 -------------------
 
-This scenario (``ccnx-grid.cc``) simulates using a grid topology build with PointToPointGrid NS-3 module
+This scenario (``ndn-grid.cc``) simulates using a grid topology build with PointToPointGrid NS-3 module
 
 .. aafig::
     :aspect: 60
@@ -115,12 +115,12 @@
        \-/          \-/      \--------/
 
 
-FIB is populated using :ndnsim:`CcnxGlobalRoutingHelper` (see :doc:`helpers`).
+FIB is populated using :ndnsim:`NdnGlobalRoutingHelper` (see :doc:`helpers`).
 
-Consumer is simulated using :ndnsim:`CcnxConsumerCbr` reference application and generates Interests towards the producer
+Consumer is simulated using :ndnsim:`NdnConsumerCbr` reference application and generates Interests towards the producer
 with frequency of 10 Interests per second (see :doc:`applications`).
 
-Producer is simulated using :ndnsim:`CcnxProducer` class, which is used to satisfy all incoming Interests with virtual payload data (1024 bytes).
+Producer is simulated using :ndnsim:`NdnProducer` class, which is used to satisfy all incoming Interests with virtual payload data (1024 bytes).
 
 
 The following code represents all that is necessary to run such a
@@ -150,11 +150,11 @@
       grid.BoundingBox(100,100,200,200);
     
       // Install CCNx stack on all nodes
-      CcnxStackHelper ccnxHelper;
+      NdnStackHelper ccnxHelper;
       ccnxHelper.InstallAll ();
     
       // Installing global routing interface on all nodes
-      CcnxGlobalRoutingHelper ccnxGlobalRoutingHelper;
+      NdnGlobalRoutingHelper ccnxGlobalRoutingHelper;
       ccnxGlobalRoutingHelper.InstallAll ();
       
       // Getting containers for the consumer/producer
@@ -165,17 +165,17 @@
       // Install CCNx applications
       std::string prefix = "/prefix";
       
-      CcnxAppHelper consumerHelper ("ns3::CcnxConsumerCbr");
+      NdnAppHelper consumerHelper ("ns3::NdnConsumerCbr");
       consumerHelper.SetPrefix (prefix);
       consumerHelper.SetAttribute ("Frequency", StringValue ("10")); // 10 interests a second
       consumerHelper.Install (consumerNodes);
       
-      CcnxAppHelper producerHelper ("ns3::CcnxProducer");
+      NdnAppHelper producerHelper ("ns3::NdnProducer");
       producerHelper.SetPrefix (prefix);
       producerHelper.SetAttribute ("PayloadSize", StringValue("1024"));
       producerHelper.Install (producer);
     
-      // Add /prefix origins to CcnxGlobalRouter
+      // Add /prefix origins to NdnGlobalRouter
       ccnxGlobalRoutingHelper.AddOrigins (prefix, producer);
     
       // Calculate and install FIBs
@@ -190,8 +190,8 @@
     }
     
 
-If this code is placed into ``scratch/ccnx-grid.cc`` and NS-3 is compiled in debug mode, you can run and see progress of the
+If this code is placed into ``scratch/ndn-grid.cc`` and NS-3 is compiled in debug mode, you can run and see progress of the
 simulation using the following command (in optimized mode nothing will be printed out)::
 
-    NS_LOG=CcnxConsumer:CcnxProducer ./waf --run=ccnx-grid
+    NS_LOG=NdnConsumer:NdnProducer ./waf --run=ndn-grid
 
diff --git a/docs/source/helpers.rst b/docs/source/helpers.rst
index 629832f..107459a 100644
--- a/docs/source/helpers.rst
+++ b/docs/source/helpers.rst
@@ -4,17 +4,17 @@
 Helpers are very important components of ndnSIM, especially for writing simulation scenarios.
 The following summarizes helpers and their basic usage.
 
-CcnxStackHelper
+NdnStackHelper
 ---------------
 
-:ndnsim:`CcnxStackHelper` is used to install ndnSIM network stack on requested nodes, as well to provide a simple way configure several important parameters of NDN simulation.
+:ndnsim:`NdnStackHelper` is used to install ndnSIM network stack on requested nodes, as well to provide a simple way configure several important parameters of NDN simulation.
 
 Example::
 
-   CcnxStackHelper ccnxHelper;
+   NdnStackHelper ndnHelper;
    NodeContainer nodes;
    ...
-   ccnxHelper.Install (nodes);
+   ndnHelper.Install (nodes);
 
 Forwarding strategy
 +++++++++++++++++++
@@ -30,9 +30,9 @@
 
       .. code-block:: c++
 
-         ccnxHelper.SetForwardingStrategy ("ns3::ndnSIM::Flooding");
+         ndnHelper.SetForwardingStrategy ("ns3::ndnSIM::Flooding");
 	 ...
-	 ccnxHelper.Install (nodes);
+	 ndnHelper.Install (nodes);
 	 
       
 
@@ -44,9 +44,9 @@
 
       .. code-block:: c++
 
-         ccnxHelper.SetForwardingStrategy ("ns3::ndnSIM::SmartFlooding");
+         ndnHelper.SetForwardingStrategy ("ns3::ndnSIM::SmartFlooding");
 	 ...
-	 ccnxHelper.Install (nodes);
+	 ndnHelper.Install (nodes);
 
   - :ndnsim:`BestRoute`
 
@@ -56,9 +56,9 @@
 
       .. code-block:: c++
 
-         ccnxHelper.SetForwardingStrategy ("ns3::ndnSIM::BestRoute");
+         ndnHelper.SetForwardingStrategy ("ns3::ndnSIM::BestRoute");
 	 ...
-	 ccnxHelper.Install (nodes);
+	 ndnHelper.Install (nodes);
 
 Default routes
 ++++++++++++++
@@ -68,34 +68,34 @@
 
 In simple topologies, like in :doc:`examples <examples>`, or when
 simulating broadcast environment, it is possible to set up *default*
-FIB entries using :ndnsim:`CcnxStackHelper::SetDefaultRoutes` call.
+FIB entries using :ndnsim:`NdnStackHelper::SetDefaultRoutes` call.
 More specifically, every installed NDN stack will have a FIB entry to ``/`` prefix, containing all available faces.
 
 The following should be done before installing stack on a node:
 
   .. code-block:: c++
 
-     ccnxHelper.SetDefaultRoutes (true);
+     ndnHelper.SetDefaultRoutes (true);
      ...
-     ccnxHelper.Install (nodes);
+     ndnHelper.Install (nodes);
 
 
 Manually routes
 +++++++++++++++
 
-Routes can be configured manually using :ndnsim:`CcnxStackHelper::AddRoute` static methods of :ndnsim:`CcnxStackHelper`.
+Routes can be configured manually using :ndnsim:`NdnStackHelper::AddRoute` static methods of :ndnsim:`NdnStackHelper`.
 
 These routes **should** be created **after** installing NDN stack on a node:
 
   .. code-block:: c++
 
-     ccnxHelper.Install (nodes);
+     ndnHelper.Install (nodes);
      ...
      Ptr<Node> node = ...     // FIB entry will be added to FIB on this node
      std::string prefix = ... // some prefix
-     Ptr<CcnxFace> face = ... // NDN face that belongs to the node and through which prefix is accessible
+     Ptr<NdnFace> face = ... // NDN face that belongs to the node and through which prefix is accessible
      int32_t metric = ...     // some routing metric
-     CcnxStackHelper::AddRoute (node, prefix, face, metric);
+     NdnStackHelper::AddRoute (node, prefix, face, metric);
 
 
 .. Enable optional interest limiting
@@ -103,60 +103,60 @@
 
 .. EnableLimits
 
-CcnxGlobalRoutingHelper
+NdnGlobalRoutingHelper
 -----------------------
 
-To simplify FIB management in large topologies, ndnSIM contains a global routing controller (:ndnsim:`helper <CcnxGlobalRoutingHelper>` and :ndnsim:`special interface <CcnxGlobalRouter>`), similar in spirit to ``Ipv4GlobalRoutingHelper``.
+To simplify FIB management in large topologies, ndnSIM contains a global routing controller (:ndnsim:`helper <NdnGlobalRoutingHelper>` and :ndnsim:`special interface <NdnGlobalRouter>`), similar in spirit to ``Ipv4GlobalRoutingHelper``.
 
 There are several necessary steps, in order to take advantage of the global routing controller:
 
-* install :ndnsim:`special interfaces <CcnxGlobalRouter>` on nodes
+* install :ndnsim:`special interfaces <NdnGlobalRouter>` on nodes
 
    .. code-block:: c++
    
      NodeContainer nodes;
      ...
-     CcnxGlobalRoutingHelper ccnxGlobalRoutingHelper;
-     ccnxGlobalRoutingHelper.Install (nodes);
+     NdnGlobalRoutingHelper ndnGlobalRoutingHelper;
+     ndnGlobalRoutingHelper.Install (nodes);
    
-* specify which node exports which prefix using :ndnsim:`CcnxGlobalRoutingHelper::AddOrigins`
+* specify which node exports which prefix using :ndnsim:`NdnGlobalRoutingHelper::AddOrigins`
 
    .. code-block:: c++
    
      Ptr<Node> producer; // producer node that exports prefix
      std::string prefix; // exported prefix
      ...
-     ccnxGlobalRoutingHelper.AddOrigins (prefix, producer);
+     ndnGlobalRoutingHelper.AddOrigins (prefix, producer);
    
-* calculate and install FIBs on every node using :ndnsim:`CcnxGlobalRoutingHelper::CalculateRoutes`
+* calculate and install FIBs on every node using :ndnsim:`NdnGlobalRoutingHelper::CalculateRoutes`
 
    .. code-block:: c++
    
-     ccnxGlobalRoutingHelper.CalculateRoutes ();
+     cdnGlobalRoutingHelper.CalculateRoutes ();
    
 
-CcnxAppHelper
+NdnAppHelper
 ---------------
 
-:ndnsim:`CcnxAppHelper` simplifies task of creating, configuring, and installing ndnSIM applications.
+:ndnsim:`NdnAppHelper` simplifies task of creating, configuring, and installing ndnSIM applications.
 
 
-The basic usage of the :ndnsim:`CcnxAppHelper`:
+The basic usage of the :ndnsim:`NdnAppHelper`:
 
 * Create helper for specific applications class:
 
    .. code-block:: c++
 
       // Create helper for the consumer generating Interests with constant rate
-      CcnxAppHelper consumerHelper ("ns3::CcnxConsumerCbr");
+      NdnAppHelper consumerHelper ("ns3::NdnConsumerCbr");
 
-* Assign prefix on which application operates (either generating Interests using this name or satisfying Interests for this name) using :ndnsim:`CcnxAppHelper::SetPrefix`:
+* Assign prefix on which application operates (either generating Interests using this name or satisfying Interests for this name) using :ndnsim:`NdnAppHelper::SetPrefix`:
 
    .. code-block:: c++
 
       consumerHelper.SetPrefix (prefix);
 
-* Assign application-specific attributes using :ndnsim:`CcnxAppHelper::SetAttribute`:
+* Assign application-specific attributes using :ndnsim:`NdnAppHelper::SetAttribute`:
 
    .. code-block:: c++
 
diff --git a/docs/source/intro.rst b/docs/source/intro.rst
index 860daf3..797bf53 100644
--- a/docs/source/intro.rst
+++ b/docs/source/intro.rst
@@ -17,7 +17,7 @@
 
 .. This flexibility allows ndnSIM to simulate scenarios of various homogeneous and heterogeneous networks (e.g., NDN-only, NDN-over-IP, etc.).
 
-The simulator is implemented in a modular fashion, using separate C++ classes to model behavior of each network-layer entity in NDN: :ndnsim:`pending Interest table (PIT) <CcnxPit>`, :ndnsim:`forwarding information base (FIB) <CcnxFib>`, :ndnsim:`content store <CcnxContentStore>`, :ndnsim:`network <CcnxNetDeviceFace>` and :ndnsim:`application <CcnxAppFace>` interfaces, :ndnsim:`Interest forwarding strategies <CcnxForwardingStrategy>`, etc.
+The simulator is implemented in a modular fashion, using separate C++ classes to model behavior of each network-layer entity in NDN: :ndnsim:`pending Interest table (PIT) <NdnPit>`, :ndnsim:`forwarding information base (FIB) <NdnFib>`, :ndnsim:`content store <NdnContentStore>`, :ndnsim:`network <NdnNetDeviceFace>` and :ndnsim:`application <NdnAppFace>` interfaces, :ndnsim:`Interest forwarding strategies <NdnForwardingStrategy>`, etc.
 This modular structure allows any component to be easily modified or replaced with no or minimal impact on other components.
 In addition, the simulator provides an extensive collection of interfaces and helpers to perform detailed tracing behavior of every component, as well as NDN traffic flow.
 
@@ -33,8 +33,8 @@
     .................|......................................|......................
     .		     v			     	            v			  .
     .		+------------------+	     +----------------------+		  .
-    .           |    "CcnxFace"    |	     |      "CcnxFace"      |		  .
-    .           |  "(CcnxAppFace)" |	     | "(CcnxNetDeviceFace)"|		  .
+    .           |    "NdnFace"     |	     |      "NdnFace"       |		  .
+    .           |  "(NdnAppFace)"  |	     | "(NdnNetDeviceFace)" |		  .
     .		+------------------+         +----------------------+		  .
     .		               ^                   ^				  .
     .			       |                   |				  .
@@ -42,7 +42,7 @@
     .			    XXXXXXXXXXXXXXXXXXXXXXXXXXXXX			  .
     .			    XX                         XX			  .
     .			    XX    Core NDN protocol    XX  			  .
-    .                       XX    "(CcnxL3Protocol)"   XX
+    .                       XX    "(NdnL3Protocol)"    XX
     .			    XX                         XX			  .
     .			    XXXXXXXXXXXXXXXXXXXXXXXXXXXXX			  .
     .			      ^       ^       ^       ^				  .
@@ -51,7 +51,7 @@
     .	  | 		    	  |		  |    		   |		  .
     .	  v			  v		  v		   v		  .
     . +-------------------+      +-------+      +-------+        +-------------+  .
-    . | "CcnxContentStore"|      |  PIT  |      |  FIB  |        | "Pluggable" |  .
+    . | "NdnContentStore" |      |  PIT  |      |  FIB  |        | "Pluggable" |  .
     . +-------------------+      +-------+      +-------+        | "Forwarding"|  .
     .							         | "Strategy"  |  .
     .							         +-------------+  .
@@ -178,18 +178,18 @@
 +-----------------+---------------------------------------------------------------------+
 | Folder          | Description                                                         |
 +=================+=====================================================================+
-| ``model/``      | implementation of NDN base: :ndnsim:`CcnxL3Protocol`, faces         |
-|                 | (:ndnsim:`CcnxFace`, :ndnsim:`CcnxNetDeviceFace`, forwarding        |
-|                 | :ndnsim:`CcnxAppFace`),                                             |
-|                 | strategies (:ndnsim:`CcnxForwardingStrategy`,                       |
-|                 | :ndnsim:`CcnxFloodingStrategy`, :ndnsim:`CcnxBestRouteStrategy`),   |
+| ``model/``      | implementation of NDN base: :ndnsim:`NdnL3Protocol`, faces          |
+|                 | (:ndnsim:`NdnFace`, :ndnsim:`NdnNetDeviceFace`, forwarding          |
+|                 | :ndnsim:`NdnAppFace`),                                              |
+|                 | strategies (:ndnsim:`NdnForwardingStrategy`,                        |
+|                 | :ndnsim:`Flooding`, :ndnsim:`SmartFlooding`, :ndnsim:`BestRoute`),  |
 |                 | etc.                                                                |
 +-----------------+---------------------------------------------------------------------+
 | ``apps/``       | applications (in NS-3 sense) that can be installed on the nodes.    |
-|                 | Right now we have one producer (:ndnsim:`CcnxProducer`) and a       |
-|                 | collection  of consumer (:ndnsim:`CcnxConsumerCbr`,                 |
-|                 | :ndnsim:`CcnxConsumerWindow`,                                       |
-|                 | :ndnsim:`CcnxConsumerBatches`).  See doxygen documentation or       |
+|                 | Right now we have one producer (:ndnsim:`NdnProducer`) and a        |
+|                 | collection  of consumer (:ndnsim:`NdnConsumerCbr`,                  |
+|                 | :ndnsim:`NdnConsumerWindow`,                                        |
+|                 | :ndnsim:`NdnConsumerBatches`).  See doxygen documentation or        |
 |                 | source  code for details                                            |
 +-----------------+---------------------------------------------------------------------+
 | ``helper/``     | a number of :doc:`useful helpers <helpers>`                         |
@@ -205,9 +205,9 @@
 Logging
 -----------------
 
-Almost every component in ndnSIM exports logging interface, so it is possible in debug compilation of simulator to track many details. For example, by enabling logging of :ndnsim:`CcnxFace` and :ndnsim:`CcnxConsumer` will show everything what happens on :ndnsim:`CcnxFace` and :ndnsim:`CcnxConsumer` classes::
+Almost every component in ndnSIM exports logging interface, so it is possible in debug compilation of simulator to track many details. For example, by enabling logging of :ndnsim:`NdnFace` and :ndnsim:`NdnConsumer` will show everything what happens on :ndnsim:`NdnFace` and :ndnsim:`NdnConsumer` classes::
 
-    NS_LOG=CcnxFace:CcnxConsumer ./waf --run=ccnx-simple
+    NS_LOG=NdnFace:NdnConsumer ./waf --run=ndn-simple
 
 Refer to the source code and NS-3 documentation to see what logging interfaces are available and about details how enable one or more logging interfaces.
 
diff --git a/model/pit/ndn-pit-impl.cc b/model/pit/ndn-pit-impl.cc
index b5f3eaa..090f1d6 100644
--- a/model/pit/ndn-pit-impl.cc
+++ b/model/pit/ndn-pit-impl.cc
@@ -114,66 +114,6 @@
   return tid;
 }
 
-// template<class Policy>
-// TypeId
-// NdnPitImpl<Policy>::GetTypeId ()
-// {
-//   static TypeId tid = TypeId ("ns3::UnknownPitPolicy");
-
-//   return tid;
-// }
-
-// NdnPitEntryImpl::NdnPitEntryImpl (NdnPit &pit,
-//                                     Ptr<const NdnInterestHeader> header,
-//                                     Ptr<NdnFibEntry> fibEntry)
-//   : NdnPitEntry (pit, header, fibEntry)
-//   , item_ (0)
-// {
-//   static_cast<NdnPitImpl&> (m_container).i_time.insert (*this);
-// }
-
-// NdnPitEntryImpl::~NdnPitEntryImpl ()
-// {
-//   static_cast<NdnPitImpl&> (m_container).i_time.erase (*this);
-// }
-
-// TypeId
-// NdnPitImpl::GetTypeId ()
-// {
-//   static TypeId tid = TypeId ("ns3::NdnPit")
-//     .SetGroupName ("Ndn")
-//     .SetParent<NdnPit> ()
-//     .AddConstructor<NdnPitImpl> ()
-//     .AddAttribute ("MaxSize",
-//                    "Set maximum number of entries in PIT. If 0, limit is not enforced",
-//                    StringValue ("0"),
-//                    MakeUintegerAccessor (&NdnPitImpl::GetMaxSize, &NdnPitImpl::SetMaxSize),
-//                    MakeUintegerChecker<uint32_t> ())
-//     ;
-
-//   return tid;
-// }
-
-
-// template<class AcceptanceAndReplacementPolicy>
-// TypeId
-// NdnPitImpl::GetTypeId ()
-// {
-//   #error "Not specialized version is not supported"
-//   // static TypeId tid = TypeId ("ns3::NdnPit")
-//   //   .SetGroupName ("Ndn")
-//   //   .SetParent<NdnPit> ()
-//   //   .AddConstructor<NdnPitImpl> ()
-//   //   .AddAttribute ("MaxSize",
-//   //                  "Set maximum number of entries in PIT. If 0, limit is not enforced",
-//   //                  StringValue ("0"),
-//   //                  MakeUintegerAccessor (&NdnPitImpl::GetMaxSize, &NdnPitImpl::SetMaxSize),
-//   //                  MakeUintegerChecker<uint32_t> ())
-//   //   ;
-
-//   return Typeid ();
-// }
-
 template<class Policy>
 NdnPitImpl<Policy>::NdnPitImpl ()
 {