This project is read-only.


The Lucere Project will include two phases. The first will closely adhere to the Java API and structure, the second will diverge and concentrate on .Net-specific and other improvements.

Each of these phases will occur in the following layers:

Layer Description
Layer 1 Disk Access (Directory, File, Lock, etc)
Layer 2 Streamable Read and Write (Various readers/writers)
Layer 3 Persistable Domain Objects (Document, Field, Term, etc)
Layer 4 Logical Domain Objects (Queries, Scorers, Searchers, Analyzers, etc)

Project Phases

Phase One

The primary goal of this phase is to provide a working build of Lucene 3.0.2 in .NET. The basic conversions to implement the API in .NET will be done by hand. Getters and setters should be converted to properties, enums should be used, case updated, etc. These steps should follow the current project guidelines outlined in the developer documentation.

Stage One: Contracts and Tests

Each layer will need to be accomplished in series:
  1. Using the Java Lucene 3.0.2 code base as a reference, create the appropriate .NET interfaces, enums, etc,
  2. Update existing test cases to use the new interfaces and the MbUnit framework
  3. Create new unit tests as needed, to appropriately cover .NET changes, etc.

Stage Two: Implementation

Each layer (outlined above) can be worked on in parallel. By creating the the interfaces first, it is not necessary to wait until a depndency layer is implemented; simply use the interface and assume it will be implemented in the future. Create mocks where needed to prove the unit tests for the piece you are working on.

This stage will mirror the implementation of the existing 3.0.2 API and internal structure. The goal is a functioning, 3.0.2 compatible build which passes all tests. This should be compared to the existing Java 3.0.2 release for performance. When Lucene.Net 3.0.2 is released, additional performance comparisons can be made.

Phase Two

Phase two will be a redesign of the API, integrating whatever new ideas we have for the library. This may or may not include changing the structure internally. The new API will be a product of community input and discussion. The work in thie phase will follow the same pattern as Phase One, in which each layer is addressed in order. The interfaces will be redefined and the tests will be updated. The second phase will be to update those changes in the implementation.

Roadmap and Schedule

We would like to complete the first phase in four weeks (12/12/2010). This would mean that phase two would be ready to start by mid-December. It also means that if, for some reason, Lucene.Net is not able to complete their 3.0.2 port by that time, we could provide them with ours to prevent ASF status problems.

While this schedule is agressive, and includes many holidays (in the US, there is Thanksgiving, Christmas, New Years, etc), which will likely delay the current roadmap, it is hoped that we can at least complete the first phase by beginning of the new year.

Roadmap as of 12/15/2010

Phase One - 3.0.2 Implementation (11/15 - 12/12, four weeks)

  • Stage One - Contracts and tests (11/15 - 11/28, two weeks)
    • Layer 1 & 2 (11/15 - 11/21)
    • Layer 3 & 4 (11/22 - 11/28)
  • Stage Two - Implementation (11/29 - 12/12, two weeks)
    • All layers (11/29 - 12/12)

Phase Two - Refactoring and implementation

  • Stage One and Stage Two, all layers (12/13/2010 - 1/2/2011, three weeks)

If you have any questions or suggestions, please post them in the discussions or on the mailing list.

Last edited Nov 18, 2010 at 9:03 PM by thoward, version 2


stimpy77 Jan 8, 2011 at 4:22 PM 
Hi. How's progress? What does the roadmap look like now, as of mid-January?