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

=== SIMILARITY RANKED ===

--- #1 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 │
╚═════════╧════════════════════════════════════════════────────────────┴──────────┘

--- #2 fediverse/849 ---
╔══════════════════════════════════════════════────────────────────────────────────┐
║ wish there were ascii characters that took up more than one line of code         │
║ vertically.                                                                      │
║                                                                                  │
║ wonder if we could use a sorting algorithm, or markup language, or something     │
║ like that to organize less structured data along user-customizable rules.        │
║ Like, a code editor that worked with your ideas, rather than the strict          │
║ expression of your text. You could pretty much write in any language, even       │
║ pseudocode, and the LLM behind the scenes would translate whatever you wrote     │
║ into whatever result you needed. Writing Rust, but need to fit in with C code?   │
║ No worries it'll translate for you. As long as the end result is functionally    │
║ the same, which could be verified by running two separate VMs that ran           │
║ interpreters every time you saved. And as long as their translation layers       │
║ matched completely, then odds are they're the same. And if not, well, the        │
║ programmer can always debug it. It's not like this would be running on           │
║ something that needed to perform in the moment? Like, improv instead of          │
║ tragedies, or battles instead of strategies                                      │

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

--- #3 fediverse/5405 ---
══════════════════════════════════════════════════════════════════════─────────────
 can't stop thinking about a visual programming editor that can be interacted
 with in the same way that people are used to (think chromebooks dragging and
 dropping icons in a web UI) but produces a text-file full of code and all the
 required compilation scripts for any language the user requires...
 
 seriously, programming is not THAT different between the different languages.
 especially the main ones. they're all essentially variables and function calls
 at the end of the day, so why not abstract away all the extra details and
 build something that n00bz can actually use to build things.
 
 I technically could make this but I don't have the bandwidth and I don't think
 it's important really? who can say, the tools tend to co-create the solutions
 in my experience.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════════════════════────────────┘

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

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

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

