Skip to content

build0018

Web of Trust Version 0.4.4 build0018
------------------------------------------------------------------------

TLDR:
  Measurements [1] of removing Trust values show an average execution
  time of 1.7 seconds, which previously was 49 seconds
  = a speed improvement of factor 28.


IMPORTANT STUFF:

NOTICE: According to TheSeeker, his machines have been seized by the US
government. This gives the government access to his WoT / FMS
identities, his freesites, etc. Please update your Trust values.
He was a seed-identity until ~2 years ago, and thus might have received
a Trust value of 100 from you automatically if you created your
identities back then.
(He says this was due to stuff *not* related to Freenet, and that he
was neither intentionally committing a crime nor being aware of
unintentionally having illegal things on his computers.)

NOTICE: While this release has not yet been bundled with a new Freenet
release, it can be acquired a lot easier than previous non-bundled
ones:
1) Update your Freenet to the testing version using the shell command
   "./update.sh testing" on Linux or "update.cmd testing" on Windows.
2) Unload the "WebOfTrust" plugin and load the "WebOfTrust Testing
   Versions" plugin. Please do first read the description for the
   security implications!
3) If you had already done step 2 previously, i.e. are already running
   the previous testing release build0017, you need to restart Freenet
   or unload and re-load the plugin for getting the update: Freenet will
   only check for updates of the testing version when the plugin
   is reloaded.
Once Freenet build 1471 is released, step 1 will not be necessary
anymore.
You will also get this release someday even if you do not switch to the
testing versions. It will just take longer: Non-testing releases are
shipped together with regular Freenet releases; and Freenet releases do
not happen as often as WoT releases.


SUMMARY AND OUTLOOK (detailed changelog is below):

This WoT version finally ships some of the long awaited core performance
improvements:

- Previous builds would fall back to "full Score re-computation" upon
  Trust changes which cause "distrust": Removal of a Trust value,
  changing a Trust value from above zero to zero or negative, or adding
  a zero or below zero Trust value. The full re-computation was a
  *very* slow piece of code as it basically recalculates the whole
  Score database. It usually took ~ 1 minute, or even 10 minutes on some
  machines. This was made even worse by the fact that it happened not
  only for local Trust changes but also for remote ones. Also, due to
  unfortunate current limitations of the database code [4], it would
  block the web interface from responding during the whole time.
  This build ships an incremental Score re-computation algorithm for
  these situations - which should be a lot faster:
  Measurements [1] show an average execution time of 1.7 seconds, which
  previously was 49 seconds = a speed improvement of factor 28.
  As there was an incremental re-computation code for non-distrust Trust
  changes already, Score re-computation is fully incremental now.

- In previous versions, restarting WoT usually caused:
    1) a defragmentation of the database.
    2) a full Score re-computation (to prevent bugs in the existing
       incremental Score computation code from causing wrong values to
       exist for a long time).
  This has been changed to:
    1) Defrag only happens once a week.
    2) Full Score re-computation only happens once every 4 weeks.
  As a consequence, startup should be a lot faster.
  It now takes ~2 minutes on my machine.

NOTICE: WoT client applications which were not yet updated to use the
new "event-notifications" API (see build0015 changelog) can put a very
high load on WoT. For example Sone currently downloads almost the whole
WoT database every 60 seconds [8].
So if you want to get a realistic grasp of whether this WoT release is
faster, please test without any client applications.

Next steps of development will be:

- While the average execution time of 1.7 seconds of the new incremental
  Score computation algorithm is acceptable, its measured worst case
  execution time of above 60 seconds is not.
  It is difficult to judge how frequently the worst case happens, as the
  benchmark which was conducted had to be synthetic: The operations
  which cause the new code to run are quite rare in network dumps, so
  real world Trust changes couldn't be used as a benchmarks.
  It thus can be hoped that the worst case is a "worst case of a worst
  case" and very rarely happens on the real network.
  To determine how often it happens, the next build will ship additions
  to the "Statistics" page to monitor the worst case [2]. (The average
  case was already added to the statistics, search for "distrust".)
  If it happens too often, there is still hope: During the months of
  development of the new code, quite a few ideas for further improvement
  arose. Part of those are completely new algorithms, and thus they're
  not implemented yet but will have to wait until we have measurements
  to show whether the effort of rewriting this yet once more is
  indicated.

- The improved startup time of ~2 minutes is still too much.
  It is caused by the fact that WoT will currently subscribe to the USKs
  of *all* trusted Identities - currently over 11 000!
  This is not only unacceptable from a startup point of view, but also
  from a network-load perspective - it causes a O(N²) network-wide
  load; and also slows down each individual node significantly.
  Hence, the algorithm will be changed to only subscribe to the USKs of
  directly trusted identities; and to fetch non-directly-trusted ones in
  a more sparse, opportunistic approach. See [3].
  This is likely the primary goal of the next release.

- The new incremental distrust computation algorithm was the subject of
  my bachelor's thesis. Therefore not only the new code was written,
  but also a very long document which describes the old algorithm and
  the steps towards the new one.
  This thesis' document has turned out to be well-suited to become a
  "WoT developer's manual", and I plan to release it as such soon.
  I will wait with that until university has graded it (ETA: October)
  for slightly selfish reasons: I don't want to risk getting negative
  opinions on it before I know for sure whether I passed - that'd only
  cause needless panic. I hope this is only "slightly" selfish as a
  not-in-panic xor is a happy xor and a happy xor will produce more
  WoT code :)
  I will announce the document on FMS / IRC / my flog / the mailing list
  once it is available.


CHANGELOG - prefixed with the bug tracker issue number:

- 0006605: [Performance] Prevent using ObjectContainer.activate() if
           already activated to sufficient depth (xor)

  "Activation" is a technical term of the db4o database which WoT uses.
  It is similar to a "join" in relational databases:
  For example, activating a Trust object will load the identities which
  gave / received the Trust value. This involves disk IO, and therefore
  is an expensive operation.

  When an object is already activated, and then  db4o's activate()
  function is called again, db4o should do nothing in theory.
  Profiling has shown that this is not the case unfortunately, it
  takes db4o quite a bit of time to determine that nothing needs to
  be done.

  Thus code has been added to WoT to prevent activating stuff twice.

  The performance impact of this has not been measured, but it should
  help quite a bit: All getter functions of WoT classes have activation
  code; and when doing stuff with objects one often calls more than
  one getter on each object.

- 0006621: [Usability] Update translations (operhiem1)

  10 files changed, 106 insertions(+), 55 deletions(-)
  de    | 22 +++++++++++-----------
  el    | 28 +++++++++++++++++++++++-----
  es    | 25 +++++++++++++++++++++++--
  fi    | 2 --
  fr    | 28 ++++++++++++++++++++--------
  hu    | 2 --
  nl    | 2 --
  pt_BR | 14 +++++++++-----
  ru    | 22 ++++++----------------
  zh-cn | 16 ++++++++++++++--

  (The fact that some languages received more removals than additions
  is due to changed English source strings which were not translated
  yet.)

  Huge thanks to the volunteers on Transifex for providing these,
  and to operhiem1 for managing Transifex.

- 0006610: [Code quality] Add command line utility for dumping Trust
           histogram (xor)

  WoT now has another user interface: The "wotutil.sh" terminal tool.

  One of its features is to gather statistics about the Trust network.
  This shall be of use for statistical evaluations.

  It already yielded a discovery [5]:
  The Trust value distribution is not "smooth". There are certain
  discrete steps of Trust values such as 75 which occur a lot more
  often than ones which would seem less "natural" to humans.

  It can be speculated that a reason for this is UI design in WoT
  client applications such as Sone which encourages discrete steps
  instead of small +/- 1 changes.

  If you are a client application developer, please consider changing
  your UI to encourage +/- 1 steps.
  The WoT algorithm supports the full input range of [-100, +100], and
  it would be usage below its capabilities if we only used a few of
  those 201 values.

