How fedi sounds some days

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

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

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!

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.

People-first language is only suggested for things that are considered undesirable in our society. No one ever says we should use, for example, "a person with blondness” or "a person with overheight.”

The problem therefore isn't necessarily where we put certain words, but that those words (and the conditions associated with them) are seen negatively.

So no, saying “a person with obesity” will not solve weight stigma in our society.

id like to apologize to venite for complaining about its default dark mode

> LOOK

You are in a room. There are exits to the north and west. There is an armchair.

> SIT

You are sitting in an armchair in a room. There are exits to the north and west. A small black cat enters the room.

> TAKE CAT

You cannot take the cat.

> PET CAT

You pet the cat. It starts to purr.

> PET CAT

You pet the cat. It jumps onto the chair, purrs, and settles on your lap.

> N

You cannot go north. You are immobilised by a cat.

> STAND UP

You cannot stand up. You are immobilised by a cat.

> W

You cannot go west. You are immobilised by a cat.

> PET CAT

The cat purrs.

if any of y’all like the newer Resident Evil games (like RE2 Remake or Resident Evil Village) I’d highly recommend giving Crisol: Theater of Idols a try

in fact if you just like puzzle-solving, exploration, and slow tactical combat I’d still highly recommend trying Crisol lol because it has a fantastic balance of all three

it’s a horror game though and there are a lot of CWs, so I’m going to make a second post with a link to the game as well as a list of CWs

who would win:

the transfemme urge to have long flowy beautiful hair

vs.

the autistic urge to not have a long flowy sensory nightmare attached to my head at all times

imagine a language like Lua except every table literal is actually a block of code that is run like a module. for example:

let someTable = {
    export someValue = "foo"
    let privateValue = "bar"
}

print(someTable.someValue)
# prints "foo"

print(someTable.privateValue)
# error

that would mean that when you require("someModule") you’re essentially wrapping the entire someModule file inside of { } and getting the result

it would make table literals more noisy but it would also let a Lua-like language have even fewer concepts that need to be learned in order to understand it

plus, you could define a whole class inside of one set of { } which would make the syntax mirror how most other languages do classes - and create a visual divide between the class and any unrelated stuff that might exist in the same file:

let SomeClass = {
    export new = (value) -> {
        let newInstance = {
            let privateValue = value
        }

        setmetatable(newInstance, this)
        return newInstance
    }

    export getValue = (this) -> {
        return this.privateValue
    }

    export setValue = (this, value) -> {
        this.privateValue = value
    }
}

let instance = SomeClass.new("foo")

you could even make it so that if you return inside of { } then the whole { } block evaluates to whatever you returned, so you can have multiple statements inside of your expressions (and not just table expressions) just like in Lisp:

let fibonacciNums = {
    let a, b = 0, 1
    let nums = {}

    for _ in range(100) do
        a, b = b, a+b
        list.push(nums, a)
    end

    return nums
}

print(fibonacciNums)
# {1, 1, 2, 3, 5, ...}

Oh, I forgot. The CD player I just bought also comes with a comic.

It says they carefully retrieved my product from their inventory with sterilized anti-bacterial gloves and placed it on a satin silk cushion.

The party they organized to celebrate my order lasted 3 days. When the time came, the clamoring crowd cheered through the city as the procession made its way to the post office.

A team of 50 experts proceeded to inspect the product. They polished it until it shine and bid it farewell with a tender caress.

The postal service then took over, using one of their many private jets to send your product as fast as possible. Give. It's inestimable value, two fighter jets were dispatched to ensure it's safe arrival.

Their internationally renowned packaging specialist (who came straight from Korea (lit candles and incense sticks. Absolute silence set as he placed the product in its box.

They've placed my photo in a 50x50 food frame and selected me as customer of the century. (Unfortunately this position may be contested in the year 2100).

They then offered to send me another version of this comic with a real photo of me (or my pet) on it that's printable.