diff --git a/src/client.rs b/src/client.rs
index 097b309..ac54b47 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -14,7 +14,7 @@
 //! use tuf::client::{Client, Config};
 //! use tuf::metadata::{RootMetadata, SignedMetadata, Role, MetadataPath,
 //!     MetadataVersion};
-//! use tuf::interchange::JsonDataInterchange;
+//! use tuf::interchange::Json;
 //! use tuf::repository::{Repository, FileSystemRepository, HttpRepository};
 //! use url::Url;
 //!
@@ -29,7 +29,7 @@
 //!         .map(|k| KeyId::from_string(k).unwrap())
 //!         .collect();
 //!
-//!     let local = FileSystemRepository::<JsonDataInterchange>::new(PathBuf::from("~/.rustup"));
+//!     let local = FileSystemRepository::<Json>::new(PathBuf::from("~/.rustup"));
 //!
 //!     let remote = HttpRepository::new(
 //!         Url::parse("https://static.rust-lang.org/").unwrap(),
@@ -669,7 +669,7 @@
     use super::*;
     use chrono::prelude::*;
     use crypto::{PrivateKey, SignatureScheme};
-    use interchange::JsonDataInterchange;
+    use interchange::Json;
     use metadata::{RootMetadata, SignedMetadata, RoleDefinition, MetadataPath, MetadataVersion};
     use repository::EphemeralRepository;
 
@@ -700,7 +700,7 @@
             RoleDefinition::new(1, hashset!(KEYS[0].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[0].key_id().clone())).unwrap(),
         ).unwrap();
-        let root: SignedMetadata<JsonDataInterchange, RootMetadata> =
+        let root: SignedMetadata<Json, RootMetadata> =
             SignedMetadata::new(&root, &KEYS[0], SignatureScheme::Ed25519).unwrap();
 
         repo.store_metadata(
@@ -720,7 +720,7 @@
             RoleDefinition::new(1, hashset!(KEYS[1].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[1].key_id().clone())).unwrap(),
         ).unwrap();
-        let mut root: SignedMetadata<JsonDataInterchange, RootMetadata> =
+        let mut root: SignedMetadata<Json, RootMetadata> =
             SignedMetadata::new(&root, &KEYS[1], SignatureScheme::Ed25519).unwrap();
 
         root.add_signature(&KEYS[0], SignatureScheme::Ed25519)
@@ -743,7 +743,7 @@
             RoleDefinition::new(1, hashset!(KEYS[2].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[2].key_id().clone())).unwrap(),
         ).unwrap();
-        let mut root: SignedMetadata<JsonDataInterchange, RootMetadata> =
+        let mut root: SignedMetadata<Json, RootMetadata> =
             SignedMetadata::new(&root, &KEYS[2], SignatureScheme::Ed25519).unwrap();
 
         root.add_signature(&KEYS[1], SignatureScheme::Ed25519)
diff --git a/src/interchange/mod.rs b/src/interchange/mod.rs
index 0f9a090..e3f3590 100644
--- a/src/interchange/mod.rs
+++ b/src/interchange/mod.rs
@@ -206,26 +206,26 @@
 /// }
 /// ```
 #[derive(Debug, Clone, PartialEq)]
-pub struct JsonDataInterchange {}
-impl DataInterchange for JsonDataInterchange {
+pub struct Json {}
+impl DataInterchange for Json {
     type RawData = json::Value;
 
     /// ```
-    /// use tuf::interchange::{DataInterchange, JsonDataInterchange};
+    /// use tuf::interchange::{DataInterchange, Json};
     ///
-    /// assert_eq!(JsonDataInterchange::extension(), "json");
+    /// assert_eq!(Json::extension(), "json");
     /// ```
     fn extension() -> &'static str {
         "json"
     }
 
     /// ```
-    /// use tuf::interchange::{DataInterchange, JsonDataInterchange};
+    /// use tuf::interchange::{DataInterchange, Json};
     /// use std::collections::HashMap;
     ///
     /// let jsn: &[u8] = br#"{"foo": "bar", "baz": "quux"}"#;
-    /// let raw = JsonDataInterchange::from_reader(jsn).unwrap();
-    /// let out = JsonDataInterchange::canonicalize(&raw).unwrap();
+    /// let raw = Json::from_reader(jsn).unwrap();
+    /// let out = Json::canonicalize(&raw).unwrap();
     /// assert_eq!(out, br#"{"baz":"quux","foo":"bar"}"#);
     /// ```
     fn canonicalize(raw_data: &Self::RawData) -> Result<Vec<u8>> {
@@ -239,7 +239,7 @@
     /// extern crate serde_json;
     /// extern crate tuf;
     ///
-    /// use tuf::interchange::{DataInterchange, JsonDataInterchange};
+    /// use tuf::interchange::{DataInterchange, Json};
     /// use std::collections::HashMap;
     ///
     /// #[derive(Deserialize, Debug, PartialEq)]
@@ -251,7 +251,7 @@
     /// fn main() {
     ///     let jsn = json!({"foo": "wat", "bar": "lol"});
     ///     let thing = Thing { foo: "wat".into(), bar: "lol".into() };
-    ///     let de: Thing = JsonDataInterchange::deserialize(&jsn).unwrap();
+    ///     let de: Thing = Json::deserialize(&jsn).unwrap();
     ///     assert_eq!(de, thing);
     /// }
     /// ```
@@ -269,7 +269,7 @@
     /// extern crate serde_json;
     /// extern crate tuf;
     ///
-    /// use tuf::interchange::{DataInterchange, JsonDataInterchange};
+    /// use tuf::interchange::{DataInterchange, Json};
     /// use std::collections::HashMap;
     ///
     /// #[derive(Serialize)]
@@ -281,7 +281,7 @@
     /// fn main() {
     ///     let jsn = json!({"foo": "wat", "bar": "lol"});
     ///     let thing = Thing { foo: "wat".into(), bar: "lol".into() };
-    ///     let se: serde_json::Value = JsonDataInterchange::serialize(&thing).unwrap();
+    ///     let se: serde_json::Value = Json::serialize(&thing).unwrap();
     ///     assert_eq!(se, jsn);
     /// }
     /// ```
@@ -293,11 +293,11 @@
     }
 
     /// ```
-    /// use tuf::interchange::{DataInterchange, JsonDataInterchange};
+    /// use tuf::interchange::{DataInterchange, Json};
     ///
     /// let arr = vec![1, 2, 3];
     /// let mut buf = Vec::new();
-    /// JsonDataInterchange::to_writer(&mut buf, &arr).unwrap();
+    /// Json::to_writer(&mut buf, &arr).unwrap();
     /// assert!(&buf == b"[1, 2, 3]" || &buf == b"[1,2,3]");
     /// ```
     fn to_writer<W, T: Sized>(mut writer: W, value: &T) -> Result<()>
@@ -311,11 +311,11 @@
     }
 
     /// ```
