diff --git a/bus.cpp b/bus.cpp
index 1ec2ce9..bfa415a 100644
--- a/bus.cpp
+++ b/bus.cpp
@@ -333,7 +333,7 @@ uint16_t bus::read(const uint16_t addr_in, const word_mode_t word_mode, const rm
 		}
 
 		if (a == ADDR_LFC) // line frequency clock and status register
-			return kw11_l_->readWord(a);
+			return kw11_l_->read_word(a);
 
 		if (a == ADDR_LP11CSR) { // printer, CSR register, LP11
 			uint16_t temp = 0x80;
@@ -349,9 +349,9 @@ uint16_t bus::read(const uint16_t addr_in, const word_mode_t word_mode, const rm
 				(a >= ADDR_PDR_U_START && a < ADDR_PDR_U_END) ||
 				(a >= ADDR_PAR_U_START && a < ADDR_PAR_U_END)) {
 			if (word_mode == wm_word)
-				return mmu_->readWord(a);
+				return mmu_->read_word(a);
 
-			return mmu_->readByte(a);
+			return mmu_->read_byte(a);
 		}
 		///////////
 
@@ -468,16 +468,16 @@ uint16_t bus::read(const uint16_t addr_in, const word_mode_t word_mode, const rm
 		}
 
 		if (tm11 && a >= TM_11_BASE && a < TM_11_END && !peek_only)
-			return word_mode == wm_byte ? tm11->readByte(a) : tm11->readWord(a);
+			return word_mode == wm_byte ? tm11->read_byte(a) : tm11->read_word(a);
 
 		if (rk05_ && a >= RK05_BASE && a < RK05_END && !peek_only)
-			return word_mode == wm_byte ? rk05_->readByte(a) : rk05_->readWord(a);
+			return word_mode == wm_byte ? rk05_->read_byte(a) : rk05_->read_word(a);
 
 		if (rl02_ && a >= RL02_BASE && a < RL02_END && !peek_only)
-			return word_mode == wm_byte ? rl02_->readByte(a) : rl02_->readWord(a);
+			return word_mode == wm_byte ? rl02_->read_byte(a) : rl02_->read_word(a);
 
 		if (tty_ && a >= PDP11TTY_BASE && a < PDP11TTY_END && !peek_only)
-			return word_mode == wm_byte ? tty_->readByte(a) : tty_->readWord(a);
+			return word_mode == wm_byte ? tty_->read_byte(a) : tty_->read_word(a);
 
 		if (dc11_ && a >= DC11_BASE && a < DC11_END && !peek_only)
 			return word_mode == wm_byte ? dc11_->read_byte(a) : dc11_->read_word(a);
@@ -937,32 +937,32 @@ write_rc_t bus::write(const uint16_t addr_in, const word_mode_t word_mode, uint1
 		}
 
 		if (a == ADDR_LFC) { // line frequency clock and status register
-			kw11_l_->writeWord(a, value);
+			kw11_l_->write_word(a, value);
 
 			return { false };
 		}
 
 		if (tm11 && a >= TM_11_BASE && a < TM_11_END) {
 			DOLOG(debug, false, "WRITE-I/O TM11 register %d: %06o", (a - TM_11_BASE) / 2, value);
-			word_mode == wm_byte ? tm11->writeByte(a, value) : tm11->writeWord(a, value);
+			word_mode == wm_byte ? tm11->write_byte(a, value) : tm11->write_word(a, value);
 			return { false };
 		}
 
 		if (rk05_ && a >= RK05_BASE && a < RK05_END) {
 			DOLOG(debug, false, "WRITE-I/O RK05 register %d: %06o", (a - RK05_BASE) / 2, value);
-			word_mode == wm_byte ? rk05_->writeByte(a, value) : rk05_->writeWord(a, value);
+			word_mode == wm_byte ? rk05_->write_byte(a, value) : rk05_->write_word(a, value);
 			return { false };
 		}
 
 		if (rl02_ && a >= RL02_BASE && a < RL02_END) {
 			DOLOG(debug, false, "WRITE-I/O RL02 register %d: %06o", (a - RL02_BASE) / 2, value);
-			word_mode == wm_byte ? rl02_->writeByte(a, value) : rl02_->writeWord(a, value);
+			word_mode == wm_byte ? rl02_->write_byte(a, value) : rl02_->write_word(a, value);
 			return { false };
 		}
 
 		if (tty_ && a >= PDP11TTY_BASE && a < PDP11TTY_END) {
 			DOLOG(debug, false, "WRITE-I/O TTY register %d: %06o", (a - PDP11TTY_BASE) / 2, value);
-			word_mode == wm_byte ? tty_->writeByte(a, value) : tty_->writeWord(a, value);
+			word_mode == wm_byte ? tty_->write_byte(a, value) : tty_->write_word(a, value);
 			return { false };
 		}
 
@@ -980,9 +980,9 @@ write_rc_t bus::write(const uint16_t addr_in, const word_mode_t word_mode, uint1
 				(a >= ADDR_PDR_U_START && a < ADDR_PDR_U_END) ||
 				(a >= ADDR_PAR_U_START && a < ADDR_PAR_U_END)) {
 			if (word_mode == wm_word)
-				mmu_->writeWord(a, value);
+				mmu_->write_word(a, value);
 			else
-				mmu_->writeByte(a, value);
+				mmu_->write_byte(a, value);
 
 			return { false };
 		}
@@ -1076,7 +1076,7 @@ uint16_t bus::readPhysical(const uint32_t a)
 	return value;
 }
 
