diff --git a/contributing/development/core_and_modules/variant_class.rst b/contributing/development/core_and_modules/variant_class.rst
index 7bd8e3460e05..7a2f1971eb03 100644
--- a/contributing/development/core_and_modules/variant_class.rst
+++ b/contributing/development/core_and_modules/variant_class.rst
@@ -6,22 +6,20 @@ Variant class
 About
 -----
 
-Variant is the most important datatype of Godot, it's the most important
-class in the engine. A Variant takes up only 20 bytes and can store
-almost any engine datatype inside of it. Variants are rarely used to
-hold information for long periods of time, instead they are used mainly
-for communication, editing, serialization and generally moving data
-around.
+Variant is the most important datatype in Godot. A Variant takes up only 20
+bytes and can store almost any engine datatype inside of it. Variants are rarely
+used to hold information for long periods of time, instead they are used mainly
+for communication, editing, serialization and generally moving data around.
 
 A Variant can:
 
--  Store almost any datatype
+-  Store almost any datatype.
 -  Perform operations between many variants (GDScript uses Variant as
    its atomic/native datatype).
--  Be hashed, so it can be compared quickly to other variants
--  Be used to convert safely between datatypes
+-  Be hashed, so it can be compared quickly to other variants.
+-  Be used to convert safely between datatypes.
 -  Be used to abstract calling methods and their arguments (Godot
-   exports all its functions through variants)
+   exports all its functions through variants).
 -  Be used to defer calls or move data between threads.
 -  Be serialized as binary and stored to disk, or transferred via
    network.
@@ -34,27 +32,30 @@ Basically, thanks to the Variant class, writing Godot itself was a much,
 much easier task, as it allows for highly dynamic constructs not common
 of C++ with little effort. Become a friend of Variant today.
 
+.. note::
+
+    Unlike Objects, Variants **cannot** be ``null`` and must always store a
+    valid value. Variant is therefore called a *non-nullable* type.
+
 References:
 ~~~~~~~~~~~
 
 -  `core/variant/variant.h <https://github.com/godotengine/godot/blob/master/core/variant/variant.h>`__
 
-Containers: Dictionary and Array
+Containers: Array and Dictionary
 --------------------------------
 
-Both are implemented using variants. A Dictionary can match any datatype
-used as key to any other datatype. An Array just holds an array of
-Variants. Of course, a Variant can also hold a Dictionary and an Array
-inside, making it even more flexible.
+Both :ref:`class_array` and :ref:`class_dictionary` are implemented using
+variants. A Dictionary can match any datatype used as key to any other datatype.
+An Array just holds an array of Variants. Of course, a Variant can also hold a
+Dictionary and an Array inside, making it even more flexible.
 
 Modifications to a container will modify all references to
-it. A Mutex should be created to lock it if multi threaded access is
-desired.
-
-Copy-on-write (COW) mode support for containers was dropped with Godot 3.0.
+it. A Mutex should be created to lock it if
+:ref:`multi-threaded access <doc_using_multiple_threads>` is desired.
 
-References:
-~~~~~~~~~~~
+References
+~~~~~~~~~~
 
 -  `core/variant/dictionary.h <https://github.com/godotengine/godot/blob/master/core/variant/dictionary.h>`__
 -  `core/variant/array.h <https://github.com/godotengine/godot/blob/master/core/variant/array.h>`__
diff --git a/tutorials/scripting/gdscript/gdscript_basics.rst b/tutorials/scripting/gdscript/gdscript_basics.rst
index 97375d92a616..3b2ceb788a3d 100644
--- a/tutorials/scripting/gdscript/gdscript_basics.rst
+++ b/tutorials/scripting/gdscript/gdscript_basics.rst
@@ -684,6 +684,11 @@ null
 ``null`` is an empty data type that contains no information and can not
 be assigned any other value.
 
+Only types that inherit from Object can have a ``null`` value
+(Object is therefore called a "nullable" type).
+:ref:`Variant types <doc_variant_class>` must have a valid value at all times,
+and therefore cannot have a ``null`` value.
+
 :ref:`bool <class_bool>`
 ^^^^^^^^^^^^^^^^^^^^^^^^