diff --git a/src/detail/bzip2-helper.cpp b/src/detail/bzip2-helper.cpp
index 0784b7f..4c5617e 100644
--- a/src/detail/bzip2-helper.cpp
+++ b/src/detail/bzip2-helper.cpp
@@ -17,12 +17,13 @@
  * ChronoSync, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "detail/bzip2-helper.hpp"
+#include "bzip2-helper.hpp"
 
-#include <boost/iostreams/filtering_stream.hpp>
-#include <boost/iostreams/detail/iostream.hpp>
-#include <boost/iostreams/filter/bzip2.hpp>
 #include <boost/iostreams/copy.hpp>
+#include <boost/iostreams/device/array.hpp>
+#include <boost/iostreams/filtering_stream.hpp>
+#include <boost/iostreams/filter/bzip2.hpp>
+#include <boost/iostreams/stream.hpp>
 
 #include <ndn-cxx/encoding/buffer-stream.hpp>
 
@@ -38,7 +39,7 @@
   bio::filtering_stream<bio::output> out;
   out.push(bio::bzip2_compressor());
   out.push(os);
-  bio::stream<bio::array_source> in(reinterpret_cast<const char*>(buffer), bufferSize);
+  bio::stream<bio::array_source> in(buffer, bufferSize);
   bio::copy(in, out);
   return os.buf();
 }
@@ -50,7 +51,7 @@
   bio::filtering_stream<bio::output> out;
   out.push(bio::bzip2_decompressor());
   out.push(os);
-  bio::stream<bio::array_source> in(reinterpret_cast<const char*>(buffer), bufferSize);
+  bio::stream<bio::array_source> in(buffer, bufferSize);
   bio::copy(in, out);
   return os.buf();
 }
diff --git a/src/detail/common.hpp b/src/detail/common.hpp
index 4e9e4cd..dffd218 100644
--- a/src/detail/common.hpp
+++ b/src/detail/common.hpp
@@ -23,7 +23,7 @@
 #ifndef CHRONOSYNC_DETAIL_COMMON_HPP
 #define CHRONOSYNC_DETAIL_COMMON_HPP
 
-#include "detail/config.hpp"
+#include "config.hpp"
 
 #ifdef CHRONOSYNC_WITH_TESTS
 #define CHRONOSYNC_VIRTUAL_WITH_TESTS virtual
@@ -38,11 +38,10 @@
 #endif
 
 #include <cstddef>
-#include <list>
-#include <queue>
+#include <functional>
+#include <memory>
 #include <set>
 #include <vector>
-#include <tuple>
 
 #include <ndn-cxx/data.hpp>
 #include <ndn-cxx/face.hpp>
@@ -55,22 +54,19 @@
 #include <ndn-cxx/util/time.hpp>
 
 #include <boost/algorithm/string.hpp>
-#include <boost/asio.hpp>
 #include <boost/assert.hpp>
 #include <boost/core/noncopyable.hpp>
 #include <boost/lexical_cast.hpp>
 
 namespace chronosync {
 
-using std::size_t;
-
 using boost::noncopyable;
 
+using std::size_t;
+
 using std::bind;
-using std::cref;
 using std::function;
 using std::make_shared;
-using std::make_tuple;
 using std::ref;
 using std::shared_ptr;
 
@@ -79,17 +75,12 @@
 using ndn::Data;
 using ndn::Interest;
 using ndn::Name;
-using ndn::security::ValidationError;
 using ndn::security::Validator;
-
-namespace tlv {
-using namespace ndn::tlv;
-} // namespace tlv
+using ndn::security::ValidationError;
 
 namespace name = ndn::name;
 namespace time = ndn::time;
 namespace security = ndn::security;
-namespace encoding = ndn::encoding;
 
 } // namespace chronosync
 
