diff --git a/src/encoding/encoder.cpp b/src/encoding/encoder.cpp
index 12b5ea1..1fdddec 100644
--- a/src/encoding/encoder.cpp
+++ b/src/encoding/encoder.cpp
@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
-/**
- * Copyright (c) 2013-2016 Regents of the University of California.
+/*
+ * Copyright (c) 2013-2018 Regents of the University of California.
  *
  * This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
  *
@@ -21,16 +21,19 @@
 
 #include "encoder.hpp"
 
+#include <boost/endian/conversion.hpp>
+
 namespace ndn {
 namespace encoding {
 
-Encoder::Encoder(size_t totalReserve/* = MAX_NDN_PACKET_SIZE*/, size_t reserveFromBack/* = 400*/)
-  : m_buffer(new Buffer(totalReserve))
+namespace endian = boost::endian;
+
+Encoder::Encoder(size_t totalReserve, size_t reserveFromBack)
+  : m_buffer(make_shared<Buffer>(totalReserve))
 {
   m_begin = m_end = m_buffer->end() - (reserveFromBack < totalReserve ? reserveFromBack : 0);
 }
 
-
 Encoder::Encoder(const Block& block)
   : m_buffer(const_pointer_cast<Buffer>(block.getBuffer()))
   , m_begin(m_buffer->begin() + (block.begin() - m_buffer->begin()))
@@ -38,30 +41,24 @@
 {
 }
 
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
 void
 Encoder::reserveBack(size_t size)
 {
-  if ((m_end + size) > m_buffer->end())
+  if (m_end + size > m_buffer->end())
     reserve(m_buffer->size() * 2 + size, false);
 }
 
 void
 Encoder::reserveFront(size_t size)
 {
-  if ((m_buffer->begin() + size) > m_begin)
+  if (m_buffer->begin() + size > m_begin)
     reserve(m_buffer->size() * 2 + size, true);
 }
 
-
 Block
-Encoder::block(bool verifyLength/* = true*/) const
+Encoder::block(bool verifyLength) const
 {
-  return Block(m_buffer,
-               m_begin, m_end,
-               verifyLength);
+  return Block(m_buffer, m_begin, m_end, verifyLength);
 }
 
 void
@@ -97,9 +94,6 @@
   }
 }
 
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
 size_t
 Encoder::prependByte(uint8_t value)
 {
@@ -120,7 +114,6 @@
   return 1;
 }
 
-
 size_t
 Encoder::prependByteArray(const uint8_t* array, size_t length)
 {
@@ -141,7 +134,6 @@
   return length;
 }
 
-
 size_t
 Encoder::prependVarNumber(uint64_t varNumber)
 {
@@ -150,19 +142,19 @@
     return 1;
   }
   else if (varNumber <= std::numeric_limits<uint16_t>::max()) {
-    uint16_t value = htobe16(static_cast<uint16_t>(varNumber));
+    uint16_t value = endian::native_to_big(static_cast<uint16_t>(varNumber));
     prependByteArray(reinterpret_cast<const uint8_t*>(&value), 2);
     prependByte(253);
     return 3;
   }
   else if (varNumber <= std::numeric_limits<uint32_t>::max()) {
-    uint32_t value = htobe32(static_cast<uint32_t>(varNumber));
+    uint32_t value = endian::native_to_big(static_cast<uint32_t>(varNumber));
     prependByteArray(reinterpret_cast<const uint8_t*>(&value), 4);
     prependByte(254);
     return 5;
   }
   else {
-    uint64_t value = htobe64(varNumber);
+    uint64_t value = endian::native_to_big(varNumber);
     prependByteArray(reinterpret_cast<const uint8_t*>(&value), 8);
     prependByte(255);
     return 9;
@@ -178,25 +170,24 @@
   }
   else if (varNumber <= std::numeric_limits<uint16_t>::max()) {
     appendByte(253);
-    uint16_t value = htobe16(static_cast<uint16_t>(varNumber));
+    uint16_t value = endian::native_to_big(static_cast<uint16_t>(varNumber));
     appendByteArray(reinterpret_cast<const uint8_t*>(&value), 2);
     return 3;
   }
   else if (varNumber <= std::numeric_limits<uint32_t>::max()) {
     appendByte(254);
-    uint32_t value = htobe32(static_cast<uint32_t>(varNumber));
+    uint32_t value = endian::native_to_big(static_cast<uint32_t>(varNumber));
     appendByteArray(reinterpret_cast<const uint8_t*>(&value), 4);
     return 5;
   }
   else {
     appendByte(255);
-    uint64_t value = htobe64(varNumber);
+    uint64_t value = endian::native_to_big(varNumber);
     appendByteArray(reinterpret_cast<const uint8_t*>(&value), 8);
     return 9;
   }
 }
 
