Wezl

Some APL environments such as ngn/apl[0] allow tab completion like |o<tab> results in ⌽. This is probably available on tryapl.org too, but I can't test it when it's down :/. It may also be available in the full dyalog apl product and IDE.

EDIT: see https://news.ycombinator.com/item?id=27462828 too

[0]: https://github.com/abrudz/ngn-apl

(not parent) personally I would like to see [trains](https://aplwiki.com/wiki/Tacit_programming#Trains) in more languages, though the way they are implemented in APL is pretty spotty (e.g. the length of a train changes its semantics)

I agree, but you have to take extensibility into account. You either have an extensible language and extend it[0], you make it an array language to the core, or you just have a few slightly convenient functions (not a language). (I don't have enough experience to judge which category Pandas / numpy are in)

[0]: https://github.com/phantomics/april

Should I have linked to project gutenberg or some other version? I linked to the mobile version because it doesn't have many sidebars or footers.

I didn't know that about the name. Should we pronounce it /ˈɡɒdoʊ/ like wikipedia says the play's name is pronounced?

I've only tried Glyphr[0] because it's online and gbdfed because it was in my linux distro's package manager and it was small (turns out it was a bitmap editor, which was fun to try out, but now I have a .bdf file that I don't know how to use). I can't really recommend these because they are the only ones I've tried, but Glyphr is simple though it doesn't have that many features.

Then find a way to use the font, like on a website, and you'll notice any problems or ugly parts.

[0]: http://www.glyphrstudio.com/

Maybe link to the website (https://dahliaos.io/)?

I use a custom font[1] I made ;). I'm still learning bits of typography, so it's not the most legible, but it was fun to make.

[1]: https://ermineii.github.io/befont.html

This also has, spoilers, https://github.com/1j01/98/issues/22

EDIT: and try opening up the page https://98.js.org/ in the internet explorer.

Hacker News.

Common Lisp[1] is pretty easy to set up, you can use portacle[2]. It's also one of the oldest and most popular. If portacle isn't in the repos, sbcl[3] is.

EDIT: For reading you can try Practical Common Lisp[4] or the Land of Lisp[5] if you want a dead tree. These I've read but there are more[6].

[1]: https://common-lisp.net/downloads

[2]: https://portacle.github.io/

[3]: http://www.sbcl.org/ (EDIT: fixed link)

[4]: http://www.gigamonkeys.com/book/

[5]: http://landoflisp.com/

[6]: https://www.cliki.net/Lisp%20books

Source: https://github.com/1j01/98

"Last modified: 2011/01/18" (in footer)

Which is used in https://98.js.org/ . (submitted: https://news.ycombinator.com/item?id=24955925)

Thank you! I've been looking for a browsser-based fantasy console.

It's a small game, they could port the entire game to another language or platform pretty easily.

I agree that Gitea looks a lot more like Github (but with a dark theme!), and I think this is a good thing. I also like Gitea because it doesn't have reCaptcha or other proprietary components, but it doesn't seem to have the advanced ('Enterprise') features that Gitlab does (I program as a hobby so I've never needed these). When Gitea has grown and is more accepted, I hope the Wikimedia Foundation will consider using it.

I need clarification: is this Mediawiki or Wikimedia moving to gitlab? It seems the Wikimedia foundation is moving their code, so why is this on mediawiki.org?

I enjoy lisp/scheme syntax, but I'm especially impressed by lua's simple, readable, flexible, whitespace-insensitive-but-whitespace-friendly syntax. It is a bit more complicated than scheme's, but more intuitive because you don't need to explain quasi-quoting and other lisp-specific stuff. https://www.lua.org/manual/5.4/manual.html#9

As a new user, I was able to get a pronounceable(ish) 4-letter username. It's not always hard. But Prologue is an English word and a lot of English words are taken. (and probably many words in other languages, too)

I agree. I like it because it is mostly words, like lua, rather than symbols.

Why does scheme have explicit booleans? Does this improve performance or is it just for clarity?

I've been writing a picolisp-like lisp interpreter[1] and I have really noticed this too. I added a length built-in just because recursion wasn't working properly, but if I had continued without the important functionality for too long, I would have needed to implement many more functions (and the lisp still would be missing important things).

[1]: https://github.com/ErmineII/mapL