diff --git a/CMakeLists.txt b/CMakeLists.txt
index eac5816..80d6f22 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -617,7 +617,7 @@
 # GCC is not strict enough by default, so enable most of the warnings.
 IF ("${UNIX}")
   SET(CMAKE_CXX_FLAGS
-      "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused -Wno-unused-parameter")
+      "${CMAKE_CXX_FLAGS} -Werror -Wall -Wextra -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-return-type-c-linkage")
 ENDIF ("${UNIX}")
 
 ADD_SUBDIRECTORY(internal/ceres)
diff --git a/docs/source/introduction.rst b/docs/source/introduction.rst
index 4e9e967..5df765b 100644
--- a/docs/source/introduction.rst
+++ b/docs/source/introduction.rst
@@ -60,11 +60,14 @@
          :ref:`chapter-tutorial`.
 
 .. [#f2] While there is some debate as to who invented the method of
-         Least Squares [Stigler]_, there is no debate that it was Carl
-         Friedrich brought it to the attention of the world. Using
-         just 22 observations of the newly discovered asteroid Ceres,
-         Gauss used the method of least squares to correctly predict
-         when and where the asteroid will emerge from behind the Sun
+         Least Squares [Stigler]_, there is no debate that it was
+         `Carl Friedrich Gauss
+         <http://en.wikipedia.org/wiki/Carl_Friedrich_Gauss>`_ who
+         brought it to the attention of the world. Using just 22
+         observations of the newly discovered asteroid `Ceres
+         <http://en.wikipedia.org/wiki/Ceres_(dwarf_planet)>`_, Gauss
+         used the method of least squares to correctly predict when
+         and where the asteroid will emerge from behind the Sun
          [TenenbaumDirector]_. We named our solver after Ceres to
          celebrate this seminal event in the history of astronomy,
          statistics and optimization.
diff --git a/docs/source/modeling.rst b/docs/source/modeling.rst
index 9235094..d8d73bf 100644
--- a/docs/source/modeling.rst
+++ b/docs/source/modeling.rst
@@ -988,30 +988,127 @@
 
 .. function:: ResidualBlockId Problem::AddResidualBlock(CostFunction* cost_function, LossFunction* loss_function, const vector<double*> parameter_blocks)
 
+   Add a residual block to the overall cost function. The cost
+   function carries with it information about the sizes of the
+   parameter blocks it expects. The function checks that these match
+   the sizes of the parameter blocks listed in parameter_blocks. The
+   program aborts if a mismatch is detected. loss_function can be
+   NULL, in which case the cost of the term is just the squared norm
+   of the residuals.
+
+   The user has the option of explicitly adding the parameter blocks
+   using AddParameterBlock. This causes additional correctness
+   checking; however, AddResidualBlock implicitly adds the parameter
+   blocks if they are not present, so calling AddParameterBlock
+   explicitly is not required.
+
+   The Problem object by default takes ownership of the
+   cost_function and loss_function pointers. These objects remain
+   live for the life of the Problem object. If the user wishes to
+   keep control over the destruction of these objects, then they can
+   do this by setting the corresponding enums in the Options struct.
+
+   Note: Even though the Problem takes ownership of cost_function
+   and loss_function, it does not preclude the user from re-using
+   them in another residual block. The destructor takes care to call
+   delete on each cost_function or loss_function pointer only once,
+   regardless of how many residual blocks refer to them.
+
+   Example usage:
+
+   .. code-block:: c++
+
+      double x1[] = {1.0, 2.0, 3.0};
+      double x2[] = {1.0, 2.0, 5.0, 6.0};
+      double x3[] = {3.0, 6.0, 2.0, 5.0, 1.0};
+
+      Problem problem;
+
+      problem.AddResidualBlock(new MyUnaryCostFunction(...), NULL, x1);
+      problem.AddResidualBlock(new MyBinaryCostFunction(...), NULL, x2, x1);
+
 
 .. function:: void Problem::AddParameterBlock(double* values, int size, LocalParameterization* local_parameterization)
-              void Problem::AddParameterBlock(double* values, int size)
+
+   Add a parameter block with appropriate size to the problem.
+   Repeated calls with the same arguments are ignored. Repeated calls
+   with the same double pointer but a different size results in
+   undefined behaviour.
+
+.. function:: void Problem::AddParameterBlock(double* values, int size)
+
+   Add a parameter block with appropriate size and parameterization to
+   the problem. Repeated calls with the same arguments are
+   ignored. Repeated calls with the same double pointer but a
+   different size results in undefined behaviour.
+
+.. function:: void Problem::RemoveResidualBlock(ResidualBlockId residual_block)
+
+   Remove a parameter block from the problem. The parameterization of
+   the parameter block, if it exists, will persist until the deletion
+   of the problem (similar to cost/loss functions in residual block
+   removal). Any residual blocks that depend on the parameter are also
+   removed, as described above in RemoveResidualBlock().  If
+   Problem::Options::enable_fast_parameter_block_removal is true, then
+   the removal is fast (almost constant time). Otherwise, removing a
+   parameter block will incur a scan of the entire Problem object.
+
+   WARNING: Removing a residual or parameter block will destroy the
+   implicit ordering, rendering the jacobian or residuals returned
+   from the solver uninterpretable. If you depend on the evaluated
+   jacobian, do not use remove! This may change in a future release.
+
+.. function:: void Problem::RemoveResidualBlock(ResidualBlockId residual_block)
+
+   Remove a residual block from the problem. Any parameters that the residual
+   block depends on are not removed. The cost and loss functions for the
+   residual block will not get deleted immediately; won't happen until the
+   problem itself is deleted.
+
+   WARNING: Removing a residual or parameter block will destroy the implicit
+   ordering, rendering the jacobian or residuals returned from the solver
+   uninterpretable. If you depend on the evaluated jacobian, do not use
+   remove! This may change in a future release.
+   Hold the indicated parameter block constant during optimization.
 
 
 .. function:: void Problem::SetParameterBlockConstant(double* values)
 
+   Hold the indicated parameter block constant during optimization.
+
 .. function:: void Problem::SetParameterBlockVariable(double* values)
 
+   Allow the indicated parameter to vary during optimization.
+
 
 .. function:: void Problem::SetParameterization(double* values, LocalParameterization* local_parameterization)
 
+   Set the local parameterization for one of the parameter blocks.
+   The local_parameterization is owned by the Problem by default. It
+   is acceptable to set the same parameterization for multiple
+   parameters; the destructor is careful to delete local
+   parameterizations only once. The local parameterization can only be
+   set once per parameter, and cannot be changed once set.
 
 .. function:: int Problem::NumParameterBlocks() const
 
+   Number of parameter blocks in the problem. Always equals
+   parameter_blocks().size() and parameter_block_sizes().size().
 
 .. function:: int Problem::NumParameters() const
 
+   The size of the parameter vector obtained by summing over the sizes
+   of all the parameter blocks.
 
 .. function:: int Problem::NumResidualBlocks() const
 
+   Number of residual blocks in the problem. Always equals
+   residual_blocks().size().
 
 .. function:: int Problem::NumResiduals() const
 
+   The size of the residual vector obtained by summing over the sizes
+   of all of the residual blocks.
 
 
 ``rotation.h``
diff --git a/docs/source/version_history.rst b/docs/source/version_history.rst
index dbfc758..8de716c 100644
--- a/docs/source/version_history.rst
+++ b/docs/source/version_history.rst
@@ -9,6 +9,10 @@
 
 New Features
 ------------
+#. Problem now supports removal of ParameterBlocks and
+   ResidualBlocks. There is a space/time tradeoff in doing this which
+   is controlled by
+   ``Problem::Options::enable_fast_parameter_block_removal`.
 
 #. Ceres now supports Line search based optimization algorithms in
    addition to trust region algorithms. Currently there is support for
@@ -39,11 +43,13 @@
 #. Automatic differenatiation with a dynamic number of parameter
    blocks. (Based on an idea by Thad Hughes).
 
-#. Speeded up problem construction destruction.
+#. Speeded up problem construction and destruction.
 
 #. Added matrix adapters to ``rotation.h`` so that the rotation matrix
    routines can work with row and column major matrices. (Markus Moll)
 
+#. ``SCHUR_JACOBI`` can now be used without ``SuiteSparse``.
+
 Bug Fixes
 ---------
 
diff --git a/internal/ceres/dogleg_strategy_test.cc b/internal/ceres/dogleg_strategy_test.cc
index 9e2ed9f..24c526e 100644
--- a/internal/ceres/dogleg_strategy_test.cc
+++ b/internal/ceres/dogleg_strategy_test.cc
@@ -206,10 +206,7 @@
   DoglegStrategy strategy(options_);
   TrustRegionStrategy::PerSolveOptions pso;
 
-  TrustRegionStrategy::Summary summary = strategy.ComputeStep(pso,
-                                                              jacobian_.get(),
-                                                              residual_.data(),
-                                                              x_.data());
+  strategy.ComputeStep(pso, jacobian_.get(), residual_.data(), x_.data());
 
   // Check if the basis is orthonormal.
   const Matrix basis = strategy.subspace_basis();
@@ -288,4 +285,3 @@
 
 }  // namespace internal
 }  // namespace ceres
-
diff --git a/internal/ceres/schur_complement_solver_test.cc b/internal/ceres/schur_complement_solver_test.cc
index 71c6cfd..1820bc9 100644
--- a/internal/ceres/schur_complement_solver_test.cc
+++ b/internal/ceres/schur_complement_solver_test.cc
@@ -75,20 +75,12 @@
 
     // Gold standard solutions using dense QR factorization.
     DenseSparseMatrix dense_A(triplet_A);
-    LinearSolver::Summary summary1 =
-        qr->Solve(&dense_A,
-                  b.get(),
-                  LinearSolver::PerSolveOptions(),
-                  sol.get());
+    qr->Solve(&dense_A, b.get(), LinearSolver::PerSolveOptions(), sol.get());
 
     // Gold standard solution with appended diagonal.
     LinearSolver::PerSolveOptions per_solve_options;
     per_solve_options.D = D.get();
-    LinearSolver::Summary summary2 =
-        qr->Solve(&dense_A,
-                  b.get(),
-                  per_solve_options,
-                  sol_d.get());
+    qr->Solve(&dense_A, b.get(), per_solve_options, sol_d.get());
   }
 
   void ComputeAndCompareSolutions(
diff --git a/internal/ceres/solver_impl.cc b/internal/ceres/solver_impl.cc
index c6ee86a..803b711 100644
--- a/internal/ceres/solver_impl.cc
+++ b/internal/ceres/solver_impl.cc
@@ -490,9 +490,6 @@
 
     double post_process_start_time = WallTimeInSeconds();
 
-
-
-
     // Evaluate the final cost, residual vector and the jacobian
     // matrix if requested by the user.
     if (options.return_final_residuals ||
@@ -820,6 +817,8 @@
 
     // Ensure the program state is set to the user parameters on the way out.
     original_program->SetParameterBlockStatePtrsToUserStatePtrs();
+    summary->postprocessor_time_in_seconds =
+        WallTimeInSeconds() - post_process_start_time;
     return;
   }
 
@@ -886,6 +885,9 @@
       summary->termination_type = NUMERICAL_FAILURE;
       summary->error = "Unable to evaluate the final cost.";
       LOG(ERROR) << summary->error;
+
+      summary->postprocessor_time_in_seconds =
+          WallTimeInSeconds() - post_process_start_time;
       return;
     }
   }
@@ -901,9 +903,6 @@
   summary->jacobian_evaluation_time_in_seconds =
       FindWithDefault(evaluator_time_statistics, "Evaluator::Jacobian", 0.0);
 
-  summary->postprocessor_time_in_seconds =
-      WallTimeInSeconds() - post_process_start_time;
-
   // Stick a fork in it, we're done.
   summary->postprocessor_time_in_seconds =
       WallTimeInSeconds() - post_process_start_time;