diff --git a/TM_press_text_2006_06.php b/TM_press_text_2006_06.php
index 3f043dd..198e9b6 100644
--- a/TM_press_text_2006_06.php
+++ b/TM_press_text_2006_06.php
@@ -57,7 +57,7 @@
  <a href="http://dev.eclipse.org/viewcvs/index.cgi/%7Echeckout%7E/platform-vcm-home/main.html">
  Eclipse Platform/Team group.</a>
 A comprehensive 
- <a href="http://www.eclipse.org/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf">document
+ <a href="http://www.eclipse.org/tm/doc/TM_Use_Cases_v1.1c.pdf">document
  outlining the use-cases</a> and applicability
 of the Target Management Project is available from the "Getting Started"
 area on the Project Website at 
diff --git a/about.php b/about.php
index 5119bf3..fcc669a 100644
--- a/about.php
+++ b/about.php
@@ -83,7 +83,7 @@
     	<li><a href="http://wiki.eclipse.org/DSDP">
       		DSDP Top-Level Overview Diagrams</a> to understand how the Target Management
       		Project fits into DSDP, and what its basic building blocks are.</li> 
-    	<li><a href="/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf">
+    	<li><a href="/tm/doc/TM_Use_Cases_v1.1c.pdf">
       		Target Management Use-Case Document</a> 
       		to understand what scenarios we want to cover with our project.</li>
 		<li><a href="/tm/development/plan.php">
@@ -109,7 +109,7 @@
 				    TM 2.0 Release Review Slides</a></li>
 			    <li><a href="http://wiki.eclipse.org/DSDP" 
 			    	target="_self">DSDP Overview Diagrams</a></li>				
-				<li><a href="/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf"
+				<li><a href="/tm/doc/TM_Use_Cases_v1.1c.pdf"
 					target="_self">TM Use Cases Document</a></li>
 				<li><a href="/tm/development/plan.php"
 					target="_self">TM Project Plan</a></li>
diff --git a/development/bug_process.php b/development/bug_process.php
index 5f7f1ff..d2e06f0 100644
--- a/development/bug_process.php
+++ b/development/bug_process.php
@@ -7,7 +7,7 @@
 	# Author: 		Martin Oberhuber
 	# Date:			2006-07-03
 	#
-	# Description: Bugzilla Process for the DSDP TM Project
+	# Description: Bugzilla Process for the TM Project
 	#
 	#
 	#****************************************************************************
@@ -15,7 +15,7 @@
 	#
 	# Begin: page-specific settings.  Change these. 
 	$pageTitle 		= "Target Management Bug Process";
-	$pageKeywords	= "DSDP, Target Management, Bugs, Process, Guidelines";
+	$pageKeywords	= "Device, Remote, Target Management, Bugs, Process, Guidelines";
 	$pageAuthor		= "Martin Oberhuber";
 	
 	# Add page-specific Nav bars here
@@ -353,8 +353,8 @@
 			contribution under the EPL.}
 		    </p>
 		If this message does not apply for you (e.g. because you did use 3rd party
-		materials), please contact the <a href="mailto:dsdp-tm-dev@exlipse.org">
-		dsdp-tm-dev@eclipse.org</a> Developer Mailing List to seek assistance of
+		materials), please contact the <a href="mailto:tm-dev@eclipse.org">
+		tm-dev@eclipse.org</a> Developer Mailing List to seek assistance of
 		a committer.<br/>
 		Once your contribution is attached to Bugzilla, a committer will pick it
 		up and follow the <a href="/tm/development/committer_howto.php#external_contrib">
@@ -364,7 +364,7 @@
 		
 		<h2>Testing, tips and tricks for bug finding</h2>
 		<ul>
-		  <li>The <a href="http://wiki.eclipse.org/DSDP/TM/Testing">
+		  <li>The <a href="http://wiki.eclipse.org/TM/Testing">
 		    TM Testing</a> page coordinates the TM Testing efforts.</li>
 		  <li>The <a href="http://wiki.eclipse.org/Field_Guide_to_Callisto_Bugs">
 		    Field Guide to Callisto Bugs</a> is also an interesting read.</li>
diff --git a/development/committer_guide.php b/development/committer_guide.php
index e86f192..d8a141c 100644
--- a/development/committer_guide.php
+++ b/development/committer_guide.php
@@ -7,7 +7,7 @@
 	# Author: 		Martin Oberhuber
 	# Date:			2006-05-10
 	#
-	# Description: Committer Guidelines for the DSDP TM Project
+	# Description: Committer Guidelines for the TM Project
 	#
 	#
 	#****************************************************************************
@@ -15,7 +15,7 @@
 	#
 	# Begin: page-specific settings.  Change these. 
 	$pageTitle 		= "TM Committer Guidelines";
-	$pageKeywords	= "DSDP, Target Management, Committer, Guidelines";
+	$pageKeywords	= "Device, Remote, Target Management, Committer, Guidelines";
 	$pageAuthor		= "Martin Oberhuber";
 	
 	# Add page-specific Nav bars here
diff --git a/development/committer_howto.php b/development/committer_howto.php
index 7b13847..4de4dab 100644
--- a/development/committer_howto.php
+++ b/development/committer_howto.php
@@ -7,7 +7,7 @@
 	# Author: 		Martin Oberhuber
 	# Date:			2006-05-23
 	#
-	# Description: Committer Howto for the DSDP TM Project
+	# Description: Committer Howto for the TM Project
 	#
 	#
 	#****************************************************************************
@@ -15,7 +15,7 @@
 	#
 	# Begin: page-specific settings.  Change these. 
 	$pageTitle 		= "TM Committer Howto";
-	$pageKeywords	= "DSDP, Target Management, Committer, Howto, Guidelines, IP";
+	$pageKeywords	= "Device, Remote, Target Management, Committer, Howto, Guidelines, IP";
 	$pageAuthor		= "Martin Oberhuber";
 	
 	# Add page-specific Nav bars here
@@ -58,7 +58,7 @@
 		  <li>Ensure that you have <a href="/tm/development/compiler_warnings.php">Compiler Warnings
 		      </a> switched on as recommended. For every file that you modify, please ensure that it
 		      compiles without warnings before you check it in.</li>
