Power consumption in mainstream CPUs has been a few picojoules per instruction since the Pentium. Even the MSP430 is almost a pJ/insn. Modern ultra-low-power CPUs like the STM32L reach down below 0.3 pJ/insn, as did the LPC1110 a decade ago. Its more mainstream STM32F siblings are still stuck at 1.5 pJ/insn. Research CPUs using exotic logic families have been below 0.05 pJ/insn since 2000, but are too slow for mass adoption.
Power reduction this millennium is almost entirely about changing architecture to GPUs and other more specialized hardware, using wider registers (with SIMD instructions at times) and being smarter about turning things off and ramping their clocks.
Concurrently we've seen a huge move from languages like C and Java to languages like JS (10x the computational load of C even with JIT) and Python (200x, or 5x if your program is dominated by Numpy.)
So power usage is not a big reason for not using CPUs from 5 years ago.
For CPUs at idle, able to turn off power to accessories, power consumption has gone down dramatically over the last decade. True, the curve has been flattening over the last 5 years, but it's still noticeable.
The number one slowdown I've seen in rendering web pages, were not bad algorithms or bad programming languages, but bad database queries.
And if that's the case, there is a lot more optimization in the DB to be gained than rewriting your back-end to C, say.
Yes, all things equal, it's better to write faster CPU-bound code. In a world in which writing optimal machine code all the time was possible without sacrificing anything else important, then we would always want to do it. This is hardly a controversial conclusion.
The reason we don't write faster CPU-bound code is that, in the world we live in, all things are never equal. Correctness, security, maintainability, development velocity, portability, engineering culture/trends, and so on are usually more important than raw CPU performance.
But it's not true today, because today hand-tuned assembly is slow compared to what you can do on the GPU or an FPGA or a TPU.
And, of course, it's not true that you should do this if you can't spend unlimited time writing your code. It's entirely reasonable to use slower languages like Python and JS if you can hack faster as a result. Since many of us are taking that entirely reasonable option, the number of CPU cycles needed to run basic applications is going up, which increases power consumption.
I don't doubt that but on today's web stacks you use either MySQL or Postgres typically and both those are written in C.
Yes, you can create your own DB written in a low level language, but you'll be hitting the same issues that the DB solves for you (indexing upon insertions, query optimizations, transactional operations, etc).
That's not how thing work. GPUs/TPUs aren't magic, they don't speed everything up: they are really good is some scenario, but they are really slow in many others: the cost of loading memory to the GPU and back from it has a huge cost and it's only worth it if the GPU has enough work to do with the workload.
In theory, you could write a web server that runs on the GPU (at least a majority of it, it will still need some CPU work obviously), but it would be incredibly slow, probably slower than if it was a regular web server running on a machine from the 90s.
FPGA are totally different beasts, you can theoretically speed up anything with them, but
1. that requires a LOT of work, and
2. they aren't new: anything you can do with FPGA today, you could do it in 1995 already.
All my power numbers here were off by three orders of magnitude. The MSP430 uses almost a nanojoule per instruction, not almost a picojoule.¹ The Pentium used 10 nanojoules per instruction, not 10 picojoules.² The STM32L011x3/4 uses 0.23 nJ per instruction, not 0.23 pJ.³ The LPC1110 uses 0.3 nJ per instruction, not 0.3 pJ.⁴ Research CPUs using exotic logic families have reached 0.01 nJ per instruction in 2008 and 0.0026 nJ per instruction in 2006, not below 0.05 pJ.⁵
Also, I should have mentioned the GreenArrays chips, which are actually fast; they're not mainstream not because they're slow but because you can't program them in C. Each core has 64 words of RAM and no PROM, so the only practical way to program them is in Forth. But they use 8 pJ per instruction, i.e. 0.008 nJ.
¹ TI's 2012 whitepaper http://www.ti.com/general/docs/lit/getliterature.tsp?baseLit... http://www.ti.com/lit/wp/slay015/slay015.pdf claims the MSP430F2001 can run a million instructions per second on 300 microamps on a 3-volt power supply, which works out to 900 μW, or 900 pJ/insn. GreenArrays published a whitepaper http://www.greenarraychips.com/home/documents/greg/WP003-100... comparing an MSP430F5xx at 8MHz to a GreenArrays chip; they claim that TI publication SLAS655A claims that the MSP430 uses 330 pJ per instruction or 2310 pJ per 16×16-bit multiply, while the GreenArrays core consumed 8 pJ per instruction or 450 pJ per 16×16 multiply.
² http://www.newscientist.com/blog/technology/2006/08/explodin... (WABAC machine link: http://web.archive.org/web/20161228045915/www.newscientist.c...) says that the Pentium from 1993, Pentium Ms from 2003, and Core Duos from 2006 all use 10 to 13 nanojoules per 32-bit instruction.
³ According to the ST datasheet for the STM32L011x3 and STM32L011x4 (DocID027973 Rev 5), these chips typically use 1.95 mA at 16MHz on range 2 (Vcore = 1.5 V, VOS[1:0] = 10) on the HSI16 clock source with Dhrystone-equivalent data processing code executed from RAM, Flash switched OFF, in Run mode (Table 24 on p.55 in §6.3.4, "Supply Current Characteristics"), and they claim 0.95 Dhrystone MIPS per MHz on the front page. This is with Vdd = 3.0 V (according to p. 52) but the extra 1.5 V is just burned in a linear voltage regulator, so the current consumption should be almost exactly the same anywhere in the operational range from 1.65 V to 3.6 V. If we assume 1.8 V, which is probably close to the lowest safe voltage, we get 1.8V · 1.95 mA = 3.51 mW. Dividing this by 0.95 · 16 MHz, we get 231 pJ per instruction; presumably in real life the number would vary anywhere from 200 to 1000. Both higher and lower clock speeds use more energy per instruction, as does running from Flash.
⁴ The LPC1110 datasheet http://www.nxp.com/documents/data_sheet/LPC111X.pdf claims it can run at 48 MHz at 1.8 V and just under 8 mA, which works out to 300 pJ per instruction. It's probably using an earlier version of the same IP core in the ST chip.
⁵ http://www-mtl.mit.edu/researchgroups/icsystems/pubs/confere... is A 10-pJ/instruction, 4-MIPS Micropower DSP for Sensor Applications, Ickes et al., MIT, 2008; http://web.eecs.umich.edu/~taustin/papers/VLSI06-sublim.pdf is A 2.60pJ/Inst Subthreshold Sensor Processor for Optimal Energy Efficiency, Zhai et. al., poster, 2006. I'm not totally clear on whether these processors were actually fabricated or not.
If anything, electricity production probably has more subsidies & externalities than semiconductor manufacture.
Edit: fixed the link
here's a link to the one you're talking about: https://www.freegeekvancouver.org/
edit: adding the link to the fantastic portland version, now that op has fixed their link: https://www.freegeek.org/
Solder joints get smaller and closer every year, leaving whiskers more and more likely to eventually short out two adjacent pins. Not to mention the cheap failure prone board level components found everywhere. (Yay for esploding capacitors).
And that's before you even get to all the junk embedded devices that have little in the way of standardization or documentation, etc. That hardware will likely never run software the OEM didn't ship.
Seeing as processor speeds have pretty much plateaued [1], I wonder if it is useful to start thinking less in terms of precious metals and instead in potential processing power of e-waste. I remember a discussion on here about cheap web host providers using consumer grade boxes as servers. With today's cluster technologies, there's certainly creative applications for processing power that would end up in a landfill.
[1] https://www.maketecheasier.com/why-cpu-clock-speed-isnt-incr...