
Do Accounting in Clojure and Datomic - moomin
https://github.com/juxt/juxt-accounting
======
stdbrouw
Also see [http://www.ledger-cli.org/](http://www.ledger-cli.org/)

I like how Ledger is essentially just a system for doing arbitrary
calculations on "buckets of quantities of stuff" a.k.a. accounts with various
currencies and assets. I'm not going to say it's a walk in the park, but I've
been able to get it set up so it spits out everything I need to do my Belgian
taxes, and before that, everything I needed to do my UK taxes. It doesn't
assume anything.

Of course, happy to see some competition in this space. Can only benefit users
like me.

~~~
rushabh
Plug: Also checkout ERPNext [https://erpnext.com](https://erpnext.com)

We just released a new version couple of weeks back.

------
amelius
I'm wondering when we will see an implementation of Datonic that has a more
liberal license.

~~~
siscia
There is eventstore ([https://geteventstore.com/](https://geteventstore.com/))
but I have never tried it...

~~~
Arcanum-XIII
Not exactly the same idea - one of the main point of Datomic is consistency,
and no guarantees are made here. In fact, only the idea of immutable value
seem to be shared.

------
holri
What is the difference to GnuCash? Why not contributing to it or the other
numerous Free Software ERP systems?

~~~
codeshaman
Because Clojure. I've seen the phrase "I want to be programming Clojure all
day" or "I program in Clojure for money !" many times. These people are
enchanted by Clojure and I'm slowly becoming one of them. Maybe only the
Haskell crowd has such a deep infatuation with their language.

All other programming languages look boring and limited compared to it. Scheme
and other lisps are another era -ish, Java, C++ and other OO languages are
totally entangled in hierarchies of mutable code-data structures, it has
concurrency "done right", pure functions mixed with mutable constructs, etc.

So you have this 21st century functional lisp designed for concurrency with
native interoperability with the Java and Javascript worlds. What's not to
like ?

~~~
bachmeier
> What's not to like ?

When I tried it several years ago:

\- All the documentation assumed you knew and understood the Java world. You
were supposed to know about the classpath, how com.this.that.foo.bar works,
how Maven works, etc.

\- Difficulty communicating with C libraries. This was an intentional choice
of the Java creators. Not Clojure's fault, but still a problem nonetheless.

\- The error messages made it hard for me to get work done and there was no
way I'd expect someone else to use a language with error messages like that.

\- Somewhat unstable tools. There would be major changes to the tools, like
the Eclipse plugin, and they would not be documented. The contrib libraries
changed dramatically with Clojure 1.3. While I'm sure it was fun making the
new system, I wasn't happy being unable to use the contrib libraries, because
they either didn't work or the documentation didn't exist. A language that
introduces major breaking changes without a solid transition plan in place is
not one that I want to use.

\- The documentation was limited in places. This was a major issue with new
releases. It felt to me as though there was a team of core developers that
were in the inner circle, so they got to use all the features, but the rest of
us got what they decided to share.

~~~
brudgers
One way I think about Clojure is as a language for writing Java macros [in the
Excel sense of "macro"]. Sure it's not exactly that, and it's much more
besides. Yet. it helps to have a model of Java's type system in my head
because the type system leaks into interactions with Clojure. Clojure also
relies on Java interop to be 'more general purpose'.

Clojure's documentation reflects the decision to target Clojure at the big fat
segment of software projects. Not fresh faced grads, but grey hairs. Not
pythonistas but Lispers. Better than hyperspec, not better than Racket.

The reason it has grown is because it focused on solving real business
problems rather than being beginners friendly. The tradeoffs are consistently
in the direction of what will make Clojure better for experienced programmers.

------
macmac
AGPL 3.0 - that is unfortunately a deal breaker for many.

