diff --git a/documentation/articles.html b/documentation/articles.html
index a694672..93add9a 100644
--- a/documentation/articles.html
+++ b/documentation/articles.html
@@ -24,10 +24,10 @@
 			<li>
 				<a href="http://alain-bernard.developpez.com/tutoriels/eclipse/tutoriel-nattable/" title="Tutoriel : lib&eacute;rez le pouvoir de la NatTable (french)" target="_blank">Tutoriel : lib&eacute;rez le pouvoir de la NatTable (french)</a>
 			</li>
+			<li>
+				<a href="resources/NatTable_Enhanced.pdf" title="NatTable Enhanced - NatTable 1.1.0 (german)" target="_blank">NatTable Enhanced - NatTable 1.1.0 (german)</a>
+			</li>
 		</ul>
-		
-		If the direct links doesn't work you can find the articles and the source code of the associated examples 
-		<a href="http://www.beone-group.com/publikationen.html" title="BeOne Stuttgart Publikationen" target="_blank">here</a>.
 	</div>
 
 	<h3>Talks at conferences</h3>
diff --git a/resources/NatTable_Enhanced.pdf b/resources/NatTable_Enhanced.pdf
new file mode 100644
index 0000000..b773e77
--- /dev/null
+++ b/resources/NatTable_Enhanced.pdf
Binary files differ
