Forum

Same here! I could only comment and upvote on 8kyu problems. Sad!

Yes.

https://github.com/codewars/codewars.com/issues/2237#issuecomment-759748091 https://github.com/codewars/codewars.com/issues/2052#issuecomment-607520277 https://github.com/codewars/codewars.com/issues/1391

...and many more.

Thank you for pointing me to the git page. I see this issue has been discussed now for man years. Hss there been any protypes or newer versions impimented in this time frame?

If one manages to solve a Kata efficiently or with clean code, I think its alright for one to give oneself a 'pat in the back'.

I think it favors people who are more audacious.

Agreed. But let's keep in mind that CW is a site used for solving algo problems, so Clean and Clever solutions really help for people who may be struggling in coming up with one.

I agree. I would still prefer it if self votes would not be allowed. It does not hinder clean and clever solutions from beeing upvoted.

@premature: According to your profile your account was made in February this year and you did 366 Katas. That can't be correct or is it? How where you able to do so many Katas in such a short period of time? I am impressed.

Yup, I picked up Python in early Jan 2021. I used HackerRank for a week or two but felt like there were a small range of problems. So I moved into CW in Feb. I have been basically grinding katas these past 3 weeks starting with 8 kyus. To be honest, @Kischy, I didn't realise I completed that much.

Even if you do vote for your own solution it won't really give you points so... it's not really worth much to disable this feature.

I agree with this. Too many newbs (myself included) give out thier first best practices upvotes to those solutions that deserve instead a clever (at best). Was there ever a tutorial explaining the difference? Some solutions do have a clever looking best practice though, so it's a tough thing to explain. Fortunatly, people seem to have figured out the correct response once they are solving 5 Kyus.

I agree with this!

Hi,

you can open an issue with this suggestion here: https://github.com/Codewars/codewars.com/issues

Plus side of this is also that I can then sort by funny rating if I am in that mood :D

I like this one but i don;t see this feature coming anytime soon XD

I agree with you, we need the funny category.

For example I have solved most of the katas with one-liners just for fun. Most of the times that is definetly not the "best practice", and a long lambda function is more funny than "clever" practice :)

And a spell checker too!

i know who you are talking about XD

you should raise issue of this at here https://github.com/Codewars/codewars.com/issues

For example, my kata, https://www.codewars.com/kata/5f1891d30970800010626843/discuss/python got targeted and got an unsatisfied vote, with one more completion and no more new solutions.

he does that with every kata ()

ZED? I don't think so, he already has a solution. Who is it?

follow people who you want to inspired by and click on Solutions of Users I am Following on solution page.

That sounds excellent! Then the only thing left is to gather a bunch of inspiring people. Thanks for the tip!

The problem seems inherently a human trait -- the tendency to defer to the "wisdom" of the crowd. It's not uncommon for people to agree with a larger group on something even when their gut (and brain) tells them otherwise.

People need to think for themselves.

They'll have to scroll down to find it. Users can sort by: Best Practice (default), Clever, Newest, and Oldest.

Somtimes I also use another sorting to see and vote e.g. newer solutions instead of the ones that have already a lot of.

First you have to solve it, and after that you'll see:

How satisfied are you with this kata? VERY SOMEWHAT NONE

Thanks!

AFAIK you can only see them if you find them by chance, and sometimes you won't even know why that comment was downvoted.

first option: how do you rate the kata

Thankyou! Master.

1 year later and I'd like to bump this. I'm very curious to know what of my solutions have been upvoted so I can get a better idea of what other programmers think is good in my code.

Agreed!

I think it counts the upvotes of your solutions (made by others)

Many people have suggested this, but it doesn't really do anything. It's just re-labeling and re-leveling the playing field. Newbies and people with bad taste will still do their thing, and they'll utilize the downvote button too so it's not like giving everyone more power will make wiser people more influencial.

"They said it before, and we'll say it again..."

Add my vote also for a parallel "time to run" score! :D

Possibly this could lead to excessive re-running of solutions to get a lucky fast score. So maybe limit the publicable time-to-rum score just to a user's first successful solution for a given kata, or something like that?

Duration of execution is a criteria but this shouldn't be THE criteria to determine the best solution. The best solution should be a fine balance between complexity(related to execution time), readability and best practice.

> implying shortest code is never also the fastest code > implying fastest code = best code

Okay, let's switch to micro-optimizations then?