-
 size_t
 Encoder::prependNonNegativeInteger(uint64_t varNumber)
 {
@@ -204,15 +195,15 @@
     return prependByte(static_cast<uint8_t>(varNumber));
   }
   else if (varNumber <= std::numeric_limits<uint16_t>::max()) {
-    uint16_t value = htobe16(static_cast<uint16_t>(varNumber));
+    uint16_t value = endian::native_to_big(static_cast<uint16_t>(varNumber));
     return prependByteArray(reinterpret_cast<const uint8_t*>(&value), 2);
   }
   else if (varNumber <= std::numeric_limits<uint32_t>::max()) {
-    uint32_t value = htobe32(static_cast<uint32_t>(varNumber));
+    uint32_t value = endian::native_to_big(static_cast<uint32_t>(varNumber));
     return prependByteArray(reinterpret_cast<const uint8_t*>(&value), 4);
   }
   else {
-    uint64_t value = htobe64(varNumber);
+    uint64_t value = endian::native_to_big(varNumber);
     return prependByteArray(reinterpret_cast<const uint8_t*>(&value), 8);
   }
 }
@@ -224,15 +215,15 @@
     return appendByte(static_cast<uint8_t>(varNumber));
   }
   else if (varNumber <= std::numeric_limits<uint16_t>::max()) {
-    uint16_t value = htobe16(static_cast<uint16_t>(varNumber));
+    uint16_t value = endian::native_to_big(static_cast<uint16_t>(varNumber));
     return appendByteArray(reinterpret_cast<const uint8_t*>(&value), 2);
   }
   else if (varNumber <= std::numeric_limits<uint32_t>::max()) {
-    uint32_t value = htobe32(static_cast<uint32_t>(varNumber));
+    uint32_t value = endian::native_to_big(static_cast<uint32_t>(varNumber));
     return appendByteArray(reinterpret_cast<const uint8_t*>(&value), 4);
   }
   else {
-    uint64_t value = htobe64(varNumber);
+    uint64_t value = endian::native_to_big(varNumber);
     return appendByteArray(reinterpret_cast<const uint8_t*>(&value), 8);
   }
 }
diff --git a/src/encoding/endian.hpp b/src/encoding/endian.hpp
deleted file mode 100644
index e37fa98..0000000
--- a/src/encoding/endian.hpp
+++ /dev/null
@@ -1,57 +0,0 @@
-/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
-/**
- * Copyright (c) 2013-2014 Regents of the University of California.
- *
- * This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
- *
- * ndn-cxx library is free software: you can redistribute it and/or modify it under the
- * terms of the GNU Lesser General Public License as published by the Free Software
- * Foundation, either version 3 of the License, or (at your option) any later version.
- *
- * ndn-cxx library 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 Lesser General Public License for more details.
- *
- * You should have received copies of the GNU General Public License and GNU Lesser
- * General Public License along with ndn-cxx, e.g., in COPYING.md file.  If not, see
- * <http://www.gnu.org/licenses/>.
- *
- * See AUTHORS.md for complete list of ndn-cxx authors and contributors.
- *
- * @author Junxiao Shi <http://www.cs.arizona.edu/people/shijunxiao/>
- */
-
-#ifndef NDN_ENCODING_ENDIAN_HPP
-#define NDN_ENCODING_ENDIAN_HPP
-
-#ifdef __linux__
-
-#include <endian.h>
-
-#endif // __linux__
-
-#ifdef __FreeBSD__
-
-#include <sys/endian.h>
-
-#endif // __FreeBSD__
-
-#ifdef __APPLE__
-
-#include <libkern/OSByteOrder.h>
-#define htobe16(x) OSSwapHostToBigInt16(x)
-#define htole16(x) OSSwapHostToLittleInt16(x)
-#define be16toh(x) OSSwapBigToHostInt16(x)
-#define le16toh(x) OSSwapLittleToHostInt16(x)
-#define htobe32(x) OSSwapHostToBigInt32(x)
-#define htole32(x) OSSwapHostToLittleInt32(x)
-#define be32toh(x) OSSwapBigToHostInt32(x)
-#define le32toh(x) OSSwapLittleToHostInt32(x)
-#define htobe64(x) OSSwapHostToBigInt64(x)
-#define htole64(x) OSSwapHostToLittleInt64(x)
-#define be64toh(x) OSSwapBigToHostInt64(x)
-#define le64toh(x) OSSwapLittleToHostInt64(x)
-
-#endif // __APPLE__
-
-#endif // NDN_ENCODING_ENDIAN_HPP
diff --git a/src/encoding/tlv.hpp b/src/encoding/tlv.hpp
index 6a14a7c..5fb2b24 100644
--- a/src/encoding/tlv.hpp
+++ b/src/encoding/tlv.hpp
@@ -23,13 +23,14 @@
 #define NDN_ENCODING_TLV_HPP
 
 #include "buffer.hpp"
-#include "endian.hpp"
 
 #include <cstring>
 #include <iterator>
 #include <ostream>
 #include <type_traits>
 
