Rewrite of the existing code

[alensiljak]

The plan of action for the code rewrite.

The existing repo is at https://github.com/ledger/ledger/

The suggestion is to translate file-by-file, keeping the same names. Potentially also stick to existing methods/function names.

The idea behind this, as recommended in the original thread, would be to port the original functionality first, before moving to expand it with new features.

[cardoe]

I'm 👎 on a line for line "do X by in Rust". Look at tools like:

• https://github.com/sharkdp/bat a cat replacement
• https://github.com/ogham/exa a ls replacement
• https://github.com/sharkdp/fd a find replacement
• https://github.com/dalance/procs a ps replacement
• https://github.com/chmln/sd a sed replacement
• https://github.com/BurntSushi/ripgrep a grep replacement
• https://github.com/ClementTsang/bottom a top replacement

The list can go on but all these tools built their own CLI and goals to make a better version instead of being a line for line replacement but in Rust.

[alensiljak]

He he, true. Unfortunately, the same argument could be made for the new Ledger implementations in Rust. I've just found a bunch of skeletons by scouring the r/plaintextaccounting.

I think that pooling interesting parties and then seeing what they are interested in committing to would be the key. The Rust development process might serve as a nice guideline.

As you can see in the #4, the rewrite would be one of the first steps. The purpose being the transfer of existing logic. And then building on top of it. Not sure if you've seen the initial thread on Reddit. The end-goal is not to have a line-by-line rewrite and let it rest. However, it may be a necessary step in order to maintain compatibility.

I am also hoping that the same set of tests can be utilized during the transition, thereby helping to get the bulk of the features ported.

But, hey, that's why we have this panel. Let's see what ideas the others would come up with. I'd certainly like proposals to be brainstormed and well defined, gaining support before doing the implementation, and then well tested before ending up in the stable version of the application. As I've said, the Rust development process itself seems to illustrate this modern workflow well.
Just like Rust syntax has kept backwards-compatibility, I'd hope the same to be the case with a PTA data format. That may be overly optimistic but let's see.

[zmrow]

IMHO Rust doesn’t lend itself well to a line-by-line port of old or existing code. One could potentially start this way, but Rust is really great at slapping you around if you aren’t writing code in an idiomatic way. Rust also has some great features that make sense to use (traits); things the existing code base wouldn’t have.

One could start with a line by line port, but I’m betting it will diverge (for the better) fairly quickly. My .02. :)

[alensiljak]

One could start with a line by line port, but I’m betting it will diverge

The idea is not to literally do line-by-line translation and I don't remember ever writing that. ;) The original (Reddit) suggestion was module by module and I added "perhaps function by function", so that any existing testing harness can be utilized.
Yours is a safe bet because the whole purpose is exactly to get Ledger in the state where the change continues to happen! There have not been many additions to Ledger in the recent years due to various reasons. And this is potentially a way to get the ball rolling again.
That said, I'm even going as far as suggesting something like #23, separating the features that are not directly related to accounting. We may identify a few more in addition to time keeping as we embark on this journey.
Welcome!

[alensiljak]

Based on a few attempts, my experience confirms the advice given above. C++ rewrite makes for a hell of an experience. References and lifetimes all over the place definitely do not allow for maintainable code.

Based on that, I've gone down the line of implemented Ledger's ideas the Rust way (as far as I'm aware). Since I'm not proficient in C++, or rather in BOOST and templates, I can't follow all of Ledger's code but I hope I get the gist of it.

In any case, it seems that a 1-on-1 rewrite is not going to happen.
Instead, the model, the concepts, the syntax should stay the same / be compatible.
The implementation, however, is done using Rust concepts.