- 0006617: [Code quality] WOTUtil: Add feature for doing database
           integrity test and recomputing all Scores (xor)

  Since Score computation is fully incremental now (as explained in the
  summary at the beginning of the changelog), wrong Scores caused by
  bugs will persist for a long time.

  To be able to detect and fix this, the aforementioned "wotutil.sh"
  has an option "-testAndRepair" which does a full re-computation
  (and an integrity test of the database schema).

  You shouldn't need to run this in normal operation as WoT will do
  a full re-computation every 4 weeks.
  It is meant mostly as a tool for developers to be able to validate
  success of test runs.

  Nevertheless, users might help testing by doing this sometimes.

- 0006618: [Code quality] StatisticsPage: Show date of last defrag /
           verification of Scores (xor)

  Since full Score re-computation and database defragmentation have been
  changed from happening every startup to every few days (as explained
  in the summary at the beginning of the changelog), the new code to
  only run them every few days might have bugs.

  To assist users with noticing these bugs, the dates when those
  maintenance operations last happened are displayed on the "Statistics"
  page.

- 0006627: [Bugs] Trying to load new databases with old WOT versions can
           break them (xor)

  The structure of WoT databases ("database schema") is versioned. The
  version is changed if the structure changes. To ensure that old
  versions of WoT do not load databases with a newer structure version,
  there has always been code in WoT which makes it refuse loading a
  newer database.

  Unfortunately, in WoT versions prior to this one, this code was
  bugged. Even though WoT refused to start and showed an error message,
  the database *was* being loaded, which could cause corruption.

  This has now been fixed, so WoT versions starting from this one will
  correctly refuse to load newer databases.

  However, old versions such as the previous one cannot be fixed as
  they're out in the public already.
  And since this new version does change the database structure, the
  previous one *will* cause corruption. (You'll at least notice if your
  database is corrupted, WoT will crash at startup. I can write code to
  repair such databases if you don't have a backup; please ask me then.)

  Thus, please do *NOT* try to downgrade this release to build0017 or
  before!

- 0005994: [Security] Schedule defragmentation after deletion of an
           OwnIdentity (xor)

  Databases are complex structures. Thus, deleting data from them might
  not actually erase it from disk. The free space might be kept as-is
  until something else fills it.

  To prevent leaking of deleted user identities, a defragmentation is
  scheduled after the user deletes an identity.
  This will happen at the next restart of WoT.

  NOTICE: In general, WoT is not yet safe against leaking data to disk.
  It for example does not yet encrypt its database if Freenet is
  configured for encryption. Freenet will hopefully soon notice the
  user about this, see [6].

- 0006607: [Security] deleteOwnIdentity() will cause the replacement
           non-own Identity to be fetched even if it is distrusted (xor)

  When the user deletes one of his local identities, it is not actually
  deleted but converted to a non-local one. (This is for security
  reasons: Other local identities might have assigned Trust to it,
  which should not get deleted.)

  This code had a bug which would cause the deleted identity to continue
  to be downloaded no matter whether it was trusted or not.
  While distrusting one of your own identities after deleting it for
  sure is a rare use case, this nevertheless was fixed.

- 0005757: [Performance] Get rid of using computeAllScoresWithoutCommit
           whereever possible (xor)

  This is the new incremental distrust computation code which was
  described in the summary at the beginning of the changelog.

- 0006636: [Performance] computeRankFromScratch() should
           opportunistically compute ranks and put them into a cache
           (xor)

  As explained in the summary at the beginning of the changelog, the
  new incremental distrust computation code has a high worst-case
  runtime.
  To alleviate the worst-case, this algorithmic optimization has been
  applied already. It is of a complex nature and thus beyond explaining
  here.

  Once my aforementioned bachelor's thesis has been published, you
  will be able to realize that this optimization is one of those
  suggested in the "Outlook" section of the thesis.
  Reading the thesis will then explain this optimization.

  The measurements at [1] aim to show how much this optimization helps.
  It is labeled as "revision 2" there; the version before it (which is
  the thesis' original code) is labeled as "revision 1".

- 0005962: [Performance] Don't defragment at every startup, defragment
           every 7 days (xor)

  As explained in the summary at the beginning of the changelog.

- 0006616: [Performance] Don't run verifyAndCorrectStoredScores() at
           every startup, run it once every 28 days (xor)

  As explained in the summary at the beginning of the changelog.

- 0006631: [Code quality] Provide development versions of WOT via fred
           USK plugin updater (xor)

  As explained in the summary at the beginning of the changelog.
  Some more information:

  These are compiled by myself instead of being compiled by the release
  manager. So instead of on a dedicated high-security system which is
  only booted for releases, they're compiled on a regular development
  machine which is in daily online use.
  They're downloaded from my main USK which is used for my flog and
  WoT identity, and thus hooked up to the network quite often.
  These both are inherently less secure.

  With regards to quality testing, I plan to keep the same standards as
  with regular releases. I will test new code before deployment just as
  I always did. The releases will be packaged with a "buildXXXX" number
  as regular releases, and also be announced as such.

  So basically, this release channel has the main goal of allowing me to
  do releases myself without paying the security price of giving me
  access to the main Freenet release keys.
  This is necessary as nowadays Freenet releases happen less often than
  WoT releases.
  It provides the side effect of allowing many users to provide testing
  without big hassle so the release gets well-tested before it is put
  onto the main network.

CHANGELOG about stuff only interesting for developers:

- 0006620: [Code quality] Add Hamcrest to junit-build classpath (pull
           request 32) (operhiem1)

  Hamcrest is a framework complementary to JUnit [7].
  It may be used for easing unit test development.

  Thanks to operhiem1 for wiring it in to WoT!

- 0006609: [Performance] Add synthetic benchmark for improvements of
           issue 5757 (xor)

  Multiple attempts have been conducted to benchmark the aforementioned
  Score computation improvements:

  - Class WOTUtil's function benchmarkRemoveTrustDestructive():
    This can be used upon a regular WoT database, i.e. a dump of the
    real network, to measure the performance of the function for
    removing Trust values.
    It does so by removing random Trust values one-by-one, and measuring
    the time it takes for each.
    This specifically tests the new code as described in the changelog's
    summary, and thus is what was used for producing the benchmarks [1]
    which were cited there.

  - Class ScoreComputationBenchmark:
    It aims to simulate the topology of the Trust graph as measured on
    the real network using WOTUtil's new histogram features.
    This was not completed to full extent yet: It does follow the Trust
    value distribution, and the trustee count distribution (thanks
    ArneBab!), but not the received-Trust distribution.
    Future development might complete this. It then could be used to
    make the unit tests more realistic: They do use random Trust graphs
    already, but the probability distribution was chosen arbitrarily,
    not from measurements.

  A more detailed elaboration of the benchmarks can be studied in my
  bachelor's thesis once it is published.

- 0005882: [Core] computeAllScoresWithoutCommit() return value should be
           false when the IdentityFetcher state was wrong (xor)

  computeAllScoresWithoutCommit() is the full Score re-computation
  function which the summary of the changelog talks about.

  It not only serves the purpose of re-computing stuff, but also of
  *validating* correctness of the existing database contents. This is
  used heavily in assert()s, and thus also in unit tests.

  It previously did not check the correctness of the instructions given
  to the IdentityFetcher of whether it should fetch each of the
  known Identities or not.
  Now it also validates whether the IdentityFetcher has been correctly
  told to fetch/ignore Identities.

  This means that the new Score computation code is also tested to
  correctly feed the IdentityFetcher with commands.

- 0006608: [Code quality] IdentityFetcher should have a
           "network dump mode" where it will also download old editions
           (xor)

  By default, the IdentityFetcher will try to only fetch the latest
  edition of each known Identity.
  A network dump using the IdentityFileDiskQueue thus is a snapshot of a
  possibly infinitesimally short timespan. It will therefore lack the
  temporal nature of Trust values being changed around by users.
  This is a problem if you want to test/benchmark things which happen
  across longer timespans.

  Hence the new flag IdentityFetcher.DEBUG__NETWORK_DUMP_MODE can be set
  to true to make the IdentityFetcher try to download some *old*
  editions as well.

  Unfortunately, my test run of a handful of hours showed that most old
  editions could have fallen out of the network. IIRC, less than 100
  Identities were discovered, even though we have over 11 000 nowadays.
  I did not have very much patience though (less than half a day), so
  you might give this a try yourself.

- 0006596: [Bugs] Add workaround for db4o bug (xor)

  This one is too boring to explain in detail here.
  What can be said is that assert()s have been added to make developer's
  notice if they use programming patterns which might trigger this db4o
  bug.

- 0006647: [Code quality] Provide changelog template (xor)

  See file "developer-documentation/Changelog-template.txt".


Thanks to:
  - All volunteers on Transifex for updating many translations.
  - ArneBab for the ideas about graph topology modeling in
    ScoreComputationBenchmark.
  - operhiem1 for coordinating Transifex.


Links:
  [1] http://localhost:8888/CHK@DPyogjdlfKp1rUavVANbwRH2NTM7Anq~7dpFA3azdqo,CJ968vmM890poA1FNi7MXlB3-r6zMxv6fytmXPlf7d4,AAMC--8/WoT-benchmark-build0016-commit-3edbad7a70-vs-build0018.png
      Produced using this GnuPlot script:
      https://gist.github.com/xor-freenet/33b7a17db0d3b80b842e
  [2] https://bugs.freenetproject.org/view.php?id=6648
  [3] https://bugs.freenetproject.org/view.php?id=3816
  [4] https://bugs.freenetproject.org/view.php?id=5748
      https://bugs.freenetproject.org/view.php?id=6247
  [5] http://localhost:8888/CHK@iCe9WZKq52Esq73iRePhdQiu63nyKrHC7RwS8pP1TaA,sh0ODWAyYOuoHd85Llfr7pF2Sy-mnZwavkx3Lz7puuQ,AAMC--8/WoT-trust-value-histogram-2015-07-23.png
  [6] https://bugs.freenetproject.org/view.php?id=6559
  [7] https://en.wikipedia.org/wiki/Hamcrest
  [8] Bombe/Sone#11

build0017

Web of Trust Version 0.4.3 build0017
------------------------------------------------------------------------

This is merely a quick hotfix release for build0016 which could not
be deployed to due a bug:
build0016 was incompatible to Java 6, but Freenet policy still is to be
compatible to it.
Sorry. I did not notice this since my development system is on Java 7
already for security reasons.

For the "real" changelog, please read the announcement of build0016.

CHANGELOG - prefixed with the bugtracker issue number:

0006629: [Bugs] Remove usage of Java 7 API so WOT works on Java 6 (xor)
  As aforementioned.

  Thanks to operhiem1 for noticing this!

build0016

Web of Trust Version 0.4.3 build0016
---------------------------------------------------------

SUMMARY AND OUTLOOK - detailed 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 detailed 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.
The next build is feature-complete already and will be available as
release candidate soon.

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 [1].
If you are a client application developer and want to make usage of
event-notifications, please contact me on IRC (nick "xor-freenet"), I am
willing to help by explaining how to use the reference implementation
FCP client.

Some builds later on, the locking on the web interface will be removed
completely to allow it to always render instantaneously. This will take
a lot of 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, and to operhiem1
for mentoring them!

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
  - Reduces 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 slower machines there will
    be more deduplication, which is a nice side effect as deduplication
    reduces load and slow machines can use that.
    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.
  - Persists fetch-progress across restart: Previously, the progress of
    the stalling threads would be lost at shutdown. The new queue code
    will keep the queued files across restarts.
  - Allows creation of "bootstrap" bundles of a dump of the XML files of
    all Identities to help new users with slow connections.
    See below at issue 006597. (Please do read this, there is a security
    pitfall with this feature!)
  - Helps developers to deterministically test changes to WOT,
    see below at issue 0006597.

  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.

- 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, now
             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:

- 0006597: [Code quality] IdentityFileDiskQueue: Support deterministic
           repeat by dequeuing sorted by filename (xor)

  The new disk queue for identity files, which was described above at
  issue 0006244 already, has a feature for repeating test runs:
  - If DEBUG logging is enabled, it will archive files after processing
    - to the directory "IdentityFileQueue/Finished".
    The filenames will be prefixed with an index number to indicate the
    order in which they were processed.
  - If DEBUG logging is enabled, it will process files in the "Queued"
    directory sorted by filename instead of in random order.
    This means you can copy files from the "Finished" to the "Queued"
    directory to repeat a test run in a deterministic way - the index
    number prefix together with the sorted import will guarantee that
    the files will be imported the same order as in the original run.
    Please shutdown WOT before doing this.

  The deterministic test runs are a useful feature for:
  - Reproducing bugs in a debugger.
  - Benchmarks: The statistics page shows the total time the identity
    file processor spent importing files.
  - Creating "bootstrap" dumps of Identity files of all Identities so
    new users can add them to their queue instead of waiting for them
    to be fetched. Please be aware that the cryptographic signatures of
    the files are NOT verified and thus you put a lot of trust in the
    person who provides the bundle - the files can be modified in any
    way.

- 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)

  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.

Links:
  [1] Bombe/Sone#11

build0016-rc03

For changelog, see tag build0016-rc02.
The only change after that is code which is only enabled if DEBUG
logging is enabled.
See https://bugs.freenetproject.org/view.php?id=6597

build0016-rc02

Web of Trust Version 0.4.3 build0016 release candidate 02
---------------------------------------------------------

SUMMARY AND OUTLOOK - detailled changelog is below:

(Changes compared to release candidate 01 are only visible to
developers, and not interesting to discuss.)

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.

build0016-rc01

Web of Trust Version 0.4.3 build0016 release candidate 01
---------------------------------------------------------

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.

build0015

This build makes no functional changes but removes two flawed tests. …
…One did not

support Java 6 - the minimum version required by Freenet - and the other was
timing-sensitive.

build0014

With 30 787 lines of code, this version includes 76% more lines of code
than the previous version which was 17 494 LOC (source: see [1]).
There is a very large amount of code quality improvements and bugfixes.
This will pay out a lot during future development hopefully; for example
the improved unit testing architecture may speed up debugging a lot.

Even though the primary purpose of this build is to alleviate the
performance issues, it will still be very slow until applications built
on top of WOT have been adapted to use the new performance features.
This has a technical reason:
The main new performance improvement is the so-called
"event-notifications" FCP API which enables apps to request notification
of changes without having to download the whole WOT database every few
minutes. This cannot be put to use without applications being changed to
use it. A reallife example to understand why this is the case: If your
mail service delivers letters by horse, they won't arrive any faster
because the government has just build a railway system. The mail company
needs to first start using trains instead of horses.
If you are a developer of a WOT application, please read the "Changelog
for developers" section for instructions how to wire it in to your app.

There are at least 5 further strong algorithmic performance
optimizations possible within WOT itself which I shall work on for the
following releases. Those then should speed up WOT without requiring
adaptions from client application developers. It was chosen to implement
event-notifications before these so we can have a parallelization of
development: Client app developers can start integrating
event-notifications now, while I can work on the WOT core optimizations.

Sorry that speeding up WOT takes so long. WOT is a major project of
30 000 lines of code already, and as such just takes its time to
optimize. I am as annoyed as anyone else by the performance issues, and
trying to do my best to get them fixed ASAP. Please stay patient :)