-		  <li>Keep the <a href="http://wiki.eclipse.org/DSDP/TM/Code_Ownership">
+		  <li>Keep the <a href="http://wiki.eclipse.org/TM/Code_Ownership">
 		  	  Code Ownership Page</a> up-to-date on the Wiki.</li>
 		  <li>Ideally, run <a href="http://www.jroller.com/andyl/entry/findbugs_update1">FindBugs 
 		      on your code to find additional issues.</li>
@@ -210,7 +210,7 @@
 		<h2>Add some legacy code to the project</h2>
 		<ul>
 		  <li>Obtain <b>PMC Member Approval</b>: Write an e-mail to 
-		      <a href="mailto:dsdp-pmc@eclipse.org">dsdp-pmc@eclipse.org</a>,
+		      <a href="mailto:tools-pmc@eclipse.org">tools-pmc@eclipse.org</a>,
 		      describing the intended contribution. Give the PMC an idea of how large the
 		      contribution is, what it is good for (cryptography?), and if there are 
 		      any other licenses than the EPL involved.</li>
@@ -247,8 +247,8 @@
 		    We now have scripts to count the lines of code in a contribution. Download
 		    any of the following:
 		    <ul>
-		      <li><a href="http://www.eclipse.org/downloads/download.php?file=/dsdp/tm/div/line_count_scripts-2.0RC1.tar">line_count_scripts-2.0RC1.tar</a>
-		      <li><a href="http://www.eclipse.org/downloads/download.php?file=/dsdp/tm/div/line_count_scripts-2.0RC1.zip">line_count_scripts-2.0RC1.zip</a>
+		      <li><a href="http://www.eclipse.org/downloads/download.php?file=/tm/div/line_count_scripts-2.0RC1.tar">line_count_scripts-2.0RC1.tar</a>
+		      <li><a href="http://www.eclipse.org/downloads/download.php?file=/tm/div/line_count_scripts-2.0RC1.zip">line_count_scripts-2.0RC1.zip</a>
 		    </ul>
 		    These scripts count all lines in either a patch or a list of directories,
 		    suppressing binary files and optionally also empty lines or lines containing
@@ -312,13 +312,13 @@
 		   project set manually. For the pserver version, you typically need to replace-all
 		   ":extssh:" by ":pserver:".
 		  </li>
-		  <li>Send an <b>E-mail</b> to dsdp-tm-dev, informing everybody that team project sets
+		  <li>Send an <b>E-mail</b> to tm-dev, informing everybody that team project sets
 		    have been updated with your new plugins.</li>
 		  <li>For <b>release engineering</b> purposes, it may be necessary to also reference your
 		      new plugins in an existing feature, add new features, modify Mapfiles
 		      and/or the ANT files for nightly builds in the project <tt>org.eclipse.rse.build</tt>.
 		      These tasks can all be accomplished by your build and release engineer, 
-		      so this is another reason for sending an <b>E-mail to dsdp-tm-dev</b> 
+		      so this is another reason for sending an <b>E-mail to tm-dev</b> 
 		      when you added a new plugin. 
 		</ul>
 
diff --git a/development/compiler_warnings.php b/development/compiler_warnings.php
index 5d84f67..049cae4 100644
--- a/development/compiler_warnings.php
+++ b/development/compiler_warnings.php
@@ -15,7 +15,7 @@
 	#
 	# Begin: page-specific settings.  Change these. 
 	$pageTitle 		= "Recommended Compiler Warnings";
-	$pageKeywords	= "DSDP, Target Management, Compiler, Warning, Quality, Guidelines";
+	$pageKeywords	= "Device, Remote, Target Management, Compiler, Warning, Quality, Guidelines";
 	$pageAuthor		= "Martin Oberhuber";
 	
 	# Add page-specific Nav bars here
diff --git a/development/contributors.php b/development/contributors.php
index e49cfbd..dcfd4c2 100644
--- a/development/contributors.php
+++ b/development/contributors.php
@@ -14,7 +14,7 @@
 	
 	#
 	# Begin: page-specific settings.  Change these. 
-	$pageTitle 		= "DSDP-TM Project Contributors";
+	$pageTitle 		= "TM Project Contributors";
 	$pageKeywords	= "device, target, contributor, committer, lead, author, developer";
 	$pageAuthor		= "Martin Oberhuber";
 	
@@ -36,14 +36,13 @@
 		<div class="homeitem3col">
 		<h3>Target Management Lead</h3>
 		<li><b>Martin Oberhuber, Wind River Systems</b> (martin.oberhuber at windriver.com)<br/>
-			Martin is the overall project lead for the Target Management Project,
-			and in this role he also serves on the DSDP Project Management Council (PMC).
+			Martin is the overall project lead for the Target Management Project.
 			As a software developer and architect, Martin is responsible for the
 			current Target Manager component in Wind River Workbench.<br/>
 			Martin holds an MS degree in Telematics from the University
 			of Technology Graz/Austria, and has been working on source code analysis
 			and tools development since 1999.<br/>
-			<a href="http://wiki.eclipse.org/User:Moberhuber">more about Martin Oberhuber &raquo;</a>
+			<a href="http://wiki.eclipse.org/Martin_Oberhuber">more about Martin Oberhuber &raquo;</a>
 			</li>
 		<li><b>David Dykstal, IBM</b> (david_dykstal at us.ibm.com)<br/>
 		 	David is the Project Lead for the IBM Remote System Explorer,
@@ -183,16 +182,14 @@
 		<div class="sideitem">
 			<h6>Getting started</h6>
 			<ul>				
-				<li><a href="http://www.eclipse.org/downloads/download.php?file=/dsdp/tm/presentations/2006-9-29_SummitEurope_TMOverview.pdf"
+				<li><a href="http://www.eclipse.org/downloads/download.php?file=/tm/presentations/2006-9-29_SummitEurope_TMOverview.pdf"
 					target="_self">TM Overview Slides</a></li>
 				<li><a href="http://www.eclipse.org/project-slides/TM_3.0_Release_Review.pdf" target="_self">
 				    TM 3.0 Release Review Slides</a></li>
-				<li><a href="http://www.eclipse.org/downloads/download.php?file=/dsdp/tm/presentations/TM_2.0_Release_Review.ppt" target="_self">
+				<li><a href="http://www.eclipse.org/downloads/download.php?file=/tm/presentations/TM_2.0_Release_Review.ppt" target="_self">
 				    TM 2.0 Release Review Slides</a></li>
