diff --git a/include/ceres/internal/expression.h b/include/ceres/internal/expression.h
index 5ab2d62..b9e2e39 100644
--- a/include/ceres/internal/expression.h
+++ b/include/ceres/internal/expression.h
@@ -183,15 +183,15 @@
   // v_0 = 3.1415;
   COMPILE_TIME_CONSTANT,
 
-  // For example a local member of the cost-functor.
+  // Assignment from a user-variable to a generated variable that can be used by
+  // other expressions. This is used for local variables of cost functors and
+  // parameters of a functions.
   // v_0 = _observed_point_x;
-  RUNTIME_CONSTANT,
+  // v_0 = parameters[0][0];
+  INPUT_ASSIGNMENT,
 
-  // Input parameter
-  // v_0 = parameters[1][5];
-  PARAMETER,
-
-  // Output Variable Assignemnt
+  // Assignment from a generated variable to a user-variable. Used to store the
+  // output of a generated cost functor.
   // residual[0] = v_51;
   OUTPUT_ASSIGNMENT,
 
@@ -223,11 +223,6 @@
   // v_5 = f(v_0,v_1,...)
   FUNCTION_CALL,
 
-  // The ternary ?-operator. Separated from the general function call for easier
-  // access.
-  // v_3 = ternary(v_0,v_1,v_2);
-  TERNARY,
-
   // Conditional control expressions if/else/endif.
   // These are special expressions, because they don't define a new variable.
   IF,
@@ -257,8 +252,7 @@
   // These functions create the corresponding expression, add them to an
   // internal vector and return a reference to them.
   static ExpressionId CreateCompileTimeConstant(double v);
-  static ExpressionId CreateRuntimeConstant(const std::string& name);
-  static ExpressionId CreateParameter(const std::string& name);
+  static ExpressionId CreateInputAssignment(const std::string& name);
   static ExpressionId CreateOutputAssignment(ExpressionId v,
                                              const std::string& name);
   static ExpressionId CreateAssignment(ExpressionId dst, ExpressionId src);
@@ -273,9 +267,6 @@
   static ExpressionId CreateLogicalNegation(ExpressionId v);
   static ExpressionId CreateFunctionCall(
       const std::string& name, const std::vector<ExpressionId>& params);
-  static ExpressionId CreateTernary(ExpressionId condition,
-                                    ExpressionId if_true,
-                                    ExpressionId if_false);
 
   // Conditional control expressions are inserted into the graph but can't be
   // referenced by other expressions. Therefore they don't return an
diff --git a/include/ceres/internal/expression_ref.h b/include/ceres/internal/expression_ref.h
index e0386f0..3d376ee 100644
--- a/include/ceres/internal/expression_ref.h
+++ b/include/ceres/internal/expression_ref.h
@@ -56,6 +56,11 @@
   // must work for T = Jet<ExpressionRef>.
   ExpressionRef(double compile_time_constant);
 
+  // By adding this constructor (which always throws an error) we can detect
+  // invalid usage of ExpressionRef. ExpressionRef can only be created from
+  // constexpr doubles.
+  ExpressionRef(double& test);
+
   // Create an ASSIGNMENT expression from other to this.
   //
   // For example:
@@ -182,21 +187,21 @@
 // This struct is used to mark numbers which are constant over
 // multiple invocations but can differ between instances.
 template <typename T>
