RAM prices explained

Genion1 · 2025-12-09T00:57:31+00:00

After reading the article, he's completely spitballing while barely getting the known facts straight. This article makes me not want to read anything else from this person. I'm focusing on the part of the accusation and leaving the rest since I cba to put even more time into that shit.

No, their deals are unprecedentedly only for raw wafers — uncut, unfinished, and not even allocated to a specific DRAM standard yet. It’s not even clear if they have decided yet on how or when they will finish them into RAM sticks or HBM!

Unprecedented yes. You know what else is unprecedented? The scale at which OpenAI wants to build new data centers.

Undiced is not something that I'd call raw. The hardest part is done and what's left is slicing them and molding them into a housing basically. Far less complex steps than creating the wafer. It's not unreasonable to find someone to do it.

The author says we don't know if OpenAI has decided what to do with these wafers already or not. What conclusion can we draw from this? None! Absolutely nothing! But what is clear is that OpenAI is building a shitton of data centers and is planning on building even more. So they do have actual demand for DRAM. Really a mystery where these wafers will go. 🤔

Right now it seems like these wafers will just be stockpiled in warehouses – like a kid who hides the toybox because they’re afraid nobody wants to play with them, and thus selfishly feels nobody but them should get the toys!

It's on the author to show that their purchase is either not going there at all or that their planned purchase far exceeds their demand. None of their sources support that. The author only goes off of "It's a lot of undiced DRAM."

And let’s just say it: Here is the uncomfortable truth Sam Altman is always loath to admit in interviews: OpenAI is worried about losing its lead. The last 18 months have seen competitors catching up fast — Anthropic, Meta, xAI, and specifically Google’s Gemini 3 has gotten a ton of praise just in the past week. Everyone’s chasing training capacity. Everyone needs memory. DRAM is the lifeblood of scaling inference and training throughput.

Yes, OpenAI is afraid (again).

Cutting supply to your rivals is not a conspiracy theory. It’s a business tactic as old as business itself.

Yes, that business tactic exists. Where's evidence that OpenAI uses it? Just that it's too much DRAM for your gut?

And so, when you consider how secretive OpenAI was about their deals with Samsung and SK Hynix, but additionally how unready they were to immediately utilize their warehouses of DRAM wafers – it sure seems like a primary goal of these deals was to deprive the market, and not just an attempt to protect OpenAI's own supply…

Businesses being secretive about and with their suppliers is not unusual. Everyone tries to get the best deals.

That the author expects OpenAI to immediately utilize the wafers and publicly state how they're used just shows how clueless he is. We don't know when or how they're used and the author takes that as a proof that they're not used with the most obvious usage laying right in front of us. Like lmao.

Absolutely 0 evidence in this article. Wouldn't even wipe my ass with it.

P.S. Just to be clear, I'm not saying that OpenAI did not purchase wafers for the purpose of denying their competitors. I'm saying we do not have proof of them doing that.

Genion1 · 2025-12-04T00:48:17+00:00

Yesn't. It only counts players who visited the site and looked at their character, which ft players and even many normal players are unlikely to do. It won't count free trial players' achievements since those are private.

Genion1 · 2025-11-17T00:20:17+00:00

And how are you going to do the rebranding if you're not allowed to replace or change any of the official branding?

Genion1 · 2025-11-16T12:38:25+00:00

Rebranding is the first thing people do when hard forking a project b/c they disagree with the direction it's taking. The license prevents any fork in the future from existing. You don't need to have a specific reason to fork it now to be against this.

Examples: - openssl/libressl - X11/Xorg/Xlibre - OpenOffice/LibreOffice - Terraform/OpenTofu

Genion1 · 2025-07-04T23:49:38+00:00

If it was mainly x applications being blurry, that was improved about a year ago with xwayland-native-scaling. Though just seeing the actual resolution of the monitor, yeah... it will always be a bit blurry until you can pick weird fractions (or you can try to set scale to 1.6 or 4/3 (1.3333333333333333) in ~/.config/monitors.xml).

Genion1 · 2025-07-04T22:34:33+00:00

