Somehow all this was done seemingly deliberately, as some MBA new hire project at a BigCo. Like how Google kills off half their useful services because nobody in the C suite knows what they're for.

Also, they (the Callahan government) had a plan to bring state of the art semiconductor manufacturing to the UK. Basically TSMC but in Wales. Thatcher killed it.

Let me tell you about real life. I’m a caregiver and leaving the home is simply not an option. Short trips to the store, a walk around the block, maybe, if it’s before sundown, provided the person I’m caring for is in the right mental state to be left alone for 45 minutes. If there were neighborhood pubs that might be a thing to do if I drank. Getting off social media is great for those lucky enough to have the option, but with an increasing number of people getting into their dementia years, many with no savings to afford respite or other forms of care, social media is going to be the only option for a lot of people like myself. It’s better than nothing.

Well, but I am not aware of anyone having come up with a good syntax to do babel things in Markdown. Markdown and Org Mode also set out to serve different purposes. For a quick and dirty text Markdown might suffice, but the babel stuff and spreadsheet stuff enable a lot of use cases that Markdown simply doesn't cater to. We already have the implementation of all these nice things in Emacs. If we were to replicate them for some markdown dialect, they would probably be done half-right, before someone actually manages to get literate programming right for various languages, including what code to translate to, how to wrap or not wrap the code that is inside blocks, sessions, output formats, etc. We might as well use what we have with Emacs. There is probably a way to call Emacs' functionality from outside of Emacs, to treat it as a library.

But not all is well with Org Mode syntax either. Many git hosters have only a very rudimentary implementation of a parser and writing a parser for it is not actually that easy. Its dynamic nature requires at least a 2 step approach of parsing and then later checking all kinds of definitions at the top of a file and further processing the document according to that. It's power comes at that cost. That's probably why we have so many Markdowns, but only one Org Mode (OK maybe a few, counting Vim and VSCodium plugins, that achieve a feature subset).

I will say though, that org mode syntax is much better suited for writing technical documentation than markdown. The only issue is, that not so many people know it or want to learn it, and I don't know a way to change that. Perhaps that effort to have the org mode syntax separately defined (https://gitlab.com/publicvoit/orgdown/-/blob/master/doc/Over...) by the same author will help creating more support for the format in various tools.

I agree about the duct tape, which I also use often around the house, so maybe that's why I like org-babel :)

Just wanted to say that I share data between different blocks in different languages through files and env variables (I add :session shared to the src blocks that need to access this). That is useful also to have src blocks you can execute repeatedly and that depend on something like an aws identity being assumed (you just assume it in the first block that shares the session).

I agree it's messy, it's just a mess that works for me.

Re: TCO

Does the language give any guarantee that TCO was applied? In other words can it give you an error that the recursion is not of tail call form? Because I imagine a probability of writing a recursion and relying on it being TCO-optimized, where it's not. I would prefer if a language had some form of explicit TCO modifier for a function. Is there any language that has this?

ClassiCube (https://github.com/ClassiCube/ClassiCube) exists, which is an open-source Minecraft Classic reimplementation with an N64 port among dozens of others. HN discussed it two years ago (https://news.ycombinator.com/item?id=37518874).

ClassiCube has a WIP GBA port, but according to commits it only hits 2 FPS as of now and is not listed in its README.

On a related tangent, there's also Fromage, a separate Minecraft Classic clone written for the PS1 (https://chenthread.asie.pl/fromage/).

one question that always plagues me when we talk about mixing manual and automatic memory systems is...how does it work? if we have a mixed graph of automatic and manual objects, it seems like we dont have a choice except to have garbage collection enabled for everything and make a new root (call it the programmer) that keeps track of whether or not the object has been explicitly freed.

since we still have the tracing overhead and the same lifetimes, we haven't really gained that much by having manual memory.

D's best take at this is a compile-time assert that basically forbids us from allocating GC memory in the affected region (please correct me if I'm wrong), but that is pretty limited.

does anyone else have a good narrative for how this would work?