Let me start by saying that I agree with every point made by @PeterTaylor. Here are some additional opinions / arguments why we should indeed revive older challenges, and in some cases simply update the existing challenge:
Let's start with the why? What are reasons we want to revive older challenges.
When we look at past challenges, in general I see four categories:
- The (very) good ones will usually have quite a few upvotes as well as answers, and even today people will post in it. Golf you a quine for great good! from 2011, one of the very first challenges and "Hello, World!" from 2015 are two examples where answers are still posted in on a weekly basis.
The earliest challenges are from the start of 2011, but there is even one from December 2008 (migrated from Stackoverflow.com to PPCG). But, even though it's this old, the specs are clear; there are test cases; and the newest answers for the challenge are from only a couple of months ago (Christmas last year). So, no problems for these kind of challenges.
- Challenges which were also good at the time, but are now closed due to updated PPCG specs. This mostly consists of popularity-contest and code-bowling challenges, to name two categories, which are closed as Too broad and aren't really allowed to be posted anymore these days.
- The very hard, and usually unanswered challenges. The specs of the challenge are in most cases clear, but the challenge is very tough to answer, which is why no one did so yet.
- The in general good concepts, but which would be downvoted and/or closed as unclear due to lack of, well.., things we'd want to see today (clear rules; test cases; flexible I/O rules; etc.)
It's this last category which I would personally want to see revived in most cases. Let's start by giving an example of an old challenge which has been revived, and why it was revived.
Example of successful revival:
In September 2012 the following challenge was posted: Generate a Kolakoski sequence. The challenge was actually entirely clear. We are given clear specs, test cases (in the form of the first x items of the sequence), even references to useful sources. So, why does this challenge fall in the fourth category, and not in the first? Here is the relevant quote why:
Input will be provided as a single command line argument
n. Please write a full program that will print the first
n elements of the Kolakoski sequence (in order) to STDOUT, with each element separated by your favorite whitespace.
Full program; input as command-line argument; output printed to STDOUT with space/tab/newline delimiter. Bleh.. Very cumbersome I/O specs which make it impossible for some languages to even compete because they don't support command-line inputs.
Because of this part of the challenge, @MartinEnder revived it in March 2018: Compute the Kolakoski sequence. Now we have a very loose spec (including for sequences in general), giving every language their own choice of the most reasonable spec:
You may choose one of three formats to do so:
- Take an input n and output the nth term of the sequence, where n starts either from 0 or 1.
- Take an input n and output the terms up to and including the nth term of the sequence, where n starts either from 0 or 1 (i.e. either print the first n or the first n+1 terms).
- Output values from the sequence indefinitely.
In the second and third case, you may choose any reasonable, unambiguous list format. It's fine if there is no separator between the elements, since they're always a single digit by definition.
In the third case, if your submission is a function, you can also return an infinite list or a generator in languages that support them.
You may write a program or a function and use any of our standard methods of receiving input and providing output. Note that these loopholes are forbidden by default.
Verbose programming languages like Java or .NET C# will of course use a lambda function instead of a full program. In some languages outputting the first \$n+1\$ items newline separated is shortest, so they'll use that; and in other languages returning just the \$n\$th value is shortest, so they'll use that.
Note that there has been a meta-discussion about this challenge in particular: Should we repost the Kolakoski challenge? A Sandbox post was created for it; discussions has been going on; and the original OP has been contacted (and in the end gave his consent). I think if we want to revive old challenges to update the spec; make it more clearer; or any other valid reason, a similar scenario should take place where opinions are asked and compared and the original OP will be contacted.
Of course there are many different reasons why we'd want to revive. In the example above it was the extremely restricted I/O ruling, which made it for a lot of languages impossible to compete in an otherwise good challenge.
What challenges should we improve instead of revive?
Sometimes there are challenges which are good, but instead of very strict ruling / I/O, they lack almost everything and consist only of a few lines. In something like this challenge: Find the largest value of power, I/O is not mentioned at all, so we can assume the default can be used. However, due to the lack of test cases, and a clear spec of what are the possible inputs, I initially completely misunderstood the challenge (reading it again, this might be mainly my own fault and I was also a bit sleepy..) Regardless, would there have been more test cases for the edge cases, I would have seen my mistake right away. Also, it is not clear what the possible inputs are. What to do with negative integer inputs;
1; etc.? So although the concept of the challenge is clear, because it is so succinct and lacks test cases, I personally had trouble completely grasping what was being asked and therefore made a mistake initially.
I think in this case we should also contact the OP and update the existing challenge instead. Add test cases (especially for edge cases). Add perhaps an example. And perhaps explicitly mention the now implicit rules regarding I/O and loopholes.
One step back to the why again. Lately I've, and many others as well, noticed that fewer and fewer challenges are being posted. Since we've already have more than 10,000 posted challenges, it is of course harder and harder to come up with a good challenge concept that isn't a duplicate of an existing challenge.
Reviving good older challenges by updating their specs solves this problem as well. Now, I know these challenges are already available, and people can just pick an (old) challenge to write an answer in. But with 10,000 challenges you sometimes don't know where to begin to pick one to write an answer for.
Personally I write an answer for a challenge usually for one of three reasons: 1. The challenge has just been posted (I regularly look at the newest challenges). 2. Someone recently posted an answer for an existing challenge, and it's visible at the active tab of the home page. Or 3. I had an idea of a challenge in mind and wanted to make sure it wasn't a dupe yet, and noticed that someone else already posted something similar or related, so I write an answer for that challenge instead (if it doesn't contain an answer in my preferred programming languages to codegolf in yet).
I almost never just randomly browse through older challenges, check if no one has posted an answer in my preferred programming languages yet, and then write an answer for it. I (maybe falsely) assume this is the case for almost all people at PPCG. Reviving older challenges will mean that it's posted as a new challenge, and more people will see and compete in it.
All in all I think we should create some kind of action flow diagram we can follow with all the steps, and then either post the revised challenge in the Sandbox (and later to main), or edit the existing challenge (with consent from OP of course).