diff --git a/samples/main-packet.cc b/samples/main-packet.cc
index 3c70556c4..f3b4540bf 100644
--- a/samples/main-packet.cc
+++ b/samples/main-packet.cc
@@ -69,7 +69,7 @@ MyChunk::get_data (void) const
 /* A sample Tag implementation
  */
 struct MyTag {
-	uint16_t m_stream_id;
+	uint16_t m_streamId;
 };
 
 
@@ -93,7 +93,7 @@ int main (int argc, char *argv[])
 	std::cout << "send data=2" << std::endl;
 	p.add (&my);
 	struct MyTag my_tag;
-	my_tag.m_stream_id = 5;
+	my_tag.m_streamId = 5;
 	p.add_tag (&my_tag);
 	receive (p);
 	return 0;
diff --git a/src/common/buffer.cc b/src/common/buffer.cc
index abe9ef989..364351db7 100644
--- a/src/common/buffer.cc
+++ b/src/common/buffer.cc
@@ -27,9 +27,9 @@
 
 namespace ns3 {
 
-Buffer::BufferDataList  Buffer::m_free_list;
-uint32_t Buffer::m_max_total_add_start = 0;
-uint32_t Buffer::m_max_total_add_end = 0;
+Buffer::BufferDataList  Buffer::m_freeList;
+uint32_t Buffer::m_maxTotalAddStart = 0;
+uint32_t Buffer::m_maxTotalAddEnd = 0;
 
 struct Buffer::BufferData *
 Buffer::allocate (uint32_t req_size, uint32_t req_start)
@@ -42,9 +42,9 @@ Buffer::allocate (uint32_t req_size, uint32_t req_start)
 	uint8_t *b = new uint8_t [size];
 	struct BufferData *data = reinterpret_cast<struct Buffer::BufferData*>(b);
 	data->m_size = req_size;
-	data->m_initial_start = req_start;
-	data->m_dirty_start = req_start;
-	data->m_dirty_size = 0;
+	data->m_initialStart = req_start;
+	data->m_dirtyStart = req_start;
+	data->m_dirtySize = 0;
 	data->m_count = 1;
 	return data;
 }
