smallstepforman

NSA is west …

I wish it was 20-30 minutes. Try 2-3 hours.

Yet the average software engineer hasn’t heard or Carl Hewitt, Joe Armstrong, has never programmed in an Actor Programming model, and dont even know what it is.

The thing about custom engines is that by the time it supports all the features you need, you’ve worked your mindset into optimal engine usage, so you end up being more performant on a hacked engine vs suboptimal code on commercial engine. Home grown always has some unique flavour.

The rushed clinical trials were only done with 122 people and a control group. During the very short trial, 1 person died in the first group, 2 in the other. The “conclusion” was its better to be vaccinated and it protects you better. 12 months later AstraZenica vaccine pulled from market everywhere ….

Doormen keep vagrants away and prevent dirty things from accumulating in front of the venue. Plus the social benefits of interaction. It is a cost but offers not immediately obvious benefits.

Mate, you have to revise your stance on Russia, more people are imprisoned annually in the UK for speaking than people in Russia in a decade. The UK banned RT while you can access any western propaganda outpost from within Russia.

You’re on Hacker News, this website is known for attracting open minded free thinkers that do not fall under the influence of government financed propaganda. Learn and reassess your thoughts.

Today I asked Gemini to extract a table from an PDF appendix and create C++ data table with its contents. After 15 or so iterations with corrections and new mistakes, it eventually gave up. I was floored when it said “I’m sorry, I cannot do this simple task, I’ve exceeded my error threshold and cannot do this task for you. My LLM prediction engine invents data instead of doing a simple data copy/reformat”.

Stunned to see that Gemini threw its digital arms in the air and gave up.

This is insane. So I need to work 5 years on site in Germany as a contractor being paid by foreign parent company, why should the company be liable to be registered and pay taxes in germany. Eg Microsoft sends tech to fix Azure system fir Mercedes.

New platforms were 68000, old platforms with legacy code just wanted access to more memory, so 8086 segments allowed 64kb chunks. A hack only usable by folks that still wanted to run their old 64kb programs.

It would be a piece of trivia today if motorola were not 6 months late which forced IBM in frustration to change tracks to Intel and MS DOS instead (which worked on 8086). That 6 month drlay created WinTel of today.

My mistake. I remember reading the C= book “on the edge” and there was a chapter about how 3 chip designers at motorola couldnt get management to pursue low cost version of 6800, so they made 6502 in a startup called MOS in 1975.

While I’m on alternative histories, if Jack Tramiel didn’t piss off Chuck Peddle, it would be MOS/C= in Intels pisition today.

The 6809 (and its clone the 6502) would also be strong contendors. And if Motorola were 6 months faster with the successor 68000 compared to Intels 8086, the IBM PC would be 68000 based and Intel would today be known as a memory chip company. We’d be big endian with no legacy in 2026 of segmented memory architecture in mainstream processors. And with big 3 companies using 68000 (IBM, Apple and C=), we definately wouldnt have WinTel.

The driver switched to lower mipmapped texture and got caught. There is a ton of that out there for popular benchmark ready games. Run pro drivers instead of adrenaline to run generic baseline real driver.

Half the compute and reduce memory by factor of x4 and in a decade we’ll have double the performance we have now.

I do old school embedded, the amount of desktop bloat is insane. Any function I really need to refactor, I can reduce size and improve performance. And there are better engineers out there that are more efficient than me.

Find an itch, then scratch it. If many people have the same itch and can use your solution, you win.

Simple as that.

The GPU loves arrays of structures AoS, since all vertex data fits in its triangle assembly cache. Once given to the GPU, the software side doesnt really care for all vertex parameters so this optimisation is pointless. Only relavent when you have instance rendering (leaves, grass) but then you only need an array of vec3’s, not the other parameters so back to normal arrays.

Meanwhile, game engines need operator overloading for adding/multiplying vectors (spatial transforms, lighting, physics) and core zig design philosophy prevents operator overloading.

Blind leading the blind. Disclaimer - I do professional rendering engines.

I had a C++ actor model which required an Api like the following (std::function):

child->Async(&ChildActor::Method, child, args);

Refactored it to use small buffer optimisation and std::move_only_function)

child<&ChildActor::Method>(args);

And saw a performance jump since no more malloc in std::function.

It also helped me decipher an animation bug in gtlf importer.

Productivity is x4 or higher.

The other day I just wanted to loop through characters in a std::string to copy data to a new string with a few escape characters (sending to peripheral device). Simple enough task for AI. I got a coroutine monstrocity back, with copies to std::array and a range based iterator, since I specified C++23. If I specified C++11, I would have received a: char p = src.data(); while (p) { … p++; }

I had the experience to keep calling out AI to simplify and downgrade the solution to something primitive, which ended up smaller, faster, easier to maintain. Juniors with real world experience would not bother, they’ll take the first working AI result.

BeOS API is based on pixel centers, not that anyone cares anymore …

In non free countries it wont show up since the ISP will block the domain (eg. Oz). Free countries show it …

c++ uses rich type system to avoid aliasing when it can, as well as template meta programming.

Eg: delete_scene(void *arg) vs delete_scene<T>(T *arg)

Linux is just the kernel, the ecosystem is make up of half a dozen desktop managers, windowing systems, API toolkits, sound servers, file systems, package hits etc. There is an abstraction layer between all these systems. Multiuser, whether you need it or not.

Haiku is a unified system, so native apps have one windowing system, one desktop environment, one API, one media kit, one file system etc. There are less layers for data to travel, hence it will always be faster. Also Haiku targets desktop users (single user system, for better or worse), while Linux in all honesty targets servers and embedded with desktop a distant 3rd use case. Haiku package management is a generation ahead of Linux.

Finally, BeOS/Haiku core architecture is built from modern 90's designs, while Linux started as a clone of Unix (deep in the bowels of Linux there is a TTY terminal block device).

Finally, BeOS had a cool factor (and their fanboys) that Linux never had. Dual CPU from day #1. Blinkenlights. Geek port. Playing videos on a face of a cube. is_computer_on(). Linux is sooo boring in comparison.

Test the API kernel calling convention when dealing with 64 bit IEE754 doubles on a 32 bit CPU, especially when dealing with MSB vs LSB processors.

Also, a long time ago (pre 486DX), processors did not have FPU circuitry instead it was a FPU coprocessor. When dealing with a kernel context switch, you'd have to copy all registers to a stack. With a coprocessor, you'd have to make sure those registers got copied as well. Which was slower with coprocessors ... So for a time some real time kernels did not allow context switching of FPU. To support that, you'd get the performance hit.

These days its all integrated so you dont have to worry about it ...

Well, they could have had BeOS instead of NeXTStep.

No mention of 601, BT709, BT2020, BT2100 etc. He did mention the P and D profiles. Unorm vs linear.

There is always a historic reason for a colour profile, sadly most software avoids terminology like the plague.

That was a PPC603/604 limitation if you wanted multi CPU’s.

Ref counting is for ownership, it doesnt convey intent. It kind of accidently works but is the wrong abstraction, especially in code bases where ownership is known.

This is all well and dandy for some usage scenarios but breaks in others, eg. scene graphs and GUI's.

A scene graph needs 2 mutable references, and has nothing to do with ownership. Same issue exists with GUI's. The pattern that Rust forces is to always request a reference, which incurs a performance penalty while retrieving the same reference again and again and again.

We humans cannot scan 100’000 articles looking for the golden nugget, the AI data mining can do it and present it in seconds. Obviously we need to verify the data.

A couple of decades ago, we didnt trust compilers, we did assembly manually. Today is same barrier, some developers will explode with productivity while others will be left behind.