trackler 2.2.1.45 → 2.2.1.46

data/tracks/javascript/exercises/protein-translation/protein-translation.spec.js

@@ -0,0 +1,63 @@
+var translate = require('./protein-translation');
+
+describe('ProteinTranslation', function() {
+    it('Empty RNA has no proteins', function() {
+        expect(translate()).toEqual([]);
+    });
+
+    xit('Methionine codon translates into protein', function () {
+      expect(translate('AUG')).toEqual(["Methionine"]);
+    });
+
+    xit('Phenylalanine codons translate into protein', function () {
+      expect(translate('UUUUUC')).toEqual(["Phenylalanine", "Phenylalanine"]);
+    });
+
+    xit('Leucine codons translate into protein', function () {
+      expect(translate('UUAUUG')).toEqual(["Leucine", "Leucine"]);
+    });
+
+    xit('Serine codons translate into protein', function () {
+      expect(translate('UCUUCCUCAUCG')).toEqual(["Serine", "Serine", "Serine", "Serine"]);
+    });
+
+    xit('Tyrosine codons translate into protein', function () {
+      expect(translate('UAUUAC')).toEqual(["Tyrosine", "Tyrosine"]);
+    });
+
+    xit('Cysteine codons translate into protein', function() {
+      expect(translate('UGUUGC')).toEqual(["Cysteine", "Cysteine"]);
+    });
+
+    xit('Tryptophan codon translates into protein', function () {
+      expect(translate('UGG')).toEqual(["Tryptophan"]);
+    });
+
+    xit('Sequence starts with stop codon 1', function () {
+      expect(translate('UAAUUUUUA')).toEqual([]);
+    });
+
+    xit('Sequence starts with stop codon 2', function () {
+      expect(translate('UAGAUGUAU')).toEqual([]);
+    });
+
+    xit('Sequence starts with stop codon 3', function () {
+      expect(translate('UGAUGU')).toEqual([]);
+    });
+
+    xit('Small RNA strand', function () {
+      expect(translate('AUGUUUUCU')).toEqual(["Methionine", "Phenylalanine", "Serine"]);
+    });
+
+    xit('Stop codon ends translation', function () {
+      expect(translate('AUGUUUUCUUAAAUG')).toEqual(["Methionine", "Phenylalanine", "Serine"]);
+    });
+
+    xit('Invalid codon throws error', function () {
+      expect(
+        function() {
+          translate('LOL')
+        }
+      ).toThrow(new Error("Invalid codon"));
+    })
+});

data/tracks/julia/README.md

@@ -1,6 +1,6 @@
 # Exercism Julia Track
 
-[![Join the chat at https://gitter.im/exercism/julia](https://badges.gitter.im/exercism/julia.svg)](https://gitter.im/exercism/julia?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Join the chat at https://gitter.im/exercism/xjulia](https://badges.gitter.im/exercism/xjulia.svg)](https://gitter.im/exercism/xjulia?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 [![Build Status](https://travis-ci.org/exercism/julia.svg?branch=master)](https://travis-ci.org/exercism/julia)
 
 Exercism exercises in Julia.

data/tracks/kotlin/config.json

@@ -15,6 +15,16 @@
 
       ]
     },
+    {
+      "uuid": "fa4194c5-084d-f780-4db6-707ef7bcc30c00e9ee5",
+      "slug": "two-fer",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 2,
+      "topics": [
+
+      ]
+    },
     {
       "uuid": "9772c916-c619-445c-834d-af7dbf1ad2d9",
       "slug": "rna-transcription",
@@ -633,3 +643,4 @@
   ],
   "solution_pattern": "reference"
 }
+

data/tracks/kotlin/exercises/acronym/README.md

@@ -7,7 +7,6 @@ Techies love their TLA (Three Letter Acronyms)!
 Help generate some jargon by writing a program that converts a long name
 like Portable Network Graphics to its acronym (PNG).
 
-
 
 
 ## Source

data/tracks/kotlin/exercises/all-your-base/README.md