@@ -61,15 +61,15 @@ Buffer::recycle (struct Buffer::BufferData *data)
 {
 	assert (data->m_count == 0);
 	/* get rid of it if it is too small for later reuse. */
-	if (data->m_size < (Buffer::m_max_total_add_start + Buffer::m_max_total_add_end)) {
+	if (data->m_size < (Buffer::m_maxTotalAddStart + Buffer::m_maxTotalAddEnd)) {
 		Buffer::deallocate (data);
 		return; 
 	}
 	/* feed into free list */
-	if (Buffer::m_free_list.size () > 1000) {
+	if (Buffer::m_freeList.size () > 1000) {
 		Buffer::deallocate (data);
 	} else {
-		Buffer::m_free_list.push_back (data);
+		Buffer::m_freeList.push_back (data);
 	}
 }
 
@@ -77,20 +77,20 @@ Buffer::BufferData *
 Buffer::create (void)
 {
 	/* try to find a buffer correctly sized. */
-	while (!Buffer::m_free_list.empty ()) {
-		struct Buffer::BufferData *data = Buffer::m_free_list.back ();
-		Buffer::m_free_list.pop_back ();
-		if (data->m_size >= (m_max_total_add_start + m_max_total_add_end)) {
-			data->m_initial_start = m_max_total_add_start;
-			data->m_dirty_start = m_max_total_add_start;
-			data->m_dirty_size = 0;
+	while (!Buffer::m_freeList.empty ()) {
+		struct Buffer::BufferData *data = Buffer::m_freeList.back ();
+		Buffer::m_freeList.pop_back ();
+		if (data->m_size >= (m_maxTotalAddStart + m_maxTotalAddEnd)) {
+			data->m_initialStart = m_maxTotalAddStart;
+			data->m_dirtyStart = m_maxTotalAddStart;
+			data->m_dirtySize = 0;
 			data->m_count = 1;
 			return data;
 		}
 		Buffer::deallocate (data);
 	}
-	struct Buffer::BufferData *data = Buffer::allocate (m_max_total_add_start+m_max_total_add_end,
-							    m_max_total_add_start);
+	struct Buffer::BufferData *data = Buffer::allocate (m_maxTotalAddStart+m_maxTotalAddEnd,
+							    m_maxTotalAddStart);
 	assert (data->m_count == 1);
 	return data;
 }
@@ -104,8 +104,8 @@ Buffer::recycle (struct Buffer::BufferData *data)
 Buffer::BufferData *
 Buffer::create (void)
 {
-	return Buffer::allocate (m_max_total_add_start+m_max_total_add_end,
-				 m_max_total_add_start);
+	return Buffer::allocate (m_maxTotalAddStart+m_maxTotalAddEnd,
+				 m_maxTotalAddStart);
 }
 #endif
 
@@ -120,8 +120,8 @@ namespace ns3 {
 void 
 Buffer::add_at_start (uint32_t start)
 {
-	assert (m_start <= m_data->m_initial_start);
-	bool is_dirty = m_data->m_count > 1 && m_start > m_data->m_dirty_start;
+	assert (m_start <= m_data->m_initialStart);
+	bool is_dirty = m_data->m_count > 1 && m_start > m_data->m_dirtyStart;
 	if (m_start >= start && !is_dirty) {
 		/* enough space in the buffer and not dirty. */
 		m_start -= start;
@@ -130,7 +130,7 @@ Buffer::add_at_start (uint32_t start)
 		/* enough space but need to move data around to fit new data */
                 memmove (m_data->m_data + start, get_start (), m_size);
 		assert (start > m_start);
-		m_data->m_initial_start += start;
+		m_data->m_initialStart += start;
                 m_start = 0;
                 m_size += start;
 	} else if (m_start < start) {
@@ -138,7 +138,7 @@ Buffer::add_at_start (uint32_t start)
 		uint32_t new_size = m_size + start;
 		struct Buffer::BufferData *new_data = Buffer::allocate (new_size, 0);
 		memcpy (new_data->m_data + start, get_start (), m_size);
-		new_data->m_initial_start = m_data->m_initial_start + start;
+		new_data->m_initialStart = m_data->m_initialStart + start;
 		m_data->m_count--;
 		if (m_data->m_count == 0) {
 			Buffer::deallocate (m_data);
@@ -151,7 +151,7 @@ Buffer::add_at_start (uint32_t start)
 		assert (is_dirty);
 		struct Buffer::BufferData *new_data = Buffer::create ();
 		memcpy (new_data->m_data + m_start, get_start (), m_size);
-		new_data->m_initial_start = m_data->m_initial_start;
+		new_data->m_initialStart = m_data->m_initialStart;
 		m_data->m_count--;
 		if (m_data->m_count == 0) {
 			recycle (m_data);
@@ -161,28 +161,28 @@ Buffer::add_at_start (uint32_t start)
 		m_size += start;
 	} 
 	// update dirty area
-	m_data->m_dirty_start = m_start;
-	m_data->m_dirty_size = m_size;
-	// update m_max_total_add_start
+	m_data->m_dirtyStart = m_start;
+	m_data->m_dirtySize = m_size;
+	// update m_maxTotalAddStart
 	uint32_t added_at_start;
-	if (m_data->m_initial_start > m_start) {
-		added_at_start = m_data->m_initial_start - m_start;
+	if (m_data->m_initialStart > m_start) {
+		added_at_start = m_data->m_initialStart - m_start;
 	} else {
 		added_at_start = 0;
 	}
-	if (added_at_start > m_max_total_add_start) {
-		m_max_total_add_start = added_at_start;
+	if (added_at_start > m_maxTotalAddStart) {
+		m_maxTotalAddStart = added_at_start;
 	}
-	TRACE ("start add="<<start<<", start="<<m_start<<", size="<<m_size<<", zero="<<m_zero_area_size<<
-	       ", real size="<<m_data->m_size<<", ini start="<<m_data->m_initial_start<<
-	       ", dirty start="<<m_data->m_dirty_start<<", dirty size="<<m_data->m_dirty_size); 
+	TRACE ("start add="<<start<<", start="<<m_start<<", size="<<m_size<<", zero="<<m_zeroAreaSize<<
+	       ", real size="<<m_data->m_size<<", ini start="<<m_data->m_initialStart<<
+	       ", dirty start="<<m_data->m_dirtyStart<<", dirty size="<<m_data->m_dirtySize); 
 }
 void 
 Buffer::add_at_end (uint32_t end)
 {
-	assert (m_start <= m_data->m_initial_start);
+	assert (m_start <= m_data->m_initialStart);
 	bool is_dirty = m_data->m_count > 1 &&
-		m_start + m_size < m_data->m_dirty_start + m_data->m_dirty_size;
+		m_start + m_size < m_data->m_dirtyStart + m_data->m_dirtySize;
 	if (m_start + m_size + end <= m_data->m_size && !is_dirty) {
 		/* enough space in buffer and not dirty */
 		m_size += end;
@@ -191,7 +191,7 @@ Buffer::add_at_end (uint32_t end)
                 uint32_t new_start = m_data->m_size - (m_size + end);
                 memmove (m_data->m_data + new_start, get_start (), m_size);
 		assert (new_start < m_start);
-		m_data->m_initial_start -= m_start - new_start;
+		m_data->m_initialStart -= m_start - new_start;
                 m_start = new_start;
                 m_size += end;
 	} else if (m_start + m_size + end > m_data->m_size) {
@@ -199,7 +199,7 @@ Buffer::add_at_end (uint32_t end)
 		uint32_t new_size = m_size + end;
 		struct Buffer::BufferData *new_data = Buffer::allocate (new_size, 0);
 		memcpy (new_data->m_data, get_start (), m_size);
-		new_data->m_initial_start = m_data->m_initial_start;
+		new_data->m_initialStart = m_data->m_initialStart;
 		m_data->m_count--;
 		if (m_data->m_count == 0) {
 			Buffer::deallocate (m_data);
@@ -212,7 +212,7 @@ Buffer::add_at_end (uint32_t end)
 		assert (is_dirty);
 		struct Buffer::BufferData *new_data = Buffer::create ();
 		memcpy (new_data->m_data + m_start, get_start (), m_size);
-		new_data->m_initial_start = m_data->m_initial_start;
+		new_data->m_initialStart = m_data->m_initialStart;
 		m_data->m_count--;
 		if (m_data->m_count == 0) {
 			recycle (m_data);
@@ -221,28 +221,28 @@ Buffer::add_at_end (uint32_t end)
 		m_size += end;
 	} 
 	// update dirty area
-	m_data->m_dirty_start = m_start;
-	m_data->m_dirty_size = m_size;
-	// update m_max_total_add_end
+	m_data->m_dirtyStart = m_start;
+	m_data->m_dirtySize = m_size;
+	// update m_maxTotalAddEnd
 	uint32_t end_loc = m_start + m_size;
 	uint32_t added_at_end;
-	if (m_data->m_initial_start < end_loc) {
-		added_at_end = end_loc - m_data->m_initial_start;
+	if (m_data->m_initialStart < end_loc) {
+		added_at_end = end_loc - m_data->m_initialStart;
 	} else {
 		added_at_end = 0;
 	}
-	if (added_at_end > m_max_total_add_end) {
-		m_max_total_add_end = added_at_end;
+	if (added_at_end > m_maxTotalAddEnd) {
+		m_maxTotalAddEnd = added_at_end;
 	}
-	TRACE ("end add="<<end<<", start="<<m_start<<", size="<<m_size<<", zero="<<m_zero_area_size<<
-	       ", real size="<<m_data->m_size<<", ini start="<<m_data->m_initial_start<<
-	       ", dirty start="<<m_data->m_dirty_start<<", dirty size="<<m_data->m_dirty_size); 
+	TRACE ("end add="<<end<<", start="<<m_start<<", size="<<m_size<<", zero="<<m_zeroAreaSize<<
+	       ", real size="<<m_data->m_size<<", ini start="<<m_data->m_initialStart<<
+	       ", dirty start="<<m_data->m_dirtyStart<<", dirty size="<<m_data->m_dirtySize); 
 }
 
 void 
 Buffer::remove_at_start (uint32_t start)
 {
-	if (m_zero_area_size == 0) {
+	if (m_zeroAreaSize == 0) {
 		if (m_size <= start) {
 			m_start += m_size;
 			m_size = 0;
@@ -251,10 +251,10 @@ Buffer::remove_at_start (uint32_t start)
 			m_size -= start;
 		}
 	} else {
-		assert (m_data->m_initial_start >= m_start);
-		uint32_t zero_start = m_data->m_initial_start - m_start;
-		uint32_t zero_end = zero_start + m_zero_area_size;
-		uint32_t data_end = m_size + m_zero_area_size;
+		assert (m_data->m_initialStart >= m_start);
+		uint32_t zero_start = m_data->m_initialStart - m_start;
+		uint32_t zero_end = zero_start + m_zeroAreaSize;
+		uint32_t data_end = m_size + m_zeroAreaSize;
 		if (start <= zero_start) {
 			/* only remove start of buffer */
 			m_start += start;
@@ -263,76 +263,76 @@ Buffer::remove_at_start (uint32_t start)
 			/* remove start of buffer _and_ start of zero area */
 			m_start += zero_start;
 			uint32_t zero_delta = start - zero_start;
-			m_zero_area_size -= zero_delta;
+			m_zeroAreaSize -= zero_delta;
 			assert (zero_delta <= start);
 			m_size -= zero_start;
 		} else if (start <= data_end) {
 			/* remove start of buffer, complete zero area, and part
 			 * of end of buffer */
-			m_start += start - m_zero_area_size;
-			m_size -= start - m_zero_area_size;
-			m_zero_area_size = 0;
+			m_start += start - m_zeroAreaSize;
+			m_size -= start - m_zeroAreaSize;
+			m_zeroAreaSize = 0;
 		} else {
 			/* remove all buffer */
 			m_start += m_size;
 			m_size = 0;
-			m_zero_area_size = 0;
+			m_zeroAreaSize = 0;
 		}
 	}
-	TRACE ("start remove="<<start<<", start="<<m_start<<", size="<<m_size<<", zero="<<m_zero_area_size<<
-	       ", real size="<<m_data->m_size<<", ini start="<<m_data->m_initial_start<<
-	       ", dirty start="<<m_data->m_dirty_start<<", dirty size="<<m_data->m_dirty_size); 
+	TRACE ("start remove="<<start<<", start="<<m_start<<", size="<<m_size<<", zero="<<m_zeroAreaSize<<
+	       ", real size="<<m_data->m_size<<", ini start="<<m_data->m_initialStart<<
+	       ", dirty start="<<m_data->m_dirtyStart<<", dirty size="<<m_data->m_dirtySize); 
 }
 void 
 Buffer::remove_at_end (uint32_t end)
 {
-	if (m_zero_area_size == 0) {
+	if (m_zeroAreaSize == 0) {
 		if (m_size <= end) {
 			m_size = 0;
 		} else {
 			m_size -= end;
 		} 
 	} else {
-		assert (m_data->m_initial_start >= m_start);
-		uint32_t zero_start = m_data->m_initial_start - m_start;
-		uint32_t zero_end = zero_start + m_zero_area_size;
-		uint32_t data_end = m_size + m_zero_area_size;
+		assert (m_data->m_initialStart >= m_start);
+		uint32_t zero_start = m_data->m_initialStart - m_start;
+		uint32_t zero_end = zero_start + m_zeroAreaSize;
+		uint32_t data_end = m_size + m_zeroAreaSize;
 		assert (zero_start <= m_size);
-		assert (zero_end <= m_size + m_zero_area_size);
+		assert (zero_end <= m_size + m_zeroAreaSize);
 		if (data_end <= end) {
 			/* remove all buffer */
-			m_zero_area_size = 0;
+			m_zeroAreaSize = 0;
 			m_start += m_size;
 			m_size = 0;
 		} else if (data_end - zero_start <= end) {
 			/* remove end of buffer, zero area, part of start of buffer */
-			assert (end >= m_zero_area_size);
-			m_size -= end - m_zero_area_size;
-			m_zero_area_size = 0;
+			assert (end >= m_zeroAreaSize);
+			m_size -= end - m_zeroAreaSize;
+			m_zeroAreaSize = 0;
 		} else if (data_end - zero_end <= end) {
 			/* remove end of buffer, part of zero area */
 			uint32_t zero_delta = end - (data_end - zero_end);
-			m_zero_area_size -= zero_delta;
+			m_zeroAreaSize -= zero_delta;
 			m_size -= end - zero_delta;
 		} else {
 			/* remove part of end of buffer */
 			m_size -= end;
 		}
 	}
-	TRACE ("end remove="<<end<<", start="<<m_start<<", size="<<m_size<<", zero="<<m_zero_area_size<<
-	       ", real size="<<m_data->m_size<<", ini start="<<m_data->m_initial_start<<
-	       ", dirty start="<<m_data->m_dirty_start<<", dirty size="<<m_data->m_dirty_size); 
+	TRACE ("end remove="<<end<<", start="<<m_start<<", size="<<m_size<<", zero="<<m_zeroAreaSize<<
+	       ", real size="<<m_data->m_size<<", ini start="<<m_data->m_initialStart<<
+	       ", dirty start="<<m_data->m_dirtyStart<<", dirty size="<<m_data->m_dirtySize); 
 }
 
 Buffer 
 Buffer::create_fragment (uint32_t start, uint32_t length) const
 {
-	uint32_t zero_start = m_data->m_initial_start - m_start;
-	uint32_t zero_end = zero_start + m_zero_area_size;
-	if (m_zero_area_size != 0 &&
+	uint32_t zero_start = m_data->m_initialStart - m_start;
+	uint32_t zero_end = zero_start + m_zeroAreaSize;
+	if (m_zeroAreaSize != 0 &&
 	    start + length > zero_start &&
 	    start <= zero_end) {
-		transform_into_real_buffer ();
+		transform_intoRealBuffer ();
 	}
 	Buffer tmp = *this;
 	tmp.remove_at_start (start);
@@ -341,22 +341,22 @@ Buffer::create_fragment (uint32_t start, uint32_t length) const
 }
 
 void
-Buffer::transform_into_real_buffer (void) const
+Buffer::transform_intoRealBuffer (void) const
 {
-	if (m_zero_area_size != 0) {
-		assert (m_data->m_initial_start >= m_start);
-		assert (m_size >= (m_data->m_initial_start - m_start));
+	if (m_zeroAreaSize != 0) {
+		assert (m_data->m_initialStart >= m_start);
+		assert (m_size >= (m_data->m_initialStart - m_start));
 		Buffer tmp;
-		tmp.add_at_start (m_zero_area_size);
-		tmp.begin ().write_u8 (0, m_zero_area_size);
-		uint32_t data_start = m_data->m_initial_start - m_start;
+		tmp.add_at_start (m_zeroAreaSize);
+		tmp.begin ().write_u8 (0, m_zeroAreaSize);
+		uint32_t data_start = m_data->m_initialStart - m_start;
 		tmp.add_at_start (data_start);
 		tmp.begin ().write (m_data->m_data+m_start, data_start);
-		uint32_t data_end = m_size - (m_data->m_initial_start - m_start);
+		uint32_t data_end = m_size - (m_data->m_initialStart - m_start);
 		tmp.add_at_end (data_end);
 		Buffer::Iterator i = tmp.end ();
 		i.prev (data_end);
-		i.write (m_data->m_data+m_data->m_initial_start,data_end);
+		i.write (m_data->m_data+m_data->m_initialStart,data_end);
 		*const_cast<Buffer *> (this) = tmp;
 	}
 }
@@ -365,7 +365,7 @@ Buffer::transform_into_real_buffer (void) const
 uint8_t *
 Buffer::peek_data (void) const
 {
-	transform_into_real_buffer ();
+	transform_intoRealBuffer ();
 	return m_data->m_data + m_start;
 }
 
diff --git a/src/common/buffer.h b/src/common/buffer.h
index 7384caf47..b31773879 100644
--- a/src/common/buffer.h
+++ b/src/common/buffer.h
@@ -240,9 +240,9 @@ public:
 		friend class Buffer;
 		inline Iterator (Buffer const*buffer, uint32_t m_current);
 		inline uint32_t get_index (uint32_t n);
-		uint32_t m_zero_start;
-		uint32_t m_zero_end;
-		uint32_t m_data_end;
+		uint32_t m_zeroStart;
+		uint32_t m_zeroEnd;
+		uint32_t m_dataEnd;
 		uint32_t m_current;
 		uint8_t *m_data;
 	};
@@ -329,26 +329,26 @@ private:
 	struct BufferData {
 		uint32_t m_count;
 		uint32_t m_size;
-		uint32_t m_initial_start;
-		uint32_t m_dirty_start;
-		uint32_t m_dirty_size;
+		uint32_t m_initialStart;
+		uint32_t m_dirtyStart;
+		uint32_t m_dirtySize;
 		uint8_t m_data[1];
 	};
 	typedef std::vector<struct Buffer::BufferData*> BufferDataList;
 
 	inline uint8_t *get_start (void) const;
-	void transform_into_real_buffer (void) const;
+	void transform_intoRealBuffer (void) const;
 	static void recycle (struct Buffer::BufferData *data);
 	static struct Buffer::BufferData *create (void);
 	static struct Buffer::BufferData *allocate (uint32_t size, uint32_t start);
 	static void deallocate (struct Buffer::BufferData *data);
 
-	static BufferDataList m_free_list;
-	static uint32_t m_max_total_add_start;
-	static uint32_t m_max_total_add_end;
+	static BufferDataList m_freeList;
+	static uint32_t m_maxTotalAddStart;
+	static uint32_t m_maxTotalAddEnd;
 
 	struct BufferData *m_data;
-	uint32_t m_zero_area_size;
+	uint32_t m_zeroAreaSize;
 	uint32_t m_start;
 	uint32_t m_size;
 };
@@ -361,8 +361,8 @@ namespace ns3 {
 
 Buffer::Buffer ()
 	: m_data (Buffer::create ()),
-	  m_zero_area_size (0),
-	  m_start (m_max_total_add_start),
+	  m_zeroAreaSize (0),
+	  m_start (m_maxTotalAddStart),
 	  m_size (0)
 {
 	if (m_start > m_data->m_size) {
@@ -373,8 +373,8 @@ Buffer::Buffer ()
 
 Buffer::Buffer (uint32_t data_size)
 	: m_data (Buffer::create ()),
-	  m_zero_area_size (data_size),
-	  m_start (m_max_total_add_start),
+	  m_zeroAreaSize (data_size),
+	  m_start (m_maxTotalAddStart),
 	  m_size (0)
 {
 	if (m_start > m_data->m_size) {
@@ -386,7 +386,7 @@ Buffer::Buffer (uint32_t data_size)
 
 Buffer::Buffer (Buffer const&o)
 	: m_data (o.m_data),
-	  m_zero_area_size (o.m_zero_area_size),
+	  m_zeroAreaSize (o.m_zeroAreaSize),
 	  m_start (o.m_start),
 	  m_size (o.m_size)
 {
@@ -406,7 +406,7 @@ Buffer::operator = (Buffer const&o)
 		m_data = o.m_data;
 		m_data->m_count++;
 	}
-	m_zero_area_size = o.m_zero_area_size;
+	m_zeroAreaSize = o.m_zeroAreaSize;
 	m_start = o.m_start;
 	m_size = o.m_size;
 	assert (m_start <= m_data->m_size);
@@ -431,7 +431,7 @@ Buffer::get_start (void) const
 uint32_t 
 Buffer::get_size (void) const
 {
-	return m_size + m_zero_area_size;
+	return m_size + m_zeroAreaSize;
 }
 
 Buffer::Iterator 
@@ -447,16 +447,16 @@ Buffer::end (void) const
 
 
 Buffer::Iterator::Iterator ()
-	: m_zero_start (0),
-	  m_zero_end (0),
-	  m_data_end (0),
+	: m_zeroStart (0),
+	  m_zeroEnd (0),
+	  m_dataEnd (0),
 	  m_current (0),
 	  m_data (0)
 {}
 Buffer::Iterator::Iterator (Buffer const*buffer, uint32_t current)
-	: m_zero_start (buffer->m_data->m_initial_start-buffer->m_start),
-	  m_zero_end (m_zero_start+buffer->m_zero_area_size),
-	  m_data_end (buffer->get_size ()),
+	: m_zeroStart (buffer->m_data->m_initialStart-buffer->m_start),
+	  m_zeroEnd (m_zeroStart+buffer->m_zeroAreaSize),
+	  m_dataEnd (buffer->get_size ()),
 	  m_current (current),
 	  m_data (buffer->m_data->m_data+buffer->m_start)
 {}
@@ -464,7 +464,7 @@ Buffer::Iterator::Iterator (Buffer const*buffer, uint32_t current)
 void 
 Buffer::Iterator::next (void)
 {
-	assert (m_current + 1 <= m_data_end);
+	assert (m_current + 1 <= m_dataEnd);
 	m_current++;
 }
 void 
@@ -476,7 +476,7 @@ Buffer::Iterator::prev (void)
 void 
 Buffer::Iterator::next (uint32_t delta)
 {
-	assert (m_current + delta <= m_data_end);
+	assert (m_current + delta <= m_dataEnd);
 	m_current += delta;
 }
 void 
@@ -497,7 +497,7 @@ Buffer::Iterator::get_distance_from (Iterator const &o) const
 bool 
 Buffer::Iterator::is_end (void) const
 {
-	return m_current == m_data_end;
+	return m_current == m_dataEnd;
 }
 bool 
 Buffer::Iterator::is_start (void) const
@@ -509,15 +509,15 @@ uint32_t
 Buffer::Iterator::get_index (uint32_t n)
 {
 	assert ( 
-		(m_current + n <= m_data_end) &&
-		((m_current + n <= m_zero_start) ||
-		 (m_current >= m_zero_end))
+		(m_current + n <= m_dataEnd) &&
+		((m_current + n <= m_zeroStart) ||
+		 (m_current >= m_zeroEnd))
 		);
 	uint32_t index;
-	if (m_current < m_zero_start) {
+	if (m_current < m_zeroStart) {
 		index = m_current;
 	} else {
-		index = m_current - (m_zero_end-m_zero_start);
+		index = m_current - (m_zeroEnd-m_zeroStart);
 	}
 	return index;
 }
diff --git a/src/common/chunk.cc b/src/common/chunk.cc
index 6ab425d92..a3723dc5b 100644
--- a/src/common/chunk.cc
+++ b/src/common/chunk.cc
@@ -25,7 +25,7 @@
 namespace ns3 {
 
 Chunk::Chunk ()
-	: m_must_peek_before_remove (false) {}
+	: m_mustPeekBeforeRemove (false) {}
 
 void 
 Chunk::print (std::ostream &os) const
@@ -41,14 +41,14 @@ void
 Chunk::peek (Buffer const *buffer)
 {
 	peek_from (buffer);
-	m_must_peek_before_remove = true;
+	m_mustPeekBeforeRemove = true;
 }
 void 
 Chunk::remove (Buffer *buffer)
 {
-	assert (m_must_peek_before_remove);
+	assert (m_mustPeekBeforeRemove);
 	remove_from (buffer);
-	m_must_peek_before_remove = false;
+	m_mustPeekBeforeRemove = false;
 }
 
 
diff --git a/src/common/chunk.h b/src/common/chunk.h
index df4bcba55..3561cef04 100644
--- a/src/common/chunk.h
+++ b/src/common/chunk.h
@@ -49,7 +49,7 @@ public:
 	void peek (Buffer const *buffer);
 	void remove (Buffer *buffer);
 private:
-	bool m_must_peek_before_remove;
+	bool m_mustPeekBeforeRemove;
 	/**
 	 * \param os the std output stream in which this 
 	 *           protocol header must print itself.
diff --git a/src/common/pcap-writer.cc b/src/common/pcap-writer.cc
index 0babe1c3c..5ab20e832 100644
--- a/src/common/pcap-writer.cc
+++ b/src/common/pcap-writer.cc
@@ -39,7 +39,7 @@ enum {
 PcapWriter::PcapWriter ()
 {
 	m_writer = 0;
-	m_write_callback = make_callback (&PcapWriter::write_data, this);
+	m_writeCallback = make_callback (&PcapWriter::write_data, this);
 }
 PcapWriter::~PcapWriter ()
 {
@@ -76,7 +76,7 @@ PcapWriter::write_packet (Packet const packet)
 		write_32 (us & 0xffffffff);
 		write_32 (packet.get_size ());
 		write_32 (packet.get_size ());
-		packet.write (m_write_callback);
+		packet.write (m_writeCallback);
 	}
 }
 
diff --git a/src/common/pcap-writer.h b/src/common/pcap-writer.h
index 6f1e54397..52235ff85 100644
--- a/src/common/pcap-writer.h
+++ b/src/common/pcap-writer.h
@@ -65,7 +65,7 @@ private:
 	void write_32 (uint32_t data);
 	void write_16 (uint16_t data);
 	SystemFile *m_writer;
-	Callback<void,uint8_t *,uint32_t> m_write_callback;
+	Callback<void,uint8_t *,uint32_t> m_writeCallback;
 };
 
 }; // namespace ns3
diff --git a/src/common/trace-container.cc b/src/common/trace-container.cc
index d21725a30..b6ccc8691 100644
--- a/src/common/trace-container.cc
+++ b/src/common/trace-container.cc
@@ -30,15 +30,15 @@ TraceContainer::TraceContainer ()
 {}
 TraceContainer::~TraceContainer ()
 {
-	m_ui_list.erase (m_ui_list.begin (), m_ui_list.end ());
-	m_si_list.erase (m_si_list.begin (), m_si_list.end ());
-	m_f_list.erase (m_f_list.begin (), m_f_list.end ());
+	m_uiList.erase (m_uiList.begin (), m_uiList.end ());
+	m_siList.erase (m_siList.begin (), m_siList.end ());
+	m_fList.erase (m_fList.begin (), m_fList.end ());
 }
 
 void 
 TraceContainer::set_ui_variable_callback (char const *name, Callback<void,uint64_t, uint64_t> callback)
 {
-	for (UiListI i = m_ui_list.begin (); i != m_ui_list.end (); i++) {
+	for (UiListI i = m_uiList.begin (); i != m_uiList.end (); i++) {
 		if ((*i).second == name) {
 			(*i).first->set_callback (callback);
 			return;
@@ -49,7 +49,7 @@ TraceContainer::set_ui_variable_callback (char const *name, Callback<void,uint64
 void 
 TraceContainer::set_si_variable_callback (char const *name, Callback<void,int64_t, int64_t> callback)
 {
-	for (SiListI i = m_si_list.begin (); i != m_si_list.end (); i++) {
+	for (SiListI i = m_siList.begin (); i != m_siList.end (); i++) {
 		if ((*i).second == name) {
 			(*i).first->set_callback (callback);
 			return;
@@ -65,7 +65,7 @@ TraceContainer::set_f_variable_callback (char const *name, Callback<void,double,
 void 
 TraceContainer::set_stream (char const *name, std::ostream *os)
 {
-	for (StreamTracerListI i = m_trace_stream_list.begin (); i != m_trace_stream_list.end (); i++) {
+	for (StreamTracerListI i = m_traceStreamList.begin (); i != m_traceStreamList.end (); i++) {
 		if ((*i).second == name) {
 			(*i).first->set_stream (os);
 			return;
@@ -78,25 +78,25 @@ void
 TraceContainer::register_ui_variable (char const *name, UiVariableTracerBase *var)
 {
 	// ensure unicity
-	for (UiListI i = m_ui_list.begin (); i != m_ui_list.end (); i++) {
+	for (UiListI i = m_uiList.begin (); i != m_uiList.end (); i++) {
 		if (i->second == name) {
-			m_ui_list.erase (i);
+			m_uiList.erase (i);
 			break;
 		}
 	}
-	m_ui_list.push_back (std::make_pair (var, name));
+	m_uiList.push_back (std::make_pair (var, name));
 }
 void 
 TraceContainer::register_si_variable (char const *name, SiVariableTracerBase *var)
 {
 	// ensure unicity
-	for (SiListI i = m_si_list.begin (); i != m_si_list.end (); i++) {
+	for (SiListI i = m_siList.begin (); i != m_siList.end (); i++) {
 		if (i->second == name) {
-			m_si_list.erase (i);
+			m_siList.erase (i);
 			break;
 		}
 	}
-	m_si_list.push_back (std::make_pair (var, name));
+	m_siList.push_back (std::make_pair (var, name));
 }
 void 
 TraceContainer::register_f_variable (char const *name, FVariableTracerBase *var)
@@ -108,26 +108,26 @@ void
 TraceContainer::register_stream (char const *name, StreamTracer *stream)
 {
 	// ensure unicity
-	for (StreamTracerListI i = m_trace_stream_list.begin (); i != m_trace_stream_list.end (); i++) {
+	for (StreamTracerListI i = m_traceStreamList.begin (); i != m_traceStreamList.end (); i++) {
 		if (i->second == name) {
-			m_trace_stream_list.erase (i);
+			m_traceStreamList.erase (i);
 			break;
 		}
 	}
-	m_trace_stream_list.push_back (std::make_pair (stream,name));
+	m_traceStreamList.push_back (std::make_pair (stream,name));
 
 }
 
 void 
 TraceContainer::register_callback (char const *name, CallbackTracerBase *tracer)
 {
-	for (CallbackListI i = m_callback_list.begin (); i != m_callback_list.end (); i++) {
+	for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++) {
 		if (i->second == name) {
-			m_callback_list.erase (i);
+			m_callbackList.erase (i);
 			break;
 		}
 	}
-	m_callback_list.push_back (std::make_pair (tracer, name));
+	m_callbackList.push_back (std::make_pair (tracer, name));
 }
 
 
@@ -139,27 +139,27 @@ TraceContainer::register_callback (char const *name, CallbackTracerBase *tracer)
 void 
 ns3::TraceContainer::print_debug (void)
 {
-	if (!m_ui_list.empty ()) {
+	if (!m_uiList.empty ()) {
 		std::cout << "ui var: " << std::endl;
-		for (UiListI i = m_ui_list.begin (); i != m_ui_list.end (); i++) {
+		for (UiListI i = m_uiList.begin (); i != m_uiList.end (); i++) {
 			std::cout << "    \"" << (*i).second << "\""<<std::endl;
 		}
 	}
-	if (!m_si_list.empty ()) {
+	if (!m_siList.empty ()) {
 		std::cout << "si var: " << std::endl;
-		for (SiListI i = m_si_list.begin (); i != m_si_list.end (); i++) {
+		for (SiListI i = m_siList.begin (); i != m_siList.end (); i++) {
 			std::cout << "    \"" << (*i).second << "\""<<std::endl;
 		}
 	}
-	if (!m_f_list.empty ()) {
+	if (!m_fList.empty ()) {
 		std::cout << "f var: " << std::endl;
-		for (FListI i = m_f_list.begin (); i != m_f_list.end (); i++) {
+		for (FListI i = m_fList.begin (); i != m_fList.end (); i++) {
 			std::cout << "    \"" << (*i).second << "\""<<std::endl;
 		}
 	}
-	if (!m_callback_list.empty ()) {
+	if (!m_callbackList.empty ()) {
 		std::cout << "callback list: "<<std::endl;
-		for (CallbackListI i = m_callback_list.begin (); i != m_callback_list.end (); i++) {
+		for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++) {
 			std::cout << "    \"" << i->second << "\""<<std::endl;
 		}
 	}
diff --git a/src/common/trace-container.h b/src/common/trace-container.h
index f54583f25..83421a310 100644
--- a/src/common/trace-container.h
+++ b/src/common/trace-container.h
@@ -187,11 +187,11 @@ private:
 	typedef std::list<std::pair<CallbackTracerBase *, std::string> > CallbackList;
 	typedef std::list<std::pair<CallbackTracerBase *, std::string> >::iterator CallbackListI;
 
-	UiList m_ui_list;
-	SiList m_si_list;
-	FList m_f_list;
-	StreamTracerList m_trace_stream_list;
-	CallbackList m_callback_list;
+	UiList m_uiList;
+	SiList m_siList;
+	FList m_fList;
+	StreamTracerList m_traceStreamList;
+	CallbackList m_callbackList;
 };
 
 }; // namespace ns3
@@ -206,7 +206,7 @@ template <typename T1>
 void 
 TraceContainer::set_callback (char const *name, Callback<void,T1> callback)
 {
-	for (CallbackListI i = m_callback_list.begin (); i != m_callback_list.end (); i++) {
+	for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++) {
 		if (i->second == name) {
 			static_cast<CallbackTracer<T1> *> (i->first)->set_callback (callback);
 			return;
@@ -220,7 +220,7 @@ template <typename T1, typename T2>
 void 
 TraceContainer::set_callback (char const *name, Callback<void,T1,T2> callback)
 {
-	for (CallbackListI i = m_callback_list.begin (); i != m_callback_list.end (); i++) {
+	for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++) {
 		if (i->second == name) {
 			static_cast<CallbackTracer<T1,T2> *> (i->first)->set_callback (callback);
 			return;
@@ -234,7 +234,7 @@ template <typename T1, typename T2, typename T3>
 void 
 TraceContainer::set_callback (char const *name, Callback<void,T1,T2,T3> callback)
 {
-	for (CallbackListI i = m_callback_list.begin (); i != m_callback_list.end (); i++) {
+	for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++) {
 		if (i->second == name) {
 			static_cast<CallbackTracer<T1,T2,T3> *> (i->first)->set_callback (callback);
 			return;
@@ -248,7 +248,7 @@ template <typename T1, typename T2, typename T3, typename T4>
 void 
 TraceContainer::set_callback (char const *name, Callback<void,T1,T2,T3,T4> callback)
 {
-	for (CallbackListI i = m_callback_list.begin (); i != m_callback_list.end (); i++) {
+	for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++) {
 		if (i->second == name) {
 			static_cast<CallbackTracer<T1,T2,T3,T4> *> (i->first)->set_callback (callback);
 			return;
@@ -262,7 +262,7 @@ template <typename T1, typename T2, typename T3, typename T4, typename T5>
 void 
 TraceContainer::set_callback (char const *name, Callback<void,T1,T2,T3,T4,T5> callback)
 {
-	for (CallbackListI i = m_callback_list.begin (); i != m_callback_list.end (); i++) {
+	for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++) {
 		if (i->second == name) {
 			static_cast<CallbackTracer<T1,T2,T3,T4,T5> *> (i->first)->set_callback (callback);
 			return;
diff --git a/src/core/callback.h b/src/core/callback.h
index 8e1f0d421..395e6a330 100644
--- a/src/core/callback.h
+++ b/src/core/callback.h
@@ -169,29 +169,29 @@ template <typename OBJ_PTR, typename MEM_PTR, typename R, typename T1, typename
 class MemPtrCallbackImpl : public CallbackImpl<R,T1,T2,T3,T4,T5> {
 public:
 	MemPtrCallbackImpl (OBJ_PTR const&obj_ptr, MEM_PTR mem_ptr)
-		: m_obj_ptr (obj_ptr), m_mem_ptr (mem_ptr) {}
+		: m_objPtr (obj_ptr), m_memPtr (mem_ptr) {}
 	virtual ~MemPtrCallbackImpl () {}
 	R operator() (void) {
-		return ((*m_obj_ptr).*m_mem_ptr) ();
+		return ((*m_objPtr).*m_memPtr) ();
 	}
 	R operator() (T1 a1) {
-		return ((*m_obj_ptr).*m_mem_ptr) (a1);
+		return ((*m_objPtr).*m_memPtr) (a1);
 	}
 	R operator() (T1 a1,T2 a2) {
-		return ((*m_obj_ptr).*m_mem_ptr) (a1,a2);
+		return ((*m_objPtr).*m_memPtr) (a1,a2);
 	}
 	R operator() (T1 a1,T2 a2,T3 a3) {
-		return ((*m_obj_ptr).*m_mem_ptr) (a1,a2,a3);
+		return ((*m_objPtr).*m_memPtr) (a1,a2,a3);
 	}
 	R operator() (T1 a1,T2 a2,T3 a3,T4 a4) {
-		return ((*m_obj_ptr).*m_mem_ptr) (a1,a2,a3,a4);
+		return ((*m_objPtr).*m_memPtr) (a1,a2,a3,a4);
 	}
 	R operator() (T1 a1,T2 a2,T3 a3,T4 a4,T5 a5) {
-		return ((*m_obj_ptr).*m_mem_ptr) (a1,a2,a3,a4,a5);
+		return ((*m_objPtr).*m_memPtr) (a1,a2,a3,a4,a5);
 	}
 private:
-	OBJ_PTR const m_obj_ptr;
-	MEM_PTR m_mem_ptr;
+	OBJ_PTR const m_objPtr;
+	MEM_PTR m_memPtr;
 };
 
 /**
diff --git a/src/core/reference-list.h b/src/core/reference-list.h
index 149a814e4..1849e3154 100644
--- a/src/core/reference-list.h
+++ b/src/core/reference-list.h
@@ -38,7 +38,7 @@ template <typename OBJ_PTR>
 class ReferenceList {
 public:
 	ReferenceList () 
-		:  m_obj_ptr (),
+		:  m_objPtr (),
 		   m_prev (), 
 		   m_next () 
 	{
@@ -46,7 +46,7 @@ public:
 		m_next = this;
 	}
 	ReferenceList (ReferenceList &o) 
-		: m_obj_ptr (),
+		: m_objPtr (),
 		  m_prev (), 
 		  m_next ()
 	{
@@ -55,7 +55,7 @@ public:
 		insert_self_in_other (o);
 	}
 	ReferenceList (ReferenceList const&o) 
-		: m_obj_ptr (),
+		: m_objPtr (),
 		  m_prev (), 
 		  m_next ()
 	{
@@ -64,7 +64,7 @@ public:
 		insert_self_in_other (o);
 	}
 	ReferenceList (OBJ_PTR const &obj_ptr)
-		: m_obj_ptr (obj_ptr), 
+		: m_objPtr (obj_ptr), 
 		  m_prev (), 
 		  m_next ()
 	{
@@ -80,15 +80,15 @@ public:
 		return *this;
 	}
 	OBJ_PTR operator-> () {
-		return m_obj_ptr;
+		return m_objPtr;
 	}
 	void set (OBJ_PTR obj_ptr) {
 		remove_from_list ();
-		m_obj_ptr = obj_ptr;
+		m_objPtr = obj_ptr;
 	}
 	OBJ_PTR get (void) {
 		// explicit conversion to raw pointer type.
-		return m_obj_ptr;
+		return m_objPtr;
 	}
 private:
 	void insert_self_in_other (ReferenceList const&o) {
@@ -96,18 +96,18 @@ private:
 		m_next = o.m_next;
 		m_next->m_prev = this;
 		o.m_next = this;
-		m_obj_ptr = o.m_obj_ptr;
+		m_objPtr = o.m_objPtr;
 	}
 	void remove_from_list (void) {
 		if (m_prev == this) {
 			//assert (m_next == this);
-			delete m_obj_ptr;
-			m_obj_ptr = OBJ_PTR ();
+			delete m_objPtr;
+			m_objPtr = OBJ_PTR ();
 		}
 		m_prev->m_next = m_next;
 		m_next->m_prev = m_prev;
 	}
-	OBJ_PTR m_obj_ptr;
+	OBJ_PTR m_objPtr;
 	mutable ReferenceList const*m_prev;
 	mutable ReferenceList const*m_next;
 };
diff --git a/src/core/unix-system-wall-clock-ms.cc b/src/core/unix-system-wall-clock-ms.cc
index 90bc53df0..359bbb9ae 100644
--- a/src/core/unix-system-wall-clock-ms.cc
+++ b/src/core/unix-system-wall-clock-ms.cc
@@ -29,24 +29,24 @@ public:
 	void start (void);
 	unsigned long long end (void);
 private:
-	struct timeval m_start_tv;
-	struct timeval m_end_tv;
+	struct timeval m_startTv;
+	struct timeval m_endTv;
 };
 
 void 
 SystemWallClockMsPrivate::start (void)
 {
 	struct timezone tz;
-	gettimeofday (&m_start_tv, &tz);
+	gettimeofday (&m_startTv, &tz);
 }
 
 unsigned long long 
 SystemWallClockMsPrivate::end (void)
 {
 	struct timezone tz;
-	gettimeofday (&m_end_tv, &tz);
-	unsigned long long end = m_end_tv.tv_sec *1000 + m_end_tv.tv_usec / 1000;
-	unsigned long long start = m_start_tv.tv_sec *1000 + m_start_tv.tv_usec / 1000;
+	gettimeofday (&m_endTv, &tz);
+	unsigned long long end = m_endTv.tv_sec *1000 + m_endTv.tv_usec / 1000;
+	unsigned long long start = m_startTv.tv_sec *1000 + m_startTv.tv_usec / 1000;
 	return end - start;
 }
 
diff --git a/src/simulator/event-id.cc b/src/simulator/event-id.cc
index 9987ffa3f..282b0fbb5 100644
--- a/src/simulator/event-id.cc
+++ b/src/simulator/event-id.cc
@@ -24,13 +24,13 @@
 namespace ns3 {
 
 EventId::EventId ()
-	: m_event_impl (0),
+	: m_eventImpl (0),
 	  m_ns (0),
 	  m_uid (0)
 {}
     
 EventId::EventId (EventImpl *impl, uint64_t ns, uint32_t uid)
-	: m_event_impl (impl),
+	: m_eventImpl (impl),
 	  m_ns (ns),
 	  m_uid (uid)
 {}
@@ -47,7 +47,7 @@ EventId::is_expired (void)
 EventImpl *
 EventId::get_event_impl (void) const
 {
-	return m_event_impl;
+	return m_eventImpl;
 }
 uint64_t 
 EventId::get_ns (void) const
diff --git a/src/simulator/event-id.h b/src/simulator/event-id.h
index 87bfc630b..73f85b575 100644
--- a/src/simulator/event-id.h
+++ b/src/simulator/event-id.h
@@ -42,7 +42,7 @@ public:
 	uint64_t get_ns (void) const;
 	uint32_t get_uid (void) const;
 private:
-	EventImpl *m_event_impl;
+	EventImpl *m_eventImpl;
 	uint64_t m_ns;
 	uint32_t m_uid;
 };
diff --git a/src/simulator/event-impl.cc b/src/simulator/event-impl.cc
index 241b1692d..d9122848c 100644
--- a/src/simulator/event-impl.cc
+++ b/src/simulator/event-impl.cc
@@ -29,7 +29,7 @@ EventImpl::~EventImpl ()
 {}
 
 EventImpl::EventImpl ()
-	: m_internal_iterator (0),
+	: m_internalIterator (0),
 	  m_cancel (false)
 {}
 void 
@@ -42,12 +42,12 @@ EventImpl::invoke (void)
 void 
 EventImpl::set_internal_iterator (void *tag)
 {
-	m_internal_iterator = tag;
+	m_internalIterator = tag;
 }
 void *
 EventImpl::get_internal_iterator (void) const
 {
-	return m_internal_iterator;
+	return m_internalIterator;
 }
 void 
 EventImpl::cancel (void)
diff --git a/src/simulator/event-impl.h b/src/simulator/event-impl.h
index c2f75bc2f..442dd776d 100644
--- a/src/simulator/event-impl.h
+++ b/src/simulator/event-impl.h
@@ -37,7 +37,7 @@ protected:
 	virtual void notify (void) = 0;
 private:
 	friend class Event;
-	void *m_internal_iterator;
+	void *m_internalIterator;
 	bool m_cancel;
 };
 
diff --git a/src/simulator/simulator.cc b/src/simulator/simulator.cc
index 1f7a3f1a4..c34d716ad 100644
--- a/src/simulator/simulator.cc
+++ b/src/simulator/simulator.cc
@@ -70,15 +70,15 @@ private:
 
 	typedef std::list<std::pair<EventImpl *,uint32_t> > Events;
 	Events m_destroy;
-	uint64_t m_stop_at;
+	uint64_t m_stopAt;
 	bool m_stop;
 	Scheduler *m_events;
 	uint32_t m_uid;
-	uint32_t m_current_uid;
-	uint64_t m_current_ns;
+	uint32_t m_currentUid;
+	uint64_t m_currentNs;
 	std::ofstream m_log;
-	std::ifstream m_input_log;
-	bool m_log_enable;
+	std::ifstream m_inputLog;
+	bool m_logEnable;
 };
 
 
@@ -87,11 +87,11 @@ private:
 SimulatorPrivate::SimulatorPrivate (Scheduler *events)
 {
 	m_stop = false;
-	m_stop_at = 0;
+	m_stopAt = 0;
 	m_events = events;
 	m_uid = 0;	
-	m_log_enable = false;
-	m_current_ns = 0;
+	m_logEnable = false;
+	m_currentNs = 0;
 }
 
 SimulatorPrivate::~SimulatorPrivate ()
@@ -112,7 +112,7 @@ void
 SimulatorPrivate::enable_log_to (char const *filename)
 {
 	m_log.open (filename);
-	m_log_enable = true;
+	m_logEnable = true;
 }
 
 void
@@ -122,9 +122,9 @@ SimulatorPrivate::process_one_event (void)
 	Scheduler::EventKey next_key = m_events->peek_next_key ();
 	m_events->remove_next ();
 	TRACE ("handle " << next_ev);
-	m_current_ns = next_key.m_ns;
-	m_current_uid = next_key.m_uid;
-	if (m_log_enable) {
+	m_currentNs = next_key.m_ns;
+	m_currentUid = next_key.m_uid;
+	if (m_logEnable) {
 		m_log << "e "<<next_key.m_uid << " " << next_key.m_ns << std::endl;
 	}
 	next_ev->invoke ();
@@ -149,7 +149,7 @@ void
 SimulatorPrivate::run (void)
 {
 	while (!m_events->is_empty () && !m_stop && 
-	       (m_stop_at == 0 || m_stop_at > next ().ns ())) {
+	       (m_stopAt == 0 || m_stopAt > next ().ns ())) {
 		process_one_event ();
 	}
 	m_log.close ();
@@ -164,15 +164,15 @@ SimulatorPrivate::stop (void)
 void 
 SimulatorPrivate::stop_at (Time at)
 {
-	m_stop_at = at.ns ();
+	m_stopAt = at.ns ();
 }
 EventId
 SimulatorPrivate::schedule (Time time, EventImpl *event)
 {
 	if (time.is_destroy ()) {
 		m_destroy.push_back (std::make_pair (event, m_uid));
-		if (m_log_enable) {
-			m_log << "id " << m_current_uid << " " << now ().ns () << " "
+		if (m_logEnable) {
+			m_log << "id " << m_currentUid << " " << now ().ns () << " "
 			      << m_uid << std::endl;
 		}
 		m_uid++;
@@ -181,8 +181,8 @@ SimulatorPrivate::schedule (Time time, EventImpl *event)
 	}
 	assert (time.ns () >= now ().ns ());
 	Scheduler::EventKey key = {time.ns (), m_uid};
-	if (m_log_enable) {
-		m_log << "i "<<m_current_uid<<" "<<now ().ns ()<<" "
+	if (m_logEnable) {
+		m_log << "i "<<m_currentUid<<" "<<now ().ns ()<<" "
 		      <<m_uid<<" "<<time.ns () << std::endl;
 	}
 	m_uid++;
@@ -191,7 +191,7 @@ SimulatorPrivate::schedule (Time time, EventImpl *event)
 Time
 SimulatorPrivate::now (void) const
 {
-	return Time::abs_ns (m_current_ns);
+	return Time::abs_ns (m_currentNs);
 }
 
 void
@@ -200,8 +200,8 @@ SimulatorPrivate::remove (EventId ev)
 	Scheduler::EventKey key;
 	EventImpl *impl = m_events->remove (ev, &key);
 	delete impl;
-	if (m_log_enable) {
-		m_log << "r " << m_current_uid << " " << now ().ns () << " "
+	if (m_logEnable) {
+		m_log << "r " << m_currentUid << " " << now ().ns () << " "
 		      << key.m_uid << " " << key.m_ns << std::endl;
 	}
 }
@@ -219,7 +219,7 @@ SimulatorPrivate::is_expired (EventId ev)
 {
 	if (ev.get_event_impl () != 0 &&
 	    ev.get_ns () <= now ().ns () &&
-	    ev.get_uid () < m_current_uid) {
+	    ev.get_uid () < m_currentUid) {
 		return false;
 	}
 	return true;
@@ -238,27 +238,27 @@ SimulatorPrivate::is_expired (EventId ev)
 namespace ns3 {
 
 SimulatorPrivate *Simulator::m_priv = 0;
-Simulator::ListType Simulator::m_list_type = LINKED_LIST;
-SchedulerFactory const*Simulator::m_sched_factory = 0;
+Simulator::ListType Simulator::m_listType = LINKED_LIST;
+SchedulerFactory const*Simulator::m_schedFactory = 0;
 
 void Simulator::set_linked_list (void)
 {
-	m_list_type = LINKED_LIST;
+	m_listType = LINKED_LIST;
 }
 void Simulator::set_binary_heap (void)
 {
-	m_list_type = BINARY_HEAP;
+	m_listType = BINARY_HEAP;
 }
 void Simulator::set_std_map (void)
 {
-	m_list_type = STD_MAP;
+	m_listType = STD_MAP;
 }
 void 
 Simulator::set_external (SchedulerFactory const*factory)
 {
 	assert (factory != 0);
-	m_sched_factory = factory;
-	m_list_type = EXTERNAL;
+	m_schedFactory = factory;
+	m_listType = EXTERNAL;
 }
 void Simulator::enable_log_to (char const *filename)
 {
@@ -271,7 +271,7 @@ Simulator::get_priv (void)
 {
 	if (m_priv == 0) {
 		Scheduler *events;
-		switch (m_list_type) {
+		switch (m_listType) {
 		case LINKED_LIST:
 			events = new SchedulerList ();
 			break;
@@ -282,7 +282,7 @@ Simulator::get_priv (void)
 			events = new SchedulerMap ();
 			break;
 		case EXTERNAL:
-			events = m_sched_factory->create ();
+			events = m_schedFactory->create ();
 		default: // not reached
 			events = 0;
 			assert (false); 
@@ -382,7 +382,7 @@ private:
 	bool m_a;
 	bool m_c;
 	bool m_d;
-	EventId m_id_c;
+	EventId m_idC;
 };
 
 SimulatorTests::SimulatorTests ()
@@ -403,7 +403,7 @@ SimulatorTests::b (int b)
 	} else {
 		m_b = true;
 	}
-	Simulator::remove (m_id_c);
+	Simulator::remove (m_idC);
 	Simulator::schedule (Time::rel_us (10), &SimulatorTests::d, this, 4);
 }
 void
@@ -430,7 +430,7 @@ SimulatorTests::run_tests (void)
 	m_d = false;
 	EventId a = Simulator::schedule (Time::abs_us (10), &SimulatorTests::a, this, 1);
 	EventId b = Simulator::schedule (Time::abs_us (11), &SimulatorTests::b, this, 2);
-	m_id_c = Simulator::schedule (Time::abs_us (12), &SimulatorTests::c, this, 3);
+	m_idC = Simulator::schedule (Time::abs_us (12), &SimulatorTests::c, this, 3);
 
 	Simulator::cancel (a);
 	Simulator::run ();
diff --git a/src/simulator/simulator.h b/src/simulator/simulator.h
index 2786d2cd5..3e6009a83 100644
--- a/src/simulator/simulator.h
+++ b/src/simulator/simulator.h
@@ -480,13 +480,13 @@ private:
 	static SimulatorPrivate *get_priv (void);
 	static EventId schedule (Time time, EventImpl *event);
 	static SimulatorPrivate *m_priv;
-	static SchedulerFactory const*m_sched_factory;
+	static SchedulerFactory const*m_schedFactory;
 	static enum ListType {
 		LINKED_LIST,
 		BINARY_HEAP,
 		STD_MAP,
 		EXTERNAL
-	} m_list_type;
+	} m_listType;
 };
 
 }; // namespace ns3
diff --git a/src/simulator/time.cc b/src/simulator/time.cc
index b51575ef8..aea902b86 100644
--- a/src/simulator/time.cc
+++ b/src/simulator/time.cc
@@ -25,22 +25,22 @@ namespace ns3 {
 
 Time::Time ()
 	: m_ns (0),
-	  m_is_destroy (true)
+	  m_isDestroy (true)
 {}
 Time::Time (Time const &o)
 	: m_ns (o.m_ns),
-	  m_is_destroy (o.m_is_destroy)
+	  m_isDestroy (o.m_isDestroy)
 {}
 Time &
 Time::operator = (Time const &o)
 {
 	m_ns = o.m_ns;
-	m_is_destroy = o.m_is_destroy;
+	m_isDestroy = o.m_isDestroy;
 	return *this;
 }
 Time::Time (uint64_t ns)
 	: m_ns (ns),
-	  m_is_destroy (false)
+	  m_isDestroy (false)
 {}
 
 double 
@@ -66,7 +66,7 @@ Time::ns (void) const
 bool
 Time::is_destroy (void) const
 {
-	return m_is_destroy;
+	return m_isDestroy;
 }
 
 Time 
diff --git a/src/simulator/time.h b/src/simulator/time.h
index f7632cf23..ab320fb77 100644
--- a/src/simulator/time.h
+++ b/src/simulator/time.h
@@ -46,7 +46,7 @@ protected:
 	Time ();
 private:
 	uint64_t m_ns;
-	bool m_is_destroy;
+	bool m_isDestroy;
 };
 
 
diff --git a/utils/replay-simulation.cc b/utils/replay-simulation.cc
index d88e65288..a79ff88f9 100644
--- a/utils/replay-simulation.cc
+++ b/utils/replay-simulation.cc
@@ -48,15 +48,15 @@ private:
 		union {
 			struct {
 				// time at which the event is supposed to expire
-				uint64_t m_ev_us;
+				uint64_t m_evUs;
 			} insert;
 			struct {
 				// location in the array of events to remove where
 				// to insert this event once it is inserted in 
 				// the scheduler.
-				uint32_t m_ev_loc; 
+				uint32_t m_evLoc; 
 				// time at which the event is supposed to expire
-				uint64_t m_ev_us;
+				uint64_t m_evUs;
 			} insert_remove;
 		};
 	};
@@ -69,7 +69,7 @@ private:
 
 	Commands m_commands;
 	CommandsI m_command;
-	RemoveEvents m_remove_events;
+	RemoveEvents m_removeEvents;
 	uint32_t m_uid;
 };
 
@@ -93,7 +93,7 @@ LogReader::read_from_filename (char const *filename)
 			struct Command cmd;
 			cmd.m_type = Command::INSERT;
 			cmd.m_uid = now_uid;
-			cmd.insert.m_ev_us = ev_us;
+			cmd.insert.m_evUs = ev_us;
 			m_commands.push_back (cmd);
 		} else if (type == "r") {
 			uint32_t now_uid, ev_uid;
@@ -122,12 +122,12 @@ LogReader::read_from_filename (char const *filename)
 			for (RemovesI j = removes.begin (); j != removes.end (); j++) {
 				if (j->second == i->m_uid) {
 					// this insert will be removed later.
-					uint64_t us = i->insert.m_ev_us;
+					uint64_t us = i->insert.m_evUs;
 					uint32_t uid = i->m_uid;
 					i->m_type = Command::INSERT_REMOVE;
 					i->m_uid = uid;
-					i->insert_remove.m_ev_us = us;
-					i->insert_remove.m_ev_loc = j->first;
+					i->insert_remove.m_evUs = us;
+					i->insert_remove.m_evLoc = j->first;
 					break;
 				}
 			}
@@ -140,8 +140,8 @@ LogReader::read_from_filename (char const *filename)
 			uint32_t loc = 0;
 			for (CommandsI tmp = i; tmp != m_commands.end (); tmp++) {
 				if (tmp->m_type == Command::REMOVE &&
-				    tmp->m_uid == i->insert_remove.m_ev_loc) {
-					i->insert_remove.m_ev_loc = loc;
+				    tmp->m_uid == i->insert_remove.m_evLoc) {
+					i->insert_remove.m_evLoc = loc;
 					break;
 				}
 				loc++;
@@ -163,8 +163,8 @@ LogReader::execute_log_commands (uint32_t uid)
 		switch (cmd.m_type) {
 		case Command::INSERT:
 			//std::cout << "exec insert now=" << Simulator::now_us ()
-			//<< ", time=" << cmd.insert.m_ev_us << std::endl;
-			Simulator::schedule_abs_us (cmd.insert.m_ev_us, 
+			//<< ", time=" << cmd.insert.m_evUs << std::endl;
+			Simulator::schedule_abs_us (cmd.insert.m_evUs, 
 						 make_event (&LogReader::execute_log_commands, this, m_uid));
 			m_uid++;
 			break;
@@ -175,15 +175,15 @@ LogReader::execute_log_commands (uint32_t uid)
 			break;
 		case Command::REMOVE: {
 			//std::cout << "exec remove" << std::endl;
-			Event ev = m_remove_events.front ();
-			m_remove_events.pop_front ();
+			Event ev = m_removeEvents.front ();
+			m_removeEvents.pop_front ();
 			Simulator::remove (ev);
 		} break;
 		case Command::INSERT_REMOVE: {
 			//std::cout << "exec insert remove" << std::endl;
 			Event ev = make_event (&LogReader::execute_log_commands, this, m_uid);
-			Simulator::schedule_abs_us (cmd.insert_remove.m_ev_us, ev);
-			m_remove_events[cmd.insert_remove.m_ev_loc] = ev;
+			Simulator::schedule_abs_us (cmd.insert_remove.m_evUs, ev);
+			m_removeEvents[cmd.insert_remove.m_evLoc] = ev;
 			m_uid++;
 		} break;
 		}