Hacker News Reader

Comment by perlgeek | Hacker News Reader

This vaguely reminded of the time where our self-hosted installation of JVM-based app worked fine in DEV and QA (on vmware-based VMs), but in PROD it would error out the time with "out of memory", even though the machines (bare metal) had far more RAM.

It turned out they also had lots more CPU cores (they were repurposed former DB machines), and by default the memory manager (of the JVM, I suppose?) scaled the allocation block size the number of CPUs, so it tried to allocate far more memory than necessary, and since this was still a 32-bit JVM it quickly ran out of space for its allocations.

Once we found out what the issue was, it was pretty easy to tune with an environment variable.

View on HN

Off topic, so apologies in advance. Why do environments so often get capitalised like that? Prod isn’t an acronym, it’s an abbreviation of Production. Similarly Dev is an abbreviation of Development.

I know in the grand scheme of things it’s meaningless, this is just one of those things that’s like someone scratching their fingers down a blackboard when I see it day to day.

I don't know, but I see unnecessary all caps in other words too - it's not infrequent that I see JAVA and sometimes RUST (for the programming languages). Kind of irks me, but obviously doesn't really matter. Ultimately I think it's just a weird niche cultural holdover from the very early days of computing when lots of random stuff was arbitrarily capitalized, like FORTRAN was originally all caps, maybe related to early character sets that only had capital letters.

And some all caps languages are still around. C, D, R, C++, C#, F#.

Those follow normal punctuation rules in that the first letter of the proper noun is capitalized.

My first guess for that particular case is that PROD and DEV are often either parts of hostnames for those particular machines or are referring to hostnames, which are often written in all caps.

> Prod isn’t an acronym, it’s an abbreviation of Production.

Tangentially, "Prod" is justified since it's being treated as a proper name, like "Paris", "Roderick", or "Mount Rushmore."

But yes, "PROD" is harder to explain, and I suspect it might be bleed-over from looking at code or config files where it gets capitalized.

Looks like how enums are often formatted. My guess is there was an environment enum with these values someone is referencing

I don't have a solid explanation but I sometimes have a tendency to capitalize things that are "important".

Think about book titles. "Exploration of Paris", the important words are capitalized.

I can imagine many people capitalize the environment names without thinking too hard about _why_ they do it.

"PROD" is an acronym (a shortened form of a more formal name for something). What it isn't is an initialism (a word coined by taking the first initial of a descriptive phrase). Traditionally, both initialisms (eg. CPU) and acronyms (eg. NORAD) use all majescule typography. Sometimes the coined words become common usages and are commonly rendered in capital or miniscule case as appropriate (eg. radar, scuba).

This is, of course, descriptive typography. Prescriptive typography will vary from style manual to style manual.

I think you're getting the definition of acronym mixed up with that of abbreviation. An acronym is an initialism that is pronounced as if it is a natural word. For example, NASA is both an initialism and an acronym. FBI is an initialism, but not an acronym.

Well that's the dictionary definition anyway. In practical terms, I think most people use acronym as a synonym of initialism, at least in the US. This is one of the places where the dictionary definition doesn't match with real world usage.

This sort of thing has long annoyed me too when I see it, so thank you for stepping into the firing line for at least the both of us. See also, "FED" for Federal Reserve.

I'm trying to train myself out of this nonsense, but some habits die hard.

The worst example of this is VISA instead of visa when talking about international travel as opposed to credit/debit cards. (Hats off though to whoever decided on that marketing name...)

It might be a leftover from the time where we had text-only docs (no courier) and the use of `backticks` was not commonplace. With those restrictions, ALL_CAPS would be a way to signal “this is a name that has meaning for machines”, simply because humans don’t use that convention.

Years ago, I had a non-technical stakeholder on a project who always capitalized it as PROD, and I made fun of him behind his back, so now I say it ironically... or at least I hope so. There was a time when I said "bro" ironically too... irony is truly a gateway drug.

generally environment variables are set with ALL_CAPS keys and underscores.

Not sure if this is a bash hold over to differentiate ENV_VAR vs local reg_var or like an os/global constant naming hold over.

Generally if you call "env" on your cmd line (all of my)/most keys are ENV_VAR capitalized.

Is production going to be the name of a variable or a value? Given that you can't be running in more than one place at once, I don't see why you'd have an env var like PROD=true instead of something like STAGE=prod, since otherwise you need to decide what to do if you have both PROD=true and DEV=true. Environmental variable values certainly don't have to be all caps, so I don't think you're explanation makes sense.

32 bit and high core count is definitely a nasty combo. Many applications spawn 2-4 threads per core which is a great way to eat up that address space.

But don't all threads of a process share mostly the same address space? I could imagine that starting many processes would exhaust address space, or allocating a lot of virtual memory / mmap without committing.

That's one of the fun bits, other processes don't share the memory space. That's one reason you can have 16GiB of ram on a 32bit x86 server without much issue. This was done on x86 through a tech called PAE (Physical Address Extension) that let the OS know there was more memory and allocate it around, but any one process was limited to 4GiB (usually lower due to kernel/userspace barriers) because of 32 bit pointers. So if those threads all allocated memory it was easier to hit the limit but if you used separate processes then they could each reach 4GiB (or whatever the limit is) independently without causing problems.

Reply on news.ycombinator.com