diff --git a/src/server.py b/src/server.py
--- a/src/server.py
+++ b/src/server.py
@@ -3,7 +3,7 @@ import ssl
 import multiprocessing
 import logging as log
 
-from hashtree import hashBlock
+from hashtree import hash_block
 from netnode import BaseConnection,NetNode
 import config as conf
 import status
@@ -11,25 +11,25 @@ from datafile import DataFile
 
 
 class Connection(BaseConnection):
-	def __init__(self, serverSocket, sslContext):
+	def __init__(self, server_socket, ssl_context):
 		super().__init__()
 
-		sock, address = serverSocket.accept()
+		sock, address = server_socket.accept()
 		peer = sock.getpeername()
 		try:
-			self._socket = sslContext.wrap_socket(sock, server_side=True)
+			self._socket = ssl_context.wrap_socket(sock, server_side=True)
 		except (ssl.SSLError,OSError) as e:
 			log.warning("Failed to establish an SSL connection from {0}.".format(peer))
 			raise e
 
 		log.info('Connected by {0}'.format(address))
-		self.createNetworkers()
+		self.create_networkers()
 
 
 class Miniserver:
-	def __init__(self, filename, treeFile=""):
+	def __init__(self, filename, tree_file=""):
 		self._filename = filename
-		self._treeFile = treeFile
+		self._tree_file = tree_file
 
 		self._ssl = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH, cafile=conf.peers)
 		self._ssl.verify_mode = ssl.CERT_REQUIRED
@@ -47,111 +47,111 @@ class Miniserver:
 				except (ssl.SSLError, OSError): continue
 				if p and p.is_alive():
 					with connection as c:
-						c[0].readMsg()
-						c[1].writeMsg({"command":"deny", "status":status.locked})
+						c[0].read_msg()
+						c[1].write_msg({"command": "deny", "status":status.locked})
 					continue
-				p = multiprocessing.Process(target=Server.run, args=(connection, self._filename, self._treeFile))
+				p = multiprocessing.Process(target=Server.run, args=(connection, self._filename, self._tree_file))
 				p.start()
 
 
 class Server(NetNode):
-	def __init__(self, connection, filename, treeFile=""):
-		super().__init__(filename, treeFile)
+	def __init__(self, connection, filename, tree_file=""):
+		super().__init__(filename, tree_file)
 		(self._incoming, self._outcoming) = connection
 
 		self.BLOCK_SIZE = self._tree.BLOCK_SIZE
 
-		self._dataFileObj = None
+		self._data_file_obj = None
 
 	@staticmethod
 	def run(connection, *args):
 		with connection as c:
-			s = Server(c,*args)
+			s = Server(c, *args)
 			s.serve()
 
 	@property
-	def _dataFile(self):
-		if not self._dataFileObj:
-			self._dataFileObj = DataFile.open(self._filename, mode="rb+")
-		return self._dataFileObj
+	def _data_file(self):
+		if not self._data_file_obj:
+			self._data_file_obj = DataFile.open(self._filename, mode="rb+")
+		return self._data_file_obj
 
 	def serve(self):
 		try:
-			while self._serveOne(): pass
+			while self._serve_one(): pass
 		except (AssertionError, ConnectionResetError) as e:
 			log.warning(e)
 
-	def _serveOne(self):
-		jsonData, binData = self._incoming.readMsg()
+	def _serve_one(self):
+		json_data, bin_data = self._incoming.read_msg()
 
-		if jsonData["command"]=="init":
-			if jsonData["blockSize"]!=self.BLOCK_SIZE or jsonData["blockCount"]!=self._tree.leafCount:
-				self._outcoming.writeMsg({"command":"deny", "status":status.incompatible.parameters})
-			if jsonData["version"]<conf.lowestCompatible:
-				self._outcoming.writeMsg({"command":"deny", "status":status.incompatible.version})
-			if jsonData["action"]=="pull" and self.isLocked():
-				self._outcoming.writeMsg({"command":"deny", "status":status.locked})
-			if jsonData["action"]=="push" and not self.isLocked():
+		if json_data["command"]=="init":
+			if json_data["blockSize"]!=self.BLOCK_SIZE or json_data["blockCount"]!=self._tree.leaf_count:
+				self._outcoming.write_msg({"command": "deny", "status": status.incompatible.parameters})
+			if json_data["version"]<conf.lowest_compatible:
+				self._outcoming.write_msg({"command": "deny", "status": status.incompatible.version})
+			if json_data["action"]=="pull" and self.is_locked():
+				self._outcoming.write_msg({"command": "deny", "status": status.locked})
+			if json_data["action"]=="push" and not self.is_locked():
 				self._lock()
 
