Feedback.

core/src/main/scala/org/apache/spark/SparkConf.scala

@@ -82,7 +82,7 @@ class SparkConf(loadDefaults: Boolean) extends Cloneable with Logging {
   }
 
   private[spark] def set[T](entry: OptionalConfigEntry[T], value: T): SparkConf = {
-    set(entry.key, entry._stringConverter(value))
+    set(entry.key, entry.rawStringConverter(value))
     this
   }
 
@@ -168,7 +168,7 @@ class SparkConf(loadDefaults: Boolean) extends Cloneable with Logging {
   }
 
   private[spark] def setIfMissing[T](entry: OptionalConfigEntry[T], value: T): SparkConf = {
-    if (settings.putIfAbsent(entry.key, entry._stringConverter(value)) == null) {
+    if (settings.putIfAbsent(entry.key, entry.rawStringConverter(value)) == null) {
       logDeprecationWarning(entry.key)
     }
     this
@@ -224,6 +224,13 @@ class SparkConf(loadDefaults: Boolean) extends Cloneable with Logging {
     getOption(key).getOrElse(defaultValue)
   }
 
+  /**
+   * Retrieves the value of a pre-defined configuration entry.
+   *
+   * - This is an internal Spark API.
+   * - The return type if defined by the configuration entry.
+   * - This will throw an exception is the config is not optional and the value is not set.
+   */
   private[spark] def get[T](entry: ConfigEntry[T]): T = {
     entry.readFrom(this)
   }

core/src/main/scala/org/apache/spark/config/ConfigEntry.scala

@@ -33,7 +33,7 @@ import org.apache.spark.network.util.{ByteUnit, JavaUtils}
  *                        string value. It's usually `toString`. But sometimes, a custom converter
  *                        is necessary. E.g., if T is List[String], `a, b, c` is better than
  *                        `List(a, b, c)`.
- * @param doc the document for the configuration
+ * @param doc the documentation for the configuration
  * @param isPublic if this configuration is public to the user. If it's `false`, this
  *                 configuration is only used internally and we should not expose it to the user.
  * @tparam T the value type
@@ -67,21 +67,27 @@ private[spark] class ConfigEntry[T] (
   }
 }
 
+/**
+ * A config entry that does not have a default value. See the `optional` method in ConfigEntry.
+ */
 private[spark] class OptionalConfigEntry[T](
     override val key: String,
-    val _valueConverter: String => T,
-    val _stringConverter: T => String,
+    _valueConverter: String => T,
+    val rawStringConverter: T => String,
     override val doc: String,
     override val isPublic: Boolean)
-    extends ConfigEntry[Option[T]](key, None, s => Some(_valueConverter(s)),
-      null, doc, isPublic) {
+    extends ConfigEntry[Option[T]](key, None, s => Option(_valueConverter(s)),
+      v => v.map(rawStringConverter).orNull, doc, isPublic) {
 
   override def readFrom(conf: SparkConf): Option[T] = {
     conf.getOption(key).map(_valueConverter)
   }
 
 }
 
+/**
+ * A config entry whose default value is defined by another config entry.
+ */
 private class FallbackConfigEntry[T] (
     override val key: String,
     override val doc: String,