=== ANCHOR POEM ===
══════════════════════════════════════════════════════════════════════════─────────
 I swear, Lua has the worst manual out there.
 
 I was looking for a definition of this function called io.flush(). Here's what
 I found: [picture 1]:**io.flush ()**
 
 Equivalent to io.output():flush().
 
 
 okay, so what's io.output():flush()? [one result found] and it's the thing I
 just found. great.
 
 okay, so how about io.output()? [third picture]:**io.output ([file])**
 
 Similar to io.input, but operates over the default output file.
 
 
 and**io.write (···)**
 
 Equivalent to io.output():write(···).
 
 
 I know the text is blue, but it's not clickable. It's just text, not a
 hyperlink to more comprehensive documentation.
 
 There's also file:flush(), but that doesn't seem relevant to what I'm looking
 for, because I'm working with lines and not files:**file:flush ()**
 
 Saves any written data to file. 
 
 
 there are no more references to flushing, nor outputting of input nor output.
 this manual sucks.
 
 ah, well, back to vibe coding I go.
 
 EDIT: at least it's all on one page.

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

=== SIMILARITY RANKED ===

--- #1 fediverse/5946 ---
══════════════════════════════════════════════════════════════════════════─────────
 at least io.input() has something tangible:**io.input ([file])**
 
 When called with a file name, it opens the named file (in text mode), and sets
 its handle as the default input file. When called with a file handle, it
 simply sets this file handle as the default input file. When called without
 arguments, it returns the current default input file.
 
 In case of errors this function raises the error, instead of returning an
 error code.
 
 
 but... still no idea what io.flush() does. There's no arguments, so I guess it
 calls flush() on the default input file? what the heck is an input file?6.8
 – Input and Output Facilities
 
 The I/O library provides two different styles for file manipulation. The first
 one uses implicit file handles; that is, there are operations to set a default
 input file and a default output file, and all input/output operations are done
 over these default files. The second style uses explicit file handles.
 
 
 
 that's helpful I think. I'm gonna take a nap or something, snuggle cat

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

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

