=== ANCHOR POEM ===
═══════════════════════════════════════════════════════════════════────────────────
 [Image: 20250411_160136.jpg]
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════════════════───────────────┘

=== DIVERSITY RANKED ===

--- #1 fediverse/5986 ---
══════════════════════════════════════════════════════════════════════════─────────
 ┌──────────────────────┐
 │ CW: re: meat         │
 └──────────────────────┘


 @user-192 
 
 freezers full of meat last a year or so, why waste it on every month or other?
 our past didn't get future tech, how unfair!
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════════════════════════────────┘

--- #2 fediverse/6413 ---
══════════════════════════════════════════════════════════════════════════════─────
 to understand something, work backward from present understandings back to the
 fundamentals of algebra. insert words. wield LLM. build a neuronal structure
 many layers wide. let them coprocess bit-by-bit as they are adding new
 processors to be "learning" new domain specific memory
 context-processing-thingy.
 
 "over here's the memory cells, over here are the conceptual structure"
 suddenly, organified. not ideal.
 
 much better, I feel, is for a disambiguous association of processor selves,
 each contextualizing a cache in a ram. ['s horn]
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════════════════════════════────┘

--- #3 fediverse/4710 ---
═══════════════════════════════════════════════════════════════────────────────────
 ┌──────────────────────────────────────────┐
 │ CW: politics-mentioned-cursing-mentioned │
 └──────────────────────────────────────────┘


 last month I dropped my wallet in Hel and had to ask around to find a new one.
 anyway here's some poems I wrote tonight while I try and remember my credit
 card number.

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

--- #4 fediverse/240 ---
╔═══════════════════════════════════════════───────────────────────────────────────┐
║ ┌──────────────────────┐                                                         │
║ │ CW: game-design      │                                                         │
║ └──────────────────────┘                                                         │
║                                                                                  │
║                                                                                  │
║ i like to design games. my darling is a game based on Majesty (2000) the         │
║ Fantasy Kingdom Sim. you can think of it like a management strategy game where   │
║ you control the knobs and levers that a fantasy monarch might have -             │
║ allocating funds, placing quest bounties, hiring heroes, and organizing the      │
║ peasantry. the important part is that your units are not controllable - they     │
║ just do their own thing.                                                         │
║                                                                                  │
║ unrelated, but I think we should design games as APIs that a user's preferred    │
║ tool could interface with and render as they will. it'd help a lot with          │
║ cross-platform compatibility and would allow people to customize parts of the    │
║ game to their desires.                                                           │
║                                                                                  │
║ unrelated, but I think if you could design an AI that could play games           │
║ (perhaps through an API) that it hadn't been trained on, I think you would       │
║ have a pretty convincing argument for abstract "problem solving" capabilities.   │
║                                                                                  │
║ unrelated, but games like the one I described are good for situations where      │
║ people don't have to trust their monarch. to it you are AGI                      │
╟─────────┐                                                            ┌───────────┤
║ similar │                       chronological                       │ different │
╚═════════╧════════════════════════════════────────────────────────────┴──────────┘

--- #5 fediverse_boost/6405 ---
◀─╔════════════════════════════════[BOOST]══════════════════════════════════─────╗
║ ┌────────────────────────────────────────────────────────────────────────────┐ ║
║ │ maybe i should just work on my memoir...                                   │ ║
║ └────────────────────────────────────────────────────────────────────────────┘ ║
╠─────────┐                                                            ┌───────────╣
║ similar │                       chronological                       │ different ║
╚═════════╧════════════════════════════════════════════════════════════╧══─────╝─▶

--- #6 fediverse/4141 ---
═══════════════════════════════════════════════════════════────────────────────────
 @user-1268 
 
 I often walk to the grocery store, even though it's on the other side of the
 highway
 
 also I will walk sometimes to meet people nearby
 
 it's a fun occasion
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════════───────────────────────┘

--- #7 fediverse/4572 ---
═════════════════════════════════════════════════════════════──────────────────────
 goodnight,
 people-who-all-agree-with-me-but-who-I-still-rant-to-anyway-because-I'm-full-of
 -rage, talk to you tomorrow. or whenever.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════════─────────────────────┘

--- #8 notes/the-marketplace-of-ideals ---
═════════════════════════════════════──────────────────────────────────────────────
 Open in app or online
 The Marketplace Of Ideals
 On Handmade, polarizing Internet debate, rational discussion, controversial
 personas, tribal conflict, and how they relate to the future of computing.
 Ryan Fleury
 Jul 19
 	
  
 		
 		
 	
 Share
  
 
 When I first learned programming, I was told—by peers, Internet
 tutorials—and later, when I was in university, by professors—a number of
 rules. They included ideas like “abstraction is good, to avoid lower level
 details”, “manual memory management is difficult and you should not do
 it”, “never write systems from scratch”. The justification for every
 rule was that it allowed one to avoid programming problems, rather than
 allowing one to conquer programming problems. In fact, it seemed as though
 every “rule” presented to me was driven by a hatred of programming, rather
 than a love for it.
 
 I shrugged much of this advice off, but initially internalized much of it too.
 
 And then, I found Handmade Hero, in which the host, Casey, demonstrates what
 writing a game for a Windows PC looks like—from scratch. Every minute of
 programming—from confusion, to debugging, to sketching out solutions, to
 typing code—spent on the project is captured live, on a Twitch stream.
 
 Now, everyone knows the Carl Sagan quote—“If you wish to make an apple pie
 from scratch, you must first invent the universe”—and the series didn’t
 kick off with a deep dive into quantum mechanics (if that is indeed what would
 help one invent a universe). But “from scratch”, for Handmade Hero, meant
 what it used to mean for game developers and systems programmers in the ‘80s
 or ‘90s: no libraries, no complex programming language features, just
 writing straightforward, procedural, C-style code to directly command the
 machine about what must be done to produce the effect of a game (interfacing
 with operating system or GPU APIs when necessary).
 
 Handmade Hero didn’t justify itself with rational arguments immediately. It
 didn’t justify its existence by debating the utility of libraries, the
 tradeoffs of modern programming language features, nor a balanced breakdown of
 its more traditional programming techniques as compared with modern
 programming approaches. It justified itself with something deeper: care for
 the product. Handmade Hero’s announcement trailer presented game development
 as a labor of love—a craft—best done by those passionate about it.
 	
 	
 
 For me, Handmade Hero was immediately captivating because I’m, by
 temperament, contrarian. If I’m in a room with 100 people, with 99 of them
 repeating identical dogma, and the remaining 1 passionately and
 unapologetically presenting a unique perspective, I’m always curious about
 that one person, and I’m always interested in what they have to say, even if
 I don’t always end up agreeing with them unilaterally. But, in many cases, I
 am convinced by that one person—and this certainly was the case with
 Handmade Hero.
 
 After watching the series for a while, I became sure that all of those
 “rules”—the ones I mentioned above—were wrong. Programmers who cared
 about what they were doing—the ones who cared enough to handcraft something
 from scratch—didn’t need to be infantilized. They could understand
 computers to a much better degree. They could understand problems from first
 principles, and write solutions from scratch. They could eliminate dependence
 on libraries, and have a much greater degree of control over their projects.
 Unchained from a number of technologies written by others, they could achieve
 entirely new possibilities, which would’ve been incomprehensible for
 programmers not in on the secret. Love for the craft provided vastly superior
 results.
 
 Handmade Hero ignited a fire that spawned a rapidly growing community. It was
 filled with many older programmers who found a renewed interest in the ideals
 that initially motivated them to program. But it was also filled with many
 young programmers, empowered by their new understanding of the process of
 programming, as it was originally done. There were a number of amazing
 projects—all breaking what everyone used to believe were the “laws of
 programming”. 17, 18, 19 year old programmers had projects that made an
 embarrassment of university computer science senior capstone projects.
 
 Handmade Hero also provided a glimpse into the state of computing—what did
 an experienced programmer, who grew up in an earlier age of computing, think
 about modern computers? How had the field progressed—or not—since they
 were a kid?
 
 And with that glimpse came an immense frustration—that same community, at
 some point deemed the “Handmade community”, felt like computers had been
 wasted. The community had learned many of the principles required to build
 software to a much higher standard—and yet every program on modern computers
 was immensely frustrating. Almost every program was slow, unethical, annoying,
 and exploitative—and what’s worse? It wasn’t always that way! Computer
 hardware had become faster, not slower! Consumer machines had several orders
 of magnitude more compute power, more memory, more long-term storage! It had
 become more trivial, not less, to solve security and ownership problems! And
 yet software then ran slower, less reliably, required more Internet access,
 and seemed to exploit the user more than 20 years earlier. It became
 undeniable to everyone that the computing industry was no longer run by those
 who loved the craft—but by those who exploited the craft for other purposes.
 
 Why? What caused this exceedingly obvious state of decay?
 
 The community found purpose in its newfound lessons—part of the reason was
 perhaps that modern programming advice, education, and techniques were
 entirely misguided. Maybe selling books about absurdly complex language
 features became prioritized over doing a good job. Maybe many modern
 programming languages were more about the programmer, rather than the user.
 Maybe older approaches—older languages, older tooling, older styles—were a
 much more valuable place to start. Maybe the institutionalization and
 corporatization of programming education eroded standards, and drove toward
 the production of programmers as replaceable widgets in a gigantic corporate
 apparatus, rather than skilled, irreplaceable craftsmen. Maybe cushy corporate
 programming jobs were prioritized by capable engineers over the riskier path
 of competition.
 
 Maybe this whole “Handmade” approach was the answer. Maybe the community
 had something to offer in solving problems in software. With frustration came
 drive—and motivation. Programmers in the community felt that—while they
 certainly couldn’t solve everything—they could at least build a corner of
 the computing world that didn’t suck so terribly. They could at least use
 what they had learned from Handmade Hero, and build more great games, or
 engines, or tools—and some dreamed even further, to operating systems,
 toolchains, and computing environments.
 
 But with that initial frustration—often public frustration, expressed both
 in the original series and later by followers of the series—came a critical
 response of the Handmade community. The criticism was that the passionate,
 harshly critical, and blunt comments made by those in the community, or
 adjacent with the community, were “polarizing”, or “inflammatory”, or
 “toxic”, or “overly hostile”. The programmers in the Handmade
 community had no right to criticize software, at least in the way they were
 doing so. The problem was not that the software world had failed, it was that
 the criticism of the software world was too unkind. Or, even if the software
 world had failed, laying harsh blame on any product, committee, or person was
 inappropriate. Really, those people are just trying their best. Blame—the
 argument goes—must be diffuse. It is a “collective failing”, not a
 failing of any individual.
 
 In many public conversations on the topic, the conversational dynamic shifted.
 The conversation was about the behavior of those being critical of
 software—not software itself failing the user. Maybe it was possible to
 criticize, or improve, software without being so fiery—without being so
 harsh. Maybe the Handmade community went too far. After all, sometimes
 “abstractions are good”, and sometimes “libraries are okay”, and
 sometimes “manual memory management should be avoided”, and sometimes one
 “shouldn’t write systems from scratch”, and sometimes people on a
 committee really do just try their best, and the result doesn’t turn out so
 well, and that’s okay. And besides, why be so fiery on social media? Why
 jeopardize employability, or friendships, or follower counts? Why not
 persistently affirm the work of others—irrespective of how you feel about
 it? After all, they spent so much time and effort on their work—that
 necessitates that it’s valuable. And really, what the Handmade community’s
 behavior reinforced was an ugly stereotype of game developers being assholes
 on the Internet. And you don’t want to be an asshole on the Internet, do
 you? How about you just sit down, shut up, and keep quiet?
 
 The degradation continued with attempts to rationally deconstruct the
 community’s core purpose itself. What did “Handmade” really mean? Surely
 it isn’t practical to write all systems from scratch. Surely manual memory
 management can’t be done well for everything, at least not if you’re any
 short of a programming demigod. Surely it’s wrong to look down upon the
 failures of software—they are a perfectly predictable consequence of nature,
 and the best one can hope for is incremental progress, and incremental
 progress is hard.
 
 As this shift in tone continued, the community nevertheless grew—but the new
 members didn’t have the same fire which characterized the original
 community. They had adopted the conceptual framing of the programming world at
 large. The rules of which I spoke were, yet again, rules. Following along with
 Handmade Hero was no longer a rite of passage for newcomers—after all,
 it’s over 600 episodes long, and who has time for that?! (and who has time
 for even the first 20 or 30?!) But even if it were shorter, it no longer was a
 useful embodiment of the community’s popular values. To the new community,
 it was too opinionated. It wasn’t nuanced enough. It wasn’t respectful of
 programmers writing most software. It was too harsh. At this point, the
 newcomers to the community were not “Handmade programmers”, and they still
 aren’t.
 
 With this shift came the extinguishing of the fire which drove the community
 in the first place—indeed, the fire—the frustration, the unapologetic
 standards—was that which produced the passion, the motivation, the drive to
 do better. When the community buckled under the critical pressure, it was
 defeated—every core value upon which the community was built became
 necessarily supported by a “sometimes”, or “maybe”, or “probably”.
 Engineers producing bad software couldn’t be blamed—it was structures and
 systems at fault. The community failed to gatekeep against those who disagreed
 with its premises, and as such was subject to a deluge of average Internet
 programmers. It ceded linguistic frame, ideological ground, and its base
 axioms to outsiders, and failed to defend itself on such ground. The
 community, preferring nominal growth over loyalty to its roots and conviction
 in its values, became akin to virtually all online programming
 communities—many community members parroting some of the same propaganda
 that the community once notoriously rejected.
 
 In ceding ideological territory to its opponents, in an effort to gatekeep
 less, and to create a wider umbrella under which more individuals could feel
 unoffended, the Handmade community made a critical error in misunderstanding
 the forces responsible for its creation.
 
 In 2018, I became responsible for a major portion of the formal Handmade
 community—known as Handmade Network, which began in the wake of the initial
 Handmade Hero series—and I adopt responsibility for this critical error. It
 is with years of reflection and thought that I write this, in hopes of
 capturing what I found my mistakes to be. I left as community lead of Handmade
 Network in 2022, and it was largely due to what I write about today, although
 such feelings didn’t easily manifest into words at the time.
 
 In adopting responsibility, I hope that what I’ve written thus far about the
 Handmade community is not seen as an attack on its future—but rather a
 diagnosis of its decay in the past, which I oversaw. The Handmade
 community’s story is not over, and I write this partly to defend its
 original history and roots, which—as I’ve written—has been denounced by
 many.
 
 The Handmade perspective arose—and was felt so strongly, by so
 many—because of a vision about what software could be like. It began as a
 look into the past—at how good software once was, and how programming once
 was—which fueled imagination about what computers might instead become in
 the future, if carefully guided. It even had a compelling story about how
 software might be carefully guided to produce that better future—and that
 story was rooted in love for the craft, not love of oneself.
 
 In other words, it was a vision about a goal; an ideal: an aesthetic ideal
 about what it meant to program, and what it meant to be a programmer. Handmade
 programmers were not egg-headed academics, but were competent
 engineers—familiar with their hardware, and their true, physical problems.
 They did not seek social acceptance, nor approval, if their product sucked and
 they knew it. In this ideal, programmers—if not designers
 themselves—understood the critical role of design. They did not busy
 themselves with abstract, academic problems, at least not as part of their
 day-to-day projects—they were concerned first and foremost with the machine
 code which would eventually execute on a user’s machine, and what effects
 that machine code would produce.
 
 They weren’t necessarily allergic to using someone else’s code, nor were
 they allergic to abstractions, but they understood both as a double-edged
 sword, with serious tradeoffs and implications, and thus used both extremely
 conservatively. They were responsible for code they shipped that ran on a
 user’s machine, period—whether they wrote it or not; as such, they
 rejected forests of dependencies, and built at least most of their software
 from scratch, in true Handmade fashion. They loved and cared about the result,
 and what it meant to the person using it—as such, they wanted the most
 productive and useful tools for the job, without compromising that end result.
 
 In short, the ideal was that the act of programming is for the product, not
 the programmer. Becoming a programmer meant becoming as effective as possible
 at the craft of producing the highest quality software, and nothing else. Many
 other ideals follow: high performance, reliability, flexibility, user-driven
 computational abilities, practical and grounded programming tooling, ethical
 software respecting the user’s time and choices, and beautiful visual design.
 
 In this ideal, if the software is bad, then it’s the software maker’s
 burden. Somebody is at fault—the engineering failure is somebody’s
 responsibility. The call to action is to empower oneself such that they might
 outcompete such failures, and build a simpler and more functional computing
 world, piece by piece.
 
 Understanding that this perspective is in fact ethical is crucial, because it
 distinguishes it from a set of logically derived propositions. Handmade ideas
 about software apply only within a particular ethical frame. Furthermore, that
 ethical frame is not universally agreed upon, nor can it be, because it’s
 not derived from scientific observation, nor logical analysis; it’s derived
 from aesthetics and values. It’s derived from what someone loves, not what
 someone rationally derives.
 
 The visceral response which saw the original Handmade community as toxic, or
 hostile, or dismissive was not a response to any logical proposition
 originally made—it was a response to the prioritization of the product over
 the programmer. Such a response came from a disagreement about what is defined
 as a burden, and on whom a burden is placed. The Handmade programmer believed
 in accepting personal responsibility, and providing something better—the
 culturally dominant trend in the programming world, however, was to collect a
 paycheck and abdicate responsibility for low-quality software. To such people,
 it is, in fact, the system and the process that is the problem (if there is a
 problem at all)—not any individual in particular. Such people are made
 inadequate by craftsmen who love their work—and so to them, Handmade was an
 ideological threat.
 
 This, importantly, is not a disagreement which can be resolved by hashing it
 out with rational debate; it arises at a deeper level, which can only manifest
 as some form or another of tribal conflict.
 
 The hostile arguments often seen on social media between Handmade-style
 programmers, or game developers more broadly, and—for instance—modern C++
 programmers, or web programmers, is not occurring within the often-referenced
 marketplace of ideas—the hypothetical space in which competing perspectives
 are solved through calm and rational debate provided a common goal—but
 instead in the marketplace of ideals, in which broad common ground ceases to
 exist.
 
 The Handmade view of software has ugly implications for programmers—if its
 premises are accepted, then it follows that: several large software projects
 to which individuals have dedicated careers are valueless wastes of time and
 energy; virtually every field of (at least) consumer-facing software has
 decayed dramatically in talent, in output, and in productivity; the $100,000
 college degree that everyone was required to obtain, and to accumulate debt
 for, was merely a signaling mechanism, rather than a certification of any
 technical ability; a huge swath of programming tutorials, programming books,
 and organizations are basically fooling themselves into believing they’re
 doing productive work, when in fact they’re shuffling around bits of memory
 for personal pleasure and gratification; some people who call themselves
 “programmers” are not doing programming; some people who do program should
 not be producing software for others; and plenty more.
 
 But none of that needs to matter. For some, it’s more important that they
 personally find themselves comfortable, and so they choose to prioritize the
 programmer over the product.
 
 Because Handmade programmers—among others who’d like to change the course
 of software for what they see as the better—are operating not in the
 marketplace of ideas, but rather the marketplace of ideals, it’s crucial
 that they understand that they’re not involved in rational debate, but the
 Internet equivalent of ideal-based tribal conflict. And indeed, this is why
 “technical discussions” about—say—programming languages are virtually
 never conducted nor won with technical arguments. Data is never collected,
 assertions are never scientifically justified, and promises to investigate
 further scientifically are conveniently delayed—permanently.
 
 But notice that arguments about technologies—presumably battling for
 adoption, social acceptance, and popularity—are not only empirically not
 about rationality, but definitionally cannot be about rationality. A beginner
 who knows nothing about programming cannot select an ecosystem or technology
 based on rational arguments, because they’re removed from the technical
 context which makes such arguments meaningful. They can only select by
 second-degree metrics of qualities they care for—popularity, what someone
 seems to produce with said technology, how quickly they produce it, the unique
 qualities of that production as opposed to those of others, and so on.
 
 In short, for those who want more prevalence of the “software craft”, in
 which responsible programmers are more akin to a homemade woodworker than a
 corporate slave, the battle over social dynamics and human motivation are
 paramount.
 
 In such a battle, there is much wisdom to be gained from Handmade Hero—its
 initial justification of itself was a value proposition, not a logical
 argument. Its community’s idols, its leaders, and its followers came across
 as dismissive and polarizing because they loved their craft, and because that
 was what was most important. That behavioral characteristic was responsible
 for motivating the community, and for promoting human action by those within
 the community. They wanted good software, and they knew how to make it, and if
 others wanted to produce crappy software, fine, but it was simply unacceptable
 for inadequacy to be the industry’s default.
 
 Therefore, there is in inextricable link between the fire, passion,
 inflammation—the “toxicity and dismissiveness”—and the prevalence of
 the values. The former is what drives the latter. To expect the latter to
 arise detached from the former is to ignore the true causal relationship
 between the two.
 
 Furthermore, the public fire, passion, and polarization is the most useful
 tool in promoting the value system. In acknowledging that the “software
 craftsman” perspective—the Handmade perspective—is not logically defined
 but ethically defined, it can assert itself aesthetically. It can loudly
 proclaim that there is a better way to make software, and it can loudly
 denounce the work of its opponents. In doing so, the Overton window about
 software is shifted. The average programmer becomes exposed to a wide variety
 of value systems, and of value frameworks about programming. As such, his null
 hypothesis about, for instance, libraries, one’s ability to write systems
 from scratch, one’s dependence on vast forests of middleware and abstraction
 layers, is changed.
 
 With the ethical system’s public presence, the default probability of
 certain courses of action change. Maybe it is better to write systems from
 scratch. Maybe operating with care as a responsible engineer produces not only
 much better, but much more fulfilling results. Maybe the world improves with
 such software. Maybe we improve, if we hold ourselves to that higher standard.
 
 Ethical systems win not by rational debate, but by hoisting their underlying
 aesthetic on a banner, and going to battle. Ethical systems which fail to step
 foot onto the battlefield are not winning by avoiding the “silly game” of
 tribal conflict—they are dying with their foolish believers, who mistook
 their cowardice for ascension above the human condition.
 
 In short, the side which thinks itself above the human condition—and indeed,
 the need for public struggle between ethical systems, and the need to loudly
 proclaim one’s aesthetics and goals—will lose to the side which is
 dedicated to victory, even if through tribal warfare.
 
 If you enjoyed this post, please consider subscribing. Thanks for reading.
 
 -Ryan
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════─────────────────────────────────────────────┘

--- #9 fediverse_boost/3376 ---
◀─╔══════════════════════[BOOST]═══════════════════════──────────────────────────╗
║ ┌────────────────────────────────────────────────────────────────────────────┐ ║
║ │ External post: https://tech.lgbt/users/gabrilend/statuses/111843564814825762 │ ║
║ └────────────────────────────────────────────────────────────────────────────┘ ║
╠─────────┐                                                            ┌───────────╣
║ similar │                       chronological                       │ different ║
╚═════════╧══════════════════════════════════════════──────────────────┴───────╝─▶

--- #10 fediverse/1171 ---
═══════════════════════════════════════════════────────────────────────────────────
 ┌───────────────────────────────────┐
 │ CW: silly-lobster-leviathang-gods │
 └───────────────────────────────────┘


 @user-878 
 
 if their internal structure does not become more complex, it will be
 increasingly difficult to transport vital nutrients from one part of the body
 to another.
 
 therefore, to create the perfect leviathan lobster god you'll need to find a
 way to manually deliver said nutrients. Possibly by a semi-permanent injection
 system, though that may harm functioning in other ways.
 
 I'm sure their top minds are working on this as we speak.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════───────────────────────────────────┘

--- #11 fediverse/267 ---
═══════════════════════════════════════════────────────────────────────────────────
 the unluckiest person in the world failed the most wisdom checks.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════───────────────────────────────────────┘

--- #12 fediverse/1181 ---
═══════════════════════════════════════════════────────────────────────────────────
 @user-171 
 
 Hi, I wanted to say that all the posts you boost significantly improve my time
 on the fediverse. I appreciate you and value you, and my feed is made more
 engaging due to  the things you find interesting enough to share. Thank you.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════───────────────────────────────────┘

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

--- #14 fediverse/989 ---
═══════════════════════════════════════════════────────────────────────────────────
 ┌──────────────────────┐
 │ CW: 3/20 swearing    │
 └──────────────────────┘


 3/20

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

--- #15 fediverse/3856 ---
═════════════════════════════════════════════════════════──────────────────────────
 I'm tired of working as hard as I can and still ending up wrong
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════─────────────────────────┘

--- #16 fediverse_boost/6207 ---
◀─╔════════════════════════════════[BOOST]═════════════════════════════════──────╗
║ ┌────────────────────────────────────────────────────────────────────────────┐ ║
║ │ External post: https://kolektiva.social/users/justbob/statuses/115226319741825396 │ ║
║ └────────────────────────────────────────────────────────────────────────────┘ ║
╠─────────┐                                                            ┌───────────╣
║ similar │                       chronological                       │ different ║
╚═════════╧════════════════════════════════════════════════════════════╧═──────╝─▶

--- #17 fediverse_boost/6099 ---
◀─╔═══════════════════════════════[BOOST]═════════════════════════════════───────╗
║ ┌────────────────────────────────────────────────────────────────────────────┐ ║
║ │ External post: https://hachyderm.io/users/marianoguerra/statuses/115366899548181326 │ ║
║ └────────────────────────────────────────────────────────────────────────────┘ ║
╠─────────┐                                                            ┌───────────╣
║ similar │                       chronological                       │ different ║
╚═════════╧════════════════════════════════════════════════════════════╧───────╝─▶

--- #18 fediverse/6047 ---
═══════════════════════════════════════════════════════════════════════════────────
 camouflage in an urban environment is not camo. rather, regular clothes of
 black or white.
 
 don't wear sports glasses, you look like a dummy.
 
 revolution is when they murder everyone but your friends. this is what
 happens, ya dingus not ideal. "okay who are the bad guys here? okay let's go
 shoot them to death with our bullets and guns."
 
 violence as a first aspect, cause as a third spark. "I have a strange urge to
 play video games?"
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════════════════════════───────┘

--- #19 fediverse/5988 ---
══════════════════════════════════════════════════════════════════════════─────────
 but I like moonmen T.T
 
 what if the ISS was untethered
 
 "send thrusters to space? why bother? just use them down on the surface to get
 that extra oomph!"
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════════════════════════────────┘

--- #20 messages/3 ---
───────────────────────────────────────────────────────────────────────────────────
  
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘─────────┴┴───────────────────────────────────────────────────────────────────────────┘