-			    <li><a href="http://wiki.eclipse.org/DSDP" 
-			    	target="_self">DSDP Overview Diagrams</a></li>				
 				<li><a
-					href="/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf"
+					href="/tm/doc/TM_Use_Cases_v1.1c.pdf"
 					target="_self">TM Use Cases Document</a></li>
 				<!-- <li><a href="/tm/development/index.php">Developer Resources</a></li> -->
 				<li><a href="/tm/doc/index.php">Developer Documents</a></li>
diff --git a/development/cvs_setup.php b/development/cvs_setup.php
index d30b435..9ba01e3 100644
--- a/development/cvs_setup.php
+++ b/development/cvs_setup.php
@@ -15,7 +15,7 @@
 	#
 	# Begin: page-specific settings.  Change these. 
 	$pageTitle 		= "TM Repository and Team Project Sets";
-	$pageKeywords	= "DSDP, Target Management, Team, Development, Project Set, psf, workspace";
+	$pageKeywords	= "Device, Remote, Target Management, Team, Development, Project Set, psf, workspace";
 	$pageAuthor		= "Martin Oberhuber";
 	
 	# Add page-specific Nav bars here
@@ -171,7 +171,7 @@
 		<a name="notifications"></a>
 		<h2>Commit Notifications</h2>
 		<p>You can subscribe to the 
-		  <a href="https://dev.eclipse.org/mailman/listinfo/dsdp-tm-cvs-commit">dsdp-tm-cvs-commit</a>
+		  <a href="https://dev.eclipse.org/mailman/listinfo/tm-cvs-commit">tm-cvs-commit</a>
 		  mailing list to receive notification E-Mails for new checkins.</p>
 
 		<a name="cvsbackground"></a>
diff --git a/development/index.php b/development/index.php
index 6eb66b2..707bc08 100644
--- a/development/index.php
+++ b/development/index.php
@@ -7,7 +7,7 @@
 	# Author: 		Martin Oberhuber
 	# Date:			2006-02-10
 	#
-	# Description: DSDP-TM developer resources page
+	# Description: TM developer resources page
 	#
 	#
 	#****************************************************************************
@@ -53,7 +53,7 @@
 						A 
 						<a href="http://download.eclipse.org/tm/downloads/drops/N-changelog/index.html">
 						CVS Changelog</a> is available, and you can subscribe to commit notifications on
-						<a href="https://dev.eclipse.org/mailman/listinfo/dsdp-tm-cvs-commit">dsdp-tm-cvs-commit</a>.</li>
+						<a href="https://dev.eclipse.org/mailman/listinfo/tm-cvs-commit">tm-cvs-commit</a>.</li>
 					<li><a href="/tm/development/bug_process.php" target="_self"><b>Bug Process</b></a><br> 
 					   View <a href="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&product=Target+Management&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&cmdtype=doit">all open</a> issues
 					   | <a target="_top" href="https://bugs.eclipse.org/bugs/enter_bug.cgi?product=Target%20Management&version=unspecified&component=RSE">Submit new</a> bugs
@@ -113,11 +113,11 @@
 						Coding standards, naming conventions, and other
 						guidelines used by the Platform. TM will use these conventions
 						until such time as deviation is required.</li>
-			    	<li><b><a href="http://www.eclipse.org/downloads/download.php?file=/dsdp/tm/presentations/2006-9-29_SummitEurope_TMOverview.pdf">
+			    	<li><b><a href="http://www.eclipse.org/downloads/download.php?file=/tm/presentations/2006-9-29_SummitEurope_TMOverview.pdf">
 						Architectural Overview</a></b><br>
 						A high level summary of the components and their architecture.</li>
 					<li><b><a
-							href="http://www.eclipse.org/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf">Project
+							href="http://www.eclipse.org/tm/doc/TM_Use_Cases_v1.1c.pdf">Project
 						Requirements</a></b> <br>
 						Look here for a list of the project use cases and their
 						priorities.</li>
@@ -140,16 +140,14 @@
 		<div class="sideitem">
 			<h6>Getting started</h6>
 			<ul>				
-				<li><a href="http://www.eclipse.org/downloads/download.php?file=/dsdp/tm/presentations/2006-9-29_SummitEurope_TMOverview.pdf"
+				<li><a href="http://www.eclipse.org/downloads/download.php?file=/tm/presentations/2006-9-29_SummitEurope_TMOverview.pdf"
 					target="_self">TM Overview Slides</a></li>
 				<li><a href="http://www.eclipse.org/project-slides/TM_3.0_Release_Review.pdf" target="_self">
 				    TM 3.0 Release Review Slides</a></li>
-				<li><a href="http://www.eclipse.org/downloads/download.php?file=/dsdp/tm/presentations/TM_2.0_Release_Review.ppt" target="_self">
+				<li><a href="http://www.eclipse.org/downloads/download.php?file=/tm/presentations/TM_2.0_Release_Review.ppt" target="_self">
 				    TM 2.0 Release Review Slides</a></li>
-			    <li><a href="http://wiki.eclipse.org/DSDP" 
-			    	target="_top">DSDP Overview Diagrams</a></li>				
 				<li><a
-					href="/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf"
+					href="/tm/doc/TM_Use_Cases_v1.1c.pdf"
 					target="_top">TM Use Cases Document</a></li>
 				<!-- <li><a href="/tm/development/index.php">Developer Resources</a></li> -->
 				<li><a href="/tm/doc/index.php">Developer Documents</a></li>
diff --git a/development/plan.php b/development/plan.php
index 909945a..5c0f867 100644
--- a/development/plan.php
+++ b/development/plan.php
@@ -7,7 +7,7 @@
 	# Author: 		Martin Oberhuber
 	# Date:			2006-02-10
 	#
-	# Description: DSDP-TM project plans
+	# Description: TM project plans
 	#
 	#
 	#****************************************************************************
@@ -64,7 +64,7 @@
         TM Future Planning Wiki</a><br>
         Plan Incubator Wiki, holding ideas for future releases. 
       </li>
-      <li><a href="http://wiki.eclipse.org/DSDP/TM"> DSDP/TM Wiki</a><br>
+      <li><a href="http://wiki.eclipse.org/TM">TM Wiki</a><br>
     	Target Management Wiki, linking to Technology Sub-Groups for breeding future ideas. </li>
     </ul>
       	</div>