-    /// use tuf::interchange::{DataInterchange, JsonDataInterchange};
+    /// use tuf::interchange::{DataInterchange, Json};
     /// use std::collections::HashMap;
     ///
     /// let jsn: &[u8] = br#"{"foo": "bar", "baz": "quux"}"#;
-    /// let _: HashMap<String, String> = JsonDataInterchange::from_reader(jsn).unwrap();
+    /// let _: HashMap<String, String> = Json::from_reader(jsn).unwrap();
     /// ```
     fn from_reader<R, T>(rdr: R) -> Result<T>
     where
diff --git a/src/metadata.rs b/src/metadata.rs
index 6d730da..e0599c3 100644
--- a/src/metadata.rs
+++ b/src/metadata.rs
@@ -248,7 +248,7 @@
     ///
     /// use chrono::prelude::*;
     /// use tuf::crypto::{PrivateKey, SignatureScheme, HashAlgorithm};
-    /// use tuf::interchange::JsonDataInterchange;
+    /// use tuf::interchange::Json;
     /// use tuf::metadata::{MetadataDescription, TimestampMetadata, SignedMetadata};
     ///
     /// fn main() {
@@ -262,7 +262,7 @@
     ///             &[HashAlgorithm::Sha256]).unwrap()
     ///     ).unwrap();
     ///
-    ///     SignedMetadata::<JsonDataInterchange, TimestampMetadata>::new(
+    ///     SignedMetadata::<Json, TimestampMetadata>::new(
     ///         &timestamp, &key, SignatureScheme::Ed25519).unwrap();
     /// }
     /// ```
@@ -296,7 +296,7 @@
     ///
     /// use chrono::prelude::*;
     /// use tuf::crypto::{PrivateKey, SignatureScheme, HashAlgorithm};
-    /// use tuf::interchange::JsonDataInterchange;
+    /// use tuf::interchange::Json;
     /// use tuf::metadata::{MetadataDescription, TimestampMetadata, SignedMetadata};
     ///
     /// fn main() {
@@ -314,7 +314,7 @@
     ///         MetadataDescription::from_reader(&*vec![0x01, 0x02, 0x03], 1,
     ///             &[HashAlgorithm::Sha256]).unwrap()
     ///     ).unwrap();
-    ///     let mut timestamp = SignedMetadata::<JsonDataInterchange, TimestampMetadata>::new(
+    ///     let mut timestamp = SignedMetadata::<Json, TimestampMetadata>::new(
     ///         &timestamp, &key_1, SignatureScheme::Ed25519).unwrap();
     ///
     ///     timestamp.add_signature(&key_2, SignatureScheme::Ed25519).unwrap();
@@ -390,7 +390,7 @@
     ///
     /// use chrono::prelude::*;
     /// use tuf::crypto::{PrivateKey, SignatureScheme, HashAlgorithm};
-    /// use tuf::interchange::JsonDataInterchange;
+    /// use tuf::interchange::Json;
     /// use tuf::metadata::{MetadataDescription, TimestampMetadata, SignedMetadata};
     ///
     /// fn main() {
@@ -406,7 +406,7 @@
     ///         MetadataDescription::from_reader(&*vec![0x01, 0x02, 0x03], 1,
     ///             &[HashAlgorithm::Sha256]).unwrap()
     ///     ).unwrap();
-    ///     let timestamp = SignedMetadata::<JsonDataInterchange, TimestampMetadata>::new(
+    ///     let timestamp = SignedMetadata::<Json, TimestampMetadata>::new(
     ///         &timestamp, &key_1, SignatureScheme::Ed25519).unwrap();
     ///
     ///     assert!(timestamp.verify(
@@ -528,7 +528,7 @@
 
         let keys_len = keys.len();
         let keys = HashMap::from_iter(keys.drain(..).map(|k| (k.key_id().clone(), k)));
-        
+
         if keys.len() != keys_len {
             return Err(Error::IllegalArgument("Cannot have duplicate keys".into()));
         }
@@ -739,15 +739,15 @@
     ///
     /// ```
     /// use tuf::crypto::HashValue;