There are many dirty tricks to make your code execution faster. Most of which you will never use in production code. People will start upvoting fastest answers as "Best Practice" and people who learn to code will pick up some bad habbits. The only thing that could work is a special category of katas, purposely curated for execution time optimizations with solutions showed from fastest to slowest.

To be fair, the never-lasting debate about "what is best practice" happens because best practice can be many different things (same to clever):

• Fastest code
• Shortest code
• Best algorithm
• Cleanest code
• Most informative code
• Most thorough code
• ...

It's kinda like you're in Oscar and there's only a "Movie of the Year" category. Of course everyone will argue about its all-encompassing nature.

The way to go is, of course, split it into those categories and rank by there. But then it (probably) becomes too complicated for everyone. So I guess we're stuck at now.

You are right, and sometimes the shortest code is also the best, depending on language ie Haskell, JS Java C# F#, if it is short because it is coded functionally, or with nice comprehensions in python. not always just depends

This is what they said on the wiki.

If you got a lot of value out of the kata and found it to be well constructed, you should vote "Very"

*If you got some value out of the kata but the quality may not be top notch, you should vote "Somewhat"

If you got no value out of the kata, in regards to enjoyment, education experience, etc, then you should pick "None".

However, they also said something about the None rating:

If you think the kata itself is valuable but you simply have some issues with it, then you should select "Somewhat" and create an issue instead. If you thought the kata is really great, other than the issues, then you can choose "Very". Please do not choose "None" simply because the kata has an issue but it is otherwise a good kata. The satisfaction rating is meant to indicate quality of kata as a concept, not its current state of condition in terms of open issues.

Agreed. I think it would help, also, to actually be able to downvote best practice.

A solution that I would like would be that you'd actually have to write a word or two on why you think it is a good solution. Then whomever reads the comments can also value each vote according to his or hers own values.

Another solution would be that "best practice"-points are awarded for receiving said points from other people and that for each level achieved, you are awarded a number of "best practice"-points to mete out by default.

Totally agree. I've just started here and I'm noticing that horrific solutions (such as brute forcing) occassionally show up as the highest ranked "best practice" for easy kata.

Users who are below the "competent" kyus should certainly not be able to select best practice solutions (perhaps only experts should be able to).

Hi, I agree with both of you, but sometimes performance and readability (which is as important as speed for a Best Practices solution) don't go hand in hand. Other option is to give higher voting power for more competent users.

IMO in the current situation is the "Best Practices" voting "kind of useless". There are also funny cases when the same solution has high number of votes for both "Clever" and "Best Practices".

Regards,

suic

I think the missing piece in the voting might be something like "readability". I seems that best practise is used too fuzzy way.

About the performance: Maybe the site will be able to figure it out / compare it by itself one day. I don't see why that should affect your voting.

I havn't been here for quite some time....this time I want to learn more about python while the last time I wanted to learn JS (solvinb Kata's by reading tutrials/books on the paradigms, techniques and languages themselves)

The question is: what is the best solution? Overall I would say that the best solution in most languages is the one, that:

• is best readable
• has selfexplainatory variable names
• does not contain multiple return statements (spaghetti)
• is most explicit
• as many constant values as possible

While your argument about the run-times is def. valid I think this is not true for everything. If I remember my basic programming training correctly: Sacrificing above mentioned for a better runtime everywhere makes a project harder to maintain, as code is read far more often than written. Therefore code can and should be viewed as a form of written communication, where a good style is in balance between having it short and crisp while giving everybody the infotmation needed to understand what is going on (communicate to inform, not impress).

When the project in the end has run-time issues, you should look for the bottlenecks and work on those. When I using this (great) platform to learn JS I saw many (in my opinion) badly written but high voted solutions, that used bad variable names (a, b, c, d) which are put there automatically during the minification process.

Maybe the best practise voting system should be remodeled? ....a few thoughts on that could be (all standing for themselves while stacking should be possible)

• weighted voting system
• having different best practises: trivial/best readable/best runtime
• having experts or the kata auhor give best practise on best readable/best runtime solution
• grouping solutions and discussing them, tagging them (best readable/best runtime)
• semi closed voting system for "experts"

I am aware of the fact that most of what I have said might sond picky. But I am propably no exception in using this plattform to learn a programming language. While I have seen clean code (from other languages) I also know run time sensitive solutions and the necessity for both, wheras a total novice might not now the difference and is prone to learn a bad style.

...only my 10 pence of thought on the topic, no offence to anybody. I honestly like and adore this plattform and am thankful for the creators, developers and the work that was necessary to built it.

