this kata already has a Go version

Alright. Sure thing!
Thanks a lot for the heads up.

you wrote a comment in the Discourse proposing a Go translation with a link to this fork, but a Go version of the kata already existed at that point, this is why I am confused...

You can play around with your own forks, but please do not publish those unless they contain proposed improvements to the kata; otherwise they make maintenance more difficult and they could also get accidentally approved.

oh maybe i was just experminting what it means to fork something here
thanks for addressing this!

what is the purpose of this fork ?

unfortunately, ranks cannot be changed post-approval and are shared between languages

I mean to mention that within the description of the kata for people to avoid confusion for future folks. I have already solved it in the past. Mentioning it here won't be visible for newcomers and won't be helpful to help them understand the problem!

Read this for more info

this is already raised here as an issue

Thanks for resolving the issue. But concurrency is well-known as advanced level in Go and generally speaking, and that's why I considered this rank.

Look lemme share my thoughts for clarity. I wanted to present some excercises for people to train on before interviews e.g
When engineers get a chance to join companies, they are asked to solve an online test to examine their abilities. Usually & Often the test includes some debugging exercise like this. I wanted to let trainees get the sense of going through all possible places that could cause the bug. that's it!

Yes, the solution is so easy. Sometimes it's an = sign missing. But it requires an advanced understanding of advanced language topics or computer science topics in-general.

I am thinking now about what should or can i do in order to get your reported issue resolved, May you kindly advise? :)

But i'd love to learn more from you regarding why would this affect ranking. Just don't feel that i understand.

Good Catch! Thank you for that.

Though it is meant to be solved in any way that works and should adhere to best practices and idiomatic Go standards. The main purpose of authoring it is to start introducing some challenges for folks need to train on Go concurrency model since I've noticed a lack of such excercises and wanted to start myself. Same applies for Debugging in Go here on CW, all available are white 8kyu.

In a real-world scenario though, people's code/solutions will absolutely go through a review process to spot such inefficiencies in their solutions. So, if somebody tried a solution here for this kata, that works like the one you kindly presented .. they are supposed to check the other approaches/solutions after submitting theirs for the sake of learning. That's assuming they are approching the kata to learn/train on Go concurrency issues. And that's the main goal assumed by the platform. Otherwise, we need to set constraints (memory & time) to prevent such work arounds for agreed upon submission approaches. And since CW does not provide such ability, the only solution left is to add Performance tag and stress on the tests till they consume the 12 seconds threshold and may be also drain the available memory :D

I wanted to avoid the latter since begininng as I wanted the kata to focus on concurrency && debugging only. Because of the reason stated above (enrich debugging and concurrency kata available on the platform for Gophers).

Anyway, I do not think of an instant modification right away that can refuse similar kinda solutions. But as I told you it's the kinda kata that presumes innocence in trainees xD due to lack of constrains tuning.

However, I might re-think it to find out something "I feel there could be". But TBH, don't feel it's worth the effort as the main goal is specified within the desc along with an advice or pushing towards the standard & best practice. Since the only firewall to guard against other un-desired solutions is all about setting env constraints, which is not easily doable with the current environment, let it be I'd say.

Speaking of the ranking, I just went through the docs tryna find the most suitable rank for it. Ended up unable to determine. So used the feedback that usually is provided for early solvers during Beta state of any kata once they submit a successful solution at the top of the page. I found the most suitable one is as follows:

1. 4 kyu kata represent a competent programming level. At this level the kata begin to take some serious thought to complete. They include tasks that may handle:

• Computer science concepts utilizing complex algorithms
• Advanced design patterns
• Understanding intricate business requirements
• Advanced concepts such as concurrency, parallelism, meta programming and cryptography

2. 3 kyu kata represent a competent programming level. At this level the kata are similar to 4 kyu but are more challenging. They include tasks that may handle:

• Computer science concepts utilizing advanced algorithms
• Ability to implement advanced requirements in a scalable fashion
• Basic AI/machine learning algorithms
• Detailed usage of advanced concepts such as concurrency, parallelism and cryptography

and that was the only space where i found instructions on how to rank a kata related to concurrency that's to the point. Thus, changed the rank just yesterday to 4kyu instead of 6 or something i can't accurately remember now.

What about this? It doesn't look like it's expected to be solved this way. (Or if it is, it will definitely affect ranking...)