There are two things missing in this Kata that would definitely make it easier to understand.

1. It states that the stacks are persistent between calls to read, but you should also state that the "current stack" is persistent since the random test cases fail if the current stack is reset to 0 between reads.
2. Sample test cases should be included which test persistence of the stacks between calls to read. Ideally, it should also test that different instances of the Interpreter class have different stacks.

Other than that, this was a great Kata!

I managed to do it through pure logic. I can't say if my solution is the most efficient, but it was successful without any guesswork.

This is a really fun kata and I enjoyed solving it. My only issue was that I ran into an intermittent bug with the random test cases in Javascript. Based on my understanding of the kata, I believe my solution should have been valid (and my solution passed after re-submitting it immediately after). I copied the test case output from a failed test to help in fixing it:

Testing for -0xb+0xbc+15x
It should work for random inputs too - Expected: 15x+0bcx, instead got: 15x

Thanks, and keep up the great work!

Good kata with one very minor issue - the "Angular" constructor is locked, which makes it confusing to try to add a new property (for tracking dependencies). It is easy to workaround but may be worth mentioning in the description.

The description could use some major improvements for this kata. In particular, please define the format for what will be passed in as context to save people time inspecting everything. In particular, state that the context object will have a 'filters' property and a 'context' property from which the respective content and filter input will be derived. Additionally, it would be helpful to state that the filter functions are just wrappers for inner function, which is what should really be called (eg: output = filterFunction()(input)). The majority of the time I spent on this kata was simply trying to understand the input.

This actually really confused me. Shouldn't it be "Any set/del after an undo should disallow new redos" (/undos/redos/)? Since you should still be able to perform undo operations after a set/del operation following an undo operation.

Love this Kata! The main improvements I would suggest would be to specify how (or if) the order of pipeline/limiters should be handled. I assumed in my implementation that they should be run/tested in the order in which they were added.

I really enjoyed the first Kata in this series, but I feel like the hardest part of the second Kata is simply understanding the requirements. Despite that, this is a great series overall so far!

As others have suggested, the description needs to clearly state that the task is only to flatten a single layer. Also - since it does not test any invalid input it wouldn't hurt to add a note to that effect in the description as well. Alternatively it might be a good idea to test edge cases - such as an empty array, a null object, or an array with one or more values that are not sub-arrays.

It would be helpful for the description to state that it will be tested with very large numbers (save people time converting to/from integers) - maybe even include one in the default test cases to make it clear.

Also wouldn't hurt to add some extra tags.

An interesting Kata, but as many others have stated the title and description could use some work. It would be even better if you could provide an example of when this type of programming might be helpful (not saying that it can't be, just that a real-world example can make a big impact on people's perspective of the kata).

A fun Kata, but needs some test cases to Train against, as well as some additional tests (possibly randomly generated) during submission.

Needs better details - in particular, how do you know when Jack Sparrow has "escaped" from jail? The error messages could also be improved ("Take another path" is not terribly helpful).

Maybe I'm just overthinking it since the Average Assessed Rank so far is 6, but I can't seem to get past the 5th test without more details about what I'm trying to accomplish, what the options available to me are, or at least what the limitations are.

On a side note - it's a bit annoying that you have to submit your code to run tests - the "Run Tests" button does not appear to work.

After submitting this solution I realized that the "shouldn't pass any dependencies into the function if such dependencies aren't specified" was actually testing functions with no parameters (as opposed to functions with undefined dependencies). I have fixed my code to work properly in all cases, as well as fixed a small test case error, in a second solution (since you can't edit solutions after submitting them). Please refer to that solution instead of this one as that is the "valid" solution and this one merely "works".