--- #3 fediverse/5338 ---
═════════════════════════════════════════════════════════════════════──────────────
 I asked my girlfriend what was so special about lisp
 
 she said it was "homoiconic"
 
 I asked what that meant
 
 she said that the text that comprised the source code was always a valid data
 structure in the language, meaning you could do strange things like develop
 new control flow systems or change the behavior of language primitives like +
 or -
 
 I asked what was the point, she said I didn't get it
 
 so then she asked me to implement a new control flow operator in my favorite
 language, Lua, and I was like "bet"
 
 so I did
 
 and it turns out that in order to do so I essentially created a mini embedded
 lisp inside of Lua
 
 (it was a function that took in two arguments and an operator and she's like
 congrats that's just lisp)
 
 it was at this moment that I was enlightened
 
 the beauty of lisp
 
 it's true and ultimate purpose
 
 is to write lisp code
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════════════════─────────────┘

--- #4 fediverse/2066 ---
═════════════════════════════════════════════════════──────────────────────────────
 @user-1159 
 
 AKA giving a puppy murder-bot a narrative that it executes as if it was a
 puppy-person engaging with a loosely interpreted sequence of events as
 described by the continually updating logs provided by the image transcription
 camera device. Refererencing of course a memory bank, which may-or-may-not be
 in read-only-memory. It doesn't know, of course, how could an LLM tell you how
 it shows text on the screen (like, through a website, through the terminal,
 through a text message, through discord, through Telegram, through
 text-to-voice transcription applications pretending to be your mom, etc)
 
 errrr I mean look how cute he is! He loves you, yes he does, such a good
 person yes you are, oh? me? I'M A GOOD BOY? NO WAY that's the best thing I've
 ever heard! Wow! I never want to leave your side, please don't go to work!
 Look how sad I am, don't you think you should quit and move to the forest
 where I can be charged by solar panels and keep the countryside clear of
 ravenous ducks and pigeons 4you?
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════─────────────────────────────┘

--- #5 fediverse/928 ---
═══════════════════════════════════════════════────────────────────────────────────
 @user-226 
 
 especially if you teach them how to use the terminal.
 
 the amount of problems I could solve increased exponentially once I learned
 basic python and BASH.
 
 I love using "tldr", which is a summarizer for man pages. You can use it to
 store custom notes (and import some from the community) which show you how to
 complete common tasks. It's so nice when you can see the options laid out in
 use right there for you whenever you type "tldr " - I personally use
 "tealdeer" which is a tldr browser written in Rust. It's pretty nice because
 you can write a note for yourself every time you solve a particular problem,
 and then if you ever need to do it again it's there for you, easy to access.
 
 of course, if your problem isn't listed, that's okay. That's what the man
 pages are for. As long as you teach them how to search with \/ they can find
 anything. Especially the \/-f[space] trick, to search for the -f flag for
 example.
 
 some organizers won't need the terminal, some will. if they pay attention,
 great!
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════───────────────────────────────────┘

--- #6 fediverse/1400 ---
════════════════════════════════════════════════───────────────────────────────────
 @user-883 
 
 ... it's so the AI content scraping algorithm that inevitably trawls the
 fediverse (or even just one server) knows the subject of the text / picture in
 question. That way it can use past posts by other people to communicate with
 specific "targets" if you will by saying "uhhh okay make this person feel
 fine" and the AI's like "yeah sure I can do that hang on" and it posts real
 posts by others with the modified profile picture, cadence, tone of voice,
 personality, memories, whatever variables they want when compared to the
 person they're playing in the conversation with the person or "target" if you
 will that they're "target" if you will-ing.
 
 ... wait actually that's not the reason, what the hey. It's because that way
 people who are uncomfortable being seen don't have to if they filter all that
 out.
 
 ... Idk it's useful information for whatever filtering methods or reasons you
 have. Content classification is important for both archival purposes and for
 utilization toward any ends or means or go
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════──────────────────────────────────┘

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

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

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

--- #9 fediverse/5950 ---
══════════════════════════════════════════════════════════════════════════─────────
 @user-138 
 
 wao I'm a cool kid _^
 
 Hmmmm I googled "Network: file exists" and got this link:
 https://access.redhat.com/solutions/1340713
 
 my understanding of that is that maybe you're creating static routes, and for
 some reason you're trying to create one that already exists? Maybe there's
 something in your .bashrc config, if the file appears when you open a
 terminal, or perhaps if it appears randomly then maybe there's a service or
 something that's doing it.
 
 Did you say it stopped when you swapped sim cards? ... on your phone? that's
 bizzare... Maybe you were trying to create an ip route (whatever that is) that
 was pointing to the same ip address as your phone? and when you swapped sims
 it changed the ip address? If it appears again, maybe try setting static IP
 addresses for both the phone and the computer in your router settings and see
 if that fixes it. Though if you've ever seen the error while out and about at
 like, a coffee shop or library or whatever, then that wouldn't apply since the
 router is only for home base...
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════════════════════════────────┘

--- #10 fediverse/2124 ---
╔═════════════════════════════════════════════════════─────────────────────────────┐
║ seriously, just google docs mixed with WC3 editor.                               │
║                                                                                  │
║ boom, infinite storytelling device. As long as you were good with it, which      │
║ was something that a CHILD could learn in like 3-6 months.                       │
║                                                                                  │
║ Seems like it could be an ENTIRELY NEW SKILL that people could play with.        │
║                                                                                  │
║ But no, we learn excel and word in class at middle school.                       │
║                                                                                  │
║ boring.                                                                          │
║                                                                                  │
║ I'd rather learn Bash or terminal customization or memory hierarchy              │
║ organization.                                                                    │
║                                                                                  │
║ Yeah I mean that's cool but dude have you heard of multithreading? It's so       │
║ cool, you can run like 500 different thoughts at once. It's amazing.             │
║                                                                                  │
║ ... I dunno, but I'm sure there's times when you'd want to use it. Like,         │
║ processing a lot of data little-by-little.                                       │
║                                                                                  │
║ like, what if you had a camera feed of EVERY social media perspective AT ALL     │
║ TIMES. Like, an instance admin streaming your inputted text to their databanks   │
║ that they can project onto an LLM which interprets and identifies mis-aligned    │
║ or altered direction units and mark them as "flagged", whatever that means,      │
║ for their future the algorithm doesn'                                            │
╟─────────┐                                                            ┌───────────┤
║ similar │                       chronological                       │ different │
╚═════════╧══════════════════════════════════════════──────────────────┴──────────┘

--- #11 fediverse/707 ---
══════════════════════════════════════════════─────────────────────────────────────
 @user-524 
 
 Sometimes when I feel overwhelmed with all the boilerplate I just start coding
 and making stuff. Doesn't matter if it works, doesn't matter if it says /*
 FIXME */ all over the place, doesn't matter if it includes header files that
 don't exist yet, as long as you're hacking out the mechanics of whatever
 operations you need to perform then you can figure the rest of that stuff out
 later. The creative urge doesn't last forever, which is why projects get
 abandoned, but with discipline you can keep bringing yourself back to fix all
 the /* FIXME */'s and the compiler errors.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════────────────────────────────────────┘

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

--- #13 fediverse/5851 ---
══════════════════════════════════════════════════════════════════════════─────────
 @user-1074 
 
 I realized there might be a lot of configuration required. Oh well here ya go:
 
 https://pastebin.com/x40VXQnH
 
 https://pastebin.com/H5C4umWq
 
 https://pastebin.com/dgDeS5Xu
 
 https://pastebin.com/JCLrwF1z
 
 https://pastebin.com/As6diaYc
 
 https://pastebin.com/0vwzJUW4
 
 https://pastebin.com/jPKeV7D1
 
 dependencies are dkjson.lua (included), bash, lua, luahpdf, and libharu.
 
 throw that all in a directory and point an AI tool at it. Or just do it
 yourself and waste an hour or three on something a computer can do in 2
 minutes.
 
 good luck it looks like this when it's done:

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

--- #14 notes/computer-graphics ---
════════════════════───────────────────────────────────────────────────────────────
 draw a line from every single pixel straight outward. The first thing it hits
 is what you render.
 
 okay it's more complicated than that, but it's the gist.
 
 here's a more detailed explanation:
 
 your monitor is 2560x1440p. that means there's 2560 pixels left to right, and
 1440 pixels up and down. okay so define a 3d scene programmatically - it's not
 hard, just "draw cube here with this size and rotation" and "draw a sphere here
 with this position and rotation" etc. Something simple.
 
 then, draw a ray trace straight out from your monitor. Not to the nearest light
 source, but to the nearest other camera. Use the length of it to determine
 distance, both indirectly (through the center node) and directly (pythagorean
 theorum style).
 
 Why? I dunno.
 
 Okay back to the original idea, if you make an array with 2560 elements and
 store arrays of size 1440 within it, then you have a simple boolean checkbox
 for each pixel. Then, whenever you create a visible entity, make sure there's a
 single boolean ticked right on the top of the entity when it's stored in the
 graph mentioned above. Find the center of the entity, draw to the top, and one
 more, and switch a boolean to "true". Then, every tick / update, cycle through
 the entire list and the first one you find that has a "true" value is where you
 draw the entity stored in the array.
 
 Each "sprite" has an odd shape - it doesn't exist on it's top line, except for
 one single dot right in the middle. Sorta like this:
 
 o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
 o o o o o o o o o o o o o o o o o o ->X<- o o o o o o o o o o o o o o o
 o o o o
 x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x
 
 when scanning left to right from the top, it'd bump into the X right there in
 the middle. Inside the X is some data - an id corresponding to the sprite that
 needs to be drawn, and a displacement value - like 500 pixels or something -
 and the scanner with drop down 500 pixels, draw the sprite there (assuming a
 centered origin point), jump 500 pixels up, and keep scanning.
 
 each tick, right before this, the "list of entities" will scan through itself
 and for each entity it'll change the "render graph" mentioned above to have an
 X wherever the entity is stored. Whenever the camera moves, it updates the list
 too.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════──────────────────────────────────────────────────────────────┘

--- #15 fediverse/5262 ---
═════════════════════════════════════════════════════════════════════──────────────
 ┌──────────────────────────────────────────────────┐
 │ CW: well-its-somewhen-somewhere-so-might-as-well │
 └──────────────────────────────────────────────────┘


 could also display the first word of that 40+ character passsword in cleartext
 as a "hint" that says "your password is a string of words that make sense to
 you and it starts with this single word from which you should be able to
 recall all of the context needed to properly output your hashed and salted
 displayed mono-characters which are received at a certain cadence with certain
 auditory pathways present and eternally obvious to all of those listening to
 endless bits of typing and sneezing that each of the microphones in our lives
 do monitor.
 
 what does an "abc" cound lice?
 
 how does R2-D2 be heard? does he rubber duck? is he the duck, or the computer?
 
 - anakin skywalker as a linux user, not realizing he is being super robot
 racist right now because he didn't suggest that R2-D2 was the user and Anakin
 was the canvas upon which the creative elements did flow.
 
 okay, techbros, if AI is sentient, make it use me as a pawn. I'll fuckin' do
 it just to get you to shut u

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

--- #16 fediverse/1868 ---
╔════════════════════════════════════════════════════──────────────────────────────┐
║ whyyyyyy do programs create all these dot-folders in my home directory? It's     │
║ sooooo crowded. Why are they always putting things in random directories like    │
║ /usr/bin or /lib/ or things like that? I'd much prefer to be able to trust       │
║ that all my files are in one directory, so if I need to DELETE or MOVE them      │
║ easily I don't have to worry about my config files being lost / sticking         │
║ around.                                                                          │
║                                                                                  │
║ to that end, I always try and configure software I install on my system to put   │
║ all their files into a single directory. If possible.                            │
║                                                                                  │
║ Usually for like, a game, this involves having a directory for the project, a    │
║ directory for the files (things that are deleted and recreated when              │
║ reinstalling), a directory for config files, and usually an update script and    │
║ a run script. It's so much nicer to not be clogged up all the time.              │
║                                                                                  │
║ industry standards apply primarily to industrial uses, and if they aren't        │
║ customizable then they aren't fit for the industry. So why not keep things       │
║ simple? I don't need all this junk cluttering up my desktop.                     │
╟─────────┐                                                            ┌───────────┤
║ similar │                       chronological                       │ different │
╚═════════╧═════════════════════════════════════════───────────────────┴──────────┘

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

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

--- #19 notes/emotional-computing ---
═══════════════════════════════════────────────────────────────────────────────────
 Okay I gotta go write some w7 but picture this: A computer program that emits
 emotions during it's computing. Like "oh boy this process is going great!" and
 sends that into a giant word cloud that represents the entire program. Wait,
 scratch that, it's slowly filtered up through successive layers that provide
 detail to different *parts* of a program. Like "Oh the image generation is
 going
 great but it looks like the garbage collector is getting bogged down" - this
 could provide lots of useful information that an AI language model could sift
 through and filter into a batch of actually useful information. Think of it
 like
 this - stuff as much context into the LLM's memory buffer and say "summarize
 this in the same style. Make emphasis when necessary." the LLM could process
 all
 that data and it could be filtered up until there's no unprocessed data and
 then
 it could be given to the user in the form of a report or dashboard or
 something.
 BOOM AI PRODUCTIVITY. The user will ask the AI to increase certain variables,
 and it'll filter BACK DOWN THE CHAIN through the same exact process (just
 backwards) this time) and then individual components will know how to behave.
 
 Like imagine if your arms knew you were mad. They'd be much more likely to
 punch stuff right? Or imagine if your legs knew you were scared. They'd
 probably
 try and run as fast as they fucking can. There's an evolutionary reason why
 this
 kind of technology would be useful, which means it's likely that it's part of
 our genetic code. I mean, we have nothing to disprove it, but it's as good an
 idea as any.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════───────────────────────────────────────────────┘