diff --git a/src/tlv.hpp b/src/detail/tlv.hpp
similarity index 84%
rename from src/tlv.hpp
rename to src/detail/tlv.hpp
index 6b5f48a..5f9bd31 100644
--- a/src/tlv.hpp
+++ b/src/detail/tlv.hpp
@@ -1,6 +1,6 @@
 /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil -*- */
 /*
- * Copyright (c) 2012-2014 University of California, Los Angeles
+ * Copyright (c) 2012-2021 University of California, Los Angeles
  *
  * This file is part of ChronoSync, synchronization library for distributed realtime
  * applications for NDN.
@@ -19,8 +19,8 @@
  * @author Yingdi Yu <yingdi@cs.ucla.edu>
  */
 
-#ifndef CHRONOSYNC_TLV_HPP
-#define CHRONOSYNC_TLV_HPP
+#ifndef CHRONOSYNC_DETAIL_TLV_HPP
+#define CHRONOSYNC_DETAIL_TLV_HPP
 
 namespace chronosync {
 namespace tlv {
@@ -32,10 +32,10 @@
 enum {
   SyncReply   = 128, // 0x80
   StateLeaf   = 129, // 0x81
-  SeqNo       = 130  // 0x82
+  SeqNo       = 130, // 0x82
 };
 
 } // namespace tlv
 } // namespace chronosync
 
-#endif // CHRONOSYNC_TLV_HPP
+#endif // CHRONOSYNC_DETAIL_TLV_HPP
diff --git a/src/diff-state-container.cpp b/src/diff-state-container.cpp
deleted file mode 100644
index 38a67f3..0000000
--- a/src/diff-state-container.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-/* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil -*- */
-/*
- * Copyright (c) 2012-2014 University of California, Los Angeles
- *
- * This file is part of ChronoSync, synchronization library for distributed realtime
- * applications for NDN.
- *
- * ChronoSync is free software: you can redistribute it and/or modify it under the terms
- * of the GNU General Public License as published by the Free Software Foundation, either
- * version 3 of the License, or (at your option) any later version.
- *
- * ChronoSync is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * ChronoSync, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Zhenkai Zhu <http://irl.cs.ucla.edu/~zhenkai/>
- * @author Chaoyi Bian <bcy@pku.edu.cn>
- * @author Alexander Afanasyev <http://lasr.cs.ucla.edu/afanasyev/index.html>
- * @author Yingdi Yu <yingdi@cs.ucla.edu>
- */
-
-#include "diff-state-container.hpp"
diff --git a/src/interest-table.hpp b/src/interest-table.hpp
index bf5685b..4fc3eb4 100644
--- a/src/interest-table.hpp
+++ b/src/interest-table.hpp
@@ -1,6 +1,6 @@
 /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil -*- */
 /*
- * Copyright (c) 2012-2017 University of California, Los Angeles
+ * Copyright (c) 2012-2021 University of California, Los Angeles
  *
  * This file is part of ChronoSync, synchronization library for distributed realtime
  * applications for NDN.
@@ -27,6 +27,8 @@
 
 #include "interest-container.hpp"
 
+#include <boost/asio/io_service.hpp>
+
 namespace chronosync {
 
 /**
@@ -38,11 +40,7 @@
   class Error : public std::runtime_error
   {
   public:
-    explicit
-    Error(const std::string& what)
-      : std::runtime_error(what)
-    {
-    }
+    using std::runtime_error::runtime_error;
   };
 
   using iterator = InterestContainer::iterator;
diff --git a/src/leaf-container.cpp b/src/leaf-container.cpp
deleted file mode 100644
index 8bad5eb..0000000
--- a/src/leaf-container.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-/* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil -*- */
-/*
- * Copyright (c) 2012-2014 University of California, Los Angeles
- *
- * This file is part of ChronoSync, synchronization library for distributed realtime
- * applications for NDN.
- *
- * ChronoSync is free software: you can redistribute it and/or modify it under the terms
- * of the GNU General Public License as published by the Free Software Foundation, either
- * version 3 of the License, or (at your option) any later version.
- *
- * ChronoSync is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * ChronoSync, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Zhenkai Zhu <http://irl.cs.ucla.edu/~zhenkai/>
- * @author Chaoyi Bian <bcy@pku.edu.cn>
- * @author Alexander Afanasyev <http://lasr.cs.ucla.edu/afanasyev/index.html>
- * @author Yingdi Yu <yingdi@cs.ucla.edu>
- */
-
-#include "leaf-container.hpp"
-// Simply check whether LeafContainer can compile
diff --git a/src/state.cpp b/src/state.cpp
index 2f31b89..ab9d87d 100644
--- a/src/state.cpp
+++ b/src/state.cpp
@@ -1,6 +1,6 @@
 /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil -*- */
 /*
- * Copyright (c) 2012-2020 University of California, Los Angeles
+ * Copyright (c) 2012-2021 University of California, Los Angeles
  *
  * This file is part of ChronoSync, synchronization library for distributed realtime
  * applications for NDN.
@@ -23,6 +23,7 @@
  */
 
 #include "state.hpp"