What follows now are two changelogs of this build:
- One of the new features which are primarily relevant to the users
- One for new stuff which can be used by developers of applications
  which use WOT.
The changelogs are briefly sorted by importance, most important stuff
first. The number left to each change is the issue number in the
bugtracker.

Notice: The changelogs exclude a LOT of the actual changes. This is
because the development of this build took a very long time, and thus to
speed up the release, I produced the changelog from the bugtracker
instead of reviewing the whole amount of the 1800 commits. So what had
no bugtracker entry is likely not included. Also, I've removed anything
which isn't "visible" to users or developers, i.e. anything which is not
a new feature or bugfix. And bugfixes are also only listed if they are
easy to explain/understand. As a conclusion, the very very many code
quality improvements and core reliability bugfixes are not in the
changelog. If you're interested in the unfiltered list of the 48
resolved bugtracker entries in this release, go to
https://bugs.freenetproject.org/changelog_page.php?version_id=63.
Sorry about the lack of a complete changelog due to the time pressure to
release soon. I will aim for a MUCH shorter release cycle with following
builds; and then you'll get full changelogs again.

Changelog for users:

- 0006039: [Web Interface] WebInterface "Log in" refactoring TODOs (xor)
  Operhiem1 helped a lot with dealing with the job of refactoring the
  general style of the web interface to allow users to "Log in" with a
  certain identity instead of having to chose which identity to work
  with at every page. This should greatly increase usability as it
  matches the general convention of how websites work.
  Also, this functionality can be used by authors of other plugins so
  there is one common WOT login for anything which uses WOT.

