I only played A Feast for Odin extensively but I disagree on that one: our playtimes are much closer to the 90-120 minutes on the box than the 3-5 hours claimed by the article. I don’t think that we ever had a game go over 3 hours. Once everybody is comfortable with the basics and at least one player knows the rules well enough to quickly clear up any details the game flows very smoothly for us. The number of meeples is not a problem at all, the article neglects to mention that most worker placement spaces require multiple meeples so the 5-12 you get per turn are gone after a few actions.

I don’t have a VM based setup but on my aging laptop:

• Indenting a single line in a buffer with ~5K lines of code is instantaneous
• Indenting the entire 5K line buffer using C-x h C-M-\ varies depending on the language and mode used. For elisp or fennel it’s instantaneous, for Go it’s about 1.5 second.
• A slow case I’ve found was indenting a C or Go buffer where every line needed to be touched, this was about 7 seconds which is admittedly slower than I thought it would be
• Indenting such a file while in c-ts-mode (so with tree-sitter enabled) is about 1s.
• Same but using LSP and M-x eglot-format-buffer is instantaneous if a small number of fixes are required or about 1s if every line needs to be touched.

I appreciate your frustration but several times slower is not normal, something is broken in the environment or setup. I’ve been using Emacs for decades and I would never put up with any kind of slowdown, not to mention several times slower. Yikes.

To make sure that I am not just talking out of my ass I ran elisp-benchmarks between emacs-28 from about 4 years ago and emacs-30. Every benchmark was either faster or unchanged with emacs-30 and overall it was almost twice as fast as emacs-28. Many of these benchmarks are compute heavy but the more interactive ones like elb-scroll and elb-smie were faster too.

It depends. If it’s under your control with your own keys then it can be beneficial. If it’s under someone else’s control (as it is for most people) then it’s a step towards the walled garden.

I was skeptical at first (uh, another one of these?) but the small algorithm illustrations charmed me enough to look at the repo and I think I like it. Well organized repo, straightforward code and a good example_test.go, something package authors often neglect. If nothing else it can be a useful source of ideas if you decide to roll your own version of one of these operations.

I am only guessing and extrapolating based on how this usually goes:

• It’s probably possible to get it to run but would take a lot of work
• It’s probably much easier to just run the windows version under Wine

While the Linux kernel usually maintains long term backward compatibility very well unfortunately the userspace (libraries) is a different story.

Looking at the game’s faq the main dependency seems to be SDL. There is no OpenGL or other 3D library requirement. It might also depend on which version was shipped on the CD according to the faq there was an earlier statically linked version (which I am guessing might be easier to get to run) and a later dynamically linked one.

One reason I’ve been sticking with DDG is the amount of UI and feature customization it offers. Not just the number of settings but that they are sensible ones: it’s stuff I care about. They also have a privacy-friendly way to save and restore these settings.

Started playing Wildfrost, a deckbuilder with some unique mechanics. I slept on it for a long time because it had somewhat mixed reviews early on with some players complaining that it was too luck based or that it was too difficult to evaluate game state. To me this hasn’t been a problem and the game was a very pleasant surprise. Thankfully it doesn’t try to be a “better Slay the Spire” since nobody seems to get that right but goes on its own way. There is no mana system, instead you pay for cards with time: playing a card (usually) takes up your turn. Some of your cards will stay on the board and periodically trigger based on cooldowns and other triggers - and so do enemies. It’s all about timing, sequencing and positioning.

These mechanics make the game flow very smoothly and the turn puzzle is satisfying. The implementation and art are great too making it a very pleasant overall experience.

I’d add the language specification. It is well written and Go is a relatively small language so the spec is not difficult to digest:

https://go.dev/ref/spec

And pretty much everything from the official documentation page is a good read:

https://go.dev/doc/