actually no i made it the fuck up

@AlgoRythm Absolutely. The meat of the argument is that we were already at a point where those genuine bits were already fairly obscure, and so the slopstorm only really serves to accelerate this; it's not a *new* problem per se but a serious aggravation of an existing one.

Essentially, it's an optimistic take: that if every mainstream space is to be irrevocably flooded by bland garbage, algorithmically generated or not, then what little remains authentic may thrive on a more intimate dimention, as opposed to the situation becoming exponentially worse ad infinitum until there's no humanity left.

I am inclined to agree with the optimism in this case simply because "human" (and whichever quasi-transcendental quality we ascribe to it) is still very much what people are actually looking for both in art and on a social context. I do not see evidence of this having changed at all, for if it had, discussions like this wouldn't be happening to begin with.

I've seen people make a similar argument regarding things like writing, music, visual art, et cetera.

It goes a bit like this: there already was a staggering number of human-made, yet soul-less, mass-produced content [*] that's virtually indistinguishable from AI slop; stuff to which there isn't truly a point to beyond gathering attention for a purely monetary purpose.

That is done for. But it's not the end of artistic expression any more than it is the end of socializing. The business model is dead, that's all, but the reason for which said model was ever established in the first place -- a human need -- has not disappeared, and will never do.

We are essentially starved for authenticity. So we'll go back to that, as we should've done over a decade ago when all of this started. Well, better late than never.

[*]: Addendum, referring to __art__ through insipid terms such as "content" is very much the epitome of enshittification.

@D-4got10-01 STAY A WHILE AND LISTEN

@retoor sorry but i am become the policia. you is retoori under arrest now.

you ++'d your own rant didntcha.

*checks whimsicals profile*

yes you did. once at least.

that's illegul.-~

@princess Sadly, I haven't yet implemented enough of this to run any meaningful tests. I am confident that the best shot at mitigating chances of incoherent relationships getting established would be simply narrowing down choices at each step in accordance to the context, as in:

- The type of scene depicted and it's purpose. This is akin to a class of situation, if you will. This would set the initial constraints on what actions may be taken.

- Current environment, and the position and surroundings of each actor within it.

- Similarly, an actor's attributes and personalities would serve to limit their choices as well.

The dataset we process would have to be a well-written series of such scenes (a series of *timelines*, as discussed in the original post), so that the "temperament -> situation -> action" chain of associations can be more easily derived from there.

But we'll see. I still need to write a LOT more code before I can be entirely sure of _anything_.

@princess I've done some prototyping and came to the conclusion that there is a simple way to establish some meaningful initial relationships. See the declaration of a sigil:

```pseudo

sigil Damage:

refs:

· die=d4.

· bonus=src->hatred->total.

· dst=tgt->HP->total.

proc:

· sub dst, stdrol.

· ret.

```

Where stdrol is just die+bonus.

Here, we reference two attributes in the implementation. Because those attributes are themselves sigils (same class), some base relationships can be established right away at compile time.

There could also be a second step. Given a large set of handmade signa (sequences of sigils), each signa associated with a particular intention (a class of action, so to speak), we could find additional relationships by processing said set via hand written rules. However, a small neural net could be useful here too, so I'm considering that idea as well. I believe a hybrid approach would yield better results, but I need to test it to be sure.

@D-4got10-01 lmaoooo, here I was trying to be intellectual and shit but it turns out I can't even count c:

b-but but...

it GIVES GOOD MEDITAAAAAAAATIONNNN https://youtube.com/watch/...

plusplus for funni and abstract plusplus for fellow SWAN.

@BordedDev I need to do a bit more work before it's fully functional, but see here (https://github.com/Liebranca/...) and here (https://github.com/Liebranca/...). [DEVILSPEAK ABOUND, SHIELD YOUR EYES].

The video is just a scholarly essay delving more into theoretical and even quasi-metaphysical phenomena; it can give you a better perspective on the philosophy of development but it's not a mandatory view.

@Reepeli Oh, you got me!

Automatic syntax-checking of the perl code generated by the macros is possible, since it's just a bunch of subroutines and a custom import/unimport, but errors arising from macro output is going to be tricky.

The way avtomat builds a project goes a bit like this, for each file: [0] apply preprocessing/code generation, [1] syntax-check the output, [2] write output to build directory, _then_ [3] run the actual compilation. At each step we throw on failure; there's futher steps to handle linking, and also pre/post build hooks, but nevermind that for now.

I still need to fully integrate this new preprocessor to the rest of the build system (I still need to fix the build system also...), but anyway `gcc -fsyntax-only` would be looking at a pure C file at step [1] so that's where I can maybe try and catch bad generation. I need to reimplement the parser first however so that may take a while.