- 0006027: [Web Interface] Backport LogInPage features from Freetalk to
  WOT (xor)
  The new "Log in" page features a wizard for creating and restoring
  identities. This wizard explains what WOT is, what an identity is,
  what trust values are, etc. It allows the user to chose preferences.
  Also, it fixes the issue of people mixing up the features for
  restoring an existing identity and creating a new one from a SSK,
  which could have caused their identity to be permanently broken. This
  is fixed by explaining the difference very clearly.
  Same as with the "Log in" page, the wizard can be used by other
  plugins.

- 0006225: [Web Interface] Make the KnownIdentitiesPage split the list
  into pages (xor)
  Previously, the "Known identities" page would list ALL identites in a
  single page. This was obviously not acceptable anymore since we have
  > 11 000 identities nowadays.
  Now the list is split into pages.

- [Not in bugtracker] [Web Interface]: Translation updates
  Add French and Simplified Chinese translations, and update Italian,
  Dutch, and Russian.
  Thanks to the volunteers on Transifex, and thanks to operhiem1 for
  putting this into a pull request.
  Notice: This is probably incomplete already because it was done before
  adding the "Create identity" wizard. AFAIK, the new stuff is up on
  Transifex already, so if you want to contribute with translating it,
  please contact me or operhiem1. Mail xor@freenetproject.org, or even
  better join the #freenet channel on Freenode IRC.

- [No bugtracker entry] [Web Interface]: Tell the user whats invalid
  bout a chosen nickname
  When the user enters a nick which contains non-allowed characters, we
  now tell him which those characters are.

- 0006136: [Web Interface] "Restore identity" is only accessible if the
  user creates an identity first (xor)
  Previously, the menu for restoring an old identity was only accessible
  if you actually had already created least one identity. The
  "Restore identity" feature can now be used through the
  "Create identity" wizard without creating a completely new identity
  first.

- 0006148: [Web Interface] Randomly generated nicknames may exceed 30
  character limit (xor)
  The nicknames now always fit the 30 character limit.

- 0005354: [Web Interface] Usability of the web interface (xor)
  When clicking on "Community" or "Community -> Home", the "Own
  anonymous identities" page is now shown instead of the "Statistics"
  page.

- 0006458: [Performance] Parallelize shutdown (xor)
  During shutdown, instead of waiting for each subsystem of WOT to have
  terminated before termining the next one, we now terminate them all in
  parallel using threads.
  This should speed up shutdown a lot (but please don't expect wonders,
  there are further issues with shutdown which the next release will
  improve).

- 0006447: [Performance] IdentityInserter thread period constant is too
  low and causes inserts to never succeed (xor)
  This fixed bug would prevent your identities from ever being inserted
  unless you had very high uptime.

- 0006001: [Core] Restore WebOfTrust.db4o.backup if WebOfTrust.db4o does
  not exist (xor)
  This fixed bug would happen if your computer crashed while WOT was
  starting up. The symptom would be loss of your database, i.e. all your
  identities would be gone.

- 0004854: [Web Interface] Stacktrace when clicking 'switch to simple
  mode' while viewing an identity (xor)
  Clicking this web interface link of Freenet did cause WOT to display
  an error, which is now fixed.

- [No bugtracker entry] [Performancde] New seed identity, thanks to
  operhiem1
  Having another seed identity should speed up the bootstrapping for new
  users.

Changelog for developers:
- [Various bugtracker entries] Event-notifications:
  This new FCP API should provide a HUGE reduction of the load which
  client apps put onto WOT.
  What this changes is as follows: To get an up-to-date list of all
  known identities (or trusts/scores), you previously had to download
  ALL of them by FCP every X minutes. You would do this even if NONE of
  them changed - a huge CPU/IO load for nothing. Now you just
  "Subscribe" to the list of identities. As a result, WOT will send you
  all of them once as you subscribe, and then keep you up to date on its
  own by sending changed identities only when a change happens.
  Thus, instead of a constant load of O(N = number of identites) every X
  minutes, independent of the amount of changes, you now get a load of
  O(1) for each change as it happens.

  If you are a client application developer, and want to integrate
  event-notifications in your app, I strongly recommend you to
  1) Use the new classes DebugFCPClient and
     FCPClientReferenceImplementation. The latter aims at being
     something which you can copy-paste to your client application
     plugin so you have a fully working FCP client which you can use to
     connect to WOT and obtain event-notifications. The DebugFCPClient
     uses the aforementioned reference FCP client to have WOT connect
     to itself and test whether event-notifications ships correct
     information (test runs of this have been done for several nights).
     For your purposes, it can also be considered as an example of how
     to actually use the FCPClientReferenceImplementation.
  2) Contact me in case you need help in understanding how to use it! :)
     Mail xor@freenetproject.org, or even better join the #freenet
     channel on Freenode IRC.

- 0006039: [Web Interface] WebInterface "Log in" refactoring TODOs (xor)
  (Even though this seems something for users, it IS interesting for
  developers, please continue reading)
  Operhiem1 helped a lot with dealing with the job of refactoring the
  general style of the web interface to allow users to "Log in" with a
  certain identity instead of having to chose which identity to work
  with at every page.

  And this functionality can be used by your plugins! You can redirect
  users of your plugin to the log in page of WOT, and have WOT redirect
  the users back to your plugin after they have logged in. For an
  example of how to use this, see
  https://github.com/Thynix/plugin-DVCS-WebUI/blob/4893cb22d919c0d6b9178711dbb4990f66a52232/src/main/java/org/freenetproject/plugin/dvcs_webui/ui/web/VelocityToadlet.java

  Please contact me or operhiem1 for further help. Mail
  xor@freenetproject.org, or even better join the #freenet channel on
  Freenode IRC.

- 0006027: [Web Interface] Backport LogInPage features from Freetalk to
  WOT (xor)
  The new "Log in" page features a wizard for creating and restoring
  identities.
  Same as with the "Log in" page, the wizard can be used by other
  plugins. For an example of how to use this, contact me. Mail
  xor@freenetproject.org, or even better join the #freenet channel on
  Freenode IRC.