-uint16_t bus::readWord(const uint16_t a, const d_i_space_t s)
+uint16_t bus::read_word(const uint16_t a, const d_i_space_t s)
 {
 	return read(a, wm_word, rm_cur, false, s);
 }
@@ -1086,7 +1086,7 @@ uint16_t bus::peekWord(const uint16_t a)
 	return read(a, wm_word, rm_cur, true);
 }
 
-void bus::writeWord(const uint16_t a, const uint16_t value, const d_i_space_t s)
+void bus::write_word(const uint16_t a, const uint16_t value, const d_i_space_t s)
 {
 	write(a, wm_word, value, rm_cur, s);
 }
diff --git a/bus.h b/bus.h
index 79c7e5e..8e12dd3 100644
--- a/bus.h
+++ b/bus.h
@@ -127,16 +127,16 @@ public:
 	dc11   *getDC11()   { return dc11_;   }
 
 	uint16_t read    (const uint16_t a, const word_mode_t word_mode, const rm_selection_t mode_selection, const bool peek_only=false, const d_i_space_t s = i_space);
-	uint16_t readByte(const uint16_t a) { return read(a, wm_byte, rm_cur); }
-	uint16_t readWord(const uint16_t a, const d_i_space_t s = i_space);
+	uint16_t read_byte(const uint16_t a) { return read(a, wm_byte, rm_cur); }
+	uint16_t read_word(const uint16_t a, const d_i_space_t s = i_space);
 	uint16_t peekWord(const uint16_t a);
 
 	uint8_t  readUnibusByte(const uint32_t a);
 	void     writeUnibusByte(const uint32_t a, const uint8_t value);
 
 	write_rc_t write    (const uint16_t a, const word_mode_t word_mode, uint16_t value, const rm_selection_t mode_selection, const d_i_space_t s = i_space);
-	void       writeByte(const uint16_t a, const uint8_t value) { write(a, wm_byte, value, rm_cur); }
-	void       writeWord(const uint16_t a, const uint16_t value, const d_i_space_t s = i_space);
+	void       write_byte(const uint16_t a, const uint8_t value) { write(a, wm_byte, value, rm_cur); }
+	void       write_word(const uint16_t a, const uint16_t value, const d_i_space_t s = i_space);
 
 	uint16_t readPhysical(const uint32_t a);
 	void     writePhysical(const uint32_t a, const uint16_t value);
diff --git a/console_ncurses.cpp b/console_ncurses.cpp
index 9988d46..7c2e8e8 100644
--- a/console_ncurses.cpp
+++ b/console_ncurses.cpp
@@ -147,7 +147,7 @@ void console_ncurses::panel_update_thread()
 			uint16_t current_PC    = c->getPC();
 			uint32_t full_addr     = b->calculate_physical_address(run_mode, current_PC, false, false, true, i_space);
 
