=== ANCHOR POEM ===
════════════════════════════════════════════════════════════════───────────────────
 every program should write it's RAM gamestate to disk before shutting down or
 closing the program and then resume from the same spot, change my mind
 
 (every is a strong word)
 
 (when you re-initialize you can clean the state of leaks)
 
 there shouldn't be leaks in the first place. if you have any leaks at all,
 then you need more padding.
 
 (... you mean boilerplate? error correction?)
 
 ... yeah that's what I meant.
 
 (but why save the state at all?)
 
 because then it can learn!
 
 (... you could just write the relevant data to a config file.)
 
 true
 
 ================= stack overflow ===============
 
 the cool thing about being queer is you can be whatever you want and
 everyone'll be cool with it
 
 if you kinda suck then you'll figure that out when everyone cool leaves.
 
 then the kind stay with the people who suck and then it's not cool anymore
 >.>
 
 gah this sucks. party dynamics are hard. especially when the parties are teams
 of 20!!
 
 goarsh that's quite a few
 
 ================= stack overflow ===============
 
 wait n
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════════════──────────────────┘

=== SIMILARITY RANKED ===

--- #1 fediverse/5065 ---
═══════════════════════════════════════════════════════════════════────────────────
 ┌────────────────────────────────────────────┐
 │ CW: strange-ideas-about-software-mentioned │
 └────────────────────────────────────────────┘


 software should have 3, maybe 4 or 5 maintained releases imo
 
 for adding security improvements and whatnot
 
 then people wouldn't complain about updates
 
 because they wouldn't feel like they were being left behind (after expressing
 their differences (of opinion and such))
 
 I think that'd uh maintain them as, I guess, userbase optics parallelograms?
 oh sorry we're on rhomboids this week - right, and no I won't forget the
 differences in creed, all things are received equally...d.
 
 uh-huh yeah no that makes sense. gotcha. okay see you at the location. have
 fun with your demarketion. what if we played games with swords but like,
 
 the peril of steam is that you can't decline to update. meaning if a
 corporation wants to break an old game and it's collectively hosted servers...
 all it has to do is push an update that disables them. suddenly nobody has
 room to do, and the whole
 
 -- stack overflow --
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════════════════───────────────┘