- 0006231: [Core] Finish synchronous FCP API at fred (xor)
  The implementation of event-notification spawned a huge 569-commit
  side-project at Freenet itself aka "plugin-fcp-rewrite": The rewrite
  of the FCP API for communication with plugins, and especially for
  plugin-to-plugin FCP communication.
  This adds a lot of new features to replace the code duplication in
  existing plugins, as they had usually implemented their own extensions
  of the old API to fix its shortcomings. It also provides new stuff
  which was completely impossible with the previous API. Notably for
  example the ability for servers to send messages to the client on
  their own, without any recent message from the client. This allows
  plugin FCP server authors to deploy events to clients.
  Also it improves the code quality of the FCP plugin API a lot - the
  old API was completely undocumented, the new one has full JavaDoc.
  There is a much longer and more complete description of whats new in
  the new API at the pull request. Anyone who has written a plugin which
  offers an FCP server or uses FCP to connect to another plugin such as
  WOT, please read it: freenet/fred#319

  Notice: WOT will for a while stay backwards-compatible to users of the
  old API. However, to use event-notifications, you must use the new
  API. I would strongly recommend you to just copypaste the WOT class
  FCPClientReferenceImplementation for communicating with WOT by FCP, it
  does use the new API alredy.

- [Pull request 26] Background jobs
  Bertm did a great job with implementing a framework for replacing
  dangerous usage of the fred implementations of interface Ticker such
  as especially TrivialTicker. This might be interesting for fred code
  and other plugins which use those fred classes. The issue was that the
  existing fred classes provide a "no duplicates" flag which sounds like
  it ensures that a scheduled job will only ever be executed once. But
  under certain conditions, the job can actually be executed multiple
  times in parallel. The new interface "BackgroundJob" and its
  implementations provide a way to run a thread with a time delay and
  the guarantee that it will execute only once in parallel. This is a
  candidate for being moved to fred or a common library.
  Bertm saved me probably weeks of work with that, thanks a lot!

- [No bugtracker entry]: Full-node unit tests
  WOT now contains class "AbstractFullNodeTest" which can be used as a
  base class for unit tests. This class starts a regular Freenet node,
  and loads the WOT plugin into it just as it would be loaded during
  normal operation of Freenet. From a quality point of view, this is a
  lot better since it provides a more real environment than the previous
  approach of manually creating certain WOT classes in a synthetic
  environment. Also, it allows unit tests to use the full capabilities
  of Freenet. This is a foundation for future tests which could do fancy
  stuff such as testing the Identity introduction code by doing real
  uploads / downloads of puzzles and their solutions.

  Notice: This might also be interesting to authors of other plugins.
  The code is pretty generic and should be easy to re-use there.

- [No bugtracker entry]: Randomized unit tests which aim to cover all
  code paths of WOT
  Function doRandomChangesToWOT() in the new class
  AbstractJUnit4BaseTest is a framework for thorough, randomized unit
  tests. It simulates real usage by doing a random amount of changes
  chosen among many of the possible UI action:
    - WebOfTrust.createOwnIdentity()
    - WebOfTrust.deleteOwnIdentity()
    - WebOfTrust.restoreOwnIdentity()
    - WebOfTrust.restoreOwnIdentity() with existing colliding non-own
      Identity
    - WebOfTrust.addIdentity()
    - WebOfTrust.addContext() (adds context to identity)
    - WebOfTrust.setProperty (adds property to identity)
    - Add/change/Remove trust values
  This can help with testing stuff for which it is difficult to say what
  might cause problems.
  It is already used for testing-event notifications: Any of the
  mentioned user actions are sources of events, so it is a good idea to
  test a random permutation of them for whether event-notifications
  ships their events correctly.

Thanks to:
  - operhiem1 for various pull requests, the great amount of web
    interface work, and insane amount of code review.
  - bertm for the giant background-job pull request which probably saved
    me weeks worth of work
  - ArneBab for various pull requests and code review
  - TheSeeker for testing
  - anyone who I forgot about
  - and basically EVERYONE in the project for having the great great
    patience of awating this release for over a year. Sorry again that
    it took so long! The only explanation I can offer of why this
    happend is because I wanted to not release half-finished stuff
    anymore given that the whole WOT peformance disaster was a result of
    deploying half-finished code as an official plugin. Nevertheless, I
    hope to have learned something from all the complaints about the
    huge delay of the release, and will try to have a MUCH shorter
    release cycle in the future.

[1]
Lines of code were computed excluding the third-party CAPTCHA library
"kaptcha" using the command:
    find src/ test/ -iname '*.java' | fgrep -vi kaptcha | xargs wc -l
NOTICE: This use of xargs can be dangerous if used upon directories
which contain files with the newline character in their name.

build0014-rc02

With >1800 commits, this build includes more new commits than WOT ever
consisted of as of the previous build which was 1461 commits.
There is a very large amount of code quality improvements and bugfixes.
This will pay out a lot during future development hopefully; for example
the improved unit testing architecture may speed up debugging a lot.

Even though the primary purpose of this build is to alleviate the
performance issues, it will still be very slow until applications built
on top of WOT have been adapted to use the new performance features.
This has a technical reason:
The main new performance improvement is the so-called
"event-notifications" FCP API which enables apps to request notification
of changes without having to download the whole WOT database every few
minutes. This cannot be put to use without applications being changed to
use it. A reallife example to understand why this is the case: If your
mail service delivers letters by horse, they won't arrive any faster
because the government has just build a railway system. The mail company
needs to first start using trains instead of horses.
If you are a developer of a WOT application, please read the "Changelog
for developers" section for instructions how to wire it in to your app.

There are at least 5 further strong algorithmic performance
optimizations possible within WOT itself which I shall work on for the
following releases. Those then should speed up WOT without requiring
adaptions from client application developers. It was chosen to implement
event-notifications before these so we can have a parallelization of
development: Client app developers can start integrating
event-notifications now, while I can work on the WOT core optimizations.

Sorry that speeding up WOT takes so long. WOT is a major project of
30 000 lines of code already, and as such just takes its time to
optimize. I am as annoyed as anyone else by the performance issues, and
trying to do my best to get them fixed ASAP. Please stay patient :)

What follows now are two changelogs of this build:
- One of the new features which are primarily relevant to the users
- One for new stuff which can be used by developers of applications
  which use WOT.
The changelogs are briefly sorted by importance, most important stuff
first. The number left to each change is the issue number in the
bugtracker.

Notice: The changelogs exclude a LOT of the actual changes. This is
because the development of this build took a very long time, and thus to
speed up the release, I produced the changelog from the bugtracker
instead of reviewing the whole amount of the 1800 commits. So what had
no bugtracker entry is likely not included. Also, I've removed anything
which isn't "visible" to users or developers, i.e. anything which is not
a new feature or bugfix. And bugfixes are also only listed if they are
easy to explain/understand. As a conclusion, the very very many code
quality improvements and core reliability bugfixes are not in the
changelog. If you're interested in the unfiltered list of the 48
resolved bugtracker entries in this release, go to
https://bugs.freenetproject.org/changelog_page.php?version_id=63.
Sorry about the lack of a complete changelog due to the time pressure to
release soon. I will aim for a MUCH shorter release cycle with following
builds; and then you'll get full changelogs again.

Changelog for users:

- 0006039: [Web Interface] WebInterface "Log in" refactoring TODOs (xor)
  Operhiem1 helped a lot with dealing with the job of refactoring the
  general style of the web interface to allow users to "Log in" with a
  certain identity instead of having to chose which identity to work
  with at every page. This should greatly increase usability as it
  matches the general convention of how websites work.
  Also, this functionality can be used by authors of other plugins so
  there is one common WOT login for anything which uses WOT.

- 0006027: [Web Interface] Backport LogInPage features from Freetalk to
  WOT (xor)
  The new "Log in" page features a wizard for creating and restoring
  identities. This wizard explains what WOT is, what an identity is,
  what trust values are, etc. It allows the user to chose preferences.
  Also, it fixes the issue of people mixing up the features for
  restoring an existing identity and creating a new one from a SSK,
  which could have caused their identity to be permanently broken. This
  is fixed by explaining the difference very clearly.
  Same as with the "Log in" page, the wizard can be used by other
  plugins.