-			uint16_t current_instr = b->readWord(current_PC);
+			uint16_t current_instr = b->read_word(current_PC);
 
 			auto data = c->disassemble(current_PC);
 
diff --git a/cpu.cpp b/cpu.cpp
index 5aa5de4..18854a6 100644
--- a/cpu.cpp
+++ b/cpu.cpp
@@ -1613,14 +1613,14 @@ void cpu::pushStack(const uint16_t v)
 	else {
 		uint16_t a = addRegister(6, rm_cur, -2);
 
-		b->writeWord(a, v, d_space);
+		b->write_word(a, v, d_space);
 	}
 }
 
 uint16_t cpu::popStack()
 {
 	uint16_t a    = getRegister(6);
-	uint16_t temp = b->readWord(a, d_space);
+	uint16_t temp = b->read_word(a, d_space);
 
 	addRegister(6, rm_cur, 2);
 
@@ -1762,7 +1762,7 @@ bool cpu::misc_operations(const uint16_t instr)
 		setPC(getRegister(link_reg));
 
 		// POP link
-		uint16_t word_on_stack = b->readWord(getRegister(6), d_space);
+		uint16_t word_on_stack = b->read_word(getRegister(6), d_space);
 
 		setRegister(link_reg, word_on_stack);
 
@@ -1821,10 +1821,10 @@ void cpu::trap(uint16_t vector, const int new_ipl, const bool is_interrupt)
 			// make sure the trap vector is retrieved from kernel space
 			psw &= 037777;  // mask off 14/15 to make it into kernel-space
 
-			setPC(b->readWord(vector + 0, d_space));
+			setPC(b->read_word(vector + 0, d_space));
 
 			// switch to kernel mode & update 'previous mode'
-			uint16_t new_psw = b->readWord(vector + 2, d_space) & 0147777;  // mask off old 'previous mode'
+			uint16_t new_psw = b->read_word(vector + 2, d_space) & 0147777;  // mask off old 'previous mode'
 			if (new_ipl != -1)
 				new_psw = (new_psw & ~0xe0) | (new_ipl << 5);
 			new_psw |= (before_psw >> 2) & 030000; // apply new 'previous mode'
@@ -2371,7 +2371,7 @@ void cpu::step()
 		if (!b->getMMU()->isMMR1Locked())
 			b->getMMU()->setMMR2(instruction_start);
 
-		uint16_t instr = b->readWord(instruction_start);
+		uint16_t instr = b->read_word(instruction_start);
 
 		addRegister(7, rm_cur, 2);
 
diff --git a/debugger.cpp b/debugger.cpp
index 3fc9be2..ba3cd07 100644
--- a/debugger.cpp
+++ b/debugger.cpp
@@ -724,7 +724,7 @@ void debugger(console *const cnsl, bus *const b, std::atomic_uint32_t *const sto
 					uint16_t a = std::stoi(a_it->second, nullptr, 8);
 					uint8_t  v = std::stoi(v_it->second, nullptr, 8);
 
-					c->getBus()->writeByte(a, v);
+					c->getBus()->write_byte(a, v);
 
 					cnsl->put_string_lf(format("Set %06o to %03o", a, v));
 				}
diff --git a/device.h b/device.h
index 96638a3..ebaa506 100644
--- a/device.h
+++ b/device.h
@@ -12,9 +12,9 @@ public:
 
 	virtual void reset() = 0;
 
-        virtual uint8_t  readByte(const uint16_t addr) = 0;
-        virtual uint16_t readWord(const uint16_t addr) = 0;
+        virtual uint8_t  read_byte(const uint16_t addr) = 0;
+        virtual uint16_t read_word(const uint16_t addr) = 0;
 
-        virtual void writeByte(const uint16_t addr, const uint8_t  v) = 0;
-        virtual void writeWord(const uint16_t addr, const uint16_t v) = 0;
+        virtual void write_byte(const uint16_t addr, const uint8_t  v) = 0;
+        virtual void write_word(const uint16_t addr, const uint16_t v) = 0;
 };
