diff --git a/ws2012/P2P/uebungen/4/src/node/Node.java b/ws2012/P2P/uebungen/4/src/node/Node.java
index 6a664bff..a1c8df58 100644
--- a/ws2012/P2P/uebungen/4/src/node/Node.java
+++ b/ws2012/P2P/uebungen/4/src/node/Node.java
@@ -20,7 +20,6 @@ public class Node {
     private static final int BUF_SIZE = 512;
 
     private DatagramChannel channel;
-    private ByteBuffer buf;
 
     private String name = "Not initialized";
 
@@ -42,8 +41,6 @@ public class Node {
             channel.socket().bind(new InetSocketAddress("localhost", 0));
             channel.configureBlocking(false);
 
-            buf = ByteBuffer.allocate(BUF_SIZE);
-
             this.name = channel.socket().getLocalSocketAddress().toString();
 
             udpListen = new UDPListen();
@@ -66,13 +63,13 @@ public class Node {
         // LOGGER.info("Name: " + getName() + ", Spawning new node.");
         Node newNode = new Node();
         
-        Send_Invite(newNode);
+        sendInvite(newNode);
         neighbors.add(newNode.getAddress());
 
         return newNode;
     }
 
-    public boolean Send_Invite(Node newNode){
+    public boolean sendInvite(Node newNode){
         ByteBuffer buffer = ByteBuffer.allocate(BUF_SIZE);
         int ack_id = generateAck(newNode.getAddress());
         buffer.put(MessageType.INVITE);
@@ -104,7 +101,7 @@ public class Node {
     public SocketAddress getAddress() {
         return channel.socket().getLocalSocketAddress();}
 
-    public boolean Send_NewNeighbor(SocketAddress receiver, SocketAddress neighbor){
+    public boolean sendNewNeighbor(SocketAddress receiver, SocketAddress neighbor){
         ByteBuffer buffer = ByteBuffer.allocate(BUF_SIZE);
         int ack_id = generateAck(neighbor);
         buffer.put(MessageType.NEW_NEIGHBOR);
@@ -133,7 +130,7 @@ public class Node {
      * @param ack_id
      *            the id to identify the ack
      */
-    private boolean Send_Ack(SocketAddress receiver, int ack_id) {
+    private boolean sendAck(SocketAddress receiver, int ack_id) {
         ByteBuffer buffer = ByteBuffer.allocate(BUF_SIZE);
         buffer.put(MessageType.ACK);
         buffer.putInt(ack_id);
@@ -147,7 +144,7 @@ public class Node {
         return true;
     }
 
-    private boolean Send_Leave(SocketAddress neighbor){
+    private boolean sendLeave(SocketAddress neighbor){
         ByteBuffer buffer = ByteBuffer.allocate(BUF_SIZE);
         int ack_id = generateAck(neighbor);
         buffer.put(MessageType.LEAVE);
@@ -173,13 +170,13 @@ public class Node {
             if (neighbors.size() > 2) {
                     int pred = ((i - 1) + neighbors.size()) % neighbors.size();
                     int succ = (i + 1) % neighbors.size();
-                    Send_NewNeighbor(neighbors.get(i), neighbors.get(succ));
-                    Send_NewNeighbor(neighbors.get(i), neighbors.get(pred));
+                    sendNewNeighbor(neighbors.get(i), neighbors.get(succ));
+                    sendNewNeighbor(neighbors.get(i), neighbors.get(pred));
             } else if (neighbors.size() == 2) {
-                    Send_NewNeighbor(neighbors.get(i), neighbors.get(Math.abs(i - 1)));
+                    sendNewNeighbor(neighbors.get(i), neighbors.get(Math.abs(i - 1)));
             }
 
-            Send_Leave(neighbors.get(i));
+            sendLeave(neighbors.get(i));
         }
 
         try {
@@ -221,35 +218,36 @@ public class Node {
 
     private class UDPListen implements Runnable {
         private volatile boolean running = true;
+		private ByteBuffer buf = ByteBuffer.allocate(BUF_SIZE);
 
-        private void Receive_Invite(SocketAddress from){
+        private void receiveInvite(SocketAddress from){
             LOGGER.log(Level.INFO, "{0} received invite from {1}", new Object[]{name, from.toString()});
             int ack_id = buf.getInt();
-            Send_Ack(from, ack_id);
+            sendAck(from, ack_id);
             neighbors.add(from);
         }
 
-        private void Receive_Ack(SocketAddress from){
+        private void receiveAck(SocketAddress from){
             LOGGER.log(Level.INFO, "{0} received ack from {1}", new Object[]{name, from.toString()});
             int ack_id = buf.getInt();
             if (!checkAck(from, ack_id)) {
                 LOGGER.log(Level.WARNING, "Received unexpected ack from: {0}", from.toString());}
         }
 
-        private void Receive_Leave(SocketAddress from){
+        private void receiveLeave(SocketAddress from){
             LOGGER.log(Level.INFO, "{0}: {1} is leaving. Deleting...", new Object[]{name, from.toString()});
 
             int idToRemove = getNeighborId(from);
             if (idToRemove != -1) {
                     neighbors.remove(idToRemove);
                     int ack_id = buf.getInt();
-                    Send_Ack(from, ack_id);
+                    sendAck(from, ack_id);
             }
             // If we don't know that neighbor, we don't have to
             // ack
         }
 
-        private void Receive_NewNeighbor(SocketAddress from){
+        private void receiveNewNeighbor(SocketAddress from){
             int ack_id = buf.getInt();
             StringBuilder theAddr = new StringBuilder();
 
@@ -261,17 +259,17 @@ public class Node {
             }
             int port = buf.getInt();
 
-            InetSocketAddress new_neighbor = new InetSocketAddress(theAddr.toString(), port);
+            InetSocketAddress newNeighbor = new InetSocketAddress(theAddr.toString(), port);
 
-            if (!hasNeighbor(new_neighbor)) {
+            if (!hasNeighbor(newNeighbor)) {
                 // Add this neighbor to my neighbor list if it
                 // was not present before
-                neighbors.add(new_neighbor);
+                neighbors.add(newNeighbor);
 
-                LOGGER.log(Level.INFO, "{0} from {1} received new neighbor:{2}", new Object[]{name, from.toString(), new_neighbor.toString()});
+                LOGGER.log(Level.INFO, "{0} from {1} received new neighbor:{2}", new Object[]{name, from.toString(), newNeighbor.toString()});
             }
 
-            Send_Ack(from, ack_id);
+            sendAck(from, ack_id);
         }
 
         public void run() {
@@ -290,16 +288,16 @@ public class Node {
 
                         switch (messageType) {
                         case MessageType.INVITE:
-                            Receive_Invite(receivedFrom);
+                            receiveInvite(receivedFrom);
                             break;
                         case MessageType.ACK:
-                            Receive_Ack(receivedFrom);
+                            receiveAck(receivedFrom);
                             break;
                         case MessageType.LEAVE:
-                            Receive_Leave(receivedFrom);
+                            receiveLeave(receivedFrom);
                             break;
                         case MessageType.NEW_NEIGHBOR:
-                            Receive_NewNeighbor(receivedFrom);
+                            receiveNewNeighbor(receivedFrom);
                             break;                                                        
                         default:
                             LOGGER.log(Level.INFO, "{0} received unknown command from {1}: [{2}]{3}", new Object[]{name, receivedFrom.toString(), messageType, new String(buf.array())});