- 0006225: [Web Interface] Make the KnownIdentitiesPage split the list
  into pages (xor)
  Previously, the "Known identities" page would list ALL identites in a
  single page. This was obviously not acceptable anymore since we have
  > 11 000 identities nowadays.
  Now the list is split into pages.

- [Not in bugtracker] [Web Interface]: Translation updates
  Add French and Simplified Chinese translations, and update Italian,
  Dutch, and Russian.
  Thanks to the volunteers on Transifex, and thanks to operhiem1 for
  putting this into a pull request.
  Notice: This is probably incomplete already because it was done before
  adding the "Create identity" wizard. AFAIK, the new stuff is up on
  Transifex already, so if you want to contribute with translating it,
  please contact me or operhiem1. Mail xor@freenetproject.org, or even
  better join the #freenet channel on Freenode IRC.

- [No bugtracker entry] [Web Interface]: Tell the user whats invalid
  bout a chosen nickname
  When the user enters a nick which contains non-allowed characters, we
  now tell him which those characters are.

- 0006136: [Web Interface] "Restore identity" is only accessible if the
  user creates an identity first (xor)
  Previously, the menu for restoring an old identity was only accessible
  if you actually had already created least one identity. The
  "Restore identity" feature can now be used through the
  "Create identity" wizard without creating a completely new identity
  first.

- 0006148: [Web Interface] Randomly generated nicknames may exceed 30
  character limit (xor)
  The nicknames now always fit the 30 character limit.

- 0005354: [Web Interface] Usability of the web interface (xor)
  When clicking on "Community" or "Community -> Home", the "Own
  anonymous identities" page is now shown instead of the "Statistics"
  page.

- 0006458: [Performance] Parallelize shutdown (xor)
  During shutdown, instead of waiting for each subsystem of WOT to have
  terminated before termining the next one, we now terminate them all in
  parallel using threads.
  This should speed up shutdown a lot (but please don't expect wonders,
  there are further issues with shutdown which the next release will
  improve).

- 0006447: [Performance] IdentityInserter thread period constant is too
  low and causes inserts to never succeed (xor)
  This fixed bug would prevent your identities from ever being inserted
  unless you had very high uptime.

- 0006001: [Core] Restore WebOfTrust.db4o.backup if WebOfTrust.db4o does
  not exist (xor)
  This fixed bug would happen if your computer crashed while WOT was
  starting up. The symptom would be loss of your database, i.e. all your
  identities would be gone.

- 0004854: [Web Interface] Stacktrace when clicking 'switch to simple
  mode' while viewing an identity (xor)
  Clicking this web interface link of Freenet did cause WOT to display
  an error, which is now fixed.

- [No bugtracker entry] [Performancde] New seed identity, thanks to
  operhiem1
  Having another seed identity should speed up the bootstrapping for new
  users.

Changelog for developers:
- [Various bugtracker entries] Event-notifications:
  This new FCP API should provide a HUGE reduction of the load which
  client apps put onto WOT.
  What this changes is as follows: To get an up-to-date list of all
  known identities (or trusts/scores), you previously had to download
  ALL of them by FCP every X minutes. You would do this even if NONE of
  them changed - a huge CPU/IO load for nothing. Now you just
  "Subscribe" to the list of identities. As a result, WOT will send you
  all of them once as you subscribe, and then keep you up to date on its
  own by sending changed identities only when a change happens.
  Thus, instead of a constant load of O(N = number of identites) every X
  minutes, independent of the amount of changes, you now get a load of
  O(1) for each change as it happens.

  If you are a client application developer, and want to integrate
  event-notifications in your app, I strongly recommend you to
  1) Use the new classes DebugFCPClient and
     FCPClientReferenceImplementation. The latter aims at being
     something which you can copy-paste to your client application
     plugin so you have a fully working FCP client which you can use to
     connect to WOT and obtain event-notifications. The DebugFCPClient
     uses the aforementioned reference FCP client to have WOT connect
     to itself and test whether event-notifications ships correct
     information (test runs of this have been done for several nights).
     For your purposes, it can also be considered as an example of how
     to actually use the FCPClientReferenceImplementation.
  2) Contact me in case you need help in understanding how to use it! :)
     Mail xor@freenetproject.org, or even better join the #freenet
     channel on Freenode IRC.

- 0006039: [Web Interface] WebInterface "Log in" refactoring TODOs (xor)
  (Even though this seems something for users, it IS interesting for
  developers, please continue reading)
  Operhiem1 helped a lot with dealing with the job of refactoring the
  general style of the web interface to allow users to "Log in" with a
  certain identity instead of having to chose which identity to work
  with at every page.

  And this functionality can be used by your plugins! You can redirect
  users of your plugin to the log in page of WOT, and have WOT redirect
  the users back to your plugin after they have logged in. For an
  example of how to use this, see
  https://github.com/Thynix/plugin-DVCS-WebUI/blob/4893cb22d919c0d6b9178711dbb4990f66a52232/src/main/java/org/freenetproject/plugin/dvcs_webui/ui/web/VelocityToadlet.java
  Please contact me or operhiem1 for further help. Mail
  xor@freenetproject.org, or even better join the #freenet channel on
  Freenode IRC.

- 0006027: [Web Interface] Backport LogInPage features from Freetalk to
  WOT (xor)
  The new "Log in" page features a wizard for creating and restoring
  identities.
  Same as with the "Log in" page, the wizard can be used by other
  plugins. For an example of how to use this, contact me. Mail
  xor@freenetproject.org, or even better join the #freenet channel on
  Freenode IRC.

- 0006231: [Core] Finish synchronous FCP API at fred (xor)
  The implementation of event-notification spawned a huge 569-commit
  side-project at Freenet itself aka "plugin-fcp-rewrite": The rewrite
  of the FCP API for communication with plugins, and especially for
  plugin-to-plugin FCP communication.
  This adds a lot of new features to replace the code duplication in
  existing plugins, as they had usually implemented their own extensions
  of the old API to fix its shortcomings. It also provides new stuff
  which was completely impossible with the previous API. Notably for
  example the ability for servers to send messages to the client on
  their own, without any recent message from the client. This allows
  plugin FCP server authors to deploy events to clients.
  Also it improves the code quality of the FCP plugin API a lot - the
  old API was completely undocumented, the new one has full JavaDoc.
  There is a much longer and more complete description of whats new in
  the new API at the pull request. Anyone who has written a plugin which
  offers an FCP server or uses FCP to connect to another plugin such as
  WOT, please read it: freenet/fred#319

  Notice: WOT will for a while stay backwards-compatible to users of the
  old API. However, to use event-notifications, you must use the new
  API. I would strongly recommend you to just copypaste the WOT class
  FCPClientReferenceImplementation for communicating with WOT by FCP, it
  does use the new API alredy.

- [Pull request 26] Background jobs
  Bertm did a great job with implementing a framework for replacing
  dangerous usage of the fred implementations of interface Ticker such
  as especially TrivialTicker. This might be interesting for fred code
  and other plugins which use those fred classes. The issue was that the
  existing fred classes provide a "no duplicates" flag which sounds like
  it ensures that a scheduled job will only ever be executed once. But
  under certain conditions, the job can actually be executed multiple
  times in parallel. The new interface "BackgroundJob" and its
  implementations provide a way to run a thread with a time delay and
  the guarantee that it will execute only once in parallel. This is a
  candidate for being moved to fred or a common library.
  Bertm saved me probably weeks of work with that, thanks a lot!