See thread below. Here's the picture again:

It just doesn't appear anywhere.

Oh, finally I found the answer on my problem, indeed right here in the forum down below. All is clear now:

Note that only approved katas have an upvote link. Beta katas get upvoted if you classify them as "ready".

I agree with you that there are upvoated solutions by "coolness", but I'll suggest a different solution.

The Clean Code category is already covered by the Best Practices. The problem is the lack of a regular Like button that everyone seems used to.

People just want to express that they've liked a solution, regardless of its practices or cleverness. I think Codewars should give that option, so the other categories can remain "unpolluted" by those votes.

Hi, I see your point, but codewars is a game and its primary purpose isn't to write production ready code. In some cases, those cool one-liners show you new features of a language or some important shortcuts. One-liners are about exploating the capabilities of the langauage or about applying some mathematical insights, which aren't obvious at first sight.

Nevertheless, this is a complicated topic. I've seen this while I was learning new languages. At the beginning it's easier to read and understand simple and clean (but often primitive) code, while later is much easier and quicker to read and understand terse (and maybe more cryptic) code which is without noise.

Best,

suic

There's two categories of UpVote for solutions. The problem is that the most concise solutions are getting UpVoted as "Best Practices" when they are clearly not. They are "Clever". That is why we use minifiers in the real world. I can only assume that this occurs due to folk who don't code for a living not realising the least code possible is very very rarely the Best Practice.

Well said, andy. I agree that clever is being mistaken for best practice. Certainly the 'cool' one-liners are harder to read.

@andyAnderson: Very well said.

While I agree that the Best practice button is being abused and treated as a like button as is the clever I will defend the concept of the clever button I only use it for things like taking a complex relationship and out writing a method that calculated the answer based on deriving an underlying mathematical relationship or using some other useful optimization or expanding the code to cover a real case or better yet class of cases that wasn’t tested for, this would also cover clever memorization strategies. Not just code golf or some other degenerate code practice that may be cool but not readable or functional.

Anyone got an answer for this? Couldn't find any easy way of locating my own upvoted solutions either...

Same here, I can't believe that any of my solutions got upvoted, but it says they did and I would love to see which ones they were. I upgraded to red to see if I could view them from the expanded stats page, but still nothing.

This is why I came to this discussion. I just got an extra upvote, but I don't know which of the hundreds of algorithms I've written got upvoted. It would really help. I suppose I'll have to write a script to find it? LOL, now there's a thought!

same here. perhaps I wrote a brilliant piece of code two months ago that went unnoticed, perhaps it was the one I had just great joy in creating the night before. I WISH I COULD KNOW!

I quite

I'd say that the addition of a "Fastest" category could cover that but then where do you stop? Do you add "Shortest"? Or what about a "Shortest and Fastest" category and then a "Cleverist and Fastest but not Shortest" category? If the Clever and Best Practices categories were used correctly I think we'd just about have it covered.

I think time & space complexity should be checked in tests. Like in codility. It is pretty important "how" user solves the task not only "if".

I agree, downvoting would be a useful mechanism to flag poorly written katas and/or encourage authors to fix them. Any user with a given account age/level of community engagement/# of katas solved/whatever should be able to downvote. Right now total upvotes is not useful info--it's just a proxy for length of time a kata has been on the site, since there's no way to reverse the trend.

Sometimes readability is more then fast execution. But yes I totally agree to you. I signed up here because I wanted to see not just how others solve some problem but also what solution is considered "best" by majority. Then I expected there to be microforum for every kata where discussion about why this and that is better. Simple "best practice" tag without comments are often not there yet. There is lot of work to be done...

@stealthguy I don't even see katas you authored when visiting your profile. Have you deleted them?

Yes, but here also some solutions should be filtered out. Or there should be better guidelines how to write tests, to not let cheat them in many different ways.

To resolve this, I suggest resetting kata votes to zero on approval. This will make it fair for all katas.

Of course, this will also require subtracting beta-stage votes from total votes on existing approved katas.

1. Maybe they can give a tour to the new warriors(users) who just signed up on codewars.
2. They can have a option to take tour any time in their profile.

I TOTALLY agree with the button being more prominent. I am still new to CW and I struggle to locate this button every time. Why not have this action in the same area where you bookmark the kata? The number of upvotes sits there too, but it is not clickable. Makes no sense at all. I just completed a fun kata in beta and struggled with this (again) hence me looking for an 'could be improved' comment.

I agree... at least we should be able to learn how long the other solutions took to pass the test.