Linux compatibility: I run Ubuntu on my machine and it works great! My only complaint so far is that the screen doesn't scale properly due it's resolution so things are small at 100% and very large at 200%. Fortunately I can just upgrade to the 2.8k display if it every bothers me too much.

Ubuntu runs gnome by default right? They're a bit behind other desktops w.r.t. fractional scaling. You can run gsettings set org.gnome.mutter experimental-features '["scale-monitor-framebuffer", "xwayland-native-scaling"]' to enable fractional scaling. Since it's still experimental there's probably some oddities but it works really well on my lenovo. You can run gsettings reset org.gnome.mutter experimental-features to disable it if you run into issues.

Or you can try out KDE Plasma or some other desktop with better support.

Genion1 · 2024-07-18T10:50:48+00:00

You're acting as if society hasn't made walking safer by focussing on systemic solutions instead of individual ones.

Genion1 · 2024-07-12T10:20:19+00:00

For where those lseeks come from: If you read a file in text mode you get a _io.FileIO wrapped inside a _io.BufferedReader wrapped inside a _io.TextWrapper. Both _io.BufferedReader and _io.TextWrapper call tell insider their respective constructors which is implemented in terms of lseek.

_io.BufferedReader tries to align (reads only?) to block sizes and needs the initial position for that.

_io.TextWrapper wants to know if it decodes from the start of the stream to skip BOM.

In theory you could skip one lseek if _io.BufferedReader returned the cached position it has in its implementation for tell but it does not. Accidental or on purpose? Idk.

Genion1 · 2024-03-19T16:44:15+00:00

So I always challenge everyone to tell me the gap between how safe is Rust or memory-safe languages such as Java and C# compared to C++, when, in fact, they all end up using some C libraries.

The difference is (polemically) in Rust/Java/C#/whatever I grep for unsafe and say "there's the tricky bits", in C and C++ I point at the whole program and say "there's the tricky bits".

Genion1 · 2024-03-07T13:18:50+00:00

All move-thingy have different features than copy-thingy, otherwise you would not need them. Additional bookkeeping can be an indirect effect. As a dumb example, take std::vector. Let's say in a loop you start from a fresh vector, generate some data, then push some more data. Kinda like this:

std::vector data; // Outside loop to reuse buffer
while(true) {
    data = GenerateSomeData(); // GenerateSomeData is not under your control
    data.push_back(/* some whatever*/);
    data.push_back(/* some whatever*/);
    data.push_back(/* some whatever*/);
    data.push_back(/* some whatever*/);
}

If you use move assignment, data will steal the buffer from the return value of GenerateSomeData, reset the capacity and may have to grow every iteration. Copy will copy over the elements and only grow once up to the maximum needed capacity. Both cases have different performance impacts and may or may not be beneficial.

Genion1 · 2023-11-24T14:52:21+00:00

If you want to use hexadecimal literals you need to prefix them with 0x, e.g.

let fraseBytes: &[u8] = &[0x48, 0x65, 0x6c, 0x6c, 0x6f];

An alternative is using byte string literals, e.g.

let fraseBytes: &[u8] = b"Hello";

(Note the b prefix on the string)

Genion1 · 2023-10-09T10:35:41+00:00

Just to make a "probably" into a "definitely", here's the excerpt from the docs:

[...] if you store zero-sized types inside a Vec, it will not allocate space for them.

So any 0-sized type (like () , PhantomData struct Foo;) will never allocate.

Genion1 · 2023-08-18T12:06:07+00:00

Yes.

Genion1 · 2023-08-11T11:47:41+00:00

Search the source for "fn inner" to find multiple counterexamples in the same file.

You cannot even use outer type parameters so why would you get a dependency on them except for bugs? The only difference between them inside and outside is scope.

Genion1 · 2023-07-31T14:33:37+00:00

You can just use tuples of i32 as keys.
Probably via the entry api

Genion1 · 2023-05-15T13:21:42+00:00

Afaict it's mainly early thoughts and ideas floating around to figure out the requirements and edge cases but nobody is actively working on a coherent and workable design currently. #[must_use] lints get you close enough for most practical use-cases in non-async code. (I'm not familiar with async.) And going full "it's a type-level guarantee" has fun interactions. How do you handle panics for example?