-			self._outcoming.writeMsg({"command":"init", "version":conf.version})
+			self._outcoming.write_msg({"command": "init", "version": conf.version})
 
-		elif jsonData["command"]=="req":
-			if jsonData["dataType"]=="data":
-				self._outcoming.writeMsg(*self._requestData(jsonData["index"]))
+		elif json_data["command"]=="req":
+			if json_data["dataType"]=="data":
+				self._outcoming.write_msg(*self._request_data(json_data["index"]))
 			else:
-				self._outcoming.writeMsg(*self._requestHash(jsonData["index"]))
+				self._outcoming.write_msg(*self._request_hash(json_data["index"]))
 
-		elif jsonData["command"]=="send" and jsonData["dataType"]=="data":
-			self._outcoming.writeMsg(*self._receiveData(jsonData, binData))
+		elif json_data["command"]=="send" and json_data["dataType"]=="data":
+			self._outcoming.write_msg(*self._receive_data(json_data, bin_data))
 
-		elif jsonData["command"]=="end":
+		elif json_data["command"]=="end":
 			self._finalize()
-			if jsonData.get("action")=="push": self._unlock()
+			if json_data.get("action")=="push": self._unlock()
 			return False
 
 		else:
-			assert False, jsonData["command"]
+			assert False, json_data["command"]
 
 		return True
 
-	def _requestHash(self, indices):
+	def _request_hash(self, indices):
 		log.info("received request for nodes {0}".format(indices))
 		assert all(i<len(self._tree.store) for i in indices)
 		hashes = [self._tree.store[i] for i in indices]
 
-		jsonResponse = {"command":"send", "index":indices, "dataType":"hash"}
-		binResponse = b"".join(hashes)
+		json_response = {"command": "send", "index": indices, "dataType": "hash"}
+		bin_response = b"".join(hashes)
 
-		return (jsonResponse, binResponse)
+		return (json_response, bin_response)
 
-	def _requestData(self, index):
+	def _request_data(self, index):
 		log.info("received request for data blocks {0}".format(index))
 
-		jsonResponse = {"command":"send", "index":index, "dataType":"data"}
+		json_response = {"command": "send", "index": index, "dataType": "data"}
 		blocks = []
 		for i in index:
-			blocks.append(self._dataFile.readFrom(i))
+			blocks.append(self._data_file.read_from(i))
 
-		return (jsonResponse, b"".join(blocks))
+		return (json_response, b"".join(blocks))
 
-	def _receiveData(self, jsonData, binData):
-		if not self.isLocked(): self._lock()
-		log.info("received data blocks {0}: {1}...{2}".format(jsonData["index"], binData[:5], binData[-5:]))
+	def _receive_data(self, json_data, bin_data):
+		if not self.is_locked(): self._lock()
+		log.info("received data blocks {0}: {1}...{2}".format(json_data["index"], bin_data[:5], bin_data[-5:]))
 
-		indices = jsonData["index"]
+		indices = json_data["index"]
 		for (i, k) in enumerate(indices):
-			block = binData[i*self.BLOCK_SIZE:(i+1)*self.BLOCK_SIZE]
-			self._dataFile.writeAt(k, block)
-			if self._treeFile:
-				self._newLeaves[k+self._tree.leafStart] = hashBlock(block)
+			block = bin_data[i*self.BLOCK_SIZE:(i+1)*self.BLOCK_SIZE]
+			self._data_file.write_at(k, block)
+			if self._tree_file:
+				self._new_leaves[k+self._tree.leaf_start] = hash_block(block)
 
 		return ({"command": "ack", "index": indices},)
 
 	def _finalize(self):
 		log.info("closing session...")
-		self._dataFile.close()
-		self._dataFileObj = None
-		if self._treeFile:
-			self._updateTree()
+		self._data_file.close()
+		self._data_file_obj = None
+		if self._tree_file:
+			self._update_tree()
 		log.info("done")