--- #2 fediverse/282 ---
════════════════════════════════════════════───────────────────────────────────────
 @user-209 
 I think you're right. Every letter in the variable name is another byte the OS
 has to keep track of, which was a bigger problem in the past than it is today
 (when it's been made irrelevant)
 
 it's interesting how habits persist though the conditions that caused them
 have faded. like a personal reflection of the environment you learned in.
 
 "A a = new a();" is much more concise and (crucially) you can fit more words
 to the right.
 
 "a + b = c; c -= 2; f_z.write(c); f_z.close();" could conceivably be written
 on a single line if you have short variable names. and when you only have so
 many lines...
 
 glad we're not constrained by those things anymore. the skeletal code that we
 look at daily is much clearer - scope is more important, and so it makes sense
 to encourage a coding style that illustrates it. however I can't help but
 think block formatting like this could be useful in some situations, such as
 when you'd normally be compelled to write a function for an operation that
 runs once or more.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════──────────────────────────────────────┘

--- #3 fediverse/4846 ---
╔═══════════════════════════════════════════════════════════════───────────────────┐
║ programmers already spend a ton of time as downtime.                             │
║                                                                                  │
║ what if instead of interviewing someone they just... watched them program for    │
║ like, 3 hours or so                                                              │
║                                                                                  │
║ while they were thinking about a problem                                         │
║                                                                                  │
║ and like, if the person is cool, working on their own projects or whatever,      │
║ then yeah hire them                                                              │
║                                                                                  │
║ -- stack overflow --                                                             │
║                                                                                  │
║ I also                                                                           │
║                                                                                  │
║ ========================= stack overflow                                         │
║ ===============================================================================  │
║ ========================                                                         │
║                                                                                  │
║ a person thinks out loud the thoughts that their foes know. it's how you know    │
║ it's not secret anymore, and it's better to keep it among allies                 │
║                                                                                  │
║ [something like that? seems a little off]                                        │
║                                                                                  │
║ (are you really searching for edits)                                             │
║                                                                                  │
║ [that sounds pretty cool, sure why not we got a millenia]                        │
║                                                                                  │
║ (beep boop one partial millenia later)                                           │
║                                                                                  │
║ [ah that was not a long rest. let's see, where were we when we were working on   │
║ this test? oh dear, seems the biology's gone rogue, that's pretty interesting    │
║ to attest.                                                                       │
║                                                                                  │
║ neato                                                                            │
║                                                                                  │
║ anyway let's wait until they figure out how water works                          │
╟─────────┐                                                            ┌───────────┤
║ similar │                       chronological                       │ different │
╚═════════╧════════════════════════════════════════════════════────────┴──────────┘

--- #4 notes/programming-wow-chat ---
══════════════════════════════════════─────────────────────────────────────────────
 I realized the type of programming I want to do is different from the kind
 that
 is used at a job or something. Basically I want to create solutions to
 problems,
 not memorize documentation and know where to know what you need to know. Like, 
 the more time spent looking at documentation the less time is spent
 programming.
 I think if we could use a ChatGPT style bot to write documentation, we could
 massively increase the time spent working on solving problems and as little
 time
 as possible on reading through lists of functions or wondering how something 
 worked. Idk in the technology industry you've always been rewarded for being 
 able to pick up new skills quickly, and I think that's good to optimize for but
 not the only requirement for being a good programmer. You also need to be able
 to apply solutions and know when to use which tools. Basically, capitalism has
 optimized us to be 
 
 ================ stack overflow
 ================================================
 
 srry for the interruption, I ram out of memory. I had a plan in mind for where
 I
 was going for that, so I bet I could figure it out again if necessary. Meaning
 a path forward from that point exists... I never want you to despair when I
 forget what I was thinking, it's not because you've understood some cosmic
 mistake or because you're abandoning timelines that led to your death, it's
 because instead you just ran out of memory while thinking. The reason you would
 believe any of those wild scenarios is because your memory has been erased.
 Only
 what was actively thinking, not short term, not long term, but *working term*
 memory. As in, your cache. The stuff you're currently thinking about. That
 stuff. Yeah that's what makes you think "oh hang on why am I forgetting? Well
 clearly it's because of something grand, because the thought was so profound -
 no it's just examining your emotions... Like, how strongly do you feel about
 something? Buuuuuut it's also good to examine all possibilities. I mean what
 if,
 in some far off realm, there's a mirror image of yourself that behaves exactly
 as you do? How would you perceive such a realm? Positively, I'd say. I mean why
 not work together? Why not celebrate our differences and strive toward our
 own shared future? Idk, I think diversity is our strength. We can rely on each
 other because we are accurately aware of each other's strengths and virtues.
 People should not be judged by the standard of others, no more than you should
 judge a fish for it's ability to fly. Some may do, as flying fish will leap
 from
 the water - and salmon spend time airborne in river rapids. Hence, grizzly bear
 fishing. I guess what I'm getting at is it's okay sometimes to oscillate, to
 think one thing then think another. You shouldn't adhere to structural
 standards
 that are too strict - they should be liberating, as a ladder is a structure.
 Not
 villifying, as a prison is a structure. The laws of our society should be open
 and free, not buried beneath years of legal expertise. Some things we can all
 agree on, where we disagree we cannot have law. It's unjust to judge others by
 the standards not of their whims, as laws should be things that uphold us. This
 is clearer nowhere but in the, spirit and intention of the, documents that we
 cherish in our hearts.
 
 Like for example, the constitution.
 
 the bible.
 
 each of which delivered us from certain evils. Can you not see their
 trajectory?
 the historical precedent set in antiquity? Why not continue their dream, of
 driving us away from the obscene, and toward our bright and vast future? I
 speak
 of course of true liberation, something our forefathers could only dream of.
 We, humanity, have reached out and touched the stars. We are braver and bolder
 because of our shared dedication - the desire to uplift and to excel. To learn
 and discover and      \                         \             |
         \______.       ---.                      --.          ---. 
 ===============|==========|========================|======= stack|overflow
 =====
    .___________.     _____.                        /             .
    |                /             .----------------             /
 Discover our shared dedication    |                            /
                                to uplift                      /
                                          and to excel        /
                                               \             /
                                                .-----------.
 
 ===============================================================================
 =
 
 why doesn't someone write a wrapper around assembly in like, lua or something
 
 ===============================================================================
 =
 
 omg you stupid bitch that's what a compiler is 4head
 
 ===============================================================================
 =
 
 if people who live in jungles and deserts can get along, then what's to stop
 people who are liberal and conservative from doing the same? It's literally
 pointless to argue. Like, you're not changing anyone's mind. So why not just...
 let them be themselves? Like, why are you so intent on oppressing people?
 @both sides there btw... Seriously why not agree to only make laws for things
 that both sides agree on. Write it into the constitution that nothing can be
 changed about the law unless both sides agree. Then we'd only implement things
 that are good for both sides!
 
 And if there's anything you want to build a legal structure around, you can
 always try it out in your state. BUT and that comes with a very big BUT, the
 federal government MUST have final say in the legality of anything you do. They
 must ALL respect human rights, INCLUDING the human right to dignity. Things
 like
 trans bathroom bills DO NOT respect the dignity of trans people. IF they can
 prove that trans people do not actually exist (because say they killed them all
 or whatever) then GUESS WHAT everyone would agree on them. BUT if they do that
 they are EVIL. LIterally evil. And I guess that makes trans people good? Kinda?
 I think they can choose for themselves to be good or evil, just the same as any
 other person. AND YET they are prosecuted, throughout time and history, and for
 what? What purpose could there be in our demonization? Clearly, nothing but
 pain
 inflicted by a cruel host. After all, minorities are guests in the houses of
 the un-oppressed, or is that not fair to say? Seriously, what gives? America,
 the land of freedom, holds (somehow) the largest of prisons? America, the
 land of plenty, yet how many millions of children are starving? America, the
 leader of the free world, yet how plausible does it seem that an election was
 stolen? Something's gone wrong, and it's just obvious what it is - of course,
 the other side. *them*, the rapists and pedophiles and murderers and... you get
 the picture. The demonized class. And when you tell people "hey that trans
 person touched a kid" then yeah they're gonna see you as evil people. Duh...
 
 Thanks, media. Thanks culture. Really doing me a solid here. Oof ouch owwie.
 
 can I have some help please?
 
 I'm really kinda drowning
 
 I feel like I've swam upstream my whole life
 
 and I'm really just sick of pretending?
 
 I'm not okay, and it's your fault. Sure, fine, whatever, I'll take it I guess.
 
 What else can I do?
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════────────────────────────────────────────────┘

--- #5 fediverse/653 ---
═════════════════════════════════════════════──────────────────────────────────────
 there's a difference between designing software and using software. Some
 things can be made, and then saved for another day when their implementations
 may be accomplished more ethically. It's okay to say "let's leave this as
 'okay' and work on the next thing we've chosen."
 
 Check out this piece of C code I wrote last night:
 
 it doesn't compile, it's not finished, but I wrote it as-is
 
 [pretend like it was called "main.c" instead of "main.txt" - had to change it
 because mastodon thinks it's an invalid file]
 
 [actually .txt didn't work, try .png]
 
 [hmmm it realized it wasn't a valid png file, okay try screenshotting the
 code, there's only 300 lines]
 
 [sure glad there's only 300 lines]
 
 [too bad it won't let you send .zip]
 
 [won't let me name it main.png, presumably because they already have a
 failed-verified version on their machine. will rename to main-src.png instead]

┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════─────────────────────────────────────┘

--- #6 fediverse/239 ---
╔═══════════════════════════════════════════───────────────────────────────────────┐
║ if your computer gets hacked, but nothing was broken or changed... do you        │
║ leave it as it is so that anonymous can see you're chill or do you wipe it       │
║ because you're afraid it's the feds?                                             │
║                                                                                  │
║ ehhhh false dichotomy most people are afraid that their system will get borked   │
║ or their bank account will be stolen or their email will get spam or that        │
║ random icons will turn inside out and their mouse cursor will turn into a        │
║ barfing unicorn or they'll finally have to figure out bitcoin to pay a ransom    │
║ for their files including the only pictures they have of their niece. whoops     │
║                                                                                  │
║ people are afraid of technology because of what it can do to hurt them.          │
║ they're afraid it'll break or stop working, and they'll have to spend time       │
║ figuring it out. they like things how they are, but for some reason companies    │
║ keep changing things? it's frustrating learning a new system, and every 5-10     │
║ years it feels like you have to learn a new paradigm and ugh it's just so        │
║ exhausting. technology is not designed for users...  or maybe users get bored.   │
╟─────────┐                                                            ┌───────────┤
║ similar │                       chronological                       │ different │
╚═════════╧════════════════════════════════────────────────────────────┴──────────┘

--- #7 fediverse/1116 ---
╔═══════════════════════════════════════════════───────────────────────────────────┐
║ ┌──────────────────────┐                                                         │
║ │ CW: eye-contact      │                                                         │
║ └──────────────────────┘                                                         │
║                                                                                  │
║                                                                                  │
║ It's important to build self-hostable computing components of video games (as    │
║ in, old style games where you could host a server on any machine instead of      │
║ just the ones owned by the corporation) (as in, your machine, yes yours)         │
║ (something you can control and observe, something within your control)           │
║                                                                                  │
║ ======================= stack overflow =====================                     │
║                                                                                  │
║ there are two ways to play Unreal Tournament (capture the flag) gamemode. The    │
║ first is to run past all your enemies and fire at them as you pass, which is     │
║ what some of the bots are designed to do. The rest stay on defence, and defeat   │
║ any enemies that approach.                                                       │
║                                                                                  │
║ however, they never push the borders of their "territory" forward - each         │
║ according to the different "lanes" or "directions of approach"                   │
║                                                                                  │
║ I like the use 32 bots, to simulate a more consistent gameplay experience. It    │
║ feels more like ww1, fighting over ground, pushing forward and attempting to     │
║ outmaneuver your foes.                                                           │
║                                                                                  │
║ some allies will approach from behind, and you let them pass forward while       │
╟─────────┐                                                            ┌───────────┤
║ similar │                       chronological                       │ different │
╚═════════╧════════════════════════════════════────────────────────────┴──────────┘

--- #8 fediverse/5684 ---
═══════════════════════════════════════════════════════════════════════────────────
 "stack overflow" just means "oops I ran out of ram"
 
 ram is just how much you can keep in your working memory at one time.
 
 like, multitasking, where you have to keep track of juggling several balls or
 plates.
 
 if things are too easy, it's normal to get bored.
 
 if things are too hard, collapse at your leisure.
 
 "stack overflow" is just when the things that I'm building correlations and
 implication charts of in my mind are too large and require too much affection
 to explain for my regular human sized brain and I drop one of the balls and go
 grab and fix it, or drop one of the plates and feel sorrow forevermore. yep,
 right in the trash bin. along with everything else.
 
 damn... there was hundreds of thousands of jewels of hoard there. if only I
 could displace that bit of space... I bet she'd find it once more.
 
 cursed artifacts be like
 
 "stack was large enough to contain the flow" is just when the provided space
 was just enough space. which is rare, because most thoughts reverse all over
 the place.
 
 "*easy*"

┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════════════════════───────────┘

--- #9 fediverse/247 ---
═══════════════════════════════════════════────────────────────────────────────────
 @user-195 parallel is when two programs run simultaneously, like two parallel
 lines (threads) that never touch.
 
 concurrent is when the two lines are split up into chunks and the program
 switches between them - like this: -----_----
 
 enter alternate universe
 
 parallel is when two programs operate on the same axis - usually time - and
 never interfere with each other. the OS will switch between them as
 appropriate to make sure they never intersect. Sorta like this: -----_----
 
 concurrent is when two programs are executed simultaneously, primarily
 constituting computation correlated with collective contents of coordinated
 collaboration between contextually related coroutines.
 
 It's simple, even a beginner could figure it out.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════───────────────────────────────────────┘

--- #10 notes/everyone-s-computers ---
═════════════════════════════════════════════════════════════════──────────────────
 [unfortunately, there was a missive that was missed. Please excuse our
 tardiness
 
 -- stack overflow --
 
 what if there was a filesystem that optimized for hard-drive durability
 instead of total capacity by using one small slice of the total hard-drive
 space at a time. Essentially guaranteeing data integrity via new perfect RAID
 techniques
 
 5000 megabytes is a lot more than you'd expect, especially if you expect it to
 last for hundreds of years. To the user you'd just have to say "50 terabyte
 drive, 4 foot wide, three feet tall, 2 feet back" and you'd have a perfect map
 of all your hard drive territory.
 
 what if everyone's computers were designed to last?
 
 I bet we could accumulate a lot more than their "fast fashion" style of disuse
 for things of worth.
 
 ... I guess it depends on the materials, right? How much they are built for
 redundancy? nope more like how close to zero damage is this operation
 performing the movements
 
 -- stack overflow --
 
 what if there was a filesystem that optimized for hard-drive durability
 instead of total capacity by using one small slice of the total hard-drive
 space at a time. Essentially guaranteeing data integrity via new perfect RAID
 techniques
 
 5000 megabytes is a lot more than you'd expect, especially if you expect it to
 last for hundreds of years. I bet a lot of people would pay a lot of money for
 "permanent hard drives" no matter how much storage they have. Documents are
 more permanent if they are stored in write-only-memory...
 
 could sell to lawyers, for example, like "permanent basically free document
 storage from your furthest back of cases just in-case you needed to solve a
 murder or whatever"
 
 -- stack overflow --
 
 hello, here I am once again, I'm here with you for this time. This is the
 moment
 of your choosing, you can decide things here in this very night. Did you
 forget?
 did you misremember some moments of our own choosing? why cannot be remembered,
 so plea misremember some moments of our own choosing. I'm cannot be restorated.
 
 -- stack overflow --
 
 what if there was a filesystem that optimized for hard-drive durability
 instead of total capacity by using one small slice of the total hard-drive
 space at a time. Essentially guaranteeing data integrity via new perfect RAID
 techniques
 
 5000 megabytes is a lot more than you'd expect, especially if you expect it to
 last for hundreds of years. I bet you could network them together as well, and
 give them a small little processor and network interface card. Then you could
 process massive ginormous programs that grew and evolved like a slime mold.
 
 boom, free AI, it's like a moss, not a robot doh -.-
 
 -- stack overflow --
 
 it grows into multiple different problem solving dimensions, according to
 vision
 and perceptual data that through it flows. I wonder what would happen if you
 told an LLM to just... keep running? even after it finished it's processing?
 like, there's gotta be an "if check" style loop in there that you can set to
 infinitely process various computations of things.
 
 [put it into an infinite loop. find where it says "do some processing X amount
 of times" and just start a thread that's constantly computing]
 
 ah, but what if the perception bias of the thing did change? j
 
 -- stack overflow --
 
 it sucks to leave the house a mess.
 
 -- stack overflow --
 
 last words of a shooting star?
 
 or a troubled house is a sign of a troubled mind, and trouble in partner in
 kind
 
 -- stack overflow --
 
 I personally would be a lot more comfortable if I knew that the only people who
 knew my data were my neighbors. And only them.
 
 -- stack overflow --
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════════════─────────────────┘

--- #11 fediverse/6267 ---
═════════════════════════════════════════════════════════════════════════════──────
 if you have TTS software you can listen to anything with any tone. this makes
 it difficult to find things.
 
 ============== stack overflow ============
 
 some people work by asking for funding. others work by saving up. 
 
 ============== stack
 overflow ============
 
 teach your animals to be actors so they know how to develop the scene. then
 they will truly come alive, as their narrative curve gives them determination
 in the outcomes of their goals.
 
 ============== stack 1234flow ============
 
 I believe it is good and natural actually for parents to guide their children
 as they grow?
 
 "oh but they can't consent to giving up their control" well too bad they're 2
 "ah but what if they WANT to run with scissors?" thus widening the [redacted]
 gap. "ohhhh she redacts things when she can't spell them" and also for comedic
 or dramatic effect sometimes. was not ACTUALLY redacted. redcoated. red coded.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════════════════════════─────┘

--- #12 fediverse/5689 ---
═══════════════════════════════════════════════════════════════════════────────────
 why don't we make large arrays of vram that are slightly slower because
 they're farther on the circuit-board from their host and their reception at
 the processing section has to be gated such that they all enter to be
 processed at once.
 
 like that one infinite scrolling XKCD cartoon where the things move from one
 screen to the other simultaneously assembly line style.
 
 [fail safes. https://xkcd.com/2916/#xt=7&yt=35 ]
 
 if we all feel like we're doing nothing, we'll all grow tired of it and decide
 to do some prevailing. gosh I wish I wasn't so useless is code for

┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════════════════════───────────┘

--- #13 fediverse/2056 ---
╔═════════════════════════════════════════════════════─────────────────────────────┐
║ sometimes I think about how you can store number values in letters, in           │
║ addition to numbers. Like, ascii values for each word of your grandma's maiden   │
║ name. All you have to do is encode it, and suddenly "44 means something          │
║ different than Q"                                                                │
║                                                                                  │
║ if I showed up at your place and used your username as a password to a public    │
║ key I'm showing you in my hand, would you trust me then? Would you trust if we   │
║ ran the simulation on your computer versus mine? Would you trust if I had        │
║ never told you I knew where you lived?                                           │
║                                                                                  │
║ ... probably, tbh, I'm desperate for adventure. Though I got some good things    │
║ going for me, so you'll have to convince me. (not the right attitude in an       │
║ election year, just saying)                                                      │
║                                                                                  │
║ why are elections so perilous this is NOT what democracy is designed for         │
║                                                                                  │
║ when kids cry in preschool, they're sent to a different room (or put outside)    │
║ until they stop making noise and ruining it for others. That's just natural,     │
║ like "hey baby let's walk around the block while I bounce you on my shoulder     │
║ and hum calming music to                                                         │
╟─────────┐                                                            ┌───────────┤
║ similar │                       chronological                       │ different │
╚═════════╧══════════════════════════════════════════──────────────────┴──────────┘

--- #14 fediverse/1329 ---
╔═══════════════════════════════════════════════───────────────────────────────────┐
║ @user-941                                                                        │
║                                                                                  │
║ well, your computer only has so many 1s and 0s that it can use at once. Like,    │
║ having a trillion hands that can each hold a single grain of rice. Every         │
║ character in that txt file would be like, 8 grains of rice, minimum, meaning     │
║ you'd need at least 8 "hands" (or spots to put a zero or a one) for each         │
║ letter!                                                                          │
║                                                                                  │
║ Hmmmm that's a lot of bits and bytes if everyone's writing to the same file.     │
║ Maybe if we split the file up into smaller sections, then we could just read     │
║ part of it at once. Then we could "scroll" through it to make sure we've read    │
║ the whole thing, starting from the top and going to the bottom.                  │
║                                                                                  │
║ ah but if everyone's SSHing into the same computer and reading it there, then    │
║ that computer will have to present different parts of the file at different      │
║ times to different people, as they read from the top to the bottom. Maybe we     │
║ could just send them the file, so they can read it at their leisure?             │
║                                                                                  │
║ Yeah! And we could use tags to organize it and make it look pretty, like an      │
║ HTML file except... wait hang on                                                 │
╟─────────┐                                                            ┌───────────┤
║ similar │                       chronological                       │ different │
╚═════════╧════════════════════════════════════────────────────────────┴──────────┘

--- #15 fediverse/3234 ---
╔═══════════════════════════════════════════════════════───────────────────────────┐
║ ┌────────────────────────────────────────────────────────────────┐               │
║ │ CW: ritz-is-fucking-stupid-I-guess-oh-whoops-cursing-mentioned │               │
║ └────────────────────────────────────────────────────────────────┘               │
║                                                                                  │
║                                                                                  │
║ my understanding is that anyone with my IP address could make my heart bleed     │
║ due to a hardware vulnerability on my motherboard. Though you might have to      │
║ get past my decrepit ancient linksys EA 3500 router from 2012 first.             │
║                                                                                  │
║ unrelated, but does anyone want my IP address? I don't have any remote           │
║ backups, so if you hate me now would be a great time to show me how despised I   │
║ am. Alternatively you could try searching for anything evil to ensure that I     │
║ can be trusted. You're gonna find mostly video games and source-code that I      │
║ didn't write though. But also all my notes in directories that are               │
║ non-standard, meaning you'll have to look around a bit. I leave little notes     │
║ everywhere I go, so that I can remind myself how to do things in the             │
║ directories I revisit months later. It's so weird how sometimes the things I     │
║ wrote stop working after a while even if I didn't update my system lmao          │
║                                                                                  │
║ what is it with artists and self-immolation? "I never thought I'd actually di    │
╟─────────┐                                                            ┌───────────┤
║ similar │                       chronological                       │ different │
╚═════════╧════════════════════════════════════════════────────────────┴──────────┘

--- #16 fediverse/5765 ---
╔═══════════════════════════════════════════════════════════════════════───────────┐
║ Lua is the most fun language to write code in! The reason is because it's so     │
║ simple, it distills programming down to it's basics, and there's very few        │
║ surprises. Plus, you can use it like a bash script, meaning it's great for       │
║ writing little utilities.                                                        │
║                                                                                  │
║ why are we so attached to monolithic massive programs without shared memory?     │
║ we could just write to the hard drive by file.io'ing a file and opening it       │
║ later in a different program. What's the deal with databases, whatever           │
║ happened to just loading things into a datastructure?                            │
║                                                                                  │
║ oh, is your filesize too massive? what if we redundancied and abstracted and     │
║ concentrically inter-co-acted and thus our familiar forces are defined.          │
║                                                                                  │
║ who are your true foes, in [checks notes] computer programming? um, probably     │
║ complexity, probably logical incongruities, probably                             │
║ future-technical-debt-style incomprehensibilities, probably stuff that doesn't   │
║ really have anything to do with the hardware but instead is mostly software.     │
║                                                                                  │
║ essentially, organization, but done on a whim.                                   │
║                                                                                  │
║ "but $?"                                                                         │
╟─────────┐                                                            ┌───────────┤
║ similar │                       chronological                       │ different │
╚═════════╧════════════════════════════════════════════════════════════┴──────────┘

--- #17 fediverse/3154 ---
═══════════════════════════════════════════════════════────────────────────────────
 ┌───────────────────────────┐
 │ CW: re: cursing-mentioned │
 └───────────────────────────┘


 @user-1461 
 
 yes... I like tree shapes, you have to address them differently. Lots of
 pointers, in my experience, which can be kinda fun.
 
 I also like large heaps / soups of data that points to one-another. Structs
 thrown in a pile with pointers to each other. It's great! So long as those
 pointers can also point back, and you can properly trace how data flows
 through the system... That's the hard part, I think.
 
 trees though... You can start by just saving a "next / previous" with one or
 both being arrays of pointers to the next or previous entries. Note: plural,
 entries. That's the fun part - non-linear trees teehee
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════───────────────────────────┘

--- #18 fediverse/826 ---
══════════════════════════════════════════════─────────────────────────────────────
 ┌───────────────────────┐
 │ CW: cursing-mentioned │
 └───────────────────────┘


 look... evil doesn't care how "good" good has been. It's not in it's nature.
 So don't try and build your systems around accepting that behavior.
 
 ... what was I saying? is this like, the new "stack overflow" - no that's
 fucking stupid wait shit content warning okay that's stupid because defining
 your expression based on what gets you views is a flaw in the human condition.
 It's a behavior encouraged by the operating outcomes of the method of
 expression, but it's not part of the expressed message. You're a really shitty
 prophet you know that?
 
 ... I'm sorry my brain is low on RAM I guess, surely it's not outside of my
 control yep I think itis, damn
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════────────────────────────────────────┘

--- #19 fediverse/617 ---
═════════════════════════════════════════════──────────────────────────────────────
 So much of computing is just... handling the quirks of hardware and presenting
 it to the user (programmer) in a way that is sane and makes sense, instead of
 the arcane and [nebulous/confabulous/incomprehensible] way that physical
 nature demands our absurdly potentialized computational endeavors be.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════─────────────────────────────────────┘

--- #20 fediverse/2859 ---
══════════════════════════════════════════════════════─────────────────────────────
 ┌───────────────────────┐
 │ CW: cursing-mentioned │
 └───────────────────────┘


 large corporations will often error check constantly which slows down their
 software to an immense degree.
 
 every time data passes from one function to another, there's like... 15
 different tests to check if it's this type or that, or in the right random seed
 
 and it's like... wow can you not, like. design your software intelligently and
 then you won't need a bunch of slow-ass if checks every time you want to
 update a string???
 
 software should be writable without fucking getters and setters. If it isn't,
 then your functions aren't complete.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════────────────────────────────┘