- [No bugtracker entry]: Full-node unit tests
  WOT now contains class "AbstractFullNodeTest" which can be used as a
  base class for unit tests. This class starts a regular Freenet node,
  and loads the WOT plugin into it just as it would be loaded during
  normal operation of Freenet. From a quality point of view, this is a
  lot better since it provides a more real environment than the previous
  approach of manually creating certain WOT classes in a synthetic
  environment. Also, it allows unit tests to use the full capabilities
  of Freenet. This is a foundation for future tests which could do fancy
  stuff such as testing the Identity introduction code by doing real
  uploads / downloads of puzzles and their solutions.

  Notice: This might also be interesting to authors of other plugins.
  The code is pretty generic and should be easy to re-use there.

- [No bugtracker entry]: Randomized unit tests which aim to cover all
  code paths of WOT
  Function doRandomChangesToWOT() in the new class
  AbstractJUnit4BaseTest is a framework for thorough, randomized unit
  tests. It simulates real usage by doing a random amount of changes
  chosen among many of the possible UI action:
    - WebOfTrust.createOwnIdentity()
    - WebOfTrust.deleteOwnIdentity()
    - WebOfTrust.restoreOwnIdentity()
    - WebOfTrust.restoreOwnIdentity() with existing colliding non-own
      Identity
    - WebOfTrust.addIdentity()
    - WebOfTrust.addContext() (adds context to identity)
    - WebOfTrust.setProperty (adds property to identity)
    - Add/change/Remove trust values
  This can help with testing stuff for which it is difficult to say what
  might cause problems.
  It is already used for testing-event notifications: Any of the
  mentioned user actions are sources of events, so it is a good idea to
  test a random permutation of them for whether event-notifications
  ships their events correctly.

Thanks to:
  - operhiem1 for various pull requests, the great amount of web
    interface work, and insane amount of code review.
  - bertm for the giant background-job pull request which probably saved
    me weeks worth of work
  - ArneBab for various pull requests and code review
  - TheSeeker for testing
  - anyone who I forgot about
  - and basically EVERYONE in the project for having the great great
    patience of awating this release for over a year. Sorry again that
    it took so long! The only explanation I can offer of why this
    happend is because I wanted to not release half-finished stuff
    anymore given that the whole WOT peformance disaster was a result of
    deploying half-finished code as an official plugin. Nevertheless, I
    hope to have learned something from all the complaints about the
    huge delay of the release, and will try to have a MUCH shorter
    release cycle in the future.

build0014-rc01

There's good news and a bad news about this build.
The good news: With >1800 commits, this build includes more new commits
than WOT ever consisted of as of the previous build which was 1461
commits :)
There is a very large amount of code quality improvements and bugfixes.
This will pay out a lot during future development hopefully; for example
the improved unit testing architecture may speed up debugging a lot.

The bad news: Even though the primary purpose of this build is to
alleviate the performance issues, it will still be very slow until
applications built on top of WOT have been adapted to use the new
performance features. This has a technical reason:
The main new performance improvement is the so-called
"event-notifications" FCP API which enables apps to request notification
of changes without having to download the whole WOT database every few
minutes. This cannot be put to use without applications being changed to
use it. A reallife example to understand why this is the case: If your
mail service delivers letters by horse, they won't arrive any faster
because the government has just build a railway system. The mail company
needs to first start using trains instead of horses.
If you are a developer of a WOT application, please read the "Changelog
for developers" section for instructions how to wire it in to your app.

There are at least 5 further strong algorithmic performance
optimizations possible within WOT itself which I shall work on for the
following releases. Those then should speed up WOT without requiring
adaptions from client application developers. It was chosen to implement
event-notifications before these so we can have a parallelization of
development: Client app developers can start integrating
event-notifications now, while I can work on the WOT core optimizations.

Sorry that speeding up WOT takes so long. WOT is a major project of
30 000 lines of code already, and as such just takes its time to
optimize. I am as annoyed as anyone else by the performance issues, and
trying to do my best to get them fixed ASAP. Please stay patient :)

What follows now are two changelogs of this build:
- One of the new features which are primarily relevant to the users
- One for new stuff which can be used by developers of applications
  which use WOT.
The changelogs are briefly sorted by importance, most important stuff
first. The number left to each change is the issue number in the
bugtracker.

Notice: The changelogs exclude a LOT of the actual changes. This is
because the development of this build took a very long time, and thus to
speed up the release, I produced the changelog from the bugtracker
instead of reviewing the whole amount of the 1800 commits. So what had
no bugtracker entry is likely not included. Also, I've removed anything
which isn't "visible" to users or developers, i.e. anything which is not
a new feature or bugfix. And bugfixes are also only listed if they are
easy to explain/understand. As a conclusion, the very very many code
quality improvements and core reliability bugfixes are not in the
changelog. If you're interested in the unfiltered list of the 48
resolved bugtracker entries in this release, go to
https://bugs.freenetproject.org/changelog_page.php?version_id=63.
Sorry about the lack of a complete changelog due to the time pressure to
release soon. I will aim for a MUCH shorter release cycle with following
builds; and then you'll get full changelogs again.

Changelog for users:

- 0006039: [Web Interface] WebInterface "Log in" refactoring TODOs (xor)
  Operhiem1 helped a lot with dealing with the job of refactoring the
  general style of the web interface to allow users to "Log in" with a
  certain identity instead of having to chose which identity to work
  with at every page. This should greatly increase usability as it
  matches the general convention of how websites work.
  Also, this functionality can be used by authors of other plugins so
  there is one common WOT login for anything which uses WOT.

- 0006027: [Web Interface] Backport LogInPage features from Freetalk to
  WOT (xor)
  The new "Log in" page features a wizard for creating and restoring
  identities. This wizard explains what WOT is, what an identity is,
  what trust values are, etc. It allows the user to chose preferences.
  Also, it fixes the issue of people mixing up the features for
  restoring an existing identity and creating a new one from a SSK,
  which could have caused their identity to be permanently broken. This
  is fixed by explaining the difference very clearly.
  Same as with the "Log in" page, the wizard can be used by other
  plugins.

- 0006225: [Web Interface] Make the KnownIdentitiesPage split the list
  into pages (xor)
  Previously, the "Known identities" page would list ALL identites in a
  single page. This was obviously not acceptable anymore since we have
  > 11 000 identities nowadays.
  Now the list is split into pages.

- [Not in bugtracker] [Web Interface]: Translation updates
  Add French and Simplified Chinese translations, and update Italian,
  Dutch, and Russian.
  Thanks to the volunteers on Transifex, and thanks to operhiem1 for
  putting this into a pull request.
  Notice: This is probably incomplete already because it was done before
  adding the "Create identity" wizard. AFAIK, the new stuff is up on
  Transifex already, so if you want to contribute with translating it,
  please contact me or operhiem1. Mail xor@freenetproject.org, or even
  better join the #freenet channel on Freenode IRC.

- [No bugtracker entry] [Web Interface]: Tell the user whats invalid
  bout a chosen nickname
  When the user enters a nick which contains non-allowed characters, we
  now tell him which those characters are.

- 0006136: [Web Interface] "Restore identity" is only accessible if the
  user creates an identity first (xor)
  Previously, the menu for restoring an old identity was only accessible
  if you actually had already created least one identity. The
  "Restore identity" feature can now be used through the
  "Create identity" wizard without creating a completely new identity
  first.

- 0006148: [Web Interface] Randomly generated nicknames may exceed 30
  character limit (xor)
  The nicknames now always fit the 30 character limit.

- 0005354: [Web Interface] Usability of the web interface (xor)
  When clicking on "Community" or "Community -> Home", the "Own
  anonymous identities" page is now shown instead of the "Statistics"
  page.

- 0006458: [Performance] Parallelize shutdown (xor)
  During shutdown, instead of waiting for each subsystem of WOT to have
  terminated before termining the next one, we now terminate them all in
  parallel using threads.
  This should speed up shutdown a lot (but please don't expect wonders,
  there are further issues with shutdown which the next release will
  improve).

- 0006447: [Performance] IdentityInserter thread period constant is too
  low and causes inserts to never succeed (xor)
  This fixed bug would prevent your identities from ever being inserted
  unless you had very high uptime.

