glouwbug

[delayed]

A great combo that was with Ned Stark too

Was great in Oblivion. RIP

Everything is cyclical. Maybe they come back when AI gets heavily regulated or pay gated. Who knows

I think once the funding dries up the finger pointing of who stole first, or who stole at all, will start. We know, for instance, Meta trained on Libgen

Server side asset decryption? Once it’s in memory I don’t know what’s stopping anyone from running with the assets too

At 8mhz? I'd imagine it rivals at least the Pentium III

_Load bearing intensifies_

But why were they reverted?

Did someone not understand what went in? Might someone have offloaded their thinking to some external tool? Did people stop caring? Did someone not plan or design a feature in full? Were the timelines unrealistic? Maybe with so many reverts timelines should be revised?

I wonder

Pharaoh vibes

    #define breakpoint(…) printf(__VA_ARGS__), getchar()

Instead?

Interrogation is great, you can even get people to confess to things they didn't even do (from IASIP or something like that)

Feels like AI is just exposing what was always glorified software-configuration

My wife for hire

I suppose that depends on tooling as well, and the user. Two scenarios:

1. Throw your entire 200k SLOC codebase in and ask for a bug fix.

2. Tokenize your codebase (AST -> SQLite) and have the LLM explore and reason about subgraphs, and then ask for a bug fix.

One takes expertise but yields a better signal to noise ratio. Though, at that level of expertise one encounters what’s effectively the library of babel: you get back what you write and / or already know, and coherent text outlining future events might be wrong until they transpire

Plan 9 inheritance is really nice. You can still use it with `gcc -fplan9-extensions`. It builds some nice polymorphic workflow an array of tagged enum void pointers

I think it was just a matter of speech. 20-30% doesn’t matter because such a planet doesn’t exist. It’s probably bigger, and so OP has a point

I always champion Bisqwit too

We have this same point made every release. I wonder if models actually are getting better or if these companies are just secretly hamstringing the previous models before releasing a similarly performing model

C3 is very good

Because in practice it’s really hard to not succumb to C++ feature creep. You start with good intentions and limit yourself to namespaces and structs, but then the “this will benefit from a vector, or this from a map” appears, then you realize you’d like a templated use case, and a single raw pointer or resource handle from a call to something like fopen() suddenly is not releasing its resource on a linked list pop and now you’re writing move semantics on top of copy semantics because a destructor declaration silently enforces copies on a std::move without move semantics. You reach for a unique pointer and, and all of a sudden, you have most of modern C++ without a single virtual call.

So people obsess over C because you’re hard limited by the upper feature bound. And that’s not so bad because C gets feature updates too - microscopic but effective feature updates; see C29 for the poor man’s RAII: defer

Feels so long ago the way you write about it, but 22 years ago was basically 2005

This is good shit

AI excels at this because it can work at the function level to brute force decomp to C with void* fiascos and keep trialing and erroring until the compiled md5sum matches the original binary’s. The resulting source will be unreadable and unmaintainable but at least compiler and platform agnostic.

Humans are still better at this given time. Check out sm64’s decomp quality

Bisqwit is there too

I wonder if the sea people were just displaced-farmers-turned-raiders that created some open loop feedback that in turn spawned more sea people in self defence or self survival.

The mythological idea of them just appearing out of nowhere is nice too. Makes it feel aligned with something like the pyramids having no explanation

Of course its unfair. You're competing against students

Wouldn't engineering then be the safest place to be? Engineers have always been embedding loose requirements into runtime law. They (supposedly) understand the business model better than most and have the technical know how to validate that

When you write something you constantly remodel your understanding through refactors and rewrites until you internalize it. By internalizing it you gain the capacity to reason about it (during critical downtime) and communicate it. An entire team that can communicate can solve problems together, from one guy's vision to products white boarding to engineering's infrastructure to UX and UI's artistry.

It boggles me we completely forgot that the world operated like this just 4 years ago

That, and it frees the compiler from reasoning about virtual inlining, and that the std::variant approach can pack potentially more than one object into a single cacheline. TLBs also work with 4096 byte pages, so 32 polymorphic 128 byte entities may (at the absolute worst case) use 32 distinct pages which requires 32 TLB virtual translations, while the std::variant one uses 1.

The next step of going SOA benefits from all of the above, it just further unlocks you packed quad and oct instructions (AVX256 and 512 depending if you buy AMD or not).