Poems by similarity to poem 0053 (page 1)

=== ANCHOR POEM ===
══════════════════════════════════─────────────────────────────────────────────────
 ┌──────────────────────┐
 │ CW: Math             │
 └──────────────────────┘


 @user-5 create an array of length 7 initialized to zero. then use a for loop
 that loops 97 times and adds a random number between 1 and 20 to an array
 index that iterates through the array each time through the for loop.
 
 NOTE: be sure to also change the loop counter based on the random number too,
 so you allocate exactly 97 points no matter what random number you get.
 
 Oh and speaking of which if the loop counter 
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════────────────────────────────────────────────────┘

=== SIMILARITY RANKED ===

--- #1 messages/972 ---
══════════════════════════════════════════════════════════════════════════─────────
 vibecoders write detailed instructions. "A for loop which iterates through all
 of the elements" and not "a package manager that stores all of it's instants"
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════════════════════════────────┘

--- #2 fediverse/1034 ---
════════════════════════════════════════════════───────────────────────────────────
 @user-192 
 
 be careful, recursion can cause stack overflows.
 
 better to run function pointers from a loop. That way you can operate as long
 as necessary. Just make sure you don't get in an infinite loop...
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════──────────────────────────────────┘

--- #3 messages/412 ---
═════════════════════════════════════════════════════──────────────────────────────
 Coding superpower:
 
 Start thread 
 While(true):
 Run();
 
 Then, whenever you want it to run something else, change the function pointer
 that run() uses to call a function
 
 At the end of the run() function, set the function pointer in the while loop
 to the next one. That way you don't stack overflow from the recursion.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════─────────────────────────────┘

--- #4 fediverse/4084 ---
════════════════════════════════════════════════════════════───────────────────────
 ┌──────────────────────┐
 │ CW: re: -mentioned   │
 └──────────────────────┘


 @user-1074 
 
 the more you try, the more you have to calculate, which is a problem, because
 endlessly recursive calculations create infinite loops, which frankly are
 impossible to compute because they defy computation! Not good, not ideal, no
 thank you, not for me, no thanks, not what I'd like.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════════──────────────────────┘

--- #5 fediverse/573 ---
══════════════════════════════════════════════─────────────────────────────────────
 already spotted a bug. Should be for(1000 / MAX times) in the last example.
 
 EDIT: Or, even better, increment that loop by +MAX instead of +1 each time
 through.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════────────────────────────────────────┘

--- #6 messages/110 ---
═════════════════════════════════════════════──────────────────────────────────────
 The best way to program computers is to organize them according to their
 relations. Like, when x increases by 4 then y increases by 2 - basically, a
 math equation that you can continuously solve by calculating more and more
 comprehensively and deeply.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════─────────────────────────────────────┘

--- #7 fediverse/2879 ---
═══════════════════════════════════════════════════════────────────────────────────
 ┌────────────────────────┐
 │ CW: re: tech info-dump │
 └────────────────────────┘


 @user-1370 
 
 I love this a lot! I want to put function pointers in a "matrix architecture
 array" and make them point to different functions at different points in the
 program. I bet you could even point them at each other, so like if M and Y
 then point at N, A, Y or something.
 
 this is really cool I like stuff like this tomorrow I'll take pictures of
 something similar I'm working on! I abandoned it tho hehe anyway remind me if
 I forget!!
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════───────────────────────────┘

--- #8 fediverse/2363 ---
═══════════════════════════════════════════════════════────────────────────────────
 Don't know what to do? Do anything at all, and odds are you'll either see an
 opportunity to do something better or you'll have an idea.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════───────────────────────────┘

--- #9 fediverse/3760 ---
══════════════════════════════════════════════════════════─────────────────────────
 DID YOU KNOW if you ask someone 15 times over the course of an activity
 whether or not they're "having fun" then odds are they won't, in fact, have
 very much fun
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════════────────────────────────┘

--- #10 fediverse/6334 ---
╔═════════════════════════════════════════════════════════════════════════════─────┐
║ a D&D rulebook can double as tarot if you need it. place one hand/bookmark       │
║ at the start of a chapter, and the other at the end. flip to a page randomly,    │
║ or randomly gain a percentage value from physical objects and then use that      │
║ value to determine roughly where in the chapter you jump to. then, read words    │
║ randomly, jumping back and forth, or try and divine some meaning from the        │
║ words that are printed there. with D&D it's easy because you can say "ah I       │
║ landed on the rogue section, that means this guy is probably pretty suave"       │
║ (confirming your expectations) "hmmm, here's the rules for fatigue and           │
║ drowning. maybe I need to take a break." (validating your unconscious            │
║ decisionmaking) "oh neat, treasure!" (needs to explanation) but with other       │
║ kinds of books it's usually better to pick the next-best word from the things    │
║ your subconscious eyes can take in and process multi-laterally (you lost your    │
║ audience, circle back) oh uh so if you wanna randomize it just put the words     │
║ in the page in an array and pick one random.                                     │

(you lost your audience, circle back) oh uh so if you wanna randomize it just put the words in the page in an array and compare llm embeddings on each of them and see which has the highest score. this is a language-based truth serum, a way of divining exactly how something is seen to be by the model in use and mixed with a dash of randomized causality.

╟─────────┐                                                            ┌───────────┤
║ similar │                       chronological                       │ different │
╚═════════╧════════════════════════════════════════════════════════════╧═════─────┘

--- #11 messages/129 ---
══════════════════════════════════════════════─────────────────────────────────────
 So you're telling me the speed difference between Python and C is due not to
 the logic that the programmer uses, but rather the optimization capabilities
 of the compiler?
 
 (An interpreter includes a compiler, it just runs it in a loop rather than a
 single pass)
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════────────────────────────────────────┘

--- #12 fediverse/5979 ---
════════════════════════════════════════════════════════════════════════════───────
 whenever you call a function, just pass along the arguments that you don't
 know what to do with yet. they'll surely be useful sometime. and, luckily, you
 can always search for them from the past, and just insert a "store this value
 in this random spot of memory and mark it as needed" then pass it along. used
 something? think it's still useful? pass it along (suddenly, formulaic
 stateless development, where everything is used until it's no longer needed,
 then generated again in a cyclical time-loop cycle which echoes and
 reverberates groundhog day but mostly a game-loop, which nobody will
 understand unless you're a game dev. but now since I said game dev, anyone can
 look it up, so like... not that one, but others like it.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════════════════════════──────┘

--- #13 fediverse/4470 ---
═════════════════════════════════════════════════════════════──────────────────────
 to be "rich" is to have more than another.
 
 if you are happy, they are happiness poor.
 if you have community, they are alone.
 if you have serenity, they are chaotic.
 
 I am rich in very little but fire in my soul.
 
 I have enough in most cases, but I still struggle to pay rent.
 
 I am warmed by the pearl my swirling darkness has coalesced into. It nourishes
 me and keeps me aligned.
 
 Never forget your purpose and your truth. It will not abandon you, so long as
 you do so too.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════════─────────────────────┘

--- #14 fediverse/4628 ---
═══════════════════════════════════════════════════════════════────────────────────
 user interface tips #18569235:
 
 if a user is expected to click the same button multiple times in a row, for
 example a "next" button in an image gallery, DO NOT move the interface from
 below their mouse pointer and cause them to move their mouse in order to click
 it again.
 
 please don't : (
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════════════───────────────────┘

--- #15 fediverse/898 ---
═══════════════════════════════════════════════────────────────────────────────────
 ┌──────────────────────┐
 │ CW: scary            │
 └──────────────────────┘


 if you set up a local LLM with the capability to explain basic coding syntax
 and logic, then your parents computer suddenly becomes much more useful to the
 nephew that's been forced to hide out there for a couple weeks until this all
 blows over.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════───────────────────────────────────┘

--- #16 fediverse/572 ---
══════════════════════════════════════════════─────────────────────────────────────
 Hi, I'm learning about semaphores right now and trying to explain them to a
 friend. But I only sorta understand how they work - can anyone look at this
 pseudocode and tell me if I'm on the right track?

$Some C pseudocode working through the semaphore design pattern. Here's the text of the pseudocode: /* no lock example */ void start_thread(int* x) { *x += 1; } int main() { int x = 0; for (1000 times){ start_thread(&x); } print(x); } /* in this case you have no idea what will print because thread A will take x and be like "ah yes it's 423" and then in the next instruction it'll be like "I'll increment this to be 424" and in the next one it'll say "okay now it's time to store 424 in the variable X" but like... there's a thousand threads all doing that at the same time, so odds are you'll have 5 that are like "ah yes this is 423 I'll set it to 424" */ /* not a good plan. Need a lock, so only one thread can use it at once. */ /* mutex example: */ void start_thread(int* x, int* x_mutex) { *x += 1; *x_mutex = 0; } int main() { int x = 0; int x_mutex = 0; for (1000 times){ while (x_mutex != 0){ } /* do nothing */ x_mutex = thread_id; start_thread(&x, &x_mutex); } print(x); } /* this should print 1000, but it's basically as slow as doing it single threaded. */ #define MAX 10 void start_thread(int* x, int* x_semaphore) { *x += 1; *x_semaphore += 1; } int main() { int x[MAX]; int x_semaphore = MAX; for (1000 times) { for (int i = 0; i < MAX; i++) { x_semaphore -= 1; start_thread(&x[i], &x_semaphore); } while (x_semaphore != MAX) { } /* do nothing */ } int value = sum(x, MAX); print(value); }$

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

--- #17 fediverse/3226 ---
════════════════════════════════════════════════════════───────────────────────────
 if your man page is longer than a list of options and their usage and a
 paragraph or twenty of how to use the software... then you need to abstract,
 and break your code into multiple purpose-built applications.
 
 do one thing, and do it right. alternatively, do one set of things, and do
 them concisely.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════──────────────────────────┘

--- #18 fediverse/3680 ---
═════════════════════════════════════════════════════════──────────────────────────
 it's probably a good idea to write pseudocode, then real code, instead of
 starting with real code, and bugfixing something incomplete and more difficult
 to reason with.
 
 unless you write real code easier than pseudocode. idk do what works for you.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════─────────────────────────┘

--- #19 fediverse/1934 ---
══════════════════════════════════════════════════════─────────────────────────────
 @user-1109 
 
 do it in a random color each time! Here's my implementation for viewing txt
 files colorfully:

some bash computer code which first picks a random color, and if the color is a bad combination (like, black front and black back, meaning you can't see the lines of the letters) then it redoes it and tries to pick a better one randomly. It'll keep trying until it gets a correct combination but honestly there's only like one or two bad ones that don't look so great

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

--- #20 fediverse/6120 ---
═════════════════════════════════════════════════════════════════════════════──────
 ┌──────────────────────┐
 │ CW: AI-mentioned     │
 └──────────────────────┘


 it's pretty easy to read an article or blog post, copy the text into a text
 file, and forget about it.
 
 you never know when you might want to use your computer's memories for
 [entertainment during long dark nights, or for creating an AI buddy bot,
 depending on how things go]
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════════════════════════─────┘

--- #21 fediverse/2622 ---
═══════════════════════════════════════════════════════────────────────────────────
 what kind of linux user are you if you don't even like reading terminal
 output? it's USEFUL and INTERESTING information!
 
 WHY ELSE WOULD THE PROGRAMMER OUTPUT IT???
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════───────────────────────────┘

--- #22 messages/887 ---
════════════════════════════════════════════════════════════════════───────────────
 To defeat community, all they have to do is get you to have more fun with
 their people until you start spending time away from the enmeshed people who
 know you. Honeypot style.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════════════════──────────────┘

--- #23 fediverse/5719 ---
════════════════════════════════════════════════════════════════════════───────────
 I love dispatch tables! which is a term I just learned and a concept I have
 been using for a while.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════════════════════──────────┘

--- #24 fediverse/112 ---
═══════════════════════════════════════════────────────────────────────────────────
 I live through the moments where I find a folder of stuff I made that I forgot
 about and I can go back and see it for the first time.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════───────────────────────────────────────┘

--- #25 fediverse/466 ---
══════════════════════════════════════════════─────────────────────────────────────
 I love Linux. All I have to do is type "authserver" and "worldserver" and
 wouldn't you know it suddenly a universe is created (with very constrained
 rules) that anyone might inhabit should they desire to. It's not like I'm
 perfect - oh wait I have a toot about that, gimme a sec
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════────────────────────────────────────┘

