John Wang wrote:
Thus we are enforcing users
that care about Serialization to use the release jar.
We already encourage folks to use a release jar if possible. So this is
not a big change. Also, if folks choose to build their own jar, then
they are expected to use that same jar everywhere, effectively making
their own release. That doesn't seem unreasonable to me. Incrementally
upgrading distributed systems has, at least in the past, been outside
the scope of Lucene.
3) Clean up the serialization story, either add SUID or implement
Externalizable for some classes within Lucene that implements Serializable:
From what I am told, this is too much work for the committers.
Not that it's too much work today, but that it adds an ongoing burden
and we should take this on cautiously if at all. If we want to go this
way we'd need to:
- document precisely which classes we'll evolve back-compatibly;
- document the releases (major? minor?) that will be compatible; and
- provide a test suite that validates this.
As a side note, we should probably move the back-compatibility
documentation from the wiki to the project website. This would permit
patches to it, among other things.
http://wiki.apache.org/lucene-java/BackwardsCompatibility
I hope you guys at least agree with me with the way it is currently, the
serialization story is broken, whether in documentation or in code.
Documenting an unstated assumption is a good thing to do, especially
when not everyone seems to share the assumption, but "broken" seems a
bit strong here.
I see the disagreement being its severity, and whether it is a trivial
fix, which I have learned it is not really my place to say.
I've outlined above what I think would be required. If you think that's
trivial, then please pursue it and show us how trivial it is. The patch
provided thus far is incomplete.
Please do understand this is not a far-fetched, made-up use-case, we are
running into this in production, and we are developing in accordance to
lucene documentation.
You developed based on some very optimistic guesses about some unstated
aspects. In Java, implementing Serializeable alone does not generally
provide any cross-version guarantees. Assuming that it did was risky.
Doug
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
