Windows 7 is such a piece of shit, part 1

So I have been using windows 7 at the moment after destroying my good computer. My god this thing is such an absolute piece of shit. One particularly bad part is the file search functionality. It is almost useless, absolute piece of crap, it is objectively worse than the search in pre-vista windows. What the fuck were they thinking, I can see no angle in which this could be considered any kind of improvement, its just shit.

There is a special spot reserved in hell for whichever fuckhead was responsible for this abomination, you know who you are, euthanize yourself right now.

Posted in Uncategorized | Leave a comment

C’s biggest mistake

Now C has taken much criticism over the years, and justly so, it has many faults. But there is one problem with the C standard which I think is far worse than all others, it has caused decades of pain and it still hurts to this day.

The FILE stream. This piece of shit can only be used with files. If they had just included but a single callback function, this thing could have been so useful. Streams are used everywhere in software and they are so useful, you can have the same code seamlessly operate on multiple sources of data, but in C we do not have that for the lack of a single function pointer.

I crave functional streams for C, one could of course make their own stream but that is totally incompatible with the rest of the C file libraries and also incompatible with other code that reads and writes files. Why has nobody even proposed to fix this travesty in all this time, the world shall be not but shit until this is corrected.

When I become leader of this world, I will of course correct this abomination. I will retroactively correct the C standard to implement proper streams, all existing software irregardless of age shall be corrected to reflect the change, all documents refereeing the original will be altered, and all historic records of this event will be expunged. In the future historians will never know of the travesty that was corrected.

 

Posted in Uncategorized | Leave a comment

C# is a complete piece of shit.

So today I attempted to use C#, my opinion of it has converged with my previous opinion all those years ago. C# is a complete piece of shit that sucks all the life out of coding. Doing anything in this language is an absolute chore. Its verbose to such a ridiculous degree, always whining over some minor thing.

The one thing that really triggered me is the complete inability to declare a simple array of constant struct data. Such a simple task, but in C# it requires such a ridiculous amount of extra syntax.

struct Test {
  public string x;
  public int y;
};

Test[] test = new Test[] {
  new Test { x="a", y=1 },
  new Test { x="b", y=2 }
};

What the fuck is this shit, why the fuck is everything so fucking verbose and hideous in C#, the whole language is like this. Coding in C# causes me physical pain. I converted an entire GUI application from C# to C++ because of shit like this, it just killed me to work with this language. C# does not even have macros, such a verbose language could have really done well with macros, but no. Piece of crap

Posted in Uncategorized | Leave a comment

Fuck Gutenberg, wordpress 4.x forever

WordPress 5.x is a piece of shit, its laggy and unusable. As with all software it will only get worse. I have decided to cut my losses and just host my own wordpress 4.x site. All future posts will only appear here, my wordpress.com site will never be updated again, fuck that shit.

Posted in Uncategorized | Leave a comment

When the standard is wrong

Ah standards, the dictatorship of a few cunts who have no real world experience defining how things should be done. Standards committees blunder forward making a huge mess that can never be fixed and we would have probably have been better off without them. At least with defacto standards the good prevails and the bad withers and dies, with formal standards the bad persists forever and nothing new can replace it without the say so of the few moldy old cunts who control said standard.

One thing which is even worse is when the standard takes something which already exists and redefines it differently, fucking up all that came before for no good reason except that in their dictatorship they are the ultimate authority and everyone else can fuck off.

Now what brought on this rant is the C function wprintf. This function was invented by Microsoft to support their UCS2 character set on windows NT. The format specifier for string was altered such that %s always matches the type of the output string, this allows the same code to be compiled as ansi or wide string facilitated by a few simple macros, the format string itself is the same in both cases.

When the c standard cunts finally woke up a decade later and decided to adopt this function, they did not take it as is, no they completely inverted the meaning of a fundamental part, the %s formatter. This made it basically 100% incompatible with windows, the system that created the fucking function. Fuck those pile of cunts,  you took a function you did not create and twisted it to serve your own purposes completely fucking up all windows code in the process.

Those responsible for this crime against all of computing deserve death by crucifixion, they really do. They had no right to redefine that function, it was already well established for a fucking decade, the change they made can not even be argued to be better, its strictly less functional than how Microsoft defined it. Fuck them I hope they die of cancer soon.

More information on the subject
https://devblogs.microsoft.com/oldnewthing/20190830-00/?p=102823

 

 

Posted in Uncategorized | Leave a comment

A quick thought on x86_64: part 1

There are some major design oversights with the x64 architecture one which is particularly painful is the lack of an absolute 64bit jump. To perform a 64bit jump on the x64 architecture one needs to use the indirect jump, this instruction and the 8 byte pointer in total comes to a nauseating 15 bytes.

It did not have to be this way. The instruction JMP ptr16:32, opcode $EA, is invalid in x64, that opcode could have been used for a absolute 64bit jump. But no its invalid, a wasted opcode, could have been extremely useful but it was not to be.

When I become leader of this world this will be corrected, all existing x64 cpus will be recalled, melted down, and then replaced with a period correct recreation the only difference being that the $EA opcode resolves to a 64bit jump. I will even have all the landfills exhumed such that not a single cpu can escape the correction. All documentation will then be altered such that no trace of the abomination can ever be found. Not a soul would be permitted to ever speak of this again on pain of torture.