-    /// use tuf::interchange::JsonDataInterchange;
+    /// use tuf::interchange::Json;
     /// use tuf::metadata::{MetadataPath, MetadataVersion};
     ///
     /// let path = MetadataPath::new("foo/bar".into()).unwrap();
-    /// assert_eq!(path.components::<JsonDataInterchange>(&MetadataVersion::None),
+    /// assert_eq!(path.components::<Json>(&MetadataVersion::None),
     ///            ["foo".to_string(), "bar.json".to_string()]);
-    /// assert_eq!(path.components::<JsonDataInterchange>(&MetadataVersion::Number(1)),
+    /// assert_eq!(path.components::<Json>(&MetadataVersion::Number(1)),
     ///            ["foo".to_string(), "1.bar.json".to_string()]);
-    /// assert_eq!(path.components::<JsonDataInterchange>(
+    /// assert_eq!(path.components::<Json>(
     ///                 &MetadataVersion::Hash(HashValue::new(vec![0x69, 0xb7, 0x1d]))),
     ///            ["foo".to_string(), "abcd.bar.json".to_string()]);
     /// ```
@@ -1431,7 +1431,7 @@
     use super::*;
     use chrono::prelude::*;
     use json;
-    use interchange::JsonDataInterchange;
+    use interchange::Json;
 
     const ED25519_1_PK8: &'static [u8] = include_bytes!("../tests/ed25519/ed25519-1.pk8.der");
     const ED25519_2_PK8: &'static [u8] = include_bytes!("../tests/ed25519/ed25519-2.pk8.der");
@@ -1814,7 +1814,7 @@
 
         let key = PrivateKey::from_pkcs8(ED25519_1_PK8).unwrap();
 
-        let signed = SignedMetadata::<JsonDataInterchange, SnapshotMetadata>::new(
+        let signed = SignedMetadata::<Json, SnapshotMetadata>::new(
             &snapshot,
             &key,
             SignatureScheme::Ed25519,
@@ -1847,8 +1847,7 @@
 
         let encoded = json::to_value(&signed).unwrap();
         assert_eq!(encoded, jsn);
-        let decoded: SignedMetadata<JsonDataInterchange, SnapshotMetadata> =
-            json::from_value(encoded).unwrap();
+        let decoded: SignedMetadata<Json, SnapshotMetadata> = json::from_value(encoded).unwrap();
         assert_eq!(decoded, signed);
     }
 
diff --git a/src/repository.rs b/src/repository.rs
index cc1d879..425a4d4 100644
--- a/src/repository.rs
+++ b/src/repository.rs
@@ -511,11 +511,11 @@
 mod test {
     use super::*;
     use tempdir::TempDir;
-    use interchange::JsonDataInterchange;
+    use interchange::Json;
 
     #[test]
     fn ephemeral_repo_targets() {
-        let mut repo = EphemeralRepository::<JsonDataInterchange>::new();
+        let mut repo = EphemeralRepository::<Json>::new();
         repo.initialize().unwrap();
 
         let data: &[u8] = b"like tears in the rain";
@@ -538,8 +538,7 @@
     #[test]
     fn file_system_repo_targets() {
         let temp_dir = TempDir::new("rust-tuf").unwrap();
-        let mut repo =
-            FileSystemRepository::<JsonDataInterchange>::new(temp_dir.path().to_path_buf());
+        let mut repo = FileSystemRepository::<Json>::new(temp_dir.path().to_path_buf());
         repo.initialize().unwrap();
 
         let data: &[u8] = b"like tears in the rain";
diff --git a/src/shims.rs b/src/shims.rs
index ef096b3..ce8e6b1 100644
--- a/src/shims.rs
+++ b/src/shims.rs
@@ -9,12 +9,21 @@
 use metadata;
 
 fn parse_datetime(ts: &str) -> Result<DateTime<Utc>> {
-    Utc.datetime_from_str(ts, "%FT%TZ")
-        .map_err(|e| Error::Encoding(format!("Can't parse DateTime: {:?}", e)))
+    Utc.datetime_from_str(ts, "%FT%TZ").map_err(|e| {
+        Error::Encoding(format!("Can't parse DateTime: {:?}", e))
+    })
 }
 
 fn format_datetime(ts: &DateTime<Utc>) -> String {
-    format!("{:04}-{:02}-{:02}T{:02}:{:02}:{:02}Z", ts.year(), ts.month(), ts.day(), ts.hour(), ts.minute(), ts.second())
+    format!(
+        "{:04}-{:02}-{:02}T{:02}:{:02}:{:02}Z",
+        ts.year(),
+        ts.month(),
+        ts.day(),
+        ts.hour(),
+        ts.minute(),
+        ts.second()
+    )
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -33,7 +42,10 @@
 
 impl RootMetadata {
     pub fn from(meta: &metadata::RootMetadata) -> Result<Self> {
-        let mut keys = meta.keys().iter().map(|(_, v)| v.clone()).collect::<Vec<crypto::PublicKey>>();
+        let mut keys = meta.keys()
+            .iter()
+            .map(|(_, v)| v.clone())
+            .collect::<Vec<crypto::PublicKey>>();
         keys.sort_by_key(|k| k.key_id().clone());
 
         Ok(RootMetadata {
@@ -138,7 +150,11 @@
             )));
         }
 
-        metadata::TimestampMetadata::new(self.version, parse_datetime(&self.expires)?, self.snapshot)
+        metadata::TimestampMetadata::new(
+            self.version,
+            parse_datetime(&self.expires)?,
+            self.snapshot,
+        )
     }
 }
 
@@ -204,7 +220,12 @@
             )));
         }
 
