diff --git a/Nuclex.Support (PC).csproj b/Nuclex.Support (PC).csproj
index 4a20885..517e18a 100644
--- a/Nuclex.Support (PC).csproj	
+++ b/Nuclex.Support (PC).csproj	
@@ -144,6 +144,10 @@
       <XNAUseContentPipeline>false</XNAUseContentPipeline>
       <Name>ObservedProgression</Name>
     </Compile>
+    <Compile Include="Source\Tracking\ProgressionTracker.cs">
+      <XNAUseContentPipeline>false</XNAUseContentPipeline>
+      <Name>ProgressionTracker</Name>
+    </Compile>
     <Compile Include="Source\Tracking\SetProgression.cs">
       <XNAUseContentPipeline>false</XNAUseContentPipeline>
       <Name>SetProgression</Name>
diff --git a/Source/Collections/TransformingReadOnlyCollection.cs b/Source/Collections/TransformingReadOnlyCollection.cs
index 567aabe..a74e1da 100644
--- a/Source/Collections/TransformingReadOnlyCollection.cs
+++ b/Source/Collections/TransformingReadOnlyCollection.cs
@@ -6,13 +6,29 @@ using System.Threading;
 
 namespace Nuclex.Support.Collections {
 
-  /// <summary>Collection transforming the contents of another collection.</summary>
+  /// <summary>Collection that transforms the contents of another collection.</summary>
   /// <typeparam name="ContainedItemType">
   ///   Type of the items contained in the wrapped collection.
   /// </typeparam>
   /// <typeparam name="ExposedItemType">
   ///   Type this collection exposes its items as.
   /// </typeparam>
+  /// <remarks>
+  ///   <para>
+  ///     This collection is useful if you want to expose the objects of an arbitrary
+  ///     collection under a different type. It can be used, for example, to construct
+  ///     wrappers for the items in a collection on-the-fly, eliminating the need to
+  ///     manage the wrappers in parallel to the real items and improving performance
+  ///     by only constructing a wrapper when an item is actually requested.
+  ///   </para>
+  ///   <para>
+  ///     Another common use would be if you have a private collection of a non-public
+  ///     type that's derived from some publicly visible type. By using this collection,
+  ///     you can return the items under the publicly visible type while still having
+  ///     your private collection under the non-public type, eliminating the need to
+  ///     downcast each time you need to access elements of the non-public type.
+  ///   </para>
+  /// </remarks>
   public abstract class TransformingReadOnlyCollection<ContainedItemType, ExposedItemType> :
     IList<ExposedItemType>, IList {
 
@@ -241,23 +257,6 @@ namespace Nuclex.Support.Collections {
     /// </remarks>
     protected abstract ExposedItemType Transform(ContainedItemType item);
 
-    /// <summary>
-    ///   Determines whether the object is compatible to the collection's data type.
-    /// </summary>
-    /// <param name="value">Object to check for compatibility.</param>
-    /// <returns>
-    ///   True if the object is compatible to the collection's data type;
-    ///   otherwise false.
-    /// </returns>
-    private static bool IsCompatibleObject(object value) {
-      if(!(value is ExposedItemType)) {
-        if((value != null) || typeof(ExposedItemType).IsValueType) {
-          return false;
-        }
-      }
-      return true;
-    }
-
     #region IList<ExposedItemType> Members
 
     /// <summary>
diff --git a/Source/Scheduling/Operation.cs b/Source/Scheduling/Operation.cs
index 51a3ef9..594a12e 100644
--- a/Source/Scheduling/Operation.cs
+++ b/Source/Scheduling/Operation.cs
@@ -8,7 +8,15 @@ namespace Nuclex.Support.Tracking {
   public abstract class Operation : Progression {
 
     /// <summary>Executes the operation</summary>
-    public abstract void Execute();
+    public abstract void Start();
+
+    /// <summary>
+    ///   Executes the operation synchronously, blocking the calling thread
+    /// </summary>
+    public virtual void Execute() {
+      Start();
+      WaitHandle.WaitOne();
+    }
 
   }
 
diff --git a/Source/Tracking/ProgressionTracker.cs b/Source/Tracking/ProgressionTracker.cs
new file mode 100644
index 0000000..4b9fb7f
--- /dev/null
+++ b/Source/Tracking/ProgressionTracker.cs
@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Nuclex.Support.Tracking {
+/*
+  public abstract class ProgressionTracker {
+
+    public void Track() {}
+
+    protected virtual void OnStartTracking();
+    protected virtual void OnEndTracking();
+    protected virtual void OnProgressUpdated();
+
+  }
+*/
+} // namespace Nuclex.Support.Tracking