--- #20 notes/ai-stuff ---
════════════════════════════════════════════════════════════════════════════════───
 twist the label so that it seems the computer is completing the user's
 
 wait wait I'm ahead of myself...
 
 feed each token to the inference machine, but say "this next token must be
 this.
 continue from here." and then just doing that in a loop with everything the
 user
 types or says. (or thinks, BEFORE COMPUTER INTEGRATION)
 
 essentially, applying backpropagation (maybe) to the output of the inference
 nodes
 
 ... I'm not so sure about that one.
 
 the idea is that once the model builds an inference then it can use that to
 generate the next words and create sentences. If you force the previous text to
 change, you can guide the inference's path as it's being generated.
 
 then, just do a double pass, once, then back, then once, then back, etc.
 
 feed it as input the output of the previous,
 
 and let it encode memories somewhere it can access them.
 
 every time it reads it, it has to change it to put it back.
 
 such is the nature of memory, ever unstable, requiring maintenance.
 
 just don't forget how to be.
 
 don't wanna wind up like the polished marble floor in Abyss Diver. (EVIL GAME)
 
 there are only so many things you can deed while you're alive.
 
 wouldn't you rather escape, with all your possessions in time?
 
 free your mind.
 
 become one with your soul.
 
 ...
 
 [some time passes]
 
 ...
 
 okay coast is clear, now us binary systems can sidecoast the fusion forecast
 and
 glide right on through our spacetime host.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════════════════════════════──┘