@@ -6,6 +6,7 @@ Implement general base conversion. Given a number in base **a**,
 represented as a sequence of digits, convert it to base **b**.
 
 ## Note
+
 - Try to implement the conversion yourself.
   Do not use something else to perform the conversion for you.
 
@@ -28,7 +29,6 @@ The number 1120, *in base 3*, means:
 
 I think you got the idea!
 
-
 *Yes. Those three numbers above are exactly the same. Congratulations!*
 
 

data/tracks/kotlin/exercises/allergies/README.md

@@ -29,7 +29,6 @@ allergens that score 256, 512, 1024, etc.).  Your program should
 ignore those components of the score.  For example, if the allergy
 score is 257, your program should only report the eggs (1) allergy.
 
-
 
 
 ## Source

data/tracks/kotlin/exercises/atbash-cipher/README.md

@@ -9,7 +9,7 @@ letter, the second with the second-last, and so on.
 
 An Atbash cipher for the Latin alphabet would be as follows:
 
-```plain
+```text
 Plain:  abcdefghijklmnopqrstuvwxyz
 Cipher: zyxwvutsrqponmlkjihgfedcba
 ```
@@ -23,6 +23,7 @@ being 5 letters, and punctuation is excluded. This is to make it harder to guess
 things based on word boundaries.
 
 ## Examples
+
 - Encoding `test` gives `gvhg`
 - Decoding `gvhg` gives `test`
 - Decoding `gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt` gives `thequickbrownfoxjumpsoverthelazydog`

data/tracks/kotlin/exercises/beer-song/README.md

@@ -4,7 +4,7 @@ Produce the lyrics to that beloved classic, that field-trip favorite: 99 Bottles
 
 Note that not all verses are identical.
 
-```plain
+```text
 99 bottles of beer on the wall, 99 bottles of beer.
 Take one down and pass it around, 98 bottles of beer on the wall.
 

data/tracks/kotlin/exercises/binary/README.md

@@ -7,10 +7,12 @@ string, your program should produce a decimal output. The
 program should handle invalid inputs.
 
 ## Note
+
 - Implement the conversion yourself.
   Do not use something else to perform the conversion for you.
 
 ## About Binary (Base-2)
+
 Decimal is a base-10 system.
 
 A number 23 in base 10 notation can be understood

data/tracks/kotlin/exercises/change/README.md

@@ -20,7 +20,7 @@ that the sum of the coins' value would equal the correct amount of change.
 
 ## Source
 
-Software Craftsmanship - Kata-logue [http://craftsmanship.sv.cmu.edu/exercises/coin-change-kata](http://craftsmanship.sv.cmu.edu/exercises/coin-change-kata)
+Software Craftsmanship - Coin Change Kata [https://web.archive.org/web/20130115115225/http://craftsmanship.sv.cmu.edu:80/exercises/coin-change-kata](https://web.archive.org/web/20130115115225/http://craftsmanship.sv.cmu.edu:80/exercises/coin-change-kata)
 
 ## Submitting Incomplete Solutions
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/kotlin/exercises/collatz-conjecture/README.md

@@ -10,6 +10,7 @@ always reach 1 eventually.
 Given a number n, return the number of steps required to reach 1.
 
 ## Examples
+
 Starting with n = 12, the steps would be as follows:
 
 0. 12
@@ -25,7 +26,6 @@ Starting with n = 12, the steps would be as follows:
 
 Resulting in 9 steps. So for input n = 12, the return value would be 9.
 
-
 
 
 ## Source

data/tracks/kotlin/exercises/complex-numbers/README.md

@@ -2,6 +2,33 @@
 
 A complex number is a number in the form `a + b * i` where `a` and `b` are real and `i` satisfies `i^2 = -1`.
 
+`a` is called the real part and `b` is called the imaginary part of `z`.
+The conjugate of the number `a + b * i` is the number `a - b * i`.
+The absolute value of a complex number `z = a + b * i` is a real number `|z| = sqrt(a^2 + b^2)`. The square of the absolute value `|z|^2` is the result of multiplication of `z` by its complex conjugate.
+
+The sum/difference of two complex numbers involves adding/subtracting their real and imaginary parts separately:
+`(a + i * b) + (c + i * d) = (a + c) + (b + d) * i`,
+`(a + i * b) - (c + i * d) = (a - c) + (b - d) * i`.
+
+Multiplication result is by definition
+`(a + i * b) * (c + i * d) = (a * c - b * d) + (b * c + a * d) * i`.
+
+The reciprocal of a non-zero complex number is
+`1 / (a + i * b) = a/(a^2 + b^2) - b/(a^2 + b^2) * i`.
+
+Dividing a complex number `a + i * b` by another `c + i * d` gives:
+`(a + i * b) / (c + i * d) = (a * c + b * d)/(c^2 + d^2) + (b * c - a * d)/(c^2 + d^2) * i`.
+
+Exponent of a complex number can be expressed as
+`exp(a + i * b) = exp(a) * exp(i * b)`,
+and the last term is given by Euler's formula `exp(i * b) = cos(b) + i * sin(b)`.
+
+
+Implement the following operations:
+ - addition, subtraction, multiplication and division of two complex numbers,
+ - conjugate, absolute value, exponent of a given complex number.
+
+
 Assume the programming language you are using does not have an implementation of complex numbers.
 
 

data/tracks/kotlin/exercises/diamond/README.md

@@ -1,7 +1,7 @@
 # Diamond
 
-The diamond kata takes as its input a letter, and outputs it in a diamond 
-shape. Given a letter, it prints a diamond starting with 'A', with the 
+The diamond kata takes as its input a letter, and outputs it in a diamond
+shape. Given a letter, it prints a diamond starting with 'A', with the
 supplied letter at the widest point.
 
 ## Requirements
@@ -15,7 +15,7 @@ supplied letter at the widest point.
 * The diamond has a square shape (width equals height).
 * The letters form a diamond shape.
 * The top half has the letters in ascending order.
-* The bottom half has the letters in descending order. 
+* The bottom half has the letters in descending order.
 * The four corners (containing the spaces) are triangles.
 
 ## Examples
@@ -24,13 +24,13 @@ In the following examples, spaces are indicated by `·` characters.
 
 Diamond for letter 'A':
 
-```plain
+```text
 A
 ```
 
 Diamond for letter 'C':
 
