diff --git a/dart-impl/mpi/src/dart_communication.c b/dart-impl/mpi/src/dart_communication.c
index 88ca9bc45..fd0cd4980 100644
--- a/dart-impl/mpi/src/dart_communication.c
+++ b/dart-impl/mpi/src/dart_communication.c
@@ -263,8 +263,11 @@ dart__mpi__get_basic(
   }
 
   if (remainder > 0) {
-    DART_LOG_TRACE("dart_get:  MPI_Get (dest %p, size %zu)",
-        dest_ptr, remainder);
+    DART_LOG_TRACE(
+        "dart_get:  MPI_Get (dest %p, size %zu, bytes: %zu)",
+        dest_ptr,
+        remainder,
+        remainder * dart__mpi__datatype_sizeof(dtype));
     CHECK_MPI_RET(
         dart__mpi__get(dest_ptr,
           remainder,
diff --git a/dash/include/dash/Atomic.h b/dash/include/dash/Atomic.h
index bd600d901..2c238609c 100644
--- a/dash/include/dash/Atomic.h
+++ b/dash/include/dash/Atomic.h
@@ -2,10 +2,10 @@
 #define DASH__ATOMIC_H__INCLUDED
 
 #include <dash/Meta.h>
+#include <dash/TypeTraits.h>
 
-#include <type_traits>
 #include <sstream>
-
+#include <type_traits>
 
 namespace dash {
 
@@ -46,32 +46,33 @@ namespace dash {
  * \endcode
  */
 template <typename T>
-class Atomic
-{
+class Atomic {
   static_assert(
-    dash::is_atomic_compatible<T>::value,
-    "Type not supported for atomic operations");
+      dash::is_atomic_compatible<T>::value,
+      "Type not supported for atomic operations");
 
-private:
-  T _value;
+ private:
+  T                 _value;
   typedef Atomic<T> self_t;
 
-public:
+ public:
   typedef T value_type;
 
   constexpr Atomic()                       = default;
   constexpr Atomic(const Atomic<T>& other) = default;
   constexpr Atomic(Atomic<T>&& other)      = default;
 
-  self_t& operator=(const self_t& other)   = default;
-  self_t& operator=(self_t&& other)        = default;
+  self_t& operator=(const self_t& other) = default;
+  self_t& operator=(self_t&& other) = default;
 
   /**
    * Initializes the underlying value with desired.
    * The initialization is not atomic
    */
   constexpr Atomic(T value)
-  : _value(value) { }
+    : _value(value)
+  {
+  }
 
   /**
    * Disabled assignment as this violates the atomic semantics
@@ -87,38 +88,35 @@ class Atomic
    * As \c Atomic is implemented as phantom type,
    * the value has to be queried using the \c dash::GlobRef
    */
-  operator T()         = delete;
+  operator T() = delete;
 
-  constexpr bool operator==(const self_t & other) const {
+  constexpr bool operator==(const self_t& other) const
+  {
     return _value == other._value;
   }
 
-  constexpr bool operator!=(const self_t & other) const {
+  constexpr bool operator!=(const self_t& other) const
+  {
     return !(*this == other);
   }
 
-  template<typename T_>
-  friend std::ostream & operator<<(
-    std::ostream     & os,
-    const Atomic<T_> & at);
+  template <typename T_>
+  friend std::ostream& operator<<(std::ostream& os, const Atomic<T_>& at);
 
-}; // class Atomic
+};  // class Atomic
 
-template<typename T>
-std::ostream & operator<<(
-  std::ostream    & os,
-  const Atomic<T> & at)
+template <typename T>
+std::ostream& operator<<(std::ostream& os, const Atomic<T>& at)
 {
   std::ostringstream ss;
   ss << dash::typestr(at) << "<phantom>";
   return operator<<(os, ss.str());
 }
 
-} // namespace dash
+}  // namespace dash
 
-#include <dash/atomic/Type_traits.h>
-#include <dash/atomic/GlobAtomicRef.h>
 #include <dash/atomic/GlobAtomicAsyncRef.h>
+#include <dash/atomic/GlobAtomicRef.h>
 #include <dash/atomic/Operation.h>
 
-#endif // DASH__ATOMIC_H__INCLUDED
+#endif  // DASH__ATOMIC_H__INCLUDED
diff --git a/dash/include/dash/Coarray.h b/dash/include/dash/Coarray.h
index 6dd3cbb0a..7392ffc3b 100644
--- a/dash/include/dash/Coarray.h
+++ b/dash/include/dash/Coarray.h
@@ -17,8 +17,6 @@
 
 #include <dash/Dimensional.h>
 
-#include <dash/atomic/Type_traits.h>
-
 /**
  * \defgroup DashCoarrayConcept  Coarray Concept
  *
diff --git a/dash/include/dash/GlobAsyncRef.h b/dash/include/dash/GlobAsyncRef.h
index 87c4e1e19..21b40e99c 100644
--- a/dash/include/dash/GlobAsyncRef.h
+++ b/dash/include/dash/GlobAsyncRef.h
@@ -124,43 +124,43 @@ class GlobAsyncRef
   /**
    * Copy constructor, implicit if at least one of the following conditions is
    * satisfied:
-   *    1) value_type and _T are exactly the same types (including const and
+   *    1) value_type and From are exactly the same types (including const and
    *    volatile qualifiers
-   *    2) value_type and _T are the same types after removing const and volatile
+   *    2) value_type and From are the same types after removing const and volatile
    *    qualifiers and value_type itself is const.
    */
-  template<typename _T,
-           int = internal::enable_implicit_copy_ctor<value_type, _T>::value>
-  GlobAsyncRef(const GlobAsyncRef<_T>& gref)
+  template<typename From,
+           int = detail::enable_implicit_copy_ctor<From, value_type>::value>
+  GlobAsyncRef(const GlobAsyncRef<From>& gref)
   : GlobAsyncRef(gref.dart_gptr())
   { }
 
   /**
    * Copy constructor, explicit if the following conditions are satisfied.
-   *    1) value_type and _T are the same types after excluding const and
+   *    1) value_type and From are the same types after excluding const and
    *    volatile qualifiers
-   *    2) value_type is const and _T is non-const
+   *    2) value_type is const and From is non-const
    */
   template <
-      typename _T,
-      long = internal::enable_explicit_copy_ctor<value_type, _T>::value>
-  explicit GlobAsyncRef(const GlobAsyncRef<_T>& gref)
+      typename From,
+      long = detail::enable_explicit_copy_ctor<From, value_type>::value>
+  explicit GlobAsyncRef(const GlobAsyncRef<From>& gref)
     : GlobAsyncRef(gref.dart_gptr())
   {
   }
 
   template <
-      typename _T,
-      int = internal::enable_implicit_copy_ctor<value_type, _T>::value>
-  GlobAsyncRef(const GlobRef<_T>& gref)
+      typename From,
+      int = detail::enable_implicit_copy_ctor<From, value_type>::value>
+  GlobAsyncRef(const GlobRef<From>& gref)
     : GlobAsyncRef(gref.dart_gptr())
   {
   }
 
   template <
-      typename _T,
-      long = internal::enable_explicit_copy_ctor<value_type, _T>::value>
-  explicit GlobAsyncRef(const GlobRef<_T>& gref)
+      typename From,
+      long = detail::enable_explicit_copy_ctor<From, value_type>::value>
+  explicit GlobAsyncRef(const GlobRef<From>& gref)
     : GlobAsyncRef(gref.dart_gptr())
   {
   }
@@ -192,20 +192,20 @@ class GlobAsyncRef
    * specified offset
    */
   template<typename MEMTYPE>
-  GlobAsyncRef<typename internal::add_const_from_type<T, MEMTYPE>::type>
+  GlobAsyncRef<typename detail::add_const_from_type<T, MEMTYPE>::type>
   member(size_t offs) const {
-    return GlobAsyncRef<typename internal::add_const_from_type<T, MEMTYPE>::type>(*this, offs);
+    return GlobAsyncRef<typename detail::add_const_from_type<T, MEMTYPE>::type>(*this, offs);
   }
 
   /**
    * Get the member via pointer to member
    */
   template<class MEMTYPE, class P=T>
-  GlobAsyncRef<typename internal::add_const_from_type<T, MEMTYPE>::type>
+  GlobAsyncRef<typename detail::add_const_from_type<T, MEMTYPE>::type>
   member(
     const MEMTYPE P::*mem) const {
     auto offs = (size_t) & (reinterpret_cast<P*>(0)->*mem);
-    return member<typename internal::add_const_from_type<T, MEMTYPE>::type>(offs);
+    return member<typename detail::add_const_from_type<T, MEMTYPE>::type>(offs);
   }
 
   /**
diff --git a/dash/include/dash/GlobPtr.h b/dash/include/dash/GlobPtr.h
index b82000f10..1b76c1929 100644
--- a/dash/include/dash/GlobPtr.h
+++ b/dash/include/dash/GlobPtr.h
@@ -10,7 +10,7 @@
 #include <dash/Exception.h>
 #include <dash/Init.h>
 
-#include <dash/atomic/Type_traits.h>
+#include <dash/TypeTraits.h>
 
 #include <dash/internal/Logging.h>
 #include <dash/iterator/internal/GlobPtrBase.h>
@@ -25,7 +25,7 @@ bool operator!=(const dart_gptr_t &lhs, const dart_gptr_t &rhs);
 
 namespace dash {
 
-  // Forward-declarations
+// Forward-declarations
 template <typename T>
 class GlobRef;
 
@@ -45,7 +45,7 @@ dash::gptrdiff_t distance(
  */
 template <typename ElementType, class GlobMemT>
 class GlobPtr {
-private:
+ private:
   typedef GlobPtr<ElementType, GlobMemT> self_t;
 
   using local_pointer_traits =
@@ -53,19 +53,22 @@ class GlobPtr {
 
   using memory_traits = dash::memory_space_traits<GlobMemT>;
 
-public:
-  typedef ElementType                          value_type;
-  typedef GlobPtr<const ElementType, GlobMemT> const_type;
-  typedef typename GlobMemT::index_type        index_type;
-  typedef typename GlobMemT::size_type         size_type;
-  typedef index_type                           gptrdiff_t;
+ public:
+  typedef ElementType                   value_type;
+  typedef typename GlobMemT::index_type index_type;
+  typedef typename GlobMemT::size_type  size_type;
+  typedef index_type                    gptrdiff_t;
 
   typedef typename local_pointer_traits::template rebind<value_type>
       local_type;
 
-  typedef typename local_pointer_traits::template rebind<value_type const>
+  typedef typename local_pointer_traits::template rebind<
+      typename std::add_const<value_type>::type>
       const_local_type;
 
+  typedef GlobPtr<typename std::add_const<ElementType>::type, GlobMemT>
+      const_type;
+
   typedef GlobMemT memory_type;
 
   /**
@@ -74,7 +77,7 @@ class GlobPtr {
   template <typename T>
   using rebind = dash::GlobPtr<T, GlobMemT>;
 
-public:
+ public:
   template <typename T, class MemSpaceT>
   friend class GlobPtr;
 
@@ -86,10 +89,11 @@ class GlobPtr {
   friend dash::gptrdiff_t distance(
       GlobPtr<T, MemSpaceT> gbegin, GlobPtr<T, MemSpaceT> gend);
 
-private:
+ private:
   // Raw global pointer used to initialize this pointer instance
   dart_gptr_t m_dart_pointer = DART_GPTR_NULL;
-public:
+
+ public:
   /**
    * Default constructor, underlying global address is unspecified.
    */
@@ -135,15 +139,14 @@ class GlobPtr {
   //clang-format on
   template <
       typename From,
-      typename = typename std::enable_if<
-          // We always allow GlobPtr<T> -> GlobPtr<void> or the other way)
-          // or if From is assignable to To (value_type)
-          dash::internal::is_pointer_assignable<
-              typename dash::remove_atomic<From>::type,
-              typename dash::remove_atomic<value_type>::type>::value>
-
-      ::type>
-  constexpr GlobPtr(const GlobPtr<From, GlobMemT> &other) DASH_NOEXCEPT
+      typename = typename std::enable_if<std::is_convertible<
+          // From pointer
+          typename std::add_pointer<
+              typename dash::remove_atomic<From>::type>::type,
+          // To pointer
+          typename std::add_pointer<
+              typename dash::remove_atomic<value_type>::type>::type>::value>>
+  constexpr GlobPtr(const GlobPtr<From, GlobMemT> &other)
     : m_dart_pointer(other.m_dart_pointer)
   {
   }
@@ -357,9 +360,13 @@ class GlobPtr {
   /**
    * Subscript operator.
    */
-  constexpr GlobRef<const value_type> operator[](gptrdiff_t n) const DASH_NOEXCEPT
+  constexpr auto operator[](gptrdiff_t n) const DASH_NOEXCEPT
   {
-    return GlobRef<const value_type>(self_t((*this) + n));
+    auto const_ptr = const_type{*this};
+    const_ptr += n;
+
+    return GlobRef<typename std::add_const<value_type>::type>(
+        std::move(const_ptr));
   }
 
   /**
@@ -367,7 +374,9 @@ class GlobPtr {
    */
   GlobRef<value_type> operator[](gptrdiff_t n) DASH_NOEXCEPT
   {
-    return GlobRef<value_type>(self_t((*this) + n));
+    auto ptr = *this;
+    ptr += n;
+    return GlobRef<value_type>(std::move(ptr));
   }
 
   /**
@@ -383,7 +392,9 @@ class GlobPtr {
    */
   constexpr GlobRef<const value_type> operator*() const DASH_NOEXCEPT
   {
-    return GlobRef<const value_type>(*this);
+    auto const_ptr = const_type{*this};
+    return GlobRef<typename std::add_const<value_type>::type>(
+        std::move(const_ptr));
   }
 
   /**
@@ -409,7 +420,8 @@ class GlobPtr {
    *           GlobPtr instance, or \c nullptr if the referenced element
    *           is not local to the calling unit.
    */
-  const value_type * local() const {
+  const value_type *local() const
+  {
     void *addr = nullptr;
     if (dart_gptr_getaddr(m_dart_pointer, &addr) == DART_OK) {
       return static_cast<const value_type *>(addr);
@@ -443,7 +455,6 @@ class GlobPtr {
     return !DART_GPTR_ISNULL(m_dart_pointer);
   }
 
-private:
   void increment(size_type offs) DASH_NOEXCEPT
   {
     if (offs == 0) {
@@ -457,8 +468,9 @@ class GlobPtr {
           "cannot increment a global null pointer");
     }
 
-    auto& reg = dash::internal::MemorySpaceRegistry::GetInstance();
-    auto const * mem_space = static_cast<const GlobMemT *>(reg.lookup(m_dart_pointer));
+    auto &      reg = dash::internal::MemorySpaceRegistry::GetInstance();
+    auto const *mem_space =
+        static_cast<const GlobMemT *>(reg.lookup(m_dart_pointer));
     // get a new dart with the requested offset
     auto const newPtr = dash::internal::increment<value_type>(
         m_dart_pointer,
@@ -544,14 +556,13 @@ dash::gptrdiff_t distance(
   using memory_space_traits = dash::memory_space_traits<MemSpaceT>;
 
   auto const begin = static_cast<dart_gptr_t>(gbegin);
-  auto const end = static_cast<dart_gptr_t>(gbegin);
+  auto const end   = static_cast<dart_gptr_t>(gbegin);
 
   DASH_ASSERT_EQ(begin.teamid, end.teamid, "teamid must be equal");
   DASH_ASSERT_EQ(begin.segid, end.segid, "segid must be equal");
 
-  auto &      reg = dash::internal::MemorySpaceRegistry::GetInstance();
-  auto const *mem_space =
-      static_cast<const MemSpaceT *>(reg.lookup(begin));
+  auto &      reg       = dash::internal::MemorySpaceRegistry::GetInstance();
+  auto const *mem_space = static_cast<const MemSpaceT *>(reg.lookup(begin));
 
   return dash::internal::distance<T>(
       static_cast<dart_gptr_t>(gbegin),
diff --git a/dash/include/dash/GlobRef.h b/dash/include/dash/GlobRef.h
index a87d95465..fe9edbb18 100644
--- a/dash/include/dash/GlobRef.h
+++ b/dash/include/dash/GlobRef.h
@@ -1,141 +1,52 @@
 #ifndef DASH__GLOBREF_H_
 #define DASH__GLOBREF_H_
 
-#include <dash/GlobPtr.h>
 #include <dash/Onesided.h>
 #include <dash/iterator/internal/GlobRefBase.h>
 
 namespace dash {
 
-// forward declaration
-template<typename T>
-class GlobAsyncRef;
-
 // Forward declarations
-template<typename T, class MemSpaceT> class GlobPtr;
+template<typename T> class GlobAsyncRef;
 
 template<typename T>
-class GlobRef
+class GlobRef : public detail::GlobRefBase<T>
 {
-  template<typename U>
-  friend std::ostream & operator<<(
-    std::ostream & os,
-    const GlobRef<U> & gref);
-
-  template <typename ElementT>
-  friend class GlobRef;
-
+  using base_t = detail::GlobRefBase<T>;
 public:
-  using value_type          = T;
-  using const_value_type    = typename std::add_const<T>::type;
-  using nonconst_value_type = typename std::remove_const<T>::type;
-  using self_t              = GlobRef<T>;
+  using value_type          = typename base_t::value_type;
+  using const_value_type    = typename base_t::const_value_type;
+  using nonconst_value_type = typename base_t::nonconst_value_type;
   using const_type          = GlobRef<const_value_type>;
-
-
-  template <class _T, class _M>
-  friend class GlobPtr;
-
-  template <class _T, class _Pat, class _M, class _Ptr, class _Ref>
-  friend class GlobIter;
-
-  template <class _T, class _Pat, class _M, class _Ptr, class _Ref>
-  friend class GlobViewIter;
-
 private:
-  /**
-   * PRIVATE: Constructor, creates an GlobRef object referencing an element in global
-   * memory.
-   */
-  template<class ElementT, class MemSpaceT>
-  explicit constexpr GlobRef(
-    /// Pointer to referenced object in global memory
-    const GlobPtr<ElementT, MemSpaceT> & gptr)
-  : GlobRef(gptr.dart_gptr())
-  { }
-
-public:
-  /**
-   * Reference semantics forbid declaration without definition.
-   */
-  GlobRef() = delete;
+  template <class T_>
+  friend class GlobRef; //required for .member()
 
-  GlobRef(const GlobRef & other) = delete;
 
-  /**
-   * Constructor, creates an GlobRef object referencing an element in global
-   * memory.
-   */
-  explicit constexpr GlobRef(dart_gptr_t dart_gptr) noexcept
-  : _gptr(dart_gptr)
-  {
-  }
-
-  /**
-   * Copy constructor, implicit if at least one of the following conditions is
-   * satisfied:
-   *    1) value_type and _T are exactly the same types (including const and
-   *    volatile qualifiers
-   *    2) value_type and _T are the same types after removing const and
-   *    volatile qualifiers and value_type itself is const.
-   */
-  template <
-      typename _T,
-      long = internal::enable_implicit_copy_ctor<value_type, _T>::value>
-  constexpr GlobRef(const GlobRef<_T>& gref) noexcept
-    : GlobRef(gref.dart_gptr())
-  {
-  }
-
-  /**
-   * Copy constructor, explicit if the following conditions are satisfied.
-   *    1) value_type and _T are the same types after excluding const and
-   *    volatile qualifiers
-   *    2) value_type is const and _T is non-const
-   */
-  template <
-      typename _T,
-      int = internal::enable_explicit_copy_ctor<value_type, _T>::value>
-  explicit constexpr GlobRef(const GlobRef<_T>& gref) noexcept
-    : GlobRef(gref.dart_gptr())
-  {
-  }
+  template<typename U>
+  friend std::ostream & operator<<(
+    std::ostream & os,
+    const GlobRef<U> & gref);
 
+public:
+  //inherit all constructors from parent class
+  using detail::GlobRefBase<T>::GlobRefBase;
   /**
-   * Constructor to convert \c GlobAsyncRef to GlobRef. Set to explicit to
-   * avoid unintendet conversion
+   * COPY Construction
    */
-  template <
-      typename _T,
-      long = internal::enable_implicit_copy_ctor<value_type, _T>::value>
-  constexpr GlobRef(const GlobAsyncRef<_T>& gref) noexcept
-    : _gptr(gref.dart_gptr())
-  {
-  }
-
-  template <
-      typename _T,
-      int = internal::enable_explicit_copy_ctor<value_type, _T>::value>
-  explicit constexpr GlobRef(const GlobAsyncRef<_T>& gref) noexcept
-    : GlobRef(gref.dart_gptr())
-  {
-  }
+  GlobRef(const GlobRef & other) = default;
 
   /**
-   * Move Constructor
+   * MOVE Construction
    */
-  GlobRef(self_t&& other) noexcept
-    :_gptr(std::move(other._gptr))
-  {
-    DASH_LOG_TRACE("GlobRef.GlobRef(GlobRef &&)", _gptr);
-  }
+  GlobRef(GlobRef && other) = default;
 
   /**
-   * Copy Assignment
+   * Copy Assignment: We copy the value behind this address, NOT the reference
    */
-  const self_t & operator=(const self_t & other) const
+  const GlobRef & operator=(const GlobRef & other) const
   {
-    if (DART_GPTR_EQUAL(_gptr, other._gptr)) {
+    if (DART_GPTR_EQUAL(this->dart_gptr(), other.dart_gptr())) {
       return *this;
     }
     set(static_cast<T>(other));
@@ -145,8 +56,9 @@ class GlobRef
   /**
    * Move Assignment: Redirects to Copy Assignment
    */
-  self_t& operator=(self_t&& other) noexcept {
-    DASH_LOG_TRACE("GlobRef.operator=(GlobRef &&)", _gptr);
+  GlobRef& operator=(GlobRef&& other) {
+    auto dart_pointer = this->dart_gptr();
+    DASH_LOG_TRACE("GlobRef.operator=(GlobRef &&)", dart_pointer);
     operator=(other);
     return *this;
   }
@@ -154,7 +66,8 @@ class GlobRef
   /**
    * Value-assignment operator.
    */
-  const self_t & operator=(const value_type& val) const {
+  auto& operator=(const value_type& val) const {
+    static_assert(!std::is_const<value_type>::value, "must not be const");
     set(val);
     return *this;
   }
@@ -162,67 +75,44 @@ class GlobRef
 
   operator nonconst_value_type() const {
     DASH_LOG_TRACE("GlobRef.T()", "conversion operator");
-    DASH_LOG_TRACE_VAR("GlobRef.T()", _gptr);
+    auto dart_pointer = this->dart_gptr();
+    DASH_LOG_TRACE_VAR("GlobRef.T()", dart_pointer);
     nonconst_value_type t;
-    dash::internal::get_blocking(_gptr, &t, 1);
-    DASH_LOG_TRACE_VAR("GlobRef.T >", _gptr);
+    dash::internal::get_blocking(dart_pointer, &t, 1);
     return t;
   }
 
-  template <typename ValueT>
-  bool operator==(const GlobRef<ValueT> & other) const {
-    ValueT val = other.get();
-    return operator==(val);
-  }
-
-  template <typename ValueT>
-  bool operator!=(const GlobRef<ValueT> & other) const {
-    return !(*this == other);
-  }
-
-  template<typename ValueT>
-  constexpr bool operator==(const ValueT& value) const
-  {
-    return static_cast<T>(*this) == value;
-  }
-
-  template<typename ValueT>
-  constexpr bool operator!=(const ValueT& value) const
-  {
-    return !(*this == value);
-  }
-
   void
   set(const value_type & val) const {
     static_assert(std::is_same<value_type, nonconst_value_type>::value,
                   "Cannot modify value referenced by GlobRef<const T>!");
 
     DASH_LOG_TRACE_VAR("GlobRef.set()", val);
-    DASH_LOG_TRACE_VAR("GlobRef.set", _gptr);
-    // TODO: Clarify if dart-call can be avoided if
-    //       _gptr->is_local()
-    dash::internal::put_blocking(_gptr, &val, 1);
-    DASH_LOG_TRACE_VAR("GlobRef.set >", _gptr);
+    auto dart_pointer = this->dart_gptr();
+    DASH_LOG_TRACE_VAR("GlobRef.set", dart_pointer);
+    dash::internal::put_blocking(dart_pointer, &val, 1);
   }
 
   nonconst_value_type get() const {
     DASH_LOG_TRACE("T GlobRef.get()", "explicit get");
-    DASH_LOG_TRACE_VAR("GlobRef.T()", _gptr);
+    auto dart_pointer = this->dart_gptr();
     nonconst_value_type t;
-    dash::internal::get_blocking(_gptr, &t, 1);
+    dash::internal::get_blocking(dart_pointer, &t, 1);
     return t;
   }
 
   void get(nonconst_value_type *tptr) const {
     DASH_LOG_TRACE("GlobRef.get(T*)", "explicit get into provided ptr");
-    DASH_LOG_TRACE_VAR("GlobRef.T()", _gptr);
-    dash::internal::get_blocking(_gptr, tptr, 1);
+    auto dart_pointer = this->dart_gptr();
+    DASH_LOG_TRACE_VAR("GlobRef.T()", dart_pointer);
+    dash::internal::get_blocking(dart_pointer, tptr, 1);
   }
 
   void get(nonconst_value_type& tref) const {
     DASH_LOG_TRACE("GlobRef.get(T&)", "explicit get into provided ref");
-    DASH_LOG_TRACE_VAR("GlobRef.T()", _gptr);
-    dash::internal::get_blocking(_gptr, &tref, 1);
+    auto dart_pointer = this->dart_gptr();
+    DASH_LOG_TRACE_VAR("GlobRef.T()", dart_pointer);
+    dash::internal::get_blocking(dart_pointer, &tref, 1);
   }
 
   void
@@ -230,8 +120,9 @@ class GlobRef
     static_assert(std::is_same<value_type, nonconst_value_type>::value,
                   "Cannot assign to GlobRef<const T>!");
     DASH_LOG_TRACE("GlobRef.put(T&)", "explicit put of provided ref");
-    DASH_LOG_TRACE_VAR("GlobRef.T()", _gptr);
-    dash::internal::put_blocking(_gptr, &tref, 1);
+    auto dart_pointer = this->dart_gptr();
+    DASH_LOG_TRACE_VAR("GlobRef.T()", dart_pointer);
+    dash::internal::put_blocking(dart_pointer, &tref, 1);
   }
 
   void
@@ -239,35 +130,22 @@ class GlobRef
     static_assert(std::is_same<value_type, nonconst_value_type>::value,
                   "Cannot modify value referenced by GlobRef<const T>!");
     DASH_LOG_TRACE("GlobRef.put(T*)", "explicit put of provided ptr");
-    DASH_LOG_TRACE_VAR("GlobRef.T()", _gptr);
-    dash::internal::put_blocking(_gptr, tptr, 1);
+    auto dart_pointer = this->dart_gptr();
+    DASH_LOG_TRACE_VAR("GlobRef.T()", dart_pointer);
+    dash::internal::put_blocking(dart_pointer, tptr, 1);
   }
 
-  const self_t &
+  const GlobRef &
   operator+=(const nonconst_value_type& ref) const {
     static_assert(std::is_same<value_type, nonconst_value_type>::value,
                   "Cannot modify value referenced by GlobRef<const T>!");
-#if 0
-    // TODO: Alternative implementation, possibly more efficient:
-    T add_val = ref;
-    T old_val;
-    dart_ret_t result = dart_fetch_and_op(
-                          _gptr,
-                          reinterpret_cast<void *>(&add_val),
-                          reinterpret_cast<void *>(&old_val),
-                          dash::dart_datatype<T>::value,
-                          dash::plus<T>().dart_operation(),
-                          dash::Team::All().dart_id());
-    dart_flush(_gptr);
-  #else
     nonconst_value_type val  = operator nonconst_value_type();
     val   += ref;
     operator=(val);
-  #endif
     return *this;
   }
 
-  const self_t &
+  const GlobRef &
   operator-=(const nonconst_value_type& ref) const {
     static_assert(std::is_same<value_type, nonconst_value_type>::value,
                   "Cannot modify value referenced by GlobRef<const T>!");
@@ -277,7 +155,7 @@ class GlobRef
     return *this;
   }
 
-  const self_t &
+  const GlobRef &
   operator++() const {
     static_assert(std::is_same<value_type, nonconst_value_type>::value,
                   "Cannot modify value referenced by GlobRef<const T>!");
@@ -296,7 +174,7 @@ class GlobRef
     return res;
   }
 
-  const self_t &
+  const GlobRef &
   operator--() const {
     static_assert(std::is_same<value_type, nonconst_value_type>::value,
                   "Cannot modify value referenced by GlobRef<const T>!");
@@ -315,7 +193,7 @@ class GlobRef
     return res;
   }
 
-  const self_t &
+  const GlobRef &
   operator*=(const_value_type& ref) const {
     static_assert(std::is_same<value_type, nonconst_value_type>::value,
                   "Cannot modify value referenced by GlobRef<const T>!");
@@ -325,7 +203,7 @@ class GlobRef
     return *this;
   }
 
-  const self_t &
+  const GlobRef &
   operator/=(const_value_type& ref) const {
     static_assert(std::is_same<value_type, nonconst_value_type>::value,
                   "Cannot modify value referenced by GlobRef<const T>!");
@@ -335,7 +213,7 @@ class GlobRef
     return *this;
   }
 
-  const self_t &
+  const GlobRef &
   operator^=(const_value_type& ref) const {
     static_assert(std::is_same<value_type, nonconst_value_type>::value,
                   "Cannot modify value referenced by GlobRef<const T>!");
@@ -345,44 +223,42 @@ class GlobRef
     return *this;
   }
 
-  constexpr dart_gptr_t dart_gptr() const noexcept {
-    return _gptr;
-  }
-
   /**
    * Checks whether the globally referenced element is in
    * the calling unit's local memory.
    */
   bool is_local() const {
     dart_team_unit_t luid;
-    dart_team_myid(_gptr.teamid, &luid);
-    return _gptr.unitid == luid.id;
+    auto dart_pointer = this->dart_gptr();
+    dart_team_myid(dart_pointer.teamid, &luid);
+    return dart_pointer.unitid == luid.id;
   }
 
   /**
    * Get a global ref to a member of a certain type at the
    * specified offset
    */
-  template<typename MEMTYPE>
-  GlobRef<typename internal::add_const_from_type<T, MEMTYPE>::type>
-  member(size_t offs) const {
-    dart_gptr_t dartptr = _gptr;
-    DASH_ASSERT_RETURNS(
-      dart_gptr_incaddr(&dartptr, offs),
-      DART_OK);
-    return GlobRef<typename internal::add_const_from_type<T, MEMTYPE>::type>(dartptr);
+  template <typename MEMTYPE>
+  auto member(size_t offs) const DASH_NOEXCEPT
+  {
+    using ref_t = GlobRef<typename std::conditional<
+        std::is_const<value_type>::value,
+        typename std::add_const<MEMTYPE>::type,
+        MEMTYPE>::type>;
+
+    dart_gptr_t dartptr = this->dart_gptr();
+    DASH_ASSERT_RETURNS(dart_gptr_incaddr(&dartptr, offs), DART_OK);
+
+    return ref_t{dartptr};
   }
 
   /**
    * Get the member via pointer to member
    */
-  template<class MEMTYPE, class P=T>
-  GlobRef<typename internal::add_const_from_type<T, MEMTYPE>::type>
-  member(
-    const MEMTYPE P::*mem) const {
-    // TODO: Thaaaat ... looks hacky.
-    auto offs = (size_t) & (reinterpret_cast<P*>(0)->*mem);
-    return member<typename internal::add_const_from_type<T, MEMTYPE>::type>(offs);
+  template <class MEMTYPE, class P = T>
+  auto member(const MEMTYPE P::*mem) const DASH_NOEXCEPT
+  {
+    return member<MEMTYPE>(detail::offset_of(mem));
   }
 
   /**
@@ -396,8 +272,29 @@ class GlobRef
     b = tmp;
   }
 
-private:
-  dart_gptr_t _gptr{};
+  template <typename ValueT>
+  bool operator==(const GlobRef<ValueT> & other) const {
+    ValueT val = other.get();
+    return operator==(val);
+  }
+
+  template <typename ValueT>
+  bool operator!=(const GlobRef<ValueT> & other) const {
+    return !(*this == other);
+  }
+
+  template<typename ValueT>
+  constexpr bool operator==(const ValueT& value) const
+  {
+    return static_cast<T>(*this) == value;
+  }
+
+  template<typename ValueT>
+  constexpr bool operator!=(const ValueT& value) const
+  {
+    return !(*this == value);
+  }
+
 };
 
 template<typename T>
@@ -406,13 +303,14 @@ std::ostream & operator<<(
   const GlobRef<T> & gref)
 {
   char buf[100]; //
+  auto dart_pointer = gref.dart_gptr();
   sprintf(buf,
           "(%06X|%02X|%04X|%04X|%016lX)",
-          gref._gptr.unitid,
-          gref._gptr.flags,
-          gref._gptr.segid,
-          gref._gptr.teamid,
-          gref._gptr.addr_or_offs.offset);
+          dart_pointer.unitid,
+          dart_pointer.flags,
+          dart_pointer.segid,
+          dart_pointer.teamid,
+          dart_pointer.addr_or_offs.offset);
   os << dash::typestr(gref) << buf;
   return os;
 }
diff --git a/dash/include/dash/Shared.h b/dash/include/dash/Shared.h
index 3d2f99459..2ed71bc22 100644
--- a/dash/include/dash/Shared.h
+++ b/dash/include/dash/Shared.h
@@ -242,7 +242,7 @@ class Shared {
     DASH_LOG_DEBUG_VAR("Shared.cget", m_owner);
     DASH_LOG_DEBUG_VAR("Shared.get", m_glob_pointer);
     DASH_ASSERT(static_cast<bool>(m_glob_pointer));
-    return reference(m_glob_pointer.dart_gptr());
+    return reference(m_glob_pointer);
   }
 
   /**
@@ -254,7 +254,7 @@ class Shared {
     DASH_LOG_DEBUG_VAR("Shared.get", m_owner);
     DASH_LOG_DEBUG_VAR("Shared.get", m_glob_pointer);
     DASH_ASSERT(m_glob_pointer);
-    return const_reference(m_glob_pointer.dart_gptr());
+    return const_reference(m_glob_pointer);
   }
 
   /**
diff --git a/dash/include/dash/TypeTraits.h b/dash/include/dash/TypeTraits.h
new file mode 100644
index 000000000..7b412986a
--- /dev/null
+++ b/dash/include/dash/TypeTraits.h
@@ -0,0 +1,103 @@
+#ifndef DASH__TYPE_TRAITS_H_
+#define DASH__TYPE_TRAITS_H_
+
+#include <type_traits>
+
+///////////////////////////////////////////////////////////////////////////////
+// Container Traits
+///////////////////////////////////////////////////////////////////////////////
+
+namespace dash {
+/**
+ * Type trait indicating whether the specified type is eligible for
+ * elements of DASH containers.
+ */
+template <class T>
+struct is_container_compatible
+  : public std::integral_constant<
+        bool,
+        std::is_default_constructible<T>::value &&
+            std::is_trivially_copyable<T>::value> {
+};
+
+}  // namespace dash
+
+///////////////////////////////////////////////////////////////////////////////
+// Atomic Traits
+///////////////////////////////////////////////////////////////////////////////
+
+/// Forward decls
+namespace dash {
+
+template <class T>
+class Atomic;
+
+}  // namespace dash
+
+namespace std {
+/**
+ * type traits for \c dash::Atomic
+ *
+ * returns an atomic with a const subtype
+ */
+template <class T>
+struct add_const<dash::Atomic<T>> {
+  using type = dash::Atomic<typename std::add_const<T>::type>;
+};
+
+}  // namespace std
+
+namespace dash {
+
+namespace detail {
+template <typename T>
+struct remove_atomic_impl {
+  using type = T;
+};
+
+template <typename T>
+struct remove_atomic_impl<dash::Atomic<T>> {
+  using type = T;
+};
+
+template <typename T>
+struct is_atomic_impl : std::false_type {
+};
+template <typename T>
+struct is_atomic_impl<dash::Atomic<T>> : std::true_type {
+};
+
+}  // namespace detail
+
+/**
+ * type traits for \c dash::Atomic
+ *
+ * returns the sub type of a \cdash::Atomic
+ */
+template <typename T>
+struct remove_atomic {
+  using type = typename detail::remove_atomic_impl<T>::type;
+};
+
+/**
+ * type traits for \c dash::Atomic
+ *
+ * true if type is atomic
+ * false otherwise
+ */
+template <typename T>
+struct is_atomic : detail::is_atomic_impl<T> {
+};
+
+/**
+ * Type trait indicating whether a type can be used for global atomic
+ * operations.
+ */
+template <typename T>
+struct is_atomic_compatible
+  : public std::integral_constant<bool, std::is_arithmetic<T>::value> {
+};
+
+}  // namespace dash
+
+#endif
diff --git a/dash/include/dash/Types.h b/dash/include/dash/Types.h
index 6062565f7..c5494c446 100644
--- a/dash/include/dash/Types.h
+++ b/dash/include/dash/Types.h
@@ -73,20 +73,6 @@ typedef internal::default_unsigned_index   default_size_t;
  */
 typedef internal::default_signed_index         gptrdiff_t;
 
-template<
-  dash::dim_t NumDimensions,
-  typename IndexType = dash::default_index_t>
-struct Point {
-  ::std::array<IndexType, NumDimensions> coords;
-};
-
-template<
-  dash::dim_t NumDimensions,
-  typename SizeType = dash::default_extent_t>
-struct Extent {
-  ::std::array<SizeType, NumDimensions> sizes;
-};
-
 #ifdef DOXYGEN
 
 /**
@@ -228,31 +214,6 @@ struct dart_punned_datatype {
 
 #endif // DOXYGEN
 
-/**
- * Type trait indicating whether the specified type is eligible for
- * elements of DASH containers.
- */
-template <class T>
-struct is_container_compatible :
-  public std::integral_constant<bool,
-              std::is_standard_layout<T>::value
-#ifdef DASH_HAVE_STD_TRIVIALLY_COPYABLE
-              && std::is_trivially_copyable<T>::value
-#elif defined DASH_HAVE_TRIVIAL_COPY_INTRINSIC
-              && __has_trivial_copy(T)
-#endif
-         >
-{ };
-
-/**
- * Type trait indicating whether a type can be used for global atomic
- * operations.
- */
-template <typename T>
-struct is_atomic_compatible
-: public std::integral_constant<bool, std::is_arithmetic<T>::value>
-{ };
-
 /**
  * Type trait indicating whether a type can be used for arithmetic
  * operations in global memory space.
@@ -264,28 +225,6 @@ struct is_arithmetic
            dash::dart_datatype<T>::value != DART_TYPE_UNDEFINED >
 { };
 
-/**
- * Type trait indicating whether a type has a comparision operator==
- * defined.
- * \code
- * bool test = has_operator_equal<MyType>::value;
- * bool test = has_operator_equal<MyType, int>::value;
- * \endcode
- */
-template<class T, class EqualTo>
-struct has_operator_equal_impl
-{
-    template<class U, class V>
-    static auto test(U*) -> decltype(std::declval<U>() == std::declval<V>());
-    template<typename, typename>
-    static auto test(...) -> std::false_type;
-
-    using type = typename std::is_same<bool, decltype(test<T, EqualTo>(0))>::type;
-};
-
-template<class T, class EqualTo = T>
-struct has_operator_equal : has_operator_equal_impl<T, EqualTo>::type {};
-
 /**
  * Convencience wrapper to determine the DART type and number of elements
  * required for the given template parameter type \c T and the desired number of
diff --git a/dash/include/dash/algorithm/Fill.h b/dash/include/dash/algorithm/Fill.h
index edbaa26c6..6b5bf9624 100644
--- a/dash/include/dash/algorithm/Fill.h
+++ b/dash/include/dash/algorithm/Fill.h
@@ -40,7 +40,6 @@ void fill(
   /// Value which will be assigned to the elements in range [first, last)
   const typename GlobIterType::value_type & value)
 {
-  typedef typename GlobIterType::index_type index_t;
   typedef typename GlobIterType::value_type value_t;
 
   // Global iterators to local range:
@@ -49,6 +48,8 @@ void fill(
   value_t * llast       = index_range.end;
 
 #ifdef DASH_ENABLE_OPENMP
+  typedef typename GlobIterType::index_type index_t;
+
   dash::util::UnitLocality uloc;
   auto n_threads = uloc.num_domain_threads();
   auto nlocal    = llast - lfirst;
diff --git a/dash/include/dash/algorithm/SUMMA.h b/dash/include/dash/algorithm/SUMMA.h
index 5681ca525..ff83e8eb7 100644
--- a/dash/include/dash/algorithm/SUMMA.h
+++ b/dash/include/dash/algorithm/SUMMA.h
@@ -429,8 +429,6 @@ void summa(
     // Block coordinates for next block multiplication result:
     l_block_c_get       = l_block_c_comp;
     l_block_c_get_view  = l_block_c_comp_view;
-    l_block_c_get_row   = l_block_c_get_row;
-    l_block_c_get_col   = l_block_c_get_col;
     DASH_LOG_TRACE("dash::summa", "summa.block.comp", "C.local.block",
                    "l_block_idx:", lb,
                    "row:",         l_block_c_comp_row,
diff --git a/dash/include/dash/atomic/GlobAtomicAsyncRef.h b/dash/include/dash/atomic/GlobAtomicAsyncRef.h
index dfdf789f3..b2cd029ee 100644
--- a/dash/include/dash/atomic/GlobAtomicAsyncRef.h
+++ b/dash/include/dash/atomic/GlobAtomicAsyncRef.h
@@ -101,40 +101,40 @@ class GlobAsyncRef<dash::Atomic<T>>
   /**
    * Copy constructor: Implicit if at least one of the following conditions is
    * satisfied:
-   *    1) value_type and _T are exactly the same types (including const and
+   *    1) value_type and From are exactly the same types (including const and
    *    volatile qualifiers
-   *    2) value_type and _T are the same types after removing const and
+   *    2) value_type and From are the same types after removing const and
    *    volatile qualifiers and value_type itself is const.
    */
-  template<typename _T,
-           int = internal::enable_implicit_copy_ctor<value_type, _T>::value>
-  GlobAsyncRef(const GlobAsyncRef<dash::Atomic<_T>>& gref)
+  template<typename From,
+           int = detail::enable_implicit_copy_ctor<From, value_type>::value>
+  GlobAsyncRef(const GlobAsyncRef<dash::Atomic<From>>& gref)
   : GlobAsyncRef(gref.dart_gptr())
   { }
 
   /**
    * Copy constructor: Explicit if the following conditions are satisfied.
-   *    1) value_type and _T are the same types after excluding const and
+   *    1) value_type and From are the same types after excluding const and
    *    volatile qualifiers
-   *    2) value_type is const and _T is non-const
+   *    2) value_type is const and From is non-const
    */
-  template<typename _T,
-           long = internal::enable_explicit_copy_ctor<value_type, _T>::value>
+  template<typename From,
+           long = detail::enable_explicit_copy_ctor<From, value_type>::value>
   explicit
-  GlobAsyncRef(const GlobAsyncRef<dash::Atomic<_T>>& gref)
+  GlobAsyncRef(const GlobAsyncRef<dash::Atomic<From>>& gref)
   : GlobAsyncRef(gref.dart_gptr())
   { }
 
-  template<typename _T,
-           int = internal::enable_implicit_copy_ctor<value_type, _T>::value>
-  GlobAsyncRef(const GlobRef<dash::Atomic<_T>>& gref)
+  template<typename From,
+           int = detail::enable_implicit_copy_ctor<From, value_type>::value>
+  GlobAsyncRef(const GlobRef<dash::Atomic<From>>& gref)
   : GlobAsyncRef(gref.dart_gptr())
   { }
 
-  template<typename _T,
-           long = internal::enable_explicit_copy_ctor<value_type, _T>::value>
+  template<typename From,
+           long = detail::enable_explicit_copy_ctor<From, value_type>::value>
   explicit
-  GlobAsyncRef(const GlobRef<dash::Atomic<_T>>& gref)
+  GlobAsyncRef(const GlobRef<dash::Atomic<From>>& gref)
   : GlobAsyncRef(gref.dart_gptr())
   { }
 
diff --git a/dash/include/dash/atomic/GlobAtomicRef.h b/dash/include/dash/atomic/GlobAtomicRef.h
index a3cbc4af4..4c81b5d0f 100644
--- a/dash/include/dash/atomic/GlobAtomicRef.h
+++ b/dash/include/dash/atomic/GlobAtomicRef.h
@@ -1,8 +1,6 @@
 #ifndef DASH__ATOMIC_GLOBREF_H_
 #define DASH__ATOMIC_GLOBREF_H_
 
-#include <dash/GlobPtr.h>
-//#include <dash/Types.h>
 #include <dash/algorithm/Operation.h>
 #include <dash/iterator/internal/GlobRefBase.h>
 
@@ -15,12 +13,17 @@ class Atomic;
 
 template <typename T>
 class GlobAsyncRef;
+
+template <typename T>
+class GlobRef;
+
 /**
  * Specialization for atomic values. All atomic operations are
  * \c const as the \c GlobRef does not own the atomic values.
  */
 template <typename T>
-class GlobRef<dash::Atomic<T>> {
+class GlobRef<dash::Atomic<T>>: public detail::GlobRefBase<dash::Atomic<T>>
+{
   /* Notes on type compatibility:
    *
    * - The general support of atomic operations on values of type T is
@@ -34,6 +37,8 @@ class GlobRef<dash::Atomic<T>> {
   template <typename U>
   friend std::ostream& operator<<(std::ostream& os, const GlobRef<U>& gref);
 
+  using base_t = detail::GlobRefBase<dash::Atomic<T>>;
+
 public:
   using value_type          = T;
   using const_value_type    = typename std::add_const<T>::type;
@@ -45,119 +50,38 @@ class GlobRef<dash::Atomic<T>> {
   using const_type          = GlobRef<const_atomic_t>;
   using nonconst_type       = GlobRef<dash::Atomic<nonconst_value_type>>;
 
-private:
-  dart_gptr_t _gptr{};
-
-
 public:
-  /**
-   * Reference semantics forbid declaration without definition.
-   */
-  GlobRef() = delete;
 
-  //TODO rkowalewski: Clarify constructors by passing various pointer types
 
-  /**
-   * Constructor: Create an atomic reference to a element in global memory
-   */
-  explicit GlobRef(dart_gptr_t dart_gptr)
-    : _gptr(dart_gptr)
-  {
-    DASH_LOG_TRACE_VAR("GlobRef(dart_gptr_t)", dart_gptr);
-  }
+  //inherit all constructors from parent class
+  using detail::GlobRefBase<dash::Atomic<T>>::GlobRefBase;
 
-  /**
-   * Constructor, creates an GlobRef object referencing an element in global
-   * memory.
-   */
-  template <typename PatternT>
-  explicit GlobRef(
-      /// Pointer to referenced object in global memory
-      const GlobPtr<const_atomic_t, PatternT>& gptr)
-    : GlobRef(gptr.dart_gptr())
+  template <class MemSpaceT>
+  GlobRef(dash::GlobPtr<value_type, MemSpaceT> const& gptr)
+    : base_t(gptr.dart_gptr())
   {
-    static_assert(
-        std::is_same<value_type, const_value_type>::value,
-        "Cannot create GlobRef<Atomic<T>> from GlobPtr<Atomic<const T>>!");
   }
 
-  template <typename PatternT>
-  explicit GlobRef(
-      /// Pointer to referenced object in global memory
-      const GlobPtr<nonconst_atomic_t, PatternT>& gptr)
-    : GlobRef(gptr.dart_gptr())
+  template <class MemSpaceT>
+  GlobRef(dash::GlobPtr<value_type, MemSpaceT>&& gptr)
+    : base_t(std::move(gptr.dart_gptr()))
   {
   }
 
   /**
-   * Copy constructor: Implicit if at least one of the following conditions is
-   * satisfied:
-   *    1) value_type and _T are exactly the same types (including const and
-   *    volatile qualifiers
-   *    2) value_type and _T are the same types after removing const and
-   *    volatile qualifiers and value_type itself is const.
+   * COPY Construction
    */
-  template <
-      typename _T,
-      int = internal::enable_implicit_copy_ctor<value_type, _T>::value>
-  GlobRef(const GlobRef<dash::Atomic<_T>>& gref)
-    : GlobRef(gref.dart_gptr())
-  {
-  }
-
-  /**
-   * Copy constructor: Explicit if the following conditions are satisfied.
-   *    1) value_type and _T are the same types after excluding const and
-   *    volatile qualifiers
-   *    2) value_type is const and _T is non-const
-   */
-  template <
-      typename _T,
-      long = internal::enable_explicit_copy_ctor<value_type, _T>::value>
-  explicit GlobRef(const GlobRef<dash::Atomic<_T>>& gref)
-    : GlobRef(gref.dart_gptr())
-  {
-  }
-
-  /**
-   * Copy constructor: Implicit if at least one of the following conditions is
-   * satisfied:
-   *    1) value_type and _T are exactly the same types (including const and
-   *    volatile qualifiers
-   *    2) value_type and _T are the same types after removing const and
-   *    volatile qualifiers and value_type itself is const.
-   */
-  template <
-      typename _T,
-      int = internal::enable_implicit_copy_ctor<value_type, _T>::value>
-  GlobRef(const GlobAsyncRef<dash::Atomic<_T>>& gref)
-    : GlobRef(gref.dart_gptr())
-  {
-  }
-
-  /**
-   * Copy constructor: Explicit if the following conditions are satisfied.
-   *    1) value_type and _T are the same types after excluding const and
-   *    volatile qualifiers
-   *    2) value_type is const and _T is non-const
-   */
-  template <
-      typename _T,
-      long = internal::enable_explicit_copy_ctor<value_type, _T>::value>
-  explicit GlobRef(const GlobAsyncRef<dash::Atomic<_T>>& gref)
-    : GlobRef(gref.dart_gptr())
-  {
-  }
+  GlobRef(const GlobRef & other) = default;
 
   /**
    * Move Constructor.
    */
-  GlobRef(self_t&& other) = default;
+  GlobRef(GlobRef&& other) = default;
 
   /**
    * Copy Assignment: Copies atomically the value from other
    */
-  self_t& operator=(const self_t& other) const
+  GlobRef& operator=(const GlobRef& other) const
   {
     store(static_cast<atomic_t>(other));
     return *this;
@@ -166,7 +90,7 @@ class GlobRef<dash::Atomic<T>> {
   /**
    * Move Assignment: Redirects to Copy Assignment
    */
-  self_t& operator=(self_t&& other) {
+  GlobRef& operator=(GlobRef&& other) {
     operator=(other);
     return *this;
   }
@@ -176,18 +100,13 @@ class GlobRef<dash::Atomic<T>> {
     return load();
   }
 
-  dart_gptr_t dart_gptr() const
-  {
-    return _gptr;
-  }
-
   /**
    * Checks whether the globally referenced element is in
    * the calling unit's local memory.
    */
   bool is_local() const
   {
-    return dash::internal::is_local(_gptr);
+    return dash::internal::is_local(this->dart_gptr());
   }
 
   /**
@@ -218,15 +137,16 @@ class GlobRef<dash::Atomic<T>> {
     static_assert(
         std::is_same<value_type, nonconst_value_type>::value,
         "Cannot modify value referenced by GlobRef<Atomic<const T>>!");
+    auto gptr = this->dart_gptr();
     DASH_LOG_DEBUG_VAR("GlobRef<Atomic>.store()", value);
-    DASH_LOG_TRACE_VAR("GlobRef<Atomic>.store", _gptr);
+    DASH_LOG_TRACE_VAR("GlobRef<Atomic>.store", gptr);
     dart_ret_t ret = dart_accumulate(
-        _gptr,
+        this->dart_gptr(),
         &value,
         1,
         dash::dart_punned_datatype<T>::value,
         DART_OP_REPLACE);
-    dart_flush(_gptr);
+    dart_flush(gptr);
     DASH_ASSERT_EQ(DART_OK, ret, "dart_accumulate failed");
     DASH_LOG_DEBUG("GlobRef<Atomic>.store >");
   }
@@ -247,16 +167,17 @@ class GlobRef<dash::Atomic<T>> {
         "Basic type or type smaller than 64bit required for "
         "atomic get!");
     DASH_LOG_DEBUG("GlobRef<Atomic>.load()");
-    DASH_LOG_TRACE_VAR("GlobRef<Atomic>.load", _gptr);
+    auto gptr = this->dart_gptr();
+    DASH_LOG_TRACE_VAR("GlobRef<Atomic>.load", gptr);
     nonconst_value_type nothing;
     nonconst_value_type result;
     dart_ret_t          ret = dart_fetch_and_op(
-        _gptr,
+        gptr,
         &nothing,
         &result,
         dash::dart_punned_datatype<T>::value,
         DART_OP_NO_OP);
-    dart_flush_local(_gptr);
+    dart_flush_local(gptr);
     DASH_ASSERT_EQ(DART_OK, ret, "dart_accumulate failed");
     DASH_LOG_DEBUG_VAR("GlobRef<Atomic>.get >", result);
     return result;
@@ -292,16 +213,17 @@ class GlobRef<dash::Atomic<T>> {
         std::is_same<value_type, nonconst_value_type>::value,
         "Cannot modify value referenced by GlobRef<Atomic<const T>>!");
     DASH_LOG_DEBUG_VAR("GlobRef<Atomic>.op()", value);
-    DASH_LOG_TRACE_VAR("GlobRef<Atomic>.op", _gptr);
+    auto gptr = this->dart_gptr();
+    DASH_LOG_TRACE_VAR("GlobRef<Atomic>.op", gptr);
     nonconst_value_type acc = value;
     DASH_LOG_TRACE("GlobRef<Atomic>.op", "dart_accumulate");
     dart_ret_t ret = dart_accumulate(
-        _gptr,
+        gptr,
         &acc,
         1,
         dash::dart_punned_datatype<T>::value,
         binary_op.dart_operation());
-    dart_flush(_gptr);
+    dart_flush(gptr);
     DASH_ASSERT_EQ(DART_OK, ret, "dart_accumulate failed");
     DASH_LOG_DEBUG_VAR("GlobRef<Atomic>.op >", acc);
   }
@@ -330,16 +252,17 @@ class GlobRef<dash::Atomic<T>> {
         std::is_same<value_type, nonconst_value_type>::value,
         "Cannot modify value referenced by GlobRef<Atomic<const T>>!");
     DASH_LOG_DEBUG_VAR("GlobRef<Atomic>.fetch_op()", value);
-    DASH_LOG_TRACE_VAR("GlobRef<Atomic>.fetch_op", _gptr);
+    auto gptr = this->dart_gptr();
+    DASH_LOG_TRACE_VAR("GlobRef<Atomic>.fetch_op", gptr);
     DASH_LOG_TRACE_VAR("GlobRef<Atomic>.fetch_op", typeid(value).name());
     nonconst_value_type res;
     dart_ret_t          ret = dart_fetch_and_op(
-        _gptr,
+        gptr,
         &value,
         &res,
         dash::dart_punned_datatype<T>::value,
         binary_op.dart_operation());
-    dart_flush(_gptr);
+    dart_flush(gptr);
     DASH_ASSERT_EQ(DART_OK, ret, "dart_fetch_op failed");
     DASH_LOG_DEBUG_VAR("GlobRef<Atomic>.fetch_op >", res);
     return res;
@@ -374,18 +297,19 @@ class GlobRef<dash::Atomic<T>> {
         std::is_same<value_type, nonconst_value_type>::value,
         "Cannot modify value referenced by GlobRef<const T>!");
     DASH_LOG_DEBUG_VAR("GlobRef<Atomic>.compare_exchange()", desired);
-    DASH_LOG_TRACE_VAR("GlobRef<Atomic>.compare_exchange", _gptr);
+    auto gptr = this->dart_gptr();
+    DASH_LOG_TRACE_VAR("GlobRef<Atomic>.compare_exchange", gptr);
     DASH_LOG_TRACE_VAR("GlobRef<Atomic>.compare_exchange", expected);
     DASH_LOG_TRACE_VAR(
         "GlobRef<Atomic>.compare_exchange", typeid(desired).name());
     nonconst_value_type result;
     dart_ret_t          ret = dart_compare_and_swap(
-        _gptr,
+        gptr,
         &desired,
         &expected,
         &result,
         dash::dart_punned_datatype<T>::value);
-    dart_flush(_gptr);
+    dart_flush(gptr);
     DASH_ASSERT_EQ(DART_OK, ret, "dart_compare_and_swap failed");
     DASH_LOG_DEBUG_VAR(
         "GlobRef<Atomic>.compare_exchange >", (expected == result));
diff --git a/dash/include/dash/atomic/Type_traits.h b/dash/include/dash/atomic/Type_traits.h
deleted file mode 100644
index fc0cc4500..000000000
--- a/dash/include/dash/atomic/Type_traits.h
+++ /dev/null
@@ -1,43 +0,0 @@
-#ifndef DASH__ATOMIC__TYPE_TRAITS_INCLUDED
-#define DASH__ATOMIC__TYPE_TRAITS_INCLUDED
-
-namespace dash {
-
-// forward decl atomic type for only importing traits without full blown atomic
-// type support
-template<typename T>
-class Atomic;
-
-/**
- * type traits for \c dash::Atomic
- *
- * true if type is atomic
- * false otherwise
- */
-template<typename T>
-struct is_atomic {
-  static constexpr bool value = false;
-};
-template<typename T>
-struct is_atomic<dash::Atomic<T>> {
-  static constexpr bool value = true;
-};
-
-/**
- * type traits for \c dash::Atomic
- *
- * returns the sub type of a \cdash::Atomic
- */
-template<typename T>
-struct remove_atomic {
-  typedef T type;
-};
-template<typename T>
-struct remove_atomic<dash::Atomic<T>> {
-  typedef T type;
-};
-
-} // namespace dash
-
-#endif // DASH__ATOMIC__TYPE_TRAITS_INCLUDED
-
diff --git a/dash/include/dash/io/hdf5/StorageDriver.h b/dash/include/dash/io/hdf5/StorageDriver.h
index 53053386f..f41af43df 100644
--- a/dash/include/dash/io/hdf5/StorageDriver.h
+++ b/dash/include/dash/io/hdf5/StorageDriver.h
@@ -133,9 +133,7 @@ class StoreHDF {
           typename dash::view_traits<View_t>::origin_type::value_type>) {
     using Container_t = typename dash::view_traits<View_t>::origin_type;
     using pattern_t = typename Container_t::pattern_type;
-    using extent_t = typename pattern_t::size_type;
     using index_t = typename Container_t::index_type;
-    using value_t = typename Container_t::value_type;
 
     constexpr auto ndim = pattern_t::ndim();
 
diff --git a/dash/include/dash/iterator/GlobIter.h b/dash/include/dash/iterator/GlobIter.h
index f4509f405..be6db3b04 100644
--- a/dash/include/dash/iterator/GlobIter.h
+++ b/dash/include/dash/iterator/GlobIter.h
@@ -224,7 +224,7 @@ class GlobIter {
    */
   DASH_CONSTEXPR reference operator*() noexcept
   {
-    return reference{this->dart_gptr()};
+    return reference{static_cast<pointer>(*this)};
   }
 
   /**
@@ -247,7 +247,7 @@ class GlobIter {
   {
     auto p = *this;
     p += g_index;
-    return reference(p.dart_gptr());
+    return reference(static_cast<pointer>(p));
   }
 
   /**
@@ -260,7 +260,7 @@ class GlobIter {
   {
     auto p = *this;
     p += g_index;
-    return const_reference(p.dart_gptr());
+    return const_reference(static_cast<const_pointer>(p));
   }
 
   /**
@@ -469,8 +469,7 @@ class GlobIter {
     return _pattern->team();
   }
 
- private:
-  DASH_CONSTEXPR dart_gptr_t
+  DASH_CONSTEXPR auto
                  _get_pointer_at(typename pattern_type::local_index_t pos) const
   {
     auto dart_pointer = static_cast<dart_gptr_t>(_globmem->begin());
diff --git a/dash/include/dash/iterator/GlobViewIter.h b/dash/include/dash/iterator/GlobViewIter.h
index a91900ee5..70f47d09e 100644
--- a/dash/include/dash/iterator/GlobViewIter.h
+++ b/dash/include/dash/iterator/GlobViewIter.h
@@ -497,7 +497,7 @@ class GlobViewIter
     // Global reference to element at given position:
 
     auto const    dart_pointer = _get_pointer_at(local_pos);
-    return reference(dart_pointer);
+    return reference{pointer{dart_pointer}};
   }
 
   /**
@@ -526,7 +526,7 @@ class GlobViewIter
     // Global reference to element at given position:
 
     auto const dart_pointer = _get_pointer_at(local_pos);
-    return const_reference(dart_pointer);
+    return const_reference{const_pointer{dart_pointer}};
   }
 
   /**
diff --git a/dash/include/dash/iterator/internal/GlobRefBase.h b/dash/include/dash/iterator/internal/GlobRefBase.h
index cd3e66f3c..68d3c9eb7 100644
--- a/dash/include/dash/iterator/internal/GlobRefBase.h
+++ b/dash/include/dash/iterator/internal/GlobRefBase.h
@@ -1,10 +1,20 @@
 #ifndef DASH__ITERATOR__INTERNAL__GLOBREF_BASE_H__INCLUDED
 #define DASH__ITERATOR__INTERNAL__GLOBREF_BASE_H__INCLUDED
 
+#include <cstdint>
+#include <memory>
 #include <type_traits>
 
+#include <dash/TypeTraits.h>
+#include <dash/dart/if/dart_globmem.h>
+
 namespace dash {
-namespace internal {
+
+/// Forward declarations
+template <typename T, class MemSpaceT>
+class GlobPtr;
+
+namespace detail {
 
 template <typename ReferenceT, typename TargetT>
 struct add_const_from_type {
@@ -22,29 +32,228 @@ struct null_v : std::integral_constant<int, 0> {
 
 // clang-format off
 
+template<class LHS, class RHS>
+using is_implicitly_convertible = std::is_convertible<
+        typename std::add_lvalue_reference<LHS>::type,
+        typename std::add_lvalue_reference<RHS>::type>;
+
+#if 0
 template <class LHS, class RHS>
-using common_condition = std::is_same<
-    typename std::remove_cv<LHS>::type,
-    typename std::remove_cv<RHS>::type>;
+using is_explicitly_convertible = std::integral_constant<bool,
+      // 1) not implicitly convertible
+      !is_implicitly_convertible<LHS, RHS>::value &&
+      // 2.1) It is constructible  or...
+      (std::is_constructible<
+        typename std::add_lvalue_reference<RHS>::type,
+        typename std::add_lvalue_reference<LHS>::type>::value ||
+      // 2.2) if RHS is a base of RHS and both classes are non-polymorphic
+      (std::conditional<std::is_const<LHS>::value,
+        std::is_const<RHS>,
+        std::true_type>::type::value
+
+       && std::is_base_of<LHS, RHS>::value
+        && !std::is_polymorphic<LHS>::value
+        && !std::is_polymorphic<RHS>::value))>;
+#else
+template <typename From, typename To>
+struct is_explicitly_convertible {
+  template <typename T>
+  static void f(T);
+
+  template <typename F, typename T>
+  static constexpr auto test(int)
+      -> decltype(f(static_cast<T>(std::declval<F>())), true)
+  {
+    return true;
+  }
+
+  template <typename F, typename T>
+  static constexpr auto test(...) -> bool
+  {
+    return false;
+  }
+
+  static bool const value = test<From, To>(0);
+};
+#endif
+
 
 template <class LHS, class RHS>
-using enable_explicit_copy_ctor = null_v<
+using enable_implicit_copy_ctor = null_v<
     typename std::enable_if<
-        common_condition<LHS, RHS>::value &&
-        !std::is_const<LHS>::value &&
-        std::is_const<RHS>::value,
+      is_implicitly_convertible<LHS, RHS>::value,
       LHS>::type>;
 
 template <class LHS, class RHS>
-using enable_implicit_copy_ctor = null_v<
+using enable_explicit_copy_ctor = null_v<
     typename std::enable_if<
-        std::is_same<LHS, RHS>::value ||
-        (common_condition<LHS, RHS>::value &&
-        std::is_const<LHS>::value),
+      !is_implicitly_convertible<LHS, RHS>::value &&
+      is_explicitly_convertible<
+        typename std::add_lvalue_reference<LHS>::type,
+        typename std::add_lvalue_reference<RHS>::type>::value,
       LHS>::type>;
 
 // clang-format on
 
-}  // namespace internal
+template <typename T1, typename T2>
+inline std::size_t constexpr offset_of(T1 T2::*member) noexcept
+{
+  constexpr T2 dummy{};
+  return std::size_t{std::uintptr_t(std::addressof(dummy.*member))} -
+         std::size_t{std::uintptr_t(std::addressof(dummy))};
+}
+
+template <class T>
+class GlobRefBase {
+ public:
+  using value_type          = T;
+  using const_value_type    = typename std::add_const<value_type>::type;
+  using nonconst_value_type = typename std::remove_const<value_type>::type;
+
+ protected:
+  /**
+   * PRIVATE: Constructor, creates an GlobRefBase object referencing an
+   * element in global memory.
+   */
+  explicit constexpr GlobRefBase(dart_gptr_t const& dart_gptr)
+    : m_dart_pointer(dart_gptr)
+  {
+  }
+  explicit constexpr GlobRefBase(dart_gptr_t&& dart_gptr)
+    : m_dart_pointer(std::move(dart_gptr))
+  {
+  }
+
+ public:
+  constexpr GlobRefBase() = delete;
+
+  GlobRefBase(GlobRefBase const&)     = default;
+  GlobRefBase(GlobRefBase&&) noexcept = default;
+
+  /**
+   * Constructor: creates an GlobRefBase object referencing an element in
+   * global memory.
+   */
+  template <class MemSpaceT>
+  explicit constexpr GlobRefBase(
+      /// Pointer to referenced object in global memory
+      const GlobPtr<value_type, MemSpaceT>& gptr)
+    : GlobRefBase(gptr.dart_gptr())
+  {
+  }
+
+  /**
+   * Constructor: creates an GlobRefBase object referencing an element in
+   * global memory.
+   */
+  template <class MemSpaceT>
+  explicit constexpr GlobRefBase(
+      /// Pointer to referenced object in global memory
+      GlobPtr<value_type, MemSpaceT>&& gptr)
+    : GlobRefBase(std::move(gptr.dart_gptr()))
+  {
+  }
+
+  // clang-format off
+  /**
+   * Copy constructor, implicit if at least one of the following conditions is
+   * satisfied:
+   *    1) value_type and _From are exactly the same types (including const and
+   *    volatile qualifiers
+   *    2) value_type and _From are the same types after removing const and
+   *    volatile qualifiers and value_type itself is const.
+   */
+  // clang-format on
+  template <
+      typename _From,
+      long = detail::enable_implicit_copy_ctor<
+          typename dash::remove_atomic<_From>::type,
+          typename dash::remove_atomic<value_type>::type>::value>
+  constexpr GlobRefBase(const GlobRefBase<_From>& gref) noexcept
+    : GlobRefBase(gref.dart_gptr())
+  {
+  }
+
+  // clang-format off
+  /**
+   * Copy constructor, implicit if at least one of the following conditions is
+   * satisfied:
+   *    1) value_type and _From are exactly the same types (including const and
+   *    volatile qualifiers
+   *    2) value_type and _From are the same types after removing const and
+   *    volatile qualifiers and value_type itself is const.
+   */
+  // clang-format on
+  template <
+      typename _From,
+      long = detail::enable_implicit_copy_ctor<
+          typename dash::remove_atomic<_From>::type,
+          typename dash::remove_atomic<value_type>::type>::value>
+  constexpr GlobRefBase(GlobRefBase<_From>&& gref) noexcept
+    : GlobRefBase(std::move(gref.dart_gptr()))
+  {
+  }
+
+  // clang-format off
+  /**
+   * Copy constructor, explicit if the following conditions are satisfied.
+   *    1) value_type and _From are the same types after excluding const and
+   *    volatile qualifiers
+   *    2) value_type is const and _From is non-const
+   */
+  // clang-format on
+  template <
+      typename _From,
+      int = detail::enable_explicit_copy_ctor<
+          typename dash::remove_atomic<_From>::type,
+          typename dash::remove_atomic<value_type>::type>::value>
+  explicit constexpr GlobRefBase(const GlobRefBase<_From>& gref) noexcept
+    : GlobRefBase(gref.dart_gptr())
+  {
+  }
+
+  // clang-format off
+  /**
+   * Copy constructor, explicit if the following conditions are satisfied.
+   *    1) value_type and _From are the same types after excluding const and
+   *    volatile qualifiers
+   *    2) value_type is const and _From is non-const
+   */
+  // clang-format on
+  template <
+      typename _From,
+      int = detail::enable_explicit_copy_ctor<
+          typename dash::remove_atomic<_From>::type,
+          typename dash::remove_atomic<value_type>::type>::value>
+  explicit constexpr GlobRefBase(GlobRefBase<_From>&& gref) noexcept
+    : GlobRefBase(std::move(gref.dart_gptr()))
+  {
+  }
+
+  constexpr dart_gptr_t const& dart_gptr() const& noexcept
+  {
+    return this->m_dart_pointer;
+  }
+
+  constexpr dart_gptr_t const&& dart_gptr() const&& noexcept
+  {
+    return std::move(this->m_dart_pointer);
+  }
+
+  constexpr dart_gptr_t& dart_gptr() & noexcept
+  {
+    return this->m_dart_pointer;
+  }
+
+  constexpr dart_gptr_t&& dart_gptr() && noexcept
+  {
+    return std::move(this->m_dart_pointer);
+  }
+
+ private:
+  dart_gptr_t m_dart_pointer{DART_GPTR_NULL};
+};
+
+}  // namespace detail
 }  // namespace dash
 #endif
diff --git a/dash/include/dash/map/UnorderedMap.h b/dash/include/dash/map/UnorderedMap.h
index 77618c52e..d719470c1 100644
--- a/dash/include/dash/map/UnorderedMap.h
+++ b/dash/include/dash/map/UnorderedMap.h
@@ -163,7 +163,7 @@ class UnorderedMap {
   /// to remote unit in next commit.
   std::vector<iterator>  _move_elements;
   /// Global pointer to local element in _local_sizes.
-  dart_gptr_t            _local_size_gptr = DART_GPTR_NULL;
+  typename local_sizes_map::pointer _local_size_gptr{};
   /// Hash type for mapping of key to unit and local offset.
   hasher                 _key_hash;
   /// Predicate for key comparison.
@@ -315,7 +315,9 @@ class UnorderedMap {
     // Initialize local sizes with 0:
     _local_sizes.allocate(_team->size(), dash::BLOCKED, *_team);
     _local_sizes.local[0] = 0;
-    _local_size_gptr      = _local_sizes[_myid].dart_gptr();
+
+    _local_size_gptr = static_cast<typename local_sizes_map::pointer>(
+        _local_sizes.begin() + _myid);
 
     // Global iterators:
     _begin       = iterator(this, 0);
diff --git a/dash/include/dash/memory/GlobStaticMem.h b/dash/include/dash/memory/GlobStaticMem.h
index d89793296..1559c0c8c 100644
--- a/dash/include/dash/memory/GlobStaticMem.h
+++ b/dash/include/dash/memory/GlobStaticMem.h
@@ -333,7 +333,6 @@ inline void GlobStaticMem<LMemSpace>::do_deallocate(
   if (*m_team != dash::Team::Null()) {
     DASH_ASSERT_RETURNS(dart_barrier(m_team->dart_id()), DART_OK);
 
-    auto soon_to_be_lbegin = gptr;
     gptr.set_unit(m_team->myid());
 
     auto* lbegin = gptr.local();
diff --git a/dash/test/iterator/GlobAsyncRefTest.cc b/dash/test/iterator/GlobAsyncRefTest.cc
index 6a671cc72..5066358e7 100644
--- a/dash/test/iterator/GlobAsyncRefTest.cc
+++ b/dash/test/iterator/GlobAsyncRefTest.cc
@@ -86,23 +86,6 @@ TEST_F(GlobAsyncRefTest, GetSet) {
   ASSERT_EQ_U(left_neighbor, array.local[0]);
 }
 
-TEST_F(GlobAsyncRefTest, Conversion)
-{
-  // Initialize values:
-  dash::Array<int> array(dash::size());
-  for (auto li = 0; li < array.lcapacity(); ++li) {
-    array.local[li] = dash::myid().id;
-  }
-  array.barrier();
-
-  auto gref_async = static_cast<dash::GlobAsyncRef<int>>(
-                        array[dash::myid().id]);
-  auto gref_sync  = static_cast<dash::GlobRef<int>>(
-                        array.async[dash::myid().id]);
-  ASSERT_EQ_U(gref_async.is_local(), true);
-  ASSERT_EQ_U(gref_sync.is_local(), true);
-}
-
 struct mytype {int a; double b; };
 
 std::ostream&
@@ -169,7 +152,7 @@ TEST_F(GlobAsyncRefTest, ConstTest)
   // assignment const -> const
   dash::GlobRef<const int> gref2 = carr[0];
   // explicit conversion const->non-const
-  dash::GlobRef<int> gref3(carr[0]);
+  //dash::GlobRef<int> gref3(carr[0]);
 
   // should fail!
   //gref1.set(0);
@@ -186,8 +169,8 @@ TEST_F(GlobAsyncRefTest, ConstTest)
   // assignment const -> const
   dash::GlobAsyncRef<const int> agref2 = carr.async[0];
   // explicit conversion const->non-const
-  dash::GlobAsyncRef<int> agref3 =
-                            static_cast<dash::GlobAsyncRef<int>>(carr.async[0]);
+  //dash::GlobAsyncRef<int> agref3 =
+  //                          static_cast<dash::GlobAsyncRef<int>>(carr.async[0]);
 
   dash::GlobAsyncRef<const int> agref4 = gref1;
   dash::GlobAsyncRef<const int> agref5{gref1};
diff --git a/dash/test/types/AtomicTest.cc b/dash/test/types/AtomicTest.cc
index 364d2e0f8..82043e5f8 100644
--- a/dash/test/types/AtomicTest.cc
+++ b/dash/test/types/AtomicTest.cc
@@ -289,13 +289,13 @@ TEST_F(AtomicTest, ArrayElements)
                  "prev: array @ unit(", remote_prev, ") +=", my_val);
   // in fact, this is a hack
   dash::GlobRef<dash::Atomic<value_t>>(
-          array[remote_prev].dart_gptr()
+          dash::addressof<typename decltype(array)::memory_type>(array[remote_prev])
         ).add(my_val);
 
   DASH_LOG_TRACE("AtomicTest.ArrayElements",
                  "next: array @ unit(", remote_next, ") +=", my_val);
   dash::GlobRef<dash::Atomic<value_t>>(
-          array[remote_next].dart_gptr()
+          dash::addressof<typename decltype(array)::memory_type>(array[remote_next])
         ).fetch_add(my_val);
 
   DASH_LOG_TRACE("AtomicTest.ArrayElements", "barrier #2");
@@ -652,8 +652,8 @@ TEST_F(AtomicTest, ConstTest) {
   // assignment const -> const
   dash::GlobRef<dash::Atomic<const int>> gref2 = carr[0];
   // explicit conversion const->non-const
-  dash::GlobRef<dash::Atomic<int>> gref3 =
-                        static_cast<dash::GlobRef<dash::Atomic<int>>>(carr[0]);
+  //dash::GlobRef<dash::Atomic<int>> gref3 =
+  //                      static_cast<dash::GlobRef<dash::Atomic<int>>>(carr[0]);
 
   // should fail!
   //gref1.add(1);
@@ -670,8 +670,8 @@ TEST_F(AtomicTest, ConstTest) {
   // assignment const -> const
   dash::GlobAsyncRef<dash::Atomic<const int>> agref2 = carr.async[0];
   // explicit conversion const->non-const
-  dash::GlobAsyncRef<dash::Atomic<int>> agref3 =
-                        static_cast<dash::GlobAsyncRef<dash::Atomic<int>>>(carr.async[0]);
+  //dash::GlobAsyncRef<dash::Atomic<int>> agref3 =
+  //                      static_cast<dash::GlobAsyncRef<dash::Atomic<int>>>(carr.async[0]);
 
   // should fail!
   //agref1.add(1);
diff --git a/dash/test/types/GlobRefTest.cc b/dash/test/types/GlobRefTest.cc
index f19db47a6..f5481fb83 100644
--- a/dash/test/types/GlobRefTest.cc
+++ b/dash/test/types/GlobRefTest.cc
@@ -1,19 +1,20 @@
-
 #include "../TestBase.h"
 #include "../TestLogHelpers.h"
 #include "GlobRefTest.h"
 
 #include <dash/Array.h>
-#include <dash/algorithm/Fill.h>
 #include <dash/algorithm/Copy.h>
-
+#include <dash/algorithm/Fill.h>
 
 TEST_F(GlobRefTest, ArithmeticOps)
 {
   using value_t = int;
   using array_t = dash::Array<value_t>;
+
   array_t arr(dash::size());
+
   int neighbor = (dash::myid() + 1) % dash::size();
+
   dash::GlobRef<value_t> gref = arr[neighbor];
 
   auto address_of_ref = dash::addressof<typename array_t::memory_type>(gref);
@@ -58,3 +59,178 @@ TEST_F(GlobRefTest, ArithmeticOps)
   ASSERT_EQ_U(gref -= 1, 1);
   ASSERT_EQ_U(gref, 1);
 }
+
+struct Parent {
+  int x;
+};
+
+struct Child : public Parent {
+  int y;
+};
+
+TEST_F(GlobRefTest, ConstCorrectness)
+{
+  dash::Array<int>     dArray{100};
+  std::array<int, 100> stdArray{};
+
+  // OK
+  int &              ref  = stdArray[0];
+  dash::GlobRef<int> gref = dArray[0];
+
+  // OK as well
+  int const &cref = ref;
+  //
+  //
+  dash::GlobRef<const int> cgref{gref};
+  //
+  //
+
+  static_assert(
+      dash::detail::is_implicitly_convertible<int, const int>::value, "");
+  static_assert(
+      !dash::detail::is_implicitly_convertible<int const, int>::value, "");
+
+  // NOT OK, because...
+  // We must not assign a non-const to const -> Compilation error
+  // int&               ref2  = cref;
+  // dash::GlobRef<int> gref2 = cgref;
+}
+
+TEST_F(GlobRefTest, InheritanceConversionTest)
+{
+  dash::Array<Child>     dArray{100};
+  std::array<Child, 100> stdArray{};
+
+  Child child;
+  child.x = 12;
+  child.y = 34;
+
+  dash::fill(dArray.begin(), dArray.end(), child);
+  std::fill(stdArray.begin(), stdArray.end(), child);
+
+  dArray.barrier();
+
+  auto lpos = dArray.pattern().local(10);
+
+  child.x = 56;
+  child.y = 123;
+  if (lpos.unit == dash::team_unit_t{dash::myid()}) {
+    dArray.local[lpos.index] = child;
+  }
+
+  stdArray[lpos.index] = child;
+
+  dArray.barrier();
+
+  Child &              child_stdArray = stdArray[10];
+  dash::GlobRef<Child> child_dArray   = dArray[10];
+
+  /*
+   * Here we explicitly cast it as Parent. In consequence, we read only 4
+   * bytes (i.e., sizeof Parent), instead of 8.
+   */
+  Parent &              upcastParent_stdArray = stdArray[10];
+  dash::GlobRef<Parent> upcastParent_dArray   = dArray[10];
+
+  auto const  val  = child;
+  auto const &cref = val;
+
+  // Why can we assign a const val to
+  auto &r_auto = val;
+  // The reason this works is the following
+  static_assert(std::is_same<Child const &, decltype(r_auto)>::value, "");
+  // => auto type deduction includes the const modifer as well.
+  // However, the following is malformed.
+  // Child & ref = cref;
+
+  // But this does not work anymore...
+  // Child& r_Child = val;
+
+  Parent const &r_upcast   = r_auto;
+  Child const & r_downcast = static_cast<Child const &>(r_upcast);
+
+  // static downcast is allowed with non-virtual base classes:
+  // see https://en.cppreference.com/w/cpp/language/static_cast, point 2
+  Child &downcastChild_stdArray = static_cast<Child &>(upcastParent_stdArray);
+  dash::GlobRef<Child> downcastChild_dArray =
+      static_cast<dash::GlobRef<Child>>(upcastParent_dArray);
+
+  EXPECT_EQ_U(child_stdArray.y, 123);
+  EXPECT_EQ_U(static_cast<Child>(child_dArray).y, 123);
+
+  EXPECT_EQ_U(upcastParent_stdArray.x, 56);
+  EXPECT_EQ_U(downcastChild_stdArray.y, 123);
+
+  // Look into the logs and grep for dart_get_blocking to see that we really
+  // get only 4 bytes instead of 8.
+  EXPECT_EQ_U(static_cast<Parent>(upcastParent_dArray).x, 56);
+  EXPECT_EQ_U(static_cast<Child>(downcastChild_dArray).y, 123);
+}
+
+template <class T>
+using dash_ref = dash::GlobRef<T>;
+
+template <
+    class LHS,
+    class RHS,
+    bool expected_implicit,
+    bool expected_explicit>
+struct StandardConformabilityTester {
+  static constexpr void test()
+  {
+    static_assert(
+        // First check if the implicit conversion rules match...
+        std::is_convertible<LHS &, RHS &>::value == expected_implicit &&
+            std::is_convertible<dash_ref<LHS>, dash_ref<RHS>>::value ==
+                expected_implicit &&
+            // Then the explicit rules...
+            dash::detail::is_explicitly_convertible<LHS &, RHS &>::value ==
+                expected_explicit &&
+            dash::detail::is_explicitly_convertible<
+                dash_ref<LHS>,
+                dash_ref<RHS>>::value == expected_explicit,
+        "");
+  }
+};
+
+template <class LHS, class RHS, bool _ignore>
+struct StandardConformabilityTester<LHS, RHS, true, _ignore> {
+  static constexpr void test()
+  {
+    // If we can implicitly convert we do not consider explicit conversion
+    // rules
+    static_assert(
+        std::is_convertible<LHS &, RHS &>::value &&
+            std::is_convertible<dash_ref<LHS>, dash_ref<RHS>>::value,
+        "");
+  }
+};
+
+TEST_F(GlobRefTest, ConversionRules)
+{
+  constexpr bool ignore = true;
+
+  // Rule 1.1: T &-> const T &
+  StandardConformabilityTester<int, const int, true, ignore>::test();
+  // Rule 1.2: const T & -> int &
+  // Conversion Fails due to const correctness
+  StandardConformabilityTester<const int, int, false, false>::test();
+
+  // Rule 2: T & -> U & if T and U are not related (FAILS)
+  StandardConformabilityTester<int, double, false, false>::test();
+
+  // Rule 3: Child & -> Parent & (Upcast)
+  StandardConformabilityTester<Child, Parent, true, ignore>::test();
+
+  // Rule 4.1: Child & -> const Parent & (Upcast to const)
+  // Rule 4.2: const Child & -> Parent & (FAILS, const correctness)
+  StandardConformabilityTester<Child, const Parent, true, ignore>::test();
+  StandardConformabilityTester<const Child, Parent, false, false>::test();
+
+  // Rule 5.1: Parent & -> const Child &
+  // Rule 5.2: Parent & -> Child &
+  // Explicit downcast (VALID)
+  // see https://en.cppreference.com/w/cpp/language/static_cast
+  StandardConformabilityTester<Parent, const Child, false, true>::test();
+  StandardConformabilityTester<Parent, Child, false, true>::test();
+}