-        metadata::TargetsMetadata::new(self.version, parse_datetime(&self.expires)?, self.targets, self.delegations)
+        metadata::TargetsMetadata::new(
+            self.version,
+            parse_datetime(&self.expires)?,
+            self.targets,
+            self.delegations,
+        )
     }
 }
 
diff --git a/src/tuf.rs b/src/tuf.rs
index 2d19abb..057d726 100644
--- a/src/tuf.rs
+++ b/src/tuf.rs
@@ -181,7 +181,9 @@
         } else if timestamp.version() == current_version {
             Ok(false)
         } else {
-            if self.snapshot.as_ref().map(|s| s.version()).unwrap_or(0) != timestamp.snapshot().version() {
+            if self.snapshot.as_ref().map(|s| s.version()).unwrap_or(0) !=
+                timestamp.snapshot().version()
+            {
                 self.snapshot = None;
             }
 
@@ -241,7 +243,13 @@
             snapshot
         };
 
-        if self.targets.as_ref().map(|s| s.version()).unwrap_or(0) != snapshot.meta().get(&MetadataPath::from_role(&Role::Targets)).map(|m| m.version()).unwrap_or(0) {
+        if self.targets.as_ref().map(|s| s.version()).unwrap_or(0) !=
+            snapshot
+                .meta()
+                .get(&MetadataPath::from_role(&Role::Targets))
+                .map(|m| m.version())
+                .unwrap_or(0)
+        {
             self.targets = None;
         }
 
@@ -567,7 +575,7 @@
     use super::*;
     use chrono::prelude::*;
     use crypto::{PrivateKey, SignatureScheme, HashAlgorithm};
-    use interchange::JsonDataInterchange;
+    use interchange::Json;
     use metadata::{RoleDefinition, MetadataDescription};
 
     lazy_static! {
@@ -597,7 +605,7 @@
             RoleDefinition::new(1, hashset!(KEYS[0].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[0].key_id().clone())).unwrap(),
         ).unwrap();
-        let root: SignedMetadata<JsonDataInterchange, RootMetadata> =
+        let root: SignedMetadata<Json, RootMetadata> =
             SignedMetadata::new(&root, &root_key, SignatureScheme::Ed25519).unwrap();
 
         assert!(Tuf::from_root_pinned(root, &[root_key.key_id().clone()]).is_ok());
@@ -615,7 +623,7 @@
             RoleDefinition::new(1, hashset!(KEYS[0].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[0].key_id().clone())).unwrap(),
         ).unwrap();
-        let root: SignedMetadata<JsonDataInterchange, RootMetadata> =
+        let root: SignedMetadata<Json, RootMetadata> =
             SignedMetadata::new(&root, &KEYS[0], SignatureScheme::Ed25519).unwrap();
 
         assert!(Tuf::from_root_pinned(root, &[KEYS[1].key_id().clone()]).is_err());
@@ -633,7 +641,7 @@
             RoleDefinition::new(1, hashset!(KEYS[0].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[0].key_id().clone())).unwrap(),
         ).unwrap();
-        let root: SignedMetadata<JsonDataInterchange, RootMetadata> =
+        let root: SignedMetadata<Json, RootMetadata> =
             SignedMetadata::new(&root, &KEYS[0], SignatureScheme::Ed25519).unwrap();
 
         let mut tuf = Tuf::from_root(root).unwrap();
@@ -648,7 +656,7 @@
             RoleDefinition::new(1, hashset!(KEYS[1].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[1].key_id().clone())).unwrap(),
         ).unwrap();
-        let mut root: SignedMetadata<JsonDataInterchange, RootMetadata> =
+        let mut root: SignedMetadata<Json, RootMetadata> =
             SignedMetadata::new(&root, &KEYS[1], SignatureScheme::Ed25519).unwrap();
 
         // add the original key's signature to make it cross signed
@@ -673,7 +681,7 @@
             RoleDefinition::new(1, hashset!(KEYS[0].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[0].key_id().clone())).unwrap(),
         ).unwrap();
-        let root: SignedMetadata<JsonDataInterchange, RootMetadata> =
+        let root: SignedMetadata<Json, RootMetadata> =
             SignedMetadata::new(&root, &KEYS[0], SignatureScheme::Ed25519).unwrap();
 
         let mut tuf = Tuf::from_root(root).unwrap();
@@ -689,7 +697,7 @@
             RoleDefinition::new(1, hashset!(KEYS[1].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[1].key_id().clone())).unwrap(),
         ).unwrap();
-        let root: SignedMetadata<JsonDataInterchange, RootMetadata> =
+        let root: SignedMetadata<Json, RootMetadata> =
             SignedMetadata::new(&root, &KEYS[1], SignatureScheme::Ed25519).unwrap();
 
         assert!(tuf.update_root(root).is_err());
@@ -707,7 +715,7 @@
             RoleDefinition::new(1, hashset!(KEYS[1].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[1].key_id().clone())).unwrap(),
         ).unwrap();
-        let root: SignedMetadata<JsonDataInterchange, RootMetadata> =
+        let root: SignedMetadata<Json, RootMetadata> =
             SignedMetadata::new(&root, &KEYS[0], SignatureScheme::Ed25519).unwrap();
 
         let mut tuf = Tuf::from_root(root).unwrap();
