Topics:

The forum is deprecated and will become read-only.
Join our Discord or use GitHub Discussions.

Kata Best Practices

Kata Best Practices

Overview

The purpose of this guide is to present authors and editors with a style guide for Codewars Kata. Since its creation, hundreds of kata have been written for CodeWars. Many different people come to CodeWars looking for different kinds of challenges. Because of this, there can really be no definitive guide suitable for everyone.

However, there are general criteria that all authors should consider:

Avoid Sequential Titles

Many kata authors have in their mind a linear progression through exercises they have divised. Due to the non-linear nature of CodeWars, however, people cannot be expected to follow exercises in sequence. This leads to odd circumstances where kata intended later in a sequence are approved, while earlier ones are not. It is best to simply avoid sequential exercises all together.

However this doesn't mean that creating related kata is not encouraged. You can use a title prefix to help group related kata so that they are easy to discover. For example. Sorting Arrays: Basic Sorting & Sorting Arrays: Bubble Sort. The prefix will cause the "related kata" section to be more accurate.

Use Proper Grammar, Punctuation and Spelling

It is important, in an albeit superficial way, that kata be written in correct English. Many people are offput by kata that do not have proper grammar and spelling. So when authoring and editing kata, it is important to keep this in mind.

The most common grammatical mistakes in English are between it's and its, as well as there, their, and they're.

In addition to following conventional grammar and English, it is recommended that kata follow the Wikipedia Manual of Style. The Manual of Style suggests to avoid:

  • First and second person pronouns
  • Contractions

Be Clear

It should be clear in the instructions what the codewarrior is expected to complete in the kata. This is not always straightforward, especially for more challenging exercises. It is helpful to:

  • Include all relevant details
    • Give clear definitions of technical terms, along with references
    • Mention all of the corner cases you intend to cover in your tests
  • Motivate problems using concrete examples
  • Give examples of input/output pairs

In general, it is best to avoid:

  • Irrelevant details
  • Very abstract concepts
  • Overly complex specifications

Ideally, it should only take a reader a couple of minutes to get the idea behind a kata.

Make Sure Content is New

Something important to consider when one is writing or editing kata: Is the concept behind this kata novel?

There are many standard exercises in programming that are well represented on CodeWars. Some examples include:

  • FizzBuzz [1, 2, 3]
  • Fibonacci Sequences [1, 2, 3, 4, 5, 5, 6, 7]
  • Reverse [1, 2, 3, 4, 5, 6]

When working on a kata, make sure to check that it has not been done already. Every new kata should ideally teach something different.

Simplicity

A good kata should be as simple as possible. Even though there are no hard and fast rules for ensuring simplicity, however the following is recommended:

  • Limit the number of corner cases tested for
  • Unless specified explicitly, only test on valid inputs declared in the description
  • Focus on testing for behavior, rather than implementation details

Follow Conventions

When writing a kata it is highly recommended to follow convention. Two subject areas with a lot of conventions are mathematics and software engineering.

In mathematics, conventions often include the (generally undefined) behavior of functions over degenerate inputs. In discrete mathematics (number theory and logic) conventions are generally chosen to allow for a recursive definitions and avoid a messy base case. Other branches of mathematics follow conventions as well. Some examples include:

In software engineering, there are numerous sources of conventions. Some examples include:

Use Behavioral Driven Development (BDD) Testing

For Clojure, Java and Haskell, Codewars uses the industry standards in test frameworks. These frameworks naturally enforce a degree of structure to how tests are written.

Other languages do not enforce any structure, however. Whenever possible, tests should ideally use RSpec style block structure.

Here are examples for various CodeWars languages:

  • Javascript
var expect = require('chai').expect,
    samples = [],
    p = 0.1,
    k = 20,
    sigma = Math.sqrt(k*p*(1-p));
    
for(var i = 0; i < 1000; i++)
  samples.push(binomial_distribution_rand(p,k));

Test.describe("Sample of function follows the statistics of a binomially distributed random number generator", function(){
  Test.it("should have k*p as its mean", function() {
    var average = samples.reduce(function(a,b) {return a + b;}) / samples.length;
    expect(average).to.be.within(p*k, 3*sigma);
  });
});
  • Coffeescript