diff --git a/kw11-l.cpp b/kw11-l.cpp
index 350afc3..978853f 100644
--- a/kw11-l.cpp
+++ b/kw11-l.cpp
@@ -86,10 +86,10 @@ void kw11_l::operator()()
 	DOLOG(debug, true, "KW11-L thread terminating");
 }
 
-uint16_t kw11_l::readWord(const uint16_t a)
+uint16_t kw11_l::read_word(const uint16_t a)
 {
 	if (a != ADDR_LFC) {
-		DOLOG(debug, true, "KW11-L readWord not for us (%06o)", a);
+		DOLOG(debug, true, "KW11-L read_word not for us (%06o)", a);
 		return 0;
 	}
 
@@ -108,10 +108,10 @@ uint16_t kw11_l::readWord(const uint16_t a)
 	return temp;
 }
 
-void kw11_l::writeWord(const uint16_t a, const uint16_t value)
+void kw11_l::write_word(const uint16_t a, const uint16_t value)
 {
 	if (a != ADDR_LFC) {
-		DOLOG(debug, true, "KW11-L writeWord not for us (%06o to %06o)", value, a);
+		DOLOG(debug, true, "KW11-L write_word not for us (%06o to %06o)", value, a);
 		return;
 	}
 
diff --git a/kw11-l.h b/kw11-l.h
index 32c6bed..8c2f8f7 100644
--- a/kw11-l.h
+++ b/kw11-l.h
@@ -42,6 +42,6 @@ public:
 	void     begin(console *const cnsl);
 	void     operator()();
 
-	uint16_t readWord (const uint16_t a);
-	void     writeWord(const uint16_t a, const uint16_t v);
+	uint16_t read_word (const uint16_t a);
+	void     write_word(const uint16_t a, const uint16_t v);
 };
diff --git a/loaders.cpp b/loaders.cpp
index c2470c1..03891ff 100644
--- a/loaders.cpp
+++ b/loaders.cpp
@@ -23,7 +23,7 @@ void loadbin(bus *const b, uint16_t base, const char *const file)
 	FILE *fh = fopen(file, "rb");
 
 	while(!feof(fh))
-		b->writeByte(base++, fgetc(fh));
+		b->write_byte(base++, fgetc(fh));
 
 	fclose(fh);
 }
@@ -139,7 +139,7 @@ void set_boot_loader(bus *const b, const bootloader_t which)
 	}
 
 	for(int i=0; i<size; i++)
-		b->writeWord(offset + i * 2, bl[i]);
+		b->write_word(offset + i * 2, bl[i]);
 
 	c->setRegister(7, start);
 }
@@ -215,7 +215,7 @@ std::optional<uint16_t> load_tape(bus *const b, const std::string & file)
 #endif
 
 			csum += c;
-			b->writeByte(p++, c);
+			b->write_byte(p++, c);
 		}
 
 #if defined(ESP32)