Posted in Uncategorized | Leave a comment

GCC gets worse each version: part 2

So today I discovered another piece of brain damage from GCC. Seriously what the fuck is wrong with this compiler, its retardation exceeds all understanding, no human programmer could ever come up with such assembly, it would take effort to write something this bad.

This code is the consequence of overzealous and misapplied optimizations, GCC is always doing this shit and its a constant battle to deal with. My code has so much inline assembly to fix the broken optimizer. The macro “#define VARFIX(x)  asm(“” : “+r(x))“, is used extensively, it does nothing but trick the compiler into thinking the variable was changed. Its sad when hiding information from the compiler results in better code but that’s all par for the course with GCC the most retarded of all compilers.

The source code:
test code

GCC 9.3 output:
gcc 9.3 code

GCC 8.3 output:
gcc 8.3 code

 

 

 

Posted in Uncategorized | Leave a comment

C++ lambdas suck

C++ lambdas are a killer feature, its just a shame that they are too bloated to ever be used. I had so much hope for this feature, I was crushed when I saw the generated assembly. Seriously WTF, every single captured variable is done so by way of a separate pointer. You could capture everything using just a single pointer to the parent scope. What a lazy good for nothing excuse for an implementation, I am not sure if something in the C++ standard has steered the implementation to be this way but every compiler does this as far as I can tell.

Here is a comparison between the generated assembly for GCC C nested functions vs C++ lambdas, I think you should clearly be able to see why I am so angry. I don’t understand why anyone would think that this bullshit code is acceptable, it makes the the whole feature completely worthless.

Lambda test code:
lambda test

C++ Lambda assembly:
lambda-c++

GCC C Nested function equivalent:
nested function c

 

Posted in Uncategorized | Leave a comment

GCC gets worse each version: part 1

Each version of GCC is somehow worse than the last. The compiler does increasingly more retarded things each version. I have observed serious bugs which go unfixed for years, do they even test this shit?

Anyway onto today’s insanity. Current versions of GCC refuse to use XMM registers in 32bit for general purpose such as memory copy and filling. It used to work but in gcc8.1 for some inexplicable reason it stopped working. Using XMM registers for memcpy and memset is a huge improvement in both speed and code size, but for some reason apparently we can’t have that anymore in 32bits. FIX YOUR SHIT.

Posted in Uncategorized | Leave a comment

On the hidden improvements of NT6x: part 1

As a faithful user of NT5x it has become increasingly painful as much software has dropped support and requires vista or newer, hell even windows 7 support is waning now and I am still on xp/2k3. Anyway, over the years I have made various efforts to hack in newer apis such that I can run this newer software. I have never made much progress due to working on many projects at once and also the fact that I am a perfectionist. I can also never quite decided how to go about it so end up floundering around with a bunch of half implemented tests.

During my experiments I have discovered a number of ways in which NT5x is completely broken. The piece of brain damage I will discuss here today is one of several related to dynamically loaded libraries.

LoadLibrary:
When one would like to load a library at run-time, one can call this function. The specified module and all its dependencies will be loaded and a corresponding call to FreeLibrary will unload this module and any dependencies will also be unloaded if no longer needed. All nice a simple, there is just one major flaw in this system.

Export forwarders:
So a dll is able to forward an export onto another dll. This export forwarding has a number of performance advantages: 1. there needs be no thunks, the function pointer is fetched directly from the target dll. 2. The target dll is loaded on demand, if none of the forwarded functions are used then the target dll need not be loaded. There is one major problem with this mechanism however, dlls loaded by way of a forwarded export can never be unloaded, windows does not track these loads and has no way to determine when these dlls should be unloaded.

NT6x fix:
When a dll is unloaded its import table is walked and each dependent dll has its reference count decremented. Those dlls are then also unloaded if their ref-count drops to zero. This mechanism is completely incompatible with unloading of dlls loaded by forwarding so in vista a new mechanism was added to track just forwarder loaded dlls.

1. a new field was added to LDR_DATA_TABLE_ENTRY: ForwarderLinks
2. when a dll is loaded by fowarder the function
LdrpRecordForwarder(PLDR_DATA_TABLE_ENTRY LdrEntry,  PLDR_DATA_TABLE_ENTRY ldrTarget)
is called, this function inserts the target dll into the ForwarderLinks list
3. The ForwarderLinks list structure
struct ForwarderLinks_t { LIST_ENTRY list;
    PLDR_DATA_TABLE_ENTRY* target; int refCount; };
For each time the target dll is loaded LdrpRecordForwarder is called
and the ForwarderLinks list is inserted the first time, susequent times the refCount is incremented
The ref-count field is not really needed, it could have been implemented without a ref-count
But they decided to leave the existing call to LdrpLoadDll which always increments the dll ref-count
Allot of the changes made in vista feel very tacked on.
4. The LdrUnloadDll has been altered as necessary to make use of this new linked list to correctly unload this dll which where loaded by forwarded and are no-longer needed. Pretty simple fix, why on earth was this allowed to be broken like this for so long. It took them more then 10years to fix this since the first windows NT release.

 

Posted in Uncategorized | Leave a comment