diff --git a/src/banking_stage.rs b/src/banking_stage.rs
index b80fd0541..24d05f882 100644
--- a/src/banking_stage.rs
+++ b/src/banking_stage.rs
@@ -100,7 +100,7 @@ impl BankingStage {
             debug!("process_transactions");
             let results = bank.process_transactions(transactions);
             let transactions = results.into_iter().filter_map(|x| x.ok()).collect();
-            signal_sender.send(Signal::Events(transactions))?;
+            signal_sender.send(Signal::Transactions(transactions))?;
             debug!("done process_transactions");
 
             packet_recycler.recycle(msgs);
@@ -293,7 +293,7 @@ mod bench {
                 &packet_recycler,
             ).unwrap();
             let signal = signal_receiver.recv().unwrap();
-            if let Signal::Events(transactions) = signal {
+            if let Signal::Transactions(transactions) = signal {
                 assert_eq!(transactions.len(), tx);
             } else {
                 assert!(false);
diff --git a/src/entry.rs b/src/entry.rs
index 4c7693874..a47a53633 100644
--- a/src/entry.rs
+++ b/src/entry.rs
@@ -9,7 +9,7 @@ use transaction::Transaction;
 /// Each Entry contains three pieces of data. The `num_hashes` field is the number
 /// of hashes performed since the previous entry.  The `id` field is the result
 /// of hashing `id` from the previous entry `num_hashes` times.  The `transactions`
-/// field points to Events that took place shortly after `id` was generated.
+/// field points to Transactions that took place shortly after `id` was generated.
 ///
 /// If you divide `num_hashes` by the amount of time it takes to generate a new hash, you
 /// get a duration estimate since the last Entry. Since processing power increases
@@ -95,7 +95,7 @@ pub fn next_hash(start_hash: &Hash, num_hashes: u64, transactions: &[Transaction
     }
 }
 
-/// Creates the next Tick or Event Entry `num_hashes` after `start_hash`.
+/// Creates the next Tick or Transaction Entry `num_hashes` after `start_hash`.
 pub fn next_entry(start_hash: &Hash, num_hashes: u64, transactions: Vec<Transaction>) -> Entry {
     Entry {
         num_hashes,
diff --git a/src/record_stage.rs b/src/record_stage.rs
index f6097d48f..ae8ae09d4 100644
--- a/src/record_stage.rs
+++ b/src/record_stage.rs
@@ -1,8 +1,8 @@
 //! The `record_stage` module provides an object for generating a Proof of History.
-//! It records Event items on behalf of its users. It continuously generates
-//! new hashes, only stopping to check if it has been sent an Event item. It
-//! tags each Event with an Entry, and sends it back. The Entry includes the
-//! Event, the latest hash, and the number of hashes since the last transaction.
+//! It records Transaction items on behalf of its users. It continuously generates
+//! new hashes, only stopping to check if it has been sent an Transaction item. It
+//! tags each Transaction with an Entry, and sends it back. The Entry includes the
+//! Transaction, the latest hash, and the number of hashes since the last transaction.
 //! The resulting stream of entries represents ordered transactions in time.
 
 use entry::Entry;
@@ -16,7 +16,7 @@ use transaction::Transaction;
 #[cfg_attr(feature = "cargo-clippy", allow(large_enum_variant))]
 pub enum Signal {
     Tick,
-    Events(Vec<Transaction>),
+    Transactions(Vec<Transaction>),
 }
 
 pub struct RecordStage {
@@ -25,7 +25,7 @@ pub struct RecordStage {
 }
 
 impl RecordStage {
-    /// A background thread that will continue tagging received Event messages and
+    /// A background thread that will continue tagging received Transaction messages and
     /// sending back Entry messages until either the receiver or sender channel is closed.
     pub fn new(signal_receiver: Receiver<Signal>, start_hash: &Hash) -> Self {
         let (entry_sender, entry_receiver) = channel();
@@ -85,7 +85,7 @@ impl RecordStage {
         recorder: &mut Recorder,
         sender: &Sender<Entry>,
     ) -> Result<(), ()> {
-        let txs = if let Signal::Events(txs) = signal {
+        let txs = if let Signal::Transactions(txs) = signal {
             txs
         } else {
             vec![]
@@ -180,7 +180,9 @@ mod tests {
         let bob_pubkey = KeyPair::new().pubkey();
         let tx0 = Transaction::new(&alice_keypair, bob_pubkey, 1, zero);
         let tx1 = Transaction::new(&alice_keypair, bob_pubkey, 2, zero);
-        tx_sender.send(Signal::Events(vec![tx0, tx1])).unwrap();
+        tx_sender
+            .send(Signal::Transactions(vec![tx0, tx1]))
+            .unwrap();
         drop(tx_sender);
         let entries: Vec<_> = record_stage.entry_receiver.iter().collect();
         assert_eq!(entries.len(), 1);
diff --git a/src/recorder.rs b/src/recorder.rs
index a3bf0a143..f457df8ed 100644
--- a/src/recorder.rs
+++ b/src/recorder.rs
@@ -1,5 +1,5 @@
 //! The `recorder` module provides an object for generating a Proof of History.
-//! It records Event items on behalf of its users.
+//! It records Transaction items on behalf of its users.
 
 use entry::Entry;
 use hash::{hash, Hash};