- 0006001: [Core] Restore WebOfTrust.db4o.backup if WebOfTrust.db4o does
  not exist (xor)
  This fixed bug would happen if your computer crashed while WOT was
  starting up. The symptom would be loss of your database, i.e. all your
  identities would be gone.

- 0004854: [Web Interface] Stacktrace when clicking 'switch to simple
  mode' while viewing an identity (xor)
  Clicking this web interface link of Freenet did cause WOT to display
  an error, which is now fixed.

- [No bugtracker entry] [Performancde] New seed identity, thanks to
  operhiem1
  Having another seed identity should speed up the bootstrapping for new
  users.

Changelog for developers:
- [Various bugtracker entries] Event-notifications:
  This new FCP API should provide a HUGE reduction of the load which
  client apps put onto WOT.
  What this changes is as follows: To get an up-to-date list of all
  known identities (or trusts/scores), you previously had to download
  ALL of them by FCP every X minutes. You would do this even if NONE of
  them changed - a huge CPU/IO load for nothing. Now you just
  "Subscribe" to the list of identities. As a result, WOT will send you
  all of them once as you subscribe, and then keep you up to date on its
  own by sending changed identities only when a change happens.
  Thus, instead of a constant load of O(N = number of identites) every X
  minutes, independent of the amount of changes, you now get a load of
  O(1) for each change as it happens.

  If you are a client application developer, and want to integrate
  event-notifications in your app, I strongly recommend you to
  1) Use the new classes DebugFCPClient and
     FCPClientReferenceImplementation. The latter aims at being
     something which you can copy-paste to your client application
     plugin so you have a fully working FCP client which you can use to
     connect to WOT and obtain event-notifications. The DebugFCPClient
     uses the aforementioned reference FCP client to have WOT connect
     to itself and test whether event-notifications ships correct
     information (test runs of this have been done for several nights).
     For your purposes, it can also be considered as an example of how
     to actually use the FCPClientReferenceImplementation.
  2) Contact me in case you need help in understanding how to use it! :)
     Mail xor@freenetproject.org, or even better join the #freenet
     channel on Freenode IRC.

- 0006039: [Web Interface] WebInterface "Log in" refactoring TODOs (xor)
  (Even though this seems something for users, it IS interesting for
  developers, please continue reading)
  Operhiem1 helped a lot with dealing with the job of refactoring the
  general style of the web interface to allow users to "Log in" with a
  certain identity instead of having to chose which identity to work
  with at every page.

  And this functionality can be used by your plugins! You can redirect
  users of your plugin to the log in page of WOT, and have WOT redirect
  the users back to your plugin after they have logged in. For an
  example of how to use this, see
  https://github.com/Thynix/plugin-DVCS-WebUI/blob/4893cb22d919c0d6b9178711dbb4990f66a52232/src/main/java/org/freenetproject/plugin/dvcs_webui/ui/web/VelocityToadlet.java
  Please contact me or operhiem1 for further help. Mail
  xor@freenetproject.org, or even better join the #freenet channel on
  Freenode IRC.

- 0006027: [Web Interface] Backport LogInPage features from Freetalk to
  WOT (xor)
  The new "Log in" page features a wizard for creating and restoring
  identities.
  Same as with the "Log in" page, the wizard can be used by other
  plugins. For an example of how to use this, contact me. Mail
  xor@freenetproject.org, or even better join the #freenet channel on
  Freenode IRC.

- 0006231: [Core] Finish synchronous FCP API at fred (xor)
  The implementation of event-notification spawned a huge 569-commit
  side-project at Freenet itself aka "plugin-fcp-rewrite": The rewrite
  of the FCP API for communication with plugins, and especially for
  plugin-to-plugin FCP communication.
  This adds a lot of new features to replace the code duplication in
  existing plugins, as they had usually implemented their own extensions
  of the old API to fix its shortcomings. It also provides new stuff
  which was completely impossible with the previous API. Notably for
  example the ability for servers to send messages to the client on
  their own, without any recent message from the client. This allows
  plugin FCP server authors to deploy events to clients.
  Also it improves the code quality of the FCP plugin API a lot - the
  old API was completely undocumented, the new one has full JavaDoc.
  There is a much longer and more complete description of whats new in
  the new API at the pull request. Anyone who has written a plugin which
  offers an FCP server or uses FCP to connect to another plugin such as
  WOT, please read it: freenet/fred#319

  Notice: WOT will for a while stay backwards-compatible to users of the
  old API. However, to use event-notifications, you must use the new
  API. I would strongly recommend you to just copypaste the WOT class
  FCPClientReferenceImplementation for communicating with WOT by FCP, it
  does use the new API alredy.

- [Pull request 26] Background jobs
  Bertm did a great job with implementing a framework for replacing
  dangerous usage of the fred implementations of interface Ticker such
  as especially TrivialTicker. This might be interesting for fred code
  and other plugins which use those fred classes. The issue was that the
  existing fred classes provide a "no duplicates" flag which sounds like
  it ensures that a scheduled job will only ever be executed once. But
  under certain conditions, the job can actually be executed multiple
  times in parallel. The new interface "BackgroundJob" and its
  implementations provide a way to run a thread with a time delay and
  the guarantee that it will execute only once in parallel. This is a
  candidate for being moved to fred or a common library.
  Bertm saved me probably weeks of work with that, thanks a lot!

- [No bugtracker entry]: Full-node unit tests
  WOT now contains class "AbstractFullNodeTest" which can be used as a
  base class for unit tests. This class starts a regular Freenet node,
  and loads the WOT plugin into it just as it would be loaded during
  normal operation of Freenet. From a quality point of view, this is a
  lot better since it provides a more real environment than the previous
  approach of manually creating certain WOT classes in a synthetic
  environment. Also, it allows unit tests to use the full capabilities
  of Freenet. This is a foundation for future tests which could do fancy
  stuff such as testing the Identity introduction code by doing real
  uploads / downloads of puzzles and their solutions.

  Notice: This might also be interesting to authors of other plugins.
  The code is pretty generic and should be easy to re-use there.

- [No bugtracker entry]: Randomized unit tests which aim to cover all
  code paths of WOT
  Function doRandomChangesToWOT() in the new class
  AbstractJUnit4BaseTest is a framework for thorough, randomized unit
  tests. It simulates real usage by doing a random amount of changes
  chosen among many of the possible UI action:
    - WebOfTrust.createOwnIdentity()
    - WebOfTrust.deleteOwnIdentity()
    - WebOfTrust.restoreOwnIdentity()
    - WebOfTrust.restoreOwnIdentity() with existing colliding non-own
      Identity
    - WebOfTrust.addIdentity()
    - WebOfTrust.addContext() (adds context to identity)
    - WebOfTrust.setProperty (adds property to identity)
    - Add/change/Remove trust values
  This can help with testing stuff for which it is difficult to say what
  might cause problems.
  It is already used for testing-event notifications: Any of the
  mentioned user actions are sources of events, so it is a good idea to
  test a random permutation of them for whether event-notifications
  ships their events correctly.

Thanks to:
  - operhiem1 for various pull requests, the great amount of web
    interface work, and insane amount of code review.
  - bertm for the giant background-job pull request which probably saved
    me weeks worth of work
  - ArneBab for various pull requests and code review
  - TheSeeker for testing
  - anyone who I forgot about
  - and basically EVERYONE in the project for having the great great
    patience of awating this release for over a year. Sorry again that
    it took so long! The only explanation I can offer of why this
    happend is because I wanted to not release half-finished stuff
    anymore given that the whole WOT peformance disaster was a result of
    deploying half-finished code as an official plugin. Nevertheless, I
    hope to have learned something from all the complaints about the
    huge delay of the release, and will try to have a MUCH shorter
    release cycle in the future.
Something went wrong with that request. Please try again.