I still think that the concept of a Lisp language is incredibly elegant and powerful, and I think it’s such a shame that every popular Lisp I’ve tried has been so unpleasant to work with. and that even some of the more niche Lisps like Janet have serious fatal flaws that need to be addressed. I don’t think Lisps have to be this way - I think this probably comes from the decades of baggage that these languages are still carrying around from the 1960’s

and I hope that someday a Lisp will be created that isn’t afraid to throw that baggage away and start from scratch, with modern language features, good documentation, and static analysis as a first-class feature. in the meantime I might use Fennel when I want to write Lua, just for fun and to remind myself that it exists. but otherwise I guess I’ll stick to Python

I’m about ready to give up on Racket. the lack of LSP features and the often-unhelpful error reporting make it pretty difficult to work with - especially as a project gets more complex, and especially when refactoring (it’s so labor-intensive to track down what all broke because I changed a function’s signature)

Typed Racket seems to fix a lot of these problems, but creates so many more of its own - like the inability to use a ton of libraries that I had been relying on up to this point, including threading which is such an amazing threading library T_T

so I’m not sure what I’m going to learn next. I might go back to Python and learn some GUI programming instead - and remake my clicker game there. Python isn’t as nifty as Racket with its macros and Lisp syntax and its amazing threading library. but Python works incredibly well for me, has really good tooling, and I know it very well

here’s a great example of the problems that I always run into with static typing

so I’m playing with Typed Racket and I have a function called hash-invert which takes a hash table (a dictionary) and returns a version with the keys and values flipped:

(define (hash-invert [h : (HashTable Any Any)]) : (HashTable Any Any)
  (for/hash ([(k v) (in-hash h)])
    (values v k)))

currently I have it annotated as taking a (HashTable Any Any) and returning a (HashTable Any Any) - but that’s not as specific as I’d like it to be. because actually, if K and V are generic types then it takes a (HashTable K V) and returns a (HashTable V K) (it flips the keys and values)

but if I try annotating the function like this, Typed Racket complains because I guess it thinks that the result of (for/hash) must always be a (HashTable Any Any) for some reason?? and I don’t know how to convince it otherwise, or even why it thinks that at all. so if I were using a statically typed language right now, I would be screwed because I wouldn’t have Any to fall back on

@zeichenreihe woahh - that is really hard to wrap my head around lol. I’m not sure if I understand at all in that case. but that’s okay! this type of stuff tends to be difficult for me anyway hehe

https://www.keshetonline.org/movetothrive/

I just discovered this program: interest-free loans up to $10,000 for any LGBTQIA+ person in the US who needs money to leave their current home

I thought I’d post about it in case anyone can make use of it

someone should make a Rust-inspired Lisp, and by that I do not mean “pedantic about the tiniest implementation detail”

I’m starting to think that maybe the trick to making a statically-analyzable Lisp is to do what Rust does and figure out as much stuff at compile-time as possible. or in this case, transpile-time because it would be transpiling to a simpler subset of the language’s own forms (which are then analyzed by the LSP)

Rust actually does a ton of smart things in terms of language design so it’s a shame that it’s *gestures vaguely*

@cinnamon I believe it - I guess by calling it a “shitpost” I meant that the program itself was a shitpost, despite the fact that it worked. but yeah I love that this existed

honestly now that ZDoom can handle non-Euclidean spaces it shouldn’t be too hard to have arbitrarily-organizable process lists that are in fractally-nested rooms. or even file lists where each room is a directory

maybe someone should remake this

@cinnamon omgg this is a seriously impressive shitpost lol

In light of the continued enshittification of Youtube, I've finally scrounged together the energy to get files shrunk down and uploaded to a peertube account

@octaviaconamore@vid.northbound.online

It won't include any full streams since there's a 20GB total data limit, but I've uploaded every stand-alone book reading I've recorded Most of them are still waiting to be transcoded server-side, but the whole YT library will be up in a few hours~ oh, and despite the potato video quality (only 1500 kb/s), the audio quality is a full 320 kb/s

add. if you follow the peertube account from your Fedi account and turn on notifications, you can get a notification every time a new video is uploaded~

#ElderScrolls #Vtuber #Reading #Bookstodon #Books

if the problem with Lisp static analysis is that macros can expand at runtime, I wonder if this could be fixed by having a Lisp where macros expand at compile-time instead (which is what Fennel does)

although this means that macros would have to be more limited, and that’s a bit of a shame (though I’m not sure exactly what the use case of runtime macro-expansion is anyway)

the Racket LSP is pretty bad so I thought I’d try editing my Racket code in Emacs instead of Neovim, since Emacs has racket-mode

but unfortunately it seems like racket-mode is every bit as bad as the Racket LSP at figuring out wtf is going on in this language lol. it can’t even tell if I’m calling a function with the wrong number of arguments (which the LSP can’t either) and has a lot of the same quirks and missing features

so that’s a shame. it seems like you can’t really have a good editing experience when writing Lisp code. I wonder if the highly-dynamic nature of Lisp languages (macros, dynamic typing, etc.) makes most kinds of static analysis impossible. it’s pretty annoying though, I’m ngl

the main feature that I’m really missing is being able to press K on any function and pull up a bunch of helpful info on that function (contracts, arguments, and its docstring (which Racket doesn’t even have :/)). instead I have to search through my files manually to find the definition of that function, every time. super annoying

@cinnamon aww that sucks, but it’s still such a cool concept for managing files in general

@cinnamon yooo this is so fucking cool! how does it handle bigger filesystems with lots of files and folders?

It’s a UNIX Linux system, I know this!

(Got the sources from https://github.com/mcuelenaere/fsv/releases/tag/fsv-0.9-1)

I’m pretty proud of myself for solving a problem that Racket folks apparently never even considered, or couldn’t solve on their own

https://pastebin.com/1tGydApd