@@ -718,7 +726,7 @@
             MetadataDescription::from_reader(&*vec![], 1, &[HashAlgorithm::Sha256])
                 .unwrap(),
         ).unwrap();
-        let timestamp: SignedMetadata<JsonDataInterchange, TimestampMetadata> =
+        let timestamp: SignedMetadata<Json, TimestampMetadata> =
             SignedMetadata::new(&timestamp, &KEYS[1], SignatureScheme::Ed25519).unwrap();
 
         assert_eq!(tuf.update_timestamp(timestamp.clone()), Ok(true));
@@ -739,7 +747,7 @@
             RoleDefinition::new(1, hashset!(KEYS[1].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[1].key_id().clone())).unwrap(),
         ).unwrap();
-        let root: SignedMetadata<JsonDataInterchange, RootMetadata> =
+        let root: SignedMetadata<Json, RootMetadata> =
             SignedMetadata::new(&root, &KEYS[0], SignatureScheme::Ed25519).unwrap();
 
         let mut tuf = Tuf::from_root(root).unwrap();
@@ -752,7 +760,7 @@
         ).unwrap();
 
         // sign it with the root key
-        let timestamp: SignedMetadata<JsonDataInterchange, TimestampMetadata> =
+        let timestamp: SignedMetadata<Json, TimestampMetadata> =
             SignedMetadata::new(&timestamp, &KEYS[0], SignatureScheme::Ed25519).unwrap();
 
         assert!(tuf.update_timestamp(timestamp).is_err())
@@ -774,7 +782,7 @@
             RoleDefinition::new(1, hashset!(KEYS[2].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[2].key_id().clone())).unwrap(),
         ).unwrap();
-        let root: SignedMetadata<JsonDataInterchange, RootMetadata> =
+        let root: SignedMetadata<Json, RootMetadata> =
             SignedMetadata::new(&root, &KEYS[0], SignatureScheme::Ed25519).unwrap();
 
         let mut tuf = Tuf::from_root(root).unwrap();
@@ -785,14 +793,14 @@
             MetadataDescription::from_reader(&*vec![], 1, &[HashAlgorithm::Sha256])
                 .unwrap(),
         ).unwrap();
-        let timestamp: SignedMetadata<JsonDataInterchange, TimestampMetadata> =
+        let timestamp: SignedMetadata<Json, TimestampMetadata> =
             SignedMetadata::new(&timestamp, &KEYS[2], SignatureScheme::Ed25519).unwrap();
 
         tuf.update_timestamp(timestamp).unwrap();
 
         let snapshot = SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), hashmap!())
             .unwrap();
-        let snapshot: SignedMetadata<JsonDataInterchange, SnapshotMetadata> =
+        let snapshot: SignedMetadata<Json, SnapshotMetadata> =
             SignedMetadata::new(&snapshot, &KEYS[1], SignatureScheme::Ed25519).unwrap();
 
         assert_eq!(tuf.update_snapshot(snapshot.clone()), Ok(true));
@@ -817,7 +825,7 @@
             RoleDefinition::new(1, hashset!(KEYS[2].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[2].key_id().clone())).unwrap(),
         ).unwrap();
-        let root: SignedMetadata<JsonDataInterchange, RootMetadata> =
+        let root: SignedMetadata<Json, RootMetadata> =
             SignedMetadata::new(&root, &KEYS[0], SignatureScheme::Ed25519).unwrap();
 
         let mut tuf = Tuf::from_root(root).unwrap();
@@ -828,14 +836,14 @@
             MetadataDescription::from_reader(&*vec![], 1, &[HashAlgorithm::Sha256])
                 .unwrap(),
         ).unwrap();
-        let timestamp: SignedMetadata<JsonDataInterchange, TimestampMetadata> =
+        let timestamp: SignedMetadata<Json, TimestampMetadata> =
             SignedMetadata::new(&timestamp, &KEYS[2], SignatureScheme::Ed25519).unwrap();
 
         tuf.update_timestamp(timestamp).unwrap();
 
         let snapshot = SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), hashmap!())
             .unwrap();
-        let snapshot: SignedMetadata<JsonDataInterchange, SnapshotMetadata> =
+        let snapshot: SignedMetadata<Json, SnapshotMetadata> =
             SignedMetadata::new(&snapshot, &KEYS[2], SignatureScheme::Ed25519).unwrap();
 
         assert!(tuf.update_snapshot(snapshot.clone()).is_err());
@@ -857,7 +865,7 @@
             RoleDefinition::new(1, hashset!(KEYS[2].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[2].key_id().clone())).unwrap(),
         ).unwrap();
-        let root: SignedMetadata<JsonDataInterchange, RootMetadata> =
+        let root: SignedMetadata<Json, RootMetadata> =
             SignedMetadata::new(&root, &KEYS[0], SignatureScheme::Ed25519).unwrap();
 
         let mut tuf = Tuf::from_root(root).unwrap();
@@ -868,14 +876,14 @@
             MetadataDescription::from_reader(&*vec![], 2, &[HashAlgorithm::Sha256])
                 .unwrap(),
         ).unwrap();
-        let timestamp: SignedMetadata<JsonDataInterchange, TimestampMetadata> =
+        let timestamp: SignedMetadata<Json, TimestampMetadata> =
             SignedMetadata::new(&timestamp, &KEYS[2], SignatureScheme::Ed25519).unwrap();
 
         tuf.update_timestamp(timestamp).unwrap();
 
         let snapshot = SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), hashmap!())
             .unwrap();
