diff --git a/bundles/org.eclipse.platform.doc.isv/guide/firstplugin_manifest.htm b/bundles/org.eclipse.platform.doc.isv/guide/firstplugin_manifest.htm
index ebf0f43..b262b40 100644
--- a/bundles/org.eclipse.platform.doc.isv/guide/firstplugin_manifest.htm
+++ b/bundles/org.eclipse.platform.doc.isv/guide/firstplugin_manifest.htm
@@ -1,7 +1,7 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"><html lang="en">
 <HEAD>
 
-<meta name="copyright" content="Copyright (c) IBM Corporation and others 2000, 2005. This page is made available under license. For full details see the LEGAL in the documentation book that contains this page." >
+<meta name="copyright" content="Copyright (c) IBM Corporation and others 2000, 2013. This page is made available under license. For full details see the LEGAL in the documentation book that contains this page." >
 
 <META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=ISO-8859-1">
 <META HTTP-EQUIV="Content-Style-Type" CONTENT="text/css">
@@ -31,8 +31,8 @@
 			name=&quot;Hello View&quot;
 			icon=&quot;icons/sample.gif&quot;
 			category=&quot;com.example.helloworld&quot;
-			class=&quot;com.example.helloworld.views.HelloWorldView&quot;
-			id=&quot;com.example.helloworld.views.HelloWorldView&quot;&gt;
+			class=&quot;com.example.helloworld.HelloWorldView&quot;
+			id=&quot;com.example.helloworld.HelloWorldView&quot;&gt;
 		&lt;/view&gt;
 	&lt;/extension&gt;
 &lt;/plugin&gt;
diff --git a/bundles/org.eclipse.platform.doc.isv/guide/firstplugin_view.htm b/bundles/org.eclipse.platform.doc.isv/guide/firstplugin_view.htm
index 4502c00..07037e4 100644
--- a/bundles/org.eclipse.platform.doc.isv/guide/firstplugin_view.htm
+++ b/bundles/org.eclipse.platform.doc.isv/guide/firstplugin_view.htm
@@ -1,7 +1,7 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"><html lang="en">
 <HEAD>
 
-<meta name="copyright" content="Copyright (c) IBM Corporation and others 2000, 2005. This page is made available under license. For full details see the LEGAL in the documentation book that contains this page." >
+<meta name="copyright" content="Copyright (c) IBM Corporation and others 2000, 2013. This page is made available under license. For full details see the LEGAL in the documentation book that contains this page." >
 
 <META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=ISO-8859-1">
 <META HTTP-EQUIV="Content-Style-Type" CONTENT="text/css">
@@ -21,7 +21,7 @@
 your <b>HelloWorldView</b>.&nbsp; Copy the contents below into the
 class you created, replacing the auto-generated content.&nbsp;</P>
 <pre>
-   package com.example.helloworld.views;
+   package com.example.helloworld;
 
    import org.eclipse.swt.widgets.Composite;
    import org.eclipse.swt.widgets.Label;
