diff --git a/reviews.xml b/reviews.xml
index e68d1d0..7fd45ab 100644
--- a/reviews.xml
+++ b/reviews.xml
@@ -1,6 +1,15 @@
 <reviews>
 
 	<review>
+		<title>Eclipse 3.3: New and Improved</title>
+		<link><![CDATA[http://blogs.infosupport.com/peterhe/archive/2007/07/27/Eclipse-Europa_3A00_-New-and-Improved.aspx]]></link>
+		<author>Peter Hendriks</author>
+		<date>7/31/2007</date>
+		<language>English</language>
+		<shortDesc><![CDATA[I've been using Eclipse 3.3 for a while now, and I've been getting that common feeling again: missing all
+		kinds of little features when switching back to an "old" Eclipse based tool. There is all kinds of stuff I really like.]]></shortDesc>
+	</review>
+	<review>
 		<title>Eclipse 3.3</title>
 		<link><![CDATA[http://julianocarniel.blogspot.com/2007/07/eclipse-33.html]]></link>
 		<author>Juliano Carniel</author>