-        let snapshot: SignedMetadata<JsonDataInterchange, SnapshotMetadata> =
+        let snapshot: SignedMetadata<Json, SnapshotMetadata> =
             SignedMetadata::new(&snapshot, &KEYS[1], SignatureScheme::Ed25519).unwrap();
 
         assert!(tuf.update_snapshot(snapshot).is_err());
@@ -898,7 +906,7 @@
             RoleDefinition::new(1, hashset!(KEYS[2].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[3].key_id().clone())).unwrap(),
         ).unwrap();
-        let root: SignedMetadata<JsonDataInterchange, RootMetadata> =
+        let root: SignedMetadata<Json, RootMetadata> =
             SignedMetadata::new(&root, &KEYS[0], SignatureScheme::Ed25519).unwrap();
 
         let mut tuf = Tuf::from_root(root).unwrap();
@@ -909,7 +917,7 @@
             MetadataDescription::from_reader(&*vec![], 1, &[HashAlgorithm::Sha256])
                 .unwrap(),
         ).unwrap();
-        let timestamp: SignedMetadata<JsonDataInterchange, TimestampMetadata> =
+        let timestamp: SignedMetadata<Json, TimestampMetadata> =
             SignedMetadata::new(&timestamp, &KEYS[3], SignatureScheme::Ed25519).unwrap();
 
         tuf.update_timestamp(timestamp).unwrap();
@@ -921,7 +929,7 @@
         );
         let snapshot = SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), meta_map)
             .unwrap();
-        let snapshot: SignedMetadata<JsonDataInterchange, SnapshotMetadata> =
+        let snapshot: SignedMetadata<Json, SnapshotMetadata> =
             SignedMetadata::new(&snapshot, &KEYS[1], SignatureScheme::Ed25519).unwrap();
 
         tuf.update_snapshot(snapshot).unwrap();
@@ -929,7 +937,7 @@
         let targets =
             TargetsMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), hashmap!(), None)
                 .unwrap();
-        let targets: SignedMetadata<JsonDataInterchange, TargetsMetadata> =
+        let targets: SignedMetadata<Json, TargetsMetadata> =
             SignedMetadata::new(&targets, &KEYS[2], SignatureScheme::Ed25519).unwrap();
 
         assert_eq!(tuf.update_targets(targets.clone()), Ok(true));
@@ -955,7 +963,7 @@
             RoleDefinition::new(1, hashset!(KEYS[2].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[3].key_id().clone())).unwrap(),
         ).unwrap();
-        let root: SignedMetadata<JsonDataInterchange, RootMetadata> =
+        let root: SignedMetadata<Json, RootMetadata> =
             SignedMetadata::new(&root, &KEYS[0], SignatureScheme::Ed25519).unwrap();
 
         let mut tuf = Tuf::from_root(root).unwrap();
@@ -966,7 +974,7 @@
             MetadataDescription::from_reader(&*vec![], 1, &[HashAlgorithm::Sha256])
                 .unwrap(),
         ).unwrap();
-        let timestamp: SignedMetadata<JsonDataInterchange, TimestampMetadata> =
+        let timestamp: SignedMetadata<Json, TimestampMetadata> =
             SignedMetadata::new(&timestamp, &KEYS[3], SignatureScheme::Ed25519).unwrap();
 
         tuf.update_timestamp(timestamp).unwrap();
@@ -978,7 +986,7 @@
         );
         let snapshot = SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), meta_map)
             .unwrap();
-        let snapshot: SignedMetadata<JsonDataInterchange, SnapshotMetadata> =
+        let snapshot: SignedMetadata<Json, SnapshotMetadata> =
             SignedMetadata::new(&snapshot, &KEYS[1], SignatureScheme::Ed25519).unwrap();
 
         tuf.update_snapshot(snapshot).unwrap();
@@ -986,7 +994,7 @@
         let targets =
             TargetsMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), hashmap!(), None)
                 .unwrap();
-        let targets: SignedMetadata<JsonDataInterchange, TargetsMetadata> =
+        let targets: SignedMetadata<Json, TargetsMetadata> =
             SignedMetadata::new(&targets, &KEYS[3], SignatureScheme::Ed25519).unwrap();
 
         assert!(tuf.update_targets(targets).is_err());
@@ -1009,7 +1017,7 @@
             RoleDefinition::new(1, hashset!(KEYS[2].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[3].key_id().clone())).unwrap(),
         ).unwrap();
-        let root: SignedMetadata<JsonDataInterchange, RootMetadata> =
+        let root: SignedMetadata<Json, RootMetadata> =
             SignedMetadata::new(&root, &KEYS[0], SignatureScheme::Ed25519).unwrap();
 
         let mut tuf = Tuf::from_root(root).unwrap();
@@ -1020,7 +1028,7 @@
             MetadataDescription::from_reader(&*vec![], 1, &[HashAlgorithm::Sha256])
                 .unwrap(),
         ).unwrap();
-        let timestamp: SignedMetadata<JsonDataInterchange, TimestampMetadata> =
+        let timestamp: SignedMetadata<Json, TimestampMetadata> =
             SignedMetadata::new(&timestamp, &KEYS[3], SignatureScheme::Ed25519).unwrap();
 
         tuf.update_timestamp(timestamp).unwrap();
@@ -1032,7 +1040,7 @@
         );
         let snapshot = SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), meta_map)
             .unwrap();
