diff --git a/lib/bertex.ex b/lib/bertex.ex
index 1661aa4..fe28170 100644
--- a/lib/bertex.ex
+++ b/lib/bertex.ex
@@ -14,15 +14,15 @@ defmodule Bertex do
   end
 
   defimpl Bert, for: Atom do
+    def encode(nil),   do: {:bert, nil}
     def encode(false), do: {:bert, false}
-    def encode(true), do: {:bert, true}
-    def encode(atom), do: atom
+    def encode(true),  do: {:bert, true}
+    def encode(atom),  do: atom
 
-    def decode(atom), do: atom
+    def decode(atom),  do: atom
   end
 
   defimpl Bert, for: List do
-    def encode([]), do: {:bert, nil}
     def encode(list) do
       Enum.map(list, &Bert.encode(&1))
     end
@@ -40,31 +40,24 @@ defmodule Bertex do
         |> List.to_tuple
     end
 
-    def decode({:bert, nil}), do: []
-
-    def decode({:bert, true}), do: true
-
+    def decode({:bert, nil}),   do: nil
+    def decode({:bert, true}),  do: true
     def decode({:bert, false}), do: false
 
     def decode({:bert, :dict, dict}), do: Enum.into(Bert.decode(dict), %{})
 
     def decode(tuple) do
-      Tuple.to_list(tuple)
-        |> Enum.map(&Bert.decode(&1))
-        |> List.to_tuple
+      tuple
+      |> Tuple.to_list
+      |> Enum.map(&Bert.decode(&1))
+      |> List.to_tuple
     end
   end
 
   defimpl Bert, for: Map do
-    def encode(dict), do: {:bert, :dict, Dict.to_list(dict)}
-    # This should never happen.
-    def decode(dict), do: Enum.into(dict, %{})
-  end
-
-  defimpl Bert, for: HashDict do
-    def encode(dict), do: {:bert, :dict, Dict.to_list(dict)}
+    def encode(map), do: {:bert, :dict, Map.to_list(map)}
     # This should never happen.
-    def decode(dict), do: Enum.into(dict, %{})
+    def decode(map), do: Enum.into(map, %{})
   end
 
   defimpl Bert, for: Any do
diff --git a/mix.exs b/mix.exs
index c6692ed..a480e2f 100644
--- a/mix.exs
+++ b/mix.exs
@@ -6,20 +6,25 @@ defmodule Bertex.Mixfile do
   """
 
   def project do
-    [ app: :bertex,
-      version: "1.2.0",
-      elixir: "~> 0.14.2 or ~> 0.15.0 or ~> 1.0.0",
+    [
+      app: :bertex,
+      version: "1.4.2",
+      elixir:
+        "~> 0.14.2 or ~> 0.15.0 or ~> 1.0.0 or ~> 1.2.0 or ~> 1.3.0 or ~> 1.4.0 or ~> 1.5.0 or ~> 1.6.0",
       name: "Bertex",
       description: @description,
-      package: package,
-      deps: [] ]
+      package: package(),
+      deps: []
+    ]
   end
 
   def application, do: []
 
   defp package do
-    [ contributors: ["Eduardo Gurgel Pinho"],
+    [
+      contributors: ["Eduardo Gurgel Pinho", "Christopher Bertels"],
       licenses: ["MIT"],
-      links: [ { "Github", "https://github.com/edgurgel/bertex" } ] ]
+      links: [{"Github", "https://github.com/edgurgel/bertex"}]
+    ]
   end
 end
diff --git a/test/bertex_test.exs b/test/bertex_test.exs
index 36cc919..9860d4c 100644
--- a/test/bertex_test.exs
+++ b/test/bertex_test.exs
@@ -9,6 +9,10 @@ defmodule Bertex.Test do
     assert decode(encode(term)) == term
   end
 
+  test "encode nil" do
+    assert binary_to_term(encode(nil)) == {:bert, nil}
+  end
+
   test "encode true" do
     assert binary_to_term(encode(true)) == {:bert, true}
   end
@@ -39,7 +43,7 @@ defmodule Bertex.Test do
   end
 
   test "encode empty list" do
-    assert binary_to_term(encode([])) == {:bert, nil}
+    assert binary_to_term(encode([])) == []
   end
 
   test "encode list" do
@@ -48,14 +52,12 @@ defmodule Bertex.Test do
 
   test "encode map" do
     dict = %{}
-      |> Dict.put(:key, "value")
+      |> Map.put(:key, "value")
     assert binary_to_term(encode(dict)) == {:bert, :dict, key: "value"}
   end
 
-  test "encode hashdict" do
-    dict = HashDict.new
-      |> Dict.put(:key, "value")
-    assert binary_to_term(encode(dict)) == {:bert, :dict, key: "value"}
+  test "decode nil" do
+    assert decode(term_to_binary({:bert, nil})) == nil
   end
 
   test "decode true" do
@@ -83,7 +85,7 @@ defmodule Bertex.Test do
   end
 
   test "decode empty list" do
-    assert decode(term_to_binary({:bert, nil})) == []
+    assert decode(term_to_binary([])) == []
   end
 
   test "decode list" do
@@ -92,17 +94,21 @@ defmodule Bertex.Test do
 
   test "decode dict" do
     dict = %{}
-      |> Dict.put(:key, "value")
+      |> Map.put(:key, "value")
     assert decode(term_to_binary({:bert, :dict, key: "value"})) == dict
   end
 
   test "decode complex Dict" do
     dict = %{}
-      |> Dict.put(:key, "value")
-      |> Dict.put(:key2, false)
+      |> Map.put(:key, "value")
+      |> Map.put(:key2, false)
     assert decode(term_to_binary({:bert, :dict, key: "value", key2: {:bert, false}})) == dict
   end
 
+  test "encode/decode nil" do
+    assert_term(nil)
+  end
+
   test "encode/decode true" do
     assert_term(true)
   end
@@ -140,7 +146,7 @@ defmodule Bertex.Test do
   end
 
   test "encode/decode a Dict" do
-    %{} |> Dict.put(:hello, "world")
+    %{} |> Map.put(:hello, "world")
         |> assert_term
   end