mrngm

Open-source Jazz Jackrabbit 2 reimplementation

Don't underestimate the work speed a person can maintain with a reliable, fast keyboard interface. Finding the right spot on a web interface and navigating with a mou---too late, the keyboard user already entered the invoice for that account using some odd VAT rate on 3 of the 5 products.

For those interested, there's also a second part [2025]: https://www.tinybird.co/blog/what-i-learned-operating-clickh...

(note: the first part was originally published April 2025 according to the date tooltip)

Dear OP,

> "I'm hoping to close them out soon, ideally before I run out of goodwill."

Your goodwill is already depleted, time to move on.

Full version of the longread over at The Atavist Magazine, titled "Toxic Lies": https://magazine.atavist.com/2026/toxic-lies-radiation-paduc...

Earlier submission (4 points, 0 comments): https://news.ycombinator.com/item?id=49149056

Asana has the same problem. Really frustrating.

Probably trace_log (we had a similar experience), but you'll only notice with limited storage space, and a regular keen eye on how your database fills up.

Unfortunately, even domains that did not have DNSSEC enabled earlier today are affected.

We observed issues on a non-DNSSEC .de domain at 19:45Z and confirmed around 20:12Z it wasn't just us, but also more high profile domain names.

If you have individual request logs with timing infomation, you could construct that afterwards. It does take some effort to have an effective way of displaying these metrics. Where would you put an individual request that took 532ms and started at t=34.682s? Would you align all requests that started in the 34th second at t=34s, or look at completion time (ie within t=35s)?

Would you rather see "number of requests started at this ms" (you seem to suggest this), or is something else more interesting?

I think a sort of Gantt chart that plots duration of requests as well as starting time within the time span (e.g. a second or more) might be very informative. Each individual request on a different position on the Y axis, time on the X axis. Perhaps you have some bound on requests in flight, that could be the height of the Y axis, so you can easily see calm or busy periods.

At least our observability stack doesn't show this level of detail, but it would be very interesting to have it. (We do have calculated heatmaps based on maximum request time in Grafana, which is at least better than plots of average request times)

That reminds me of this talk[0] by Gil Tene called "How NOT to Measure Latency" at the Strangeloop conference in 2015 (or read this blog post[1] that contains the most important points).

[0] https://www.youtube.com/watch?v=lJ8ydIuPFeU

[1] https://bravenewgeek.com/everything-you-know-about-latency-i...

[2020], and written for IOCCC: The International Obfuscated C Code Contest.

This was awarded "Best of Show - abuse of libc" at the time[0]. See also the judges' remarks[1]:

This program consists of a single printf(3) statement wrapped in a while loop. You would not think that this would amount to much, but you would be very, very wrong. A clue to what is happening and how this works is encoded in the ASCII art of the program source.

[0] https://www.ioccc.org/2020/index.html

[1] https://www.ioccc.org/2020/carlini/index.html

Related thread from 11 days ago: https://news.ycombinator.com/item?id=47067395 "What years of production-grade concurrency teaches us about building AI agents", 144 points, 51 comments.

Interesting problem, perhaps you could replicate results using RIPE Atlas to see geographical impact as well?

Agree. I'll catch up on group chats that do not require immediate attention when it suits me, not when the stream of messages happens to arrive.

As for OP: read up on alert fatigue; if a notification isn't directly actionable, you shouldn't even see it!

The pull model for information is more durable for humans than the push model. Try RSS for news/blogs, take some time (preferably offline) each week to prepare for the important events in the upcoming week(s), write them down on something you pass by every day (such as a whiteboard near your front door).

This.

It seems your project is at a really early stage. Almost none of the links on the page work, which is too bad, because it could have provided more background information on your goals and wishes. The only thing that seems to work is login through Google, which is a bit much for a demo site.

What's going to be the edge above the already excellent https://bgp.tools ?

You could have a _somewhat_ static blog and incorporate something like Webmentions[0] for comments or replies. For example, Molly White's microblog[1] shows the following text below the post:

  Have you responded to this post on your own site? Send a webmention[0]! Note: Webmentions are moderated for anti-spam purposes, so they will not appear immediately.

I find this method to be a sweet spot between generating content on your own pace, while allowing other people to "post" to your website, but not relying on a third-party service like Disqus.

[0] https://indieweb.org/Webmention

[1] https://www.mollywhite.net/micro/entry/202511101848

I found this document[0] very insightful. It's quite a long read, but gradually introduces the concepts needed for double-entry bookkeeping.

I think the main advantage is that you can granularly keep track of the movement of money, stocks, commodities, etc., and their conversions. As a day-to-day example, it gives you the ability to follow, for example, invoices received (Liabilities or Accounts Payable), transactions on a bank account (Assets), and what you are going to spend (or at some point, have spent) (Expenses).

This separation allows you to, for example, enter an invoice you've received on January 1 in Accounts Payable, with a corresponding value in Expenses. At this moment, nothing happened yet, it's simply an administrative transfer of some amount from an asset account to an expenses account (the sum of these transfers must be zero, so one amount is negative whereas the other amount is positive. See [0] for more details).

As a result, this gives you insight in what still needs to be paid. Once a transaction for that invoice enters your bank account on, for example, January 10, it gets "paid" to Accounts Payable, thus giving you a link between an invoice, its payment, and finally the amount spent. (This concept also works the other way around, see this sibling comment[1], where it's also extended into working with multiple accounts.)

[0] https://beancount.github.io/docs/the_double_entry_counting_m...

[1] https://news.ycombinator.com/item?id=46464893

paperless-ngx and their built-in OCR might help here for the data transformation.

I do like how it has some brutalist web design elements. With regards to drop-shadow colours on the /symbols page, it doesn't provide additional structure, so I would choose either none or a grayscale tint. Or, if you prefer colours, choose as many distinct colours as there are categories, such that they provide that additional structure.

The symbols on that page could be a bit bigger, though, as they are the main subject. (I changed 1.125rem to something like 1.6rem for text-lg; that works, but it could get a bit crowded with the clickable arrow on lower resolution screens).

I'm not a huge fan of things that move; the offset of a block of symbols, as well as scaling of an individual symbol block when hovering seems a bit too much. I would do either, but not both.