reminder that to “try your best” doesn’t mean to strain yourself. it means to take the task seriously. when “trying your best” it’s still important to:

• work at a reasonable, sustainable pace
• set definite end points to any work that you do (“I’ll read one chapter”, “I’ll finish refactoring this function”, etc.)
• take frequent breaks
• take a moment to appreciate your work whenever you finish a task

lazygit is so fucking good. I can’t believe I’m only trying it now

I’m learning stuff that I never really understood about git just from playing with its interface. I bet learning to use this would be a fantastic way to learn git in general

how long until things will be okay again?

> “end to end encrypted chat”

> looks inside

> Math.random

what are the chances it’s not ai generated

risk-aware consensual c programming

we rly need a differnt term than handheld for devices the size of a small tv that require a backpack to carry around #gaming #switch2 #steamdeck

it makes me super happy to finally be able to show the capsule / box art as well as a name reveal for Iris Blade! the next game of my little studio, the one you've likely seen me share around here

the art was made by kali, same artist who did the capsule for carrot survivors. you can find her on instagram @Kalisdr_art. she's done art for other games, and if you enjoy the style, I'm told commissions are now open!!

for those curious, you can find a bit more details in the official announcement: https://community.carrot-games.com/viewtopic.php?p=42#p42

happy third anniversary to i can’t believe it’s really wed mar 1 16:49:20 2023

Thank you to all the members of the faceting community that have supported GemCad over many years. I am now retired and no longer offer GemCad for sale. You may use GemCad and GemRay for Windows free of charge, but you may not sell it or redistribute it. Please link to www.gemcad.com so long as this site is active
You may use the following registration keys free of charge:

User name: anybody (Note: literally just the word anybody, not your name)
GemCad key: 7672
GemRay key: 1336746504

If you find the software useful, please make a contribution to your local food bank or other charitable organization and send me a note by email or text via the Contact tab above.

ok so like, could literally every single person and company selling software please fucking do this, cause this is the coolest fucking thing ever

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