Sometimes, when I think I'm going crazy, I open devrant and realize that I'm still very far from MadMen / YouAllSuck / AvatarOfKaine.

So we have an API that my team is supposed send messages to in a fire and forget kind of style.

We are dependent on it. If it fails there is some annoying manual labor involved to clean that mess up. (If it even can be cleaned up, as sometimes it is also time-sensitive.)

Yet once in a while, that endpoint just crashes by letting the request vanish. No response, no error, nothing, it is just gone.

Digging through the log files of that API nothing pops up. Yet then I realize the size of the log files. About ~30GB on good old plain text log files.

It turns out that that API has taken the LOG EVERYTHING approach so much too heart that it logs to the point of its own death.

Is circular logging such a bleeding edge technology? It's not like there are external solutions for it like loggly or kibana. But oh, one might have to pay for them. Just dump it to the disk :/

This is again a combination of developers thinking "I don't need to care about space! It's cheap!" and managers thinking "100 GB should be enough for that server cluster. Let's restrict its HDD to 100GB, save some money!"

And then, here I stand trying to keep my sanity :/

Is just me or being a developer has become a complete nightmare?
I mean, I never expected when I got into it to have a simple life in the first place, it's a fucking problems solving job.
But heck, I'm in the field from more than 12 years and something has definitely changed for the worse. Believe me I am just seeking for a general consensus not approval or anything, but it doesn't feel anything like 10 years ago.

I have worked with .NET mostly in all his sauces from aspx, wpf, up to today .NET 10 and C#13 and in the meanwhile it happened that I needed to do tech assistance, code in exoteric shit, use arduinos and raspberries, use perl, java, turn into full stack with databases, devops and shit.

Each year it's worse, the "developer" word gets more and more blurred word to say "the one who must know everything".
I'm asked to know docker, kubernetes, kafka, CI/CD and devop shit, web dev, to get ertifications, to learn how AI works to the level of learning again matht to do matrix interpolations, to get on data science, python, numpy, pandas, pytorch and shit, to know every OS, to know about networking because APIs now have to use rest, a single verb for every action, because if routers and new communication protocols break you have to know and figure out why.

Not to mention that marketing and sales guy shove up the big customers ass every new tecnology to make our work look like bling-a-ling top notch 1% developer stuff that always use latest bleeding edge technology and you're forced to learn new immature frameworks every 2 months or so (latest being various javascript/typescript diagramming libraries).

Every idiot feels entitled to puke out a new framework or supersets of existing languages. I lost count how many supersets css has that I had to peek and learn lol.

Every fucking simple software I did from scratch and designed by myself, web portals for big pharma were much simple than whatever PM i get assigned to are and guess what, I published it and fixed ofc some bugs, but most bugs are related to customer unstable datasets and well, I never had bugs after the first few weeks, except once every few months and nothing serious.

The fucking things they let me do now are hypercomplicated and I spend days fixing other people bugs and we get some hair pulling structural problems becuase they shove in all they can (mediator patterns are a must): kafka, docker, messagebus, whatever javascript clusterfuck they can, patchworks of html and css blurred out in layers of hierarchical scss or sass, slapped into angular (the most immature and crappy shit in js) that has all of his hidden ways to bury and hide DOM (ng-deep: anyone? :host anyone?).

And it's all like this. Whenever I put hands everyone wants to do his little frankeinstein experiment cooking togheter in a cauldron a shit ton of different stuff, overcomplicated patterns.

it's a challenge at shooting flies with bazookas.

I'm really tired of technology at all, not only for my jobs. This fucking trend is a plague spread everywhere and now, since everyone has to deal with it, everything is unstable.

In my daily usage of a smartphone app crashes a lot or have weird troubles, slowness, websites are pretending to be full blown app with this shitty SPA trend and are filled with bugs and incompatibilites.

Basically every tech tool we use is 100% more prone to bugs than 10 years ago.I'm really thinking to find a simple job like baker or shit and get an old phone that just can call and send SMS.
I need to get out of tech for a few years to get back my sanity.

This is not a problem-solving job anymore.
10 years ago I needed to study too but once I got the tools in my hands the job was fun, you got a magic wrench and sky was the limit.

Now you got to fucking learn a ton of bullshit everyday and it's not like you see a end on it, everyday people push out new unstable and bugged shit waiting for devs to be guinea pigs for them. You gotta learn a ton of stuff of which 3/4 will be useless/obsolete/broken and considered inefficient the next month.

jeeeeeez

Consider,

```
namespace A;

macro m00 a,b;
··display a,b;
end macro;

macro m01 a;
··m00 a,$0A;
end macro;

m01 $24;
end namespace;
```
OUT: $0A24 ("$\n").

Ah, but you just HAD to fuck me in the ass, didncha fasm2? Initializing anal bleeding:

```
namespace B;
A.m01 $24;
end namespace;
```
OUT: illegal instruction 'm00'.

Explanation: macros carry no context, and so 'm00' is unreachable from 'B' namespace.

Could I maybe write a code-capture macro to generate a wrapper that resets the namespace? Yes, and in fact, I did; brilliant exercise in mystical mindfuckery.

But why try so hard? Just pass the fucking ref, like a MAN.
EXPLICIT CTX, BITCH.

```
define @CAS $non; current addressing space
define %ICE @CAS;

macro self:PA&; recursive macro, uuuh spooky-spooky
··match ice , %ICE;

····; self->proc(args)
····match =-=> proc (args) , PA;
······path.proc ice,args; pass ref and args

····; ^self->proc()
····else match =-=> proc () , PA;
······path.proc ice; pass ref only

····; ^sneaky sneaky. set current context when self ctx;
····else match cas , @CAS;
······%ICE equ cas.PA;

····end match;

··end match;
end macro;
```

ALL TOGETHER NOW
```
namespace A;

macro m00 ice,a,b;
··display a,b;
end macro;

macro m01 ice,a;
··self->m00(a,$0A); could also be 'ice.m00 ice,a,$0A' lmao
end macro;

end namespace;

namespace B;

self A; set ice
self->m01($24);
restore %ICE; back to previous

end namespace;
```

OUT: $0A24 ("$\n").

A-há, now **I** got you from behind motherfucker!

Final note: this is 100% perl DNA seeping through the cracks of my sanity and into a fresh fasm2 framework. Why? Dingle-dongle-jungle-berries, that's why. Also crack.

Have a nice wallop.