--- #6 fediverse/4196 ---
═══════════════════════════════════════════════════════════────────────────────────
 if you only have a phone, you can still program. Just write it out on paper,
 and put the whole program out on the floor.
 
 Screens will never compare, for they are but a tiny keyhole into the total
 program at hand. And you can pick parts of it up and carry them around - so
 useful! You could make an entire building out of that. [floorplan, layout,
 that kind of thing]
 
 downside is, of course, you don't have a computer, so you have to look up
 syntax on your phone.
 
 and eventually you're gonna have to type it, unless you can get a computer to
 read it for you.
 
 just imagining office buildings where employees can follow along with monitors
 on the wall that explains what they're working on and what they need to resolve
 
 then they meet up with a bunch of other humans and they hash things out
 
 turns out computers are really bad at speaking in group situations.
 
 which is why they let humans do that all on their own. [uhhh, no it's how you
 can tell if someone's a robot/alien/lizard/spy/secret-agent/whatever-sneaking]
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════════───────────────────────┘

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

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

--- #8 fediverse/2847 ---
══════════════════════════════════════════════════════─────────────────────────────
 if you want to make an ASI, just build your wires out of computer instead of
 copper or fiberoptics.
 
 like, telephone route switchers relaying conversations, where the
 conversations take place as like... a rube goldberg machine of processing
 toward a certain feeling of idea, expressed to another part of the
 network.icoosjff9ffddsssdfaggssssbwbnuigoopooiiuyioiouuoiifffff;;ssssskllemv0ob
 jfjgk
 
 sorry my cat was typing on my computer. I don't know why she couldn't wait
 until I was finished but she wanted to be like her mom or whatever so. anyway.
 
 right so anyway
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════────────────────────────────┘

--- #9 fediverse/4125 ---
═══════════════════════════════════════════════════════════────────────────────────
 @user-883 
 
 yeah that's probably better too since it'll be easier so there'll be fewer
 bugs, especially since processing audio isn't usually performance critical ^_^
 
 TBH I just want people to make more threading primitives like locks,
 semaphores, and iterators. Like... thread pools, or hashmaps that run a
 function on each record stored within every time each of the threads passes a
 checkpoint, or paginated arrays of data that run a function on themselves and
 the records near them (with slightly different input values, of course) idk
 what those are called but I can't resist putting them in everything
 
 Anyway I do think multithreading programs that don't need it will teach you to
 be a better programmer, so... depends on what you're working on I guess. Are
 you preparing to be ready and working, or are you ready and working?
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════════───────────────────────┘

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

--- #11 messages/181 ---
══════════════════════════════════════════════─────────────────────────────────────
 I know you don't want to hear this, but there is a chance that there will come
 a time where your life depends on your ability to debug a computer without the
 internet. To set up an SSH server. To install Linux. To program in C. To do
 something else that I'm not prepared for... If StackOverflow didn't exist
 because network connectivity has been lost, could you remember syntax? Maybe
 it's a good idea to set up a local LLM that can answer basic questions about
 technology. Maybe it's a good idea to set up on your parents computer, just in
 case you have to hide out there for a couple months. Maybe it's a good idea to
 download wikipedia, just in case.
 
 If I need to use a mac, I'm screwed
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════────────────────────────────────────┘

--- #12 fediverse/646 ---
╔═════════════════════════════════════════════─────────────────────────────────────┐
║ @user-470                                                                        │
║                                                                                  │
║ oh sorry I'll "en-longify" that for you:                                         │
║                                                                                  │
║ most monitors have a fixed resolution, somewhere between 720 pixels wide and     │
║ 480 pixels high to 2560 by 1440 pixels high/wide.                                │
║                                                                                  │
║ This is due to both the desire for humans to read left to right (ingrained in    │
║ our minds at a very young age by learning to read) (or right to left, same       │
║ direction) that we develop the desire for wide-screen monitors.                  │
║                                                                                  │
║ Therefore, the windows of perception that we have unto this digital world are    │
║ constrained (necessarily) to their own individual specifications. Of which,      │
║ the property value "width" is more valued than "height". Because of this, we     │
║ believe that computers are mistakenly re-acclimated - for everything is most     │
║ efficient when it's aligned to the smallest bits of it's design.                 │
║                                                                                  │
║ sorry, I like programming in C. Basically I'm very porous, and thinking about    │
║ low level topics (like C programming) is an easy way to burn characters when     │
║ there's only so many in the mastodon post that I can use to express my intents   │
║ and tr                                                                           │
╟─────────┐                                                            ┌───────────┤
║ similar │                       chronological                       │ different │
╚═════════╧══════════════════════════════════──────────────────────────┴──────────┘

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

--- #14 fediverse/5402 ---
══════════════════════════════════════════════════════════════════════─────────────
 @user-1773 
 
 that point about HTML is soooooo good
 
 like, we could be designing websites like we design video game UIs but instead
 we use React which fills your browser with insecure-by-design javascript
 generated visuals
 
 or, even better, or just use HTML like a config file
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════════════════════────────────┘

--- #15 fediverse/634 ---
═════════════════════════════════════════════──────────────────────────────────────
 @user-192 
 
 I'd agree with that. it's not designed for performance, not really. Mostly
 ubiquity, which is it's strength. As long as something can be compiled to a
 binary, BASH can execute it. That's why it's good, for accomplishing diverse
 tasks that you cannot have the capacity to program yourself. Scientific
 computations or cultural approximations, things that are beyond your intuitive
 understanding as a human on this earth, but which compel and align your
 thinking.
 
 I'm sure someone could create a more intuitive or accessible syntax, but
 syntax isn't the point - the capabilities, what you can do with it, has always
 defined the purpose of programming paradigms. And BASH is (currently) at the
 forefront of it's niche, the "terminal" language that handles "command line"
 applications. Powershell is good, yes... but it's not as good as BASH. Neither
 is Fish or... the one that starts with a z? zfs? something like that. The
 acronyms are hard to keep straight sometimes.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════─────────────────────────────────────┘

--- #16 fediverse/6015 ---
══════════════════════════════════════════════════════════════════════════─────────
 ┌──────────────────────┐
 │ CW: AI-mentioned     │
 └──────────────────────┘


 In 2025, if you want to create a piece of software your options are to either:
 devote your life to it, or use AI to build a semi-working prototype that you
 can use to pitch your idea to a bunch of people who have devoted their lives
 to learning how to use your idea as documentation while they build it from
 scratch, throwing out most of the code but keeping all the checklists and
 progress-trackers you built along the way, perhaps even utilizing some of your
 tooling that you used while constructing the scaffolding of this monstrous
 application that you won't be using most of the source-code for.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════════════════════════────────┘

--- #17 fediverse/5911 ---
╔═════════════════════════════════════════════════════════════════════════─────────┐
║ I was always fascinated by the Linux way of programming. Need to do something?   │
║ write it into a script! You never know when you'll need it again. Then, just     │
║ stay organized, religiously so, and understand that you will forget about        │
║ stuff. But, you'll come across it eventually, ready and willing and able to      │
║ help you.                                                                        │
║                                                                                  │
║ if you don't want me using AI, then give me ~20 junior developers. Which is      │
║ more efficient, do you think?                                                    │
║                                                                                  │
║ "girl you haven't even tested your vibe-coded slop, how do you know if it        │
║ works"                                                                           │
║                                                                                  │
║ oh I'm sure it doesn't, but it's the thought that counts                         │
║                                                                                  │
║ ... I guess I'm just saying, please don't burn the data centers. Computers are   │
║ not only bad for the environment when they're burnt, but also we can use them    │
║ for all kinds of neat things. Even if it takes a lot of energy, just... build    │
║ more solar panels and only use the computers for important stuff?                │
║ timeshare-style?                                                                 │
║                                                                                  │
║ \@/documents/books/man-and-the-computer.pdf                                      │
║                                                                                  │
║ that was my mother's book... I love her. I miss that side of her. She fled       │
║ when the cancer came.                                                            │
╟─────────┐                                                            ┌───────────┤
║ similar │                       chronological                       │ different │
╚═════════╧════════════════════════════════════════════════════════════╧═─────────┘

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

--- #19 fediverse/4897 ---
════════════════════════════════════════════════════════════════───────────────────
 what if we asked chatGPT to generate a list of every personality archetype
 that humans have. Like... really get super specific and fill out the whole
 list of character sheets.
 
 then we give each fraction of it that fraction of dollars and if some people
 aren't fully represented (because they have greater needs) then we both
 increase production of resources and take a penalty on our own supply, in
 order to meet the needs of our allies.
 
 simplest thing. how could it work? who can say. maybe it won't. maybe it's
 just... arcane. /shrug that's game design for ya you can't tell how it'll go
 until it's in the hands of your players. too bad we don't do too many
 play-things.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════════════──────────────────┘

--- #20 notes/internet-privacy-is-withheld-by-this ---
═══════────────────────────────────────────────────────────────────────────────────
 Recently, there's been a ton of buzz in the news about internet privacy.
 From the many lawsuits against Facebook, to the rise of Duck Duck Go and the
 creepy nature of apps and IoT devices that listen to your every motion and
 record and transmit endless amounts of data to a central server somewhere to
 be processed. The traditional argument against privacy online is that the
 infrastructure was designed to accomodate rapid adoption of the new tech,
 rather than efficient design for distributed throughput. So we were told to
 accept the minor downsides associated with centralized servers - downsides
 that we neither understood nor truly accepted. Well, the technology has
 advanced to the point that those arguments are no longer valid - we have mesh
 networking and 5g internet access, and now that big tech is in control of the
 industry (wrenching it from the people, I might add) they seek to maintain
 their hold by any means necessary.
 
 Luckily, there is a way out - self hosting.
 
 If we hosted our own email server, then theoretically Gmail couldn't read your
 messages. If we hosted our own social media websites, then theoretically
 big data processing corporations couldn't scrape your personal information
 and distribute it as they please. If we hosted our own videos, software, art,
 and anything else we see fit to use a computer for, then we'd be unshackled
 from the dominion of the silicon valley powers that be. The liberation of the
 computer is the liberation of us all.
 
 The problem, of course, is the difficulty involved.
 
 People are conditioned to desire and only accept a level of accessibility that
 can only be provided by massive corporate think tanks leveraging all the
 marketing prowess that the markets of capital provides. That is to say,
 essentially infinite eyes examining the interactions of man with machine, to
 find the most generally applicable font, color scheme, layout, and style of
 each and every website they host. Every function will be scrutinized to death
 and optimized to extract the most profit while subtely conforming the minds
 of those who use it. This is the era of group think, fake news, and
 journalistic fraud. We have no windows to the outside world that are truly
 and completely untainted by the bias inherent in the system.
 
 A self perpetuating rhythm of continuous dissatisfaction.
 
 But I believe the only person who can truly design a tool is the person who
 the tool is intended to be used by. And by increasing the accessibility of the
 tools themselves, rather than the products of those tools, we can raise the
 tide that lifts all ships - we can put more tools that use less time to use
 and are easier to learn into the hands of as many people as possible. The
 crossbow was originally no more devastating than a longbow, yet it rapidly
 outpaced the latter by reducing it's difficulty curve. The screwdriver is the
 same - stronger joints can be made with nails or traditional joinery, but
 once someone understands how a screwdriver works they can pretty much force
 two pieces of wood to be permanently fixed together without understanding the
 angles of nails or cuts. The capabilities are the same, while ease of access
 increased.
 
 So, to truly liberate the internet, we must develop tools that allow people to
 host their own content as easily, cheaply, and flexibly as possible, while
 being aesthetically pleasing, affordable (free), and accessible to
 as many people as possible - inertia is important, after all. It seems to be
 an insurmountable task, but that's what free and open source software
 developers fight for. Raspberry Pis can host email servers, Mastodon can host
 a facsimile of Twitter, and torrents can be used to exchange any type of file
 to be presented in whatever way the user sees fit. These are all free (or very
 cheap, in the Raspberry Pi's case) and accessible to anyone with access to the
 internet. But they aren't easy. They aren't always flashy. And sometimes it's
 hard to even describe what problem you're trying to solve.
 
 But still you try, because to fail in this fight is to fade from this earth.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘══════───┴╧───────────────────────────────────────────────────────────────────────────┘