@zeichenreihe omgg I just looked up LEAN and it scares me lol. like it seems pretty cool - it seems like it’s able to solve equations at compile time and turn them into constant values? and maybe it can also mathematically prove that certain functions will always be correct, which sounds really cool if that’s a thing that it cna do

but this type of advanced math scares me lol - you can’t even google what something like ∀ means or what a lot of the jargon is

FFXIV should have an addon where people can thumbs-up or thumbs-down whether some dialog is worth reading or if you should just skip past it. and then everyone can see those ratings before they decide whether to read something or not. I genuinely think that would be incredibly helpful for the community to have

every MMO has to have an unreasonable amount of filler because that’s how they keep players occupied long enough to make the next expansion. FFXIV, being a story-first game, puts a lot of that filler in the form of dialog. so NPCs will prattle on for paragraphs and paragraphs about how you should deliver wine to some guy, then you walk over to the guy and he prattles on about how you gave him wine

but if there was a way to know what dialog is filler and what dialog is worth reading, that would alleviate a ton of the problems that FFXIV players face - especially new ones who have to deal with the incredibly slow start of the story

it might even convince me to not skip past every bit of MSQ dialog I encounter :P

Racket’s contract system is so cool!

it kind of works like type annotations in a language like Python, except instead of providing information for static analysis from an LSP, these are checked at runtime and they’re much more granular than just checking types

for example in Python I could write a simple Collatz function like this:

def collatz(max_: int) -> list[int]:
    ...

and that would tell my LSP that max_ is an integer and this function should return a list of integers. but in Racket I can do:

(define/contract (collatz max)
  (-> positive-integer? (listof positive-integer?))
  ;; ... code for the collatz function goes here
  )

and what this means is that max must be a positive integer, and collatz must always return a list of positive integers. if anything else happens, that will cause a contract error at runtime

so you’re not just defining what types your functions take - you’re also defining what specific kinds of values you’re expecting! and you can even define your own contracts from scratch, almost like writing your own assert statements (except it’s also kind of like defining a new type of data)

the one downside to this is that the Racket LSP can’t statically check contracts - they have to be checked at runtime. but still, it’s so cool

@mark_pc ooh I hope that you end up liking Rogue Incursion! it’s definitely not for everyone but it sounds like you might appreciate a lot of the same things that I did - and I also just enjoyed the atmosphere a lot too

for Alien: Isolation, I definitely remember a few times where I stopped and asked myself what a room was used for before everything went to shit and I couldn’t really figure it out

and I also remember that there’s this one specific machine that kept being reused as an objective. in one mission it was a power generator for an elevator but in another mission it was something completely different, and I think it was reused about 3-4 times as different things each time. but I could have also just been confused lol because I had a hard time understanding what Ripley’s moment-to-moment goals were in that game

@emmy that’s an interesting thought! I wonder if that’s at least part of what’s going on

@ruwuby thank you I hate this

@h3mmy @kasdeya automatic semicolon insertion has gotta be my favorite part of js - somehow brendan eich managed to make both semicolon likers and haters mad. unprecedented lows in language design

@nycki that honestly does kinda fit what my experience is. except for the compiled languages which want to be like Java. but Java wants to be like C in a grey business suit

there is a weirdly strong correlation and I’m not sure why that is

how to tell if a language is compiled:

are there semicolons at the end of every line?

no: it’s interpreted

yes: it’s compiled

@Owlor yeah I’ve joined tech.lgbt and now cryptid.cafe and both of them have been amazing! so I’ve never run into this problem on Fedi thankfully

I wonder if that’s because a Fedi server is more like a community where you interact with the folks you’re helping every day - but a Matrix homeserver is more like a public service where you just see an abstract number of how much the server is getting used

this post inspired by me taking this advice and ending up with a homeserver that shut down within 2 weeks of me joining

oh? I noticed that your matrix account uses the matrix.org homeserver. did you know that if you use a homeserver besides matrix.org you’ll be helping the network grow more robust and decentralized?

for example there’s transkitty.nyaan.si which I- oh that one’s gone

well I’ve seen a lot of folks using miau.dev which is run by- oop the server has been offline since a month ago

well there’s always homeserver.project.foxgirls.online which- ah, they’ve announced that the project will be shut down due to creative differences

anyway make sure not to use matrix.org or the network will be less robust!

@codingcoyote hm I’m having trouble imagining what those higher order functions would be or how they work, but I think I roughly understand overall! it kinda reminds me of Python’s duck typing, where as long as the expected fields are there then everything is okay. almost like following an implicit interface

also this has me worried that I’m going to have no idea how to do abstractions in Racket lol. I think you use structs for that? maybe it’ll make sense when I start experimenting

I just had a realization about a point of confusion I’ve had with functional programming languages for a long time: sometimes, in functional programming, an entire value can represent an abstraction and you aren’t meant to know anything about its internals at all

in the languages that I’m used to:

• if you have a function, that signals that it’s an abstraction and you’re only meant to understand its inputs, its outputs, and its side effects
• if you have a class or object, that signals that it’s an abstraction and you’re only meant to understand its methods (as if they were functions), its publicly-accessible data, and roughly what data it’s representing internally
• if you have any other type of data, you’re meant to understand every detail of it, because it’s not an abstraction

but since functional programming doesn’t use classes, the abstractions go more like this:

• if you have a function, it’s the same as above (know side effects, inputs, outputs, everything else is abstracted)
• if you have certain data types (I’m not sure how you know which ones but there is probably a well-defined indicator) that signals an abstraction and you’re only meant to know what type it is (so you know which functions can operate on it) and roughly what its internal data represents
• otherwise, you should know everything about the data because it’s not abstracted

so that explains a lot lol. I was talking to a functional programmer about why they were sadistically (from my perspective) asking the caller to do a bunch of very complex function composition in order to use their public API, but from their perspective the function composition was an implementation detail and what was actually happening is that functions were being used to manipulate abstractions in a way that was probably very intuitive to them. and this distinction was completely lost on me at the time so I just got confused and frustrated

stuff like this has me thinking that the cultural differences between functional programmers and {mixed paradigm or OOP} programmers might be so extreme that you’d need a translation layer between functional code and OOP code in order for programmers on each side to use each others’ APIs. because even very fundamental things like “how do I recognize a black box when I see one?” are very different between them, and in a way that’s so implicit that they aren’t even aware that it’s a cultural difference

RE: https://infosec.exchange/@rebane2001/116123227412288110

This might genuinely be the most mind blowing thing I’ve ever seen.