diff --git a/src/state/dieterichstateupdater.hh b/src/state/dieterichstateupdater.hh
index ee8480c473e4f1f32802a97e51a2d9b21ef8d839..1db5cbd56f8f672c8e8f22b3ff3070c7de0a163b 100644
--- a/src/state/dieterichstateupdater.hh
+++ b/src/state/dieterichstateupdater.hh
@@ -17,7 +17,7 @@ class DieterichStateUpdater
   virtual void extractState(SingletonVectorType &state);
 
 private:
-  SingletonVectorType alpha_old;
+  SingletonVectorType alpha_o;
   SingletonVectorType alpha;
   Dune::BitSetVector<1> const &nodes;
   double const L;
@@ -32,7 +32,7 @@ DieterichStateUpdater<SingletonVectorType, VectorType>::DieterichStateUpdater(
 
 template <class SingletonVectorType, class VectorType>
 void DieterichStateUpdater<SingletonVectorType, VectorType>::nextTimeStep() {
-  alpha_old = alpha;
+  alpha_o = alpha;
 }
 
 template <class SingletonVectorType, class VectorType>
@@ -47,7 +47,7 @@ void DieterichStateUpdater<SingletonVectorType, VectorType>::solve(
   for (size_t i = 0; i < nodes.size(); ++i)
     if (nodes[i][0]) {
       double const V = velocity_field[i].two_norm();
-      alpha[i] = state_update_dieterich_euler(tau, V / L, alpha_old[i]);
+      alpha[i] = state_update_dieterich_euler(tau, V / L, alpha_o[i]);
     }
 }
 
diff --git a/src/state/ruinastateupdater.hh b/src/state/ruinastateupdater.hh
index 083d97eedaeb2d86085a193f7b03b331ea8459a4..94c78361763d9f0b0584867c30727427b22fac69 100644
--- a/src/state/ruinastateupdater.hh
+++ b/src/state/ruinastateupdater.hh
@@ -16,7 +16,7 @@ class RuinaStateUpdater : public StateUpdater<SingletonVectorType, VectorType> {
   virtual void extractState(SingletonVectorType &state);
 
 private:
-  SingletonVectorType alpha_old;
+  SingletonVectorType alpha_o;
   SingletonVectorType alpha;
   Dune::BitSetVector<1> const &nodes;
   double const L;
@@ -31,7 +31,7 @@ RuinaStateUpdater<SingletonVectorType, VectorType>::RuinaStateUpdater(
 
 template <class SingletonVectorType, class VectorType>
 void RuinaStateUpdater<SingletonVectorType, VectorType>::nextTimeStep() {
-  alpha_old = alpha;
+  alpha_o = alpha;
 }
 
 template <class SingletonVectorType, class VectorType>
@@ -45,7 +45,7 @@ void RuinaStateUpdater<SingletonVectorType, VectorType>::solve(
   for (size_t i = 0; i < nodes.size(); ++i)
     if (nodes[i][0]) {
       double const V = velocity_field[i].two_norm();
-      alpha[i] = state_update_ruina(tau, V * tau / L, alpha_old[i]);
+      alpha[i] = state_update_ruina(tau, V * tau / L, alpha_o[i]);
     }
 }
 
diff --git a/src/timestepping/eulerpair.cc b/src/timestepping/eulerpair.cc
index 480f86052e75ed439305c4040b8d22e7e18956a9..364e64fd3f3f2bfba510f8d8640bcb7e2db8d48b 100644
--- a/src/timestepping/eulerpair.cc
+++ b/src/timestepping/eulerpair.cc
@@ -14,8 +14,8 @@ EulerPair<VectorType, MatrixType, FunctionType, dim>::EulerPair(
 
 template <class VectorType, class MatrixType, class FunctionType, int dim>
 void EulerPair<VectorType, MatrixType, FunctionType, dim>::nextTimeStep() {
-  v_old = v;
-  u_old = u;
+  v_o = v;
+  u_o = u;
 }
 
 template <class VectorType, class MatrixType, class FunctionType, int dim>
@@ -27,8 +27,8 @@ void EulerPair<VectorType, MatrixType, FunctionType, dim>::setup(
   tau = _tau;
 
   problem_rhs = ell;
-  Arithmetic::addProduct(problem_rhs, 1.0 / tau, B, v_old);
-  Arithmetic::subtractProduct(problem_rhs, A, u_old);
+  Arithmetic::addProduct(problem_rhs, 1.0 / tau, B, v_o);
+  Arithmetic::subtractProduct(problem_rhs, A, u_o);
 
   // For fixed tau, we'd only really have to do this once
   Dune::MatrixIndexSet indices(A.N(), A.M());
@@ -39,8 +39,8 @@ void EulerPair<VectorType, MatrixType, FunctionType, dim>::setup(
   Arithmetic::addProduct(problem_AB, tau, A);
   Arithmetic::addProduct(problem_AB, 1.0 / tau, B);
 
-  // v_old makes a good initial iterate; we could use anything, though
-  problem_iterate = v_old;
+  // v_o makes a good initial iterate; we could use anything, though
+  problem_iterate = v_o;
 
   for (size_t i = 0; i < dirichletNodes.size(); ++i)
     switch (dirichletNodes[i].count()) {
@@ -72,7 +72,7 @@ void EulerPair<VectorType, MatrixType, FunctionType, dim>::postProcess(
 
   v = problem_iterate;
 
-  u = u_old;
+  u = u_o;
   Arithmetic::addProduct(u, tau, v);
 }
 
diff --git a/src/timestepping/eulerpair.hh b/src/timestepping/eulerpair.hh
index 34e684a57023ce03dfb1fb3f6ecca5b8cbb11516..289f98d26f1278d36e91d32047257e465999cb3e 100644
--- a/src/timestepping/eulerpair.hh
+++ b/src/timestepping/eulerpair.hh
@@ -25,8 +25,8 @@ class EulerPair
   Dune::BitSetVector<dim> const &dirichletNodes;
   FunctionType const &dirichletFunction;
 
-  VectorType u_old;
-  VectorType v_old;
+  VectorType u_o;
+  VectorType v_o;
 
   double tau;
 
diff --git a/src/timestepping/impliciteuler.cc b/src/timestepping/impliciteuler.cc
index 753689da45bb9547179174310cabdf51c14243e0..2ae4991f8611b8258cabe42cc8002fda757164d7 100644
--- a/src/timestepping/impliciteuler.cc
+++ b/src/timestepping/impliciteuler.cc
@@ -12,8 +12,8 @@ ImplicitEuler<VectorType, MatrixType, FunctionType, dim>::ImplicitEuler(
 
 template <class VectorType, class MatrixType, class FunctionType, int dim>
 void ImplicitEuler<VectorType, MatrixType, FunctionType, dim>::nextTimeStep() {
-  v_old = v;
-  u_old = u;
+  v_o = v;
+  u_o = u;
 }
 
 template <class VectorType, class MatrixType, class FunctionType, int dim>
@@ -25,14 +25,14 @@ void ImplicitEuler<VectorType, MatrixType, FunctionType, dim>::setup(
   tau = _tau;
 
   problem_rhs = ell;
-  Arithmetic::subtractProduct(problem_rhs, A, u_old);
+  Arithmetic::subtractProduct(problem_rhs, A, u_o);
 
   // For fixed tau, we'd only really have to do this once
   problem_AB = A;
   problem_AB *= tau;
 
-  // v_old makes a good initial iterate; we could use anything, though
-  problem_iterate = v_old;
+  // v_o makes a good initial iterate; we could use anything, though
+  problem_iterate = v_o;
 
   for (size_t i = 0; i < dirichletNodes.size(); ++i)
     switch (dirichletNodes[i].count()) {
@@ -64,7 +64,7 @@ void ImplicitEuler<VectorType, MatrixType, FunctionType, dim>::postProcess(
 
   v = problem_iterate;
 
-  u = u_old;
+  u = u_o;
   Arithmetic::addProduct(u, tau, v);
 }
 
diff --git a/src/timestepping/impliciteuler.hh b/src/timestepping/impliciteuler.hh
index 93f2d3dc8932d3a4840ea0b7368980d46d7676f7..fd0a86e34cb2bf6fd454122dfa854a6e6363ed14 100644
--- a/src/timestepping/impliciteuler.hh
+++ b/src/timestepping/impliciteuler.hh
@@ -24,8 +24,8 @@ class ImplicitEuler
   Dune::BitSetVector<dim> const &dirichletNodes;
   FunctionType const &dirichletFunction;
 
-  VectorType u_old;
-  VectorType v_old;
+  VectorType u_o;
+  VectorType v_o;
 
   double tau;
 
diff --git a/src/timestepping/newmark.cc b/src/timestepping/newmark.cc
index 30ad548af61f1b9384d6230e0ce3f3ae2cd80515..a08dad6b073b6054aa7e6fbd74dfe38f17e794ff 100644
--- a/src/timestepping/newmark.cc
+++ b/src/timestepping/newmark.cc
@@ -14,9 +14,9 @@ Newmark<VectorType, MatrixType, FunctionType, dim>::Newmark(
 
 template <class VectorType, class MatrixType, class FunctionType, int dim>
 void Newmark<VectorType, MatrixType, FunctionType, dim>::nextTimeStep() {
-  a_old = a;
-  v_old = v;
-  u_old = u;
+  a_o = a;
+  v_o = v;
+  u_o = u;
 }
 
 template <class VectorType, class MatrixType, class FunctionType, int dim>
@@ -28,10 +28,10 @@ void Newmark<VectorType, MatrixType, FunctionType, dim>::setup(
   tau = _tau;
 
   problem_rhs = ell;
-  Arithmetic::addProduct(problem_rhs, 2.0 / tau, B, v_old);
-  Arithmetic::addProduct(problem_rhs, B, a_old);
-  Arithmetic::subtractProduct(problem_rhs, A, u_old);
-  Arithmetic::subtractProduct(problem_rhs, tau / 2.0, A, v_old);
+  Arithmetic::addProduct(problem_rhs, 2.0 / tau, B, v_o);
+  Arithmetic::addProduct(problem_rhs, B, a_o);
+  Arithmetic::subtractProduct(problem_rhs, A, u_o);
+  Arithmetic::subtractProduct(problem_rhs, tau / 2.0, A, v_o);
 
   // For fixed tau, we'd only really have to do this once
   Dune::MatrixIndexSet indices(A.N(), A.M());
@@ -42,7 +42,7 @@ void Newmark<VectorType, MatrixType, FunctionType, dim>::setup(
   Arithmetic::addProduct(problem_AB, tau / 2.0, A);
   Arithmetic::addProduct(problem_AB, 2.0 / tau, B);
 
-  // v_old makes a good initial iterate; we could use anything, though
+  // v_o makes a good initial iterate; we could use anything, though
   problem_iterate = 0.0;
 
   for (size_t i = 0; i < dirichletNodes.size(); ++i)
@@ -75,14 +75,14 @@ void Newmark<VectorType, MatrixType, FunctionType, dim>::postProcess(
 
   v = problem_iterate;
 
-  u = u_old;
+  u = u_o;
   Arithmetic::addProduct(u, tau / 2.0, v);
-  Arithmetic::addProduct(u, tau / 2.0, v_old);
+  Arithmetic::addProduct(u, tau / 2.0, v_o);
 
   a = 0;
   Arithmetic::addProduct(a, 2.0 / tau, v);
-  Arithmetic::subtractProduct(a, 2.0 / tau, v_old);
-  Arithmetic::subtractProduct(a, 1.0, a_old);
+  Arithmetic::subtractProduct(a, 2.0 / tau, v_o);
+  Arithmetic::subtractProduct(a, 1.0, a_o);
 }
 
 template <class VectorType, class MatrixType, class FunctionType, int dim>
diff --git a/src/timestepping/newmark.hh b/src/timestepping/newmark.hh
index b9c1e91d3052df7078e173eb3f19180a435f4514..f576d1d778a7d52f021d1878b79bb7f8766aaa6e 100644
--- a/src/timestepping/newmark.hh
+++ b/src/timestepping/newmark.hh
@@ -27,9 +27,9 @@ class Newmark
   Dune::BitSetVector<dim> const &dirichletNodes;
   FunctionType const &dirichletFunction;
 
-  VectorType u_old;
-  VectorType v_old;
-  VectorType a_old;
+  VectorType u_o;
+  VectorType v_o;
+  VectorType a_o;
 
   double tau;