+#include <boost/endian/conversion.hpp>
+
 namespace ndn {
 
 /** @brief practical limit of network layer packet size
@@ -323,21 +324,21 @@
         uint16_t value = 0;
         std::memcpy(&value, &*begin, 2);
         begin += 2;
-        number = be16toh(value);
+        number = boost::endian::big_to_native(value);
         return true;
       }
       case 4: {
         uint32_t value = 0;
         std::memcpy(&value, &*begin, 4);
         begin += 4;
-        number = be32toh(value);
+        number = boost::endian::big_to_native(value);
         return true;
       }
       case 8: {
         uint64_t value = 0;
         std::memcpy(&value, &*begin, 8);
         begin += 8;
-        number = be64toh(value);
+        number = boost::endian::big_to_native(value);
         return true;
       }
       default: {
@@ -452,19 +453,19 @@
   }
   else if (number <= std::numeric_limits<uint16_t>::max()) {
     os.put(static_cast<char>(253));
-    uint16_t value = htobe16(static_cast<uint16_t>(number));
+    uint16_t value = boost::endian::native_to_big(static_cast<uint16_t>(number));
     os.write(reinterpret_cast<const char*>(&value), 2);
     return 3;
   }
   else if (number <= std::numeric_limits<uint32_t>::max()) {
     os.put(static_cast<char>(254));
-    uint32_t value = htobe32(static_cast<uint32_t>(number));
+    uint32_t value = boost::endian::native_to_big(static_cast<uint32_t>(number));
     os.write(reinterpret_cast<const char*>(&value), 4);
     return 5;
   }
   else {
     os.put(static_cast<char>(255));
-    uint64_t value = htobe64(number);
+    uint64_t value = boost::endian::native_to_big(number);
     os.write(reinterpret_cast<const char*>(&value), 8);
     return 9;
   }
@@ -504,17 +505,17 @@
     return 1;
   }
   else if (integer <= std::numeric_limits<uint16_t>::max()) {
-    uint16_t value = htobe16(static_cast<uint16_t>(integer));
+    uint16_t value = boost::endian::native_to_big(static_cast<uint16_t>(integer));
     os.write(reinterpret_cast<const char*>(&value), 2);
     return 2;
   }
   else if (integer <= std::numeric_limits<uint32_t>::max()) {
-    uint32_t value = htobe32(static_cast<uint32_t>(integer));
+    uint32_t value = boost::endian::native_to_big(static_cast<uint32_t>(integer));
     os.write(reinterpret_cast<const char*>(&value), 4);
     return 4;
   }
   else {
-    uint64_t value = htobe64(integer);
+    uint64_t value = boost::endian::native_to_big(integer);
     os.write(reinterpret_cast<const char*>(&value), 8);
     return 8;
   }
diff --git a/src/lp/field-decl.hpp b/src/lp/field-decl.hpp
index 26336ff..d1c39f0 100644
--- a/src/lp/field-decl.hpp
+++ b/src/lp/field-decl.hpp
@@ -26,10 +26,11 @@
 #include "field.hpp"
 #include "sequence.hpp"
 #include "tlv.hpp"
-
 #include "../encoding/block-helpers.hpp"
 #include "../util/concepts.hpp"
+
 #include <boost/concept/requires.hpp>
+#include <boost/endian/conversion.hpp>
 
 namespace ndn {
 namespace lp {
@@ -145,9 +146,9 @@
   static size_t
   encode(EncodingImpl<TAG>& encoder, uint64_t value)
   {
-    uint64_t be = htobe64(value);
-    const uint8_t* buf = reinterpret_cast<const uint8_t*>(&be);
-    return encoder.prependByteArrayBlock(TlvType::value, buf, sizeof(be));
+    boost::endian::native_to_big_inplace(value);
+    return encoder.prependByteArrayBlock(TlvType::value,
+                                         reinterpret_cast<const uint8_t*>(&value), sizeof(value));
   }
 };
 
diff --git a/tests/unit-tests/util/sha256.t.cpp b/tests/unit-tests/util/sha256.t.cpp
index 5775785..094f5f6 100644
--- a/tests/unit-tests/util/sha256.t.cpp
+++ b/tests/unit-tests/util/sha256.t.cpp
@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2013-2017 Regents of the University of California.
+ * Copyright (c) 2013-2018 Regents of the University of California.
  *
  * This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
  *
@@ -21,10 +21,10 @@
 
 #include "util/sha256.hpp"
 #include "util/string-helper.hpp"
-#include "encoding/endian.hpp"
 
 #include "boost-test.hpp"
 
+#include <boost/endian/conversion.hpp>
 #include <sstream>
 
 namespace ndn {
@@ -149,7 +149,7 @@
 
   Sha256 statefulSha256;
   for (size_t i = 0; i < sizeof(input) / sizeof(uint64_t); ++i) {
-    statefulSha256 << htobe64(input[i]);
+    statefulSha256 << boost::endian::native_to_big(input[i]);
   }
   ConstBufferPtr digest = statefulSha256.computeDigest();