-        let snapshot: SignedMetadata<JsonDataInterchange, SnapshotMetadata> =
+        let snapshot: SignedMetadata<Json, SnapshotMetadata> =
             SignedMetadata::new(&snapshot, &KEYS[1], SignatureScheme::Ed25519).unwrap();
 
         tuf.update_snapshot(snapshot).unwrap();
@@ -1040,7 +1048,7 @@
         let targets =
             TargetsMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), hashmap!(), None)
                 .unwrap();
-        let targets: SignedMetadata<JsonDataInterchange, TargetsMetadata> =
+        let targets: SignedMetadata<Json, TargetsMetadata> =
             SignedMetadata::new(&targets, &KEYS[2], SignatureScheme::Ed25519).unwrap();
 
         assert!(tuf.update_targets(targets).is_err());
diff --git a/tests/integration.rs b/tests/integration.rs
index 1871162..57101c8 100644
--- a/tests/integration.rs
+++ b/tests/integration.rs
@@ -8,7 +8,7 @@
 use std::collections::HashMap;
 use tuf::Tuf;
 use tuf::crypto::{PrivateKey, SignatureScheme, HashAlgorithm};
-use tuf::interchange::JsonDataInterchange;
+use tuf::interchange::Json;
 use tuf::metadata::{RoleDefinition, RootMetadata, MetadataPath, SignedMetadata, TargetDescription,
                     TargetPath, TargetsMetadata, MetadataDescription, SnapshotMetadata,
                     TimestampMetadata, Delegation, Delegations};
@@ -52,20 +52,17 @@
         timestamp_def,
     ).unwrap();
 
-    let signed = SignedMetadata::<JsonDataInterchange, RootMetadata>::new(
-        &root,
-        &root_key,
-        SignatureScheme::Ed25519,
-    ).unwrap();
+    let signed =
+        SignedMetadata::<Json, RootMetadata>::new(&root, &root_key, SignatureScheme::Ed25519)
+            .unwrap();
 
-    let mut tuf =
-        Tuf::<JsonDataInterchange>::from_root_pinned(signed, &[root_key.key_id().clone()]).unwrap();
+    let mut tuf = Tuf::<Json>::from_root_pinned(signed, &[root_key.key_id().clone()]).unwrap();
 
     //// build the timestamp ////
     let snap = MetadataDescription::from_reader(&*vec![0u8], 1, &[HashAlgorithm::Sha256]).unwrap();
     let timestamp = TimestampMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), snap).unwrap();
 
-    let signed = SignedMetadata::<JsonDataInterchange, TimestampMetadata>::new(
+    let signed = SignedMetadata::<Json, TimestampMetadata>::new(
         &timestamp,
         &timestamp_key,
         SignatureScheme::Ed25519,
@@ -84,7 +81,7 @@
     let snapshot = SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), meta_map)
         .unwrap();
 
-    let signed = SignedMetadata::<JsonDataInterchange, SnapshotMetadata>::new(
+    let signed = SignedMetadata::<Json, SnapshotMetadata>::new(
         &snapshot,
         &snapshot_key,
         SignatureScheme::Ed25519,
@@ -118,7 +115,7 @@
         Some(delegations),
     ).unwrap();
 
-    let signed = SignedMetadata::<JsonDataInterchange, TargetsMetadata>::new(
+    let signed = SignedMetadata::<Json, TargetsMetadata>::new(
         &targets,
         &targets_key,
         SignatureScheme::Ed25519,
@@ -136,7 +133,7 @@
     let delegation =
         TargetsMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), target_map, None).unwrap();
 
-    let signed = SignedMetadata::<JsonDataInterchange, TargetsMetadata>::new(
+    let signed = SignedMetadata::<Json, TargetsMetadata>::new(
         &delegation,
         &delegation_key,
         SignatureScheme::Ed25519,
@@ -184,20 +181,17 @@
         timestamp_def,
     ).unwrap();
 
-    let signed = SignedMetadata::<JsonDataInterchange, RootMetadata>::new(
-        &root,
-        &root_key,
-        SignatureScheme::Ed25519,
-    ).unwrap();
+    let signed =
+        SignedMetadata::<Json, RootMetadata>::new(&root, &root_key, SignatureScheme::Ed25519)
+            .unwrap();
 
-    let mut tuf =
-        Tuf::<JsonDataInterchange>::from_root_pinned(signed, &[root_key.key_id().clone()]).unwrap();
+    let mut tuf = Tuf::<Json>::from_root_pinned(signed, &[root_key.key_id().clone()]).unwrap();
 
     //// build the timestamp ////
     let snap = MetadataDescription::from_reader(&*vec![0u8], 1, &[HashAlgorithm::Sha256]).unwrap();
     let timestamp = TimestampMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), snap).unwrap();
 
-    let signed = SignedMetadata::<JsonDataInterchange, TimestampMetadata>::new(
+    let signed = SignedMetadata::<Json, TimestampMetadata>::new(
         &timestamp,
         &timestamp_key,
         SignatureScheme::Ed25519,
@@ -218,7 +212,7 @@
     let snapshot = SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), meta_map)
         .unwrap();
 
