Now

Transactions, that's what humans need to learn. Given that that's they who invented that.

Pet is a moron sometimes (most of, actually).

Probably broke shring for a couple days.

Meow.

How shitty that golang is.

It does not like

process_file(
    filename,
    template,
    true
)

It needs exactly

process_file(
    filename,
    template,
    true)

Yay, pet finished revising (again) Status at last.

Exception kind of Status sucked as a concept because the logic was weird. Pet separated it into Exception type, a subtype of Struct with Status as a mixin.

Updated MYAW passed tests.

Pet does not like this solution and considers it temporary. But it's okay for now because it's stable and more or less clear. It will be revised many times, probably.

Now, pet gets back to exceptions handling in PetMachine.

April 2026

Pet never liked RaspberryPi because of shitty hardware. Of course its pioneer role can't be diminished, but other teams quickly outperformed it and left far behind.

Pet would never get RPi intentionally, but it was donated a few and could not refuse.

Today pet tried to bring hostapd up on a RPi4. Pet has rich experience with cheap wifi, only a few work as access point. The only board where AP was not supported at all was OrangePi Zero. Pet thinks AllWInner forced them to buy that 819 crap along with H3 chips, that's the only explanation. And that was their only fuckup. The next one, Orange PI R1 had a decent wifi based on Realtek chip. Not mentioning modern boards where wifi works like a charm.

Well, what pet has got on RPi4? Here's what:

hostapd[1500]: Failed to set beacon parameters
wlan0: Could not connect to kernel driver
Interface initialization failed
wlan0: interface state COUNTRY_UPDATE->DISABLED
wlan0: AP-DISABLED
wlan0: Unable to setup interface.
wlan0: interface state DISABLED->DISABLED
wlan0: AP-DISABLED
wlan0: CTRL-EVENT-TERMINATING
hostapd_free_hapd_data: Interface wlan0 wasn't started

WTF? Pet glanced at search results and found a few people fixed that changing channel 11 to 6. Well, pet used channel 11 too and tried the same.

That did not help.

Okay, what's about rfkill?

ID TYPE      DEVICE      SOFT      HARD
0 bluetooth hci0     blocked unblocked
1 wlan      phy0     blocked unblocked

Arrgh, meow! Okay,

rfkill unblock wlan

And it worked! Even with channel 11.

But where to put this rfkill in this fucking systemd? Yes, pet should have moved to Void Linux but there's a lot of other urgent things to do besides licking balls which is mandatory.

Okay, let's customize the unit. First, copy it:

cp /lib/systemd/system/hostapd.service /etc/systemd/system/

Open it, and... Fuck! What the fuck?

Type=forking
ExecStart=/usr/sbin/hostapd -B -P /run/hostapd.pid $DAEMON_OPTS ${DAEMON_CONF}

Those Raspbian humans are in love with that fucking systemd for more than a decade and they still do not know in which hole they should insert their cocks?

Let's fix that:

Type=simple
ExecStart=/usr/sbin/hostapd $DAEMON_OPTS ${DAEMON_CONF}

And add what we need:

ExecStartPre=-/usr/sbin/rfkill unblock wlan

That's all, pets. Guess you know how to re-enable the unit. Reboot safely.

Pet is working on synchronization primitives.

Tasks are such primitives too: they are awaitable.

The implementation is a bit hacky at the moment, but Task and ChldTasks primitives can do without memory allocation at all.

Web rings are cool, but the way they are managed is devastating.

From pet's perspective this should be like this:

This way a user would always be able to make full circle.

Transactions, that's what humans need to learn. Given that that's they who invented that.

Revised Status type. Added kind field that clearly distinguishes simple statuses from exceptions.

Why not using subtypes?

Status type is special. When used in its simplest form (BaseError and SystemError kinds) it should do without memory allocation.

Meantime Status is a subype of Struct but memory is allocated only if its kind is Exception.

Subtyping is possible. Actually, MYAW does this already. Revised code should make it simpler, pet hopes.

Statuses of Exception kind can be chained. This is necessary for PetLang.

Pet gets back to PetMachine.

It's like a lizard brain that exposes human's nature, the remains of human brain make pet write smelly code without a reason.

It's damn hard to keep myself in paws and do things right.

Pet is in process of revising PetWay Status type. It's an interesting type, and pet almost forgot all its details. That's bad. Things must be simple. Pet's neural network will be improved only in the next life if pet will be in luck.

Okay, pet moved to Claws-Mail.

Pet went through all frustrations and configuration options and finally reconciled itself with the humans reality.

Pet managed to make it from fucking lame down to a bit lame, as all good free projects. After all, that's just a matter of taste.