@@ -259,7 +259,7 @@ void load_p11_x11(bus *const b, const std::string & file)
 		if (n) {
 			uint8_t byte = strtol(buffer, nullptr, 16);
 
-			b->writeByte(addr, byte);
+			b->write_byte(addr, byte);
 
 			n--;
 
diff --git a/mmu.cpp b/mmu.cpp
index b0cf558..ddd376b 100644
--- a/mmu.cpp
+++ b/mmu.cpp
@@ -145,7 +145,7 @@ void mmu::write_par(const uint32_t a, const int run_mode, const uint16_t value,
 	DOLOG(debug, false, "mmu WRITE-I/O PAR run-mode %d: %c for %d: %o (%07o)", run_mode, is_d ? 'D' : 'I', page, word_mode == wm_byte ? value & 0xff : value, pages[run_mode][is_d][page].par * 64);
 }
 
-uint16_t mmu::readWord(const uint16_t a)
+uint16_t mmu::read_word(const uint16_t a)
 {
 	uint16_t v = 0;
 
@@ -165,9 +165,9 @@ uint16_t mmu::readWord(const uint16_t a)
 	return v;
 }
 
-uint8_t mmu::readByte(const uint16_t addr)
+uint8_t mmu::read_byte(const uint16_t addr)
 {
-	uint16_t v = readWord(addr);
+	uint16_t v = read_word(addr);
 
 	if (addr & 1)
 		return v >> 8;
@@ -175,7 +175,7 @@ uint8_t mmu::readByte(const uint16_t addr)
 	return v;
 }
 
-void mmu::writeWord(const uint16_t a, const uint16_t value)
+void mmu::write_word(const uint16_t a, const uint16_t value)
 {
 	// supervisor
 	if (a >= ADDR_PDR_SV_START && a < ADDR_PDR_SV_END)
@@ -194,7 +194,7 @@ void mmu::writeWord(const uint16_t a, const uint16_t value)
 		write_par(a, 3, value, wm_word);
 }
 
-void mmu::writeByte(const uint16_t a, const uint8_t value)
+void mmu::write_byte(const uint16_t a, const uint8_t value)
 {
 	// supervisor
 	if (a >= ADDR_PDR_SV_START && a < ADDR_PDR_SV_END)
diff --git a/mmu.h b/mmu.h
index ee8ba4f..e8edc75 100644
--- a/mmu.h
+++ b/mmu.h
@@ -100,9 +100,9 @@ public:
 	void     write_pdr(const uint32_t a, const int run_mode, const uint16_t value, const word_mode_t word_mode);
 	void     write_par(const uint32_t a, const int run_mode, const uint16_t value, const word_mode_t word_mode);
 
-	uint8_t  readByte(const uint16_t addr) override;
-	uint16_t readWord(const uint16_t addr) override;
+	uint8_t  read_byte(const uint16_t addr) override;
+	uint16_t read_word(const uint16_t addr) override;
 
-	void     writeByte(const uint16_t addr, const uint8_t v) override;
-	void     writeWord(const uint16_t addr, uint16_t v)      override;
+	void     write_byte(const uint16_t addr, const uint8_t v) override;
+	void     write_word(const uint16_t addr, uint16_t v)      override;
 };
diff --git a/rk05.cpp b/rk05.cpp
index f529803..046cc84 100644
--- a/rk05.cpp
+++ b/rk05.cpp
@@ -46,9 +46,9 @@ void rk05::reset()
 	memset(registers, 0x00, sizeof registers);
 }
 
-uint8_t rk05::readByte(const uint16_t addr)
+uint8_t rk05::read_byte(const uint16_t addr)
 {
-	uint16_t v = readWord(addr & ~1);
+	uint16_t v = read_word(addr & ~1);
 
 	if (addr & 1)
 		return v >> 8;
@@ -56,7 +56,7 @@ uint8_t rk05::readByte(const uint16_t addr)
 	return v;
 }
 
-uint16_t rk05::readWord(const uint16_t addr)
+uint16_t rk05::read_word(const uint16_t addr)
 {
 	const int reg = (addr - RK05_BASE) / 2;
 
@@ -102,16 +102,16 @@ void rk05::update_bus_address(const uint16_t v)
 	registers[(RK05_CS - RK05_BASE) / 2] |= ((org_v >> 16) & 3) << 4;
 }
 
-void rk05::writeByte(const uint16_t addr, const uint8_t v)
+void rk05::write_byte(const uint16_t addr, const uint8_t v)
 {
 	uint16_t vtemp = registers[(addr - RK05_BASE) / 2];
 
 	update_word(&vtemp, addr & 1, v);
 
-	writeWord(addr, vtemp);
+	write_word(addr, vtemp);
 }
 
-void rk05::writeWord(const uint16_t addr, const uint16_t v)
+void rk05::write_word(const uint16_t addr, const uint16_t v)
 {
 	const int reg = (addr - RK05_BASE) / 2;
 
diff --git a/rk05.h b/rk05.h
index 5f4f4c4..86ed1d5 100644
--- a/rk05.h
+++ b/rk05.h
@@ -51,9 +51,9 @@ public:
 	static rk05 *deserialize(const json_t *const j, bus *const b);
 #endif
 
-	uint8_t  readByte(const uint16_t addr) override;
-	uint16_t readWord(const uint16_t addr) override;
+	uint8_t  read_byte(const uint16_t addr) override;
+	uint16_t read_word(const uint16_t addr) override;
 
-	void writeByte(const uint16_t addr, const uint8_t  v) override;
-	void writeWord(const uint16_t addr, const uint16_t v) override;
+	void write_byte(const uint16_t addr, const uint8_t  v) override;
+	void write_word(const uint16_t addr, const uint16_t v) override;
 };