-struct RuntimeConstant {
+struct InputAssignment {
   using ReturnType = T;
   static inline ReturnType Get(double v, const char* /* unused */) { return v; }
 };
 
 template <>
-struct RuntimeConstant<ExpressionRef> {
+struct InputAssignment<ExpressionRef> {
   using ReturnType = ExpressionRef;
   static inline ReturnType Get(double /* unused */, const char* name) {
-    return ExpressionRef::Create(Expression::CreateRuntimeConstant(name));
+    return ExpressionRef::Create(Expression::CreateInputAssignment(name));
   }
 };
 
 template <typename G, int N>
-struct RuntimeConstant<Jet<G, N>> {
+struct InputAssignment<Jet<G, N>> {
   using ReturnType = Jet<G, N>;
   static inline Jet<G, N> Get(double v, const char* /* unused */) {
     return Jet<G, N>(v);
@@ -204,27 +209,31 @@
 };
 
 template <int N>
-struct RuntimeConstant<Jet<ExpressionRef, N>> {
+struct InputAssignment<Jet<ExpressionRef, N>> {
   using ReturnType = Jet<ExpressionRef, N>;
   static inline ReturnType Get(double /* unused */, const char* name) {
     // Note: The scalar value of v will be thrown away, because we don't need it
     // during code generation.
     return Jet<ExpressionRef, N>(
-        ExpressionRef::Create(Expression::CreateRuntimeConstant(name)));
+        ExpressionRef::Create(Expression::CreateInputAssignment(name)));
   }
 };
 
 template <typename T>
-inline typename RuntimeConstant<T>::ReturnType MakeRuntimeConstant(
+inline typename InputAssignment<T>::ReturnType MakeInputAssignment(
     double v, const char* name) {
-  return RuntimeConstant<T>::Get(v, name);
+  return InputAssignment<T>::Get(v, name);
 }
 
-#define CERES_EXPRESSION_RUNTIME_CONSTANT(_v) \
-  ceres::internal::MakeRuntimeConstant<T>(_v, #_v)
+// This macro should be used for local variables in cost functors. Using local
+// variables directly, will compile their current value into the code.
+// Example:
+//  T x = CERES_LOCAL_VARIABLE(observed_x_);
+#define CERES_LOCAL_VARIABLE(_v) \
+  ceres::internal::MakeInputAssignment<T>(_v, #_v)
 
 inline ExpressionRef MakeParameter(const std::string& name) {
-  return ExpressionRef::Create(Expression::CreateParameter(name));
+  return ExpressionRef::Create(Expression::CreateInputAssignment(name));
 }
 inline ExpressionRef MakeOutput(ExpressionRef v, const std::string& name) {
   return ExpressionRef::Create(Expression::CreateOutputAssignment(v.id, name));
diff --git a/internal/ceres/expression.cc b/internal/ceres/expression.cc
index 4c8dd5c..b3f9106 100644
--- a/internal/ceres/expression.cc
+++ b/internal/ceres/expression.cc
@@ -63,33 +63,12 @@
   return expr.lhs_id_;
 }
 
-ExpressionId Expression::CreateRuntimeConstant(const std::string& name) {
-  auto& expr = MakeArithmeticExpression(ExpressionType::RUNTIME_CONSTANT);
+ExpressionId Expression::CreateInputAssignment(const std::string& name) {
+  auto& expr = MakeArithmeticExpression(ExpressionType::INPUT_ASSIGNMENT);
   expr.name_ = name;
   return expr.lhs_id_;
 }
 
-ExpressionId Expression::CreateParameter(const std::string& name) {
-  auto& expr = MakeArithmeticExpression(ExpressionType::PARAMETER);
-  expr.name_ = name;
-  return expr.lhs_id_;
-}
-
-ExpressionId Expression::CreateAssignment(ExpressionId dst, ExpressionId src) {
-  auto& expr = MakeArithmeticExpression(ExpressionType::ASSIGNMENT, dst);
-
-  expr.arguments_.push_back(src);
-  return expr.lhs_id_;
-}
-
-ExpressionId Expression::CreateUnaryArithmetic(const std::string& op,
-                                               ExpressionId v) {
-  auto& expr = MakeArithmeticExpression(ExpressionType::UNARY_ARITHMETIC);
-  expr.name_ = op;
-  expr.arguments_.push_back(v);
-  return expr.lhs_id_;
-}
-
 ExpressionId Expression::CreateOutputAssignment(ExpressionId v,
                                                 const std::string& name) {
   auto& expr = MakeArithmeticExpression(ExpressionType::OUTPUT_ASSIGNMENT);
@@ -98,21 +77,28 @@
   return expr.lhs_id_;
 }
 
-ExpressionId Expression::CreateFunctionCall(
-    const std::string& name, const std::vector<ExpressionId>& params) {
-  auto& expr = MakeArithmeticExpression(ExpressionType::FUNCTION_CALL);
-  expr.arguments_ = params;
-  expr.name_ = name;
+ExpressionId Expression::CreateAssignment(ExpressionId dst, ExpressionId src) {
+  auto& expr = MakeArithmeticExpression(ExpressionType::ASSIGNMENT, dst);
+
+  expr.arguments_.push_back(src);
   return expr.lhs_id_;
 }
 
-ExpressionId Expression::CreateTernary(ExpressionId condition,
-                                       ExpressionId if_true,
-                                       ExpressionId if_false) {
-  auto& expr = MakeArithmeticExpression(ExpressionType::TERNARY);
-  expr.arguments_.push_back(condition);
-  expr.arguments_.push_back(if_true);
-  expr.arguments_.push_back(if_false);
+ExpressionId Expression::CreateBinaryArithmetic(const std::string& op,
+                                                ExpressionId l,
+                                                ExpressionId r) {
+  auto& expr = MakeArithmeticExpression(ExpressionType::BINARY_ARITHMETIC);
+  expr.name_ = op;
+  expr.arguments_.push_back(l);
+  expr.arguments_.push_back(r);
+  return expr.lhs_id_;
+}
+
+ExpressionId Expression::CreateUnaryArithmetic(const std::string& op,
+                                               ExpressionId v) {
+  auto& expr = MakeArithmeticExpression(ExpressionType::UNARY_ARITHMETIC);
+  expr.name_ = op;
+  expr.arguments_.push_back(v);
   return expr.lhs_id_;
 }
 
@@ -132,13 +118,11 @@
   return expr.lhs_id_;
 }
 
-ExpressionId Expression::CreateBinaryArithmetic(const std::string& op,
-                                                ExpressionId l,
-                                                ExpressionId r) {
-  auto& expr = MakeArithmeticExpression(ExpressionType::BINARY_ARITHMETIC);
-  expr.name_ = op;
-  expr.arguments_.push_back(l);
-  expr.arguments_.push_back(r);
+ExpressionId Expression::CreateFunctionCall(
+    const std::string& name, const std::vector<ExpressionId>& params) {
+  auto& expr = MakeArithmeticExpression(ExpressionType::FUNCTION_CALL);
+  expr.arguments_ = params;
+  expr.name_ = name;
   return expr.lhs_id_;
 }
 
diff --git a/internal/ceres/expression_ref.cc b/internal/ceres/expression_ref.cc
index 7c2bc5d..9aa25d4 100644
--- a/internal/ceres/expression_ref.cc
+++ b/internal/ceres/expression_ref.cc
@@ -44,6 +44,11 @@
   id = Expression::CreateCompileTimeConstant(compile_time_constant);
 }
 
+ExpressionRef::ExpressionRef(double& test) {
+  CHECK(false)
+      << "ExpressionRefs can only be created from compile-time constants.";
+}
+
 ExpressionRef::ExpressionRef(const ExpressionRef& other) { *this = other; }
 
 ExpressionRef& ExpressionRef::operator=(const ExpressionRef& other) {
@@ -125,7 +130,7 @@
 ExpressionRef Ternary(ComparisonExpressionRef c,
                       ExpressionRef a,
                       ExpressionRef b) {
-  return ExpressionRef::Create(Expression::CreateTernary(c.id, a.id, b.id));
+  return MakeFunctionCall("ternary", {c.id, a.id, b.id});
 }
 
 #define CERES_DEFINE_EXPRESSION_COMPARISON_OPERATOR(op)                   \