+#include "detail/tlv.hpp"
 
 #include <boost/range/adaptor/reversed.hpp>
 #include <ndn-cxx/util/exception.hpp>
@@ -36,20 +37,19 @@
 {
   m_wire.reset();
 
-  LeafContainer::iterator leaf = m_leaves.find(info);
-
+  auto leaf = m_leaves.find(info);
   if (leaf == m_leaves.end()) {
-    m_leaves.insert(make_shared<Leaf>(info, cref(seq)));
-    return make_tuple(true, false, 0);
+    m_leaves.insert(make_shared<Leaf>(info, seq));
+    return std::make_tuple(true, false, 0);
   }
   else {
     if ((*leaf)->getSeq() == seq || seq < (*leaf)->getSeq()) {
-      return make_tuple(false, false, 0);
+      return std::make_tuple(false, false, 0);
     }
 
     SeqNo old = (*leaf)->getSeq();
     m_leaves.modify(leaf, [=] (LeafPtr& leaf) { leaf->setSeq(seq); } );
-    return make_tuple(false, true, old);
+    return std::make_tuple(false, true, old);
   }
 }
 
@@ -82,9 +82,9 @@
   return *this;
 }
 
-template<encoding::Tag T>
+template<ndn::encoding::Tag T>
 size_t
-State::wireEncode(encoding::EncodingImpl<T>& block) const
+State::wireEncode(ndn::encoding::EncodingImpl<T>& block) const
 {
   size_t totalLength = 0;
 
diff --git a/src/state.hpp b/src/state.hpp
index e5d0de2..7bbb60c 100644
--- a/src/state.hpp
+++ b/src/state.hpp
@@ -1,6 +1,6 @@
 /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil -*- */
 /*
- * Copyright (c) 2012-2017 University of California, Los Angeles
+ * Copyright (c) 2012-2021 University of California, Los Angeles
  *
  * This file is part of ChronoSync, synchronization library for distributed realtime
  * applications for NDN.
@@ -26,9 +26,9 @@
 #define CHRONOSYNC_STATE_HPP
 
 #include "leaf-container.hpp"
-#include "tlv.hpp"
 
 #include <ndn-cxx/util/sha256.hpp>
+#include <tuple>
 
 namespace chronosync {
 
@@ -49,11 +49,7 @@
   class Error : public std::runtime_error
   {
   public:
-    explicit
-    Error(const std::string& what)
-      : std::runtime_error(what)
-    {
-    }
+    using std::runtime_error::runtime_error;
   };
 
   virtual
@@ -112,9 +108,9 @@
   wireDecode(const Block& wire);
 
 protected:
-  template<encoding::Tag T>
+  template<ndn::encoding::Tag T>
   size_t
-  wireEncode(encoding::EncodingImpl<T>& block) const;
+  wireEncode(ndn::encoding::EncodingImpl<T>& block) const;
 
 protected:
   LeafContainer m_leaves;
