diff --git a/aos/ipc_lib/ipc_comparison.cc b/aos/ipc_lib/ipc_comparison.cc
index cff2699..2c73397 100644
--- a/aos/ipc_lib/ipc_comparison.cc
+++ b/aos/ipc_lib/ipc_comparison.cc
@@ -23,12 +23,12 @@
 
 #include "aos/condition.h"
 #include "aos/event.h"
+#include "aos/init.h"
+#include "aos/ipc_lib/queue.h"
 #include "aos/logging/implementations.h"
 #include "aos/logging/logging.h"
 #include "aos/mutex/mutex.h"
 #include "aos/time/time.h"
-#include "aos/init.h"
-#include "aos/ipc_lib/queue.h"
 
 DEFINE_string(method, "", "Which IPC method to use");
 DEFINE_int32(messages, 1000000, "How many messages to send back and forth");
@@ -427,7 +427,6 @@
   const ::std::unique_ptr<SemaphoreInterface> ping_, pong_;
 };
 
-
 class AOSMutexPingPonger : public ConditionVariablePingPonger {
  public:
   AOSMutexPingPonger()
@@ -457,10 +456,8 @@
  public:
   AOSEventPingPonger()
       : SemaphorePingPonger(
-            ::std::unique_ptr<SemaphoreInterface>(
-                new AOSEventSemaphore()),
-            ::std::unique_ptr<SemaphoreInterface>(
-                new AOSEventSemaphore())) {}
+            ::std::unique_ptr<SemaphoreInterface>(new AOSEventSemaphore()),
+            ::std::unique_ptr<SemaphoreInterface>(new AOSEventSemaphore())) {}
 
  private:
   class AOSEventSemaphore : public SemaphoreInterface {
@@ -572,8 +569,7 @@
  private:
   class SysvSemaphore : public SemaphoreInterface {
    public:
-    SysvSemaphore()
-        : sem_id_(PCHECK(semget(IPC_PRIVATE, 1, 0600))) {}
+    SysvSemaphore() : sem_id_(PCHECK(semget(IPC_PRIVATE, 1, 0600))) {}
 
    private:
     void Get() override {
@@ -606,8 +602,7 @@
  private:
   class PosixSemaphore : public SemaphoreInterface {
    public:
-    PosixSemaphore(sem_t *sem)
-        : sem_(sem) {}
+    PosixSemaphore(sem_t *sem) : sem_(sem) {}
 
    private:
     void Get() override { PCHECK(sem_wait(sem_)); }
@@ -909,8 +904,7 @@
   server.join();
 
   LOG(INFO, "Took %f seconds to send %" PRId32 " messages\n",
-      chrono::duration_cast<chrono::duration<double>>(end - start).count(),
-      FLAGS_messages);
+      ::aos::time::DurationInSeconds(end - start), FLAGS_messages);
   const chrono::nanoseconds per_message = (end - start) / FLAGS_messages;
   if (per_message >= chrono::seconds(1)) {
     LOG(INFO, "More than 1 second per message ?!?\n");
diff --git a/aos/time/time.h b/aos/time/time.h
index 0333c5c..469534f 100644
--- a/aos/time/time.h
+++ b/aos/time/time.h
@@ -2,17 +2,16 @@
 #define AOS_TIME_H_
 
 #include <stdint.h>
-#include <time.h>
 #include <sys/time.h>
-#include <stdint.h>
+#include <time.h>
 
-#include <type_traits>
 #include <chrono>
-#include <thread>
 #include <ostream>
+#include <thread>
+#include <type_traits>
 
-#include "aos/type_traits/type_traits.h"
 #include "aos/macros.h"
+#include "aos/type_traits/type_traits.h"
 
 namespace aos {
 
@@ -98,6 +97,16 @@
          hertz;
 }
 
+template <typename Scalar>
+constexpr Scalar TypedDurationInSeconds(monotonic_clock::duration dt) {
+  return ::std::chrono::duration_cast<::std::chrono::duration<Scalar>>(dt)
+      .count();
+}
+
+constexpr double DurationInSeconds(monotonic_clock::duration dt) {
+  return TypedDurationInSeconds<double>(dt);
+}
+
 // RAII class that freezes monotonic_clock::now() (to avoid making large numbers
 // of syscalls to find the real time).
 class TimeFreezer {
diff --git a/aos/util/log_interval.h b/aos/util/log_interval.h
index 5e76166..69170e4 100644
--- a/aos/util/log_interval.h
+++ b/aos/util/log_interval.h
@@ -1,8 +1,8 @@
 #ifndef AOS_UTIL_LOG_INTERVAL_H_
 #define AOS_UTIL_LOG_INTERVAL_H_
 
-#include "aos/time/time.h"
 #include "aos/logging/logging.h"
+#include "aos/time/time.h"
 
 #include <string>
 
@@ -78,8 +78,7 @@
       log_do(level_, "%s: %.*s %d times over %f sec\n", context_,
              static_cast<int>(message_.size()), message_.data(),
              interval_.Count(),
-             ::std::chrono::duration_cast<::std::chrono::duration<double>>(
-                 interval_.interval()).count());
+             ::aos::time::DurationInSeconds(interval_.interval()));
       context_ = NULL;
     }
   }
diff --git a/aos/util/trapezoid_profile.cc b/aos/util/trapezoid_profile.cc
index e58324f..a1e8abb 100644
--- a/aos/util/trapezoid_profile.cc
+++ b/aos/util/trapezoid_profile.cc
@@ -12,21 +12,17 @@
   output_.setZero();
 }
 
-void TrapezoidProfile::UpdateVals(double acceleration,
-                                  double delta_time) {
-  output_(0) += output_(1) * delta_time +
-      0.5 * acceleration * delta_time * delta_time;
+void TrapezoidProfile::UpdateVals(double acceleration, double delta_time) {
+  output_(0) +=
+      output_(1) * delta_time + 0.5 * acceleration * delta_time * delta_time;
   output_(1) += acceleration * delta_time;
 }
 
-const Matrix<double, 2, 1> &TrapezoidProfile::Update(
-    double goal_position,
-    double goal_velocity) {
+const Matrix<double, 2, 1> &TrapezoidProfile::Update(double goal_position,
+                                                     double goal_velocity) {
   CalculateTimes(goal_position - output_(0), goal_velocity);
 
-  double next_timestep =
-      ::std::chrono::duration_cast<::std::chrono::duration<double>>(timestep_)
-          .count();
+  double next_timestep = ::aos::time::DurationInSeconds(timestep_);
 
   if (acceleration_time_ > next_timestep) {
     UpdateVals(acceleration_, next_timestep);
@@ -93,26 +89,23 @@
   }
 
   // We now know the top velocity we can get to.
-  double top_velocity = sqrt((distance_to_target +
-                              (output_(1) * output_(1)) /
-                              (2.0 * acceleration_) +
-                              (goal_velocity * goal_velocity) /
-                              (2.0 * deceleration_)) /
-                             (-1.0 / (2.0 * deceleration_) +
-                              1.0 / (2.0 * acceleration_)));
+  double top_velocity = sqrt(
+      (distance_to_target + (output_(1) * output_(1)) / (2.0 * acceleration_) +
+       (goal_velocity * goal_velocity) / (2.0 * deceleration_)) /
+      (-1.0 / (2.0 * deceleration_) + 1.0 / (2.0 * acceleration_)));
 
   // If it can go too fast, we now know how long we get to accelerate for and
   // how long to go at constant velocity.
   if (top_velocity > maximum_velocity_) {
-    acceleration_time_ = (maximum_velocity_ - output_(1)) /
-        maximum_acceleration_;
-    constant_time_ = (distance_to_target +
-                      (goal_velocity * goal_velocity -
-                       maximum_velocity_ * maximum_velocity_) /
-                      (2.0 * maximum_acceleration_)) / maximum_velocity_;
+    acceleration_time_ =
+        (maximum_velocity_ - output_(1)) / maximum_acceleration_;
+    constant_time_ =
+        (distance_to_target + (goal_velocity * goal_velocity -
+                               maximum_velocity_ * maximum_velocity_) /
+                                  (2.0 * maximum_acceleration_)) /
+        maximum_velocity_;
   } else {
-    acceleration_time_ = (top_velocity - output_(1)) /
-        acceleration_;
+    acceleration_time_ = (top_velocity - output_(1)) / acceleration_;
   }
 
   CHECK_GT(top_velocity, -maximum_velocity_);
@@ -122,8 +115,7 @@
     acceleration_time_ = 0;
   }
 
-  deceleration_time_ = (goal_velocity - top_velocity) /
-      deceleration_;
+  deceleration_time_ = (goal_velocity - top_velocity) / deceleration_;
 }
 
 }  // namespace util