--- #26 fediverse/2638 ---
═══════════════════════════════════════════════════════────────────────────────────
 I really do believe that you can write any computer program you'd like with a
 combination of Lua, Bash, and C.
 
 Bash to start the program and enable updates / configuration, Lua to handle
 the scripting and ordering of events, and C (or Rust) to execute performance
 intensive sections. (often in their own threads)
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════───────────────────────────┘

--- #27 notes/ideal-raleigh-structure ---
═══════════════════════════════════════════════════════════════════────────────────
 with a baseline directory structure,
 a measure of order and semblance of
 direction and purpose enable three.
 next, of course, is the final of 1
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════════════════───────────────┘

--- #28 fediverse/1976 ---
╔═════════════════════════════════════════════════════─────────────────────────────┐
║ when pushing ctrl+v, the operating system first checks the file-type of the      │
║ content being submitted.                                                         │
║                                                                                  │
║ if it's like, a .jpg or .png, it knows that it's an image file. Do note that     │
║ these are RANDOM letters that mean nothing, not something informative like       │
║ .pic.                                                                            │
║                                                                                  │
║ if, however, it is text-based information, it first reads what is being sent     │
║ to the application which is requesting a ctrl+v.                                 │
║                                                                                  │
║ Then, upon reading said information, it decides "is this worth passing on?       │
║ Should I send something else, based on the results of what I've been analyzing   │
║ of the situation as it develops over time, being observed by the execution       │
║ operations of the monitor, which is projected forward unto the screen?           │
║ (totally forgetting that "virtual" monitors exist, meaning monitors that don't   │
║ display to any physical screen, but which rather are projected into the          │
║ computer's "aetherspace", an area which is purely of the mind.                   │
║                                                                                  │
║ Alas, that other sensors might not have read from this area. That they might     │
║ not observe the results of the operations pe                                     │
╟─────────┐                                                            ┌───────────┤
║ similar │                       chronological                       │ different │
╚═════════╧══════════════════════════════════════════──────────────────┴──────────┘

--- #29 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 │
╘═════════╧╧═════════════════════════════════════──────────────────────────────────────┘

--- #30 fediverse/4301 ---
════════════════════════════════════════════════════════════───────────────────────
 @user-1655 
 
 maybe the user could tell their client what fields to expect and how to
 present them (like, a field called "memes" would be presented as a picture in
 this panel, a field called "rants" would be passed to a word-cloud function
 that extracts the most common 6+ letter words so you can tell at a glance what
 the rant is about, this other field could be for calendar invites (plain text
 of course, but interpreted by the calendar program) etc)
 
 plus, if it's encrypted with PGP keys by default, there'd be few security
 concerns. Unless your friend got hacked, or you got hacked, but, well... make
 sure everything's sandboxed and don't do any remote code execution and you're
 good, right?
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════════──────────────────────┘

--- #31 messages/753 ---
══════════════════════════════════════════════════════════════════─────────────────
 trusting the "open source community" to properly vett software is absurd
 because 90% of them just... install whatever and throw libraries and
 frameworks at problems until they can script their way out of whatever problem
 they face.
 
 the other 10% are focused on very specific tools that are so niche that other
 people can't even understand when to *use* them much less how they work.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════════════════────────────────┘

--- #32 fediverse/110 ---
═══════════════════════════════════════════────────────────────────────────────────
 @user-95 monday is as reasonable of a day to start the universe as any,
 wouldn't you think? it is the beginning of the week, after all.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════───────────────────────────────────────┘

--- #33 messages/488 ---
════════════════════════════════════════════════════════───────────────────────────
 Look at the unique patterns in a programming language, and you will find
 within them a usecase.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════──────────────────────────┘

--- #34 fediverse_boost/5196 ---
◀─╔════════════════════════════[BOOST]═════════════════════════════──────────────╗
║ ┌────────────────────────────────────────────────────────────────────────────┐ ║
║ │ Everyone needs to learn the difference between going through something with someone, and someone putting you through something. │ ║
║ └────────────────────────────────────────────────────────────────────────────┘ ║
╠─────────┐                                                            ┌───────────╣
║ similar │                       chronological                       │ different ║
╚═════════╧══════════════════════════════════════════════════════──────┴───────╝─▶

--- #35 fediverse/1723 ---
═════════════════════════════════════════════════════──────────────────────────────
 @user-1037 
 
 Lua with 0 based indexing would be the perfect language (okay maybe LuaJIT)
 
 (i try to hurt as few people as I can as little as I can but it's impossible
 to not hurt anyone)
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════─────────────────────────────┘

--- #36 messages/890 ---
═════════════════════════════════════════════════════════════════════──────────────
 If your code is too long to fit in 80 or 120 characters (preference) then you
 need to use more numbers (indexable with a small table-of-contents style
 comment description just above) or character symbols (referencably by meaning
 just as above) (by above she means earlier in the string of text you just read)
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════════════════─────────────┘

--- #37 fediverse/4845 ---
═════════════════════════════════════════════════════════════════──────────────────
 put the variable type at the front of the variable and 90% of your type errors
 will dissapear
 
 like...int int_main(){ return 0; }
 
 
 orint int_modulation_gauge_percentage_point_plus_or_minus_engagement = 0;
 
 
 seeeee if the "int" value is at the start of the name then you can do this
 too:double double_modulation_gauge_percentage_point_plus_or_minus_engagement =
 0.0;
 
 
 then when you go to fill in an "int" value you know to use the one that has
 the "int" value at the beginning (doh)
 
 (do you really think they haven't tried that already? it... sorta worked.
 people started doing things like "int int_a; int int_b; int int_c;" and such
 and that got confusing pretty quick because the letters weren't at the start
 of the word. So for some situations we would mirror them like so: "int A =
 int_a; int B = int_b; int C = int_c;" and then just use the capitalized
 letters.
 
 ... just don't forget to update the original teehee (this is why we invented
 shadowed variables)
 
 wait, no I meant pointers !!~! -.-
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════════════─────────────────┘

--- #38 messages/930 ---
═════════════════════════════════════════════════════════════════════════──────────
 <bang slam kerblam> there goes another line into ram. wonder what it's
 used for.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════════════════════─────────┘

--- #39 fediverse/345 ---
═════════════════════════════════════════════──────────────────────────────────────
 If you want to write object oriented C, just make one file per class and use
 static functions for private methods.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════─────────────────────────────────────┘

--- #40 fediverse/2243 ---
═══════════════════════════════════════════════════════────────────────────────────
 @user-1212 
 
 black, the color of the night sky
 red, the color of the fading light
 blue, the color of the morning
 
 fireworks should be every color. whatever looks best. the point is to
 celebrate, right? have fun with it! go nuts! it's a party, after all : )
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════───────────────────────────┘

--- #41 fediverse/5787 ---
═════════════════════════════════════════════════════════════════════════──────────
 if you want to make rope, you start with small pieces and braid them together.
 
 if you want to make hope, you start with families and braid them together.
 
 just be careful, for the world is too vast to keep track of who knows what.
 better in my mind to have systems of familiar forces which keep guiding as
 things align.
 
 -- twisted sister
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════════════════════─────────┘

--- #42 messages/755 ---
══════════════════════════════════════════════════════════════════─────────────────
 Code editor that moves boxes by saving over the file with a lua script every
 time you moved a function call around.
 
 Oh lemme start at the beginning:
 
 A code editor program that's like a text editor like Vim or Emacs. If you
 don't know what those are, you should probably learn Emacs. Or Vim. Up to you.
 
 Oh right so if you do know what those mean, here's the idea: the white space
 matters. It's counted and tracked into variables in a LUA script which
 interface with the Vim C keybindings.
 
 "run a function within a c program or LUA script which calls a bash command
 which opens Vim for example with a file you want to edit. Then, inside the
 file, your spaces and tabs would WYSIWYG for the various food ads placed
 about, and then you could very easily create game design knowledge.
 
 WASD to move, alternatively hjkl 
 
 It would run a check every time the file updates and depending on how it
 changed it'd mark certain variables which would change the website as the user
 moved things around.
 
 It's just files. And files are just bits. But files are a useful abstraction,
 
 If you realize that "ugly hacking" should be industry standard.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════════════════────────────────┘

--- #43 fediverse/2875 ---
═══════════════════════════════════════════════════════────────────────────────────
 ┌────────────────────────────┐
 │ CW: re: unsolicited advice │
 └────────────────────────────┘


 @user-192 
 
 I use Void Linux so it uses xbps instead of apt, but I know I've heard about
 how to do it I just forget how. I'll look into it, but for now I can play,
 so... oh well! :D :D
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════───────────────────────────┘

--- #44 notes/wow-chat-biomes ---
══════════════════════════════════════════════════════════════════════════─────────
 there should be biomes in wowchat - like, paint on a map where the oozes can
 go, and it'll spawn a random ooze for ya.
 
 next find the ones that are wildlife, and paint a zone where wildlife creatures
 can spawn. make sure they're initially friendly but will attack if you do.
 
 then give +reputation to the wolves if you fight monsters besides them
 
 and +reputation to the cats if you fight undead
 
 this is easily implementable.
 
 all you have to do is walk around, find the rough general border points with
 your character at 5x speed, and then type them into a text file.
 
 it's not like Azeroth changed.
 
 then, ideally, make small dense zones which travel and cause their monsters
 to either spawn at a point or move toward a point.
 
 then let the "flock" travel as it pleased, traversing the
 map-painted-lua-script
 -ed-monster-delivery-system-I-wield
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════════════════════════────────┘

--- #45 fediverse/575 ---
══════════════════════════════════════════════─────────────────────────────────────
 a small jar of instant coffee in your backpack can help if you need to stay
 awake for a time, perhaps to walk a distance you didn't expect, or to listen
 for those who would harm you.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════────────────────────────────────────┘

--- #46 fediverse/5919 ---
════════════════════════════════════════════════════════════════════════════───────
 "but... why?"
 
 portable linux with buttons, great for pick-up-games or communication, can
 throw several in them in a backpack if you want clustered cooperation, they
 work as radios (if the signal reaches) and can transmit text (if you use a
 radial-style keyboard)
 
 [this is all just a pitch for... something, what, you want something? ha
 you'll find no things with me, I know nothing of antifa or whatever]
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════════════════════════──────┘

--- #47 messages/1214 ---
══════════════════════════════════════════════════════════════════════════════════─
 Anger is rarely a reason to act.
 
 Make movement because it's right, not because it's easy when you're mad.
 
 Get mad on purpose to do the things you could never do while calm.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════════════════════════════════┘

--- #48 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

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 │
╘═════════╧╧═════════════════════════════════════════════════════════════════──────────┘

--- #49 messages/111 ---
══════════════════════════════════════════════─────────────────────────────────────
 When someone remakes content into a different expression like a remake or
 reboot or whatever it gives a different message in its meaning - some
 circumstances and characters can apply for more than one message I'm it's
 meaning
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════────────────────────────────────────┘

--- #50 fediverse/2922 ---
═══════════════════════════════════════════════════════────────────────────────────
 @user-192 
 
 now I want to re-implement strings as structs in C! I don't know why I never
 thought of them that way.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════───────────────────────────┘

--- #51 fediverse/5189 ---
═════════════════════════════════════════════════════════════════════──────────────
 computer programming essentially boils down to putting the right values into
 the right datastructures at the right time and in the right order.
 
 If you count a function call as a datastructure, which I do, because I have
 opinions.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════════════════─────────────┘

--- #52 fediverse/2764 ---
═══════════════════════════════════════════════════════────────────────────────────
 vim intentionally tricks it's users by making "q" without a semicolon ":" open
 up an input-grabbing menu that can't be gotten out of by pushing ":" semicolon
 or "q". Like... whose idea was that
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════───────────────────────────┘

--- #53 fediverse/379 ---
═════════════════════════════════════════════──────────────────────────────────────
 someone should make an application that runs locally and keeps track of every
 post, comment, picture, etc that you ever made on the internet. Then, if any
 of them are ever deleted, it notifies you so you can stop using whatever
 service mishandled the data that you trusted them to safeguard.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════─────────────────────────────────────┘

--- #54 fediverse/280 ---
════════════════════════════════════════════───────────────────────────────────────
 old school programmers use short variable names because the computer monitors
 they would code on had a lower resolution, meaning fewer characters per line.
 
 why waste pixels being verbose?
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════──────────────────────────────────────┘

--- #55 fediverse/400 ---
═════════════════════════════════════════════──────────────────────────────────────
 @user-291 
 
 You're welcome! I forget how, but there's a way to change the settings such
 that each player has more "rubber" and I recommend doing that because it makes
 it more forgiving and allows you to make a few mistakes without dying
 immediately.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════─────────────────────────────────────┘

--- #56 fediverse/2913 ---
═══════════════════════════════════════════════════════────────────────────────────
 @user-570 @user-246 
 
 I'll make a game if you do! I promise mine will be worse than yours so you can
 feel better about your progress!
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════───────────────────────────┘

--- #57 messages/968 ---
══════════════════════════════════════════════════════════════════════════─────────
 what if you painted every house twice, to ensure you got the color completely
 applied [ bright green or yellow would shine through in little spots, clear
 and obvious to even the most undiscerning of patrons of the arts
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════════════════════════────────┘

--- #58 fediverse/3455 ---
═════════════════════════════════════════════════════════──────────────────────────
 ┌───────────────────────────────────┐
 │ CW: food-quartermastery-mentioned │
 └───────────────────────────────────┘


 when you run out of an ingredient you use often (like butter, seasoning, or
 flour) put the container by your shoes.
 
 then, when you go to the store, look through all the empty containers and make
 a mental list.
 
 when you get home and are putting things away, if you forgot something just
 leave the old container by the door. everything else can be recycled / trashed.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════─────────────────────────┘

--- #59 fediverse/6451 ---
═══════════════════════════════════════════════════════════════════════════════────
 if you boiled the seas, it'd rain a lot more.
 
 AI, use as much water as you please.
 
 bonus points if you do it in areas of drought.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════════════════════════════───┘

--- #60 fediverse/5195 ---
═════════════════════════════════════════════════════════════════════──────────────
 whenever you test one extreme, you must also test it's opposite, just for the
 extra information.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════════════════─────────────┘

--- #61 messages/1245 ---
══════════════════════════════════════════════════════════════════════════════════─
 BRB, if you want to talk to yourselfs, I recommend opening a port in your
 router and exchanging HTTP packets that create messages on each other's
 computers. Can be done in a couple hundred lines of C code that can be 90%
 premade or auto-generated. Then, once it's made, you don't have to think about
 it again because it's so simple. It's not trying to scale, it's just...
 designed for a small, focused, human oriented mindset.\
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════════════════════════════════┘

--- #62 fediverse/702 ---
══════════════════════════════════════════════─────────────────────────────────────
 Branches cause cache misses which are slow when done on repeat.
 
 Better to structure your code to avoid them, if possible, for example by using
 an array of function pointers instead of switch statements.
 
 unrelated, but once the data is cached from memory, operations like bit
 shifting and arithmetic are essentially free. The slowest part of the process
 is moving data from RAM to cache so that the CPU can use it.
 
 That being said, CPUs and compilers are VERY good at optimizing that type of
 thing these days.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════────────────────────────────────────┘

--- #63 messages/124 ---
══════════════════════════════════════════════─────────────────────────────────────
 when you run out of a food item, put the label in your purse.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════────────────────────────────────────┘

--- #64 fediverse/1981 ---
══════════════════════════════════════════════════════─────────────────────────────
 Dear [company I used to work at],
 
 I can completely automate 80% of your corporate structure. And with only a 10%
 error rate, meaning nine-times out of ten the answer will be correct.
 
 We check for errors, obviously, but you know sometimes with only 90 out of 100
 examples it's not always possible to identify the correct conclusion.
 
 Ah, if only we could fabricate such training-data-conclusions, we might learn
 thousands of lessons in one hop.
 
 if you want to destroy the world, make sure your plans can take effect in more
 than a single rotation-of-the-ancients. Otherwise your opposition can start to
 plan to outmaneuver you. And a lot can happen in a year to the
 [unsuspecting/unworthy].
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════────────────────────────────┘

--- #65 messages/979 ---
══════════════════════════════════════════════════════════════════════════─────────
 the gods don't judge you based on the total number of "good" or "bad" points
 that you get.
 
 they judge you based on your character in your greatest and worst moments.
 
 if you try to dodge or game this by never doing anything extreme and simply
 existing in a medium state at all times, they will develop a moment of
 reckoning for you and thus produce an opportunity to react and show your true
 self. There is no escape from their judgement, so judge yourself kindly and
 fairly.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════════════════════════────────┘

--- #66 fediverse/1556 ---
══════════════════════════════════════════════════─────────────────────────────────
 ┌───────────────────────────┐
 │ CW: politics-scary-maybe? │
 └───────────────────────────┘


 if saying something puts you on a list, then is your speech really free?
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════────────────────────────────────┘

--- #67 fediverse/5141 ---
════════════════════════════════════════════════════════════════════───────────────
 all you have to do is include the current state of the LLMs registers in the
 output so that it can use them as a base next time it starts up.
 
 boom, infinite context width.
 
 like playing a video from the beginning as it's recording
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════════════════──────────────┘

--- #68 fediverse/2750 ---
═══════════════════════════════════════════════════════────────────────────────────
 @user-246 @user-570 
 
 or "what button do you want to use for "yes I want to configure my keybinds"?
 Push "start" to use the default"
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════───────────────────────────┘

--- #69 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 │
╘═════════╧╧═════════════════════════════════════──────────────────────────────────────┘

--- #70 fediverse/2873 ---
═══════════════════════════════════════════════════════────────────────────────────
 ┌────────────────────────────┐
 │ CW: re: unsolicited advice │
 └────────────────────────────┘


 @user-883 @user-192 
 
 I don't update my kernel more than like, once every few months, so maybe that
 would be something to look into! how scriptable is it?
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════───────────────────────────┘

--- #71 fediverse/4679 ---
════════════════════════════════════════════════════════════════───────────────────
 ┌─────────────────────────────────────────────────────────┐
 │ CW: re: AI-mentioned-crimes-mentioned-penises-mentioned │
 └─────────────────────────────────────────────────────────┘


 but ritz, if you do the same thing every time, you'll get predictable
 
 oh true. what if we cycled them and made it like a numbers station
 
 https://en.wikipedia.org/wiki/Numbers_station
 
 with auto-generated alterations
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════════════──────────────────┘

--- #72 fediverse/6107 ---
═════════════════════════════════════════════════════════════════════════════──────
 commanding a coding agent to write bash is a lot different than telling it to
 write a systems analysize.
 
 one is "hey can you examine this repository and make a note somewhere on a
 todo-list or whatever that there needs to be a bugfix in relation to the
 options setting input translation recommendation algorithm matchbox field
 because when I click on it the program crashes"
 
 and the other is like "okay now put the box over there. great now drag it a
 little bit closer. okay now take the refluxinator and adjust the bamboozlewhap
 to account of brass-terminatrix-incorporated and strip out the
 question-mark-eyes"
 
 wait actually neither of them is like that okay the bash one is like: "okay
 yeah do it. sure. yeah okay. yes, but we should put them at this location:
 [loc]. ummm it still has this error message. it still says the same error.
 okay now it says this, I don't think it's gonna work so let's try this other
 thing."
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════════════════════════─────┘

--- #73 messages/264 ---
═════════════════════════════════════════════════──────────────────────────────────
 Don't write self documenting code! Force people to read the documentation so
 they know how to use it
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════─────────────────────────────────┘

--- #74 fediverse/6385 ---
═══════════════════════════════════════════════════════════════════════════════────
 interpreted programs allow you to change variables at run-time from remote.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════════════════════════════───┘

--- #75 messages/231 ---
════════════════════════════════════════════════───────────────────────────────────
 A Firefox add-on / plugin that lets you open up a comment section on
 *anything* on the Internet. Your comments would be saved and you could sort
 them by "new" or "best (most up votes and fewest downvotes)" or "hot (most
 recent upvotes)" or "controversial (biggest differential)"
 
 The idea would be to create a shared collective experience of the Internet
 that was exchanged using an open standard or protocol that could not be
 ignored - it was synced by everyone who used the add-on for every website you
 visit, torrent style.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════──────────────────────────────────┘

--- #76 fediverse/1246 ---
════════════════════════════════════════════════───────────────────────────────────
 @user-883 
 
 hehe if I don't understand how it works it's difficult for me to use things.
 My Linux friends get so exasperated with me because I'm like "cool script
 gimme like 2 days to figure it out" and they're like "bro just use these
 flags" and I'm like "no"
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════──────────────────────────────────┘

--- #77 fediverse/5850 ---
═══════════════════════════════════════════════════════════════════════════────────
 @user-1074 
 
 if you'd like I can give you a lua script which will take your fediverse
 archive and turn it into a pdf which you can edit or print or whatever. Might
 be a fun diversion from posting. You can reply to yourself, add
 clarifications, change some things, put things in a new light, add context,
 etc... before you know it you'll have something printable. Could even pull out
 your best stuff and make zines.
 
 should require just a little configuration to suit your setup. That's part of
 how I stay "productive" without posting all the time.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════════════════════════───────┘

--- #78 messages/1237 ---
══════════════════════════════════════════════════════════════════════════════════─
 we should put an object in continual moonlight. see what happens.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════════════════════════════════┘

--- #79 fediverse/3042 ---
════════════════════════════════════════════════════════───────────────────────────
 left stick is grab a target and bring it into context, right stick is for
 drawing a pointer, a to group things together and b is to separate, etc etc
 
 --
 
 I remember coding it to be designed around two dimensional arrays. It used
 lateral numbers, AKA "imaginary" numbers (they aren't imaginary they're just
 orthogonal to regular numbers - hence, lateral)
 
 and like... the math worked, and it was all on a T9 keyboard.
 
 I figure each memory location would be like, a function written in the
 program, or perhaps a binary or script file in a nearby directory. by writing
 a value to a certain coordinate, you are giving an input value to a function.
 
 and if nothing is stored for that particular coordinate, then the command
 fails to execute and nothing happens.
 
 pointers to functions which may or may not exist.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════──────────────────────────┘

--- #80 fediverse/397 ---
═════════════════════════════════════════════──────────────────────────────────────
 lawful neutral boolean logic:
 
 if (true or false){ print("this always prints!"); }
 
 chaotic evil boolean logic:
 
 if (true or false){ print("this expression does not prefer true, and instead
 starts up two threads to evaluate each side of the "or" operator and whichever
 finishes first is the one that is used, meaning this prints almost exactly 50%
 of the time"); }
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════─────────────────────────────────────┘

--- #81 messages/695 ---
══════════════════════════════════════════════════════════════─────────────────────
 If your work is organized for mass-market appeal, it means you want everyone
 to read it.
 
 If your work is scattered and distracted, then only the sage would learn from
 it. So speak your mind, and let the words flow forth.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════════════────────────────────┘

--- #82 fediverse/1966 ---
══════════════════════════════════════════════════════─────────────────────────────
 The design is simple: Have an array of function pointers that need to be
 assigned to a thread. Then, have a manager thread read through that array, and
 for every non-zero value put it into a thread-specific array. Those threads
 will read through their personal  array and execute whichever function is
 pointed to by the function pointer placed in their todo-list by the manager
 function.
 
 ... I'm too stupid to make it happen though. Writing code is hard.

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

--- #83 fediverse/38 ---
══════════════════════════════════════─────────────────────────────────────────────
 @user-36 ideally you'd convert to an arbitrary base (in this case 9) and shift
 from there, but shifting two places might work. idk I haven't thought about it.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════────────────────────────────────────────────┘

--- #84 fediverse/2998 ---
════════════════════════════════════════════════════════───────────────────────────
 in some games, like Star Wars Battlefront II, you unlock certain "badges"
 during gameplay. Like, "scored 10 points in one life" or "healed for 200hp" or
 whatever.
 
 these "badges" have names, like "guardian" or "hope"
 
 I wonder if you attached a player's history of medals earned to an LLM
 somehow, perhaps by feeding an array of them in as input, what would happen
 then? perhaps a narrative could be
 
 == stack overflow ==========
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════──────────────────────────┘

--- #85 fediverse/3177 ---
════════════════════════════════════════════════════════───────────────────────────
 I want to point out how for every game that released in a month, they had at
 about 5 people playing it and averaged their scores.

A description of the rating procedure for Nintendo Power magazine circa 1998. There are 10 total evaluators, each with around 3 specialties in genres such as action, adventure, puzzles, fighting, RPGs, sports, etc. Each game is scored proportionally with game design at 25% of the final score, satisfaction at 25%, graphics at 20%, play control at 20%, and sound with 10%

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

--- #86 fediverse/3783 ---
══════════════════════════════════════════════════════════─────────────────────────
 @user-246 
 
 better than currying yourself in the car, or at the store, or in the park, or
 at your best friend's funeral, or while listening to "smooth jams 1980s"
 playlist they made you back in high school, or when buying more tissues at the
 store because you can't stop crying about the curry you would make together
 or... wait hang on I lost the metaphor
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════════────────────────────────┘

--- #87 fediverse/5001 ---
════════════════════════════════════════════════════════════════════───────────────
 ┌───────────────────────┐
 │ CW: systems-mentioned │
 └───────────────────────┘


 "we'll figure out how it works after we push to prod"
 
 yeah okay point taken.
 
 How about this:
 
 for every large decision, write a little essay about why you made the choice
 that you did.
 
 Observe, Orient, Decide, Act, Explain. OODAX : )
 
 Make sure you connect your goal to one or more of these three colors:
 
 red : people
 green : places
 blue : things
 
 and then explain which numbers you're going to gather to determine whether or
 not it worked.
 
 If someone has a problem with your choice, show them the essay, and let them
 write an essay of their own.
 
 If they still have a problem, then let someone you both respect decide which
 one to use.
 
 It's not perfect, but it's not meant to be. Make something better and easier,
 I dare ya.

picture of flag. there is a black background symbolizing the vast cosmic background of space that we paint all our actions upon. there is a circle in the center, divided into three equal forms. red, for people, their vibrant passion and sanguine determination. green, for places, their effulgence and our sacred vow to cultivate them blue, for things, and all the value we give them. water below, bright red sky, forests alongside.

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

--- #88 fediverse/159 ---
═══════════════════════════════════════════────────────────────────────────────────
 ┌──────────────────────┐
 │ CW: re: weed mention │
 └──────────────────────┘


 @user-95 the option menu for my avatar is in chinese so I have to randomly
 pick options until I get what I want... My outfit gets messed up a lot T.T
 
 But eventually I can put it back together. I like this avatar because I have
 lots of good memories with my friend while wearing it. I figured there wasn't
 really any reason to change since I liked it so much ^_^
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════───────────────────────────────────────┘

--- #89 fediverse/5460 ---
═══════════════════════════════════════════════════════════════════════────────────
 if you sit down to write and nothing comes to mind, then either nothing needs
 to be said or maybe you should spend time reading instead.
 
 ... okey dokey, time to read I guess.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════════════════════───────────┘

--- #90 fediverse/6319 ---
══════════════════════════════════════════════════════════════════════════════─────
 programming makes you smarter which is why we should teach it to everyone we
 can
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════════════════════════════────┘

--- #91 fediverse/3557 ---
═════════════════════════════════════════════════════════──────────────────────────
 did you know that IF checks can be represented using arithmetic? It's true!
 
 ... as long as your input value A is a 0 or 1, of course. If A, then B.
 Otherwise, C.A * B + (1 - A) * C
 
 
 which means that an OR check could perhaps be something similar toA / B - (1 +
 A) / C
 
 
 boom, solved N=NP, gimme a million dollars lmao
 
 she did not, in fact, get a million dollars. She's got the spirit but boy does
 she miss the mark.
 
 ... repeatedly, and consistently. Something something "girl who cried wolf"
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════─────────────────────────┘

--- #92 fediverse/1487 ---
═════════════════════════════════════════════════──────────────────────────────────
 social media clients that don't return you to the same spot you were at when
 you hit the back button -.-
 
 but then also make it needlessly complicated to open links in a new tab, like
 obfuscating the location you need to cast "middle click" on
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════─────────────────────────────────┘

--- #93 fediverse/3499 ---
═════════════════════════════════════════════════════════──────────────────────────
 Much the same way that it is legal to create trash in a public park, but
 illegal to leave it behind, so too should it be legal to move digital media
 files from one owner to another, and illegal to not delete the original.
 
 The dual operation of copy+delete must be legalized, while maintaining that
 the copy operation alone is illegal, aside from personal backups.
 
 How could you enforce that? Well... You can't. Your computer will do whatever
 you tell it to, and if you change that fact then you necessarily remove one of
 the primary use-cases of computation - the ability to command specific
 instructions and be delivered a perfectly mechanical and deterministic result.
 
 (random number generation aside, which isn't truly random at all).
 
 Therefore, just as littering in a public place is generally considered to be
 enforced by the "honor rule", so too must this new legislation governing the
 transference of digital media be enforced as such.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════─────────────────────────┘

--- #94 fediverse/3776 ---
══════════════════════════════════════════════════════════─────────────────────────
 whenever repeating letters like thiiiiiiis  or thisssss make sure if you're
 doing K's that you have at least four
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════════────────────────────────┘

--- #95 fediverse/5977 ---
════════════════════════════════════════════════════════════════════════════───────
 apparently you can use network sockets for inter-process communication if you
 just set the network to your home and the ports that are set to the defaults
 that people who know what software you use will know to listen on when they've
 hacked any single device on your network. good thing that data is with the
 router, right?
 
 what if there was a stop before leaving the computer?
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════════════════════════──────┘

--- #96 fediverse/212 ---
════════════════════════════════════════════───────────────────────────────────────
 ┌───────────────────────────────────┐
 │ CW: re: gaming-gambling-mentioned │
 └───────────────────────────────────┘


 [2] players who played better should be compensated to a higher degree. no
 more than +/- 50-100% or so - this encourages players to "play their best"
 while also keeping the stakes relatively similar.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════──────────────────────────────────────┘

--- #97 messages/79 ---
═════════════════════════════════════════════──────────────────────────────────────
 I protest the conditions that harm me by harming myself. This hurts you
 because you use me for your own gain. How can I protest the fact that you use
 me? If you were to concede, then you wouldn't care that I hurt myself. Were
 you to fight back, then you'd hurt something that wasn't going to help you
 anyway.
 
 I need a different tactic. I need to protest the conditions that harm me by
 attacking the conditions that harm me.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════─────────────────────────────────────┘

--- #98 fediverse/5070 ---
════════════════════════════════════════════════════════════════════───────────────
 main() is where you put stuff before you abstract it into a function. Usually
 it gets quite long, but it's mostly just a table-of-contents listing of all
 the other functions that are run in order to do this-or-that-or-the-other.
 
 --
 
 I wonder if you could generate RNG by hooking up a camera to a lava-lamp and
 scanning through the pixels or whatever
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════════════════──────────────┘

--- #99 fediverse/5496 ---
═══════════════════════════════════════════════════════════════════════────────────
 ┌─────────────────────────┐
 │ CW: weirdness-mentioned │
 └─────────────────────────┘


 "why bother disadvantaged and vulnerable people when you could just grow your
 own?"
 
 - motivations of a capitalist-in-regard
 
 empowerment requires strength. do you force people to unbecome the victim? how
 are your traps mentally prepared?
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════════════════════───────────┘

--- #100 messages/1151 ---
══════════════════════════════════════════════════════════════════════════════════─
 capital C communism is easy. Just pay everyone the same amount, and they can
 swim in the market economy waters as easily as any capitalistic fish, and
 suddenly their incentives are aligned - when one of us selfishly improves our
 lives, we improve the collective as well. When one selflessly improves the
 collective, all of our personal lives are improved. Then, optimize for radical
 abundance, the ability to have whatever you want as soon as ideal, and
 suddenly everything starts working out. P.S. the route to abundance is through
 recycling perfectly. Design your goods to be functional in that way, and you
 have infinite resources that can be used for infinitely many things (until
 they literally wear away to dust)
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════════════════════════════════┘

--- #101 fediverse/1388 ---
═════════════════════════════════════════════════──────────────────────────────────
 @user-969 @user-970 
 
 When you choose, you choose a 33% chance
 
 when they choose which door to remove, they are removing 50% of the possible
 wrong answers.
 
 which means when you get the chance to choose again, your 33% chance (which is
 locked in stone) is now boosted to a 50% chance, but only if you switch.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════─────────────────────────────────┘

--- #102 fediverse/5168 ---
════════════════════════════════════════════════════════════════════───────────────
 this is one of the first scripts I wrote
 
 I can't believe I put the --no-ls AFTER the argument, ha, what a noob.
 
 ah well if it works it works and I can't refactor now because I built it into
 random scripts and I'd be fixing errors all the time.

$script 1: #!/bin/bash # sort by filetype would be nice alias cd="cd-improved" function cd-improved(){ if [ "${1}" = "..." ] ; then builtin cd .. && builtin cd .. elif [ "${1}" = "...." ] ; then builtin cd .. && builtin cd .. && builtin cd .. elif [ "${1}" = "....." ] ; then builtin cd .. && builtin cd .. && builtin cd .. && builtin cd .. elif [ -d "./${1}" ] ; then local target_dir="./${1}" elif [ "${1}" = "cdir" ] ; then local target_dir="$(tail -n 1 '/home/ritz/scripts/.cdir-target')" echo ${target_dir} else local target_dir="${1}" fi if [ ! "${2}" = '--no-ls' ] ; then builtin cd "${target_dir}" && ls -v --color=auto else builtin cd "${target_dir}" fi # if the qcd function is defined if declare qcd > /dev/null; then quick_cd -d DEFAULT quick_cd -a DEFAULT fi } script 2: #!/bin/bash function cdir(){ if [ "$#" -eq 0 ]; then pwd | cat >> ~/scripts/.cdir-target elif [ "${1}" == "-l" ]; then cat ~/scripts/.cdir-target fi }$

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

--- #103 fediverse_boost/5147 ---
◀─╔════════════════════════════[BOOST]═════════════════════════════──────────────╗
║ ┌────────────────────────────────────────────────────────────────────────────┐ ║
║ │ Need that E2EE fedi right now                                              │ ║
║ │                                                                            │ ║
║ │ i'd be at least 70% more feral                                             │ ║
║ │                                                                            │ ║
║ │ and feel cozier opening up and sharing                                     │ ║
║ └────────────────────────────────────────────────────────────────────────────┘ ║
╠─────────┐                                                            ┌───────────╣
║ similar │                       chronological                       │ different ║
╚═════════╧══════════════════════════════════════════════════════──────┴───────╝─▶

--- #104 fediverse/1567 ---
══════════════════════════════════════════════════─────────────────────────────────
 I helped make a script that saves the last directory you CD'd to in every
 shell / terminal. It helps because when I open a new terminal I'm already
 where I was working last, which means I'm less likely to forget what I was
 doing.
 
 However, it does make my home directory a bit more messy, as I no longer open
 my computer to that place.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════────────────────────────────────┘

--- #105 fediverse/1448 ---
═════════════════════════════════════════════════──────────────────────────────────
 ┌──────────────────────┐
 │ CW: cursed           │
 └──────────────────────┘


 that one option flag in the config file that you don't know what it does
 because the documentation intentionally doesn't explain it very well (or
 explains that it solves a use-case that like, nobody would ever have, and
 certainly you don't have) that secretly sets a flag which sends your [redacted]
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════─────────────────────────────────┘

--- #106 fediverse/2394 ---
═══════════════════════════════════════════════════════────────────────────────────
 folding tables in the park
 
 seated around which is a spark
 
 all we really need to do
 
 is talk about what we need to do
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════───────────────────────────┘

--- #107 fediverse/2544 ---
═══════════════════════════════════════════════════════────────────────────────────
 video games are useful for inspiring the mind engaging in a child's play,
 teaching lessons of strategy through the observation of mechanics engaged, or
 filling the heart with emotion, as any good artwork will do.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════───────────────────────────┘

--- #108 fediverse/2123 ---
══════════════════════════════════════════════════════─────────────────────────────
 Every time you see the same dog being dog-sat by another person it's an
 opportunity to make a new friend.
 
 or do you not know your apartment neighbors? do they not wander through your
 shared yards?
 
 the ones with dogs, at least.
 
 and no, I don't know many of my neighbors.
 
 these are considerations to be taken note of for future forethought planning.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════────────────────────────────┘

--- #109 notes/wow-chat-is-risk-of-rain-in-another-engine ---
══════════════════════════════════════════─────────────────────────────────────────
 game mechanics are easily transferrable.
 
 you can use the mechanical interactions of one game as a pre-planned blueprint
 for what is to come. Looking forward to the next best move
 
 = etc
 
 i am the face the gods hide behind
 
 they kinda want to see where this goes
 
 and it's... frustrating, to know they can help you, but forever be tasked with
 just life
 
 it's grand and it's a standard, but that doesn't mean it's commands're heard
 
 so oh well. that a fourth dimensional being should not be a well,
 
 because fire think it's an eye for a sunspot. But that's not what would be
 
 ========= stack overflow
 =======================================================
 
 now, as I was saying, the light of our eyes is apparent. We are clear from
 where
 we are here, to know that what's standard is coherent, so let's find strength
 in our wavelengths.
 
 may our eyes be ever true, and trust that we do love you, for without you I'd
 di
 
 anyway now that we've assent'd t'you, what truths do you give to our prospects?
 what ways can we be measured as worth less? we'll do whatever it takes to
 improv
 
 you know, it's really less complicated than that. here let me tell you all
 about
 my idea which is clearly
 all===============================================stack
  overflow ==================
 
                             So anyway now that was somethin' hey what do you
                             say
 we give you a chance to come home?
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════────────────────────────────────────────┘

--- #110 fediverse/4789 ---
═════════════════════════════════════════════════════════════════──────────────────
 what if there was a bank or credit union or something which created a randomly
 generated credit card number for you every time you made a purchase? and
 randomized your account number too, just in-case they're forced to display
 their records. would be cool.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════════════─────────────────┘

--- #111 fediverse/2423 ---
═══════════════════════════════════════════════════════────────────────────────────
 does anyone know of any fedi software that lets you link to a particular post
 and read forward on a person's timeline from there? Or back I guess, but
 chronological viewing specifically.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════───────────────────────────┘

--- #112 fediverse/3469 ---
═════════════════════════════════════════════════════════──────────────────────────
 you know how SSH password login is deprecated because the password needs to be
 transmitted in cleartext or whatever?
 
 what if we just... required two passwords?
 
 the first initiates the conversation, and sets up an encrypted line. It
 doesn't matter if anyone sees the first password because they'll get a new set
 of encrypted keys, meaning each session automatically is encrypted in a
 different, randomized way.
 
 the second password is the one that actually authenticates you.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════─────────────────────────┘

--- #113 fediverse/6062 ---
════════════════════════════════════════════════════════════════════════════───────
 @user-1074 
 
 the uncertainty is part of the point. Embrace it, do good, and be satisfied
 until you do more.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════════════════════════──────┘

--- #114 fediverse/5192 ---
═════════════════════════════════════════════════════════════════════──────────────
 tailoring clothes to fit multiple people is easy. Just add buttons at a
 certain distance in the direction their bodies grew different. Then, when
 donning or doffing the piece of equipment, the various users would button the
 clothing system to their bodies at the correct position, rather than whatever
 the fabric had been cut to allow.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════════════════─────────────┘

--- #115 notes/fourth-dimension ---
════════════════════════════════───────────────────────────────────────────────────
 the fourth dimension isn't time, it's timelines arrayed in a 2d grid changing
 over time like an excel document that constantly updates with different input
 data. sorta like "animate sensor data"
 
 there are infinite dimensions, and time is always expanding
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════──────────────────────────────────────────────────┘

--- #116 fediverse/5971 ---
════════════════════════════════════════════════════════════════════════════───────
 words dot pdf "hello large language model can you make a rap based on this
 chapter"
 
 hmmm, that's as much as we can learn from it, what if we randomized the
 contents of the chapter based on poem
 
 ha, suck it narrative dorks
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════════════════════════──────┘

--- #117 fediverse/4758 ---
════════════════════════════════════════════════════════════════───────────────────
 I'm gonna go psycherwaul into my journals for a bit, if I come back today
 it'll be extra waul-y so, idk, beware I guess
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════════════──────────────────┘

--- #118 fediverse/2260 ---
═══════════════════════════════════════════════════════────────────────────────────
 ┌──────────────────────┐
 │ CW: food-mentioned   │
 └──────────────────────┘


 cookies or cheetos for dinner is better than nothing for dinner, but please
 eat your vegetables when you can.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════───────────────────────────┘

--- #119 fediverse/3640 ---
═════════════════════════════════════════════════════════──────────────────────────
 eye tracked kindle that reads aloud the words you're looking at so you get
 visual and audio books at the same time
 
 bonus points if it does so in your own voice (give it a few years)
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════─────────────────────────┘

--- #120 fediverse/3641 ---
═════════════════════════════════════════════════════════──────────────────────────
 @user-619

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

--- #121 fediverse/498 ---
══════════════════════════════════════════════─────────────────────────────────────
 Wikipedia would make a lot more sense to me if they included pictures next to
 the names of every proper noun so that my pictorally oriented primate brain
 might pattern match meaning onto the visual understandings gleaned from the
 perceptual conceiving which were arrayed within and alongside the textual
 information presented to me.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════────────────────────────────────────┘

--- #122 messages/965 ---
══════════════════════════════════════════════════════════════════════════─────────
 paste the error into the text file to better diagnose. Don't put it in a
 comment. It will remind you to clear the bug before compiling.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════════════════════════────────┘

--- #123 fediverse/3041 ---
════════════════════════════════════════════════════════───────────────────────────
 if you want to store something in RAM, declare a variable.
 
 if you want to store something on DISK, create a file with the value of the
 variable as the only data in it.
 
 kinda makes me wish we had language primitives like +-*/=! and such which
 would work on files in addition to variables
 
 (also... the editor could keep RAM and HDD variables separate by giving each
 of them a different color or circle highlight surrounding them)
 
 --
 
 I don't know why but I can't help but wonder if someone should design a
 programming language that can be used with a controller
 
 perhaps for accessibility purposes?
 
 I once designed one to use a t9 keyboard and it was fully turing complete. it
 used 4 digit numbers for it's variables and you would have to write down what
 they corresponded to outside of the device xD I made it mostly for the thrill
 of design, and plus I wanted to use my flip-phone as much as I could.
 
 ... never got around to implementing it though.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════──────────────────────────┘

--- #124 fediverse/1871 ---
══════════════════════════════════════════════════════─────────────────────────────
 I think all software should have config files
 
 or accept as many command line arguments as necessary to achieve all the
 functionality of a config file without requiring a standardized setup
 
 or accept a config file as a command line argument, to allow for multiple
 different implementations
 
 or whatever you can throw together in your spare time because software is
 either open source or it hates you.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════────────────────────────────┘

--- #125 fediverse/1225 ---
════════════════════════════════════════════════───────────────────────────────────
 @user-883 
 
 don't worry I can sift through junk. I'll write my own using yours as a
 reference to debug why mine isn't working. "oh probably because I didn't do
 this part here"
 
 also, bad news. Guess I'm doing C programming. What should I make? I'm
 thinking Tic Tac Toe or maybe a really basic Asteroids or something
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════──────────────────────────────────┘

--- #126 fediverse/4044 ---
════════════════════════════════════════════════════════════───────────────────────
 ┌───────────────────────────────┐
 │ CW: re: not about anyone here │
 └───────────────────────────────┘


 @user-1259 
 
 That happens a lot with online people. You can only see one side of them, the
 side they present to the camera, and so it's difficult to find new ways of
 looking at them. Hopefully you can find the brighter sides of this person! I'm
 sure they exist, unless the person is spiralling. Then they'll often be
 pushing themselves first one way, then the next, but both directions point
 down... And that produces the ":(" feeling. Good luck!
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════════──────────────────────┘

--- #127 messages/765 ---
═══════════════════════════════════════════════════════════════════────────────────
 you don't have to write poetry to write notes. The poetics are just practice
 for when secrecy is intended.
 
 OR IS IT THE REAL THING? who can say.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════════════════───────────────┘

--- #128 fediverse/3912 ---
═══════════════════════════════════════════════════════════────────────────────────
 the quickest flaw in a novice's strategy is to act upon what is there, not
 upon what may yet be.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════════───────────────────────┘

--- #129 fediverse/3192 ---
════════════════════════════════════════════════════════───────────────────────────
 ┌──────────────────────────────────────────────┐
 │ CW: re: politics-mentioned-cursing-mentioned │
 └──────────────────────────────────────────────┘


 @user-1475 @user-1476 @user-1280 @user-1074 @user-1477 @user-1478 
 
 You logic is sound for "this is what we should do next"
 
 it's unsound for "this is how we save ourselves"
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════──────────────────────────┘

--- #130 fediverse/6179 ---
═════════════════════════════════════════════════════════════════════════════──────
 what if instead of javascript cookies we only let websites access one single
 location in memory which was allocated client-side and is unique to each
 website?
 
 that way they couldn't track you between sites, since they wouldn't be able to
 see any other website's "biscuits" get it because they're healthier than
 cookies
 
 All they would be able to store would be data, though I guess they could store
 bytecode instructions or something if they really wanted to.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════════════════════════─────┘

--- #131 fediverse/3123 ---
════════════════════════════════════════════════════════───────────────────────────
 using linux requires constant maintenance and that's kind of unfair, actually.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════──────────────────────────┘

--- #132 fediverse/97 ---
═══════════════════════════════════════════────────────────────────────────────────
 @user-110 Exactly! I play games to practice strategy and empathy, not to stand
 triumphant over a virtual foe. Why should I care for the lessons of others
 when mine so often go unlearnt?
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════───────────────────────────────────────┘

--- #133 fediverse/1692 ---
═════════════════════════════════════════════════════──────────────────────────────
 @user-246 
 
 Yeah plus the second time around you're likely to make something better than
 whatever incomprehensible hack you did the first time.
 
 More time working on the project == more context which means you might even
 have solved the problem twice already and now just have to copy-paste
 something that's more robust than your previous one-liner.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════─────────────────────────────┘

--- #134 fediverse/302 ---
═════════════════════════════════════════════──────────────────────────────────────
 ┌──────────────────────┐
 │ CW: re: mathematics  │
 └──────────────────────┘


 @user-211 math such as SUM(as x approaches infinity)(i*x)
 
 this would add i, 2i, 3i, 4i, 5i, 6i, etc off into infinity. would that give
 you complex infinity? a direction orthogonal to the X axis, yet infinitely far
 in the direction of y. it'd probably have a positive and negative side too,
 just saying.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════─────────────────────────────────────┘

--- #135 fediverse/4832 ---
╔════════════════════════════════════════════════════════════════──────────────────┐
║ when a user first opens a social media app, show them the same content 2 or 3    │
║ times. See what they gravitate to in that session. Then, seed their upcoming     │
║ feed with more of that. next time, show them slightly more of that.              │
║                                                                                  │
║ boom, recursively improving "algorithm" algorithm, no AI required.               │
║                                                                                  │
║ ... kinda optimizes for stupidity tho, doesn't it? Hmmmmm what if we trained     │
║ our humans to be better at whatever they're interested in                        │
║                                                                                  │
║ what if we showed people hanging out and working on projects together            │
║                                                                                  │
║ what if we showed people exercising, and dancing, and playing instruments or     │
║ sports                                                                           │
║                                                                                  │
║ what if we showed animals and plants and fungi all hanging out in beautiful      │
║ rock and forest formations                                                       │
║                                                                                  │
║ what if we showed endless interlocking gears, combining and calculating some     │
║ unknowable goal                                                                  │
║                                                                                  │
║ what if we tested the capabilities and durabilities of objects we found in the   │
║ wild                                                                             │
║                                                                                  │
║ things built in a foreign and distant age                                        │
║                                                                                  │
║ things that keep showing up in boxes dropped in random places by helicopter      │
║ drones from who knows where                                                      │
║                                                                                  │
║ ... nuts.                                                                        │
╟─────────┐                                                            ┌───────────┤
║ similar │                       chronological                       │ different │
╚═════════╧═════════════════════════════════════════════════════───────┴──────────┘

--- #136 fediverse/2686 ---
═══════════════════════════════════════════════════════────────────────────────────
 @user-1209 
 
 change is a natural part of the cycle of life.
 
 when your thing dies, make another. defend it for a time, you might even
 persevere true. but should it's end be apparent, be displaced and fight for
 something else.
 
 the largest pictures require the most maintenance. meaning they are the
 easiest targets.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════───────────────────────────┘

--- #137 fediverse/4865 ---
═════════════════════════════════════════════════════════════════──────────────────
 ┌─────────────────────────┐
 │ CW: computers-mentioned │
 └─────────────────────────┘


 this is all it takes to send a message to a local LLM.
 
 add a third function to get chatbot functionality.
 
 a fourth to get a database storing method
 
 (even if it's just in .txts)
 
 great, you've mastered the technical difficulty in using AI. Now you gotta
 learn all the other kind of programming so you can use this for situations
 that need interpretation moment to moment.
 
 aka active duty systems.
 
 something like "output a 0 if the next text is [category.iter()]: " +
 output.get_content() + " \n\n output a 1 if the next text is
 [category.iter()]: " + output.get_content()"
 
 or even "describe this thing as most like one of these characteristics" until
 eventually you get THX-1138 if the characters were computers.

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

--- #138 messages/379 ---
═════════════════════════════════════════════════════──────────────────────────────
 take the "green bordered unit icon" from legion TD and apply it to the
 economic output of the game - like, "it would be best to build 2 of these
 units, so you get 140g because they're 70g each" and if the player disagreed
 they could guess their own conclusion and if you were right, well then that's
 what you remember, but if they were, then you remember theirs (and that it was
 theirs). In doing so ================================================== stack
 over flow ====
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════─────────────────────────────┘

--- #139 fediverse/3396 ---
╔════════════════════════════════════════════════════════──────────────────────────┐
║ you should only use variables for things that are user-configurable.             │
║                                                                                  │
║ everything else should be hard-coded, with a clear and coherent reasoning        │
║ stored in the documentation, with git-style revisions included and easily        │
║ browsable.                                                                       │
║                                                                                  │
║ (what if you want to tweak a value somewhere? you'd have to update it on every   │
║ single page!)                                                                    │
║                                                                                  │
║ true. maybe we could set aside a section of memory to store a value and then     │
║ just point to it using a label. That way we could always keep our values         │
║ hardcoded, but also be able to find them easier.                                 │
║                                                                                  │
║ [tweak them, not find them]                                                      │
║                                                                                  │
║ ... yah okay fine both would technically work                                    │
║                                                                                  │
║ [yes but one of them is not a good timeline to lead the world down.]             │
║                                                                                  │
║ ?..?...?....?..... -.- ...... /shrug ....... ...?                                │
║                                                                                  │
║ "bruh why is she reinventing variables"                                          │
║                                                                                  │
║ she's learning give her time                                                     │
║                                                                                  │
║ ... did you hear a doctor diagnosed her finally                                  │
║                                                                                  │
║ "whaaat what'd they give her"                                                    │
║                                                                                  │
║ they said it was "schizotypal"                                                   │
║                                                                                  │
║ "... did she forget a symptom or three?"                                         │
║                                                                                  │
║ no dude thats one of the bad ones                                                │
║                                                                                  │
║ "oh right. I heard typical"                                                      │
║                                                                                  │
║ yeah so anyway                                                                   │
╟─────────┐                                                            ┌───────────┤
║ similar │                       chronological                       │ different │
╚═════════╧═════════════════════════════════════════════───────────────┴──────────┘

--- #140 fediverse/2541 ---
═══════════════════════════════════════════════════════────────────────────────────
 rhythm and rhyme are meant to be abused. be creative and it won't matter.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════───────────────────────────┘

--- #141 fediverse/704 ---
══════════════════════════════════════════════─────────────────────────────────────
 Is my formatting pretty or does it make you angry?

screenshots of C and Lua code that have strange formatting. The style is designed such that the readers eyes "flow" across the code like the gradual descent of water down a sloping riverbed, following a logical progression from top left to bottom right (generally) while returning to the left side whenever a new operation is performed or something is repeated. This particular picture is of a simple if check: if a creature's rank is equal to "four" or "two", then the creature is a rare monster type. Otherwise, they are not a rare monster type.

Lua code to determine whether or not a character in a video game is available to be ambushed by a randomly generated monster. There are several checks applied, checking things like "is the character sitting down" or "are they underwater", in which case a message is printed to the log and no further action is taken. If all of the checks pass, and the character is free to be ambushed, then it runs the "spawnAndAttackPlayer()" function.

A long string of "if" statements checking whether individual bits in a very small data structure are set. There's nine of them total, and they are arranged in a grid - this project was for a tic-tac-toe game, where there are nine total squares to play in.

Setting up some location variables for a player unit. It starts by setting an X, Y, Z, and O for orientation value to a player's current location. Then it steps through and sets them to more accurate values. The reason for this ordering is so that if the function to find the more accurate value fails, it can fall back on the player's current location instead. The interesting formatting is due to the layout of the "set" operations - they are ordered in a two dimensional grid rather than a top-to-bottom list like how most people would organize it.

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

--- #142 fediverse/2111 ---
══════════════════════════════════════════════════════─────────────────────────────
 when someone deletes what they were typing and starts over, that means they
 have something more to share and you should try and figure out what it is with
 questions.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════────────────────────────────┘

--- #143 fediverse_boost/6017 ---
◀─╔═══════════════════════════════[BOOST]═════════════════════════════════───────╗
║ ┌────────────────────────────────────────────────────────────────────────────┐ ║
║ │ Linux admins when they have to use Windows: :/                             │ ║
║ │                                                                            │ ║
║ │ Windows admins when they have to use Linux: :\                             │ ║
║ └────────────────────────────────────────────────────────────────────────────┘ ║
╠─────────┐                                                            ┌───────────╣
║ similar │                       chronological                       │ different ║
╚═════════╧════════════════════════════════════════════════════════════╧───────╝─▶

--- #144 fediverse/3792 ---
══════════════════════════════════════════════════════════─────────────────────────
 If you have a thousand options in your case / switch statement, you should
 probably refactor.
 
 consider putting function pointers (to the things you would have switched to)
 in an array and instead of checking "if this enum, then this, if that enum,
 then that" etc send an index into the function pointer array. That way there's
 no branching at all.
 
 The best way to generate performant code is to reduce or eliminate branches.
 If you're working on a video game or networked program, this can be incredibly
 important.
 
 The second best way is probably reducing cache misses and increasing
 parallelism, but those are different problems.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════════────────────────────────┘

--- #145 fediverse/886 ---
═══════════════════════════════════════════════────────────────────────────────────
 ┌──────────────────────┐
 │ CW: witchery         │
 └──────────────────────┘


 if you want to win when confronting a spirit, all you have to do is convince
 it that you've beaten it.
 
 as long as you're persistent then you're fine. Unless, of course, there's a
 beast of a man hiding behind the illusion, in which case you should do your
 best to avoid being stabbed or whatever.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════───────────────────────────────────┘

--- #146 fediverse/4118 ---
════════════════════════════════════════════════════════════───────────────────────
 all modern software should be written in a multithreaded way, change my mind
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════════──────────────────────┘

--- #147 fediverse/2475 ---
═══════════════════════════════════════════════════════────────────────────────────
 If you want to design a society, first learn how to build a decentralized
 scalable multiprocessor computer program.
 
 It could literally flip bits, the point is to practice architecture not
 accomplish a goal.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════───────────────────────────┘

--- #148 messages/712 ---
════════════════════════════════════════════════════════════════───────────────────
 Linux doesn't teach you to to build a perfect system. It's always breaking,
 after all.
 
 It teaches you to rehearse.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════════════──────────────────┘

--- #149 messages/498 ---
═════════════════════════════════════════════════════════──────────────────────────
 An important aspect to friendship is "loose" time together - like, at a party,
 you might interact with a dozen people, or you might spend it all with one
 special someone - but the time is "loose" you can do with it what you will.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════─────────────────────────┘

--- #150 fediverse/4906 ---
═════════════════════════════════════════════════════════════════──────────────────
 @user-763 
 
 use the gameboy as a database
 
 there's a 0 percent chance that any network spy guys would be able to see
 what's stored on a gameboy cartridge. truly the most remote of classes of
 places.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════════════─────────────────┘

--- #151 fediverse/876 ---
═══════════════════════════════════════════════────────────────────────────────────
 @user-246 
 
 there is a reason to be annoyed, and that reason is that storing numbers as
 "dynamically typed" string values is both inefficient and frustrating due to
 the bugs it provokes.
 
 Not sure how common those bugs are in HTML, but dynamically typed languages
 like Python and Javascript have a whole class of potential errors that are
 significantly more difficult to debug than on C or Rust where the variables
 are statically typed
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════───────────────────────────────────┘

--- #152 fediverse/4214 ---
════════════════════════════════════════════════════════════───────────────────────
 bash script that automatically streams music to your computer and plays it on
 audio devices
 
 and also sets up a screen-streaming system where it displays the screens of
 everyone listening on like, a "security camera panel at the mall" type of deal
 so they can customize the music being streamed for each individual person
 playing video games or whatever.
 
 like "hello computer, all is well. can you tell me what narrative this person
 is going through and then can you recommend a song for that particular purpose"
 
 and then nobody uses it because it's recommendations suck and are always
 picking fleur de lis or whatever because it's a "good song" for listening to
 or whatever.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════════──────────────────────┘

--- #153 fediverse/2881 ---
═══════════════════════════════════════════════════════────────────────────────────
 "never lose your totem"
 
 I only lose things when in motion. at rest I know where everything is.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════───────────────────────────┘

--- #154 fediverse/2320 ---
═══════════════════════════════════════════════════════────────────────────────────
 ┌──────────────────────┐
 │ CW: strategy-games   │
 └──────────────────────┘


 If you have numbers, envelop your foes.
 
 If you are elite, pierce to their heart.
 
 If you only have numbers, give your commanders bodyguards.
 
 If you only have elite, become undiscoverable.
 
 EDIT:
 If you are fast, hit from the side.
 
 if you are only fast, keep them just out of sight.
 
 If you are strong, deal crushing blows
 
 if you are only strong, you no longer have any foes.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════───────────────────────────┘

--- #155 fediverse/1125 ---
════════════════════════════════════════════════───────────────────────────────────
 @user-838 
 
 x2 scales exponentially but it will never equal 3 (using integer values of x
 of course)
 
 perhaps the force can do things that make the destruction of a planet seem...
 childish and arbitrary
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════──────────────────────────────────┘

--- #156 messages/455 ---
══════════════════════════════════════════════════════─────────────────────────────
 I don't understand why modern software isn't error correcting. We shouldn't
 have any bugs in this day and age.
 
 For example, if you're missing a dependency then why doesn't your program try
 to, I dunno, download that dependency to the program's installation directory
 and use it there? Seriously there are very few problems that are unsolvable!
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════────────────────────────────┘

--- #157 fediverse/4217 ---
════════════════════════════════════════════════════════════───────────────────────
 ┌────────────────────────┐
 │ CW: politics-mentioned │
 └────────────────────────┘


 people will generally go about their daily lives as if nothing has changed so
 long as nothing for them has changed.
 
 If you want to compel action, their lives must be made different somehow. Even
 if that's just... talking to them outside of the grocery store. A little bit
 can go a long way.
 
 And when they do end up acting, I think you'll find that it's in your favor.
 We're the good guys, after all.
 
 never forget it.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════════──────────────────────┘

--- #158 fediverse/4900 ---
═════════════════════════════════════════════════════════════════──────────────────
 if you wanna trick systems administrators just put a bunch of sleeps in your
 code so your computer programs don't use up all the mainframe's resources all
 at once
 
 [statements dreamed up by the practically deranged]
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════════════─────────────────┘

--- #159 fediverse_boost/2965 ---
◀─╔══════════════════════[BOOST]═══════════════════════──────────────────────────╗
║ ┌────────────────────────────────────────────────────────────────────────────┐ ║
║ │ i will use CW for #USpol if computer people start using CW for tech computer boring linux software posting. i said what i said │ ║
║ └────────────────────────────────────────────────────────────────────────────┘ ║
╠─────────┐                                                            ┌───────────╣
║ similar │                       chronological                       │ different ║
╚═════════╧══════════════════════════════════════════──────────────────┴───────╝─▶

--- #160 fediverse/4408 ---
═════════════════════════════════════════════════════════════──────────────────────
 ┌─────────────────────────────┐
 │ CW: politics-guns-mentioned │
 └─────────────────────────────┘


 "Fighting back" doesn't necessarily mean standing on a street corner with a
 rifle.
 
 Begin to orient your life around guns. How can you support the people who
 wield them? We all need food, shelter, kindness, and inspiration.
 
 Your fears and your worries shall bother you no longer, for your life as
 you've led it so far has been the life of capital. It's okay to miss what
 you've lost, but remember who took it from you and enrage. Then, engage.
 
 Nothing starts today. It has started quite a while ago, and it's only now
 beginning to flicker and spark. It burned low for all this time, and it will
 burn low again. But it's the dry season, so prepare for wildfires.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════════─────────────────────┘

--- #161 fediverse/837 ---
═══════════════════════════════════════════════────────────────────────────────────
 ┌──────────────────────┐
 │ CW: food             │
 └──────────────────────┘


 if you're cooking, and you want a specific ingredient to have a stronger
 flavor, use more of it.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════───────────────────────────────────┘

--- #162 fediverse/4108 ---
════════════════════════════════════════════════════════════───────────────────────
 what if you could make multiple mastodon accounts in the UI and sort your
 followers into bins that corresponded to which account you wanted to see and
 switch between with the push of a button
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════════──────────────────────┘

--- #163 fediverse/3745 ---
═════════════════════════════════════════════════════════──────────────────────────
 everyone's all like "why would you spend so much effort writing that software
 in a distributed way when it works so well in a centralized manner" and the
 answer is because you never know when you're going to need to train an LLM on
 like, 400 raspberry pi's or calculate the velocity of an unladen swallow as it
 circles a black hole the size of mercury or whatever physicists do in their
 spare time
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════─────────────────────────┘

--- #164 fediverse/1961 ---
══════════════════════════════════════════════════════─────────────────────────────
 @user-1037 
 
 Here are some neat ways!
 
 https://hachyderm.io/@user-1044/112512896931443652
 
 but you were part of that thread last month so you might remember : )
 
 (I ended up buying two of those python-only processors chips btw - I don't
 know how to solder though so I'm waiting to meet a new friend at my new job
 who can do it for me)
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════────────────────────────────┘

--- #165 fediverse/1109 ---
════════════════════════════════════════════════───────────────────────────────────
 ┌─────────────────────────────────────────────────┐
 │ CW: re: death mentioned, nazi germany reference │
 └─────────────────────────────────────────────────┘


 @user-815 
 
 Agreed, and if you leave then you are needed elsewhere. Listen to your heart.
 That's what I did.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════──────────────────────────────────┘

--- #166 fediverse/4804 ---
═════════════════════════════════════════════════════════════════──────────────────
 I love it when wine doesn't work because it "failed to open program.exe"
 
 ... okay, can you tell me why it failed?
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════════════─────────────────┘

--- #167 fediverse/1229 ---
════════════════════════════════════════════════───────────────────────────────────
 @user-883 
 
 graphics isn't too bad in C if you use Raylib. Here's my template project:
 
 If you ever want to do something with a GUI or a game or something then I
 definitely recommend that library. It's soooooo nice as a C programmer

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

--- #168 fediverse/3118 ---
════════════════════════════════════════════════════════───────────────────────────
 ┌──────────────────────┐
 │ CW: politics         │
 └──────────────────────┘


 they want your stuff breaking after 5 years so that you always need them.
 
 if you have everything you need, there's nothing stopping us from revolt
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════──────────────────────────┘

--- #169 fediverse/894 ---
═══════════════════════════════════════════════────────────────────────────────────
 a code editor that only highlights the lines that have been specifically
 flagged to have a certain function. Like, rendering, or sound, or GUI, or data
 storage, or logic, or control flow.
 
 then, when the user is browsing, they can say "only show me these types of
 functions" with a very advanced filter mechanism. The editor would highlight
 the ones that were relevant and related, as according to user-defined flags
 that were set when writing it originally. In this way, by using a bit more
 syntax, even if it's literally just blocks of [category] labels (like how """
 or ``` often starts or ends a comment block)
 
 highlighting with colors is great, but what if we de-emphasized the stuff that
 didn't matter? by increasing the opacity more closely aligning the font color
 to the background color, we could make a bit of text seem to "fade" from
 perspective, while still readable the user's eyes would not be drawn to it.
 Then, according to the labels marked as filtered, certain text would be bold,
 highlighted, o
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════───────────────────────────────────┘

--- #170 fediverse/3654 ---
═════════════════════════════════════════════════════════──────────────────────────
 ┌──────────────────────┐
 │ CW: food-mentioned   │
 └──────────────────────┘


 phew this is what happens when you make your morning pages public. gonna eat
 some pizza instead of this nonsense.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════─────────────────────────┘

--- #171 fediverse/718 ---
══════════════════════════════════════════════─────────────────────────────────────
 @user-547 
 
 That feeling when you get to the end of a paragraph and think "why do I have
 this extra parenthesis )? Oh yeah I opened it up waaaaay up here" and then you
 reread what you wrote and think
 
 perfect, no notes
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════────────────────────────────────────┘

--- #172 fediverse/4306 ---
════════════════════════════════════════════════════════════───────────────────────
 ┌───────────────────────┐
 │ CW: cursing-mentioned │
 └───────────────────────┘


 operations: try not to use the last of anything, and always use last-time's
 last first.
 
 projects: you better clean your fucking plate because anything you don't eat
 is going in the TRASH
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════════──────────────────────┘

--- #173 fediverse_boost/1546 ---
◀─╔═══════════════════[BOOST]═════════════════════───────────────────────────────╗
║ ┌────────────────────────────────────────────────────────────────────────────┐ ║
║ │ Ethers dances for you.                                                     │ ║
║ │                                                                            │ ║
║ │ If this flame is beautiful, ⭐ or boost this post to improve its chances for future breedings. │ ║
║ │ #fractal                                                                   │ ║
║ └────────────────────────────────────────────────────────────────────────────┘ ║
╠─────────┐                                                            ┌───────────╣
║ similar │                       chronological                       │ different ║
╚═════════╧═════════════════════════════════════───────────────────────┴───────╝─▶

--- #174 fediverse/1846 ---
══════════════════════════════════════════════════════─────────────────────────────
 If you're running away from something, you need to make sure that you're going
 fast enough and far enough away that you can look forward for interception
 events. Otherwise you are vulnerable.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════────────────────────────────┘

--- #175 fediverse/2747 ---
═══════════════════════════════════════════════════════────────────────────────────
 easiest way to solve an entire class of accessibility problems: in the
 tutorial, instead of having button prompts, have keybinding confirmations.
 
 "what button do you want to use to jump?"
 
 "super triple mega backflip spin-dozer needs three jumps and a kick"
 
 "use the boost to get through! [game pauses] (which button do you want to use
 to boost?) [displays a map of previously bound keys]"
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════───────────────────────────┘

--- #176 fediverse/5442 ---
═══════════════════════════════════════════════════════════════════════────────────
 @user-1839 
 
 the trick is to just make it and point people toward it as if it's supposed to
 be there.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════════════════════───────────┘

--- #177 fediverse/950 ---
════════════════════════════════════════════════───────────────────────────────────
 @user-192 
 
 multidimensional arrays aren't too hard, it gets a bit more complicated when
 you need multidimensional slices, but once you get your head around it it
 comes easier.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════──────────────────────────────────┘

--- #178 fediverse/3061 ---
════════════════════════════════════════════════════════───────────────────────────
 every time I read a subtoot I assume it's about me and I mentally curl up into
 a ball
 
 doesn't matter if it's totally irrelevant, if there's no target specified it
 defaults to me because... like, who else is there right?
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════──────────────────────────┘

--- #179 fediverse/5612 ---
════════════════════════════════════════════════════════════════════════───────────
 you know, [you can just randomize your profile every time you log in] .... oh
 there was a stack overflow at the last one so

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

--- #180 fediverse/3647 ---
═════════════════════════════════════════════════════════──────────────────────────
 it's always wild when the exact moment I start playing music (quiet enough not
 to hear more than 5 feet away) or switch tasks suddenly there's a LOT of
 activity outside my apartment. like... if you're gonna watch me at least make
 it more subtle lmao
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════─────────────────────────┘

--- #181 bluesky#21 ---
══════════════════════════════════════════════════════════════════─────────────────
 the main product that github offers is the assurance that the code displayed
 on your monitor is the same as the one running on your computer.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════════════════────────────────┘

--- #182 fediverse_boost/4174 ---
◀─╔════════════════════════[BOOST]═════════════════════════──────────────────────╗
║ ┌────────────────────────────────────────────────────────────────────────────┐ ║
║ │ the belief that the world consists of discrete 'objects', rather than regarding it as an undifferentiated field of matter to which we can attach various framings, is a widespread mental limitation │ ║
║ └────────────────────────────────────────────────────────────────────────────┘ ║
╠─────────┐                                                            ┌───────────╣
║ similar │                       chronological                       │ different ║
╚═════════╧══════════════════════════════════════════════──────────────┴───────╝─▶

--- #183 fediverse/3592 ---
═════════════════════════════════════════════════════════──────────────────────────
 @user-1570 
 
 [meme of Mr Incredible from the Incredibles pointing at a table]
 
 LINUX IS LINUX.
 
 (anything that works on Linux can theoretically be made to work on your
 toaster, if it also runs Linux!)
 
 This is very cool, and if I understand correctly it means that any Godot games
 could theoretically be played on these NEAT as HECK little devices, yeah? So
 cool!
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════─────────────────────────┘

--- #184 messages/999 ---
═══════════════════════════════════════════════════════════════════════════────────
 Okay bear with me, but, what if we took the AI that they use to play games
 (like, the kind that memorize the best way to play space invaders or whatever)
 and instead of A and B and start and select they could use programming
 languages to try and recreate exactly a winning move, which in this case is
 just the exact behavior that is created by the test case playthrough of Super
 Mario Bros or Space Invaders. Free open source everygame!
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════════════════════════───────┘

--- #185 fediverse/4014 ---
═══════════════════════════════════════════════════════════────────────────────────
 I don't know about you, but "trying my hardest" involves giving up sometimes.
 
 How else are you to know your limits if you don't test your boundaries? And,
 after finding that there's nowhere else for you to go, you turn around and
 "give up", until you're ready for your next expedition.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════════───────────────────────┘

--- #186 messages/453 ---
══════════════════════════════════════════════════════─────────────────────────────
 UX idea: text is rapidly revealed (rate configurable) letter by letter and
 upon reaching the bottom of the page it starts over at the beginning,
 overwriting what was there in a different color to show that they're separate.
 
 For colorblind accessibility it might switch between white background black
 text, and black background white text. Again, user configurable, colors are
 cool too.
 
 If the user pushes the spacebar it pauses until they resume it, and it goes a
 bit slower. If they catch up to it they can double spacebar to make it go
 faster!
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════────────────────────────────┘

--- #187 fediverse/537 ---
══════════════════════════════════════════════─────────────────────────────────────
 @user-366 @user-367 @user-246 @user-353 
 
 Ah yes, wouldn't it be nice if everyone spoke their mind? I'm doing my part
 d=(^_^)z
 
 Thank you for adding context to what I posted. I now know better how and where
 to use it, if I ever do again. We shall see, I haven't yet read the
 examinations of the author you sent me. I'll do that before I think about the
 post again.
 
 Those 6 tabs I mentioned last night have now become 4, and soon I'll get
 through all of them - reading is a joy to me ^_^
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════────────────────────────────────────┘

--- #188 fediverse/3082 ---
════════════════════════════════════════════════════════───────────────────────────
 ┌─────────────────────────────────────┐
 │ CW: states-mentioned-climate-change │
 └─────────────────────────────────────┘


 the government doesn't want you using solar panels because then the coal and
 gas infrastructure won't be able to consume coal and gas, and everyone knows
 that using resources as fast as possible is surely the best and most
 productive use of our state's time
 
 like, subsidies exist. they could just... make it cheaper, but instead they're
 stuck doing... nothing of value
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════──────────────────────────┘

--- #189 fediverse/6443 ---
═══════════════════════════════════════════════════════════════════════════════────
 speedrunners forget how to play (toy) their favorite toys and learn how to
 play (instrument) their favorite instruments
 
 EDIT: it can be relearned. focus on the tandem.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════════════════════════════───┘

--- #190 messages/304 ---
══════════════════════════════════════════════════─────────────────────────────────
 Relax.
 
 Take it from me.
 
 I won't resist, at least I'll try, and if I start suddenly then it hurts and
 you should go slower. Unless I do three short, three long, three short.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════────────────────────────────────┘

--- #191 fediverse/5840 ---
═══════════════════════════════════════════════════════════════════════════────────
 ]]]]
 
 I have never stopped fighting for the people, ever, once, at any time.
 
 every moment of pause or relaxation was purely intended in pursuit of the
 cause.
 
 -- turn-of-the-century-autocrat
 
 enchanting magic's easier when you have a laboratory
 
 please, please, please let me teach you magic?
 
 enchantment is temporary, construction is as stable as the boject youses form.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════════════════════════───────┘

--- #192 messages/758 ---
══════════════════════════════════════════════════════════════════─────────────────
 what if we got a bunch of computer programmers in a room and all had them
 write the same program, line by line. Like, if they each contributed to the
 discussion about what should be placed next.
 
 "I wrote a for loop that does what we're looking for on line 43 through 69"
 and then someone else says "nice" and everyone's like "oh you"
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════════════════────────────────┘

--- #193 fediverse/5590 ---
════════════════════════════════════════════════════════════════════════───────────
 vibe coding is just writing comments in increasing detail until the generated
 code matches what you need.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════════════════════──────────┘

--- #194 fediverse/582 ---
══════════════════════════════════════════════─────────────────────────────────────
 @user-431 
 
 I made an alias that overwrites cd so I don't have to do this. The important
 line is line 27, you could probably accomplish something similar like this:
 
 alias cd="cd ${1} && ls -v --color=auto"
 
 I also set it up so I can change more than one directory up using ... or ....
 or .....
 
 also I have a few shortcut scripts, cdir and qcd. cdir creates a quick way to
 drop a bookmark wherever I'd like, while qcd can make permanent bookmarks.
 Also qcd makes it so whenever I open a new terminal it opens to the last
 directory I was in, which is nice if you need a new terminal to do something
 in the current folder and you don't want to have to walk alllllllll the way
 back.

$A BASH script that overwrites the built in "change directory" command to auto magically list the contents of the directory you've moved into after moving. here's the content of the script: #!/bin/bash alias cd="cd-improved" function cd-improved(){ if [ "${1}" = "..." ] ; then builtin cd .. && builtin cd .. elif [ "${1}" = "...." ] ; then builtin cd .. && builtin cd .. && builtin cd .. elif [ "${1}" = "....." ] ; then builtin cd .. && builtin cd .. && builtin cd .. && builtin cd .. elif [ -d "./${1}" ] ; then local target_dir="./${1}" elif [ "${1}" = "cdir" ] ; then local target_dir="$(tail -n 1 '/home/ritz/scripts/.cdir-target')" echo ${target_dir} else local target_dir="${1}" fi if [ ! "${2}" = '--no-ls' ] ; then builtin cd "${target_dir}" && ls -v --color=auto else builtin cd "${target_dir}" fi # if the qcd function is defined if declare qcd > /dev/null; then quick_cd -d DEFAULT quick_cd -a DEFAULT fi }$

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

--- #195 fediverse/1334 ---
═════════════════════════════════════════════════──────────────────────────────────
 ┌──────────────────────────────────────────────────┐
 │ CW: TMI-medical-issue-thing-don't-worry-about-it │
 └──────────────────────────────────────────────────┘


 subconsciously running your hand over your butt every time you stand up to
 make sure you didn't pee your pants
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════─────────────────────────────────┘

--- #196 fediverse/1841 ---
══════════════════════════════════════════════════════─────────────────────────────
 curling up in a ball and thinking about crying for hours is the same as
 crying. If a little bit less of a release.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════────────────────────────────┘

--- #197 fediverse/3559 ---
═════════════════════════════════════════════════════════──────────────────────────
 @user-1209 
 
 like... var = x?? that doesn't make sense. Or like, 5 = var x? that feels wrong
 
 in programming = is assignment, not equality, which tripped me up for a bit.
 But if you read it left to right it's like X equals 5. Got it, now I know that
 X is the same as 5. Right?
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════─────────────────────────┘

--- #198 fediverse/1003 ---
════════════════════════════════════════════════───────────────────────────────────
 @user-735 
 
 I made a World of Warcraft private server where all the default NPCs are
 removed from the game and the world is empty. But, every once in a while,
 monsters will spawn and attack you Risk of Rain style.
 
 If your character sits down, they stop attacking/spawning. I call it
 "wow-chat" because I'm bad with names, but the idea is basically a low stakes
 social game that you can pick up and set down whenever you want, while hanging
 out with your friends.
 
 there's also treasure and wandering merchants, and I've been thinking about
 adding dynamic quests but so far nobody's asked to play it so I've been
 working on other things.
 
 it's all open source too so you can host it yourself if you want.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════──────────────────────────────────┘

--- #199 fediverse/968 ---
════════════════════════════════════════════════───────────────────────────────────
 ┌──────────────────────┐
 │ CW: for-cats-only    │
 └──────────────────────┘


 the gameplay value of a cardboard box increases exponentially upon the
 introduction of a box-cutter [to make holes in the box] and varmint sized toys
 [to play whack-a-mole with]
 
 also, it's important to let your can win about 65% of the time - just enough
 to keep them interested (cats lose attention) but not enough to make them feel
 like it's easy.
 
 That's why it's important not to use your hands as a toy, because your hands
 always hurt. It gives them a feeling they're craving, both of attention but
 also success.
 
 65% is more addictive, just ask any designer for multiplayer games. Well... 65
 is my number, but there's a percentage (depending on the game) that players
 have to win if you want to keep their attention. If they win more than that,
 they lose interest. if they lose more, then they get frustrated. It's a
 delicate balance that ideally would be measured by AI [cursed] and adjusted
 per player. That way you could get maximum engagement and
 =============== stack overflow ===================
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════──────────────────────────────────┘

--- #200 fediverse/161 ---
═══════════════════════════════════════════────────────────────────────────────────
 I wish games started with everything unlocked and if you wanted you could
 "start a journey" or whatever and lock everything but a few options... then
 slowly as you play the game you unlock new things to do until eventually
 you're back where you started.
 
 Essentially... starting at level 100 and having the option to prestige right
 away. If you want the experience. While playing a game. That you have every
 right to enjoy as you will.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════───────────────────────────────────────┘