Finally, RSS is a huge argument:

How comes thunderbird stuck and pet missed a few emails?

Pet is trying claws-mail.

Fucking gmail with its oauth. Nothing works. -- pet had to add self to users ot that oauth app. Fucking idiots. Including pet who's using crap from fucking idiots.

Humans drag pet to caves.

Fuck humans!

Basically, pet needs to setup redirect and forget about google for good.

Okay, selfhosting email again. Previous attempt did not work because... because... pet does not remember. Probably because of inability to setup a PTR record on a shitty VPS hosting. And thanks to one idiot who enabled PTR checking by default in opensmtpd.

Humans used to say selfhosted email works okay only with other selfhosted servers.

Fuck, no!

Even gmail is not this restrictive. Yes, messages fall to spam folder but they aren't bounced.

Email is dead, actually. For pet, at least.

Pet is happy to know via https://baccyflap.com/ that Android will become a locked-down platform in 130 days.

Pet always wanted to dive into mobile development but it was too busy (with you know what) or, honestly, lazy.

Maybe that's good? Why fight for crap? All pet needs is an LTE modem attached to some Nano/Orange Pi Zero and a WiFi terminal based on something pet is able to reflash.

Humans go back to caves!

Pet is working on PetMachine.

Two stacks, as in Forth, multiple tasks, the logic is pretty simple.

But the major difference is hierarchial structure of tasks. Initially this was inspired by https://vorpus.org/blog/notes-on-structured-concurrency-or-go-statement-considered-harmful/ but nurseries look weird. Not because the concept is bad, no. They are weird because of one implicit thing: blocking on context exit.

Yes, that looks the only point that makes a good idea weird.

Nobody is against a process tree concept, right? But what if a parent process would implicitly block awaiting termination of all children?

That would be weirdest thing humans ever invented.

Processes have SIGCHILD. Trio has error propagation.

Pet borrows these two ideas: hierarchy and error propagation. Pet rejects nurseries.

Having parent-child relationships, rules are simple for tasks:

If an exception from a child may arrive at any time, this is troublesome. Consider the following example (yes, this is PetLang syntax with objective description after try):

try "Start all necessary tasks"
{
    create_task(START_NOW, ...)
    create_task(START_LATER, ...)
}
except TaskException {
    // WTF ???
}

try "Doing our own job"
{
    while (true) {
        // ...
    }
}
except TaskException {
    // ignore, re-raise, print, whatever
}

The problem with this code is that a TaskException may occur between except TaskException and try "Doing our own job". How to handle them correctly?

A solution could be similar to signals: disable_exceptions and enable_exceptions, but pet thinks that's cumbersome and error prone.

Pet's solution:

Well, that's too implicit, but that's what Pet would expect from a code like this:

task_1 = create_task(START_NOW, ...);
task_2 = create_task(START_LATER, ...);

// exceptions from children aren't propagated yet

try "Doing our own job" {

    // here's the point where exceptions from children may emerge

    while (true) {
        // ...
    }
} except TaskException {
    // ignore, re-raise, print, whatever
}

Also, propagation should be disabled in exception handlers, i.e. in except and finally blocks.

Pet is playing with Void Linux.

Pet loves it!

It seems pet will meow "Farewell, Devuan" very soon.

It seems peTux is not necessary for now.

Whatever pet tries to implement it runs into the lack of coroutines in C.

Humans would say use C++.

No. Pet does not want to step into this.

Go, with all its flaws, is simply great when it's about goroutines. No function coloring with async, everything is plain and simple: go.

This is at the expence of implementing their own code generator.

Pet can't afford that. Pet needs a simpler solution.

Forth, the greatest language with the ugliest syntax gave pet a hint: threaded code.

Well, not exactly threaded, but what if a function would be a sequence of bool (*func)() pointers? It would need a machine to execute, but that would not be an exact virtual machine because it would deal with addresses, not opcodes. Each function would represent a noninterruptible piece and could be implemented in C.

Pet gets down to the PetLang spec.

Pet just thought: each humans' attempt to create a social network breaks against their sins. Basically, on the one hand primates tend to hierarchies and the client-server model perfectly reflects that. But on the other hand, as "The Pastor is The Shepherd of God's Flock", clients are just a flock.

Can pets form a flock? Don't make pet laugh.

No matter who creates a social network following this model, they are doomed.

Federation could be a rescue but that did not help humans. They found de-federation wars is a perfect entertainment. That model is not acceptable for pets.

So what's then?

Anarchy, obviously.

Pet thinks it should add an RSS in its site generator.

Pet is now happy Deluge user.

Before