Slashdot Mirror
Linus Torvalds on Why ARM Won't Win the Server Space (realworldtech.com)
Linus Torvalds: I can pretty much guarantee that as long as everybody does cross-development, the platform won't be all that stable. Or successful. Some people think that "the cloud" means that the instruction set doesn't matter. Develop at home, deploy in the cloud. That's bullshit. If you develop on x86, then you're going to want to deploy on x86, because you'll be able to run what you test "at home" (and by "at home" I don't mean literally in your home, but in your work environment). Which means that you'll happily pay a bit more for x86 cloud hosting, simply because it matches what you can test on your own local setup, and the errors you get will translate better. This is true even if what you mostly do is something ostensibly cross-platform like just run perl scripts or whatever. Simply because you'll want to have as similar an environment as possible.
Which in turn means that cloud providers will end up making more money from their x86 side, which means that they'll prioritize it, and any ARM offerings will be secondary and probably relegated to the mindless dregs (maybe front-end, maybe just static html, that kind of stuff). Guys, do you really not understand why x86 took over the server market? It wasn't just all price. It was literally this "develop at home" issue. Thousands of small companies ended up having random small internal workloads where it was easy to just get a random whitebox PC and run some silly small thing on it yourself. Then as the workload expanded, it became a "real server". And then once that thing expanded, suddenly it made a whole lot of sense to let somebody else manage the hardware and hosting, and the cloud took over. Do you really not understand? This isn't rocket science. This isn't some made up story. This is literally what happened, and what killed all the RISC vendors, and made x86 be the undisputed king of the hill of servers, to the point where everybody else is just a rounding error. Something that sounded entirely fictional a couple of decades ago. Without a development platform, ARM in the server space is never going to make it. Trying to sell a 64-bit "hyperscaling" model is idiotic, when you don't have customers and you don't have workloads because you never sold the small cheap box that got the whole market started in the first place.
Which in turn means that cloud providers will end up making more money from their x86 side, which means that they'll prioritize it, and any ARM offerings will be secondary and probably relegated to the mindless dregs (maybe front-end, maybe just static html, that kind of stuff). Guys, do you really not understand why x86 took over the server market? It wasn't just all price. It was literally this "develop at home" issue. Thousands of small companies ended up having random small internal workloads where it was easy to just get a random whitebox PC and run some silly small thing on it yourself. Then as the workload expanded, it became a "real server". And then once that thing expanded, suddenly it made a whole lot of sense to let somebody else manage the hardware and hosting, and the cloud took over. Do you really not understand? This isn't rocket science. This isn't some made up story. This is literally what happened, and what killed all the RISC vendors, and made x86 be the undisputed king of the hill of servers, to the point where everybody else is just a rounding error. Something that sounded entirely fictional a couple of decades ago. Without a development platform, ARM in the server space is never going to make it. Trying to sell a 64-bit "hyperscaling" model is idiotic, when you don't have customers and you don't have workloads because you never sold the small cheap box that got the whole market started in the first place.
I always found it strange to use an Ubuntu server. Whilst it's okay, and often better than most BSD or other systems, it's not as stable as RedHat. So why so many Ubuntu servers? It's simple: that's what the developers are using. Linus is, as occasionally happens, spot on with this one. If you can't get exactly the same set up locally there's always going to be the odd really difficult debugging case that just takes you too much time to justify. The solution is obvious: start providing ARM Linux laptops with very similar processors to the ones used in servers. I'll buy a few myself.
Then why are we not seeing Intel rule the mobile world then? I disagree.
"IBM on Why Intel Won't Win the Server Space 2: Electric Bugaloo"
Ezekiel 23:20
Everything in the cloud space is following in the wake of the big providers and people who run giant datacenters: Netflix, Facebook, Amazon, Google, Microsoft. Nobody is big enough to even consider needing anything like what they have. Akamai, maybe. Valve? But outside a very limited number of heavyweights the benefits for switching to ARM just aren't there.
Assuming you aren't rolling your own thread and atomics libraries, is there a perceivable difference on the API side when moving from x86 to ARM or any other architecture? Hell, if this argument were true, there are enough differences between the various x86 iterations that would make it so that devs want the specific *family* of processors they develop on to be in the servers they use...
I posit there's probably enough of a difference between AMD's x86 implementation and Intel's...
When you can't try out software on some cheap commodity hardware, it never even gets to the cost-benefit analysis. Fronting tens of thousands of dollars just to try out a software-hardware combination is a non-starter in almost any company. x86 wins because the difference between a vm running on a dev's/sysadmin's laptop and one running in a VMWare or Hyper-V architecture is almost non-existent - they know what they're getting before they've spent any money.
At least ARM has some netbooks floating around with the architecture. IBM didn't bother to try and keep Apple on their architecture, and that has hurt the ability to court new customers.
It was all X86 and games until Johny Srouji went and disrupted that home PC space and got more people wanting an ARM processor to use in the Cloud.
x86 won on price, on the desktop, on the server. That is the simple truth.
As for stability and bugs, cross platform is superior. Bugs that are hard to manifest on one hardware architecture may manifest quite readily on a different architecture. Having worked on various cross-platform projects I've seen the main x86 based dev teams visit the alternative architecture teams (ex PPC) when they are stumped debugging, they eventually appreciated the alternative architectures. A single architecture target allows for longer lived quirky bugs. The simple truth is that cost is more important to many.
This is not to say ARM will be successful in server space, just that it will be about cost and little else.
It seems to me that mobile apps wouldn't be a thing either if this logic was true.
Laws are rules for the court, but merely a bottom bar to hit for life. Think beyond laws in your actions always.
Try to tell me I don't need that tank to go off roading.
...because most of the network lackeys who went to ITT Tech learned how to do active directory and other Windows-based drivel there. These are people who don't know the difference between HA and DR. Once IT directors began to figure out (remember that they are dumb, too) that their network people are just useless id10ts who have little value then it was off to the cloud races.
Windows running on x86 after dominating the desktop is what enabled x86 to "win" in the server market, not cheap end-user hardware.
Why not just build a system around a Crusoe processor at home and let it emulate anything you want to eventually run the software being developed on?
Seems pretty cut and dry to me.
load "linux",8,1
At some point in the near future, Macbooks will start coming with custom Apple designed ARM processors instead of Intel chips.
At that point, the trendy urban hipsters buying these Macbooks will be developing on ARM and will want to deploy their code on ARM based servers. Your local IT department might say no, but I'm sure that the cloud hosting providers will gladly oblige.
"Develop at home" is really a proxy for "develop/deploy on cheapest". What applications, what software stacks, care about the underlying hardware architecture? If cloud based servers ran non-x86 hardware few would notice or care. If cloud server costs for non-x86 hardware were cheaper and performed adequately they would get used. x86 Linux won because it was cheaper than the traditional Unix vendors with their proprietary *nix RISC based platforms. Similar on the workstation side. The shift from RISC *nix boxes to x86 Linux was overwhelmingly about cost, almost no software cared which it ran on.
Linux x86 to Linux ARM would be a virtually unnoticeable transition for nearly all. Again assuming adequate performance for the money. It was about price in RISC *nix days, it will be about price in ARM days.
ARM is a computer construction kit, not a platform, just like Android is a firmware construction kit, not an OS. Every ARM system needs its own special Linux distribution. As long as that doesn't change, there's no threat to the x86/x64 world. Besides, ARM is just slow compared to x64. Yes, it uses less power, but it also does less. I use small ARM servers for very light workloads, but that's really all they're good for.
Trollvalds is a joke, yea but he is wrong. Any company with a sophisticated development team doesnt run their code "at home" or even on their "local" work laptop. The shit is built on a build server (jenkins, etc) somewhere.
Why not use smartphones as testing platform. That is ARM everywhere
Look, if people get comfortable compiling their Rasp Pi kernel on that Rasp Pi, we'll start looking at ARM on the Cloud adoption.
Pretty sensible argument. Put those ARM chips to some hardcore dev.
I'm currently hoping the Pinebook Pro does very well when released later this year. I'm already planning on purchasing one for FreeBSD ARM development. The specs still are not the best, but are decent enough for some interesting development tasks. A portable ARM laptop with a hex-core processor, 4GB RAM, 64/128GB eMMC, Mini-PCIe with NVMe support, 1080p ISP display, 10,000 mha battery, and USB-C that supports charging + 4k/60hz video. This thing will be a little mini beast for $200. Most of programming is reading/writing code more so than executing it, so I believe this should be plenty powerful for solid web development and system service programming. This laptop NEEDS to do well to show the industry as a whole that these are the type of devices we WANT.
Most of the web applications these days are developed using frameworks/languages that are cross platform (like node.js, .net core, java..). With these frameworks and app containers, it doesn't really matter what OS or hardware is running it. Server farms will move to a more efficient way to manage their server loads. I think performance/power and performance/price will be critical in deciding who wins. You can't rule out ARM right now.
Sorry Linus, but that's bullshit and here is why:
Already in all phones. They're not x86. Apple is moving to ARM. Windows is ported/ing to ARM. So that's that side of it more or less done.
Datacenters, yes, less power and heat? Yes please. So that's a move to ARM (Scaleway, et al are already doing this).
So once laptops (The preferred being mac) and datacenters have ARM options, which is provably happening, then your x86 argument dies horribly.
Lets face it. x86 is a turd, and people need to stop trying to polish it. ARM is a breath of fresh air.
I sure as hell don't develop android apps on an android device. I have no problem developing for arm devices from my pc. Been doing it for years now.
What if you also develop and test on the cloud on the same platform as your hosting environment? Might that be the reason Amazon bought Cloud9 http://c9.io/
'nuff said
A lot of hosted applications, especially those where the heavy client lifting has been moved client-side (Angular, React, etc.), could be described as accept parameters, call a database based upon those parameters, organize data into an acceptable payload and return that payload. It's hard to see why these would be dependent upon x86. Same for ETLs. If the power consumption/cost argument for ARM servers is really as compelling as being advertised, there might be something there.
ARM may not be a fit for everything (speech and image recognition, bitcoin mining, etc.), but there is probably a lot of code in NodeJS, Python, etc. that would probably run fine. VMs and even containers can be set up as ARM, and mitigate a lot of the whole "the server doesn't match my home rig" concern raised. Risk can be further mitigated with adequate unit and integration testing. Load starts becoming a more significant variant, but adequate testing can mitigate that risk as well.
I wouldn't discount the possibility of government stepping in and putting more restrains and regulation on power consumption of the larger data centers. If that were to happen, the costs to run x86 hardware at less-than-full capacity/inefficiency could become significant.
IBM is buying RedHat for $34 billion.
2018 RHAT revenue was $2.9 billion. Canonical last year had revenues of $125.97 million. That's a 20x multiple.
The market share follows a similar trend.
I wish I was "losing" by having a 20x multiple.
Linus seems to be forgetting about the massive shift in software development that has occured, to consuming software as container-based microservices, and providing it as the same.
No one cares what architecture Redis is running on, as long as the service provides the same API contract and can be consumed by existing code. X86, ARM, Power, no one cares - run it where it performs the best at the lowest cost, thanks.
The same is true of all of the other microservices that you consume, and all of the microservices you provide that make up your software. As long as you can deliver the container targeted to that architecture, no one will care.
Linus's argument is a leaky abstraction argument. Just how much of differences can one hide from the developer where it doesn't matter what you develop for.
https://stackoverflow.com/questions/3883006/meaning-of-leaky-abstraction
They're trying to keep RISC-V from stealing their thunder.
SPARC:
https://www.servethehome.com/new-oracle-fujitsu-sparc-m12-servers-launched-384-cores-32tb-ram/
Plus:
On Friday, September 1, 2017, after a round of layoffs that started in Oracle Labs in November 2016, Oracle terminated SPARC design after the completion of the M8. Much of the processor core development group in Austin, Texas, was dismissed, as were the teams in Santa Clara, California, and Burlington, Massachusetts. SPARC development continues with Fujitsu returning to the role of leading provider of SPARC servers, with a new CPU due in the 2020 time frame.
The big iron ARM64 hardware isn't even available to us (Can't name names sorry). So no our code isn't going to be ported to your servers.
Yes, the latest PI is 64 bit hardware but not the software and if you want software that runs well on 128 cores you need to be stress testing on 128 cores.
No one will ever need 640K of RAM
Apple will never succeed in the cellphone market
We now have another famous "miss" in predictions.
They also make damn sure devs in large companies get access to their hardware. They actually do a LOT better than the company I work for in getting us hardware.
And guess what, our software runs better on Intel than it does on our own hardware - surprise.
Most applications are written in portable languages like java, node/javascript, python, etc now. The CPU architecture doesn't matter so much as long as the OS will run on both chips or the OS doesn't matter for the application.
Assuming an all linux environment, it's extremely unlikely to matter for most people.
There are two issues though. First, the general problem with ARM that's also it's biggest benefit to some, the SoC design. It saves power, but it also means that every ARM variant needs OS support for it's funky design. There is no standard chipset. I can buy an AMD x370 and run various ryzen chips on it. The same sata controller works for all the CPUs. In ARM fantasyland, even the same vendor may have incompatible chips. Look at all the things that run on the pi but not the pi 3 etc.
The second issue is more relevant to the cloud though. There aren't a lot of good SERVER ARM manufacturers yet. They always target lowend cell phone chips. It's not really ARM's fault but more like Qualcomm, Samsung and others. We need a company that cares about pushing ARM performance, like a server version of apple's team (but not at apple of course) to actually get competitive. For this reason alone, I think risc v has a better shot in the server space long term. Qualcomm doesn't even want to compete with apple's chips. They make 2 generation back designs with beater slow performance. It's as bad as intel's ultrabook chips for laptops that run at 8 year old AMD phenom II speeds. We need something in the 125 watt range with many cores. Something that can compete with the old sun niagra designs but better.
Actually, that brings up a third problem. ARM chips tend to favor many cores over single core performance. That means they are TERRIBLE for node.js and vert.x applications which are design for few cores.
How does Linus think all those mobile apps get developed, since smartphones are 99.9% ARM? Well you develop on an x86 desktop, then deploy to ARM cell phones. Acting like developing on x86 desktops and deploying to ARM servers is some impossibility might be true at his level, the kernel level, but at the business process level you very rarely care. I'd say 99% of all bugs are due to some bad code or flawed design in something you wrote or a library you used. On the rare occasion that the system libraries of .NET, Java, Swift etc. or your database have a bug it's likely to be an implementation bug that affects all platforms. And in those exceptionally few cases where it's not you do a have a test/qa VM you can debug on.
Live today, because you never know what tomorrow brings
Between cross compilers, qemu, and other platform simulation tools, there is no reason your development isa and target isa have to match at all. Embedded sw engineers have been living in this environment for decades.
People could buy a PC and put Linux on it for $500 vs. $20k for a Sun/IBM/HP box. That's what made it "at home".
Why pay for a separate machine that runs legacy x86_64 instructions when you will have your mobile device that can access any remote resource that could be ARM or x86 or whatever.
1. Parts. People like mow cost, fast, low power and heat parts. That work better. RAM, storage, networking all has to be ready, working and fully supported. ... better than anything.
2. Software. The CPU has to support something great to make people change everything and learn to code a new system.
3. Cost. Power savings while doing more math and networking and
4. Ability of staff. People have to learn to code something new. Thats a lot of code to bring over.
5. What is the advantage when power costs are low, heat is easy to move, people know how to code on existing systems.
That new CPU and surrounding support has to be so much better at everything over a generation than anything on the market.
Domestic spying is now "Benign Information Gathering"
As a hardware and software developer for over 25yrs, I have considered ARM many times and always run into the same problem. As much as we like to talk about multi-threading, there are still many applications where the single-thread performance is the most important. ARM performance is just barely good enough for mobile devices and very limited Android TV boxes. The performance of ARM is catching up though. Maybe in a 2-3 generations the performance will be good enough for people to tolerate ARM laptops and desktops.
About kings of the servers, aka LAMP:
1. OS: Linux.
2. Web platform: Apache.
3. SQL DataBase Manager: MariaDB.
4. Programming Language for web: PHP.
Does it support AArch64?
1. Linux for AArch64 is OK if the server is a Rasperry's AArch64.
2. Apache for AArch64.
3. MariaDB for AArch64.
4. PHP for AArch64? Maybe.
Ubuntu in the cloud, evil... Evil.. EVIL!!!!
Not.
Ubuntu in the cloud running apps, I don't know how many Heroku/Mulesoft/SFDC projects I've been on, it's what we do and they are stable, scale and, stay with me here, key point ahead, easy to support. Most devs, 90% of your devops models, do not take in to account the support/sustain model afterwards. Companies don't want to pay 150k$ devops engineer, or even a 30k$ APAC engineer, they want to pay 5-10k$. So you need to have a product that can be easily supported and sometimes, not by a sysadmin. Look, console jockeys are on their way out, trust me, they are.
Now.
I'm not saying there are not better methods that can meet those use cases, because their are and a lot. I'm just saying, throwing Ubuntu under the bus as the bane of Evilness, makes you look, well, stupid.
The "small cheap box" for ARM hardware means different things to different audiences.
Back in the 80's, the IBM PC was the definition of a small cheap box albeit it cost around 5,000$CAN. Enough to run some apps for work and some games for the kids. Then IBM PC Clones/Compatibles came along and started to redefine what small and what cheap meant. We could get decent capabillity equivalent to the what IBM was currently selling but at a fraction of the cost if we were willing to take a risk on lesser known brand names. GATEWAY, DELL, and the every other PC Compatible reseller were easily able to sell their kit since everybody out there had no computer whatsoever at home and thought they could use one, but didn't know what exactly to get yet. $UCKER was written on everyone's forehead back then.
Now everybody's a bit wiser and have a bunch of different pc's laptops and crazy reseller/support stories under our belts. We don't buy quite as often and try to make them last as long as possible.
So with all that in mind, when we buy something, we buy with the intent that it will last and not just for two years which is what the resellers sweet spot is.
I bought a few "small cheap ARM boards"...rock64, odroid-c2, zoomtak u-plus....4GB RAM or 2GB RAM in them. The speed of them is respectable. The RAM capacity does not compare with intel-based low-end gaming pc's. The storage capacity for arm boards also suffer and does not compare well in the general sense. Can I easily plunk in an m.2, sata into one of these arm boards? No I can't because all the varieties of all these different arm boards are so ALL-OVER-THE-PLACE in terms of offerings that they don't consistently offer the same kind of storage in all these devices and you can't expect anything easy when you shop around for "small cheap arm box" because they don't compare well to "small cheap intel gaming box" which better defines the "small cheap box" since it easily handles the load for SOHO and you teenager gaming requirements.
In other words, Linux is right. ARM won't win in the server space because it needs to conquer or at least compete in the work at home space first before it can have an opportunity to work as a server on-site or in the clouds for that matter. Working at home for me means 32GB RAM with 8+ cores CPU and GPU with newer sata/m.2 storage options like ssd/nvme and fiber included. No arm board at present provides that at a decent price. I'm not looking for a 25$ to a 50$ system. I'm looking more for the average $1000 to 2000$ GAMING desktop that could also be a SOHO office. ARM manufacturers don't have standards to make such a thing happen. most motherboards for pc's can handle most of that with the default price except for fiber capability. The ARM-based MACCHIATOBIN board is darn close, but it needed a default GPU to come with it to make it more general purpose rather than just for networking, but did it conform to the new server boot standard ? How come it can just handle 16GB RAM when any supermicro intel-based server motherboard can have 512GB to 1TB RAM installed on them?? The price points for these are awesome by the way. I have yet to see comparable ARM capability without sacrificing something or paying 6-10 times the price.
Having a new server boot standard for ARM is good, but we need similar standards for smaller boards also. We shouldn't be arguing about graphics drivers for linux at this point. They should come included for every distro be it ARM or intel or riscv without any discussion that it will crap out in production. Works at home means works on the servers....ARM-based SOHOs small cheap boxes and servers need decent GPU capability right from the start and not as extra option you have to pay for...It should be included as it usually is when you buy a PC desktop system.
As a kernel hacker stuck with dying languages, heâ(TM)s myopic to a serious fault. Professionals, with vanishingly few exceptions, couldnâ(TM)t care less what instruction setâ(TM)s used. Especially those forward-thinking and well-learned enough to have embraced category theory and functional programming. If youâ(TM)re building user-facing software, and itâ(TM)s adversely affected by the platform, youâ(TM)ve made huge mistakes.
Long before they were gobbled up by Oracle, Sun used to offer universities cheap sun workstations. They had a trade in program where you could get half off on your upgraded computer by turning in any old sun server. They never asked for the computer back but the same department couldn't use the machine for two upgrades which encouraged it to be recycled into a different department who could then upgrade it to something else. University discount was typically 50% and sometimes 65% and the trade in dropped the cost by an additional half so some departments were buying new hardware at 17% of what a small company would pay. A $10k Sun server at $1,700 was a much more powerful than a pc of the day. When those admins hit the corporate world in the dot.com bubble, they knew Sun hardware and they bought massive amounts of it.
Google, Amazon and Oracle all control their own server architectures, each use a different processor architecture and none of them care what Torvalds thinks. These companies have a great deal to say about what the cloud is and they don't agree on processor.
The processor that runs code deployed in a high level language really does not matter, does Linus really not understand that?
The reasons x86 grew to dominate have little to do with current requirements and aren't interesting in predicting the future.
The server market is actually different now... DCS is bigger than home servers...
arm has this now :
https://github.com/ARM-software/sbsa-acs
but well thought out just dated Linus Torvalds...
John Jones
ARM keeps changing their instruction sets, and they keep getting bigger and more complex. ARM used to be a simple ISA and chip. Why try to expand ARM all the way up to a big fat core, for the server room? Why not use an existing big fat ISA for the server, such as Power like, or Sparc?
EOM
We suffer more in our imagination than in reality. - Seneca
Linus has just "proved" that Linux can never supplant Windows in the server space.
Which IMHO shows his argument is flawed - a rare occurrence.
I tried my best to get an ARM desktop computer which is worthy of that title. The MP30-AR0 from Gigabyte seems to be the only worthy option but alas it is too expensive.
Linus is wrong. Sorry he happens to be an x86 fanboi but x86 is dieing. x86 is only still with us because of Intel's massive investments in shrinking die sizes. In fact, in terms of install base x86 has already been eclipsed by ARM, today in 2019. In my home there are currently 8 cores of x86 trashiness (quad core laptop, quad core desktop) compared to 14 ARM cores (two in my TV, 4 in my phone, 4 in my wife's phone, 4 in the Raspbery Pi), there's also an older Pi in the garage which I think is only a single core. There would be more but I left work at work... where we are transitioning Windows PCs to Raspberry Pies because they are much cheaper to maintain. So yes Linus is correct people want to use one platform everywhere as a way of simplifying their life but he is wrong about that propping up the x86 market instead of causing it to collapse. In 6 months at work we will phase out about 5% of our desktops and by the end of the year all of our field machines will be Pis or about 10% of the install base. If I could deploy ARM laptops running some flavor of Linux with a reasonable UI we'd do another 10% each year... and frankly the only thing holding back transitioning the server farm is the poor virtualization support.
On the one hand, he has a point, developer-friendly form factors are x86 and that's unlikely to change due to the propensity for developers to have some x86 app they want and better to hedge your bets.
However, the presumption that cloud providers would prefer x86 because it can carry a price premium fails to acknowledge that the providers can potentially get wider margins out of an ARM ecosystem. In x86, you have two vendors and thus they only get so desperate to compete against one another. In ARM server space, at one point you had Marvell, Qualcomm, Broadcom, AMD, Cavium and more vying for the space. The big providers love pitting many vendors against each other as generally *someone* is desperate enough to take a big loss just to get the business. This probability decreases as you have fewer viable vendors.
But it's also been a bit rough. Most of those ARM vendors have since given up their server ambitions. Of the ones that made it to market, none of them could deliver the performance or even performance/watt near the x86 offerings. Many of the advantages they have enjoyed in mobile space (notably better idle behavior) erode in a server setup with high utilization.
XML is like violence. If it doesn't solve the problem, use more.
Excellent analysis, wrong conclusion.
Raspberry PI
A small cheap ARM box, that let you develop on a cheap cluster at home.
Those with a virtual box solves the small to big issue Linus talks about
The point is that Intel architecture downscaling is stopping. The only reason why Intel compatible architecture has the lead is because they can run their less efficient computing architecture on smaller silicon. And that's slowing down due to physical limitations. It doesn't seem that they are capable of tackling this problem.
Once the playing field is 'even' and both ARM and Intel architecture are running on the same nano-scale, it's the most efficient platform which wins eventually. Obviously consumer habits and marketing materials will slow down this effect, but given some time, I wouldn't rule out the ARM architecture on servers just yet.
It all depends,... but ARM isn't in a bad position if physics block further downscaling of the silicon.
You make a good point about the durability of detachables. As for RAM use:
Or what fundamental thing about computing has changed since then, other than the increasing aggressiveness of web analytics and adtech to eat RAM while continuously tracking viewers' browsing?
That's not enough?
Correct, it's not enough. The user can work around "the increasing aggressiveness of web analytics and adtech to eat RAM" by using a tracking blocker. This can be the built-in tracking protection feature of the Firefox web browser or the Disconnect extension for Google Chrome. Though the user will see fewer ads with a tracking blocker, it isn't really an ad blocker, as a tracking blocker allows publisher-hosted ads and any other script that isn't involved in cross-site surveillance of viewers' browsing history.
To save money, I tend to use laptop computers until replacement battery packs are no longer readily available. Thus I was able to keep my daily tasks (software development and web browsing) usably fast on a laptop with 1 GB of RAM until 2015 and 2 GB of RAM until 2018. Tracking blockers were a big part of what made this possible.
android development was done on x86 and deployed to arm - nothing stopped it - came with a nifty little emulator out of the box - I don't get it
I see ARM advocates, and mostly they have motivations that don't match what the market actually wants. IMO.
A lot of ARM advocates hate Intel, so they root for ARM. There's another group that values instruction set consistency and elegance; these people are often unrepentant RISC fans who never quite got over the matter of RISC failing. There's yet another group that simply want competition in the marketplace and they think that ARM can deliver on that.
None of those reasons will achieve ARM servers.
There is another group of ARM advocates who are a little more grounded. They claim that ARM servers will be cheaper, or use less power. Economics can be a powerful driver of market penetration, but this group is wrong too. Why?
Outside of massive buyers of servers (Google, Facebook, etc.), data centers want simple, industry-standard server boxes. They are tasked with running software that gets handed to them. They don't want to get into software engineering, recompilations, or any of that. And most IT analysts these days are much the same; your job is to implement a system, not spend days, weeks or months on a passion project to get System X running on Unusual Hardware Y. Even if Unusual Hardware Y is 7.3% more efficient, who cares? It's not enough to justify the time and analytical energy needed to make it work. And if your vendor/provider won't support Unusual Hardware Y then that's the kiss of death.
Maybe, maybe, Twitter, YouTube, SnapChat and the like can justify expending a lot of engineering resources on ARM servers. I don't think anyone else can.