I agree. I see its often the shortest code in words, that are upvoted, when it should be based on runtime insted.

Sometimes runtime is not the ultimate criterion. What I mean is yess add new way of sorting solutions by runtime it is going to be great! But do not remove current tagging by doing that.

It might be more constructive to point out the problems with a solution in a comment. Then people that are learning can see what exactly is wrong with the solution.

Sure, you should do that. Still, that doesn't solve the problem with potentially wrong or non-best-practice solutions being on top (or having positive votes, instead of negative)

Yeah this is something that we may add, although for now we want to see how things evolve for a bit longer. Often there is a few solutions that have 1 or 2 up votes when they really aren't best practices. These aren't so bad I think, because not having the downvote button actually causes people to instead leave a comment, which helps to foster discussion. We prefer to encourage discussion, our mission here isn't to catalog the worlds best solutions to a specific problem.

Having a "downvote" comment where you are forced to give a reason why its not a best practice might be a solution here. Another possible improvement is to show-by-default comments for solutions that have been voted on, so that someone doesn't miss the comments on why something is not actually a good practice.

The issue gets a bit more problematic though when there is a poor solution with a ton of votes. Downvotes would really help this case, although having comments as to why its not really a good solution be visible by default would probably stop the crowd from following along on the trend of up voting a particular solution.

What about having a best practice upvote require either making a comment that's linked to the best practices upvote, or upvoting a best practices comment? I think that the best practice feature would be much more useful if we could see why a solution is considered to be using best practices.

For what it's worth I don't think clever needs a similar system since it's usually self evident and it's not as important a vote as best practices.

Upvote comments sound good, but you can get upvotes with "Wow, so short -> best practice", so I still think down-vote isn't a bad idea.

+1 for downvote.

I don't think it's enough to just add a constructive comment to a bad solution that has a tonne of upvotes. I doubt if a large number of users even read the comments.

I've only been a member for a day and already noticed the problem described by others here.

I like the idea of requiring a comment for a downvote, and I like the idea of requiring one for an upvote too. I find the solutions disappointingly devoid of discussion, this may help.

What about the following alternative to downvotes: allow "Issue" comments on solutions.

+1 for downvote. I've seen a lot of inappropriate "best practices". I think it's a really shame.

+1 for downvote. It's really unfortunate when solutions that are problematic have lots of best practices upvotes.

I rather like the idea of upvoting best practice comments, rather than directly upvoting a best practice, as having a solution voted best practice doesn't really do much for most folks.

You should be able to up vote any kata that you have completed. If this isn't the case then its a bug.

Where do I press to upvote katas?

Next to the "Share this kata" section. Note that only approved katas have an upvote link. Beta katas get upvoted if you classify them as "ready".

Thank you. Excellent explanation. :)

Here is a potential way to calculate the sort order for the solutions page:

var ranks = {
  "kyu 8":12,
  "kyu 7":11,
  "kyu 6":10,
  "kyu 5":9,
  "kyu 4":8,
  "kyu 3":7,
  "kyu 2":6,
  "kyu 1":5,
  "dan 1":4,
  "dan 2":3,
  "dan 3":2,
  "dan 1":1
};

function getSolutionRankingScore( solution ) {
  var solutionScore = 0;
  
  solutionScore += getAgedSolutionBaseScore(solution);
  solutionScore += getRankBonusScore(solution);
  solutionScore += getUpvoteBonusScore(solution);
  
  return solutionScore;
}

function getAgedSolutionBaseScore( solution ) {
  // Base score for new solutions, diminishes as time goes by, allowing other new solutions to show up at the top
  const MILISECONDS_TO_HOURS = 1 / (1000 * 60 * 60),
  HALF_LIFE_24HOURS = -0.028881132523311,
  BASE_SCORE = 128;
  
  var solutionLifeHours = (new Date().getTime() - solution.submitTime) * MILISECONDS_TO_HOURS,
  return BASE_SCORE * Math.exp(HALF_LIFE_24HOURS * solutionLifeHours );
}

function getRankBonusScore( solution ) {
  // Bonus score for low ranking users completing high ranking solutions.
  return ranks[solution.userRankAtTimeOfSubmit] / ranks[solution.kataRank];
}

function getUpvoteBonusScore( solution ) {
  // Bonus score for upvotes
  // low ranking users provide less of a bump than high ranking users
  var rankAdjust = ranks.length + 1;
  return solution.upvotes.reduce(function(p,e,i){
    return p + (rankAdjust - ranks[e.userRankAtTimeOfUpvote) / 2];
  },0);
}

