Code requiring a third-party pre-processor to make it work

Question

In this Wolves, Goats and Cabbages in Java question (here is a link to the pre-edited version), Java code is presented to solve the problem.

The code requires pre-processing by a third-party tool in order to function.

The third-party tool adds a number of 'template' or 'boilerplate' methods that make the code complete. In Java terms, these are things like getters, setters, toString(), equals(), and hashCode().

Without pre-processing the code, it is:

• full of errors, and will not compile.
• comprehensively broken in 'standard' IDE's like Eclipse, IntelliJ, Netbeans, etc.

In order to pre-process the code, you need to download the pre-processor, as well as plugins for the various IDEs so that they are modified to accommodate these pre-processor annotations.

These downloads are from a non-official site, and are not part of any standard tool-chain.

For example, from the question we have the interface Action, and the class ActionImpl:

import java.util.Collection;

public interface Action<T> {

    Action<T> previous();

    T data();

    Collection<Action<T>> children();

    void children(Collection<Action<T>> children);

}

and

@Accessors(fluent = true, chain = false)
@Data()
@EqualsAndHashCode(of = "data")
@ToString(of = {"data"})
public class ActionImpl<T> implements Action<T> {

    private final Action<T> previous;
    private final T data;
    private Collection<Action<T>> children;

}

In Java terms, the ActionImpl class is missing four methods:

• previous()
• data()
• children()
• children(Collection<Action<T>>)

Additionally, there are compile/IDE errors for all the @Annotations which do not exist.

This makes the class fail to compile, and, essentially, there is nothing to review ;-)

Question:

Is it working code, or is it off-topic?

Answer 1

What is code but instructions to a compiler?

Would we allow an obscure language that no one here has a compiler to? I would hope the answer is yes. You might not be able to answer it but another person might.

I can currently think of more than one example that we would accept but requires an extension/plugin. less-css is one that I personally use. It requires "pre-"processing" of a sort and compiles to css. Unless I have missed some important clue I don't personally see a difference here.

I would suggest that the normal language tag alone in this case is incorrect. Further tagging it with the extension/pre-processor/whatever tag.

I'd vote for On topic.

Answer 2

I agree with @JamesKhoury.

The GNU GPL defines "source code" as "the preferred form of the work for making modifications to it". For the author of the question, that means the version of the code with the meta-programming annotations.

It does not make sense to review the post-processed form of the code, because we would then be critiquing auto-generated code, which isn't something that the author has full control over. (As an extreme analogy, consider CoffeeScript. You wouldn't compile it into JavaScript, then review the JavaScript.)

We gladly accept code that requires the various CSS preprocessors. We would also accept Perl code written using Moose — a similarly transformative third-party library for meta-programming. The objection, I believe, is not to the fact that the code requires a preprocessor, but that this particular preprocessor is (currently) obscure. Although it is a third-party dependency, it's not a particularly onerous one: the preprocessor is MIT-licensed, and all you have to do is include it in your classpath when compiling. In that sense, it is not any more of an inconvenience compared to other dependencies such as Apache Commons or Joda Time.

As for that particular question, I believe that replacing the original code with the post-processed code was an invalid edit.

If you don't like the Lombok preprocessor, you could create a lombok tag so that you can choose to ignore such questions in the future. Now that the question has been replaced with post-processed code, though, taking that option would make a further mess of things.

Answer 3

It is on-topic, however I would remove the java tag.

At least for all the coffeescript questions I ruthlessly remove the javascript tag, it is not JavaScript! Tags should reflect the language of the code, not the language that is about to be generated.

Answer 4

It's been almost two days and still can't find out how the code is working(?). It might be that I'm not very familiar with Java8. Still I would say the question is on-topic. Why?

To quote palacsint

See also: Effective Java, 2nd edition, Item 47: Know and use the libraries (The author mentions only the JDK's built-in libraries but I think the reasoning could be true for other libraries too.)