diff --git a/tutorials/tour/_posts/2017-02-13-polymorphic-methods.md b/tutorials/tour/_posts/2017-02-13-polymorphic-methods.md
index b6117a4069..1fd3104dc6 100644
--- a/tutorials/tour/_posts/2017-02-13-polymorphic-methods.md
+++ b/tutorials/tour/_posts/2017-02-13-polymorphic-methods.md
@@ -6,26 +6,29 @@ disqus: true
 
 tutorial: scala-tour
 categories: tour
+section:
 num: 28
 
 next-page: local-type-inference
 previous-page: implicit-conversions
+prerequisite-knowledge: unified-types,
 ---
 
-Methods in Scala can be parameterized with both values and types. Like on the class level, value parameters are enclosed in a pair of parentheses, while type parameters are declared within a pair of brackets.
+Methods in Scala can be parameterized by type as well as value. The syntax is similar to that of generic classes. Type parameters are declared within a pair of brackets while value parameters are enclosed in a pair of parentheses.
 
 Here is an example:
 
 ```tut
-def dup[T](x: T, n: Int): List[T] = {
-  if (n == 0)
-    Nil
-  else
-    x :: dup(x, n - 1)
+def listOfDuplicates[A](x: A, length: Int): List[A] = {
+    if (length < 1)
+        Nil
+    else
+        x :: listOfDuplicates(x, length - 1)
 }
-
-println(dup[Int](3, 4))
-println(dup("three", 3))
+println(listOfDuplicates[Int](3, 4))  // List(3, 3, 3, 3)
+println(listOfDuplicates("La", 8))  // List(La, La, La, La, La, La, La, La)
 ```
 
-Method `dup` is parameterized with type `T` and with the value parameters `x: T` and `n: Int`. In the first call to `dup`, the programmer provides the required parameters, but as the following line shows, the programmer is not required to give actual type parameters explicitly. The type system of Scala can infer such types. This is done by looking at the types of the given value parameters and at the context where the method is called.
+The method `listOfDuplicates` takes a type parameter `A` and values parameters `x` and `n`. In this case, value `x` is of type `A`. If `length > 1` we return an empty list. Otherwise we prepend `x` to the the list of duplicates returned by the recursive call to `listOfDuplicates`. (note: `::` means prepend an element on the left to a sequence on the right).
+
+When we call `listOfDuplicates` with `[Int]` as the type parameter, the first argument must be an int and the return type will be List[Int]. However, you don't always need to explicitly provide the the type parameter because the compiler can often figure it out based on the type of value argument (`"La"` is a String). In fact, if calling this method from Java it is impossible to provide the type parameter.