-    let signed = SignedMetadata::<JsonDataInterchange, SnapshotMetadata>::new(
+    let signed = SignedMetadata::<Json, SnapshotMetadata>::new(
         &snapshot,
         &snapshot_key,
         SignatureScheme::Ed25519,
@@ -252,7 +246,7 @@
         Some(delegations),
     ).unwrap();
 
-    let signed = SignedMetadata::<JsonDataInterchange, TargetsMetadata>::new(
+    let signed = SignedMetadata::<Json, TargetsMetadata>::new(
         &targets,
         &targets_key,
         SignatureScheme::Ed25519,
@@ -286,7 +280,7 @@
         Some(delegations),
     ).unwrap();
 
-    let signed = SignedMetadata::<JsonDataInterchange, TargetsMetadata>::new(
+    let signed = SignedMetadata::<Json, TargetsMetadata>::new(
         &delegation,
         &delegation_a_key,
         SignatureScheme::Ed25519,
@@ -306,7 +300,7 @@
     let delegation =
         TargetsMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), target_map, None).unwrap();
 
-    let signed = SignedMetadata::<JsonDataInterchange, TargetsMetadata>::new(
+    let signed = SignedMetadata::<Json, TargetsMetadata>::new(
         &delegation,
         &delegation_b_key,
         SignatureScheme::Ed25519,
diff --git a/tests/simple_example.rs b/tests/simple_example.rs
index dfffed9..51949ab 100644
--- a/tests/simple_example.rs
+++ b/tests/simple_example.rs
@@ -8,7 +8,7 @@
 use tuf::Error;
 use tuf::client::{Client, Config};
 use tuf::crypto::{PrivateKey, SignatureScheme, KeyId, HashAlgorithm};
-use tuf::interchange::{DataInterchange, JsonDataInterchange};
+use tuf::interchange::{DataInterchange, Json};
 use tuf::metadata::{RoleDefinition, RootMetadata, Role, MetadataVersion, MetadataPath,
                     SignedMetadata, TargetDescription, TargetPath, TargetsMetadata,
                     MetadataDescription, SnapshotMetadata, TimestampMetadata};
@@ -23,16 +23,13 @@
 
 #[test]
 fn main() {
-    let mut remote = EphemeralRepository::<JsonDataInterchange>::new();
+    let mut remote = EphemeralRepository::<Json>::new();
     let root_key_ids = init_server(&mut remote).unwrap();
     init_client(&root_key_ids, remote).unwrap();
 }
 
-fn init_client(
-    root_key_ids: &[KeyId],
-    remote: EphemeralRepository<JsonDataInterchange>,
-) -> Result<(), Error> {
-    let local = EphemeralRepository::<JsonDataInterchange>::new();
+fn init_client(root_key_ids: &[KeyId], remote: EphemeralRepository<Json>) -> Result<(), Error> {
+    let local = EphemeralRepository::<Json>::new();
     let config = Config::build().finish()?;
 
     let mut client = Client::with_root_pinned(root_key_ids, config, local, remote)?;
@@ -44,7 +41,7 @@
     client.fetch_target(&TargetPath::new("grendel".into())?)
 }
 
-fn init_server(remote: &mut EphemeralRepository<JsonDataInterchange>) -> Result<Vec<KeyId>, Error> {
+fn init_server(remote: &mut EphemeralRepository<Json>) -> Result<Vec<KeyId>, Error> {
     // in real life, you wouldn't want these keys on the same machine ever
     let root_key = PrivateKey::from_pkcs8(ED25519_1_PK8)?;
     let snapshot_key = PrivateKey::from_pkcs8(ED25519_2_PK8)?;
@@ -76,11 +73,8 @@
         timestamp_def,
     )?;
 
-    let signed = SignedMetadata::<JsonDataInterchange, RootMetadata>::new(
-        &root,
-        &root_key,
-        SignatureScheme::Ed25519,
-    )?;
+    let signed =
+        SignedMetadata::<Json, RootMetadata>::new(&root, &root_key, SignatureScheme::Ed25519)?;
 
     remote.store_metadata(
         &Role::Root,
@@ -105,7 +99,7 @@
     let target_map = hashmap!(target_path => target_description);
     let targets = TargetsMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), target_map, None)?;
 
-    let signed = SignedMetadata::<JsonDataInterchange, TargetsMetadata>::new(
+    let signed = SignedMetadata::<Json, TargetsMetadata>::new(
         &targets,
         &targets_key,
         SignatureScheme::Ed25519,
@@ -124,8 +118,7 @@
         &signed,
     )?;
 
-    let targets_bytes =
-        JsonDataInterchange::canonicalize(&JsonDataInterchange::serialize(&signed)?)?;
+    let targets_bytes = Json::canonicalize(&Json::serialize(&signed)?)?;
 
     //// build the snapshot ////
     let meta_map =
@@ -135,7 +128,7 @@
     };
     let snapshot = SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), meta_map)?;
 
-    let signed = SignedMetadata::<JsonDataInterchange, SnapshotMetadata>::new(
+    let signed = SignedMetadata::<Json, SnapshotMetadata>::new(
         &snapshot,
         &snapshot_key,
         SignatureScheme::Ed25519,
@@ -154,14 +147,13 @@
         &signed,
     )?;
 
-    let snapshot_bytes =
-        JsonDataInterchange::canonicalize(&JsonDataInterchange::serialize(&signed)?)?;
+    let snapshot_bytes = Json::canonicalize(&Json::serialize(&signed)?)?;
 
     //// build the timestamp ////
     let snap = MetadataDescription::from_reader(&*snapshot_bytes, 1, &[HashAlgorithm::Sha256])?;
     let timestamp = TimestampMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), snap)?;
 
-    let signed = SignedMetadata::<JsonDataInterchange, TimestampMetadata>::new(
+    let signed = SignedMetadata::<Json, TimestampMetadata>::new(
         &timestamp,
         &timestamp_key,
         SignatureScheme::Ed25519,