diff --git a/rl02.cpp b/rl02.cpp
index 9e9565a..4df351b 100644
--- a/rl02.cpp
+++ b/rl02.cpp
@@ -109,9 +109,9 @@ rl02 *rl02::deserialize(const json_t *const j, bus *const b)
 }
 #endif
 
-uint8_t rl02::readByte(const uint16_t addr)
+uint8_t rl02::read_byte(const uint16_t addr)
 {
-	uint16_t v = readWord(addr & ~1);
+	uint16_t v = read_word(addr & ~1);
 
 	if (addr & 1)
 		return v >> 8;
@@ -119,7 +119,7 @@ uint8_t rl02::readByte(const uint16_t addr)
 	return v;
 }
 
-uint16_t rl02::readWord(const uint16_t addr)
+uint16_t rl02::read_word(const uint16_t addr)
 {
 	const int reg = (addr - RL02_BASE) / 2;
 
@@ -145,7 +145,7 @@ uint16_t rl02::readWord(const uint16_t addr)
 	return value;
 }
 
-void rl02::writeByte(const uint16_t addr, const uint8_t v)
+void rl02::write_byte(const uint16_t addr, const uint8_t v)
 {
 	uint16_t vtemp = registers[(addr - RL02_BASE) / 2];
 
@@ -158,7 +158,7 @@ void rl02::writeByte(const uint16_t addr, const uint8_t v)
 		vtemp |= v;
 	}
 
-	writeWord(addr, vtemp);
+	write_word(addr, vtemp);
 }
 
 uint32_t rl02::get_bus_address() const
@@ -184,7 +184,7 @@ void rl02::update_dar()
 	registers[(RL02_DAR - RL02_BASE) / 2] = (sector & 63) | (head << 6) | (track << 7);
 }
 
-void rl02::writeWord(const uint16_t addr, uint16_t v)
+void rl02::write_word(const uint16_t addr, uint16_t v)
 {
 	const int reg = (addr - RL02_BASE) / 2;
 
diff --git a/rl02.h b/rl02.h
index af46109..0ea1d92 100644
--- a/rl02.h
+++ b/rl02.h
@@ -58,9 +58,9 @@ public:
 	static rl02 *deserialize(const json_t *const j, bus *const b);
 #endif
 
-	uint8_t  readByte(const uint16_t addr) override;
-	uint16_t readWord(const uint16_t addr) override;
+	uint8_t  read_byte(const uint16_t addr) override;
+	uint16_t read_word(const uint16_t addr) override;
 
-	void writeByte(const uint16_t addr, const uint8_t  v) override;
-	void writeWord(const uint16_t addr, const uint16_t v) override;
+	void write_byte(const uint16_t addr, const uint8_t  v) override;
+	void write_word(const uint16_t addr, const uint16_t v) override;
 };
diff --git a/tm-11.cpp b/tm-11.cpp
index 65e95d8..e2c12ff 100644
--- a/tm-11.cpp
+++ b/tm-11.cpp
@@ -33,9 +33,9 @@ void tm_11::reset()
 	offset = 0;
 }
 
-uint8_t tm_11::readByte(const uint16_t addr)
+uint8_t tm_11::read_byte(const uint16_t addr)
 {
-	uint16_t v = readWord(addr & ~1);
+	uint16_t v = read_word(addr & ~1);
 
 	if (addr & 1)
 		return v >> 8;
@@ -43,7 +43,7 @@ uint8_t tm_11::readByte(const uint16_t addr)
 	return v;
 }
 
-uint16_t tm_11::readWord(const uint16_t addr)
+uint16_t tm_11::read_word(const uint16_t addr)
 {
 	const int reg = (addr - TM_11_BASE) / 2;
 	uint16_t vtemp = registers[reg];
@@ -78,7 +78,7 @@ uint16_t tm_11::readWord(const uint16_t addr)
 	return vtemp;
 }
 
