Where communities thrive


  • Join over 1.5M+ people
  • Join over 100K+ communities
  • Free without limits
  • Create your own community
People
Activity
    Ioan Eugen Stan
    @ieugen_gitlab
    I have some experience with create-react-app
    I also tend to favor tools with a bigger user base. I started learning Scala a few years back and tooling was missing and for me the language is very expressive but also dense. You can write a lot of stuff in a just a few characters and that is good for writing but bad for reading and understanding. In my experience you write code once and then read it multiple times.
    Anyway, I'm not here to change your mind or anything, just ranting a bit :)
    Ioan Eugen Stan
    @ieugen_gitlab
    I think a lot of stuff that is not core can live outside the main repo - it will make testing out new things maybe a bit slower (it's always easier in the same repo but maybe with git subtree or submodule things can seem in the same place),
    Having them separate makes it easier to handle contributions and we can have different policies regarding tests and stuff
    core should be ~ 80%-90%+ covered with tests, in the UI things might not be that easy
    Ioan Eugen Stan
    @ieugen_gitlab
    I would like to take on some of the management/ documentation / community building part once we settle on some goals for the project, something like https://hledger.org/ROADMAP.html#milestones
    I like the hledger project organization / website - I thing it's a good model to have. They managed to cover most of the stuff a good project needs in their website. I also like this chart - It's very useful for getting an overview https://hledger.org/_static/images/data-model.png
    regarding the docs - I would love more examples on how to get things done - and what are the API concepts.
    I was looking for some java docs to find out how to put things together, where is the entry point.
    I ended up loking over the code - core and cli to figure stuff out
    Ioan Eugen Stan
    @ieugen_gitlab
    anyway, once I have some time I will push the sample on my repo and make a PR - so we can start a discussion
    again regarding the repos - in my experience having lots of repositories has the tendency of slowing things down and confusing people - it is a bit of a mental effort for people, including me
    I think a lot of things can be done as we go

    If you think it would make sense, we could create a separate, more relaxed repo for tackler examples, like jgit Cookbook

    I like this one, yes

    Ioan Eugen Stan
    @ieugen_gitlab
    some updates regarding what we discussed:
    • I've been learning more about how hledger works and double accounting in ledger style
    • I'm working on some code to convert a custom / multi line (ugly) transaction report from ING to ledger - going to publish that
    • I have a plan to convince the a client to use tackelr / ledger style accounting so I can spend more time on this
    • I've played around with typescript - to build a CLI (with oclif) and I'm quite pleased how that turned out very good - there is also antlr4 typescript project . Do you think we could compile the scala code to a typescript library as well ?
    Ioan Eugen Stan
    @ieugen_gitlab
    I'm working with a friend on an react app that will allow us to assign transactions exported from the bank to a list of accounts
    that will allow me to import with some manual work bank translations to the ledger format
    35V LG84
    @35VLG84_gitlab

    Do you think we could compile the scala code to a typescript library as well ?

    I honestly don't know from technical point of view. From project's point of view, probably not. Tackler's core has few quite big java depencies which have non-trivial functionalities (e.g. JGit), so those might not translate to Typescript or Javascript so well. It would be also be a substantial amount of work to maintain core in two different implementation language, even when the translation would be done by compiler/plugins (all command line test, unit and integration tests would have to be duplicated for Typescript target).

    I'm working with a friend on an react app that will allow us to assign transactions exported from the bank to a list of accounts

    That sounds really cool. Especially if you have feedback how handy or not git storage backend is for your use case, that would be interesting to hear.

    Ioan Eugen Stan
    @ieugen_gitlab
    thanks, we are going to develop the app client side entierly - you copy paste /download the result locally - no server interaction yet
    it's a set of components for the future
    regarding the dependency on git, from your statement above, it does not seem to me that I can't OPT-OUT of git storage
    I do like the idea but I believe that storage / persistence should be plugable.
    while tackler library should not care where the data comes from, something like tackler-cli and tackler-web-api should care about that
    Ioan Eugen Stan
    @ieugen_gitlab
    hi, some updates: I've started learning clojure and I quite like it. I'm going to try to write some tooling around plaintextaccounting using it
    Eugen Stan
    @ieugen
    This message was deleted
    35V LG84
    @35VLG84_gitlab
    Hi, there is a new Tackler release v0.33.0. Now there could be custom timestamps in reports. It has support for Scala-JS 1.x and Scala 2.12, 2.13, see: https://tackler.e257.fi/news/2020/12/20/tackler-0-33-0/
    This will be probably the last release to support Scala 2.12
    oli
    @olimination
    Hi, Tackler looks very interesting. Do you have any real-life examples where the software is used? Maybe you could add a section on the homepage for some "customer real-life" examples...?
    35V LG84
    @35VLG84_gitlab

    Hi, Thanks, nice to hear that! I don't have any real customer or usage stories to be shared, but based on OSSRH stats, it is used to some extend. I have private systems which are based on Tackler, but I can not share details about those.

    In general, there are several features which makes Tackler really well suited to client-server systems (kind of CQRS setups), imho:

    For example the client can update "account" state by sending transactions as single message (txn-file) to server. This transaction will internally be coherent (guaranteed by accounting equation e.g. sum is zero), and it can be delivered to server either as a file/message or as part of git commit. If it's delivered as file/message, then it can be verified by server string2Txns (https://gitlab.com/e257/accounting/tackler/-/blob/main/core/src/main/scala/fi/e257/tackler/parser/TacklerTxns.scala#L326) before it will be inserted into storage (be it on filesystem or git).

    There is possible to generate proof of used (by server) accounting data to the client, and client (system) can run reports by themselves and verify that server has used correct transactions for the report https://tackler.e257.fi/docs/auditing/ and https://gitlab.com/e257/accounting/tackler/blob/main/contrib/txn-set-checksum.sh

    Lastly Tackler data model is designed and tested to withstand a lot of transactions (not in VISA scale, but in scale of smaller system), it is routinely tested with integration tests with 100_000 txn sets, and performance tested with 1_000_000 tnx sets. One transaction every minute over year is around 500_000 txns. Or 1000 persons, 10 txns per person per day for one month, that's around 300_000 txns. Git itself will have some problems when there are many objects, but there are workarounds for those problems. If you like to play with git as db, check out this demo/proto: (https://gitlab.com/e257/proto/gitdb)

    If you are after personal finances and don't need strong auditing capabilities, then you could be better of with ledger, hledger or beancount. On the other hand, if you have system, which is (semi) autonomously producing transactions, then tackler could be something which is worth of investigation.

    So in summary, there are many features in Tackler which supports Event/Message based accounting. The major question is how well plain text accounting concept fits with your business domain.
    35V LG84
    @35VLG84_gitlab
    One thing more, with ledger / hledger / beancount there is no way to proof what was the state of journal, when reporting was done. With Tackler's transaction checksum, it is possible to attach that information e.g. into printed or externally stored report. It's possible to run different reports, with different parameters and validate easily (by comparing txn checksum) that the same set of transactions is used with all reports. If that feature is needed, then it's really valuable thing to have.
    oli
    @olimination
    Thanks @35VLG84_gitlab for the info. I'm currently thinking of using it for a small/medium enterprise setup. But first I think of using it privately to make some experience with it, checking how it works, etc. I like it because it uses Scala :) and Git as a storage possibility. Are there already any web-gui projects for Tackler? I'm just thinking of having some webapplication with an easy UI for entering transactions and generating/displaying reports for the users. This could for example be achieved by using the "Play framework" or Akka/HTTP for implementing an API and having some separate Frontend app using it. What do you think?
    35V LG84
    @35VLG84_gitlab
    That's interesting. It would be really good idea to explore it and the idea first with tackler, because it doesn't have as much features e.g. hlegder. It is as small as possible by purpose.
    Please check out this PoC: https://gitlab.com/e257/proto/reporter It's PoC of reporter done with play, ScalaJS, ScalaJS-React, etc. it has some basic reporting functionality and gatling test setup for load testing. It isn't much more than exploration framework to test ideas, and it's not even a poc of real reporting server, but it can be used to play around the concepts.
    The Frontend app should definintely be a separate thing, imho. it would be interesting to have Frontend App done with rust + wasm =)
    35V LG84
    @35VLG84_gitlab
    There server is configured to run txns-1E5 (100_000 txns) set, other options with available samples are (1E1, and 1E2). With txns-1E5, when data is pre-read and parsed into memory, reporter responds in ~100ms or under for balance and balance-group reports.
    Last thing: if you decide to play directly with audit-repo.git, e.g. clone it, run following command before you do that: mkdir -p tackler/tests/audit/audit-repo.git/refs/{tags,heads}
    35V LG84
    @35VLG84_gitlab
    Have fun and good luck!
    Yohanes Yuen
    @yohanesyuen
    Is this project still active?
    35V LG84
    @35VLG84_gitlab
    Yes it is and it's in production use. However, typically the most of the changes happen during Northern Hemisphere winter time. And on top of that, if there are no real need for changes, then it won't be updated just for fun. I try to keep it as simple and small as possible.
    35V LG84
    @35VLG84_gitlab
    And the latest release is v0.35.0, details are here: https://tackler.e257.fi/news/2021/03/07/tackler-0-35-0/
    oli
    @olimination
    Hi @35VLG84_gitlab, is there an Income Statement (Profit/Loss) report available? As far as I have seen there is no such report. Is this an idea to provide such a report? Or is there some extension point to add custom reports? What would be your recommendation to achieve this? Thanks for feedback.
    35V LG84
    @35VLG84_gitlab

    Hi @olimination! Maybe, maybe not. =) It depends on what are you actually trying to do? Simplest way is to generate balance report for Income and Expenes accounts and then the delta is income or Profit/Loss. Typically negative delta means that you have gained value (Profit) and positive delta means Loss. This is because Income is represented with negative values when using typical plaintext accounting conventions. (Beancount tutorial about general concept of Income statement and plaintext accounting: https://beancount.github.io/docs/the_double_entry_counting_method.html#income-statement)

    The selection of balance report accounts could be selected either by configuration file or by command line arguments, e.g. --reporting.accounts "Income(:.*)?" "Expenses(:.*)?" for typical account names. More info about account selectors is here: https://tackler.e257.fi/docs/report-balance/#account_selectors

    If you would like to have something for closing accounts or books as the year end is approaching, then Equity export could be used for that: https://tackler.e257.fi/docs/export-equity/

    Lastly, if you would like to build/extend own report (e.g. PDF report) then JSON output could be perhaps utilised or used directly server API: https://tackler.e257.fi/docs/server-api/#generating_reports

    Currently tackler is missing at least these features, which could be usefull in this case: option to invert values (e.g. Income is negative, Expenses are positive numbers, when using plaintext accounting conventions) and a report where you have left and right sides and the delta between those sides (this is the actual income or profit/loss report?).

    Hope this helps. Happy accounting and New Year!

    2 replies
    sm
    @simonmic:matrix.org
    [m]
    Happy new year, @35VLG84_gitlab & fellow #plaintextaccounting:matrix.org fans
    sm
    @simonmic:matrix.org
    [m]
    1 reply
    sm
    @simonmic:matrix.org
    [m]
    tackler examples welcome!
    oli
    @olimination
    Hi @35VLG84_gitlab I have a question regarding the usage of Tackler on a daily base. How do you personally add your transactions? Do you just use a simple text editor and add the transactions based on the given format. Or do you have some CLI or other program to enter transactions? Thanks for help.
    oli
    @olimination
    The website https://tackler.e257.fi/ seems to be down...is there a plan to reactivate it or will the project be shutdown?
    sm
    @simonmic:matrix.org
    [m]
    up now
    1 reply