Wollantine

I'm going to follow in the footsteps of @Aron_Adler and uninstall Twitter from my phone. I hope this helps me focus more on the important stuff, both in here and out.

on my language wishlist is a language that makes it super easy to describe type level checklists. i think this sort of exists already but im not sure how clean it is. like im thinking about opengl rn. shader programs will often have some global values, like positions for lights or cameras. each time you switch shaders you gotta configure whatever uniform data the program needs before you start using it to render objects. you can modify this data, but it is usually an error to not initialize it. the naive fix is to wrap up all of opengl in something functional. each invocation of a shader program could have these values as parameters. which would totally work and make everything type safe but now you are sending data to the GPU for every single draw call. if you only need to configure the shader once and are gonna reuse the config on 1000 different objects then you are sending a lot of redundant info on the wire. you could alternatively try to do some sort of reactive programming system, where you have the trad functional API but under the hood the program checks if there has been a state transition and skips the data upload if there isn't a change to the shader config. but this is pretty hard to get right. and i suspect it is really hard to get the compiler to eliminate all the checks for changed data at comptime, so there is still some runtime overhead what seems like a nice lightweight alternative would be some kind of type level checklist. in order to run a shader program you need to provide evidence of initialization of each of the relevant uniform data fields. the signature for the shader execution would be something like `runShader : ShaderProgramID -> ProofThatLightingIsConfigured -> ProofThatCoordinateTransformIsConfigured -> IO ()`. in order to obtain evidence you'd have to run other programs, like `configureLighting : LightData -> IO ProofThatLightingIsConfigured`. in principle all this evidence should be erasable at compile time. so no overhead. but it also guarantees that the shader is configured before it is used. also opens the door to things like skipping the data upload. it is technically legit to skip configuration; opengl initializes unconfigured uniform buffers to predictable default values. but imo it's still good practice to be explicit. so you could add a `useDefaultLightingConfiguration : ProofThatLightingIsConfigured` and now it is clearly documented and checked by the type system that you wanna use the defaults. i know there are things out there like this. idk ATS at all but i get the vibe that this is the sort of thing ATS is all about. also seems probably pretty easy to implement a crude version of this with linear type systems + phantom types otoh i don't see a lot of implementations of this sort of system and so that makes me wonder if there is a reason for that. given it doesn't seem terribly sophisticated i'd expect to see it show up places if it were actually useful maybe the devex isn't that great? it kind of seems like modeling a state machine at the type level with a million phantom types could feel very cluttered. maybe with the right syntax support this would be useful? or maybe its the kind of thing that you can get stuck admiring and improving your fancy type level model instead of getting work done. maybe its the sort of thing where the amount of time spent building the evidence management system eclipses the time spent debugging and so economy suggests not doing it so idk maybe this is a dumb idea. but i really love checklists and so i imagine id love a good system for representing them at the type level

@Aron_Adler @kerckhove_ts Make the illegal state unrepresentable democratically as well.

@wollantine @kerckhove_ts things the deep state doesn't want you to know

Do you prefer bash-flavoured bools or C-flavoured bools?

@kerckhove_ts This might come as a surprise for C and bash developers, but 0 is not a boolean, it's an integer.

In bash, 0 is true, but in C 0 is false.

@DjMolehill @nicbarkeragain But it's not "the actual concepts", it's "the C concepts", and it's good that people stop learning the C concepts.

@wollantine @nicbarkeragain I think Nic is saying that misusing terms makes it harder for people to understand the actual concepts, not that it's a pro

There's been a lot of damage done by high level programming languages overloading technical terms with a new meaning. An "array" in javascript is often not an actual array. "Objects" are actually hashmaps. Array.slice doesn't produce a slice, it allocates a new array and copies.

@itsfarseen A hidden storage. Like a concealed box of weapons, or a hole where a squirrel would hide the nuts it found so it wouldn't need to go searching when it gets hungry.

@wollantine What does cache mean?

C doesn't have the monopoly. Computer science does. Besides it's nice to have certain terms mean standard things across languages. JS being weird is a JS problem.

@kai_fall Wow, Rust is miles ahead.

@kmdrfx Lol "manure" instead of "demure". Spot on!

Terminals are where browsers were 25 years ago. Everything is different just eeeever so slightly. And then there are the proprietary features. Very mindful, very manure.

@iamtexture @zack_overflow Yes. We circle back to my first post. What if their personal beliefs include ceding the language to other maintainers once it gains traction?

You can just use logic. Ask yourself the question: "Why would someone create a programming language given that so many already exist?" And the answer is "To make a programming language that doesn't exist, based on their own personal beliefs about what a programming language should be."

Zig devs: Can we have private fields pls Creator of Zig: No just name them really, really carefully and hope for the best

@iamtexture @zack_overflow I think the sample size is way too small and we're doomed to shoot our subjective impressions. I propose we wait until a thousand more autists have made popular PLs.

@wollantine @zack_overflow Actually, there's a good chance he'll just stop letting other people use it if they bother him too much.

@iamtexture @zack_overflow Nothing stops that autistic man's manifest ideology from being "a language should cater to its audience".

@zack_overflow When a single person creates a programming language, you should realize that you are in one autistic man's manifest ideology about what a programming language should be. He's not going to be taking requests.

@mattpocockuk @dillon_mulroy @FlavioCorpa If you want to make FP palatable, you need to make FP palatable, not an approximation of it. FP is great because of functions, not despite them.

@mattpocockuk @dillon_mulroy @FlavioCorpa Not having .ap() means you can't apply an Effect of a function to an Effect of a value. In that case, Effect would be designed as a wrapper of values exclusively, and not treating functions as a first class citizen. Thus, it wouldn't be FP.

100 likes and I’ll make it happen! 🙌🏻🤞🏻

@mattpocockuk @dillon_mulroy @FlavioCorpa It doesn't matter if the course of action must be the same for both: Effect must be FP.

@dillon_mulroy @FlavioCorpa Effect should not be making TS more palatable to FP people Effect should be making FP more palatable to TS people

@davesnx To hell with abbreviations, I say! And don't get me started with single letter variables!

them: "I'm a functional programmer, I love abbreviations, code clean makes me happy" me: Sure, let's play a game

Anyone who prefers M*crosoft Teams over google meet doesn't deserve employment

@awesomekling @ladybirdbrowser

mfw reading @ladybirdbrowser commit messages "Atlassian login gets the base URL for its module scripts by throwing an error and pulling out the current script's URL from error.stack with regex."

@Aron_Adler Well, they can't offer help with Lean, or you would be sure they are phishing, can they?

these targeted emails are getting wild

Addendum: Slop is Senior Level Objective Programming.

To make goop you just need Go and Objective Programming.