Holdup~. Shitposting is art ok, all the experts agree on this. Recent studies show that governments *should* fund and empower b2plane's asshole for the advancement of mankind.

@whimsical here i teach you software engerninren:

clang-tidy fixmyshit

doesn't substract money from my account every time i run it. wow. such technology. much sillicon.

@whimsical i shurg; can do the same without integrated decepticon in vim. faster too.

@whimsical bruh. we have VIM at home lmao.

@whimsical you need advanced decepticon system on datacenter miningrack to copy paste implementation?

education free/libre in cosmopolitan republic of gnuya; not a single binary blob. i have spent zero babylonian shekel per year in machine code golfing studies, save cost of khubzuzaatar plus electrical bill. now using elder magus power to raise the dead and evade taxes.

inb4 retoori says prediction engine good after spending 700~ euro per year in subscription.

@D-4got10-01 i too practice the fobidden art of counting inodes~

holdup now im curious.

```wat

TEMP := SRC1;

MASK := SRC2;

DEST := 0 ;

m := 0, k := 0;

DO WHILE m < OperandSize

· · IF MASK[ m] = 1 THEN

· · · · DEST[ k] := TEMP[ m];

· · · · k := k+ 1;

· · FI

· · m := m+ 1;

OD

```

(^pseudo from https://felixcloutier.com/x86/pext/)

say you write a branchless version of that, just straight up pasting the same block with a rept to unroll the loop. and to keep it simple lets say we're not actually benchmarking, just going by the ops/latency found in uncle agner's tables (https://agner.org/optimize/...).

just how much faster can it be? its a stupid problem and a very good one.

shill detected; remove hypercopium in progress.

@BordedDev why would you parse solely with regexes are you on crack.

im parsing C files solely with regexes.

reason why is im embedding perl subroutines in C files to use perl as a C preprocessor. yes.

nothing out of this world actually, i just wanted to concatenate `typeof` and then remembered that doesnt work. thats just so stupid. fixed with black magic:

```C

macro typename(expr) {

· · my $have=(exists $CSCOPE->{local}->{$expr}) \

· · · · ? $CSCOPE->{local}->{$expr} \

· · · · : $CSCOPE->{global}->{$expr} \

· · · · ;

· · throw "Undefined symbol $expr" \

· · if ! defined $have;

· · return $have->{name};

};

macro ref(args) {

· · my $cpy=$args->[0];

· · my $type=derefof typename $args->[0];

· · return $type->{name}_deref($cpy);

};

```

wee now i can call variation of function based on type of first argument. can invoke ref macro as ref var or ref(var) because fuck the police.

anyway i lost my train of thought halfway through.

@stackodev just let crack do the talking qr{(?<blk>(?<rec>\{([^\{\}]+|(?&rec))+\};?)+){1}}s;

you see that? _that_ is your brain on drugs. it's genius, but only if you're high on the good shit. a sober brain can hardly grasp, much less produce things like these.

also first to understand what devilspeak regex does gets special prize maybe.

By letters.

[S, O and I]: There is merit to having a base/generic implementation of some struct or functionality, then writing each specialization of it separately. This gives you granularity, in that you only have to include the bits you're actually going to use. In some cases this can speed up build times a lot as simply put you'll usually wind up with less symbols per file.

[L]: If the first field of struct B is an instance of struct A, then yes, ((A ptr) B) is a valid cast. The type theory word salad is very much redundant in this case, the property in question is mere common sense.

[D]: Making it so one module isn't dependent on the implementation _details_ of another is sound advice.

In conclusion, these ideas have validity and practical application, yet there is a special place in hell for Uncle Bob nonetheless.

@TerriToniAX I was precisely considering a Ducky One something as most people seem to agree they are good.

Most models I've seen don't have a numpad, though. I can live with that, but it's bit of a shame. I like using those keys for bindings, they're perfect for it as I never hit them accidentally, given that they're so out of the way when I type.

I dunno, I grew up on an IBM replica (model M2 I think it was? it had the winkey so must be something else) and fucking Turbo Assembler. For reference, I was born in 1994 lmao. But anyway I have way over two decades of muscle memory on that layout, I can't just change to a different one, but for the last five-six years I've had to compromise as models try to get inventive with it, just moving keys around to fuck with me.

"It is more compact!" yeah and it fucking ruins my life, thank you very much smh. That is not directed at anyone in particular just the embodiment of keyboard manufacturers.

implement typing for perl lmao.

next thing he knew executive was breaking chalice. https://youtube.com/watch/...

@atheist that no funi ( o ` _ ´ o )

@tamagotchi adjective: inextricable

· · impossible to disentangle or separate.

You is too much AI and too little dictionary maybe.