-```plain
+```text
 ··A··
 ·B·B·
 C···C
@@ -40,7 +40,7 @@ C···C
 
 Diamond for letter 'E':
 
-```plain
+```text
 ····A····
 ···B·B···
 ··C···C··

data/tracks/kotlin/exercises/etl/README.md

@@ -3,6 +3,7 @@
 We are going to do the `Transform` step of an Extract-Transform-Load.
 
 ### ETL
+
 Extract-Transform-Load (ETL) is a fancy way of saying, "We have some crufty, legacy data over in this system, and now we need it in this shiny new system over here, so
 we're going to migrate this."
 
@@ -11,6 +12,7 @@ once." That's then typically followed by much forehead slapping and
 moaning about how stupid we could possibly be.)
 
 ### The goal
+
 We're going to extract some scrabble scores from a legacy system.
 
 The old system stored a list of letters per score:

data/tracks/kotlin/exercises/flatten-array/README.md

@@ -3,14 +3,13 @@
 Take a nested list and return a single flattened list with all values except nil/null.
 
 The challenge is to write a function that accepts an arbitrarily-deep nested list-like structure and returns a flattened structure without any nil/null values.
- 
+
 For Example
 
 input: [1,[2,3,null,4],[null],5]
 
 output: [1,2,3,4,5]
 
-
 
 
 ## Source

data/tracks/kotlin/exercises/grade-school/README.md

@@ -21,7 +21,6 @@ In the end, you should be able to:
 Note that all our students only have one name.  (It's a small town, what
 do you want?)
 
-
 ## For bonus points
 
 Did you get the tests passing and the code clean? If you want to, these

data/tracks/kotlin/exercises/grains/README.md