-void tm_11::writeByte(const uint16_t addr, const uint8_t v)
+void tm_11::write_byte(const uint16_t addr, const uint8_t v)
 {
 	uint16_t vtemp = registers[(addr - TM_11_BASE) / 2];
 
@@ -91,10 +91,10 @@ void tm_11::writeByte(const uint16_t addr, const uint8_t v)
 		vtemp |= v;
 	}
 
-	writeWord(addr, vtemp);
+	write_word(addr, vtemp);
 }
 
-void tm_11::writeWord(const uint16_t addr, uint16_t v)
+void tm_11::write_word(const uint16_t addr, uint16_t v)
 {
 	DOLOG(debug, false, "TM-11 write %o: %o", addr, v);
 
diff --git a/tm-11.h b/tm-11.h
index 45163c7..b65456a 100644
--- a/tm-11.h
+++ b/tm-11.h
@@ -39,9 +39,9 @@ public:
 
 	void reset() override;
 
-	uint8_t  readByte(const uint16_t addr) override;
-	uint16_t readWord(const uint16_t addr) override;
+	uint8_t  read_byte(const uint16_t addr) override;
+	uint16_t read_word(const uint16_t addr) override;
 
-	void writeByte(const uint16_t addr, const uint8_t v) override;
-	void writeWord(const uint16_t addr, uint16_t v)      override;
+	void write_byte(const uint16_t addr, const uint8_t v) override;
+	void write_word(const uint16_t addr, uint16_t v)      override;
 };
diff --git a/tty.cpp b/tty.cpp
index 57494a1..2c12978 100644
--- a/tty.cpp
+++ b/tty.cpp
@@ -61,9 +61,9 @@ void tty::reset()
 	memset(registers, 0x00, sizeof registers);
 }
 
-uint8_t tty::readByte(const uint16_t addr)
+uint8_t tty::read_byte(const uint16_t addr)
 {
-	uint16_t v = readWord(addr & ~1);
+	uint16_t v = read_word(addr & ~1);
 
 	if (addr & 1)
 		return v >> 8;
@@ -79,7 +79,7 @@ void tty::notify_rx()
 		b->getCpu()->queue_interrupt(4, 060);
 }
 
-uint16_t tty::readWord(const uint16_t addr)
+uint16_t tty::read_word(const uint16_t addr)
 {
 	const int reg    = (addr - PDP11TTY_BASE) / 2;
 	uint16_t  vtemp  = registers[reg];
@@ -155,7 +155,7 @@ void tty::operator()()
 	}
 }
 
-void tty::writeByte(const uint16_t addr, const uint8_t v)
+void tty::write_byte(const uint16_t addr, const uint8_t v)
 {
 	uint16_t vtemp = registers[(addr - PDP11TTY_BASE) / 2];
 	
@@ -168,10 +168,10 @@ void tty::writeByte(const uint16_t addr, const uint8_t v)
 		vtemp |= v;
 	}
 
-	writeWord(addr, vtemp);
+	write_word(addr, vtemp);
 }
 
-void tty::writeWord(const uint16_t addr, uint16_t v)
+void tty::write_word(const uint16_t addr, uint16_t v)
 {
 	const int reg = (addr - PDP11TTY_BASE) / 2;
 
diff --git a/tty.h b/tty.h
index 6702889..98a9769 100644
--- a/tty.h
+++ b/tty.h
@@ -58,11 +58,11 @@ public:
 
 	void reset();
 
-	uint8_t readByte(const uint16_t addr);
-	uint16_t readWord(const uint16_t addr);
+	uint8_t read_byte(const uint16_t addr);
+	uint16_t read_word(const uint16_t addr);
 
-	void writeByte(const uint16_t addr, const uint8_t v);
-	void writeWord(const uint16_t addr, uint16_t v);
+	void write_byte(const uint16_t addr, const uint8_t v);
+	void write_word(const uint16_t addr, uint16_t v);
 
 	void operator()();
 };