This is just an example to show how I would calculate the score from scratch. The variable names should be descriptive enough to make it clear what the code is doing. Let me know if you have any questions.

An example solution object:

solution = {
  "kataRank":"kyu 5",
  "submitTime":new Date(2013, 11, 11, 13, 55, 00), // 2013-11-11 01:55:00 PM
  "userRankAtTimeOfSubmit":"kyu 2",
  "upvotes":[
    {"userRankAtTimeOfUpvote":"kyu 2"}, // Always a self upvote!
    {"userRankAtTimeOfUpvote":"kyu 7"},
    {"userRankAtTimeOfUpvote":"kyu 5"}
  ]
};

If the score for the above sample solution is evaluated after exactly 24 hours, then the score will be 71.67. If evaluated after exactly one week, then the score will be 8.17. If an additional upvote by a kyu 3 user is gained during that week, then the score would be 11.17.

This is pretty interesting. A sort score field could be used that gets re-computed by a background task every time a new solution is saved or something is up voted. A simpler version is being used to compute the popularity score on the kata list page. We just use published_at.to_i as the base of the score, I may update that to use a half-life as well.

Something like this could be used for the default sort. I still think having straight-forward "highest voted" & "most recent" views would also be helpful. Also the sorting helps to solve part of the "late to the party" issue, but doesn't really help the "code golf preferred" issue that is starting to take place. I think its very important to be able to reward solutions as being easy to read, practical, efficient, creative, etc. Being to able to vote/tag a solution as having those attributes could also play into the default sort score.

As a side-note, it could be interesting to start to see kata form around possible algorithms to be used on Codewars (or other sites... but who cares about them). Once we support forks than users could "rebound" (if you are familiar with dribbble) other users kata/algorithms with design/logic changes. At the very least I can see a sort score & popularity score kata being very cool.

+1 for 'New solutions should generally sort to the top' Really good new solutions are at the bottom of page and nobody upvote them. It would be no problem for old solutions because good solutions are upvoted and stay at the top.

Not sure I completely understand getSolutionRankingScore and getUpvoteBonusScore,

but it seems that upvote points don't decay over time.

Wouldn't the concept fail to produce the desired effect if upvote points don't decay?

Solutions aren't displayed randomly yet. This is definitely an area that needs more focus and we intend to make some changes soon. Randomly showing solutions that aren't already up voted is probably the first step. Providing a couple of different views (latest, most popular, most concise, most creative, etc) is another approach we have been throwing around.

Some sort of "trending" view would probably help a lot too, where it excludes the up votes coming from maybe the top 5 solutions and focuses on the most recently up voted ones instead.

Good to know, and those are all good ideas. One other thought is to force people (or allow people to earn a little extra honor) by looking at other solutions and deciding to upvote or not to upvote. So you might show one solution per screen with two big buttons for each of those actions, and people would be forced or encouraged to look at some number of other solutions to the problem they just finished before moving on to their next kata. The number would probably need to small if it is required, because forward momentum/addiction is clearly important.

One other idea along these lines (and following HN) is to not show the number upvotes, to eliminate bandwagon bias. Or at the very least, not show the number of upvotes until you had yourself explicitly pressed "Upvote" or "No upvote".

Another view could be ranking according to test complition time.

I assume you meant "running time" and not "compilation time," since most (all?) of the languages here are interpreted. Regardless, though, I don't think that's a relevant metric. Katas are primarily about writing clean, readable code -- a human metric that has little to do with compilation time or running time.

How about we just disable the ability to up vote your own comments? Right now you can up vote your own comment (but don't get points for it).

That's fine too. I just thought of the self-upvote-by-default thing because that's how reddit does it. Maybe because it feels better to have your comments start at 1 rather than 0? :) I suppose it comes down to a matter of taste.

From a strict votes perspective I think the reddit style makes sense. The question is does that become confusing with the honor points system? You shouldn't get an honor point just for leaving a comment, comments should only be worth points if someone else finds them useful in some way.

I realize that its already confusing as it stands now, to be able to up vote your own comment but not earn honor for it. Thats really more of a bug than a design issue though.

It would be pretty elegant to simply award honor only if the upvote count is greater than one.

I'm a little late on the announcement, but this change has been implemented - in case you haven't noticed :)

You can still upvote your own kata solutions though.

Yeah, you can still upvote own kata solutions and (at least in my mind) it's not very appropriate ;]