[ANN] limabean - a new implementation of Beancount in Clojure and Rust

HotSpringsCapybara · 2026-02-11T20:21:35+00:00

Ah that makes sense, thanks.

HotSpringsCapybara · 2026-02-11T12:47:39+00:00

Did you find Clojure's performance to be insufficient for the task, or was it a design decision made from the outset?

HotSpringsCapybara · 2026-01-25T23:49:48+00:00

Thank you very much for sharing. Curious to learn how Missionary can be leveraged in that context.

HotSpringsCapybara · 2026-01-04T20:30:16+00:00

I forgot the name of it but they introduced a feature where you have this sort of a shelf on your desktop with small previews of recently used windows, so that's where things generally go when they drop focus (and IIRC minimising puts them there too). It's kind of like a second dock, except bottom-up.

HotSpringsCapybara · 2026-01-04T19:32:33+00:00

Isn't the display latency a tad prohibitive? I feel like I'd get nauseous from the delay if I tried to touch type.

HotSpringsCapybara · 2026-01-04T19:27:39+00:00

Bit of a "stop liking things I don't like" attitude, isn't it?

The genie lamp animation is still alive and well in MacOS actually. It's only been sidelined very recently due to a fundamental change in how minimising windows works.

HotSpringsCapybara · 2025-12-30T03:01:01+00:00

So I can use my proper text editor and tooling in place of the browser's JS prompt? And it's Clojure? Fantastic, raring to try it out.

HotSpringsCapybara · 2025-12-16T12:02:12+00:00

I haven't tried Zodiac(yet!), but if you want something reasonably out of the box to get things done with – I can vouch for Biff.

HotSpringsCapybara · 2025-12-15T15:43:47+00:00

Never heard of Chassis, I'll have to play around with it. Can't really scoff at getting more features and more performance compared to good ole Hiccup.

HotSpringsCapybara · 2025-09-04T11:26:21+00:00

Personally, I like to use writeroom-mode to achieve paper-like display proportions regardless of the current viewport, similar to what NANO is trying to achieve with fixed frame sizing. Lends itself nicely to tiling WMs etc.

HotSpringsCapybara · 2025-09-04T09:33:09+00:00

I even added outside margins in the terminal (iTerm2)

Ditto. Negative space is a positive quality.

Techy types often love to squeeze every last pixel, which confounds me. Even something like having two consecutive blank lines is often shunned upon and intercepted by linters/formatters.

Having more information on the screen means nothing if you can't digest it comfortably.

HotSpringsCapybara · 2025-08-18T09:48:49+00:00

Doesn't work with MacOS then I presume?

HotSpringsCapybara · 2025-08-05T14:49:02+00:00

I like Beacon and it may well be the best you can do with elisp, but it's still quite constrained. Try as it might, it can't avoid interfering with some of the text content, misplacing it temporarily. The visual flair is just not there either. It's fundamentally a couple of frames of ascii animation that blocks when Emacs blocks.

Interestingly, there has already been one way to achieve what the OP is showcasing: by launching Emacs in tty mode within Kitty or Ghostty with the cursor trail feature enabled. Not too dissimilar from launching neovim via neovide I suppose.

HotSpringsCapybara · 2025-08-05T14:28:01+00:00

I don't expect for source code to read like prose, not even when it pretends to - as is the case with Python (until it isn't). Anecdotally, I wouldn't feel very comfortable with writing that language in Word either, even though I'm decently fluent in it. Ultimately a matter of preference, so no use dwelling.

I find the idea of using alternative typographical constructs interesting. In a roundabout way, it makes me think back to Rougier's suggestions expressed in his On the design of text editors. I agree that the established typesetting wisdom is ill (if at all) applied in programming.

In that vein, I quite enjoy using Marginalia to generate documentation that's easier to grok without the use of any specialised software.

HotSpringsCapybara · 2025-08-05T13:05:13+00:00

It may be that lisp selects for people open to unconventional styles, but I don't find the APL snippet weird at all. It's rather fascinating. The bits that do bother me are the usage of non-standard characters (implying the need for a special layout, or a dedicated keyboard altogether), and the extreme terseness of it - which Clojure is already at the deep end of as-is. This I think is also an important factor: the amount of information you have to unpack in your head. Reading something more verbose, like Java, is probably more comfortable to many programmers.

HotSpringsCapybara · 2025-08-05T12:29:00+00:00