@@ -74,7 +74,7 @@
 	<li><a href="/tm/development/">
 		TM Development Home Page</a><br>
 		Main page for Target Management Development Resources.</li>
-	<li><a href="/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf">
+	<li><a href="/tm/doc/TM_Use_Cases_v1.1c.pdf">
     	Target Management Use Cases Document</a><br>
     	Requirements: Target Management Use Cases - dated but still current.</li>
 	<li><a href="/tm/doc/index.php">
diff --git a/development/relnotes/2.0/readme_tm_2.0.html b/development/relnotes/2.0/readme_tm_2.0.html
index c02cf9f..5dd42fd 100644
--- a/development/relnotes/2.0/readme_tm_2.0.html
+++ b/development/relnotes/2.0/readme_tm_2.0.html
@@ -3,12 +3,12 @@
 
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<title>DSDP-TM Release Notes 2.0.2</title>
+<title>TM Release Notes 2.0.2</title>
 </head>
 
 <body>
 
-<h1>DSDP Target Management Release Notes</h1>
+<h1>Target Management Release Notes</h1>
 <p>Release 2.0.3<br/>
 Last revised February 25, 2008</p>
 
diff --git a/development/relnotes/2.0/tm-news-2.0.html b/development/relnotes/2.0/tm-news-2.0.html
index e665e11..5bbab8c 100644
--- a/development/relnotes/2.0/tm-news-2.0.html
+++ b/development/relnotes/2.0/tm-news-2.0.html
@@ -4,10 +4,10 @@
 <meta http-equiv="Content-Language" content="en-us" />
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
 <link rel="stylesheet" href="http://www.eclipse.org/default_style.css" type="text/css"/>
-<title>DSDP-TM 2.0 News</title>
+<title>TM 2.0 News</title>
 </head>
 <body>
-<h1>DSDP Target Management 2.0 - New and Noteworthy</h1>
+<h1>Target Management 2.0 - New and Noteworthy</h1>
 <p>The emphasis on the TM 2.0 release has been API polish and cleanup,
   so there are not too many new features to mention. Still, here are 
   some of the more noteworthy things you'll find in TM 2.0 (June 27, 2007)
diff --git a/development/relnotes/3.0/readme_tm_3.0.html b/development/relnotes/3.0/readme_tm_3.0.html
index 99977ee..89cbadb 100644
--- a/development/relnotes/3.0/readme_tm_3.0.html
+++ b/development/relnotes/3.0/readme_tm_3.0.html
@@ -3,12 +3,12 @@
 
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<title>DSDP-TM Release Notes 3.0.3</title>
+<title>TM Release Notes 3.0.3</title>
 </head>
 
 <body>
 
-<h1>DSDP Target Management Release Notes</h1>
+<h1>Target Management Project Release Notes</h1>
 <p>Release 3.0.3<br/>
 Last revised February 18, 2009</p>
 
@@ -47,7 +47,7 @@
 
 <h2>TM Release 3.0</h2>
 <p>
-The DSDP Target Management Project has been focused on internal API Review,
+The Target Management Project has been focused on internal API Review,
 Cleanup, Refactoring and Performance improvements for the Ganymede release,
 but there's still some exciting news:
 <ul>
diff --git a/development/relnotes/3.0/tm-news-3.0.html b/development/relnotes/3.0/tm-news-3.0.html
index 7ae9815..ee27fdd 100644
--- a/development/relnotes/3.0/tm-news-3.0.html
+++ b/development/relnotes/3.0/tm-news-3.0.html
@@ -4,10 +4,10 @@
 <meta http-equiv="Content-Language" content="en-us" />
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
 <link rel="stylesheet" href="http://www.eclipse.org/default_style.css" type="text/css"/>
-<title>DSDP-TM 3.0 News</title>
+<title>TM 3.0 News</title>
 </head>
 <body>
-<h1>DSDP Target Management 3.0 - New and Noteworthy</h1>
+<h1>Target Management 3.0 - New and Noteworthy</h1>
 <p>The emphasis on the TM 3.0 release has been API polish, cleanup
   and performance improvements,
   so there are not too many new features to mention. Still, here are 
diff --git a/development/relnotes/3.1/readme_tm_3.1.html b/development/relnotes/3.1/readme_tm_3.1.html
index 3447deb..4f174d8 100644
--- a/development/relnotes/3.1/readme_tm_3.1.html
+++ b/development/relnotes/3.1/readme_tm_3.1.html
@@ -3,11 +3,11 @@
 
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<title>DSDP-TM Release Notes 3.1.1</title>
+<title>TM Release Notes 3.1.1</title>
 </head>
 
 <body>
-<h1>DSDP Target Management Release Notes</h1>
+<h1>Target Management Project Release Notes</h1>
 <p>Release 3.1.2<br/>
 Last revised Feb 26, 2010</p>
 
@@ -44,7 +44,7 @@
 See the <a href="http://www.eclipse.org/tm/development/relnotes/3.1/tm-news-3.1.html">TM 3.1 New &amp; Noteworthy</a> for new features<br/> 
 See the <a href="http://www.eclipse.org/projects/project-plan.php?projectid=dsdp.tm">TM 3.1 Project Plan</a>
       for supported operating environments<br/>
-See the <a href="http://wiki.eclipse.org/DSDP/TM/3.1_Known_Issues_and_Workarounds">TM 3.1 Known Issues and Workarounds</a> Wiki for known problems.<br/>
+See the <a href="http://wiki.eclipse.org/TM/3.1_Known_Issues_and_Workarounds">TM 3.1 Known Issues and Workarounds</a> Wiki for known problems.<br/>
   <!--  <li>See the <a href="">TM 3.1 Migration</a> Wiki for migration info</li> -->
 </p><p>
 Some amendments to API specifications are worth noticing, and may require changes 
diff --git a/development/relnotes/3.1/tm-news-3.1.html b/development/relnotes/3.1/tm-news-3.1.html
index 266fcf7..b1a5359 100644
--- a/development/relnotes/3.1/tm-news-3.1.html
+++ b/development/relnotes/3.1/tm-news-3.1.html
@@ -4,10 +4,10 @@
 <meta http-equiv="Content-Language" content="en-us" />
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
 <link rel="stylesheet" href="http://www.eclipse.org/default_style.css" type="text/css"/>
-<title>DSDP-TM 3.1 News</title>
+<title>TM 3.1 News</title>
 </head>
 <body>