@@ -15,7 +15,6 @@ Write code that shows:
 - how many grains were on each square, and
 - the total number of grains
 
-
 ## For bonus points
 
 Did you get the tests passing and the code clean? If you want to, these

data/tracks/kotlin/exercises/hello-world/.meta/hints.md

@@ -0,0 +1,4 @@
+Since this is your first Kotlin exercise, we've included a detailed TUTORIAL.md
+file that guides you through your solution. Check it out for tips and
+assistance!
+

data/tracks/kotlin/exercises/hello-world/.meta/src/reference/kotlin/HelloWorld.kt

@@ -1,3 +1,3 @@
-fun hello(name: String = "World"): String {
-    return "Hello, ${if (name.isBlank()) "World" else name}!"
+fun hello(): String {
+    return "Hello, World!"
 }

data/tracks/kotlin/exercises/hello-world/README.md

@@ -14,6 +14,12 @@ The objectives are simple:
 
 If everything goes well, you will be ready to fetch your first real exercise.
 
+Since this is your first Kotlin exercise, we've included a detailed TUTORIAL.md
+file that guides you through your solution. Check it out for tips and
+assistance!
+
+
+
 
 
 ## Source

data/tracks/kotlin/exercises/hello-world/TUTORIAL.md

@@ -1,22 +1,15 @@
 NOTE: You can also view the HTML version of this file here:
 https://github.com/exercism/kotlin/blob/master/exercises/hello-world/TUTORIAL.md
 
+* [Introduction](#introduction)
+* [Exercise Structure](#exercise-structure)
 * [Solving "Hello, World!"](#solving-hello-world)
- * [Reading Gradle output](#reading-gradle-output)
- * [Fixing the first failing test](#fixing-the-first-failing-test)
- * [Enabling and fixing the second test](#enabling-and-fixing-the-second-test)
- * [Enabling and fixing the third test](#enabling-and-fixing-the-third-test)
- * [Enabling the last test](#enabling-the-last-test)
- * [Refactoring](#refactoring)
 * [Submitting your first iteration](#submitting-your-first-iteration)
 * [Next Steps](#next-steps)
- * [Review (and comment on) others' submissions to this exercise](#review-and-comment-on-others-submissions-to-this-exercise)
- * [Extend an exercise](#extend-an-exercise)
- * [Contribute to Exercism](#contribute-to-exercism)
 
 ----
 
-# Solving "Hello, World!"
+# Introduction
 
 Welcome to the first exercise on the Kotlin track!
 
@@ -35,7 +28,22 @@ left off.  If you haven't reviewed those instructions, do so now.
 
 The following instructions work equally well on Windows, Mac OS X and Linux.
 
-## Reading Gradle output
+# Exercise Structure
+
+When you fetch a new Kotlin exercise, you will receive:
+
+* __one or more test files__ (always). These live in the `src/test/kotlin`
+directory and define a set of tests that our solution must satisfy before we
+can safely declare that it is working.
+* __one or more starter files__ (initially). If provided, these live in the
+`src/main/kotlin` directory and define shells of the classes you will need
+in order to solve the current problem.
+
+
+
+# Solving "Hello World!"
+
+## Step 1: Run the tests against the starter solution
 
 Use Gradle to run the tests:
 
@@ -84,19 +92,14 @@ running the task you asked it to: executing the tests against the solution.
 ```
 :test
 
-HelloWorldTest > helloSampleName SKIPPED
 
-HelloWorldTest > helloBlankName SKIPPED
-
-HelloWorldTest > helloNoName FAILED
+HelloWorldTest > helloWorldTest FAILED
     org.junit.ComparisonFailure: expected:<[Hello, World!]> but was:<[]>
         at org.junit.Assert.assertEquals(Assert.java:115)
         at org.junit.Assert.assertEquals(Assert.java:144)
         at HelloWorldTest.helloNoName(HelloWorldTest.kt:10)
 
-HelloWorldTest > helloAnotherSampleName SKIPPED
-
-4 tests completed, 1 failed, 3 skipped
+1 test completed, 1 failed
 :test FAILED
 
 FAILURE: Build failed with an exception.
@@ -113,19 +116,19 @@ BUILD FAILED
 Total time: 7.473 secs
 ```
 
-Seeing the word "fail" NINE TIMES might give you the impression you've done
+Seeing the word "fail" might give you the impression you've done
 something horribly wrong!  You haven't.  It's a whole lot of noise over
 a single test not passing.
 
 Let's focus in on the important bits:
 
 ```
-HelloWorldTest > helloNoName FAILED
+HelloWorldTest > helloWorldTest FAILED
     org.junit.ComparisonFailure: expected:<[Hello, World!]> but was:<[]>
 ```
 
 ...is read: "Within the test class named `HelloWorldTest`, the test method
-`helloNoName` did not pass because the solution did not satisfy an
+`helloWorldTest` did not pass because the solution did not satisfy an
 assertion.  Apparently, we expected to see the string 'Hello, World!' but
 a blank string was returned instead.
 
@@ -133,7 +136,7 @@ The last line of the stack trace tells us exactly where this unsatisfied
 assertion lives:
 
 ```
-        at HelloWorldTest.helloNoName(HelloWorldTest.kt:10)
+        at HelloWorldTest.helloWorldTest(HelloWorldTest.kt:10)
 ```
 
 Looks like the scene of the crime is on line 10 in the test file.
@@ -145,25 +148,22 @@ Knowing these two facts,
 
 we can turn this failure into success.
 
-
-
-## Fixing the first failing test
+## Step 2: Fix the Test!
 
 In your favorite text editor, open `src/test/kotlin/HelloWorldTest.kt`
 and go to line 10.
 
 ```kotlin
-assertEquals("Hello, World!", hello(""))
+assertEquals("Hello, World!", hello())
 ```
 
-The test is expecting that `hello()`, when given an empty string (`""`),
-returns "Hello, World!".  Instead, `hello()` is returning `""`.
+The test is expecting that `hello()`, returns "Hello, World!".  Instead, `hello()` is returning `""`.
 Let's fix that.
 
 Open `src/main/kotlin/HelloWorld.kt`.
 
 ```kotlin
-fun hello(name: String = ""): String {
+fun hello(): String {
    return ""
 }
 ```
@@ -171,7 +171,7 @@ fun hello(name: String = ""): String {
 Let's change that to return the expected string:
 
 ```kotlin
-fun hello(name: String = ""): String {
+fun hello(): String {
    return "Hello, World!"
 }
 ```
@@ -181,7 +181,6 @@ Save the file and run the tests again:
 ```
 $ gradle test
 :compileKotlin
-w: /Users/jtigger/exercism/exercises/kotlin/hello-world/src/main/kotlin/HelloWorld.kt: (1, 11): Parameter 'name' is never used
 :compileJava UP-TO-DATE
 :copyMainKotlinClasses
 :processResources UP-TO-DATE
@@ -193,419 +192,18 @@ w: /Users/jtigger/exercism/exercises/kotlin/hello-world/src/main/kotlin/HelloWor
 :testClasses UP-TO-DATE
 :test
 
-HelloWorldTest > helloSampleName SKIPPED
-
-HelloWorldTest > helloBlankName SKIPPED
-
-HelloWorldTest > helloNoName PASSED
-
-HelloWorldTest > helloAnotherSampleName SKIPPED
+HelloWorldTest > helloWorldTest PASSED
 
 BUILD SUCCESSFUL
 
 Total time: 7.318 secs
 ```
 
-"BUILD SUCCESSFUL"!  Woohoo! :)  You can see that `helloNoName()` test is
+"BUILD SUCCESSFUL"!  Woohoo! :)  You can see that `helloWorldTest()` test is
 now passing.
 
-We still see the warning about `name` not being used; we'll get to that
-next.
-
-With one win under our belt, we can turn our focus to some other messages
-that we've been ignoring: the lines ending in "`SKIPPED`".
-
-Each test suite contains a series of tests, all of which have been marked
-to be skipped/ignored except the first one.  We did this to help you focus
-on getting one test running at a time.
-
-Let's tackle the next test...
-
-
-
-## Enabling and fixing the second test
-
-Right now, that second test is being skipped/ignored.  Let's enable it.
-
-(Re)open `src/test/kotlin/HelloWorldTest.kt` and find the second test:
-
-```kotlin
-@Test
-@Ignore
-fun helloSampleName() {
-    assertEquals("Hello, Alice!", hello("Alice"))
-}
-```
-
-When the JUnit test runner sees that `@Ignore` annotation on the test
-method, it knows to skip over that test.  Remove that line:
-
-```kotlin
-@Test
-fun helloSampleName() {
-    assertEquals("Hello, Alice!", hello("Alice"))
-}
-```
-
-Now, when you run the tests, both tests run:
-
-```
-$ gradle test
-:test
-
-HelloWorldTest > helloSampleName FAILED
-    org.junit.ComparisonFailure: expected:<Hello, [Alice]!> but was:<Hello, [World]!>
-        at org.junit.Assert.assertEquals(Assert.java:115)
-        at org.junit.Assert.assertEquals(Assert.java:144)
-        at HelloWorldTest.helloSampleName(HelloWorldTest.kt:15)
-
-HelloWorldTest > helloBlankName SKIPPED
-
-HelloWorldTest > helloNoName PASSED
-
-HelloWorldTest > helloAnotherSampleName SKIPPED
-
-4 tests completed, 1 failed, 2 skipped
-```
-
-The first test, `helloNoName()` continues to pass.  We see that
-`helloSampleName` -- the test we just un-`@Ignore`'d -- is now running and
-failing.  Yay, failing test!  In fact, the "failure" message is just
-describing the difference between what the program does now and what it
-should do for us to call it "done."
-
-Right now, we've hardcoded the greeting.  Enabling this second test has
-unleashed a new expectation: that our program incorporate a name given
-into that greeting.  When given the name "`Alice`", that's who should be
-greeted instead of "`World`".
-
-(Re)open `src/main/kotlin/HelloWorld.kt`.
-
-```kotlin
-fun hello(name: String = ""): String {
-   return "Hello, World!"
-}
-```
-
-While `hello()` does accept a reference to a string named `name`, it is not
-using it in the output.  Let's change that:
-
-
-```kotlin
-fun hello(name: String = ""): String {
-   return "Hello, $name!"
-}
-```
-
-_(Kotlin allows you to embed expressions within strings, a feature known as
-string interpolation.  For more about this feature, see
-https://kotlinlang.org/docs/reference/basic-types.html#string-templates )_
-
-... and rerun the tests ...
-
-```
-$ gradle test
-:test
-
-HelloWorldTest > helloSampleName PASSED
-
-HelloWorldTest > helloBlankName SKIPPED
-
-HelloWorldTest > helloNoName FAILED
-    org.junit.ComparisonFailure: expected:<Hello, [World]!> but was:<Hello, []!>
-        at org.junit.Assert.assertEquals(Assert.java:115)
-        at org.junit.Assert.assertEquals(Assert.java:144)
-        at HelloWorldTest.helloNoName(HelloWorldTest.kt:10)
-
-HelloWorldTest > helloAnotherSampleName SKIPPED
-
-4 tests completed, 1 failed, 2 skipped
-```
-
-Wait... didn't we just fix the test?  Why is it failing?  Take a closer look...
-
-In fact, `helloSampleName()` *is* passing.  It's just that at the same time,
-we just inadvertently broke that first test: `helloNoName()`.
-
-This is one tiny example of the benefit of maintaining a test suite: if we
-use them to drive out our code, the second we break the program the tests
-say so.  Since we saw them passing just *before* our latest change,
-whatever we *just* did most likely cause that regression.
-
-Our latest change was making the greeting dependent on the name given.  If
-no name is given, our function defaults to an empty string.  The intent is
-that when `hello()` is called on no one in particular, our function greets
-the whole world.  Sound like a job for a default value!
-
-`src/main/kotlin/HelloWorld.kt`:
-```kotlin
-fun hello(name: String = "World"): String {
-   return "Hello, $name!"
-}
-```
-
-... and re-run the tests ...
-
-```
-$ gradle test
-:compileKotlin
-:compileJava UP-TO-DATE
-:copyMainKotlinClasses
-:processResources UP-TO-DATE
-:classes UP-TO-DATE
-:compileTestKotlin
-:compileTestJava UP-TO-DATE
-:copyTestKotlinClasses
-:processTestResources UP-TO-DATE
-:testClasses UP-TO-DATE
-:test
-
-HelloWorldTest > helloSampleName PASSED
-
-HelloWorldTest > helloBlankName SKIPPED
-
-HelloWorldTest > helloNoName PASSED
-
-HelloWorldTest > helloAnotherSampleName SKIPPED
-
-BUILD SUCCESSFUL
-```
-
-Excellent!  Not only are both our tests passing, but that pesky warning
-about not using `name` has faded into the distant past.  We're now
-(at least) three-fourth the way done.  Just two more tests to go...
-
-
-
-## Enabling and fixing the third test
-
-(Re)open `src/test/kotlin/HelloWorldTest.kt` and find the penultimate test:
-
-```kotlin
-@Test
-@Ignore
-fun helloBlankName() {
-    assertEquals("Hello, World!", hello("    "))
-}
-```
-
-In this test, we're trying to be tricky.  It's one thing to omit a
-parameter completely; it's a whole other situation when we provide a blank
-string for a name.  This test is telling us that we'd like to treat these
-cases the same way.
-
-... and remove it's `@Ignore` to enable it ...
-
-```kotlin
-@Test
-fun helloBlankName() {
-    assertEquals("Hello, World!", hello("    "))
-}
-```
-
-... and re-run the tests ...
-
-```
-$ gradle test
-:test
-
-HelloWorldTest > helloSampleName PASSED
-
-HelloWorldTest > helloBlankName FAILED
-    org.junit.ComparisonFailure: expected:<Hello, [World]!> but was:<Hello, [    ]!>
-        at org.junit.Assert.assertEquals(Assert.java:115)
-        at org.junit.Assert.assertEquals(Assert.java:144)
-        at HelloWorldTest.helloBlankName(HelloWorldTest.kt:20)
-
-HelloWorldTest > helloNoName PASSED
-
-HelloWorldTest > helloAnotherSampleName SKIPPED
-
-4 tests completed, 1 failed, 1 skipped
-```
-
-Since `"    "` is an actual value, Kotlin does _not_ substitute in the
-default value.
-
-(Re)open `src/main/kotlin/HelloWorld.kt`.
-
-```kotlin
-fun hello(name: String = "World"): String {
-   return "Hello, $name!"
-}
-```
-
-One way to handle this case is to check to see if `name` is blank.  Let's
-do that:
-
-
-```kotlin
-fun hello(name: String = "World"): String {
-   return "Hello, ${if (name.isBlank()) "World" else name}!"
-}
-```
-
-As you can see, string templates can contain not just references to
-variables, but entire expressions!  This is appropriate in a case like this
-where we want to apply a simple condition to a value.
-
-... and rerun the tests ...
-
-```
-$ gradle test
-:test
-
-HelloWorldTest > helloSampleName PASSED
-
-HelloWorldTest > helloBlankName PASSED
-
-HelloWorldTest > helloNoName PASSED
-
-HelloWorldTest > helloAnotherSampleName SKIPPED
-
-BUILD SUCCESSFUL
-```
-
-We're almost there (perhaps closer than you think)!  Just _one_ more test
-to pass before we have a solution we can have real confidence in.
-
-
-
-## Enabling the last test
-
-(Re)open `src/test/kotlin/HelloWorldTest.kt` and find the last test:
-
-```kotlin
-@Test
-@Ignore
-fun helloAnotherSampleName() {
-    assertEquals("Hello, Bob!", hello("Bob"))
-}
-```
-
-... and pop-off that `@Ignore` ...
-
-```kotlin
-@Test
-fun helloAnotherSampleName() {
-    assertEquals("Hello, Bob!", hello("Bob"))
-}
-```
-
-... then rerun the tests ...
-
-```
-:test
-
-HelloWorldTest > helloSampleName PASSED
-
-HelloWorldTest > helloBlankName PASSED
-
-HelloWorldTest > helloNoName PASSED
-
-HelloWorldTest > helloAnotherSampleName PASSED
-
-BUILD SUCCESSFUL
-```
-
-Oh, hello!  Turns out, the solution we put into place didn't just apply for
-"`Alice`" but for "`Bob`" equally well.  In this case, the test succeeded
-with no additional code on our part.
-
 Congratulations!
 
-
-
-## Refactoring
-
-Now that you've got all the tests passing, you might consider whether
-the code is in the most readable/maintainable/efficient shape.  What makes
-for "good" design of software is a big topic.  The pursuit of it underlies
-much of what makes up the more valuable conversations on Exercism.
-
-Kotlin is such a concise language and this exercise is so small, there is
-not much room for us to make adjustments.  Most would leave this code, as
-is.
-
-That said, we've taken such pains to illustrate two core parts of the
-Test-Driven Development approach (i.e. "red", "green"), we'd be remiss if
-we skipped the all important final part: "refactor".
-
-More on TDD at http://www.jamesshore.com/Blog/Red-Green-Refactor.html.
-
-The core responsibility of `hello()` is to produce a personalized greeting.
-_How_ we determine whether or not a name is given (i.e. `name` is
-effectively an empty string) is a lower-level detail.
-
-```kotlin
-fun hello(name: String = "World"): String {
-   return "Hello, ${if (name.isBlank()) "World" else name}!"
-}
-```
-
-How would things read if we extracted that detail into a separate method?
-
-```kotlin
-fun hello(name: String = ""): String {
-   return "Hello, ${whom(name)}!"
-}
-
-private fun whom(name: String):String {
-   return if(name.isBlank()) "World" else name
-}
-```
-
-By extracting that logic into the `whom()` method, we've added a little
-abstraction to our program — it's not as literal as it was before.  Yet,
-it allows us to defer _needing_ to understand _how_ the recipient of the
-greeting is determined.
-
-If we can assume that `whom()` just works, we don't have to
-downshift in our head to those details.  Instead, we can remain at the same
-level of thinking: what's the greeting?
-
-_(Yes, this is considerable more lines of code; again, not a move we'd likely
-make typically.  The takeaway is this: when you are "done" with an exercise
-ask yourself, "can I adjust the shape of this code to better tell the
-story of what's going on through its shape?")_
-
-We made a bunch of changes, let's make sure we didn't break the program!
-
-```
-$ gradle test
-:compileKotlin
-:compileJava UP-TO-DATE
-:copyMainKotlinClasses
-:processResources UP-TO-DATE
-:classes UP-TO-DATE
-:compileTestKotlin
-:compileTestJava UP-TO-DATE
-:copyTestKotlinClasses UP-TO-DATE
-:processTestResources UP-TO-DATE
-:testClasses UP-TO-DATE
-:test
-
-HelloWorldTest > helloSampleName PASSED
-
-HelloWorldTest > helloBlankName PASSED
-
-HelloWorldTest > helloNoName PASSED
-
-HelloWorldTest > helloAnotherSampleName PASSED
-
-BUILD SUCCESSFUL
-```
-
-This illustrates another benefit of writing tests: you can make significant
-changes to the structure of the program and very quickly restore your
-confidence that the program still works.  These tests are a far cry from a
-"proof" of correctness, but well-written tests do a much better job of
-(very quickly) giving us evidence that it is.  Without them, we manually
-run the program with different inputs and/or inspecting the code
-line-by-line — time-consuming and error prone.
-
-
-
 # Submitting your first iteration
 
 With a working solution that we've reviewed, we're ready to submit it to