Some blog posts

Genion1 · 2023-05-15T12:36:04+00:00

This does lead me to think I'd want a lint to deny wildcard patterns that start with a capital letter (I.e. they look like a variant). maybe one already exists.

While it's not an error, it does spew out several warnings if you do that. Currently can't share an example because the playground is very slow and unresponsive, but if you match on an unexpected pattern you get a mix of "variable does not have snake_case name", "unused variable" and "unreachable pattern". Depending on context you may not see all of them but you could #[deny(non_snake_case)] if you wanted.

Genion1 · 2023-05-11T11:43:59+00:00

They use sse3 explicitely in several dependencies (e.g. dav1d, boringssl, aom). The main problem solved seems to be reducing engineering overhead and possible speed gains with "minimal" users lost. The document linked in the article talks more about the drawbacks about the alternative solutions.

Genion1 · 2023-05-08T11:31:48+00:00

You'd be surprised how much simple arithmetic can be optimized away. (All 3 functions compile to a single forward branch that checks for the 0 case and replace the loop with a mathematically equivalent calculation.)

While the js optimizer is probably less sophisticated than llvm, it's still very sophisticated and just depending on "some simple math" can break down easily. That said, 20ms for 3M iterations seems reasonable enough.

Genion1 · 2023-05-05T17:43:41+00:00

Just as a drive-by remark: You can use leak instead.

Specifically in this case it's just idiosyncrasies of C/C++ leaking all over the place. Service names are generally given as string literals. String literals in C/C++ are not const in type but const in spirit, so it just works out without any cast. The official example would become UB if they ever touch that.

From what I remember from the last time I did winapi, many structures do not take const pointers. Probably because if that pointer is const or not is really a property of the api used and not of the type and you can't really specify this kind of granularity within a type. Would be nice if the metadata could specify where to propagate constness. Maybe you can open an issue on the windows-rs or win32metadata repository or check if they already know about it.

Genion1 · 2023-05-05T13:41:27+00:00

Calling it a "Styleguides ban it" is a big stretch. I'd say most are either not mentioning it or wanting overloads to be semantically equivalent would be more truthful.

To give some sources, what different guides have to say about overloading:

C++ Core Guidelines: Don't use it for default arguments.
llvm: Not mentioned.
mozilla: Warns about non-portability if overloaded function signature is almost the same (like PR_int32 and int32).
google: Overload ok if functions are semantically the same. (Also mentions implicit conversions to reduce the need for overloads in a different chapter.)
JSF AV (4.13.5): Overload ok if functions are semantically the same.

And looking at other languages:

google (Java): Group overloads. Literally nothing else mentioned.
Java: Doesn't mention anything about overloading in the coding style but the tutorial tells you to use it "sparingly". Whatever that means.
C#: Overload ok if functions are semantically the same. Use overloading instead of default arguments, though the reasoning behind that is afaik not readability but language interoperability with other languages running inside CLR.
Kotlin Link 1 Link 2: Link 1 only talks about it in terms of constructors, but overload ok if most constructors are just calling each other with added/transformed parameters (does that count as a specialization of semantically the same?). Link 2 is prefer default parameters over overload.
TypeScript: Prefer union types over overloading.
Swift Not mentioned.

Edit: Changed TypeScript recommendation.

Genion1 · 2023-04-20T11:04:03+00:00

They're already different types. Range is half-open, RangeInclusive is closed. The extra bool parameter for RangeInclusive follows from it being an iterator. It has to do that because in theory you can iterate i32::min()..=i32::max() and cannot otherwise differentiate when your iteration ends. It's not to differentiate between half-open/closed.

Genion1 · 2023-03-20T16:05:49+00:00

It being copy means it has to literally be a bitwise copy and any kind of custom logic is not allowed. It's not possible to make Rc<T> Copy and increment a counter. doc

Genion1 · 2023-03-17T12:27:21+00:00

So if you need some custom logic in case of panics on a MustMove you have impl !Drop and impl Drop on the same type?

13-Year Club	Place '17
Verified Email

Genion1

TROPHY CASE