imaltont

You should take a look at something called Case-based reasoning. Seems to perfectly fit into the road you are currently walking, as you basically just rediscovered the CBR-cycle.

Amazon's game engine is also open source under the name O3DE.

I have done typescript successfully. It has another install folder than the default, as the repo has tree-sitter for both tsx and typescript. C/C++ could be a similar situation. The installer should prompt you for it during the setup.

While it doesn't properly understand the structure, you can move around pretty well with Imenu or (configured) org-goto. I assume it's also possible to make something for it so that it take nesting into consideration like it does for some programming languages. My org files are only a couple 1000 lines though, so don't know how they perform when it gets larger than that.

And the finetuned models seems to be CC-BY-4.0 (note there are no NC). IBM actually not lying it seems unlike most of the other "open source" models.

You should check out Scheme with SRFI-119 or similar. It is a really elegant and noise-free way of writing S-expressions, unsure if it works with Racket or not though.

I also did a similar challenge this year, though I had to drop some of the more exotic languages that you kept in. Nice work.

You can type ‘M-x butterfly C-M-c’ to run it. This is a permuted variation of ‘C-x M-c M-butterfly’ from url ‘https://xkcd.com/378/’.

From the documentation. I don't know why they didn't make it the same, but this is how it is, though maybe because M-butterfly is rather hard to press.

M-x butterfly C-M-c(or RET), made in reference to the xkcd. Been in there since version 23.

Emacs 29 can download packages straight from their source too, so time to move back I guess.

In my experience it depends a bit on the LSP server itself (as well as it just being horribly slow in Emacs 27 and older). Omnisharp is for instance way slower than clangd and rust-analyzer. Also helps to make sure all the various mingw dependencies are there if you use Windows (json and native compile in particular). If you used LSP-mode it would be worth checking out if you can disable some of the information it renders to improve performance in general.

Other than that, Company can be a bit slow compared to Corfu, which is a bit more lightweight completion framework, built more around the emacs internals.

It was my comment you replied to. I meant for running scripts locally, before pushing/pulling/commiting etc. The distribution part is just those scripts being by default in a folder that is not tracked by git (.git/hooks), but you can change it in your config file. Hooks should be able to run any executable script file, so there isn't really any limits outside of convenience to what you can make it do.

You probably could use server-side git hooks just fine as an alternative if you self host the repo though, but I would assume if you are using github, or another hosting service, their tools are probably best/easiest/most convenient for their own platform.

The post is about running github actions locally though. The built in ones also support running server-side too, though I imagine github doesn't have the same level of interface over that as their own services.

Git also has built in support for automated stuff (git hooks). By default it is only local to each machine, but it is possible to set it up to distribute the hooks too.

Common Lisp is idd pretty nice.

I don't think you know just how modular a Common Lisp environment is. Sure there is some hot reloading that sometimes works and you can change the value of variables, maybe even jump back and forth in your stack trace. Rarely does it do any of them as well as Common Lisp though, where the only thing that doesn't dynamically update when you change something is struct-instances and macros. Functions, variables/values, classes (including instances) can all change as you want it without restarting anything. When something goes wrong, like errors or exceptions, you can modify some code, restart some where on the stack, ignore it and continue execution, insert dummy value or insert a placeholder function.

Some form of interactivity with the debugger is common in my experience. The level of interactivity you get with Common Lisp is not.

You here run into other problems though with people mirroring code on github that they do not have the rights to change the license for, which would be required for accepting the terms of services. E.g. if you take a GNU project hosted at Savannah and maintain your own independent for of it on github for whatever reason, you cannot re-license the bit that is own by the FSF to conform with the github ToS without getting the FSF's permission (and for other projects without a single copyright holder, every single contributor). This ofc isn't Microsoft's or Github's fault, but the people making the github repo, but still creates a problem for breaking licenses.

Their FAQ also has some ambiguity on what it has been trained on:

It has been trained on natural language text and source code from publicly available sources, including code in public repositories on GitHub.

Do you constantly "rewind"? E.g. getting rid of stuff like "try if this works" type commit messages, after you've finished doing whatever experimentation you need to do?

Not constantly, but will clean up the local/personal branch history before creating a PR with a rebase. Change some messages, maybe change up where some of the code is committed or even change the order if that makes more sense than the way it actually happened. It's a pretty quick and easy task to do when you get use to it.

I, for example, dislike having to track any small change I have made and commit it. I like committing larger parts which contain a functionality.

This is pretty much the suggested way by the creator of git too. A commit should contain the necessary changes for one bit of functionality/bug fix. This imo makes the history pretty neat and tidy, while at the same time making it easy to search through with blame/bisect whenever you need to. Giant commits (multiple functionality/whole project/extension squashed into one) makes both of those hard to use and in some cases pretty much useless outside of finding who did it and hope they still work at the company and remember their state of mind when they did the change.

I assume you are probably trying to make fun of the comment or playing devil's advocate or something, but you are correct. The illegal part comes when you try to share things you have no rights to share, such as the ROMs or BIOS.

Just as you can go to to arch linux' web page and download through their recommended method (torrent), you can go play old PS1 games on the PSClassic (based on the PCSX emulator), or play GB/GBC games on your 3DS Virtual Console (in house nintendo-made emulator afaik, correct me if I'm wrong).

Torrenting is a pretty standard, official, way of distributing Linux ISOs. Linux' license also doesn't really stop anyone from doing so, as it very much wants its users to share it with others (GPL v2, see the 4 freedoms of the FSF). There could be problems distributing e.g. Red Hat-owned stuff (trademarks, copyrighted things, non-FOSS software and such) without permission, but Linux itself is completely legal to share.

Torrenting also isn't illegal by itself or a direct link to pirating, it is just a very common way of sharing pirated data.

Also convinced he writes in his sleep with the amount of books he releases.

Also seems pretty hostile towards KDE's MauiKit from an ethical standpoint, as it is both older and trademarked afaik.

At least KeePassXC has a non-cryptic website. Still not as convenient as the cloud based ones though, but it's nice if you are primarily using one device or know how to share the database between your devices.

No, mold is fungi. Some of them even contain anti-bacteria properties (penicillin).

Emacs comes with a built in debug mode that works with several debuggers, including gdb, out of the box. There are also things like DAP-mode. Vim has Vimspector which is pretty decent as well as a debug/gdb mode introduced in vim 8 that I have not tried yet. There is a built int TUI as well, but I haven't tried it too much. There are probably stand alone interfaces available too that I am not aware of.

I think SUSE have some positions focusing on consulting as well.

Well, they are different languages made for different things. Clasp was specifically made because the author had a bunch of C++ code for his research projects, but wanted something more high level/simpler to implement things in. He landed on Common Lisp but none of the implementations had good C++ interop, so he made his own. Can recommend Christian Schafmeister's (creator of clasp) talks on it, it's interesting stuff. In particular his talk on an LLVM Conference.

I believe Clasp has a pretty good C++ interface as well for Common Lisp.

It requires sharing derived code for free.

It requires you share the code with your users/the people you distributed derived works to for no additional cost. You can still charge money for the software, but you can't charge an additional fee for access to the code. You also give them the right to share it how they seem fit, so they could share it (the code, not necessarily trademarked things like names or artwork/assets) for free, share derived software including the code for a free or a fee, or not share any derived work at all.

You can read more here: https://www.gnu.org/licenses/gpl-faq.html

Guile was afaik, until it wasn't anymore and they went with Vala instead, though I can't remember when that happened.