---------------------------------------------------------

SUMMARY AND OUTLOOK - detailled changelog is below:

The main goal of this build is to improve the very poor latency of the
web interface.
This is done by redesigning the way fetched Identity XML files are
processed.
Previously, each file would be processed in a thread of its own, even
though the actual processing requires a single lock which can only be
taken by one thread at once. This did cause processing to be effectively
single-threaded, while hundreds or even thousands of threads would be
piling up when competing for the single lock.
With this build, processing is redesigned to queue fetched XML files to
disk and process them one-by-one on a single thread.
As a result, the web interface thread now does not have to compete
against hundreds of threads who want the same lock.
This will result in much lower latency of the web interface, especially
if your WOT is not permanently running and thus at startup has to
process many identity files in bulk.

There are some more benefits which are listed in the detailled changelog
below.

It is still possible for the web interface to stall for minutes due to
the fact that the computations to import a trust list are still
implemented with a very poor algorithm.
The goal of the next build is to improve this algorithm significantly.

Also, please notice that usage of client applications which have not
been adapted to use the new WOT event-notifications API yet can slow
down the web interface significantly. This applies to especially Sone
which downloads almost the whole WOT database every 60 seconds.
If you are a client application developer and want to make usage of
event-notifications, please contact me on IRC, I am willing to help by
explaining how to use the reference implementation FCP client.

Some builds later on, the locking from the web interface will be removed
completely to allow it to always render instantaneously. This will take
some time to implement due to issues with the database and thus has
been postponed to after the more easy algorithm improvements.

In addition to the performance fixes, many new translations of the UI
are included: 9 new languages, and 3 updated ones.
Very very many thanks to the contributors on Transifex!

CHANGELOG - prefixed with the bugtracker issue number:

- 0006244: [Performance] Queue fetched trust lists instead of processing
           them immediately (xor / nextgens)

  This is what has been described in the introduction.

  Beyond the latency improvement of the web interface, this also:
  - Helps plugins such as FlogHelper which have not been adapted to
    event-notifications yet. They should lose connection to WOT less
    frequently, which fixes issues such as FlogHelper saying that WOT
    is not loaded even though it is.
  - Helps users of machines with little memory such as Raspberry Pi.
    Less threads = less memory usage.
  - Speeds up shutdown
  - Reduce total CPU/IO usage by identity file deduplication: If an
    identity file is queued for processing with edition N, and the node
    fetches edition N+1 of that identity before edition N has been
    processed, then the old edition N will be dropped. Only the newest
    will be processed. It is possible that deduplication does not yield
    a good ratio yet. To fix this, more measurements will have to be
    done in the future to tweak the time window for which we wait before
    processing a queued file. Generally, on faster machines there will
    be less deduplication.
    To compute the deduplication ratio, go to the "Statistics" page
    and divide "Deduplicated files" by "Total ever enqueued (= fetched)
    files". Feel welcome to share this number with the team.
  - Helps make WOT look less buggy to new users: They were the ones
    where the most new XML files would be fetched at once, and thus
    did suffer the most severe web interface lockup.

  You can view statistics about the new identity file queue and identity
  file processor on WOT's "Statistics" page.
  In particular, the two "Failed files" counters are of interest.
  Consider looking at your log files if they are non-zero.
  Instructions for logging are in "Testing instructions.txt"

- 0006561: [Usability] L10n: Add new translations from Transifex, update
           existing ones (operhiem1, and many Transifex contributors)
  0006560: [Security] L10n: Review German translation on Transifex (xor)
  0006495: [Usability] L10n: Update Transifex, new l10n strings have
           been added (operhiem1)

  New translations:
    Brazilian Portugese
    Finnish
    French
    Greek
    Hungarian
    Norwegian
    Polish
    Simplified Chinese
    Spanish

  Updated translations:
    Dutch
    German (also fully reviewed and improved compared to English, can be
            considered as reference translation)
    Italian

- 0006499: [Security] Web interface: Allow sorting identities by edition
           count (xor)

  This allows you to check for identities which insert an excessive
  amount of trust lists, which can be considered as a denial of service
  attack.
  If an identity does this, please try to contact them to find out
  whether it is a bug in their WOT; and distrust them if do not
  cooperate to fix this behavior.
  Also, report this to the Freenet team please so we can check for bugs.

- 0006554: [Code quality] Web interface / Statistics: Add "Number of
           unfetched identities" (xor)

  For first time users or people whose WOT has been offline for a long
  time, this number can be used to find out how far WOT is with
  downloading all identities.

- 0006230: [Security] Make sure to always display the logged-in identity
           in the web interface (xor)

  This is to prevent you from accidentally revealing which of your
  identities are owned by the same person by setting a trust value
  or trust comment with the wrong identity.

  For now, it will show the full ID of the identity, which is very long
  and thus ugly.
  Fixing this is a bit of work and thus it will have to wait until
  after performance is fixed.
  See https://bugs.freenetproject.org/view.php?id=6072

- 0006493: [Usability] Web interface: Change page title from
           "Web of Trust" to "Community"; allow translating (xor)

  This is to ensure that the page title matches the name of the
  "Community" menu through which WOT is accessed.

- 0006491: [Performance] Update seed identity edition numbers
           immediately before releasing (xor / ArneBab)

  This will speed up downloading all identities for new users.

CHANGELOG about stuff only interesting for developers:

- 0006531: [Code quality] Unit tests which can fail on slow machines
           should only be executed if "test.unreliable=true" (xor)

  This applies to the tests in package "plugins.WebOfTrust.util.jobs".
  They test a timer class, and thus are timing-sensitive and fail
  randomly on slow or heavily loaded machines.

- 0006523: [Code quality] Ant build improvements (xor) - resolved.

  The "-projecthelp" parameter now lists all build targets. It was
  missing "junit".
  It now also lists the various "-D" options for junit.
  The "-D" options for junit now all start with "test.". Namely,
  "-Dbenchmark=true" is now "-Dtest.benchmark".

- 0006522: [Code quality] Merge PR 28: Ant build: allow for
           -Dtest.class=... unit test selection (bertm / xor)

  This allows running only a single unit test class from Ant. It's
  useful if you are working on a new test class for example.

  Thanks to bertm for implementing this!

- 0006368: [Bugs] Identicon leaks an InputStream (xor)

  This memory leak would only apply when using a WOT-based application
  which showed Identicons via WOT. This probably applied to Sone.

Thanks to:
  - nextgens for motivating me to implement the performance optimization
    which is the main feature of this build.
  - operhiem1 for administrating Transifex which has proven to be a huge
    source of new Translations; and for committing the new l10n files.
  - ArneBab, stanley and probably some more people I forgot about for
    testing
  - bertm for the Ant improvements
  - you, the users, for having patience while performance optimizations
    are implemented one after another.