-<h1>DSDP Target Management 3.1 - New and Noteworthy</h1>
+<h1>Target Management 3.1 - New and Noteworthy</h1>
 <p>The emphasis on the <a href="http://www.eclipse.org/tm/tutorial/">Target Management 3.1</a>
   release has been on solidifying and hardening existing functionality,
   so there are not too many new features to mention. Still, here are 
diff --git a/development/relnotes/3.2/readme_tm_3.2.html b/development/relnotes/3.2/readme_tm_3.2.html
index c83d68b..5ad78e6 100644
--- a/development/relnotes/3.2/readme_tm_3.2.html
+++ b/development/relnotes/3.2/readme_tm_3.2.html
@@ -3,11 +3,11 @@
 
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<title>DSDP-TM Release Notes 3.2</title>
+<title>TM Release Notes 3.2</title>
 </head>
 
 <body>
-<h1>DSDP Target Management Release Notes</h1>
+<h1>Target Management Project Release Notes</h1>
 <p>Release 3.2.1<br/>
 Last revised Sep 24, 2010</p>
 
@@ -27,14 +27,14 @@
 129 unique bugs were addressed in the TM 3.2 release, including 4 API change requests.<br/>
 See <a href="https://bugs.eclipse.org/bugs/report.cgi?x_axis_field=target_milestone&y_axis_field=bug_severity&z_axis_field=&query_format=report-table&short_desc_type=allwordssubstr&short_desc=&product=Target+Management&component=Core&component=RSE&component=TCF&component=Terminal&target_milestone=3.2&target_milestone=3.2+M2&target_milestone=3.2+M3&target_milestone=3.2+M4&target_milestone=3.2+M5&target_milestone=3.2+M6&target_milestone=3.2+M7&target_milestone=3.2+RC1&target_milestone=3.2+RC2&target_milestone=3.2+RC3&target_milestone=3.2+RC4&longdesc_type=allwordssubstr&longdesc=&bug_file_loc_type=allwordssubstr&bug_file_loc=&status_whiteboard_type=allwordssubstr&status_whiteboard=&keywords_type=allwords&keywords=&bug_status=RESOLVED&bug_status=VERIFIED&bug_status=CLOSED&emailtype1=substring&email1=&emailtype2=substring&email2=&bugidtype=include&bug_id=&votes=&chfieldfrom=&chfieldto=Now&chfieldvalue=&format=table&action=wrap&field0-0-0=noop&type0-0-0=noop&value0-0-0=">this report</a> 
 for details on all bugs, and 
-<a href="https://bugs.eclipse.org/bugs/buglist.cgi?keywords=api;query_format=advanced;keywords_type=allwords;component=Core;component=RSE;component=TCF;component=Terminal;resolution=FIXED;target_milestone=3.2;target_milestone=3.2%20M2;target_milestone=3.2%20M3;target_milestone=3.2%20M4;target_milestone=3.2%20M5;target_milestone=3.2%20M6;target_milestone=3.2%20M7;target_milestone=3.2%20RC1;target_milestone=3.2%20RC2;target_milestone=3.2%20RC3;target_milestone=3.2%20RC4;product=Target%20Management;classification=DSDP">this list</a>
+<a href="https://bugs.eclipse.org/bugs/buglist.cgi?keywords=api;query_format=advanced;keywords_type=allwords;component=Core;component=RSE;component=TCF;component=Terminal;resolution=FIXED;target_milestone=3.2;target_milestone=3.2%20M2;target_milestone=3.2%20M3;target_milestone=3.2%20M4;target_milestone=3.2%20M5;target_milestone=3.2%20M6;target_milestone=3.2%20M7;target_milestone=3.2%20RC1;target_milestone=3.2%20RC2;target_milestone=3.2%20RC3;target_milestone=3.2%20RC4;product=Target%20Management">this list</a>
 for new API introduced.
 </p><p>
 See the <a href="http://www.eclipse.org/tm/development/relnotes/3.2/tm-news-3.2.html">TM 3.2 New &amp; Noteworthy</a> for new features<br/> 
-See the <a href="http://wiki.eclipse.org/DSDP/TM/3.2_Release_Summary">TM 3.2 Release Summary</a> for statistics and interesting data about the project<br/>
+See the <a href="http://wiki.eclipse.org/TM/3.2_Release_Summary">TM 3.2 Release Summary</a> for statistics and interesting data about the project<br/>
 See the <a href="http://www.eclipse.org/projects/project-plan.php?projectid=dsdp.tm">TM 3.2 Project Plan</a>
       for supported operating environments<br/>
-See the <a href="http://wiki.eclipse.org/DSDP/TM/3.2_Known_Issues_and_Workarounds">TM 3.2 Known Issues and Workarounds</a> Wiki for known problems.<br/>
+See the <a href="http://wiki.eclipse.org/TM/3.2_Known_Issues_and_Workarounds">TM 3.2 Known Issues and Workarounds</a> Wiki for known problems.<br/>
   <!--  <li>See the <a href="">TM 3.2 Migration</a> Wiki for migration info</li> -->
 </p>
 <p><b>TM 3.2 API Specification Updates</b>
diff --git a/development/relnotes/3.2/tm-news-3.2.html b/development/relnotes/3.2/tm-news-3.2.html
index d7b615c..5a50e94 100644
--- a/development/relnotes/3.2/tm-news-3.2.html
+++ b/development/relnotes/3.2/tm-news-3.2.html
@@ -4,10 +4,10 @@
 <meta http-equiv="Content-Language" content="en-us" />
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
 <link rel="stylesheet" href="http://www.eclipse.org/default_style.css" type="text/css"/>
-<title>DSDP-TM 3.2 News</title>
+<title>TM 3.2 News</title>
 </head>
 <body>
-<h1>DSDP Target Management 3.2 - New and Noteworthy</h1>
+<h1>Target Management 3.2 - New and Noteworthy</h1>
 <p>The emphasis on the <a href="http://www.eclipse.org/tm/tutorial/">Target Management 3.2</a>
   release has been on solidifying and hardening existing functionality,
   so there are not too many new features to mention. Still, here are 
@@ -86,7 +86,7 @@
     <td width="30%" valign="top" align="left"><b>TCF Improvements </b></td>
     <td width="70%" valign="top"> TCF Improvements are tracked on the TM Wiki.
        For details, see
