# EPF week 11 & 12
I am currently developing multiple versions of the same tool with
distinct functionalities: one version to quickly provide statistics,
another to deliver stats in a block-wise manner, and a third version,
the stat analyzer, designed to work within the client environment. Due
to the different requirements of these versions, I've encountered
significant code coupling and increased complexity.

To address this, I implemented a quick and dirty solution for processing
transaction statistics asynchronously. However, this approach resulted
in the tool becoming tightly coupled with instance management and
synchronization. The main goal was to ensure that no stats processing
occurs while transactions are actively processed in the EVM. Instead,
the stats execution is triggered during brief periods of EVM inactivity,
specifically at the end of a transaction and block execution.

Despite writing tests, the second version of the tool has a fatal flaw:
it is not fulfilling its core function of providing top N-grams.
Interestingly, the earlier version performed this task more effectively.
On the other hand, the third version has successfully minimized
complexity by focusing primarily on its main objective of accumulating
statistics, while the tests for its underlying duty are ongoing.

Additionally, ongoing work is being done to ensure that the Stat
Analyzer can handle any volume of data. To achieve this, i'm exploring
and experimenting with log scales in yet another version of the tool.