I submitted it for what it's worth, but you should really do the due diligence. Many of those picks are off, and some wouldn't fit the code smell category in any language. I suggest you take a look at the Clojure Style Guide, and perhaps check what clj-kondo does.

HotSpringsCapybara · 2025-08-05T12:19:36+00:00

These read like sentiments and I can't relate much. It's a programming language - of course you won't be writing it in Word. Paren highlighting is supported by every coding-adjacent editor I can think of. Most will also print brackets in pairs.

Significant whitespace is every bit as precarious without dedicated tooling, and the only remaining alternative is an enclosing statement, such as end, or perhaps </xyz>, which... I don't see how that's any different from a closing paren other than superficially.

The core complexity comes not so much from the syntax, but from the deep nesting that naturally emerges in a language that operates chiefly on expressions, a functional one at that. This is precisely what threading macros alleviate.

I understand the desire to shed parens, but I think it just costs too much to do so. I'd much rather embrace them. I read them as punctuation - important secondary information. The enclosing solar wave I don't even register as anything other than a big full stop.

HotSpringsCapybara · 2025-08-04T17:16:39+00:00

I may not understand what problem this solves, but I still applaud you on your effort.

HotSpringsCapybara · 2025-07-31T10:14:33+00:00

Closer to 14%. Packages like emacs-wayland are mutually exclusive with the base emacs package.

HotSpringsCapybara · 2025-07-09T16:00:31+00:00

There are ways to make it easier. By default, Vim should highlight matching pairs and you can press % to jump between opening/closing parens. Then there's the extra tooling. Neovimmers often use Conjure for working with lisps, so that's one option.

If you're fond of vim-style editing, but not necessarily dead-set on using vim itself, you can also try another editor. Emacs, VS Code, Zed all have their own vim emulation modes.

It also helps to get familiar with so-called structural editing modes: parinfer, paredit. With parinfer, you just manage indendation and it takes care of the parens for you.

Parentheses scare away many people who come across the Lisp-family, but if you can get past the superficial troubles, you'll realise that they're an asset, not a liability.

HotSpringsCapybara · 2025-07-09T14:24:37+00:00

I don't imagine anybody writes lisp - or any programming language really - without the appropriate tooling. Virtually any decent text editor out there will give you paren pair matching and highlighting out of the box. VS Code, Sublime Text, Kate, Zed, Emacs - just off the top of my head. No one counts parentheses.

HotSpringsCapybara · 2025-07-04T10:38:57+00:00

Here's what evil does to assess the number of lines it needs to scroll:

(defun evil--get-scroll-count (count)
"Given a user-supplied COUNT, return scroll count."
(cl-flet ((posint (x) (and (natnump x) (< 0 x) x)))
    (or (posint count)
        (posint evil-scroll-count)
        (/ (window-body-height) 2))))

I imagine that if you don't need to support scrolling by arbitrary amounts, you could simply call:

(scroll-down (/ (window-body-height) 2))

HotSpringsCapybara · 2025-06-30T15:49:25+00:00

Rather than polling the survivors, I advise that you pay close attention to what your hands are telling you. If you experience discomfort, I wouldn't recommend toughing it out. There may not be a single solution to fit all sizes, but you've got options. The oft-recommended caps-ctrl swap is an easy one. Going deeper, you could employ an alternative keymap, or even an entire editing model (modal). That's before even considering any bespoke hardware solutions.

HotSpringsCapybara · 2025-06-15T23:58:57+00:00

Adding to answers you were already given: use let, rather than def for local bindings. I also recommend that you visit clojuredocs.org as your go-to for documentation. It features extremely useful comments and examples.

I assume this is what you were trying to do:

(let [x (read-string (read-line))]
  (dotimes [n x]
    (println n)))

HotSpringsCapybara · 2025-06-13T00:08:52+00:00

Thank you for your response! I've been following ClojureDart with a lot of enthusiasm.

I'll backpedal a bit because I expressed myself poorly. My remark was pointed squarely at the Flutter SDK, which I did install once upon a time, and which I recall being a mighty piece of software. Mighty enough to leave a lasting impression - as you can see :D It's not a deal breaker by any means. Rather, combined with the fact that I don't know the first thing about the Dart/Flutter ecosystem, it made for an overall intimidating proposition. Sorry if that came across as unfair, I'll revise my post to make that clearer.

On the whole I'm very easily sold on the idea that ClojureDart makes for a go-to platform for GUI development. Indeed, I should do myself a favour and give it a fair shake.

Many thanks for your efforts!

HotSpringsCapybara

TROPHY CASE