expect = require("chai").expect
samples = []
p = 0.1
k = 20
sigma = Math.sqrt(k * p * (1 - p))
i = 0

while i < 1000
    samples.push binomial_distribution_rand(p, k)
    i++

Test.describe "Sample of function follows the statistics of a binomially distributed random number generator", ->
    Test.it "should have k*p as its mean", ->
      average = samples.reduce((a, b) -> a + b) / samples.length
      expect(average).to.be.within p * k, 3 * sigma
  • Python
from math import abs, sqrt
p = 0.1
k = 20
sigma = sqrt(p * k * (1-p))
samples = [binomial_distribution_rand(p, k) for _ in range(1000)]

test.describe("Sample of function follows the statistics of a binomially distributed random number generator")
test.it("should have k*p as its mean")
sample_average = sum(samples) / len(samples)
text.expect(abs(sample_average - p*k) < 3 * sigma, "Sample average {0} should be within three sigma (where sigma = {1}) of the expected average {2}".format(sample_average, sigma, p*k))
  • Ruby
p = 0.1
k = 20
samples = (1..1000).map {|_| binomial_distribution_rand(p, k)}
sigma = Math.sqrt(p * k * (1-p))
describe "Sample of function follows the statistics of a binomially distributed random number generator" do
  it "should have k*p as its mean" do
     average = samples.instance_eval { reduce(:+) / size.to_f }
     Test.expect((average - p*k).abs < 3*sigma, "Sample average #{average} should be within three sigma (where sigma = #{sigma}) of the expected average #{p*k}")
  end
end

Have Full Code Coverage

While it is not possible to test for every possible input, you should aim for your tests to have Full Test Coverage.

This is perhaps easiest to do in Haskell. Here is an example, curtesy of bkaes:

Description: The dot product is usually encountered in linear algebra or scientific computing. It's also called scalar product or inner product sometimes:

In mathematics, the dot product, or scalar product (or sometimes inner product in the context of Euclidean space), is an algebraic operation that takes two equal-length sequences of numbers (usually coordinate vectors) and returns a single number. Wikipedia

In our case, we define the dot product algebraically for two vectors a = [a1, a2, …, an], b = [b1, b2, …, bn] as dot a b = a1 * b1 + a2 * b2 + … + an * bn.
Your task is to find permutations of a and b, such that dot a b is minimal, and return that value. For example, the dot product of [1,2,3] and [4,0,1] is minimal if we switch 0 and 1 in the second vector.

Test Fixture:

module MinimumDot.Test where
import MinimumDot (minDot)
import Test.Hspec
import Test.QuickCheck
import Data.List (sort)

sameLength :: [a] -> [a] -> ([a], [a])
sameLength xs ys = let r = zip xs ys
                   in (map fst r, map snd r)

main = hspec $ do
  describe "minDot" $ do
    it "should work for the empty list" $
      minDot [] [] `shouldBe` (0 :: Double)
    it "should work for the examples" $ do
      minDot [1,2,3,4,5] [0,1,1,1,0]  `shouldBe` 6
      minDot [1,2,3,4,5] [0,0,1,1,-4] `shouldBe` -17
      minDot [1,3,5]     [4,-2,1]     `shouldBe` -3
    it "should work for random lists" $
      property $ \xs ys ->
        let (xs', ys') = sameLength xs ys
        in minDot xs' ys' `shouldBe` (solution xs' ys' :: Integer)
  where solution xs ys = sum $ zipWith (*) (sort xs) $ reverse $ sort ys

This tests more or less every possible input, including cases of empty lists. The author has provided a gold solution, and tests different kinds of randomized input against the gold solution. This level of testing borders of overkill, however we can be extremely confident that any two solutions will behave exactly the same.

Test for Invariants

Whenever possible, it is encouraged that kata test for invariants. These are laws that a solution must obey to be correct. Some examples of common invariants include:

Discuss:

  • Please sign in or sign up to leave a comment.
  • hcl7 Avatar

    #include <stdlib.h>

    int getIndex( const int arr[], int el, size_t n);

    int *array_diff(const int *arr1, size_t n1, const int *arr2, size_t n2, size_t *z) { if(n1 == 0){ return 0; }else { int tmp[] = {0}; int index = 0; for (size_t t=0;t<n1;t++){ tmp[t] = arr1[t]; }

    for (size_t i=0;i<n2;i++){
  while (index != -1){
    index = getIndex(tmp, arr2[i], n1);
    for (size_t k=index;k<n1;k++){
      tmp[k] = tmp[k+1];
    }
  }
  index = 0;
}
z = (size_t *)(sizeof(tmp) / sizeof(tmp[0]));
return (int *)(sizeof(tmp) / sizeof(tmp[0]));

    } }

    int getIndex( const int arr[], int el, size_t n){ int h = -1; for (size_t i=0;i<n;i++){ if (arr[i] == el){ h = i; break; } } if (h != -1){ return h; } else return -1; }

    help with this, is become frustating.

  • MLOpt Avatar

    I have some ideas for kata from the machine learning and combinatorial optimisation fields. These problem types both include datasets and usually a longer processing time than is allowed here.

    I'm looking around and can see this kind of problem is atypical on the site, so my first question is would more problems like this be welcome? If so, would it be reasonable for users to code the solutions off-site and submit the results instead of an algorithm? In code wars you'd merely write a function that returns the result.

    For example, I have a staff rostering dataset constrained enough that it can be solved to optimality (these are usually NP-Hard problems), but doing so typically takes 20 minutes of processing. If a user could do the processing off-site and submit a result with a high-enough objective score, that would be proof enough that they've solved it.

    For testing, I'd merely run the result, which would be a completed roster, through an objective function and check that the objective score is the expected range.

    Just wanted to run it by the community before putting the effort in.

    Thanks.

  • NoSoCo Avatar

    Does the time complexity of my solution affect the run time of the person who's solving the code? More specifically for Java.

  • kuniku Avatar

    i want to create kata, but don't know how to write the test.. i saw many kata use 'Test' but when i trying to implement it said 'Test is undefined', can someone help me to write example test

  • RedMountain Avatar

    How do I create a kata? I saw one person on youtube say it is in the dropdown menu where sign out and view profile is. I don't see it, can anybody help me.

  • Mert21433 Avatar

    Hello. I am trying to learn coding by myself, there is a problem I have been having. I struggle and solve 8 and 7 kyu problems(Sometimes.), when I see other user solutions, they are much more neat and orderly and have things that I have no idea what they are. I have no idea how to get there. Is there a source I can learn these methods of solving? I have been studying the solutions, but if there is a another way, I would like to do that aswell. (I have watched a lot of tutorials already, but if you have new suggestions, I would like to take a look.)

  • shtou Avatar

    can katas include public libraries for a specific programming language,like doing security related challenges in python by leveraging the pwn public library?

  • amirsaeed671 Avatar

    is it a bad habit that if I could not solve one problem for 1 or 2 days than i should click on unlock solution??

  • user7897247 Avatar

    Anyone else think that some Kata about decision-making AI would be of great value? (Asking because I don't want to spend weeks on a Kata and then let it suffer retirement because it wasn't of much value...)

  • JoshuaBones Avatar

    I'd like to suggest that kata creators follow best sql table naming practices and not naming them plural. Nearly every kata I've done has this.

  • NevErOddOɿƎvɘИ Avatar

    Looking for the documentation on how to get involved in Kata Translation. I am reasonably proficient in Python, and learning Clojure. I could can see that I would learn stuff and contribute to the community by translating Kata with Python solutions into Clojure. Would appreciate advice on how to get started in this direction. Thanks!

  • KenKamau Avatar

    I'm writing my first Kata and I'm really stuck on where test data should be stored, so that it is imported as: module Codewars.MyPrefix.KataName.Test where or module MinimumDot.Test where in the Test Fixture.

    My module name would be: module Codewars.MyPrefix.KataName. Where does the .Test come from?

    This is for Haskell.

  • nitinaggarwal1986 Avatar

    Repeatedly getting error Error: Command failed: javac -verbose -cp followed by a long list of description. Any idea why I am getting this?

  • macobo Avatar

    I have a task idea, but for it to be interesting it requires bounding the amount of extra memory you can allocate in your solution (O(1)).

    Is there a way to limit the amount of memory used (i.e. enforce O(1) or limit the number of variables you can have) in any language?

    I guess you could do it in say javascript via regex-checking all var, const, foo.bar = 5, window and banning them as well as eval, and force you to use a passed in function to save values, but this approach is bound to be full of holes. Any ideas?

  • xiaoyufan Avatar

    It's kind of weird to see many solutions in javascript using lots of array operations (filter, reduce...) are voted as cleverest, just because they are written in one or two lines. They may look clever, but they are actually quite slow and inefficient (looping through an array over and over). Hope Kata could introduce performance measure in the future.

  • Everstalk Avatar

    So after managing so solve a problem, I observe that other solutions to that same problem are cleverer and are written in fewer lines of code than mine(by smarter programmers no doubt). How do I get from my level to that level?

  • user5454555 Avatar

    Regarding specifications from standards committees it should be ECMA 262 instead of EMCA 262. Am I wrong?

  • JTorr Avatar

    I am translating a Kata into Ruby, and need to disable the use of certain operators. What is the best way to go about this?

  • bkaes Avatar

    This article should be shown the first time you write a new kata. Like an EULA, the user should read it and has to acknowledge that he read it. I completely forgot about it since my last comment and started writing my own best practice guide since I saw the same non-best practice behaviour over and over.

    Off-topic: While writing this comment, I thought "Huh, that code seems familiar". "This level of testing borders of overkill". Ah, yes, that's definitely what I would do. Then I've noticed my name. It's funny how things always come back to you on this site.

  • GiacomoSorbi Avatar

    I had this interesting discussion here about translating a kata with uncommon usage of variables and data structures, among other things (you can read about it in my reply to jolaf and, below, discussing it with the kata creator damned3).

    As I stated, I decided to keep them both to preserve the original aspect of the kata (which may or may not add to its difficulty but surely forces you to think things differently) and out of respect for the choices of the original author.

    If you wish, it was more of an artistic thing than a coding issue, but even so I wondered what other fellow code-warriors thought about this approach and their reasons.

    Thanks in advance for your kind feed :)

  • ma3east Avatar

    Just a small thing, the link to the Wikipedia Manual of Style, in the 'Use Proper Grammar, Punctuation and Spelling' section is incorrect,i assume you want to use either one of these instead.

    http://en.wikipedia.org/wiki/Wikipedia:Manual_of_Style/Text_formatting http://en.wikipedia.org/wiki/Wikipedia:Manual_of_Style

  • julescopeland Avatar

    May I suggest another sub-heading for the testing section?

    The test output needs to give really clear messages as to why a test is failing. I've seen so many katas where the only feedback is 'expected to receive x, but received y'. This might be ok for some scenarios, but when the entire test suite is actually just a single spec and you only have the returned failure messages for each line, it tells you nothing about why your code is failing.

    I'm a rubyist primarily, and the general rule is 'one assertion per spec'. That way, when something fails, you can see what element of the code you were checking for in the first place from the spec description. There are far to many where the test suite comprises of a single spec called something like 'it returns the correct answer', with about 15 assertions in it - all checking different things.

  • user3482173 Avatar

    Do you have to ask the author before translating a kata ?

  • leif Avatar

    Hello,

    I have some (probably beginner ;-)) questions that I just could not figure out myself.

    1. Is there a way to create a solution with multiple files?
    2. On a java kata I was trying to import java.util.function. But it didn't compile. I thought it comes with java 1.8 which should be the target jre version. Any ideas? (sorry I'm not a java expert.)

    Thanks a lot!

  • Talamantez Avatar

    Hi all - is there any documentation on writing tests for this framework?

  • user3482173 Avatar

    IS it possible to include mathematical formula in a kata description ? Same question for the javascript test/output (console.log) ?

    IS it possible to include formatting in a kata description (titles,bold) ? Same question for the javascript test/output (console.log) ?

  • artisanV Avatar

    I want to create katas out of interview questions that are already available on the web albeit with some alterations. I would like to credit the source. Is this needed? If so, what is the best place to do so?

  • christianhammer Avatar

    Could we build up a knowledge base of code we can apply when making the tests. Eg. how do you turn off certain features, like RegExp? How do you shuffle an array? Stuff like that.

  • errinlarsen Avatar

    I am dissapointed in the number of solutions I see that are object based.

    Disclaimer: I am a Rubyist, and as such I have only been practicing Ruby kata.

    The entire point of training with kata is to develop positive habits with practice. If you are developing in an OO language, the positive habits you want to develop are Object Oriented in nature. If the code you produce while training with kata is not Object Oriented, then you are not developing habits that will help your Object Oriented programming!

    In my opinion, Ruby is one of the greatest OO languages ever produced. We should be using the power of Objects that it provides!

  • jhoffner Avatar

    Never just use Test.expect() in your test cases, unless you are using the spec pattern (describe/it). Some sort of feedback is needed or those training on the kata will drive themselves crazy. If you are worried about warriors knowing the expected outputs and hardcoding values than you could include a few Test.expect() tests at the end of the tests, after you have used a few more descriptive tests to help warriors get through the hump.

    One exception to this rule that I can think of is if you are creating a kata that is meant to force users to write their own test cases. If this is your intention, you should call it out in the kata description. In this case you should also make sure every single requirement is explained within the description so that there are no hidden gotchas in the test cases.

  • JulianNicholls Avatar

    It would be good if the Katas were all done in all three languages, or at the very least there should be a Coffescript version of any Javascript Katas. Many might say 'I only know Javascript', but the whole raison d'etre of the site is to learn...

  • jhoffner Avatar

    In regards to how to handle testing for edge-cases, IMO the author should be explicit in how they handle this. I see 2 main approaches.

    • Be very exact in how edge cases should be handled. The design is pre-decided and test cases are implemented to test for that chosen design. The benefit here is that it is meant to force users to make their code more robust.

    • Not test for edge-cases at all, and allow each end-user (code warrior) to decide how robust the code should be. The benefit here is that it allows more expression on the end-users part, and those that solve the problem with the most thought out design will get higher up votes.

    I personally think both of these approaches are appropriate and picking one depends on what type of training the kata is meant to provide.

    Either way, be deliberate about your approach. Call it out in the instructions and make sure your test cases are appropriate.

  • ineiti Avatar

    We started a discussion with jfarmer about code-styles (which will be different for each language), so I'd like to start a topic of

    RUBY-STYLES

    what to do with

    • variable-names
    • do...end <-> {}
    • parameters with / without spaces
    • indents

    ?? Let the flame-war begin ;)

  • constablebrew Avatar

    Always include at least one full example test case that the student can copy-paste into the test fixture section

  • bkimmel Avatar

    A couple more on Kata testing practices:

    1. In te failure messages for your tests, be as descriptive as possible about what you were expecting and (where applicable) what you got instead... It is frustrating for students to be validating their solution and just get an "error" message with no description of why their test case didn't pass.
    2. If you expect vars to be closed within certain objects, be sure to test global scope to ensure that they weren't just tacked on to global.
  • bkimmel Avatar

    Just to throw a few out there;

    1. Don't violate your own description in your test cases... if you say "n is an integer" in the description, then don't make n null or {} in your test cases... this is one of my biggest pet peeves about kata.
    2. Don't assume the student "knows" what process you are talking about in your exercise... explain what you expect with as much formal detail as possible.
    3. Don't be afraid to disable things like Prototype.array.sort in the pre-loads, but be explicit when you do it .
    4. Engage with students on the kata you create. Give them a "nice job" and maybe an upvote on their solution when you are the sensei...Ask some interesting questions/ start a discussion about how the kata might apply in "real-world" systems... Codewars offers the ability to engage with your students, so use it.
    5. When you are creating a kata, have a certain technique or language feature in mind that you want to teach, and maintain your focus on that... generally the best kata cleave to this guideline, and the worst just make the student handle complexity for complexity's sake...