-       <a href="http://wiki.eclipse.org/DSDP/TM/3.2_Release_Summary#Executive_Summary">The TM Release Summary</a>.
+       <a href="http://wiki.eclipse.org/TM/3.2_Release_Summary#Executive_Summary">The TM Release Summary</a>.
     </td>  
   </tr>
   <tr>
diff --git a/development/tm_plan_3_0.xml b/development/tm_plan_3_0.xml
index fd94053..b89783a 100644
--- a/development/tm_plan_3_0.xml
+++ b/development/tm_plan_3_0.xml
Binary files differ
diff --git a/development/tm_plan_3_1.xml b/development/tm_plan_3_1.xml
index 73026f5..3ab23c7 100644
--- a/development/tm_plan_3_1.xml
+++ b/development/tm_plan_3_1.xml
Binary files differ
diff --git a/development/tm_plan_3_2.xml b/development/tm_plan_3_2.xml
index eac6d0d..5cea3ab 100644
--- a/development/tm_plan_3_2.xml
+++ b/development/tm_plan_3_2.xml
Binary files differ
diff --git a/development/tm_plan_3_3.xml b/development/tm_plan_3_3.xml
index 22c384e..444d8fc 100644
--- a/development/tm_plan_3_3.xml
+++ b/development/tm_plan_3_3.xml
Binary files differ
diff --git a/development/tm_project_plan_1_0.html b/development/tm_project_plan_1_0.html
index b7451e7..e98aa6d 100644
--- a/development/tm_project_plan_1_0.html
+++ b/development/tm_project_plan_1_0.html
@@ -4,12 +4,12 @@
 <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
 <meta name="Author" content="Martin Oberhuber">
 <meta name="Keywords" content="development,project,plan,device,target,embedded,communication">
-<title>DSDP - Target Management 1.0 Plan</title>
+<title>Target Management 1.0 Plan</title>
 <link rel="stylesheet" href="../../default_style.css" type="text/css">
 </head>
 <body>
 
