Because somebody wrote in their stackoverflow survey that they get a huge salary. But other than that nothing else mattered and no comparisons was made. So it's probably one person or something.

First time I heard about it was over a year ago on the Software Unscripted podcast: https://open.spotify.com/episode/3UMd6PTIcuWqwoL5SL8EeT But the hotness started, I think when https://bun.sh/ by (among other things) showing how much faster bun install was compared to npm install and attributing that to using Zig. It seems to be a great systems language and easier to learn than the other hotness du jour, Rust. Jarred Sumner's (Bun's creator) tweets mentioning Zig: https://twitter.com/search?q=from%3Ajarredsumner%20zig&src=typed_query

Probably Bun and Uber

ClojureZig in 3, 2, … 😄

There is a kind of clojure -> zig transpiler thing: https://github.com/dundalek/liz

I’m seeing people rave about Zig now that the Rust team have made some unpopular choices. I’m sure they’re both really useful but seeing a lot of hype

Looks like Zig is successfully targeting the niche of "Better C"

Zig works like this (err returns, null returns, LSP immaturity): https://youtube.com/watch?v=VU1h-h9doS8 Rust does this policy: https://youtube.com/watch?v=gutR_LNoZw0 I think I infringed their policy by writing here about _ust. What a great way to invite developers to love your language.

https://tigerbeetle.com/ I think TigerBeetle is also contributing to Zig's popularity, and if FinTech startups are building stuff atop it that would perhaps explain part of the high salaries.

We have no choice, we must start a fintech startup to push Clojure's metrics

Like nubank you mean? 😁

We need more!

There is a wayland tiling WM written in Zig -- https://github.com/riverwm/river -- I'm using it along with babashka which has been fun, but I'm not sure how much a niche project like this would contribute to Zigs popularity ¯\(ツ)/¯

https://youtube.com/watch?v=mwrA5IRGpfU

org-scope incident review sessions

not really any kind of solution, but made me think of https://cohost.org/mononcqc/post/1376487-paper-ironies-of-au the summary and the paper talk about failure cases of automation, and how increasing automation effects how operator response to problems.

Every time there's an incident at my company, we do a blameless https://en.wikipedia.org/wiki/Five_whys discussion, where we all discuss exactly what happened with as much specificity as we can, try to not talk just about "who did what" but also what intentions and goals for specific actions were, ways that communication broke down, and what kind of safe guards we could put into place later. One or more people take notes, and then write a more formalized document afterwards and put it into Notion (which is our document share of choice). It's helpful to review occasionally, and most times processes are changed to reflect ways things went wrong

It's similar. It's a combination of several failure states which coalesced to persistently mess up the system. That things happened automatically certainly made things worse, and made them persist on a wonky state. Slow rolling restart was what solved the issue. But now I want my colleagues to be able to see something like that then figure out that a rolling restart will solve it (a bulk restart would have been bad)

the paper the above post is summarizing recommends doing things manually to keep skills up

What I'm bothered by is the correct mix of trivia necessary to understand and solve such issues at real time

at my last job very briefly we had an org mode file that we would periodically export to a fancy pdf called "Manuel: the Manual" that was just a dump of operational stuff from running our monolith

it was challenging to keep up to date, specifically because the problem areas were often places where there was a lot of change, often trying to address the problems

Make a dashboard that makes the problem visible

As noted, it is a hard problem because the same thing does not happen twice. In this event, you had a "thundering herd" or a "cache stampede", but you will fix that; next time the lights flicker the cause will be something else. The best option is to send people to Strange Loop every year. :-)

"But doctor, I've already watched all strange loop videos!"

We had periodic cache stampede, which is cos(as fun)

I once introduced a practice of voluntarily writing up post-mortems of interesting tech problems, be they bugs that make it into production or multi-day train wrecks. I modeled it after journals I would find in climbing shops, North American Climbing Accidents. If someone survived, they could write up their own accident. They were short, to the point, first breaking down what happened, then concluding with lessons learned. This made them, first, easy to absorb in small bites, and second, great for specifics on how to stay out of trouble. Cautionary tales, as it were. More than once I remember thinking, "Oops. I do that." I and one guy followed the practice for a few months, did not catch on. Not sure sth like this works if mandatory. 🤷 https://www.amazon.com/Accidents-North-American-Climbing-2022/dp/1735695696

The post mortem is going to be a hoot for sure

Better than a post-mortem would be an explicit process change or software enhancement that would prevent the problem from ever happening again. But we just lost three days on this, no time! Human nature wants to make up for lost time, so we just carry on as we did before with 🤞 .

no return in the code that handles let, falls through to the lower switch

I recommend starting by writing a reader, and then write eval (the interpreter) for that

Thank you for the reply. Could you give me an example?

a reader reads the characters (a b c) and returns a list when the first element is the symbol with the name a, the second is the symbol with the name b, and the third c

more like how you would usually think about using a json parser then how you might think about using traditional parsing (lexing, building a parser tree, etc)

oh

the most common way they are implemented is as a very naive straightforward recursive descent kind of thing

https://github.com/kanaka/mal might be interesting to look at

the last section of sicp https://mitp-content-server.mit.edu/books/content/sectbyfn/books_pres_0/6515/sicp.zip/full-text/book/book-Z-H-25.html#%_chap_4 is about implementing a programming language(a lisp), to the point of designing a register machine that runs the language, but unfortunately leaves out reading, just re-uses the host scheme reader

(last and second to last?)