-<h1>DSDP - Target Management 1.0 Plan</h1>
+<h1>Target Management 1.0 Plan</h1>
 
 <p>Last revised 11:00 CEST Oct 23, 2006 (
 <img src="new.gif" alt="(new)" border="0" height="12" width="12"/>
@@ -24,10 +24,10 @@
 the </i><a href="mailto:dsdp-tm-dev@eclipse.org">dsdp-tm-dev@eclipse.org</a> <i>developer
 mailing list.</i></p>
 <p>This document lays out the feature and API set for the initial
-release of the Eclipse DSDP - Target Management Project, 
+release of the Eclipse Target Management Project, 
 <b>Remote System Explorer (RSE) version 1.0.0</b>.</p>
 <p>The Remote System Explorer is a Tool and Framework for working with 
-remote computer systems. It forms the first release out of the DSDP - 
+remote computer systems. It forms the first release out of the
 Target Management Project, to be augmented by additional plug-ins for device
 specific connection schemes and tasks in the future.</p> 
 <ul>
diff --git a/development/tm_project_plan_2_0.html b/development/tm_project_plan_2_0.html
index 6b1b910..0ded2c5 100644
--- a/development/tm_project_plan_2_0.html
+++ b/development/tm_project_plan_2_0.html
@@ -4,12 +4,12 @@
 <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
 <meta name="Author" content="Martin Oberhuber">
 <meta name="Keywords" content="development,project,plan,device,target,embedded,communication">
-<title>DSDP - Target Management 2.0 Plan</title>
+<title>Target Management 2.0 Plan</title>
 <link rel="stylesheet" href="../../default_style.css" type="text/css">
 </head>
 <body>
 
-<h1>DSDP - Target Management 2.0 Plan</h1>
+<h1>Target Management 2.0 Plan</h1>
 
 <p>Last revised 16:20 CEST Jul 11, 2007
 (<img src="new.gif" alt="(new)" border="0" height="12" width="12"/>
@@ -23,7 +23,7 @@
 the </i><a href="mailto:dsdp-tm-dev@eclipse.org">dsdp-tm-dev@eclipse.org</a> <i>developer
 mailing list.</i></p>
 <p>This document lays out the feature and API set for the
-next feature release of the DSDP Target Management Project
+next feature release of the Target Management Project
 after RSE 1.0, designated TM release 2.0.
 </p>
 <ul>
@@ -402,8 +402,8 @@
 <h2><a name="Features">Features and Capabilities</a></h2>
 <p>Plan items listed bleow were defined according to contributor requirements,
 but in accordance with the Target Management
-<a href="http://www.eclipse.org/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf">
-Use Cases Document</a> and the DSDP and Eclipse
+<a href="http://www.eclipse.org/tm/doc/TM_Use_Cases_v1.1c.pdf">
+Use Cases Document</a> and the Eclipse
 <a href="http://wiki.eclipse.org/RequirementsCouncil06TP#Embedded_Device_Software">
 Themes and Priorities</a> (Preliminary Roadmap v3)
 set forth by the Eclipse Requirments Council.
@@ -471,7 +471,7 @@
 
 <p><strong>Improve Discovery and Autodetect in RSE.</strong>
 Support the use cases defined by the 
-<a href="http://wiki.eclipse.org/DSDP/TM/Autodetect">
+<a href="http://wiki.eclipse.org/TM/Autodetect">
 Autodetect Group</a>, namely finding remote systems such that
 they can be added as RSE connections; and finding services on those
 systems and registering them with RSE connections. A single RSE
diff --git a/development/tm_project_plan_3_0.html b/development/tm_project_plan_3_0.html
index 4ecacc0..48747c3 100644
--- a/development/tm_project_plan_3_0.html
+++ b/development/tm_project_plan_3_0.html
@@ -4,12 +4,12 @@
 <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
 <meta name="Author" content="Martin Oberhuber">
 <meta name="Keywords" content="development,project,plan,device,target,embedded,communication">
-<title>DSDP - Target Management 3.0 Plan</title>
+<title>Target Management 3.0 Plan</title>
 <link rel="stylesheet" href="../../default_style.css" type="text/css">
 </head>
 <body>
 
-<h1>DSDP - Target Management 3.0 Plan</h1>
+<h1>Target Management 3.0 Plan</h1>
 
 <p>Last revised 22:00 CET Oct 11, 2007
 <!--
@@ -25,7 +25,7 @@
 the </i><a href="mailto:dsdp-tm-dev@eclipse.org">dsdp-tm-dev@eclipse.org</a> <i>developer
 mailing list.</i></p>
 <p>This document lays out the feature and API set for the
-next feature release of the DSDP Target Management Project
+next feature release of the Target Management Project
 after TM 2.0, designated TM release 3.0.
 </p>
 <ul>
@@ -408,8 +408,8 @@
 <h2><a name="Features">Features and Capabilities</a></h2>
 <p>Plan items listed bleow were defined according to contributor requirements,
 but in accordance with the Target Management
-<a href="http://www.eclipse.org/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf">
-Use Cases Document</a> and the DSDP and Eclipse
+<a href="http://www.eclipse.org/tm/doc/TM_Use_Cases_v1.1c.pdf">
+Use Cases Document</a> and the Eclipse
 <a href="http://wiki.eclipse.org/RequirementsCouncil06TP#Embedded_Device_Software">
 Themes and Priorities</a> (Preliminary Roadmap v3)
 set forth by the Eclipse Requirments Council.
@@ -477,7 +477,7 @@
 
 <p><strong>Improve Discovery and Autodetect in RSE.</strong>
 Support the use cases defined by the 
-<a href="http://wiki.eclipse.org/DSDP/TM/Autodetect">
+<a href="http://wiki.eclipse.org/TM/Autodetect">
 Autodetect Group</a>, namely finding remote systems such that
 they can be added as RSE connections; and finding services on those
 systems and registering them with RSE connections. A single RSE
diff --git a/doc/DSDPTM_Use_Cases_v1.1c.pdf b/doc/TM_Use_Cases_v1.1c.pdf
similarity index 100%
rename from doc/DSDPTM_Use_Cases_v1.1c.pdf
rename to doc/TM_Use_Cases_v1.1c.pdf
Binary files differ
diff --git a/doc/index.php b/doc/index.php
index d4d0450..f675e15 100644
--- a/doc/index.php
+++ b/doc/index.php
@@ -36,7 +36,7 @@
 
     	<h2>Use Cases (your best bet to get started!)</h2>
     	<ul>
-    	<li><a href="/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf">DSDP-TM Use Cases v1.1c.pdf</a></li>
+    	<li><a href="/tm/doc/TM_Use_Cases_v1.1c.pdf">DSDP-TM Use Cases v1.1c.pdf</a></li>
     	<li><a href="/tm/doc/nucleus_edge_target_usecase.pdf">nucleus edge target usecase.pdf</a></li>
     	</ul>
 
@@ -118,7 +118,7 @@
 			    <li><a href="http://wiki.eclipse.org/DSDP" 
 			    	target="_self">DSDP Overview Diagrams</a></li>				
 				<li><a
-					href="/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf"
+					href="/tm/doc/TM_Use_Cases_v1.1c.pdf"
 					target="_self">TM Use Cases Document</a></li>
 				<!-- <li><a href="/tm/development/index.php">Developer Resources</a></li> -->
 				<li><a href="/tm/development/plan.php"
diff --git a/downloads.php b/downloads.php
index 0528f00..aad1f9a 100644
--- a/downloads.php
+++ b/downloads.php
@@ -66,7 +66,7 @@
 			    <li><a href="http://wiki.eclipse.org/DSDP" 
 			    	target="_self">DSDP Overview Diagrams</a></li>				
 				<li><a
-					href="/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf"
+					href="/tm/doc/TM_Use_Cases_v1.1c.pdf"
 					target="_self">TM Use Cases Document</a></li>
 				<!-- <li><a href="/tm/development/index.php">Developer Resources</a></li> -->
 				<li><a href="/tm/doc/index.php">Developer Documents</a></li>
diff --git a/index.php b/index.php
index 226763e..3ee6b18 100644
--- a/index.php
+++ b/index.php
@@ -112,7 +112,7 @@
 					   | <a target="_top" href="https://bugs.eclipse.org/bugs/enter_bug.cgi?product=Target%20Management&version=unspecified&component=RSE">Submit new</a> bugs
 					   | Request an <a target="_top" href="https://bugs.eclipse.org/bugs/enter_bug.cgi?product=Target%20Management&version=unspecified&component=RSE&rep_platform=All&op_sys=All&priority=P3&bug_severity=enhancement&form_name=enter_bug">enhancement</a>
 					</li>
-					<li><a href="/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf"><b>Use cases</b></a> and requirements for Target Management</a></li>
+					<li><a href="/tm/doc/TM_Use_Cases_v1.1c.pdf"><b>Use cases</b></a> and requirements for Target Management</a></li>
 			    	<li><a href="http://www.eclipse.org/downloads/download.php?file=/dsdp/tm/presentations/2006-9-29_SummitEurope_TMOverview.pdf">
       					<b>Architectural Overview</b></a>
     	  				(<a href="http://www.eclipse.org/downloads/download.php?file=/dsdp/tm/presentations/2006-9-29_SummitEurope_TMOverview.ppt">PPT</a>
@@ -195,7 +195,7 @@
 				<li><a href="http://dsdp.eclipse.org/help/latest/index.jsp?topic=/org.eclipse.rse.doc.user/gettingstarted/g_start.html"
 					target="_self">TM 3.0 Tutorial</a></li>
 				<li><a
-					href="/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf"
+					href="/tm/doc/TM_Use_Cases_v1.1c.pdf"
 					target="_self">TM Use Cases</a></li>
 				<li><a href="/tm/development/plan.php">TM Project Plan</a></li>
 			</ul>
diff --git a/tm-new/about/index.php b/tm-new/about/index.php
index fef02ad..92fcfe9 100644
--- a/tm-new/about/index.php
+++ b/tm-new/about/index.php
@@ -83,7 +83,7 @@
     	<li><a href="http://wiki.eclipse.org/DSDP">
       		DSDP Top-Level Overview Diagrams</a> to understand how the Target Management
       		Project fits into DSDP, and what its basic building blocks are.</li> 
-    	<li><a href="/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf">
+    	<li><a href="/tm/doc/TM_Use_Cases_v1.1c.pdf">
       		Target Management Use-Case Document</a> 
       		to understand what scenarios we want to cover with our project.</li>
 		<li><a href="/tm/development/plan.php">
@@ -107,7 +107,7 @@
 				    TM 2.0 Release Review Slides</a></li>
 			    <li><a href="http://wiki.eclipse.org/DSDP" 
 			    	target="_self">DSDP Overview Diagrams</a></li>				
-				<li><a href="/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf"
+				<li><a href="/tm/doc/TM_Use_Cases_v1.1c.pdf"
 					target="_self">TM Use Cases Document</a></li>
 				<li><a href="/tm/development/plan.php"
 					target="_self">TM Project Plan</a></li>
diff --git a/tm-new/downloads/index.php b/tm-new/downloads/index.php
index 0528f00..aad1f9a 100755
--- a/tm-new/downloads/index.php
+++ b/tm-new/downloads/index.php
@@ -66,7 +66,7 @@
 			    <li><a href="http://wiki.eclipse.org/DSDP" 
 			    	target="_self">DSDP Overview Diagrams</a></li>				
 				<li><a
-					href="/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf"
+					href="/tm/doc/TM_Use_Cases_v1.1c.pdf"
 					target="_self">TM Use Cases Document</a></li>
 				<!-- <li><a href="/tm/development/index.php">Developer Resources</a></li> -->
 				<li><a href="/tm/doc/index.php">Developer Documents</a></li>
diff --git a/tm-new/index.php b/tm-new/index.php
index b95d120..3584999 100644
--- a/tm-new/index.php
+++ b/tm-new/index.php
@@ -53,7 +53,7 @@
 					| Request an <a target="_top" href="https://bugs.eclipse.org/bugs/enter_bug.cgi?product=Target%20Management&version=unspecified&component=RSE&rep_platform=All&op_sys=All&priority=P3&bug_severity=enhancement&form_name=enter_bug">enhancement</a>
 				</li>
 				<li>
-					<a href="/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf"><b>Use cases</b></a> and requirements for Target Management
+					<a href="/tm/doc/TM_Use_Cases_v1.1c.pdf"><b>Use cases</b></a> and requirements for Target Management
 				</li>
 			    <li>
 			    	<a href="http://www.eclipse.org/downloads/download.php?file=/dsdp/tm/presentations/2006-9-29_SummitEurope_TMOverview.pdf"><b>Architectural Overview</b></a>
diff --git a/tm-new/team/index.php b/tm-new/team/index.php
index 5cf1b07..563db95 100644
--- a/tm-new/team/index.php
+++ b/tm-new/team/index.php
@@ -131,7 +131,7 @@
 			    <li><a href="http://wiki.eclipse.org/DSDP" 
 			    	target="_self">DSDP Overview Diagrams</a></li>				
 				<li><a
-					href="/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf"
+					href="/tm/doc/TM_Use_Cases_v1.1c.pdf"
 					target="_self">TM Use Cases Document</a></li>
 				<!-- <li><a href="/tm/development/index.php">Developer Resources</a></li> -->
 				<li><a href="/tm/doc/index.php">Developer Documents</a></li>
diff --git a/tm-new/tutorial/index.php b/tm-new/tutorial/index.php
index cf18768..1884fdc 100644
--- a/tm-new/tutorial/index.php
+++ b/tm-new/tutorial/index.php
@@ -77,7 +77,7 @@
 	<p>
 	Our plans beyond TM 2.0 are available from the
     Target Management <a href="/tm/development/plan.php">Project Plan
-    </a> and our <a href="/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf">
+    </a> and our <a href="/tm/doc/TM_Use_Cases_v1.1c.pdf">
     Use Cases Document</a>, which covers all areas of interest to us.</p>
     
 	  <div class="homeitem3col">
@@ -113,7 +113,7 @@
     	<li><a href="http://wiki.eclipse.org/DSDP">
       		DSDP Top-Level Overview Diagrams</a> to understand how the Target Management
       		Project fits into DSDP, and what its basic building blocks are.</li> 
-    	<li><a href="/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf">
+    	<li><a href="/tm/doc/TM_Use_Cases_v1.1c.pdf">
       		Target Management Use-Case Document</a> 
       		to understand what scenarios we want to cover with our project.</li>
 		<li><a href="/tm/development/plan.php">
@@ -135,7 +135,7 @@
 				    TM 2.0 Release Review Slides</a></li>
 			    <li><a href="http://wiki.eclipse.org/DSDP" 
 			    	target="_self">DSDP Overview Diagrams</a></li>				
-				<li><a href="/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf"
+				<li><a href="/tm/doc/TM_Use_Cases_v1.1c.pdf"
 					target="_self">TM Use Cases Document</a></li>
 				<li><a href="http://dsdp.eclipse.org/help/latest/index.jsp?topic=/org.eclipse.rse.doc.user/gettingstarted/g_start.html"
 					target="_self">TM 2.0 Tutorial</a></li>
diff --git a/tutorial/index.php b/tutorial/index.php
index 4b2a72c..ca2b5a9 100644
--- a/tutorial/index.php
+++ b/tutorial/index.php
@@ -79,7 +79,7 @@
     <p>
 	Our plans beyond TM 3.0 are available from the
     Target Management <a href="/tm/development/plan.php">Project Plan
-    </a> and our <a href="/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf">
+    </a> and our <a href="/tm/doc/TM_Use_Cases_v1.1c.pdf">
     Use Cases Document</a>, which covers all areas of interest to us.</p>
     
 	  <div class="homeitem3col">
@@ -115,7 +115,7 @@
     	<li><a href="http://wiki.eclipse.org/DSDP">
       		DSDP Top-Level Overview Diagrams</a> to understand how the Target Management
       		Project fits into DSDP, and what its basic building blocks are.</li> 
-    	<li><a href="/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf">
+    	<li><a href="/tm/doc/TM_Use_Cases_v1.1c.pdf">
       		Target Management Use-Case Document</a> 
       		to understand what scenarios we want to cover with our project.</li>
 		<li><a href="/tm/development/plan.php">
@@ -139,7 +139,7 @@
 				    TM 2.0 Release Review Slides</a></li>
 			    <li><a href="http://wiki.eclipse.org/DSDP" 
 			    	target="_self">DSDP Overview Diagrams</a></li>				
-				<li><a href="/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf"
+				<li><a href="/tm/doc/TM_Use_Cases_v1.1c.pdf"
 					target="_self">TM Use Cases Document</a></li>
 				<li><a href="http://dsdp.eclipse.org/help/latest/index.jsp?topic=/org.eclipse.rse.doc.user/gettingstarted/g_start.html"
 					target="_self">TM 3.0 Tutorial</a></li>
